code-template ::


      name '=' code-exprs ';'


    | CODE_TEMPLATE ';'


    | '<undefined>' ';'
code-exprs ::


      <EMPTY>


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

A code template is a sequence of string literals, variables, optional elements and lists, or a reference to another code template, or a special value <undefined>. Variables are placeholders that are substituted during code generation phase. List variables are special: when expanding list templates, re2js repeats expressions the right hand side of the column a few times, each time replacing occurrences of the list variable with a value specific to this repetition. Lists have optional bounds (negative values are counted from the end, e.g. -1 means the last element). Conditional names start with a dot. Both conditionals and variables may be either local (specific to the given code template) or global (allowed in all code templates). When re2js reads syntax file, it checks that each code template uses only the variables and conditionals that are allowed in it.

For example, the following code template defines if-then-else construct for a C-like language:

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;

Here branch is a list variable: branch{0} expands to the first branch (which is special, as there is no else part), branch{1:-1} expands to all remaining branches (if any). stmt is also a list variable: [stmt: stmt] is a nested list that expands to a list of statements in the body of the current branch. topindent, indent, dedent and nl are global variables, and .cond is a local conditional (their meaning is described below). This code template could produce the following code:

if x {


    // do something
} else if y {


    // do something else
} else {


    // don't do anything
}

Here's a list of all code templates supported by re2js with their local variables and conditionals. Note that a particular definition may, but does not have to use local variables and conditionals. Any unused code templates should be set to <undefined>.

Here's a list of all global variables that are allowed in syntax files:

Here's a list of all global conditionals that are allowed in syntax files:

// re2js $INPUT -o $OUTPUT
// expects a null-terminated string
function lex(yyinput) {


    let yycursor = 0;


    let count = 0


    loop: while (true) {


    /*!re2c


        re2c:yyfill:enable = 0;


        *      { return -1 }


        [\x00] { return count }


        [ ]+   { continue loop }


        [a-z]+ { count += 1; continue loop }


    */


    }
}
function test(s, n) { if (lex(s) != n) throw "error!"; }
test("\0", 0)
test("one two three\0", 3)
test("f0ur\0", -1)

// re2js $INPUT -o $OUTPUT
// expects a null-terminated string
function lex(yyinput) {


    let yycursor = 0;


    let yylimit = yyinput.length - 1 // terminating null not included


    let count = 0


    loop: while (true) {


    /*!re2c


        re2c:yyfill:enable = 0;


        re2c:eof = 0;


        str = ['] ([^'\\] | [\\][^])* ['];


        *    { return -1 }


        $    { return count }


        [ ]+ { continue loop }


        str  { count += 1; continue loop }


    */


    }
}
function test(s, n) { if (lex(s) != n) throw "error!"; }
test("\0", 0)
test("'qu\0tes' 'are' 'fine: \\'' \0", 3)
test("'unterminated\\'\0", -1)

// re2js $INPUT -o $OUTPUT
/*!max:re2c*/
function lex(yyinput) {


    let yycursor = 0;


    let yylimit = yyinput.length


    let count = 0


    loop: while (true) {


    /*!re2c


        re2c:YYFILL = "return -1";


        str = ['] ([^'\\] | [\\][^])* ['];


        [\x00] {


            // check that it is the sentinel, not some unexpected null


            return (yycursor == yylimit - YYMAXFILL + 1) ? count : -1


        }


        str  { count += 1; continue loop }


        [ ]+ { continue loop }


        *    { return -1 }


    */


    }
}
function test(s, n) {


    let padded_s = s + "\0".repeat(YYMAXFILL)


    if (lex(padded_s) != n) throw "error!"
}
test("", 0)
test("'unterminated\\'", -1)
test("'qu\0tes' 'are' 'fine: \\'' ", 3)
test("'unexpected \0 null", -1)

// re2js $INPUT -o $OUTPUT
// expects a string without terminating null
function lex(str) {


    let cur = 0;


    let lim = str.length


    let count = 0


    loop: while (true) {


    /*!re2c


        re2c:api = generic;


        re2c:YYPEEK = "cur < lim ? str.charCodeAt(cur) : 0";


        re2c:YYSKIP = "cur += 1";


        re2c:yyfill:enable = 0;


        *      { return -1 }


        [\x00] { return count }


        [ ]+   { continue loop }


        [a-z]+ { count += 1; continue loop }


    */


    }
}
function test(s, n) { if (lex(s) != n) throw "error!"; }
test("", 0)
test("one two three", 3)
test("f0ur", -1)

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

