| __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] |