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 [Sedlex_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 [Sedlex_cset]
best_final [Ppx_sedlex]
blank [Sedlex_cset]
builtin_regexps [Ppx_sedlex]
C
call_state [Ppx_sedlex]
cc [Unicode.Categories]
cf [Unicode.Categories]
chars [Sedlex]
cn [Unicode.Categories]
co [Unicode.Categories]
codepoint [Ppx_sedlex]
combining_char [Sedlex_cset]
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 [Sedlex_cset]
digit [Sedlex_cset]
E
empty [Sedlex_cset]
eof [Sedlex_cset]
eps [Sedlex]
err [Ppx_sedlex]
extender [Sedlex_cset]
extensions [Ppx_sedlex]
F
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 [Sedlex_cset]
intersection [Sedlex_cset]
intersection [Sedlex]
interval [Sedlex_cset]
is_empty [Sedlex_cset]
L
letter [Sedlex_cset]
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_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_positions [Sedlexing]

Sedlexing.lexing_positions lexbuf returns the start and end positions of the current token, using a record of type Lexing.position.

lident_loc [Ppx_sedlex]
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 [Sedlex_cset]
mc [Unicode.Categories]
me [Unicode.Categories]
min_code [Sedlex_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
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_for_char [Ppx_sedlex]
regexp_for_string [Ppx_sedlex]
regexp_of_pattern [Ppx_sedlex]
regexps [Ppx_sedlex]
rep [Sedlex]
repeat [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 for lexbuf.

should_set_cookies [Ppx_sedlex]
simplify [Ppx_sedlex]
simplify_decision_tree [Ppx_sedlex]
singleton [Sedlex_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]
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]
tr8876_ident_char [Sedlex_cset]
U
union [Sedlex_cset]
uppercase [Unicode.Properties]
V
version [Unicode]
W
white_space [Unicode.Properties]
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]