// re2js $INPUT -o $OUTPUT
const fs = require('fs')
const BUFSIZE = 4096
const OK = 0
const EOF = 1
const LONG_LEXEME = 2
function fill(st) {


    if (st.eof) return EOF


    // Error: lexeme too long. In real life could reallocate a larger buffer.


    if (st.token < 1) return LONG_LEXEME


    // Shift buffer contents (discard everything up to the current token).


    st.yyinput.copy(st.yyinput, 0, st.token, st.yylimit)


    st.yycursor -= st.token;


    st.yymarker -= st.token;


    st.yylimit -= st.token;


    st.token = 0;


    // Read a new chunk of data from file and append it to `yyinput`.


    let want = BUFSIZE - st.yylimit - 1 // -1 for sentinel


    let nread = fs.readSync(st.file, st.yyinput, st.yylimit, want)


    st.eof = nread < want // end of file?


    st.yylimit += nread


    st.yyinput.writeUInt8(0, st.yylimit) // sentinel


    return OK
}
function lex(yyrecord, count) {


    loop: while (true) {


        yyrecord.token = yyrecord.yycursor


        /*!re2c


            re2c:api = record;


            re2c:YYPEEK = "readUInt8";


            re2c:YYFILL = "fill(yyrecord) == OK";


            re2c:eof = 0;


            str = ['] ([^'\\] | [\\][^])* ['];


            *    { return -1 }


            $    { return count }


            [ ]+ { continue loop }


            str  { count += 1; continue loop }


        */


    }
}
function main() {


    let fname = "input"


    // Create input file.


    let content = "'qu\0tes' 'are' 'fine: \\'' ".repeat(BUFSIZE)


    fs.writeFileSync(fname, content, function(err) { if (err) throw err; })


    // Init lexer state.


    let limit = BUFSIZE - 1 // exclude terminating null


    let st = {


        file: fs.openSync(fname, 'r'),


        yyinput: Buffer.alloc(BUFSIZE),


        yylimit: limit,


        yycursor: limit,


        yymarker: limit,


        token: limit,


        eof: false


    }


    // Run lexer on the prepared file.


    if (lex(st, 0) != 3 * BUFSIZE) { throw "error :[" }


    // Cleanup.


    fs.unlink(fname, function(err){ if (err) throw err; })
}
main()

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

// re2js $INPUT -o $OUTPUT
const fs = require('fs')
const BUFSIZE = 4096
const OK = 0
const EOF = 1
const LONG_LEXEME = 2
/*!max:re2c*/
function fill(st, need) {


    if (st.eof) return EOF


    // Error: lexeme too long. In real life could reallocate a larger buffer.


    if (st.token < need) return LONG_LEXEME


    // Shift buffer contents (discard everything up to the current token).


    st.yyinput.copy(st.yyinput, 0, st.token, st.yylimit)


    st.yycursor -= st.token;


    st.yylimit -= st.token;


    st.token = 0;


    // Read a new chunk of data from file and append it to `yyinput`.


    let want = BUFSIZE - st.yylimit - 1 // -1 for sentinel


    let nread = fs.readSync(st.file, st.yyinput, st.yylimit, want)


    st.yylimit += nread


    if (nread < want) {


        st.eof = true // end of file


        st.yyinput.write("\0".repeat(YYMAXFILL), st.yylimit)


        st.yylimit += YYMAXFILL


    }


    return OK
}
function lex(yyrecord, count) {


    loop: while (true) {


        yyrecord.token = yyrecord.yycursor


        /*!re2c


            re2c:api = record;


            re2c:YYPEEK = "readUInt8";


            re2c:YYFILL = "if (fill(yyrecord, @@) != OK) return -1;";


            str = ['] ([^'\\] | [\\][^])* ['];


            [\x00] {


                // Check that it is the sentinel, not some unexpected null.


                return yyrecord.token == yyrecord.yylimit - YYMAXFILL ? count : -1


            }


            str  { count += 1; continue loop }


            [ ]+ { continue loop }


            *    { return -1 }


        */


    }
}
function main() {


    let fname = "input"


    // Create input file.


    let content = "'qu\0tes' 'are' 'fine: \\'' ".repeat(BUFSIZE)


    fs.writeFileSync(fname, content, function(err) { if (err) throw err; })


    // Init lexer state.


    let limit = BUFSIZE - 1 // exclude terminating null


    let st = {


        file: fs.openSync(fname, 'r'),


        yyinput: Buffer.alloc(BUFSIZE),


        yylimit: limit,


        yycursor: limit,


        token: limit,


        eof: false


    }


    // Run lexer on the prepared file.


    if (lex(st, 0) != 3 * BUFSIZE) { throw "error :[" }


    // Cleanup.


    fs.unlink(fname, function(err){ if (err) throw err; })
}
main()

