RE2D(1) RE2D(1) (NAME) re2d - D (SYNOPSIS) re2d [ OPTIONS ] [ WARNINGS ] INPUT - stdin . (INTRODUCTION) re2d . ( D ) / . . re2d . D . : // re2d $INPUT -o $OUTPUT -i module main; private bool lex(const(char)* yycursor) { /*!re2c re2c:YYCTYPE = char; re2c:yyfill:enable = 0; [1-9][0-9]* { return true; } * { return false; } */ } void main() { assert(lex("1234")); } re2d : /* Generated by re2d */ // re2d $INPUT -o $OUTPUT -i module main; private bool lex(const(char)* yycursor) { { char yych; yych = *yycursor; switch (yych) { case '1': .. case '9': goto yy2; default: goto yy1; } yy1: ++yycursor; { return false; } yy2: yych = *++yycursor; switch (yych) { case '0': .. case '9': goto yy2; default: goto yy3; } yy3: { return true; } } } void main() { assert(lex("1234")); } (BASICS) re2d . : name = regular-expression ; name regular-expression . . regular expressions re2d . name . . . . configuration = value ; re2d . re2d configurations . value . . . regular-expression code regular-expression ( := ) . regular-expression code . . . : * $. ( encoding support ). handling the end of input . start conditions . !action code code ( ). actions . !directive ; . . directives . /*!re2c */ %{ %} ( ). . . : /*!re2c[:] ... */ %{[:] ... %} . re2d (DFA) . . . /*!local:re2c[:] ... */ %{local[:] ... %} ( ). /*!rules:re2c[:] ... */ %{rules[:] ... %} -- . ( ). . re2d -r --reusable . /*!use:re2c[:] ... */ %{use[:] ... %} use . re2d ( ) . use . . re2d use -r --reusable . /*!max:re2c[:[:...]] ... */ %{max[:[:...]] ... %} YYMAXFILL . YYMAXFILL ( ). C (#define YYMAXFILL ) Go (var YYMAXFILL int = ) . format @@{max} ( @@) YYMAXFILL . /*!maxnmatch:re2c[:[:...]] ... */ %{maxnmatch[:[:...]] ... %} YYMAXNMATCH ( -P --posix-captures ). YYMAXNMATCH ( ). C (#define YYMAXNMATCH ) Go (var YYMAXNMATCH int = ) . format @@{max} ( @@) YYMAXNMATCH . /*!stags:re2c[:[:...]] ... */, /*!mtags:re2c[:[:...]] ... */ %{stags[:[:...]] ... %}, %{mtags[:[:...]] ... %{ s-tag/m-tag re2d . ( ). : format separator. format @@{tag} ( @@) . separator format . /*!svars:re2c[:[:...]] ... */, /*!mvars:re2c[:[:...]] ... */ %{svars[:[:...]] ... %}, %{mvars[:[:...]] ... %{ s-tag/m-tag ( --tags) re2d ( --captvars --posix-captvars) . ( ). : format separator. format @@{tag} ( @@) . separator format . /*!getstate:re2c[:[:...]] ... */ %{getstate[:[:...]] ... %} ( --storable-state ). . . . --loop-switch goto . /*!conditions:re2c[:[:...]] ... */, /*!types:re2c... */ %{conditions[:[:...]] ... %}, %{types... %} ( --conditions ). ( ). YYCONDTYPE . format separator . format @@{cond} ( @@) @@{num} . separator format . /*!include:re2c */ %{include %} (double-quoted) . #include C/C++ . --depfile . /*!header:re2c:on*/ %{header:on %} . header:off re2d -t --type-header . /*!header:re2c:off*/ %{header:off %} header:on*/ . /*!ignore:re2c ... */ %{ignore ... %} . re2d : re2c:api, re2c:input --api. re2c:api:sigil ("sigil") API . @@ . . $ ${name} . API . API re2c:YYFILL@len YYFILL. re2c:api:style API . functions ( C) free-form ( Go Rust). functions API . ( YYFILL) C/C++ (closures) Go Rust . free-form API : @@{var} @@ ( ). API re2c:YYFILL:naked YYFILL . re2c:bit-vectors, re2c:flags:bit-vectors, re2c:flags:b --bit-vectors . re2c:captures, re2c:leftmost-captures --leftmost-captures . re2c:captvars, re2c:leftmost-captvars --leftmost-captvars . re2c:case-insensitive, re2c:flags:case-insensitive --case-insensitive . re2c:case-inverted, re2c:flags:case-inverted --case-inverted . re2c:case-ranges, re2c:flags:case-ranges --case-ranges . re2c:computed-gotos, re2c:flags:computed-gotos, re2c:flags:g --computed-gotos . re2c:computed-gotos:relative, re2c:cgoto:relative --computed-gotos-relative . re2c:computed-gotos:threshold, re2c:cgoto:threshold goto if . 9 . re2c:cond:abort (abort) . re2c:cond:goto :=> . goto @@; . @@ ( re2c:api:sigil re2c:cond:goto@cond ). re2c:cond:goto@cond re2c:cond:goto . @@ . re2c:api:sigil . re2c:cond:divider . /* *********************************** */ . ( re2c:api;sigil re2c:cond:divider@cond ). re2c:cond:divider@cond re2c:cond:divider . @@ . re2c:api:sigil . re2c:cond:prefix, re2c:condprefix . yyc_ . re2c:cond:enumprefix, re2c:condenumprefix . yyc . re2c:debug-output, re2c:flags:debug-output, re2c:flags:d --debug-output . re2c:empty-class, re2c:flags:empty-class --empty-class . re2c:encoding:ebcdic, re2c:flags:ecb, re2c:flags:e --ebcdic . re2c:encoding:ucs2, re2c:flags:wide-chars, re2c:flags:w --ucs2 . re2c:encoding:utf8, re2c:flags:utf-8, re2c:flags:8 --utf8 . re2c:encoding:utf16, re2c:flags:utf-16, re2c:flags:x --utf16 . re2c:encoding:utf32, re2c:flags:unicode, re2c:flags:u --utf32 . re2c:encoding-policy, re2c:flags:encoding-policy --encoding-policy . re2c:eof $ . -1 ( $ ). . . re2c:header, re2c:flags:type-header, re2c:flags:t . --header . re2c:indent:string . "\t" . . . re2c:indent:top . . . re2c:invert-captures --invert-captures . re2c:label:prefix, re2c:labelprefix DFA . yy . re2c:label:start, re2c:startlabel . . . . ( ). re2c:label:yyFillLabel YYFILL re2c:eof . re2c:label:yyloop --loop-switch . yyloop . re2c:label:yyNext YYGETSTATE ( re2c:state:nextlabel) . yyNext . re2c:lookahead, re2c:flags:lookahead ( --no-lookahead ). re2c:monadic ( Haskell ). re2c:nested-ifs, re2c:flags:nested-ifs, re2c:flags:s --nested-ifs . re2c:posix-captures, re2c:flags:posix-captures, re2c:flags:P --posix-captures . re2c:posix-captvars --posix-captvars . re2c:tags, re2c:flags:tags, re2c:flags:T --tags . re2c:tags:expression . re2d yyt . struct . @@{tag} @@ . re2c:tags:expression = "s.@@"; s.yyt . re2c:api:sigil ..TP re2c:tags:negative ( -1 (null pointer) ). re2c:tags:prefix . yyt . re2c:sentinel ( re2c:yyfill:enable = 0; re2c:eof ). : . -1` ( re2d ). . re2c:state:abort (abort) -1 . re2c:state:nextlabel switch YYGETSTATE yyNext ( ). re2c:label:start getstate switch YYGETSTATE . re2c:unsafe, re2c:flags:unsafe --no-unsafe . unsafe YYPEEK . ( ). Rust . re2c:YYBACKUP, re2c:define:YYBACKUP API YYBACKUP . re2c:YYBACKUPCTX, re2c:define:YYBACKUPCTX API YYBACKUPCTX . re2c:YYCONDTYPE, re2c:define:YYCONDTYPE API YYCONDTYPE . re2c:YYCTYPE, re2c:define:YYCTYPE API YYCTYPE . re2c:YYCTXMARKER, re2c:define:YYCTXMARKER API YYCTXMARKER . re2c:YYCURSOR, re2c:define:YYCURSOR API YYCURSOR . re2c:YYDEBUG, re2c:define:YYDEBUG API YYDEBUG . re2c:YYFILL, re2c:define:YYFILL API YYFILL . re2c:YYFILL@len, re2c:define:YYFILL@len (sigil) YYFILL . @@ . re2c:api:sigil . re2c:YYFILL:naked, re2c:define:YYFILL:naked re2c:api:style YYFILL . API (free-form) . re2c:YYFN API YYFN . re2c:YYINPUT API YYINPUT . re2c:YYGETCOND, re2c:define:YYGETCONDITION API YYGETCOND . re2c:YYGETCOND:naked, re2c:define:YYGETCONDITION:naked re2c:api:style YYGETCOND . API . re2c:YYGETSTATE, re2c:define:YYGETSTATE API YYGETSTATE . re2c:YYGETSTATE:naked, re2c:define:YYGETSTATE:naked re2c:api:style YYGETSTATE . API . re2c:YYGETACCEPT, re2c:define:YYGETACCEPT API YYGETACCEPT . re2c:YYLESSTHAN, re2c:define:YYLESSTHAN API YYLESSTHAN . re2c:YYLIMIT, re2c:define:YYLIMIT API YYLIMIT . re2c:YYMARKER, re2c:define:YYMARKER API YYMARKER . re2c:YYMTAGN, re2c:define:YYMTAGN API YYMTAGN . re2c:YYMTAGP, re2c:define:YYMTAGP API YYMTAGP . re2c:YYPEEK, re2c:define:YYPEEK API YYPEEK . re2c:YYRESTORE, re2c:define:YYRESTORE API YYRESTORE . re2c:YYRESTORECTX, re2c:define:YYRESTORECTX API YYRESTORECTX . re2c:YYRESTORETAG, re2c:define:YYRESTORETAG API YYRESTORETAG . re2c:YYSETCOND, re2c:define:YYSETCONDITION API YYSETCOND . re2c:YYSETCOND@cond, re2c:define:YYSETCONDITION@cond (sigil) YYSETCOND . @@ . re2c:api:sigil . re2c:YYSETCOND:naked, re2c:define:YYSETCONDITION:naked re2c:api:style YYSETCOND . API . re2c:YYSETSTATE, re2c:define:YYSETSTATE API YYSETSTATE . re2c:YYSETSTATE@state, re2c:define:YYSETSTATE@state (sigil) YYSETSTATE . @@ . re2c:api:sigil . re2c:YYSETSTATE:naked, re2c:define:YYSETSTATE:naked re2c:api:style YYSETSTATE . API . re2c:YYSETACCEPT, re2c:define:YYSETACCEPT API YYSETACCEPT . re2c:YYSKIP, re2c:define:YYSKIP API YYSKIP . re2c:YYSHIFT, re2c:define:YYSHIFT API YYSHIFT . re2c:YYCOPYMTAG, re2c:define:YYCOPYMTAG API YYCOPYMTAG . re2c:YYCOPYSTAG, re2c:define:YYCOPYSTAG API YYCOPYSTAG . re2c:YYSHIFTMTAG, re2c:define:YYSHIFTMTAG API YYSHIFTMTAG . re2c:YYSHIFTSTAG, re2c:define:YYSHIFTSTAG API YYSHIFTSTAG . re2c:YYSTAGN, re2c:define:YYSTAGN API YYSTAGN . re2c:YYSTAGP, re2c:define:YYSTAGP API YYSTAGP . re2c:yyaccept, re2c:variable:yyaccept API yyaccept . re2c:yybm, re2c:variable:yybm API yybm . re2c:yybm:hex, re2c:variable:yybm:hex (bitmaps) --bit-vectors . ( ). re2c:yych, re2c:variable:yych API yych . re2c:yych:emit, re2c:variable:yych:emit yych . . re2c:yych:conversion, re2c:variable:yych:conversion re2d yych YYCTYPE . ( ). re2c:yych:literals, re2c:variable:yych:literals yych . : char ( ) hex ( ) char_or_hex ( ). re2c:yyctable, re2c:variable:yyctable API yyctable ..TP re2c:yynmatch, re2c:variable:yynmatch API yynmatch . re2c:yypmatch, re2c:variable:yypmatch API yypmatch . re2c:yytarget, re2c:variable:yytarget API yytarget . re2c:yystable, re2c:variable:yystable . re2c:yystate, re2c:variable:yystate API yystate . re2c:yyfill, re2c:variable:yyfill API yyfill . re2c:yyfill:check YYFILL ( YYLESSTHAN API YYLIMIT API C) . ( ). re2c:yyfill:enable YYFILL ( ) . ( ) YYFILL ( (sentinel) ). ( -W) re2c:sentinel (lexer) . (YYFILL ). re2c:yyfill:parameter YYFILL . . ( ). re2c:YYFILL:naked re2c:api:style . re2c:yyfn:sep YYFN ( - ). re2c:yyfn:throw YYFN ( ). (Regular expressions) re2d : "foo" . 'foo' . [a-xyz], [^a-xyz] ( ). . (newline). R \ S R S. R* R. R+ R. R? R . R{n} R n . R{n,} R n . R{n,m} R n m . (R) R . (submatch) --invert-captures (R) . (!R) --invert-captures (!R) . R S : R S. R | S : R S. R / S (Lookahead): R S S . name name ( "name" Flex). {name} name Flex. @stag s-tag: @stag stag . #mtag m-tag: #mtag mtag . $ . : \a \b \f \n \r \t \v \\ \ooo \xhh \uhhhh \Uhhhhhhhh..SS " (Actions)" re2d : !entry code (Entry action) code . start conditions . (lexeme). !pre_rule code (Pre-rule action) code ( start conditions) . ( ) . !post_rule code (Post-rule action) code ( start conditions) . (trap statements) . (Directives) re2d : !use:name ; use name . . : . * $ . use use . !include file ; include : file . (Program interface) (primitives) API . . . re2d ( ) . API . re2d API : Simple API API D . YYCURSOR YYMARKER YYCTXMARKER YYLIMIT YYCTYPE* . Record API Record API struct . --api record re2c:api = record . API yyrecord ( re2c:yyrecord ) struct yycursor yymarker yyctxmarker yylimit ( ). Generic API API . --api generic re2c:api = generic . : YYPEEK YYSKIP YYBACKUP YYBACKUPCTX YYSTAGP YYSTAGN YYMTAGP YYMTAGN YYRESTORE YYRESTORECTX YYRESTORETAG YYSHIFT YYSHIFTSTAG YYSHIFTMTAG YYLESSTHAN YYEND. API . YYCTYPE (code units). ASCII EBCDIC UTF-8 . UTF-16 UCS-2 . UTF-32 . YYCURSOR l-value ( YYINPUT). YYCURSOR . YYCURSOR . YYLIMIT r-value ( YYINPUT). YYLIMIT . . YYCURSOR YYLIMIT . YYMARKER l-value ( YYINPUT). (rollback) YYCURSOR . . YYCTXMARKER l-value (trailing context) ( YYINPUT). . YYCTXMARKER / . YYFILL API len. YYFILL len . re2c:eof len 1 YYFILL . re2c:eof YYFILL . len YYMAXFILL . YYFN --recursive-functions . re2c:fn:sep ( ) . ( void ). : ( ) ( - ). YYINPUT r-value ( ) . YYMAXFILL YYFILL. max . YYLESSTHAN API len. r-value boolean true len . YYEND API . r-value boolean true ( ). YYEND $ . YYLESSTHAN . YYPEEK API . r-value YYCTYPE . YYSKIP API (code unit) . YYBACKUP API ( YYRESTORE ). YYRESTORE API YYBACKUP . YYBACKUPCTX API (trailing context) ( YYRESTORECTX )..TP YYRESTORECTX API YYBACKUPCTX . YYRESTORETAG API tag tag . YYSTAGP API tag tag YYINPUT ( ). YYSTAGP tag . YYSTAGN API tag tag YYINPUT ( ). YYSTAGN tag . YYMTAGP API tag. YYMTAGP tag ( ). YYMTAGN API tag. YYMTAGN tag ( ). YYSHIFT API shift shift ( ). YYCOPYSTAG API lhs rhs s-tag rhs s-tag lhs . lhs rhs . YYCOPYMTAG API lhs rhs m-tag rhs m-tag lhs . lhs rhs . YYSHIFTSTAG API tag shift tag shift ( ). YYSHIFTMTAG API tag shift tag shift ( ). YYMAXNMATCH POSIX . maxnmatch . YYCONDTYPE (enum) . conditions --header . YYGETACCEPT var . var . YYSETACCEPT : var ( l-value ) val ( ). var val . YYGETCOND r-value YYCONDTYPE . YYSETCOND cond cond . YYGETSTATE r-value . -1 . YYSETSTATE state state . YYDEBUG -d --debug-output . ( YYDEBUG ). YYDEBUG : state ( DFA -1) symbol ( ). yyaccept l-value . --storable-state . yybm ( --bitmaps ). . . k- n- (true) n- k- . if switch . yych l-value YYCTYPE . -f --storable-state . yyctable ( --conditions --computed-gotos ). yyfill l-value YYFILL ( YYFILL ). yynmatch l-value POSIX . -P --posix-captures . yypmatch l-value . yynmatch * 2 ( YYMAXNMATCH * 2 ). -P --posix-captures . yystable . yystate l-value --loop-switch DFA . yytarget ( ) . () . yytarget --computed-gotos . re2c . re2c . re2c . -? --help -h . --api API . simple (lexer) . record (struct class ) . generic API . --bit-vectors -b (bit masks). --nested-ifs . --captures, --leftmost-captures (leftmost greedy). yybmatch 2 * YYMAXNMATCH yynmatch . --captvars, --leftmost-captvars . yytl yytr k- . --case-insensitive . --case-inverted : . --case-ranges case switch low ... high. C/C++ GCC Clang Tcc . case Tcc (binary) . --computed-gotos -g "computed goto" ( ). re2d . cgoto:threshold . cgoto:relative . --bit-vectors . --computed-gotos-relative --computed-gotos ( ). --computed-gotos . --conditions --start-conditions -c "conditions" Flex: . re2d goto . --depfile FILE FILE Makefile : [include-file ...]. / include include . --output . --ebcdic --ecb -e EBCDIC . re2d 0 -- 0xFF . --empty-class re2d . match-empty () ( ). match-none . error . --encoding-policy re2d (surrogates). fail surrogate re2d . substitute re2d 0xFFFD . ignore () re2d . . --flex-syntax -F Flex: . . --goto-label "goto/label": DFA goto . goto . --header --type-header -t HEADER HEADER. header:on header:off . condition enum ( conditions ). -I PATH PATH include . include . re2d FILE include -I . --input --api. default simple ( backend ). custom generic . --input-encoding re2d. ascii () re2d ASCII : (code units) . utf8 re2d UTF8 . --invert-captures (capturing) (non-capturing). (...) (! ...) . (! ...) (...) . --lang . C D Go Haskell Java JS OCaml Python Rust Swift V Zig ( --syntax ). none . --location-format . gnu 'filename:line:column: ...' . msvc 'filename(line,column) ...' . gnu . --loop-switch "loop/switch": DFA switch case switch . yystate . yystate case . --nested-ifs -s if switch . . --no-debug-info -i (line directives) . ( ). --no-generation-date . --no-version . --no-unsafe unsafe YYPEEK ( Rust ). YYPEEK (bounds-checking) . YYPEEK release --no-unsafe unsafe . --output -o OUTPUT OUTPUT. --posix-captures, -P POSIX. yybmatch 2 * YYMAXNMATCH yynmatch . --posix-captvars POSIX. yytl yytr k- . --recursive-functions (co-recursive) DFA . --reusable -r 2.2 ( ). --skeleton -S "" (skeleton). "" . . C ..TP --storable-state -f lexer . lexer push . YYGETSTATE YYSETSTATE yych yyaccept state lexer . --syntax FILE FILE (syntax) . FILE ( ) backend ( --lang none ). --tags -T . --ucs2 --wide-chars -w lexer UCS2 . re2d 0 -- 0xFFFF . --nested-ifs . --utf8 --utf-8 -8 lexer UTF-8 . re2d 0 -- 0x10FFFF . --utf16 --utf-16 -x lexer UTF16 . re2d 0 -- 0x10FFFF . --nested-ifs . --utf32 --unicode -u lexer UTF32 . re2d 0 -- 0x10FFFF . --nested-ifs . --verbose . --vernum -V MMmmpp ( ). --version -v . --single-pass -1 . ( ). --debug-output -d YYDEBUG . lexer . --dump-adfa : DFA ( .dot). --dump-cfg : ( .dot). --dump-closure-stats : (closure). --dump-dfa-det : DFA ( .dot). --dump-dfa-min : DFA ( .dot). --dump-dfa-tagopt : DFA ( .dot). --dump-dfa-tree : DFA ( .dot). --dump-dfa-raw : DFA ( .dot). --dump-interf : . --dump-nfa : NFA ( .dot). --emit-dot -D lexer .dot . Graphviz ( dot -Tpng -odfa.png dfa.dot). --dfa-minimization : DFA re2d. moore (Moore) ( ). table " " . DFA . --eager-skip : lexer -- . -- . --no-lookahead . TDFA(0) . TDFA(1) TDFA(0) . . TDFA(0) TDFA(1) . --no-optimize-tags : ( ). --posix-closure : (epsilon-closure) POSIX: gor1 () Goldberg-Radzik gtop " " . --posix-prectable : POSIX. complex TNFA . naive TNFA complex . --stadfa . staDFA TDFA . staDFA TDFA . --fixed-tags : (fixed-tag) (all) (none) (toplevel) . all . "" ( "" ) . . (no-match) ( no-match ). . . -W . -Werror . . -W warning . -Wno- warning . -Werror- warning ( -W ). -Wno-error- warning . . -Wcondition-order . --header conditions . -Wempty-character-class . : . re2d . --empty-class . -Wmatch-empty-string ( ) . . -Wswapped-range . . -Wundefined-control-flow ( ). . * . -Wunreachable-rules . -Wdeprecated-eof_rule $ . $ . -Wuseless-escape (escape) . re2d (escape sequence) . -Wnondeterministic-tags n n . -Wsentinel-in-midrule (sentinel) --- (crash) . . re2c:sentinel . -Wundefined-syntax-config --syntax . : . . (Syntax files) re2c . -- . re2c re2c: : . ( include/syntax ) re2d . ( --lang none ). : . (Feature lists) re2d : supported_apis API simple record generic. supported_api_styles API functions free-form. supported_code_models goto-label loop-switch recursive-functions. supported_targets code dot skeleton. supported_features nested-ifs bitmaps computed-gotos case-ranges monadic unsafe tags captures captvars. (Language configurations) re2d : semicolons (semicolon) . backtick_quoted_strings (backtick) . single_quoted_strings (single-quote) . indentation_sensitive . wrap_blocks_in_braces . (Inplace configurations) re2c: . . (Code templates) . - : code-template :: name '=' code-exprs ';' | CODE_TEMPLATE ';' | '' ';' code-exprs :: | code-exprs code-expr code-expr :: STRING | VARIABLE | optional | list optional :: '(' CONDITIONAL '?' code-exprs ')' | '(' CONDITIONAL '?' code-exprs ':' code-exprs ')' list :: '[' VARIABLE ':' code-exprs ']' | '[' VARIABLE '{' NUMBER '}' ':' code-exprs ']' | '[' VARIABLE '{' NUMBER ',' NUMBER '}' ':' code-exprs ']' . . : re2d . ( -1 ). . ( ) ( ) . re2d . if-then-else C : code:if_then_else = [branch{0}: topindent "if " cond " {" nl indent [stmt: stmt] dedent] [branch{1:-1}: topindent "} else" (.cond ? " if " cond) " {" nl indent [stmt: stmt] dedent] topindent "}" nl; branch : branch{0} ( else ) branch{1:-1} ( ) . stmt : [stmt: stmt] . topindent indent dedent nl .cond ( ). : if x { // do something } else if y { // do something else } else { // don't do anything } re2d . . . code:var_local . : type ( ) name ( ) init ( ). : .init ( ). code:var_global code:var_local top-level . code:const_local . : type ( ) name ( ) init ( ). code:const_global code:const_local top-level . code:array_local () . : type ( ) name ( ) size ( ) row ( ) elem ( -- row ). : .const ( ). code:array_global code:array_local top-level . code:array_elem (). : array ( ) index ( ). code:enum enum ( ). : type ( ) elem ( ) init ( ). : .init ( ). code:enum_elem ( code:enum). : name ( ) type ( ). code:assign . : lhs ( ) rhs ( ). code:type_int (signed). code:type_uint (unsigned). code:type_yybm yybm. code:type_yytarget yytarget. code:type_yyctable yyctable. code:cmp_eq " " (equals). code:cmp_ne " " (not equals). code:cmp_lt " " (less than). code:cmp_gt " " (greater than). code:cmp_le " " (less or equal). code:cmp_ge " " (greater or equal). code:if_then_else if-then-else . : branch ( ) cond ( ) stmt ( ). : .cond ( ) .many ( ). code:if_then_else_oneline code:if_then_else . code:if_then_else . code:switch switch (case). : expr ( switch) case ( case ). code:switch_cases switch . : case ( ) stmt ( ). code:switch_cases_oneline code:switch_cases . code:switch_cases . code:switch_case_range switch ( ). : val ( ). : .many ( ) .char_literals ( switch -- ). code:switch_case_default (default) switch. code:loop ( ). : label ( ) stmt ( ). code:continue continue. : label ( ). code:goto goto. : label ( ). code:cgoto goto (computed goto). : array ( goto ) index ( ) base ( .cgoto.relative ). code:cgoto:data goto . : label ( ) type ( ) base ( - .cgoto.relative ). code:fndecl . : name ( ) type ( ) throw ( re2c:yyfn:throw ) arg ( ) argname ( ) argtype ( ). : .type ( void ). code:fndef code:fndecl stmt . code:fncall . : name ( ) retval ( l-value ) arg ( ). : .args ( ) .retval ( ). code:tailcall (tail call). : name ( ) arg ( ). : .args ( ) .retval ( void ). code:recursive_functions --recursive-functions. : fn ( ) fndecl ( ) fndef ( ). code:fingerprint (fingerprint) . : ver ( re2d ) date ( ). code:line_info (line directives) ( ). : line ( ) file ( ). code:abort (abort) . code:yydebug YYDEBUG (API) . : YYDEBUG yyrecord yych ( re2c:) state ( DFA)..TP code:yypeek YYPEEK API . : YYPEEK YYCTYPE YYINPUT YYCURSOR yyrecord yych ( re2c: ). : .cast ( re2c:yych:conversion ). code:yyskip YYSKIP API . : YYSKIP YYCURSOR yyrecord ( re2c: ). code:yybackup YYBACKUP API . : YYBACKUP YYCURSOR YYMARKER yyrecord ( re2c: ). code:yybackupctx YYBACKUPCTX API . : YYBACKUPCTX YYCURSOR YYCTXMARKER yyrecord ( re2c: ). code:yyskip_yypeek code:yyskip code:yypeek ( code:yyskip code:yypeek ). code:yypeek_yyskip code:yypeek code:yyskip ( code:yypeek code:yyskip ). code:yyskip_yybackup code:yyskip code:yybackup ( code:yyskip code:yybackup ). code:yybackup_yyskip code:yybackup code:yyskip ( code:yybackup code:yyskip ). code:yybackup_yypeek code:yybackup code:yypeek ( code:yybackup code:yypeek ). code:yyskip_yybackup_yypeek code:yyskip code:yybackup code:yypeek ( ``code:yyskip`` code:yybackup code:yypeek ). code:yybackup_yypeek_yyskip code:yybackup code:yypeek code:yyskip ( ``code:yybackup`` code:yypeek code:yyskip ). code:yyrestore YYRESTORE API . : YYRESTORE YYCURSOR YYMARKER yyrecord ( re2c: ). code:yyrestorectx YYRESTORECTX API . : YYRESTORECTX YYCURSOR YYCTXMARKER yyrecord ( re2c: ). code:yyrestoretag YYRESTORETAG API . : YYRESTORETAG YYCURSOR yyrecord ( re2c: ) tag ( ). code:yyshift YYSHIFT API . : YYSHIFT YYCURSOR yyrecord ( re2c: ) offset ( ). code:yyshiftstag YYSHIFTSTAG API . : YYSHIFTSTAG yyrecord negative ( re2c: ) tag ( ) offset ( ). : .nested ( -- re2c:tags:negative ). code:yyshiftmtag YYSHIFTMTAG API . : YYSHIFTMTAG ( re2c: ) tag ( ) offset ( ). code:yystagp YYSTAGP API . : YYSTAGP YYCURSOR yyrecord ( re2c: ) tag ( ). code:yymtagp YYMTAGP API . : YYMTAGP ( re2c: ) tag ( ). code:yystagn YYSTAGN API . : YYSTAGN negative yyrecord ( re2c: ) tag ( ). code:yymtagn YYMTAGN API . : YYMTAGN ( re2c: ) tag ( ). code:yycopystag YYCOPYSTAG API . : YYCOPYSTAG yyrecord ( re2c: ) lhs rhs ( ). code:yycopymtag YYCOPYMTAG API . : YYCOPYMTAG yyrecord ( re2c: ) lhs rhs ( ). code:yygetaccept YYGETACCEPT API . : YYGETACCEPT yyrecord ( re2c: ) var ( re2c:yyaccept ). code:yysetaccept YYSETACCEPT API . : YYSETACCEPT yyrecord ( re2c: ) var ( re2c:yyaccept ) val ( ). code:yygetcond YYGETCOND API . : YYGETCOND yyrecord ( re2c: ) var ( re2c:yycond ). code:yysetcond YYSETCOND API . : YYSETCOND yyrecord ( re2c: ) var ( re2c:yycond ) val ( ). code:yygetstate YYGETSTATE API . : YYGETSTATE yyrecord ( re2c: ) var ( re2c:yystate ). code:yysetstate YYSETSTATE API . : YYSETSTATE yyrecord ( re2c: ) var ( re2c:yystate ) val ( ). code:yylessthan YYLESSTHAN API . : YYLESSTHAN YYCURSOR YYLIMIT yyrecord ( re2c: ) need ( ). : .many ( need ). code:yyend YYEND API . : YYEND YYCURSOR YYLIMIT. code:yybm_filter yych yybm ( --bitmaps ). : yych ( re2c:yych ). code:yybm_match yybm ( --bitmaps). : yybm yych ( re2c: ) offset ( yybm yych ) mask ( ). code:yytarget_filter yych yytarget ( --computed-gotos ). : yych ( re2c:yych ). (syntax files) : nl (newline). indent ..TP dedent . topindent . . (syntax) : .api.simple API (--api simple re2c:api = simple). .api.generic API (--api generic re2c:api = generic). .api.record API (--api record re2c:api = record). .api_style.functions API (re2c:api-style = functions). .api_style.freeform API (free-form) (re2c:api-style = free-form). .case_ranges case (--case-ranges re2c:case-ranges = 1). .cgoto.relative goto (--computed-gotos-relative re2c:cgoto:relative = 1). .code_model.goto_label goto/label (--goto-label). .code_model.loop_switch loop/switch (--loop-switch). .code_model.recursive_functions (--recursive-function). .date (fingerprint) . .loop_label re2d (re2c:label:yyloop ). .monadic (re2c:monadic = 1). . .start_conditions (start conditions) (--start-conditions). .storable_state (--storable-state). .unsafe re2d "unsafe" (--unsafe re2c:unsafe = 1). "unsafe" . .version (fingerprint) re2d . .yyfill.enable YYFILL (re2c:yyfill:enable = 1). .yyfn.throw re2c:yyfn:throw . (HANDLING THE END OF INPUT) (lexer) . : o ( *) o o <<>> : . : . . re2d . . : o (Sentinel). . <<>> . . : . . YYFILL re2c:yyfill:enable = 0; re2c:eof -1 . o (Sentinel with bounds checks). : . . <<>> <<>> . ( ). . . YYFILL ( ). . . re2c:eof ( ). YYFILL . o (Bounds checks with padding). << >> . DFA (SCC) SCC SCC . . (padding) ( ) . YYMAXFILL max . YYFILL . YYFILL re2c:eof -1 ( ). o (Custom checks). (Generic API) . . Generic API --api custom re2c:api = custom; re2c:yyfill:enable = 0; re2c:yyfill:check = 0; . ..SS (Sentinel) (sentinel) . null . null : (lexeme) ( ). null * ( -Wsentinel-in-midrule re2c:sentinel ). re2c:yyfill:enable = 0; YYFILL . // re2d $INPUT -o $OUTPUT module main; // Expect a null-terminated string. private int lex(const(char)* yycursor) { uint count = 0; for (;;) { /*!re2c re2c:YYCTYPE = char; re2c:yyfill:enable = 0; * { return -1; } [\x00] { return count; } [a-z]+ { ++count; continue; } [ ]+ { continue; } */ } assert(0); // unreachable } void main() { assert(lex("") == 0); assert(lex("one two three") == 3); assert(lex("f0ur") == -1); } (Sentinel with bounds checks) ( 1.2 ). . null re2c:eof = 0; . sentinel null ( 'aaa\0aa'\0 'aaa\0 ). null . YYLIMIT <= YYCURSOR API YYLESSTHAN(1) . (YYFILL re2c:yyfill:enable = 0; YYFILL YYFILL with sentinel ). : $ ( *) -Wundefined-control-flow . // re2d $INPUT -o $OUTPUT module main; // Expect a null-terminated string. private int lex(immutable char[] s) { const(char)* yycursor = s.ptr, yylimit = s.ptr + s.length, yymarker; int count = 0; for (;;) { /*!re2c re2c:YYCTYPE = char; re2c:yyfill:enable = 0; re2c:eof = 0; str = ['] ([^'\\] | [\\][^])* [']; * { return -1; } $ { return count; } str { ++count; continue; } [ ]+ { continue; } */ } assert(0); // unreachable } void main() { assert(lex("") == 0); assert(lex("'qu\0tes' 'are' 'fine: \\'' ") == 3); assert(lex("'unterminated\\'") == -1); } (Bounds checks with padding) ( ). . YYMAXFILL null YYMAXFILL max . null --- (lexeme) ( ). "stop" (null) ( null ). (strongly connected components) . (YYLIMIT - YYCURSOR) < n API YYLESSTHAN(n) n ( n ). YYFILL(n) n . YYFILL ( ). YYFILL YYFILL with padding . // re2d $INPUT -o $OUTPUT module main; import core.stdc.stdlib; import core.stdc.string; /*!max:re2c*/ private int lex(immutable char[] s) { // Make a copy of the string with YYMAXFILL zeroes at the end. char *buf = cast(char*) malloc(s.length + YYMaxFill); memcpy(buf, cast(const(void*)) s, s.length); memset(buf + s.length, 0, YYMaxFill); const(char)* yycursor = buf; const(char)* yylimit = buf + s.length + YYMaxFill; int count = 0; loop: /*!re2c re2c:YYCTYPE = char; re2c:YYFILL = "goto fail;"; str = ['] ([^'\\] | [\\][^])* [']; [\x00] { // Check that it is the sentinel, not some unexpected null. if (yycursor - 1 == buf + s.length) goto exit; else goto fail; } str { ++count; goto loop; } [ ]+ { goto loop; } * { goto fail; } */ fail: count = -1; exit: free(buf); return count; } void main() { assert(lex("") == 0); assert(lex("'qu\0tes' 'are' 'fine: \\'' ") == 3); assert(lex("'unterminated\\'") == -1); assert(lex("'unexpected \0 null\\'") == -1); } generic API . . sentinel (null- terminated) . YYPEEK (bounds check) . . YYPEEK . // re2d $INPUT -o $OUTPUT module main; import core.stdc.stdlib; import core.stdc.string; private int lex(immutable char[] s) { // For the sake of example create a string without terminating null. char *buf = cast(char*) malloc(s.length); memcpy(buf, cast(const(void*)) s, s.length); const(char) *cur = buf, lim = buf + s.length; int count = 0; for (;;) { /*!re2c re2c:api = generic; re2c:yyfill:enable = 0; re2c:YYCTYPE = char; re2c:YYPEEK = "cur < lim ? *cur : 0"; // fake null re2c:YYSKIP = "++cur;"; * { count = -1; break; } [\x00] { break;{} } [a-z]+ { ++count; continue;{} } [ ]+ { continue; } */ } free(buf); return count; } void main() { assert(lex("") == 0); assert(lex("one two three ") == 3); assert(lex("f0ur") == -1); } (BUFFER REFILLING) : ( ) . . . (lexer) : o (cursor): (YYCURSOR API C YYSKIP/YYPEEK generic API) o (limit): (YYLIMIT API C YYLESSTHAN generic API ) o (marker): (YYMARKER API YYBACKUP/YYRESTORE generic API) o (token): (lexeme) ( API re2d lexer ) o (context marker): (YYCTXMARKER API C YYBACKUPCTX/YYRESTORECTX generic API) o (tag variables): ( stags mtags generic API YYSTAGP/YYSTAGN/YYMTAGP/YYMTAGN) YYFILL . token cursor token token limit . YYFILL ( lexer ). YYFILL EOF : EOF (padding) . -f --storable-state YYFILL ( ). YYFILL (YYFILL with sentinel) EOF YYFILL . YYFILL YYLIMIT <= YYCURSOR API C YYLESSTHAN() generic API . YYFILL . YYFILL . Limit limit re2c:eof . YYFILL ( # ). <-- shift --> >-A------------B---------C-------------D#-----------E-> buffer token marker limit, cursor >-A------------B---------C-------------D------------E#-> buffer, marker cursor limit token <-- shift --> >-A------------B---------C-------------D#--E (EOF) buffer token marker limit, cursor >-A------------B---------C-------------D---E#........ buffer, marker cursor limit token input.txt EOF . // re2d $INPUT -o $OUTPUT module main; import core.stdc.string; import core.stdc.stdio; enum BUFSIZE = 4095; struct Input { FILE* file; char[BUFSIZE + 1] buffer;// +1 for sentinel char* yylimit, yycursor, yymarker, token; bool eof; }; private int fill(ref Input it) { if (it.eof) return 1; const size_t shift = it.token - it.buffer.ptr; const size_t used = it.yylimit - it.token; // Error: lexeme too long. In real life could reallocate a larger buffer. if (shift < 1) return 2; // Shift buffer contents (discard everything up to the current token). memmove(cast(void*)it.buffer.ptr, it.token, used); it.yylimit -= shift; it.yycursor -= shift; it.yymarker -= shift; it.token -= shift; // Fill free space at the end of buffer with new data from file. it.yylimit += fread(it.yylimit, 1, BUFSIZE - used, it.file); it.yylimit[0] = 0; it.eof = it.yylimit < (it.buffer.ptr + BUFSIZE); return 0; } private int lex(ref Input yyrecord) { int count = 0; for (;;) { yyrecord.token = yyrecord.yycursor; /*!re2c re2c:api = record; re2c:YYCTYPE = "char"; re2c:YYFILL = "fill(yyrecord) == 0"; re2c:eof = 0; str = ['] ([^'\\] | [\\][^])* [']; * { return -1; } $ { return count; } str { ++count; continue; } [ ]+ { continue; } */ } assert(0); } void main() { const char[] fname = "input"; const char[] content = "'qu\0tes' 'are' 'fine: \\'' "; // Prepare input file: a few times the size of the buffer, containing // strings with zeroes and escaped quotes. FILE* f = fopen(fname.ptr, "w"); for (int i = 0; i < BUFSIZE; ++i) { fwrite(cast(const(void*)) content.ptr, 1, content.length - 1, f); } fclose(f); int count = 3 * BUFSIZE; // number of quoted strings written to file // Initialize lexer state: all pointers are at the end of buffer. Input it; it.file = fopen(fname.ptr, "r"); it.yycursor = it.yymarker = it.token = it.yylimit = it.buffer.ptr + BUFSIZE; it.eof = 0; // Sentinel (at YYLIMIT pointer) is set to zero, which triggers YYFILL. it.yylimit[0] = 0; // Run the lexer. assert(lex(it) == count); // Cleanup: remove input file. fclose(it.file); remove(fname.ptr); } ( EOF ) YYFILL (primitive) . YYFILL (YYLIMIT - YYCURSOR) < n API C YYLESSTHAN(n) API (generic) . YYFILL . YYFILL lexer ( ). YYFILL (limit) YYMAXFILL ( YYFILL n ). YYFILL ( YYMAXFILL # ). <-- shift --> <-- need --> >-A------------B---------C-----D-------E---F--------G-> buffer token marker cursor limit >-A------------B---------C-----D-------E---F--------G-> buffer, marker cursor limit token <-- shift --> <-- need --> >-A------------B---------C-----D-------E-F (EOF) buffer token marker cursor limit >-A------------B---------C-----D-------E-F############### buffer, marker cursor limit token <- YYMAXFILL -> input.txt (bounds-checking) . // re2d $INPUT -o $OUTPUT module main; import core.stdc.string; import core.stdc.stdio; /*!max:re2c*/ enum BufSize = (4096 - YYMaxFill); struct Input { FILE* file; char[BufSize + YYMaxFill] buffer; char* yylimit, yycursor, token; bool eof; }; private int fill(ref Input it, size_t need) { if (it.eof) return 1; const size_t shift = it.token - it.buffer.ptr; const size_t used = it.yylimit - it.token; // Error: lexeme too long. In real life could reallocate a larger buffer. if (shift < need) return 2; // Shift buffer contents (discard everything up to the current token). memmove(it.buffer.ptr, it.token, used); it.yylimit -= shift; it.yycursor -= shift; it.token -= shift; // Fill free space at the end of buffer with new data from file. it.yylimit += fread(it.yylimit, 1, BufSize - used, it.file); // If read less than expected, this is end of input => add zero padding // so that the lexer can access characters at the end of buffer. if (it.yylimit < it.buffer.ptr + BufSize) { it.eof = true; memset(it.yylimit, 0, YYMaxFill); it.yylimit += YYMaxFill; } return 0; } private int lex(ref Input yyrecord) { int count = 0; for (;;) { yyrecord.token = yyrecord.yycursor; /*!re2c re2c:api = record; re2c:YYCTYPE = "char"; re2c:YYFILL = "if (fill(yyrecord, @@) != 0) return -1;"; str = ['] ([^'\\] | [\\][^])* [']; [\x00] { // Check that it is the sentinel, not some unexpected null. return yyrecord.token == yyrecord.yylimit - YYMaxFill ? count : -1; } str { ++count; continue; } [ ]+ { continue; } * { return -1; } */ } assert(0); } void main() { const char[] fname = "input"; const char[] content = "'qu\0tes' 'are' 'fine: \\'' "; // Prepare input file: a few times the size of the buffer, containing // strings with zeroes and escaped quotes. FILE* f = fopen(fname.ptr, "w"); for (int i = 0; i < BufSize; ++i) { fwrite(content.ptr, 1, content.length - 1, f); } fclose(f); int count = 3 * BufSize; // number of quoted strings written to file // Initialize lexer state: all pointers are at the end of buffer. // This immediately triggers YYFILL, as the check `it.yycursor < it.yylimit` fails. Input it; it.file = fopen(fname.ptr, "r"); it.yycursor = it.token = it.yylimit = it.buffer.ptr + BufSize; it.eof = 0; // Run the lexer. assert(lex(it) == count); // Cleanup: remove input file. fclose(it.file); remove(fname.ptr); } (Multiple blocks) (lexer) ( ). re2d . (start conditions) . . goto ( C/C++ Go) (label) . goto . goto ( Rust) switch /switch yystate re2d . (binary) (octal) (decimal) (hexadecimal) . . . . // re2d $INPUT -o $OUTPUT -i module main; enum ERROR = ulong.max; private void add(ulong BASE)(ref ulong u, int d) { u = u * BASE + d; if (u > uint.max) { u = ERROR; } } private ulong parse_u32(const(char)* s) { const(char)* yycursor = s, yymarker; ulong u = 0; /*!re2c re2c:yyfill:enable = 0; re2c:YYCTYPE = char; end = "\x00"; '0b' / [01] { goto bin; } "0" { goto oct; } "" / [1-9] { goto dec; } '0x' / [0-9a-fA-F] { goto hex; } * { return ERROR; } */ bin: /*!re2c end { return u; } [01] { add!(2)(u, yycursor[-1] - '0'); goto bin; } * { return ERROR; } */ oct: /*!re2c end { return u; } [0-7] { add!(8)(u, yycursor[-1] - '0'); goto oct; } * { return ERROR; } */ dec: /*!re2c end { return u; } [0-9] { add!(10)(u, yycursor[-1] - '0'); goto dec; } * { return ERROR; } */ hex: /*!re2c end { return u; } [0-9] { add!(16)(u, yycursor[-1] - '0'); goto hex; } [a-f] { add!(16)(u, yycursor[-1] - 'a' + 10); goto hex; } [A-F] { add!(16)(u, yycursor[-1] - 'A' + 10); goto hex; } * { return ERROR; } */ } void main() { assert(parse_u32("") == ERROR); assert(parse_u32("1234567890") == 1234567890); assert(parse_u32("0b1101") == 13); assert(parse_u32("0x7Fe") == 2046); assert(parse_u32("0644") == 420); assert(parse_u32("9999999999") == ERROR); } (Start conditions) --start-conditions . re2d . re2d . : YYGETCOND YYSETCOND . conditions --header re2c:header . re2c:cond:enumprefix . (< >) <*> . : < condition-list > regular-expression code condition-list . regular-expression code . < condition-list > regular-expression => condition code condition-list . regular-expression condition code . < condition-list > regular-expression :=> condition condition-list . regular-expression condition ( ). < condition-list > !action code code action condition-list ( actions ). code code condition-list . !pre_rule ( ). < > code "0" code . !entry ( ). < > => condition code condition . < > :=> condition condition . re2d re2d goto/label loop/switch . goto ( C/C++ Go) yyc_ cond ( re2c:cond:prefix ). goto . re2d switch YYGETSTATE . :=> switch ( re2c:cond:goto ). . goto ( Rust) re2d yystate . switch DFA . switch . ( YYGETCOND/YYSETCOND ). . . cond conditions . // re2d $INPUT -o $OUTPUT -ci module main; enum ERROR = ulong.max; /*!conditions:re2c*/ private void add(ulong BASE)(ref ulong u, int d) { u = u * BASE + d; if (u > uint.max) { u = ERROR; } } private ulong parse_u32(const(char)* s) { const(char)* yycursor = s, yymarker; YYCond yycond = YYCond.yycinit; ulong u = 0; /*!re2c re2c:yyfill:enable = 0; re2c:YYCTYPE = char; <*> * { return ERROR; } '0b' / [01] :=> bin "0" :=> oct "" / [1-9] :=> dec '0x' / [0-9a-fA-F] :=> hex "\x00" { return u; } [01] { add!(2)(u, yycursor[-1] - '0'); goto yyc_bin; } [0-7] { add!(8)(u, yycursor[-1] - '0'); goto yyc_oct; } [0-9] { add!(10)(u, yycursor[-1] - '0'); goto yyc_dec; } [0-9] { add!(16)(u, yycursor[-1] - '0'); goto yyc_hex; } [a-f] { add!(16)(u, yycursor[-1] - 'a' + 10); goto yyc_hex; } [A-F] { add!(16)(u, yycursor[-1] - 'A' + 10); goto yyc_hex; } */ } void main() { assert(parse_u32("") == ERROR); assert(parse_u32("1234567890") == 1234567890); assert(parse_u32("0b1101") == 13); assert(parse_u32("0x7Fe") == 2046); assert(parse_u32("0644") == 420); assert(parse_u32("9999999999") == ERROR); } --storable-state re2d . re2d <<>> ("pull") <<>> ( ). ( (parser) ). : <<>> ("push") . . . <<>> : o YYSETSTATE() YYGETSTATE(state) . o yych yyaccept ( ) state (persistent) . state -1 . o YYFILL . . o . o getstate YYGETSTATE . goto ( --loop-switch). o re2c:eof sentinel with bounds checks ( ) . (padding) : (lexeme) . ( ). <<>> . . <<>> . . // re2d $INPUT -o $OUTPUT -f module main; import core.stdc.stdio; import core.stdc.string; // Use a small buffer to cover the case when a lexeme doesn't fit. // In real world use a larger buffer. enum BUFSIZE = 10; struct State { FILE* file; char[BUFSIZE + 1] buffer; char* yylimit, yycursor, yymarker, token; int yystate; }; enum Status {END, READY, WAITING, BAD_PACKET, BIG_PACKET}; private Status fill(ref State st) { const size_t shift = st.token - cast(char*)st.buffer; const size_t used = st.yylimit - st.token; const size_t free = BUFSIZE - used; // Error: no space. In real life can reallocate a larger buffer. if (free < 1) return Status.BIG_PACKET; // Shift buffer contents (discard already processed data). memmove(cast(void*)st.buffer, st.token, used); st.yylimit -= shift; st.yycursor -= shift; st.yymarker -= shift; st.token -= shift; // Fill free space at the end of buffer with new data. const size_t read = fread(st.yylimit, 1, free, st.file); st.yylimit += read; st.yylimit[0] = 0; // append sentinel symbol return Status.READY; } private Status lex(ref State yyrecord, uint* recv) { char yych; /*!getstate:re2c*/ for (;;) { yyrecord.token = yyrecord.yycursor; /*!re2c re2c:api = record; re2c:YYCTYPE = char; re2c:YYFILL = "return Status.WAITING;"; re2c:eof = 0; packet = [a-z]+[;]; * { return Status.BAD_PACKET; } $ { return Status.END; } packet { *recv = *recv + 1; continue; } */ } assert(0); // unreachable } private void test(string[] packets, Status expect) { // Create a pipe (open the same file for reading and writing). const(char*) fname = "pipe"; FILE* fw = fopen(fname, "w"); FILE* fr = fopen(fname, "r"); setvbuf(fw, null, _IONBF, 0); setvbuf(fr, null, _IONBF, 0); // Initialize lexer state: `state` value is -1, all pointers are at the end // of buffer. State st; st.file = fr; st.yycursor = st.yymarker = st.token = st.yylimit = cast(char*)st.buffer + BUFSIZE; // Sentinel (at YYLIMIT pointer) is set to zero, which triggers YYFILL. st.yylimit[0] = 0; st.yystate = -1; // Main loop. The buffer contains incomplete data which appears packet by // packet. When the lexer needs more input it saves its internal state and // returns to the caller which should provide more input and resume lexing. Status status; uint send = 0, recv = 0; for (;;) { status = lex(st, &recv); if (status == Status.END) { debug{printf("done: got %u packets\n", recv);} break; } else if (status == Status.WAITING) { debug{printf("waiting...\n");} if (send < packets.length) { debug{printf("sent packet %u\n", send);} fprintf(fw, "%s", cast(char*)packets[send]); ++send; } status = fill(st); debug{printf("queue: '%s'\n", cast(char*)st.buffer);} if (status == Status.BIG_PACKET) { debug{printf("error: packet too big\n");} break; } assert(status == Status.READY); } else { assert(status == Status.BAD_PACKET); debug{printf("error: ill-formed packet\n");} break; } } // Check results. assert(status == expect); if (status == Status.END) assert(recv == send); // Cleanup: remove input file. fclose(fw); fclose(fr); remove(fname); } void main() { string[] packets1 = []; string[] packets2 = ["zero;", "one;", "two;", "three;", "four;"]; string[] packets3 = ["zer0;"]; string[] packets4 = ["looooooooooong;"]; test(packets1, Status.END); test(packets2, Status.END); test(packets3, Status.BAD_PACKET); test(packets4, Status.BIG_PACKET); } /*!rules:re2c[:] ... */ %{rules[:] ... %} re2d . . (rules block) use . . use /*!use:re2c[:] ... */ %{use[:] ... %} . : ( ). use . use (lexer) : ( ). !use:; re2d . . : ( ). * $ ( ) . use re2d ( ). use 2.2 re2d . ( ). 2.2 -r --reusable . 1.2 . !use // re2d $INPUT -o $OUTPUT module main; // This example shows how to combine reusable re2c blocks: two blocks // ('colors' and 'fish') are merged into one. The 'salmon' rule occurs // in both blocks; the 'fish' block takes priority because it is used // earlier. Default rule * occurs in all three blocks; the local (not // inherited) definition takes priority. enum What { COLOR, FISH, DUNNO }; /*!rules:re2c:colors * { assert(false); } "red" | "salmon" | "magenta" { return What.COLOR; } */ /*!rules:re2c:fish * { assert(false); } "haddock" | "salmon" | "eel" { return What.FISH; } */ private What lex(const(char)* s) { const(char)* yycursor = s, yymarker; /*!re2c re2c:YYCTYPE = "char"; re2c:yyfill:enable = 0; !use:fish; !use:colors; * { return What.DUNNO; } // overrides inherited '*' rules */ } void main() { assert(lex("salmon") == What.FISH); assert(lex("what?") == What.DUNNO); } /*!use:re2c ... */ // re2d $INPUT -o $OUTPUT --input-encoding utf8 module main; import std.stdint; // This example supports multiple input encodings: UTF-8 and UTF-32. // Both lexers are generated from the same rules block, and the use // blocks add only encoding-specific configurations. /*!rules:re2c re2c:yyfill:enable = 0; "x y" { return 0; } * { return 1; } */ private int lex_utf8(const(uint8_t)* s) { const(uint8_t)* yycursor = s, yymarker; /*!use:re2c re2c:YYCTYPE = uint8_t; re2c:encoding:utf8 = 1; */ } private int lex_utf32(const(uint32_t)* s) { const(uint32_t)* yycursor = s, yymarker; /*!use:re2c re2c:YYCTYPE = uint32_t; re2c:encoding:utf32 = 1; */ } void main() { immutable uint8_t[] s8 = // UTF-8 [ 0xe2, 0x88, 0x80, 0x78, 0x20, 0xe2, 0x88, 0x83, 0x79 ]; immutable uint32_t[] s32 = // UTF32 [ 0x00002200, 0x00000078, 0x00000020, 0x00002203, 0x00000079 ]; assert(lex_utf8(cast(const(uint8_t)*)s8) == 0); assert(lex_utf32(cast(const(uint32_t)*)s32) == 0); } re2d (submatch extraction) . Tags (tags) @stag #mtag stag mtag . -T --tags re2c:tags = 1 . : ( ) . S-tag m-tag ( ). svars mvars . (leftmost greedy) . Captures (capturing groups) . --captures re2c:captures = 1 . --leftmost-captures () --posix-captures POSIX (POSIX longest-match) . : (! ... ). --invert-captures re2c:invert-captures = 1 . yynmatch ( ) yypmatch . yynmatch yypmatch yypmatch [yynmatch * 2] . maxnmatch YYMAXNMATCH yynmatch . Captvars --captvars re2c:captvars = 1 . --captures : yynmatch yypmatch re2d yytl yytr k- ( svars ). : --leftmost-captvars re2c:leftmost-captvars = 1 () --posix-captvars re2c:posix-captvars POSIX. Tagged Deterministic Finite Automata with Lookahead ( TDFA) . TDFA . TDFA DFA . . TDFA (tag variables) : . . stags mtags . (lexer state) . YYFILL . S-tag : o s-tag: t = YYCURSOR API C YYSTAGP(t) API (generic API) o s-tag: t = NULL API C YYSTAGN(t) API o s-tag : t1 = t2 M-tag : o m-tag: YYMTAGP(t) API o m-tag: YYMTAGN(t) API o m-tag : t1 = t2 S-tag ( ) . M-tag . m-tag ( ) m-tag (prefix-tree) (v, p) v p . s-tag (semantic versions) : major minor patch ( ). YYFILL . // re2d $INPUT -o $OUTPUT module main; struct SemVer { int major; int minor; int patch; }; private int s2n(const(char)* s, const(char)* e) { // pre-parsed string to number int n = 0; for (; s < e; ++s) n = n * 10 + (*s - '0'); return n; } private bool lex(const(char)* str, ref SemVer ver) { const(char)* yycursor = str, yymarker; // Final tag variables available in semantic action. /*!svars:re2c format = 'const(char)* @@;\n'; */ // Intermediate tag variables used by the lexer (must be autogenerated). /*!stags:re2c format = 'const(char)* @@;\n'; */ /*!re2c re2c:yyfill:enable = 0; re2c:tags = 1; re2c:YYCTYPE = "char"; num = [0-9]+; @t1 num @t2 "." @t3 num @t4 ("." @t5 num)? [\x00] { ver.major = s2n(t1, t2); ver.minor = s2n(t3, t4); ver.patch = t5 != null ? s2n(t5, yycursor - 1) : 0; return true; } * { return false; } */ } void main() { SemVer v; assert(lex("23.34", v) && v.major == 23 && v.minor == 34 && v.patch == 0); assert(lex("1.2.999", v) && v.major == 1 && v.minor == 2 && v.patch == 999); assert(!lex("1.a", v)); } s-tag YYFILL . YYFILL . s-tag . m-tag . // re2d $INPUT -o $OUTPUT --tags module main; import core.stdc.string; import core.stdc.stdio; import std.stdio; enum BUFSIZE = 4095; struct Input { FILE* file; char[BUFSIZE + 1] buffer;// +1 for sentinel char* yylimit, yycursor, yymarker, token; // Intermediate tag variables must be part of the lexer state passed to YYFILL. // They don't correspond to tags and should be autogenerated by re2c. /*!stags:re2c format = 'char* @@;'; */ bool eof; }; struct SemVer { int major; int minor; int patch; }; private int s2n(const(char)* s, const(char)* e) { // pre-parsed string to number int n = 0; for (; s < e; ++s) n = n * 10 + (*s - '0'); return n; } private int fill(ref Input it) { if (it.eof) return 1; const size_t shift = it.token - it.buffer.ptr; const size_t used = it.yylimit - it.token; // Error: lexeme too long. In real life could reallocate a larger buffer. if (shift < 1) return 2; // Shift buffer contents (discard everything up to the current token). memmove(cast(void*)it.buffer.ptr, it.token, used); it.yylimit -= shift; it.yycursor -= shift; it.yymarker -= shift; it.token -= shift; // Tag variables need to be shifted like other input positions. The check // for non-null is only needed if some tags are nested inside of alternative // or repetition, so that they can have null value. /*!stags:re2c format = "if (it.@@) it.@@ -= shift;\n"; */ // Fill free space at the end of buffer with new data from file. it.yylimit += fread(it.yylimit, 1, BUFSIZE - used, it.file); it.yylimit[0] = 0; it.eof = it.yylimit < (it.buffer.ptr + BUFSIZE); return 0; } private bool lex(ref Input yyrecord, ref SemVer[] vers) { // Final variables available in semantic actions. /*!svars:re2c format = 'char* @@;'; */ for (;;) { yyrecord.token = yyrecord.yycursor; /*!re2c re2c:api = record; re2c:YYCTYPE = "char"; re2c:YYFILL = "fill(yyrecord) == 0"; re2c:eof = 0; num = [0-9]+; num @t1 "." @t2 num @t3 ("." @t4 num)? [\n] { int major = s2n(yyrecord.token, t1); int minor = s2n(t2, t3); int patch = t4 != null ? s2n(t4, yyrecord.yycursor - 1) : 0; SemVer ver = SemVer(major, minor, patch); vers ~= ver; continue; } $ { return true; } * { return false; } */ } assert(0); } void main() { const char[] fname = "input"; const char[] content = "1.22.333\n' "; SemVer[BUFSIZE] expect = SemVer(1, 22, 333); SemVer[] actual; // Prepare input file: a few times the size of the buffer, containing // strings with zeroes and escaped quotes. FILE* f = fopen(fname.ptr, "w"); for (int i = 0; i < BUFSIZE; ++i) { fwrite(cast(const(void*)) content.ptr, 1, content.length - 2, f); // skip null-terminator } fclose(f); // Initialize lexer state: all pointers are at the end of buffer. Input it; it.file = fopen(fname.ptr, "r"); it.yycursor = it.yymarker = it.token = it.yylimit = it.buffer.ptr + BUFSIZE; it.eof = 0; // Sentinel (at YYLIMIT pointer) is set to zero, which triggers YYFILL. it.yylimit[0] = 0; // Run the lexer. assert(lex(it, actual) && actual == expect); // Cleanup: remove input file. fclose(it.file); remove(fname.ptr); } (capturing groups) . // re2d $INPUT -o $OUTPUT module main; struct SemVer { int major, minor, patch; }; private int s2n(const(char)* s, const(char)* e) { // pre-parsed string to number int n = 0; for (; s < e; ++s) n = n * 10 + (*s - '0'); return n; } private bool lex(const(char)* str, ref SemVer ver) { const(char)* yycursor = str, yymarker; // Final tag variables available in semantic action. /*!svars:re2c format = 'const(char)* @@;\n'; */ // Intermediate tag variables used by the lexer (must be autogenerated). /*!stags:re2c format = 'const(char)* @@;\n'; */ /*!re2c re2c:yyfill:enable = 0; re2c:captvars = 1; re2c:YYCTYPE = "char"; num = [0-9]+; (num) "." (num) ("." num)? [\x00] { ver.major = s2n(yytl1, yytr1); ver.minor = s2n(yytl2, yytr2); ver.patch = yytl3 ? s2n(yytl3 + 1, yytr3) : 0; return true; } * { return false; } */ } void main() { SemVer v; assert(lex("23.34", v) && v.major == 23 && v.minor == 34 && v.patch == 0); assert(lex("1.2.999", v) && v.major == 1 && v.minor == 2 && v.patch == 999); assert(!lex("1.a", v)); } m-tag . (trie) . // re2d $INPUT -o $OUTPUT module main; enum MtagRoot = -1; // An m-tag tree is a way to store histories with an O(1) copy operation. // Histories naturally form a tree, as they have common start and fork at some // point. The tree is stored as an array of pairs (tag value, link to parent). // An m-tag is represented with a single link in the tree (array index). struct Mtag { const(char)* elem; // tag value int pred; // index of the predecessor node or root }; alias MtagTrie = Mtag[]; alias Ver = int[]; private int s2n(const(char)* s, const(char)* e) { // pre-parsed string to number int n = 0; for (; s < e; ++s) n = n * 10 + (*s - '0'); return n; } // Append a single value to an m-tag history. private void add_mtag(ref MtagTrie trie, ref int mtag, const(char)* value) { Mtag m = {value, mtag}; mtag = cast(int)trie.length; trie ~= [m]; } // Recursively unwind tag histories and collect version components. private void unfold(const ref MtagTrie trie, int x, int y, ref Ver ver) { // Reached the root of the m-tag tree, stop recursion. if (x == MtagRoot && y == MtagRoot) return; // Unwind history further. unfold(trie, trie[x].pred, trie[y].pred, ver); // Get tag values. Tag histories must have equal length. assert(x != MtagRoot && y != MtagRoot); const(char)* ex = trie[x].elem, ey = trie[y].elem; if (ex != null && ey != null) { // Both tags are valid pointers, extract component. ver ~= [s2n(ex, ey)]; } else { // Both tags are null (this corresponds to zero repetitions). assert(ex == null && ey == null); } } private bool parse(const(char)* str, ref Ver ver) { const(char)* yycursor = str, yymarker; MtagTrie mt; // Final tag variables available in semantic action. /*!svars:re2c format = "const(char)* @@;"; */ /*!mvars:re2c format = "int @@;"; */ // Intermediate tag variables used by the lexer (must be autogenerated). /*!stags:re2c format = "const(char)* @@ = null;"; */ /*!mtags:re2c format = "int @@ = MtagRoot;"; */ /*!re2c re2c:yyfill:enable = 0; re2c:tags = 1; re2c:YYCTYPE = "char"; re2c:YYMTAGP = "add_mtag(mt, @@, yycursor);"; re2c:YYMTAGN = "add_mtag(mt, @@, null);"; num = [0-9]+; @t1 num @t2 ("." #t3 num #t4)* [\x00] { ver = []; ver ~= [s2n(t1, t2)]; unfold(mt, t3, t4, ver); return true; } * { return false; } */ } void main() { Ver v; assert(parse("1", v) && v == [1]); assert(parse("1.2.3.4.5.6.7", v) && v == [1, 2, 3, 4, 5, 6, 7]); assert(!parse("1.2.", v)); } code point code unit . code point . code unit . code point code unit . (fixed-length) code point code unit . (variable-length) code point code unit . << >> ("any") [^] code point code unit ( code unit * ). code unit : yych code unit YYCTYPE code unit . code point . re2d code point code unit . : code point code unit . : o ASCII ( ). [0-255] code point code unit - . o EBCDIC ( --ebcdic re2c:encoding:ebcdic). [0-255] code point code unit - . o UCS2 ( --ucs2 re2c:encoding:ucs2). [0-0xFFFF] code point code unit - . o UTF8 ( --utf8 re2c:encoding:utf8). . code unit . code point -- code unit . o UTF16 ( --utf16 re2c:encoding:utf16). . code unit . code point -- code unit . o UTF32 ( --utf32 re2c:encoding:utf32). [0-0x10FFFF] code point code unit - . include/unicode_blocks.re include/unicode_categories.re include/unicode_properties.re re2d . --input-encoding . --input-encoding utf8 re2d UTF8 ( --utf8 ). --encoding-policy (code point [0xD800-0xDFFF]) re2d . UTF8 . // re2d $INPUT -o $OUTPUT -8 -i module main; /*!include:re2c "unicode_categories.re" */ private int lex(const(char)* s) { const(char)* yycursor = s, yymarker; /*!re2c re2c:YYCTYPE = "char"; re2c:yyfill:enable = 0; // Simplified "Unicode Identifier and Pattern Syntax" // (see https://unicode.org/reports/tr31) id_start = L | Nl | [$_]; id_continue = id_start | Mn | Mc | Nd | Pc | [\u200D\u05F3]; identifier = id_start id_continue*; identifier { return 0; } * { return 1; } */ } void main() { assert(lex("_") == 0); assert(lex("!!!")==1); } (Include files) re2d /*!include:re2c FILE */ %{include FILE %} !include FILE ; FILE . re2d -I . / re2d #include C/C++ : FILE / . . --depfile . re2d include/ . ( ) re2d . . (definitions.d) enum Result{ OK, FAIL }; /*!re2c number = [1-9][0-9]*; */ // floating-point numbers frac = [0-9]* "." [0-9]+ | [0-9]+ "."; exp = 'e' [+-]? [0-9]+; float = frac exp? | [0-9]+ exp; float { return Result.OK; } // re2d $INPUT -o $OUTPUT -i /*!include:re2c "definitions.d" */ private Result lex(const(char)* s) { const(char)* yycursor = s, yymarker; /*!re2c re2c:YYCTYPE = "char"; re2c:yyfill:enable = 0; * { return Result.FAIL; } number { return Result.OK; } !include "extra_rules.re.inc"; */ } void main() { assert(lex("123") == Result.OK); assert(lex("123.4567") == Result.OK); } re2d --header re2c:header /*!header:re2c:on*/ /*!header:re2c:off*/ %{header:on%} %{header:off%} .re . . re2d --header re2c:header ( stdout) . re2d (translation units) . (tag variables) ( ). // re2d $INPUT -o $OUTPUT -i --header lexer/state.d module main; import core.stdc.stddef; import lexer.state; // the module is generated by re2c /*!header:re2c:on*/ module lexer.state; struct LexerState { const(char)* str, yycursor; /*!stags:re2c format = "const(char)* @@;"; */ }; /*!header:re2c:off*/ private long lex(ref LexerState yyrecord) { const(char)* t; /*!re2c re2c:api = record; re2c:YYCTYPE = "char"; re2c:tags = 1; re2c:yyfill:enable = 0; re2c:header = "lexer/state.d"; [a]* @t [b]* { return t - yyrecord.str; } */ } void main() { const(char)* s = "ab"; LexerState st = {s, s /*!stags:re2c format = ", null"; */}; assert(lex(st) == 1); const(char)* s2 = "aaabbbbbbbb"; LexerState st2 = {s2, s2 /*!stags:re2c format = ", null"; */}; assert(lex(st2) == 3); } /* Generated by re2c */ module lexer.state; struct LexerState { const(char)* str, yycursor; const(char)* yyt1; }; -S, --skeleton re2d re2d C . (lexer) . DFA ( ) re2d lexer : .input DFA .keys . lexer .input . : o re2d ( DFA ). o . o (minimized test cases) ( ). ( ). re2d DFA . : DFA . ( ASCII UTF-8 EBCDIC) DFA . DFA : re2d DFA . . re2d ( ) lexer . 1Gb (re2d ). (Visualization and debug) -D, --emit-dot re2d DFA DOT (dump) . Graphviz DFA . DFA . --dump-nfa --dump-dfa-raw ( ). (SEE ALSO) re2c : http://re2c.org. flex(1) lex(1) quex(http://quex.sourceforge.net). (AUTHORS) re2d Peter Bumbulis (peter@csg.uwaterloo.ca) . Marcus Boerger Dan Nuffer . : Brian Young (bayoung@acm.org) Marcus Boerger Dan Nuffer (nuffer@users.sourceforge.net) Ulya Trofimovich (skvadrik@gmail.com) Serghei Iakovlev Sergei Trofimovich Petr Skocik ligfx raekye PolarGoose. RE2D(1)