parol 4.5.0

// ---------------------------------------------------------
// This file was generated by parol.
// Do not edit this file manually.
// Changes will be overwritten on the next build.
// ---------------------------------------------------------

use parol_runtime::{
    ParolError, ParseTree, TokenStream,
    parser::{
        LLKParser, LookaheadDFA, ParseType, Production, Trans, parse_tree_type::TreeConstruct,
    },
};
use scnr2::scanner;
use std::path::Path;

use crate::parser::parol_grammar::ParolGrammar;
use crate::parser::parol_grammar_trait::ParolGrammarAuto;

pub const TERMINAL_NAMES: &[&str; 47] = &[
    /*  0 */ "EndOfInput",
    /*  1 */ "Newline",
    /*  2 */ "Whitespace",
    /*  3 */ "LineComment",
    /*  4 */ "BlockComment",
    /*  5 */ "PercentStart",
    /*  6 */ "PercentTitle",
    /*  7 */ "PercentComment",
    /*  8 */ "PercentUserUnderscoreType",
    /*  9 */ "Equ",
    /* 10 */ "PercentNtUnderscoreType",
    /* 11 */ "PercentTUnderscoreType",
    /* 12 */ "PercentGrammarUnderscoreType",
    /* 13 */ "PercentLineUnderscoreComment",
    /* 14 */ "PercentBlockUnderscoreComment",
    /* 15 */ "PercentAutoUnderscoreNewlineUnderscoreOff",
    /* 16 */ "PercentAutoUnderscoreWsUnderscoreOff",
    /* 17 */ "PercentSkip",
    /* 18 */ "PercentOn",
    /* 19 */ "PercentAllowUnderscoreUnmatched",
    /* 20 */ "PercentEnter",
    /* 21 */ "PercentPush",
    /* 22 */ "PercentPop",
    /* 23 */ "PercentPercent",
    /* 24 */ "DoubleColon",
    /* 25 */ "Colon",
    /* 26 */ "Semicolon",
    /* 27 */ "Or",
    /* 28 */ "LT",
    /* 29 */ "GT",
    /* 30 */ "String",
    /* 31 */ "RawString",
    /* 32 */ "Regex",
    /* 33 */ "LParen",
    /* 34 */ "RParen",
    /* 35 */ "LBracket",
    /* 36 */ "RBracket",
    /* 37 */ "LBrace",
    /* 38 */ "RBrace",
    /* 39 */ "Identifier",
    /* 40 */ "PercentScanner",
    /* 41 */ "Comma",
    /* 42 */ "At",
    /* 43 */ "CutOperator",
    /* 44 */ "PositiveLookahead",
    /* 45 */ "NegativeLookahead",
    /* 46 */ "Error",
];

scanner! {
    ParolGrammarScanner {
        mode INITIAL {
            token r"\r\n|\r|\n" => 1; // "Newline"
            token r"[\s--\r\n]+" => 2; // "Whitespace"
            token r"//.*(\r\n|\r|\n)?" => 3; // "LineComment"
            token r"/\*/?([^/]|[^*]/)*\*/" => 4; // "BlockComment"
            token r"%start" => 5; // "PercentStart"
            token r"%title" => 6; // "PercentTitle"
            token r"%comment" => 7; // "PercentComment"
            token r"%user_type" => 8; // "PercentUserUnderscoreType"
            token r"=" => 9; // "Equ"
            token r"%nt_type" => 10; // "PercentNtUnderscoreType"
            token r"%t_type" => 11; // "PercentTUnderscoreType"
            token r"%grammar_type" => 12; // "PercentGrammarUnderscoreType"
            token r"%line_comment" => 13; // "PercentLineUnderscoreComment"
            token r"%block_comment" => 14; // "PercentBlockUnderscoreComment"
            token r"%auto_newline_off" => 15; // "PercentAutoUnderscoreNewlineUnderscoreOff"
            token r"%auto_ws_off" => 16; // "PercentAutoUnderscoreWsUnderscoreOff"
            token r"%skip" => 17; // "PercentSkip"
            token r"%on" => 18; // "PercentOn"
            token r"%allow_unmatched" => 19; // "PercentAllowUnderscoreUnmatched"
            token r"%enter" => 20; // "PercentEnter"
            token r"%push" => 21; // "PercentPush"
            token r"%pop" => 22; // "PercentPop"
            token r"%%" => 23; // "PercentPercent"
            token r"::" => 24; // "DoubleColon"
            token r":" => 25; // "Colon"
            token r";" => 26; // "Semicolon"
            token r"\|" => 27; // "Or"
            token r"<" => 28; // "LT"
            token r">" => 29; // "GT"
            token r#""(\\.|[^"])*""# => 30; // "String"
            token r"'(\\.|[^'])*'" => 31; // "RawString"
            token r"/(\\.|[^\/])*/" => 32; // "Regex"
            token r"\(" => 33; // "LParen"
            token r"\)" => 34; // "RParen"
            token r"\[" => 35; // "LBracket"
            token r"\]" => 36; // "RBracket"
            token r"\{" => 37; // "LBrace"
            token r"\}" => 38; // "RBrace"
            token r"[a-zA-Z_][a-zA-Z0-9_]*" => 39; // "Identifier"
            token r"%scanner" => 40; // "PercentScanner"
            token r"," => 41; // "Comma"
            token r"@" => 42; // "At"
            token r"\^" => 43; // "CutOperator"
            token r"\?=" => 44; // "PositiveLookahead"
            token r"\?!" => 45; // "NegativeLookahead"
            token r"." => 46; // "Error"
        }
    }
}