// re2js $INPUT -o $OUTPUT
/*!re2c // Common re2c definitions shared between all functions.


    re2c:api = record;


    re2c:yyrecord = st;


    re2c:yyfill:enable = 0;
*/
function parse_u32(str) {


    let st = {


        yyinput: str,


        yycursor: 0,


        yymarker: 0


    }


    /*!re2c


        '0b' / [01]        { return parse_bin(st) }


        "0"                { return parse_oct(st) }


        "" / [1-9]         { return parse_dec(st) }


        '0x' / [0-9a-fA-F] { return parse_hex(st) }


        *                  { return null }


    */
}
function parse_bin(st) {


    n = 0


    loop: while (true) {


    /*!re2c


        [01] { n = n * 2 + (st.yyinput.charCodeAt(st.yycursor - 1) - 48); continue loop }


        *    { return n }


    */


    }
}
function parse_oct(st) {


    n = 0


    loop: while (true) {


    /*!re2c


        [0-7] { n = n * 8 + (st.yyinput.charCodeAt(st.yycursor - 1) - 48); continue loop }


        *     { return n }


    */


    }
}
function parse_dec(st) {


    n = 0


    loop: while (true) {


    /*!re2c


        [0-9] { n = n * 10 + (st.yyinput.charCodeAt(st.yycursor - 1) - 48); continue loop }


        *     { return n }


    */


    }
}
function parse_hex(st) {


    n = 0


    loop: while (true) {


    /*!re2c


        [0-9] { n = n * 16 + (st.yyinput.charCodeAt(st.yycursor - 1) - 48); continue loop }


        [a-f] { n = n * 16 + (st.yyinput.charCodeAt(st.yycursor - 1) - 87); continue loop }


        [A-F] { n = n * 16 + (st.yyinput.charCodeAt(st.yycursor - 1) - 55); continue loop }


        *     { return n }


    */


    }
}
function test(s, n) {


    if (parse_u32(s) != n) throw "error!"
}
test("\0", null)
test("1234567890\0", 1234567890)
test("0b1101\0", 13)
test("0x7Fe\0", 2046)
test("0644\0", 420)
test("9999999999\0", 9999999999)

// re2js $INPUT -o $OUTPUT -c
/*!conditions:re2c*/
function parse_u32(yyinput) {


    let yycursor = 0


    let yycond = YYC_INIT


    let n = 0


    loop: while (true) {


    /*!re2c


        re2c:yyfill:enable = 0;


        re2c:indent:top = 2;


        <INIT> '0b' / [01]        :=> BIN


        <INIT> "0"                :=> OCT


        <INIT> "" / [1-9]         :=> DEC


        <INIT> '0x' / [0-9a-fA-F] :=> HEX


        <INIT> * { return null }


        <BIN> [01]  { n = n * 2 + (yyinput.charCodeAt(yycursor - 1) - 48); continue loop }


        <OCT> [0-7] { n = n * 8 + (yyinput.charCodeAt(yycursor - 1) - 48); continue loop }


        <DEC> [0-9] { n = n * 10 + (yyinput.charCodeAt(yycursor - 1) - 48); continue loop }


        <HEX> [0-9] { n = n * 16 + (yyinput.charCodeAt(yycursor - 1) - 48); continue loop }


        <HEX> [a-f] { n = n * 16 + (yyinput.charCodeAt(yycursor - 1) - 87); continue loop }


        <HEX> [A-F] { n = n * 16 + (yyinput.charCodeAt(yycursor - 1) - 55); continue loop }


        <BIN, OCT, DEC, HEX> * { return n }


    */


    }
}
function test(s, n) {


    if (parse_u32(s) != n) throw "error!"
}
test("\0", null)
test("1234567890\0", 1234567890)
test("0b1101\0", 13)
test("0x7Fe\0", 2046)
test("0644\0", 420)
test("9999999999\0", 9999999999)

