# Index of values

__private__next_int [Sedlexing] | `__private__next_int lexbuf` extracts the next code point from the lexer buffer and increments to current position.
A
alphabetic [Unicode.Properties] |
alt [Sedlex] |
any [Cset] |
appfun [Ppx_sedlex] |
ascii_hex_digit [Unicode.Properties] |
B
backtrack [Sedlexing] | `backtrack lexbuf` returns the value stored in the internal slot of the buffer, and performs backtracking (the current position is set to the value of the backtrack position).
base_char [Xml] |
best_final [Ppx_sedlex] |
blank [Xml] |
builtin_regexps [Ppx_sedlex] |
bytes_loc [Sedlexing] | `Sedlexing.bytes_loc lexbuf` returns the pair `(Sedlexing.lexeme_bytes_start lexbuf,Sedlexing.lexeme_bytes_end lexbuf)`.
C
call_state [Ppx_sedlex] |
cc [Unicode.Categories] |
cf [Unicode.Categories] |
char [Ppx_sedlex] |
chars [Sedlex] |
check_four [Sedlexing.Utf8.Helper] |
check_three [Sedlexing.Utf8.Helper] |
check_two [Sedlexing.Utf8.Helper] |
cn [Unicode.Categories] |
co [Unicode.Categories] |
codepoint [Ppx_sedlex] |
combining_char [Xml] |
compile [Sedlex] |
compl [Sedlex] |
create [Sedlexing] | Create a generic lexer buffer.
cs [Unicode.Categories] |
D
decision [Ppx_sedlex] |
decision_table [Ppx_sedlex] |
default_loc [Ppx_sedlex] |
difference [Cset] |
digit [Xml] |
E
empty [Cset] |
eof [Cset] |
eps [Sedlex] |
err [Ppx_sedlex] |
extender [Xml] |
extensions [Ppx_sedlex] |
F
fold [Utf8] |
from_channel [Sedlexing.Utf16] | Works as `Utf16.from_gen` with an `in_channel`.
from_channel [Sedlexing.Utf8] | Create a lexbuf from a UTF-8 encoded input channel.
from_channel [Sedlexing.Latin1] | Create a lexbuf from a Latin1 encoded input channel.
from_gen [Sedlexing.Utf16] | `Utf16.from_gen s opt_bo` creates a lexbuf from an UTF-16 encoded stream.
from_gen [Sedlexing.Utf8] | Create a lexbuf from a UTF-8 encoded stream.
from_gen [Sedlexing.Latin1] | Create a lexbuf from a Latin1 encoded stream (ie a stream of Unicode code points in the range `0..255`)
from_gen [Sedlexing] | Create a lexbuf from a stream of Unicode code points.
from_int_array [Sedlexing] | Create a lexbuf from an array of Unicode code points.
from_string [Sedlexing.Utf16] | Works as `Utf16.from_gen` with a `string`.
from_string [Sedlexing.Utf8] | Create a lexbuf from a UTF-8 encoded string.
from_string [Sedlexing.Latin1] | Create a lexbuf from a Latin1 encoded string.
from_uchar_array [Sedlexing] | Create a lexbuf from an array of Unicode code points.
G
gen_definition [Ppx_sedlex] |
gen_recflag [Ppx_sedlex] |
gen_state [Ppx_sedlex] |
get_partitions [Ppx_sedlex] |
get_tables [Ppx_sedlex] |
glb_value [Ppx_sedlex] |
H
hex_digit [Unicode.Properties] |
I
id_continue [Unicode.Properties] |
id_start [Unicode.Properties] |
ideographic [Xml] |
intersection [Sedlex] |
intersection [Cset] |
interval [Cset] |
is_empty [Cset] |
L
letter [Xml] |
lexeme [Sedlexing.Utf16] | `utf16_lexeme lb bo bom` as `Sedlexing.lexeme` with a result encoded in UTF-16 in byte_order `bo` and starting with a BOM if `bom = true`.
lexeme [Sedlexing.Utf8] | As `Sedlexing.lexeme` with a result encoded in UTF-8.
lexeme [Sedlexing.Latin1] | As `Sedlexing.lexeme` with a result encoded in Latin1.
lexeme [Sedlexing] | `Sedlexing.lexeme lexbuf` returns the string matched by the regular expression as an array of Unicode code point.
lexeme_bytes_end [Sedlexing] | `Sedlexing.lexeme_end lexbuf` returns the offset in the input stream of the byte following the last code point of the matched string.
lexeme_bytes_length [Sedlexing] | `Sedlexing.lexeme_length lexbuf` returns the difference `(Sedlexing.lexeme_bytes_end lexbuf) - (Sedlexing.lexeme_bytes_start lexbuf)`, that is, the length (in bytes) of the matched string.
lexeme_bytes_start [Sedlexing] | `Sedlexing.lexeme_start lexbuf` returns the offset in the input stream of the first byte of the matched string.
lexeme_char [Sedlexing.Latin1] | As `Sedlexing.lexeme_char` with a result encoded in Latin1.
lexeme_char [Sedlexing] | `Sedlexing.lexeme_char lexbuf pos` returns code point number `pos` in the matched string.
lexeme_end [Sedlexing] | `Sedlexing.lexeme_end lexbuf` returns the offset in the input stream of the character following the last code point of the matched string.
lexeme_length [Sedlexing] | `Sedlexing.lexeme_length lexbuf` returns the difference `(Sedlexing.lexeme_end lexbuf) - (Sedlexing.lexeme_start lexbuf)`, that is, the length (in code points) of the matched string.
lexeme_start [Sedlexing] | `Sedlexing.lexeme_start lexbuf` returns the offset in the input stream of the first code point of the matched string.
lexing_bytes_position_curr [Sedlexing] | `Sedlexing.lexing_bytes_position_curr lexbuf` returns the end position, in bytes, of the current token.
lexing_bytes_position_start [Sedlexing] | `Sedlexing.lexing_bytes_position_start lexbuf` returns the start position, in bytes, of the current token.
lexing_bytes_positions [Sedlexing] | `Sedlexing.lexing_bytes_positions lexbuf` returns the start and end positions, in bytes, of the current token, using a record of type `Lexing.position`.
lexing_position_curr [Sedlexing] | `Sedlexing.lexing_position_curr lexbuf` returns the end position, in code points, of the current token.
lexing_position_start [Sedlexing] | `Sedlexing.lexing_position_start lexbuf` returns the start position, in code points, of the current token.
lexing_positions [Sedlexing] | `Sedlexing.lexing_positions lexbuf` returns the start and end positions, in code points, of the current token, using a record of type `Lexing.position`.
limit [Ppx_sedlex] |
list [Unicode.Properties] |
list [Unicode.Categories] |
ll [Unicode.Categories] |
lm [Unicode.Categories] |
lo [Unicode.Categories] |
loc [Sedlexing] | `Sedlexing.loc lexbuf` returns the pair `(Sedlexing.lexeme_start lexbuf,Sedlexing.lexeme_end lexbuf)`.
lowercase [Unicode.Properties] |
lt [Unicode.Categories] |
lu [Unicode.Categories] |
M
mapper [Ppx_sedlex] |
mark [Sedlexing] | `mark lexbuf i` stores the integer `i` in the internal slot.
math [Unicode.Properties] |
max_code [Cset] |
mc [Unicode.Categories] |
me [Unicode.Categories] |
min_code [Cset] |
mn [Unicode.Categories] |
N
nd [Unicode.Categories] |
new_line [Sedlexing] | `Sedlexing.new_line lexbuf` increments the line count and sets the beginning of line to the current position, as though a newline character had been encountered in the input.
next [Sedlexing] | `next lexbuf` extracts the next code point from the lexer buffer and increments to current position.
nl [Unicode.Categories] |
no [Unicode.Categories] |
O
of_list [Cset] |
other_alphabetic [Unicode.Properties] |
other_lowercase [Unicode.Properties] |
other_math [Unicode.Properties] |
other_uppercase [Unicode.Properties] |
P
partition [Ppx_sedlex] |
partition_counter [Ppx_sedlex] |
partition_name [Ppx_sedlex] |
partitions [Ppx_sedlex] |
pc [Unicode.Categories] |
pd [Unicode.Categories] |
pe [Unicode.Categories] |
pf [Unicode.Categories] |
pi [Unicode.Categories] |
plus [Sedlex] |
po [Unicode.Categories] |
post_handler [Ppx_sedlex] |
pre_handler [Ppx_sedlex] |
previous [Ppx_sedlex] |
ps [Unicode.Categories] |
R
regexp_of_pattern [Ppx_sedlex] |
regexps [Ppx_sedlex] |
rep [Sedlex] |
repeat [Ppx_sedlex] |
rev_csets_of_string [Ppx_sedlex] |
rollback [Sedlexing] | `Sedlexing.rollback lexbuf` puts `lexbuf` back in its configuration before the last lexeme was matched.
S
sc [Unicode.Categories] |
segments_of_partition [Ppx_sedlex] |
seq [Sedlex] |
set_filename [Sedlexing] | `set_filename lexbuf file` sets the filename to `file` in `lexbuf`.
set_position [Sedlexing] | set the initial tracked input position, in code point, for `lexbuf`.
should_set_cookies [Ppx_sedlex] |
simplify [Ppx_sedlex] |
simplify_decision_tree [Ppx_sedlex] |
singleton [Cset] |
sk [Unicode.Categories] |
sm [Unicode.Categories] |
so [Unicode.Categories] |
start [Sedlexing] | `start t` informs the lexer buffer that any code points until the current position can be discarded.
state_fun [Ppx_sedlex] |
string_of_encoding [Ppx_sedlex] |
sub_lexeme [Sedlexing.Utf16] | `sub_lexeme lb pos len bo bom` as `Sedlexing.sub_lexeme` with a result encoded in UTF-16 with byte order `bo` and starting with a BOM if `bom=true`
sub_lexeme [Sedlexing.Utf8] | As `Sedlexing.sub_lexeme` with a result encoded in UTF-8.
sub_lexeme [Sedlexing.Latin1] | As `Sedlexing.sub_lexeme` with a result encoded in Latin1.
sub_lexeme [Sedlexing] | `Sedlexing.sub_lexeme lexbuf pos len` returns a substring of the string matched by the regular expression as an array of Unicode code point.
subtract [Sedlex] |
T
table [Ppx_sedlex] |
table_counter [Ppx_sedlex] |
table_name [Ppx_sedlex] |
tables [Ppx_sedlex] |
to_list [Cset] |
to_seq [Cset] |
tr8876_ident_char [Iso] |
U
uchar [Ppx_sedlex] |
union [Cset] |
union_list [Cset] |
uppercase [Unicode.Properties] |
V
version [Unicode] |
W
white_space [Unicode.Properties] |
width [Sedlexing.Utf8.Helper] |
with_tokenizer [Sedlexing] | `with_tokenizer tokenizer lexbuf` given a lexer and a lexbuf, returns a generator of tokens annotated with positions.
X
xid_continue [Unicode.Properties] |
xid_start [Unicode.Properties] |
Z
zl [Unicode.Categories] |
zp [Unicode.Categories] |
zs [Unicode.Categories] |