const MAX_K: usize = 1;
pub const SKIP_TOKENS_BY_SCANNER_STATE: &[&[parol_runtime::TerminalIndex]; 1] = &[&[]];

pub const NON_TERMINALS: &[&str; 49] = &[
    /*  0 */ "ASTControl",
    /*  1 */ "ASTControlOpt",
    /*  2 */ "Alternation",
    /*  3 */ "AlternationList",
    /*  4 */ "Alternations",
    /*  5 */ "AlternationsList",
    /*  6 */ "CutOperator",
    /*  7 */ "Declaration",
    /*  8 */ "DoubleColon",
    /*  9 */ "Factor",
    /* 10 */ "GrammarDefinition",
    /* 11 */ "GrammarDefinitionList",
    /* 12 */ "Group",
    /* 13 */ "Identifier",
    /* 14 */ "IdentifierList",
    /* 15 */ "IdentifierListList",
    /* 16 */ "LookAhead",
    /* 17 */ "LookAheadGroup",
    /* 18 */ "MemberName",
    /* 19 */ "NegativeLookahead",
    /* 20 */ "NonTerminal",
    /* 21 */ "NonTerminalOpt",
    /* 22 */ "Optional",
    /* 23 */ "Parol",
    /* 24 */ "PositiveLookahead",
    /* 25 */ "Production",
    /* 26 */ "Prolog",
    /* 27 */ "PrologList",
    /* 28 */ "PrologList0",
    /* 29 */ "RawString",
    /* 30 */ "Regex",
    /* 31 */ "Repeat",
    /* 32 */ "ScannerDirectives",
    /* 33 */ "ScannerState",
    /* 34 */ "ScannerStateDirectives",
    /* 35 */ "ScannerStateList",
    /* 36 */ "SimpleToken",
    /* 37 */ "SimpleTokenOpt",
    /* 38 */ "StartDeclaration",
    /* 39 */ "String",
    /* 40 */ "Symbol",
    /* 41 */ "TokenExpression",
    /* 42 */ "TokenExpressionOpt",
    /* 43 */ "TokenLiteral",
    /* 44 */ "TokenWithStates",
    /* 45 */ "TokenWithStatesOpt",
    /* 46 */ "UserTypeDeclaration",
    /* 47 */ "UserTypeName",
    /* 48 */ "UserTypeNameList",
];

pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 49] = &[
    /* 0 - "ASTControl" */
    LookaheadDFA {
        prod0: -1,
        transitions: &[
            Trans(0, 25, 3, 72),
            Trans(0, 42, 2, 71),
            Trans(0, 43, 1, 70),
        ],
        k: 1,
    },
    /* 1 - "ASTControlOpt" */
    LookaheadDFA {
        prod0: -1,
        transitions: &[
            Trans(0, 25, 1, 73),
            Trans(0, 26, 2, 74),
            Trans(0, 27, 2, 74),
            Trans(0, 28, 2, 74),
            Trans(0, 30, 2, 74),
            Trans(0, 31, 2, 74),
            Trans(0, 32, 2, 74),
            Trans(0, 33, 2, 74),
            Trans(0, 34, 2, 74),
            Trans(0, 35, 2, 74),
            Trans(0, 36, 2, 74),
            Trans(0, 37, 2, 74),
            Trans(0, 38, 2, 74),
            Trans(0, 39, 2, 74),
        ],
        k: 1,
    },
    /* 2 - "Alternation" */
    LookaheadDFA {
        prod0: 32,
        transitions: &[],
        k: 0,
    },
    /* 3 - "AlternationList" */
    LookaheadDFA {
        prod0: -1,
        transitions: &[
            Trans(0, 26, 2, 34),
            Trans(0, 27, 2, 34),
            Trans(0, 28, 1, 33),
            Trans(0, 30, 1, 33),
            Trans(0, 31, 1, 33),
            Trans(0, 32, 1, 33),
            Trans(0, 33, 1, 33),
            Trans(0, 34, 2, 34),
            Trans(0, 35, 1, 33),
            Trans(0, 36, 2, 34),
            Trans(0, 37, 1, 33),
            Trans(0, 38, 2, 34),
            Trans(0, 39, 1, 33),
        ],
        k: 1,
    },
    /* 4 - "Alternations" */
    LookaheadDFA {
        prod0: 29,
        transitions: &[],
        k: 0,
    },
    /* 5 - "AlternationsList" */
    LookaheadDFA {
        prod0: -1,
        transitions: &[
            Trans(0, 26, 2, 31),
            Trans(0, 27, 1, 30),
            Trans(0, 34, 2, 31),
            Trans(0, 36, 2, 31),
            Trans(0, 38, 2, 31),
        ],
        k: 1,
    },
    /* 6 - "CutOperator" */
    LookaheadDFA {
        prod0: 76,
        transitions: &[],
        k: 0,
    },
    /* 7 - "Declaration" */
    LookaheadDFA {
        prod0: -1,
        transitions: &[
            Trans(0, 6, 1, 7),
            Trans(0, 7, 2, 8),
            Trans(0, 8, 3, 9),
            Trans(0, 10, 4, 10),
            Trans(0, 11, 5, 11),
            Trans(0, 12, 6, 12),
            Trans(0, 13, 7, 13),
            Trans(0, 14, 7, 13),
            Trans(0, 15, 7, 13),
            Trans(0, 16, 7, 13),
            Trans(0, 17, 7, 13),
            Trans(0, 18, 7, 13),
            Trans(0, 19, 7, 13),
        ],
        k: 1,
    },
    /* 8 - "DoubleColon" */
    LookaheadDFA {
        prod0: 27,
        transitions: &[],
        k: 0,
    },
    /* 9 - "Factor" */
    LookaheadDFA {
        prod0: -1,
        transitions: &[
            Trans(0, 28, 4, 38),
            Trans(0, 30, 4, 38),
            Trans(0, 31, 4, 38),
            Trans(0, 32, 4, 38),
            Trans(0, 33, 1, 35),
            Trans(0, 35, 3, 37),
            Trans(0, 37, 2, 36),
            Trans(0, 39, 4, 38),
        ],
        k: 1,
    },
    /* 10 - "GrammarDefinition" */
    LookaheadDFA {
        prod0: 24,
        transitions: &[],
        k: 0,
    },
    /* 11 - "GrammarDefinitionList" */
    LookaheadDFA {
        prod0: -1,
        transitions: &[Trans(0, 0, 2, 26), Trans(0, 39, 1, 25)],
        k: 1,
    },
    /* 12 - "Group" */
    LookaheadDFA {
        prod0: 57,
        transitions: &[],
        k: 0,
    },
    /* 13 - "Identifier" */
    LookaheadDFA {
        prod0: 63,
        transitions: &[],
        k: 0,
    },
    /* 14 - "IdentifierList" */
    LookaheadDFA {
        prod0: 67,
        transitions: &[],
        k: 0,
    },
    /* 15 - "IdentifierListList" */
    LookaheadDFA {
        prod0: -1,
        transitions: &[
            Trans(0, 6, 2, 69),
            Trans(0, 7, 2, 69),
            Trans(0, 8, 2, 69),
            Trans(0, 10, 2, 69),
            Trans(0, 11, 2, 69),
            Trans(0, 12, 2, 69),
            Trans(0, 13, 2, 69),
            Trans(0, 14, 2, 69),
            Trans(0, 15, 2, 69),
            Trans(0, 16, 2, 69),
            Trans(0, 17, 2, 69),
            Trans(0, 18, 2, 69),
            Trans(0, 19, 2, 69),
            Trans(0, 20, 2, 69),
            Trans(0, 21, 2, 69),
            Trans(0, 22, 2, 69),
            Trans(0, 23, 2, 69),
            Trans(0, 29, 2, 69),
            Trans(0, 38, 2, 69),
            Trans(0, 40, 2, 69),
            Trans(0, 41, 1, 68),
        ],
        k: 1,
    },
    /* 16 - "LookAhead" */
    LookaheadDFA {
        prod0: 81,
        transitions: &[],
        k: 0,
    },
    /* 17 - "LookAheadGroup" */
    LookaheadDFA {
        prod0: -1,
        transitions: &[Trans(0, 44, 1, 82), Trans(0, 45, 2, 83)],
        k: 1,
    },
    /* 18 - "MemberName" */
    LookaheadDFA {
        prod0: 75,
        transitions: &[],
        k: 0,
    },
    /* 19 - "NegativeLookahead" */
    LookaheadDFA {
        prod0: 85,
        transitions: &[],
        k: 0,
    },
    /* 20 - "NonTerminal" */
    LookaheadDFA {
        prod0: 60,
        transitions: &[],
        k: 0,
    },
    /* 21 - "NonTerminalOpt" */
    LookaheadDFA {
        prod0: -1,
        transitions: &[
            Trans(0, 25, 1, 61),
            Trans(0, 26, 2, 62),
            Trans(0, 27, 2, 62),
            Trans(0, 28, 2, 62),
            Trans(0, 30, 2, 62),
            Trans(0, 31, 2, 62),
            Trans(0, 32, 2, 62),
            Trans(0, 33, 2, 62),
            Trans(0, 34, 2, 62),
            Trans(0, 35, 2, 62),
            Trans(0, 36, 2, 62),
            Trans(0, 37, 2, 62),
            Trans(0, 38, 2, 62),
            Trans(0, 39, 2, 62),
            Trans(0, 42, 1, 61),
            Trans(0, 43, 1, 61),
        ],
        k: 1,
    },
    /* 22 - "Optional" */
    LookaheadDFA {
        prod0: 58,
        transitions: &[],
        k: 0,
    },
    /* 23 - "Parol" */
    LookaheadDFA {
        prod0: 0,
        transitions: &[],
        k: 0,
    },
    /* 24 - "PositiveLookahead" */
    LookaheadDFA {
        prod0: 84,
        transitions: &[],
        k: 0,
    },
    /* 25 - "Production" */
    LookaheadDFA {
        prod0: 28,
        transitions: &[],
        k: 0,
    },
    /* 26 - "Prolog" */
    LookaheadDFA {
        prod0: 1,
        transitions: &[],
        k: 0,
    },
    /* 27 - "PrologList" */
    LookaheadDFA {
        prod0: -1,
        transitions: &[
            Trans(0, 6, 1, 4),
            Trans(0, 7, 1, 4),
            Trans(0, 8, 1, 4),
            Trans(0, 10, 1, 4),
            Trans(0, 11, 1, 4),
            Trans(0, 12, 1, 4),
            Trans(0, 13, 1, 4),
            Trans(0, 14, 1, 4),
            Trans(0, 15, 1, 4),
            Trans(0, 16, 1, 4),
            Trans(0, 17, 1, 4),
            Trans(0, 18, 1, 4),
            Trans(0, 19, 1, 4),
            Trans(0, 23, 2, 5),
            Trans(0, 40, 2, 5),
        ],
        k: 1,
    },
    /* 28 - "PrologList0" */
    LookaheadDFA {
        prod0: -1,
        transitions: &[Trans(0, 23, 2, 3), Trans(0, 40, 1, 2)],
        k: 1,
    },
    /* 29 - "RawString" */
    LookaheadDFA {
        prod0: 55,
        transitions: &[],
        k: 0,
    },
    /* 30 - "Regex" */
    LookaheadDFA {
        prod0: 56,
        transitions: &[],
        k: 0,
    },
    /* 31 - "Repeat" */
    LookaheadDFA {
        prod0: 59,
        transitions: &[],
        k: 0,
    },
    /* 32 - "ScannerDirectives" */
    LookaheadDFA {
        prod0: -1,
        transitions: &[
            Trans(0, 13, 1, 14),
            Trans(0, 14, 2, 15),
            Trans(0, 15, 3, 16),
            Trans(0, 16, 4, 17),
            Trans(0, 17, 5, 18),
            Trans(0, 18, 6, 19),
            Trans(0, 19, 7, 20),
        ],
        k: 1,
    },
    /* 33 - "ScannerState" */
    LookaheadDFA {
        prod0: 64,
        transitions: &[],
        k: 0,
    },
    /* 34 - "ScannerStateDirectives" */
    LookaheadDFA {
        prod0: -1,
        transitions: &[
            Trans(0, 20, 1, 21),
            Trans(0, 21, 2, 22),
            Trans(0, 22, 3, 23),
        ],
        k: 1,
    },
    /* 35 - "ScannerStateList" */
    LookaheadDFA {
        prod0: -1,
        transitions: &[
            Trans(0, 13, 1, 65),
            Trans(0, 14, 1, 65),
            Trans(0, 15, 1, 65),
            Trans(0, 16, 1, 65),
            Trans(0, 17, 1, 65),
            Trans(0, 18, 1, 65),
            Trans(0, 19, 1, 65),
            Trans(0, 38, 2, 66),
        ],
        k: 1,
    },
    /* 36 - "SimpleToken" */
    LookaheadDFA {
        prod0: 48,
        transitions: &[],
        k: 0,
    },
    /* 37 - "SimpleTokenOpt" */
    LookaheadDFA {
        prod0: -1,
        transitions: &[
            Trans(0, 25, 1, 49),
            Trans(0, 26, 2, 50),
            Trans(0, 27, 2, 50),
            Trans(0, 28, 2, 50),
            Trans(0, 30, 2, 50),
            Trans(0, 31, 2, 50),
            Trans(0, 32, 2, 50),
            Trans(0, 33, 2, 50),
            Trans(0, 34, 2, 50),
            Trans(0, 35, 2, 50),
            Trans(0, 36, 2, 50),
            Trans(0, 37, 2, 50),
            Trans(0, 38, 2, 50),
            Trans(0, 39, 2, 50),
            Trans(0, 42, 1, 49),
            Trans(0, 43, 1, 49),
        ],
        k: 1,
    },
    /* 38 - "StartDeclaration" */
    LookaheadDFA {
        prod0: 6,
        transitions: &[],
        k: 0,
    },
    /* 39 - "String" */
    LookaheadDFA {
        prod0: 54,
        transitions: &[],
        k: 0,
    },
    /* 40 - "Symbol" */
    LookaheadDFA {
        prod0: -1,
        transitions: &[
            Trans(0, 28, 3, 41),
            Trans(0, 30, 2, 40),
            Trans(0, 31, 2, 40),
            Trans(0, 32, 2, 40),
            Trans(0, 39, 1, 39),
        ],
        k: 1,
    },
    /* 41 - "TokenExpression" */
    LookaheadDFA {
        prod0: 45,
        transitions: &[],
        k: 0,
    },
    /* 42 - "TokenExpressionOpt" */
    LookaheadDFA {
        prod0: -1,
        transitions: &[
            Trans(0, 25, 2, 47),
            Trans(0, 26, 2, 47),
            Trans(0, 27, 2, 47),
            Trans(0, 28, 2, 47),
            Trans(0, 30, 2, 47),
            Trans(0, 31, 2, 47),
            Trans(0, 32, 2, 47),
            Trans(0, 33, 2, 47),
            Trans(0, 34, 2, 47),
            Trans(0, 35, 2, 47),
            Trans(0, 36, 2, 47),
            Trans(0, 37, 2, 47),
            Trans(0, 38, 2, 47),
            Trans(0, 39, 2, 47),
            Trans(0, 42, 2, 47),
            Trans(0, 43, 2, 47),
            Trans(0, 44, 1, 46),
            Trans(0, 45, 1, 46),
        ],
        k: 1,
    },
    /* 43 - "TokenLiteral" */
    LookaheadDFA {
        prod0: -1,
        transitions: &[
            Trans(0, 30, 1, 42),
            Trans(0, 31, 2, 43),
            Trans(0, 32, 3, 44),
        ],
        k: 1,
    },
    /* 44 - "TokenWithStates" */
    LookaheadDFA {
        prod0: 51,
        transitions: &[],
        k: 0,
    },
    /* 45 - "TokenWithStatesOpt" */
    LookaheadDFA {
        prod0: -1,
        transitions: &[
            Trans(0, 25, 1, 52),
            Trans(0, 26, 2, 53),
            Trans(0, 27, 2, 53),
            Trans(0, 28, 2, 53),
            Trans(0, 30, 2, 53),
            Trans(0, 31, 2, 53),
            Trans(0, 32, 2, 53),
            Trans(0, 33, 2, 53),
            Trans(0, 34, 2, 53),
            Trans(0, 35, 2, 53),
            Trans(0, 36, 2, 53),
            Trans(0, 37, 2, 53),
            Trans(0, 38, 2, 53),
            Trans(0, 39, 2, 53),
            Trans(0, 42, 1, 52),
            Trans(0, 43, 1, 52),
        ],
        k: 1,
    },
    /* 46 - "UserTypeDeclaration" */
    LookaheadDFA {
        prod0: 77,
        transitions: &[],
        k: 0,
    },
    /* 47 - "UserTypeName" */
    LookaheadDFA {
        prod0: 78,
        transitions: &[],
        k: 0,
    },
    /* 48 - "UserTypeNameList" */
    LookaheadDFA {
        prod0: -1,
        transitions: &[
            Trans(0, 6, 2, 80),
            Trans(0, 7, 2, 80),
            Trans(0, 8, 2, 80),
            Trans(0, 10, 2, 80),
            Trans(0, 11, 2, 80),
            Trans(0, 12, 2, 80),
            Trans(0, 13, 2, 80),
            Trans(0, 14, 2, 80),
            Trans(0, 15, 2, 80),
            Trans(0, 16, 2, 80),
            Trans(0, 17, 2, 80),
            Trans(0, 18, 2, 80),
            Trans(0, 19, 2, 80),
            Trans(0, 23, 2, 80),
            Trans(0, 24, 1, 79),
            Trans(0, 26, 2, 80),
            Trans(0, 27, 2, 80),
            Trans(0, 28, 2, 80),
            Trans(0, 30, 2, 80),
            Trans(0, 31, 2, 80),
            Trans(0, 32, 2, 80),
            Trans(0, 33, 2, 80),
            Trans(0, 34, 2, 80),
            Trans(0, 35, 2, 80),
            Trans(0, 36, 2, 80),
            Trans(0, 37, 2, 80),
            Trans(0, 38, 2, 80),
            Trans(0, 39, 2, 80),
            Trans(0, 40, 2, 80),
        ],
        k: 1,
    },
];