// re2js $INPUT -o $OUTPUT -f
const fs = require('fs')
// Use a small buffer to cover the case when a lexeme doesn't fit.
// In real world use a larger buffer.
const BUFSIZE = 10
const DEBUG = false
const END = 0
const READY = 1
const WAITING = 2
const BIG_PACKET = 3
const BAD_PACKET = 4
function log() {


    if (DEBUG) console.log.apply(console, arguments)
}
function fill(st) {


    // Error: lexeme too long. In real life could reallocate a larger buffer.


    if (st.token < 1) return BIG_PACKET


    // Shift buffer contents (discard everything up to the current token).


    st.yyinput.copy(st.yyinput, 0, st.token, st.yylimit)


    st.yycursor -= st.token;


    st.yymarker -= st.token;


    st.yylimit -= st.token;


    st.token = 0;


    // Read a new chunk of data from file and append it to `yyinput`.


    let want = BUFSIZE - st.yylimit - 1 // -1 for sentinel


    let nread = fs.readSync(st.file, st.yyinput, st.yylimit, want)


    st.yylimit += nread


    st.yyinput.writeUInt8(0, st.yylimit) // sentinel


    return READY
}
function lex(yyrecord) {


    loop: while (true) {


        yyrecord.token = yyrecord.yycursor


        /*!re2c


            re2c:api = record;


            re2c:YYPEEK = "readUInt8";


            re2c:YYFILL = "return WAITING";


            re2c:eof = 0;


            packet = [a-z]+[;];


            *      { return BAD_PACKET }


            $      { return END }


            packet { yyrecord.received += 1; continue loop }


        */


    }
}
function test(packets, expect) {


    // Emulate a "pipe" by opening the same file for reading and writing.


    let fname = "input"


    let fw = fs.openSync(fname, 'w');


    let fr = fs.openSync(fname, 'r');


    // Init lexer state.


    let limit = BUFSIZE - 1 // exclude terminating null


    let st = {


        file: fr,


        yyinput: Buffer.alloc(BUFSIZE),


        yylimit: limit,


        yycursor: limit,


        yymarker: limit,


        token: limit,


        yystate: -1,


        received: 0


    }


    // 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.


    let send = 0


    let status


    loop: while (true) {


        status = lex(st)


        if (status == END) {


            log("done: got", st.received, "packets")


            break loop


        } else if (status == WAITING) {


            log("waiting...");


            if (send < packets.length) {


                log("sent packet", send, packets[send])


                fs.writeFileSync(fw, packets[send])


                send += 1


            }


            status = fill(st)


            log("queue:", st.yyinput.toString())


            if (status == BIG_PACKET) {


                log("error: packet too big")


                break loop


            }


            if (status != READY) throw "expected READY"


        } else {


            if (status != BAD_PACKET) throw "expected BAD_PACKET"


            log("error: ill-formed packet")


            break loop


        }


    }


    // Check results.


    if (status != expect) throw "unexpected status"


    if (status == END && st.received != send) "unexpected packet count"


    // Cleanup.


    fs.unlinkSync(fname, function(err){ if (err) throw err; })
}
function main() {


    test([], END)


    test(["zero;", "one;", "two;", "three;", "four;"], END)


    test(["zer0;"], BAD_PACKET)


    test(["goooooooooogle;"], BIG_PACKET)
}
main()

// re2js $INPUT -o $OUTPUT
// 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.
const COLOR = 1
const FISH = 2
const DUNNO = 3
/*!rules:re2c:colors


    *                            { throw "ah" }


    "red" | "salmon" | "magenta" { return COLOR }
*/
/*!rules:re2c:fish


    *                            { throw "oh" }


    "haddock" | "salmon" | "eel" { return FISH }
*/
function lex(yyinput) {


    let yycursor = 0


    /*!re2c


        re2c:yyfill:enable = 0;


        !use:fish;


        !use:colors;


        * { return DUNNO } // overrides inherited '*' rules


    */
}
function test(s, n) { if (lex(s) != n) throw "error!"; }
test("salmon", FISH)
test("what?", DUNNO)

// re2js $INPUT -o $OUTPUT --input-encoding utf8
// 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;


    re2c:YYPEEK = "at";


    "∀x ∃y" { return yycursor }


    *       { return null }
*/
function lex_utf8(yyinput) {


    let yycursor = 0


    /*!use:re2c


        re2c:encoding:utf8 = 1;


    */
}
function lex_utf32(yyinput) {


    let yycursor = 0


    /*!use:re2c


        re2c:encoding:utf32 = 1;


    */
}
function test(f, s) {


    if (f(s) != s.length) throw "error!"
}
test(lex_utf8, [0xe2, 0x88, 0x80, 0x78, 0x20, 0xe2, 0x88, 0x83, 0x79])
test(lex_utf32, [0x2200, 0x78, 0x20, 0x2203, 0x79])

// re2js $INPUT -o $OUTPUT
const assert = require('assert');
function parse(yyinput) {


    let yycursor = 0


    // Final tag variables available in semantic action.


    /*!svars:re2c format = "let @@\n"; */


    // Intermediate tag variables used by the lexer (must be autogenerated).


    /*!stags:re2c format = "let @@\n"; */


    /*!re2c


        re2c:yyfill:enable = 0;


        re2c:tags = 1;


        num = [0-9]+;


        @t1 num @t2 "." @t3 num @t4 ("." @t5 num)? [\x00] {


            return {


                major: Number(yyinput.substring(t1, t2)),


                minor: Number(yyinput.substring(t3, t4)),


                patch: t5 == -1 ? 0 : Number(yyinput.substring(t5, yycursor - 1))


            }


        }


        * { return null }


    */
}
assert.deepEqual(parse("23.34\0"), {major: 23, minor: 34, patch: 0})
assert.deepEqual(parse("1.2.99999\0"), {major: 1, minor: 2, patch: 99999})
assert.deepEqual(parse("1.a\0"), null)

// re2js $INPUT -o $OUTPUT
const assert = require('assert');
const fs = require('fs')
const BUFSIZE = 4096
const OK = 0
const EOF = 1
const LONG_LEXEME = 2
function fill(st) {


    if (st.eof) return EOF


    // Error: lexeme too long. In real life could reallocate a larger buffer.


    if (st.token < 1) return LONG_LEXEME


    // Shift buffer contents (discard everything up to the current token).


    st.yyinput.copy(st.yyinput, 0, st.token, st.yylimit)


    st.yycursor -= st.token;


    st.yymarker -= st.token;


    st.yylimit -= st.token;


    /*!stags:re2c format = "if (st.@@ != -1) st.@@ -= st.token\n"; */


    st.token = 0;


    // Read a new chunk of data from file and append it to `yyinput`.


    let want = BUFSIZE - st.yylimit - 1 // -1 for sentinel


    let nread = fs.readSync(st.file, st.yyinput, st.yylimit, want)


    st.eof = nread < want // end of file?


    st.yylimit += nread


    st.yyinput.writeUInt8(0, st.yylimit) // sentinel


    return OK
}
function lex(st) {


    let vers = []


    loop: while (true) {


        st.token = st.yycursor


        // Final tag variables available in semantic action.


        /*!svars:re2c format = "let @@\n"; */


        /*!re2c


            re2c:api = record;


            re2c:yyrecord = st;


            re2c:YYPEEK = "readUInt8";


            re2c:YYFILL = "fill(st) == OK";


            re2c:eof = 0;


            re2c:tags = 1;


            num = [0-9]+;


            num @t1 "." @t2 num @t3 ("." @t4 num)? [\n] {


                vers.push({


                    major: Number(st.yyinput.subarray(st.token, t1)),


                    minor: Number(st.yyinput.subarray(t2, t3)),


                    patch: t4 == -1 ? 0 : Number(st.yyinput.subarray(t4, st.yycursor - 1))


                })


                continue loop


            }


            $ { return vers }


            * { return null }


        */


    }
}
function main() {


    let fname = "input"


    // Create input file.


    let content = "1.22.333\n".repeat(BUFSIZE)


    fs.writeFileSync(fname, content, function(err) { if (err) throw err; })


    // Init lexer state.


    let limit = BUFSIZE - 1 // exclude terminating null


    let st = {


        file: fs.openSync(fname, 'r'),


        yyinput: Buffer.alloc(BUFSIZE),


        yylimit: limit,


        yycursor: limit,


        yymarker: limit,


        token: limit,


        // Intermediate tag variables used by the lexer (must be autogenerated).


        /*!stags:re2c format = "@@: -1,\n"; */


        eof: false


    }


    // Run lexer on the prepared file.


    assert.deepEqual(lex(st), Array(BUFSIZE).fill({major: 1, minor: 22, patch: 333}))


    // Cleanup.


    fs.unlink(fname, function(err){ if (err) throw err; })
}
main()