pub const PRODUCTIONS: &[Production; 86] = &[
    // 0 - Parol: Prolog GrammarDefinition;
    Production {
        lhs: 23,
        production: &[ParseType::N(10), ParseType::N(26)],
    },
    // 1 - Prolog: StartDeclaration PrologList /* Vec */ PrologList0 /* Vec */;
    Production {
        lhs: 26,
        production: &[ParseType::N(28), ParseType::N(27), ParseType::N(38)],
    },
    // 2 - PrologList0: ScannerState : crate::parser::parol_grammar::ScannerConfig  PrologList0;
    Production {
        lhs: 28,
        production: &[ParseType::N(28), ParseType::N(33)],
    },
    // 3 - PrologList0: ;
    Production {
        lhs: 28,
        production: &[],
    },
    // 4 - PrologList: Declaration PrologList;
    Production {
        lhs: 27,
        production: &[ParseType::N(27), ParseType::N(7)],
    },
    // 5 - PrologList: ;
    Production {
        lhs: 27,
        production: &[],
    },
    // 6 - StartDeclaration: '%start'^ /* Clipped */ Identifier;
    Production {
        lhs: 38,
        production: &[ParseType::N(13), ParseType::T(5)],
    },
    // 7 - Declaration: '%title'^ /* Clipped */ String;
    Production {
        lhs: 7,
        production: &[ParseType::N(39), ParseType::T(6)],
    },
    // 8 - Declaration: '%comment'^ /* Clipped */ String;
    Production {
        lhs: 7,
        production: &[ParseType::N(39), ParseType::T(7)],
    },
    // 9 - Declaration: '%user_type'^ /* Clipped */ Identifier '='^ /* Clipped */ UserTypeName : crate::parser::parol_grammar::UserDefinedTypeName ;
    Production {
        lhs: 7,
        production: &[
            ParseType::N(47),
            ParseType::T(9),
            ParseType::N(13),
            ParseType::T(8),
        ],
    },
    // 10 - Declaration: "%nt_type"^ /* Clipped */ Identifier@nt_name '='^ /* Clipped */ UserTypeName@nt_type : crate::parser::parol_grammar::UserDefinedTypeName ;
    Production {
        lhs: 7,
        production: &[
            ParseType::N(47),
            ParseType::T(9),
            ParseType::N(13),
            ParseType::T(10),
        ],
    },
    // 11 - Declaration: "%t_type"^ /* Clipped */ UserTypeName@t_type : crate::parser::parol_grammar::UserDefinedTypeName ;
    Production {
        lhs: 7,
        production: &[ParseType::N(47), ParseType::T(11)],
    },
    // 12 - Declaration: '%grammar_type'^ /* Clipped */ RawString;
    Production {
        lhs: 7,
        production: &[ParseType::N(29), ParseType::T(12)],
    },
    // 13 - Declaration: ScannerDirectives;
    Production {
        lhs: 7,
        production: &[ParseType::N(32)],
    },
    // 14 - ScannerDirectives: '%line_comment'^ /* Clipped */ TokenLiteral;
    Production {
        lhs: 32,
        production: &[ParseType::N(43), ParseType::T(13)],
    },
    // 15 - ScannerDirectives: '%block_comment'^ /* Clipped */ TokenLiteral TokenLiteral;
    Production {
        lhs: 32,
        production: &[ParseType::N(43), ParseType::N(43), ParseType::T(14)],
    },
    // 16 - ScannerDirectives: '%auto_newline_off'^ /* Clipped */;
    Production {
        lhs: 32,
        production: &[ParseType::T(15)],
    },
    // 17 - ScannerDirectives: '%auto_ws_off'^ /* Clipped */;
    Production {
        lhs: 32,
        production: &[ParseType::T(16)],
    },
    // 18 - ScannerDirectives: '%skip'^ /* Clipped */ IdentifierList;
    Production {
        lhs: 32,
        production: &[ParseType::N(14), ParseType::T(17)],
    },
    // 19 - ScannerDirectives: '%on'^ /* Clipped */ IdentifierList ScannerStateDirectives : crate::parser::parol_grammar::ScannerStateSwitch ;
    Production {
        lhs: 32,
        production: &[ParseType::N(34), ParseType::N(14), ParseType::T(18)],
    },
    // 20 - ScannerDirectives: '%allow_unmatched'^ /* Clipped */;
    Production {
        lhs: 32,
        production: &[ParseType::T(19)],
    },
    // 21 - ScannerStateDirectives: '%enter'^ /* Clipped */ Identifier;
    Production {
        lhs: 34,
        production: &[ParseType::N(13), ParseType::T(20)],
    },
    // 22 - ScannerStateDirectives: '%push'^ /* Clipped */ Identifier;
    Production {
        lhs: 34,
        production: &[ParseType::N(13), ParseType::T(21)],
    },
    // 23 - ScannerStateDirectives: '%pop';
    Production {
        lhs: 34,
        production: &[ParseType::T(22)],
    },
    // 24 - GrammarDefinition: '%%'^ /* Clipped */ Production GrammarDefinitionList /* Vec */;
    Production {
        lhs: 10,
        production: &[ParseType::N(11), ParseType::N(25), ParseType::T(23)],
    },
    // 25 - GrammarDefinitionList: Production GrammarDefinitionList;
    Production {
        lhs: 11,
        production: &[ParseType::N(11), ParseType::N(25)],
    },
    // 26 - GrammarDefinitionList: ;
    Production {
        lhs: 11,
        production: &[],
    },
    // 27 - DoubleColon: '::';
    Production {
        lhs: 8,
        production: &[ParseType::T(24)],
    },
    // 28 - Production: Identifier ':'^ /* Clipped */ Alternations ';'^ /* Clipped */;
    Production {
        lhs: 25,
        production: &[
            ParseType::T(26),
            ParseType::N(4),
            ParseType::T(25),
            ParseType::N(13),
        ],
    },
    // 29 - Alternations: Alternation AlternationsList /* Vec */;
    Production {
        lhs: 4,
        production: &[ParseType::N(5), ParseType::N(2)],
    },
    // 30 - AlternationsList: '|'^ /* Clipped */ Alternation AlternationsList;
    Production {
        lhs: 5,
        production: &[ParseType::N(5), ParseType::N(2), ParseType::T(27)],
    },
    // 31 - AlternationsList: ;
    Production {
        lhs: 5,
        production: &[],
    },
    // 32 - Alternation: AlternationList /* Vec */;
    Production {
        lhs: 2,
        production: &[ParseType::N(3)],
    },
    // 33 - AlternationList: Factor AlternationList;
    Production {
        lhs: 3,
        production: &[ParseType::N(3), ParseType::N(9)],
    },
    // 34 - AlternationList: ;
    Production {
        lhs: 3,
        production: &[],
    },
    // 35 - Factor: Group;
    Production {
        lhs: 9,
        production: &[ParseType::N(12)],
    },
    // 36 - Factor: Repeat;
    Production {
        lhs: 9,
        production: &[ParseType::N(31)],
    },
    // 37 - Factor: Optional;
    Production {
        lhs: 9,
        production: &[ParseType::N(22)],
    },
    // 38 - Factor: Symbol;
    Production {
        lhs: 9,
        production: &[ParseType::N(40)],
    },
    // 39 - Symbol: NonTerminal;
    Production {
        lhs: 40,
        production: &[ParseType::N(20)],
    },
    // 40 - Symbol: SimpleToken;
    Production {
        lhs: 40,
        production: &[ParseType::N(36)],
    },
    // 41 - Symbol: TokenWithStates;
    Production {
        lhs: 40,
        production: &[ParseType::N(44)],
    },
    // 42 - TokenLiteral: String;
    Production {
        lhs: 43,
        production: &[ParseType::N(39)],
    },
    // 43 - TokenLiteral: RawString;
    Production {
        lhs: 43,
        production: &[ParseType::N(29)],
    },
    // 44 - TokenLiteral: Regex;
    Production {
        lhs: 43,
        production: &[ParseType::N(30)],
    },
    // 45 - TokenExpression: TokenLiteral TokenExpressionOpt /* Option */;
    Production {
        lhs: 41,
        production: &[ParseType::N(42), ParseType::N(43)],
    },
    // 46 - TokenExpressionOpt: LookAhead;
    Production {
        lhs: 42,
        production: &[ParseType::N(16)],
    },
    // 47 - TokenExpressionOpt: ;
    Production {
        lhs: 42,
        production: &[],
    },
    // 48 - SimpleToken: TokenExpression SimpleTokenOpt /* Option */;
    Production {
        lhs: 36,
        production: &[ParseType::N(37), ParseType::N(41)],
    },
    // 49 - SimpleTokenOpt: ASTControl;
    Production {
        lhs: 37,
        production: &[ParseType::N(0)],
    },
    // 50 - SimpleTokenOpt: ;
    Production {
        lhs: 37,
        production: &[],
    },
    // 51 - TokenWithStates: '<'^ /* Clipped */ IdentifierList '>'^ /* Clipped */ TokenExpression TokenWithStatesOpt /* Option */;
    Production {
        lhs: 44,
        production: &[
            ParseType::N(45),
            ParseType::N(41),
            ParseType::T(29),
            ParseType::N(14),
            ParseType::T(28),
        ],
    },
    // 52 - TokenWithStatesOpt: ASTControl;
    Production {
        lhs: 45,
        production: &[ParseType::N(0)],
    },
    // 53 - TokenWithStatesOpt: ;
    Production {
        lhs: 45,
        production: &[],
    },
    // 54 - String: /"(\\.|[^"])*"/;
    Production {
        lhs: 39,
        production: &[ParseType::T(30)],
    },
    // 55 - RawString: /'(\\.|[^'])*'/;
    Production {
        lhs: 29,
        production: &[ParseType::T(31)],
    },
    // 56 - Regex: "/(\\.|[^\/])*/";
    Production {
        lhs: 30,
        production: &[ParseType::T(32)],
    },
    // 57 - Group: '(' Alternations ')';
    Production {
        lhs: 12,
        production: &[ParseType::T(34), ParseType::N(4), ParseType::T(33)],
    },
    // 58 - Optional: '[' Alternations ']';
    Production {
        lhs: 22,
        production: &[ParseType::T(36), ParseType::N(4), ParseType::T(35)],
    },
    // 59 - Repeat: '{' Alternations '}';
    Production {
        lhs: 31,
        production: &[ParseType::T(38), ParseType::N(4), ParseType::T(37)],
    },
    // 60 - NonTerminal: Identifier NonTerminalOpt /* Option */;
    Production {
        lhs: 20,
        production: &[ParseType::N(21), ParseType::N(13)],
    },
    // 61 - NonTerminalOpt: ASTControl;
    Production {
        lhs: 21,
        production: &[ParseType::N(0)],
    },
    // 62 - NonTerminalOpt: ;
    Production {
        lhs: 21,
        production: &[],
    },
    // 63 - Identifier: /[a-zA-Z_][a-zA-Z0-9_]*/;
    Production {
        lhs: 13,
        production: &[ParseType::T(39)],
    },
    // 64 - ScannerState: '%scanner'^ /* Clipped */ Identifier@state_name '{'^ /* Clipped */ ScannerStateList /* Vec */ '}'^ /* Clipped */;
    Production {
        lhs: 33,
        production: &[
            ParseType::T(38),
            ParseType::N(35),
            ParseType::T(37),
            ParseType::N(13),
            ParseType::T(40),
        ],
    },
    // 65 - ScannerStateList: ScannerDirectives ScannerStateList;
    Production {
        lhs: 35,
        production: &[ParseType::N(35), ParseType::N(32)],
    },
    // 66 - ScannerStateList: ;
    Production {
        lhs: 35,
        production: &[],
    },
    // 67 - IdentifierList: Identifier IdentifierListList /* Vec */;
    Production {
        lhs: 14,
        production: &[ParseType::N(15), ParseType::N(13)],
    },
    // 68 - IdentifierListList: ','^ /* Clipped */ Identifier IdentifierListList;
    Production {
        lhs: 15,
        production: &[ParseType::N(15), ParseType::N(13), ParseType::T(41)],
    },
    // 69 - IdentifierListList: ;
    Production {
        lhs: 15,
        production: &[],
    },
    // 70 - ASTControl: CutOperator;
    Production {
        lhs: 0,
        production: &[ParseType::N(6)],
    },
    // 71 - ASTControl: MemberName ASTControlOpt /* Option */;
    Production {
        lhs: 0,
        production: &[ParseType::N(1), ParseType::N(18)],
    },
    // 72 - ASTControl: UserTypeDeclaration;
    Production {
        lhs: 0,
        production: &[ParseType::N(46)],
    },
    // 73 - ASTControlOpt: UserTypeDeclaration;
    Production {
        lhs: 1,
        production: &[ParseType::N(46)],
    },
    // 74 - ASTControlOpt: ;
    Production {
        lhs: 1,
        production: &[],
    },
    // 75 - MemberName: '@'^ /* Clipped */ Identifier;
    Production {
        lhs: 18,
        production: &[ParseType::N(13), ParseType::T(42)],
    },
    // 76 - CutOperator: '^'^ /* Clipped */;
    Production {
        lhs: 6,
        production: &[ParseType::T(43)],
    },
    // 77 - UserTypeDeclaration: ':'^ /* Clipped */ UserTypeName : crate::parser::parol_grammar::UserDefinedTypeName ;
    Production {
        lhs: 46,
        production: &[ParseType::N(47), ParseType::T(25)],
    },
    // 78 - UserTypeName: Identifier UserTypeNameList /* Vec */;
    Production {
        lhs: 47,
        production: &[ParseType::N(48), ParseType::N(13)],
    },
    // 79 - UserTypeNameList: DoubleColon^ /* Clipped */ Identifier UserTypeNameList;
    Production {
        lhs: 48,
        production: &[ParseType::N(48), ParseType::N(13), ParseType::N(8)],
    },
    // 80 - UserTypeNameList: ;
    Production {
        lhs: 48,
        production: &[],
    },
    // 81 - LookAhead: LookAheadGroup TokenLiteral;
    Production {
        lhs: 16,
        production: &[ParseType::N(43), ParseType::N(17)],
    },
    // 82 - LookAheadGroup: PositiveLookahead;
    Production {
        lhs: 17,
        production: &[ParseType::N(24)],
    },
    // 83 - LookAheadGroup: NegativeLookahead;
    Production {
        lhs: 17,
        production: &[ParseType::N(19)],
    },
    // 84 - PositiveLookahead: '?='^ /* Clipped */;
    Production {
        lhs: 24,
        production: &[ParseType::T(44)],
    },
    // 85 - NegativeLookahead: '?!'^ /* Clipped */;
    Production {
        lhs: 19,
        production: &[ParseType::T(45)],
    },
];

pub fn parse<'t, T>(
    input: &'t str,
    file_name: T,
    user_actions: &mut ParolGrammar<'t>,
) -> Result<ParseTree, ParolError>
where
    T: AsRef<Path>,
{
    use parol_runtime::{
        parser::{parse_tree_type::SynTree, parser_types::SynTreeFlavor},
        syntree::Builder,
    };
    let mut builder = Builder::<SynTree, SynTreeFlavor>::new_with();
    parse_into(input, &mut builder, file_name, user_actions)?;
    Ok(builder.build()?)
}
#[allow(dead_code)]
pub fn parse_into<'t, T: TreeConstruct<'t>>(
    input: &'t str,
    tree_builder: &mut T,
    file_name: impl AsRef<Path>,
    user_actions: &mut ParolGrammar<'t>,
) -> Result<(), ParolError>
where
    ParolError: From<T::Error>,
{
    use parol_grammar_scanner::ParolGrammarScanner;
    let mut llk_parser = LLKParser::new(
        23,
        LOOKAHEAD_AUTOMATA,
        PRODUCTIONS,
        TERMINAL_NAMES,
        NON_TERMINALS,
    );
    let scanner = ParolGrammarScanner::new();
    // Initialize wrapper
    let mut user_actions = ParolGrammarAuto::new(user_actions);
    llk_parser.parse_into(
        tree_builder,
        TokenStream::new_with_skip_tokens(
            input,
            file_name,
            scanner.scanner_impl.clone(),
            &ParolGrammarScanner::match_function,
            MAX_K,
            SKIP_TOKENS_BY_SCANNER_STATE,
        )
        .unwrap(),
        &mut user_actions,
    )
}