// re2js $INPUT -o $OUTPUT
const assert = require('assert');
function parse(yyinput) {


    let yycursor = 0


    // Final tag variables available in semantic action.


    /*!svars:re2c format = "let @@\n"; */


    // Intermediate tag variables used by the lexer (must be autogenerated).


    /*!stags:re2c format = "let @@\n"; */


    /*!re2c


        re2c:yyfill:enable = 0;


        re2c:captvars = 1;


        num = [0-9]+;


        (num) "." (num) ("." num)? [\x00] {


            return {


                major: Number(yyinput.substring(yytl1, yytr1)),


                minor: Number(yyinput.substring(yytl2, yytr2)),


                patch: yytl3 == -1 ? 0 : Number(yyinput.substring(yytl3 + 1, yytr3))


            }


        }


        * { return null }


    */
}
assert.deepEqual(parse("23.34\0"), {major: 23, minor: 34, patch: 0})
assert.deepEqual(parse("1.2.99999\0"), {major: 1, minor: 2, patch: 99999})
assert.deepEqual(parse("1.a\0"), null)

// re2js $INPUT -o $OUTPUT
const assert = require('assert')
function parse(yyinput) {


    let yycursor = 0


    // Final tag variables available in semantic action.


    /*!svars:re2c format = "let @@\n"; */


    /*!mvars:re2c format = "let @@\n"; */


    // Intermediate tag variables used by the lexer (must be autogenerated).


    /*!stags:re2c format = "let @@\n"; */


    /*!mtags:re2c format = "let @@ = []\n"; */


    /*!re2c


        re2c:YYMTAGP = "@@.push(yycursor)";


        re2c:YYMTAGN = ""; // do nothing


        re2c:yyfill:enable = 0;


        re2c:tags = 1;


        num = [0-9]+;


        @t1 num @t2 ("." #t3 num #t4)* [\x00] {


            let vers = [Number(yyinput.substring(t1, t2))]


            for (let i = 0; i < t3.length; ++i) {


                vers.push(Number(yyinput.substring(t3[i], t4[i])))


            }


            return vers


        }


        * { return null }


    */
}
assert.deepEqual(parse("1\0"), [1])
assert.deepEqual(parse("1.2.3.4.5.6.7\0"), [1, 2, 3, 4, 5, 6, 7])
assert.deepEqual(parse("1.2.\0"), null)

// re2js $INPUT -o $OUTPUT --utf8 -s
/*!include:re2c "unicode_categories.re" */
function lex(yyinput) {


    let yycursor = 0


    /*!re2c


        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 true }


        *          { return false }


    */
}
if (!lex("_Ыдентификатор\0")) throw "error!"

const INT = 1
const FLOAT = 2
const NAN = 3
/*!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 FLOAT }

// re2js $INPUT -o $OUTPUT
/*!include:re2c "definitions.js" */
function lex(yyinput) {


    let yycursor = 0


    /*!re2c


        re2c:yyfill:enable = 0;


        *      { return NAN }


        number { return INT }


        !include "extra_rules.re.inc";


    */
}
function test(s, n) {


    if (lex(s) != n) throw "error!"
}
test("123\0", INT)
test("123.4567\0", FLOAT)

// re2js $INPUT -o $OUTPUT --header lexer/state.js
let state = require('./lexer/state.js');
/*!header:re2c:on*/
exports.mk_state = function(str) {


    return {


        yyinput: str,


        /*!stags:re2c format = "@@: 0,\n"; */


        yycursor: 0


    }
}
/*!header:re2c:off*/
function lex(yyrecord) {


    let t


    /*!re2c


        re2c:api = record;


        re2c:tags = 1;


        re2c:yyfill:enable = 0;


        re2c:header = "lexer/state.js";


        [a]* @t [b]* { return t }


    */
}
if (lex(state.mk_state("ab\0")) != 1) {


    throw "error!"
}

// Generated by re2c
exports.mk_state = function(str) {


    return {


        yyinput: str,


        yyt1: 0,


        yycursor: 0


    }
}