using Irony.Parsing;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AngelScript
{
    [Language("Angel Script", "1.0", "Angel Script Programming Language")]
    public class AngelScriptGrammar : Irony.Parsing.Grammar
    {
        public AngelScriptGrammar()
        {
            var singleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
            var delimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/");
            NonGrammarTerminals.Add(singleLineComment);
            NonGrammarTerminals.Add(delimitedComment);

            //  Regular Operators
            var DOT = ToTerm(".");
            var COLON = ToTerm(":");
            var COLONCOLON = ToTerm("::");
            var SEMIC = ToTerm(";");
            var COMMA = ToTerm(",");

            #region Operators

            //  Standard Operators
            var EQ = Operator("=");

            var OpeAND = Operator("&&");
            var OpeOR = Operator("||");
            var OpeNOT = Operator("!");

            var OpeEQ = Operator("==");
            var OpeNEQ = Operator("!=");
            var OpeBig = Operator(">");
            var OpeBigEQ = Operator(">=");
            var OpeSm = Operator("<");
            var OpeSmEQ = Operator("<=");

            var OpeAdd = Operator("+");
            var OpeSub = Operator("-");
            var OpeMul = Operator("*");
            var OpeDiv = Operator("/");
            var OpePow = Operator("^");

            var OpePre = Operator("%");
            var OpeAt = Operator("@");
            var OpeAmp = Operator("&");
            var OpeQmark = Operator("?");

            #endregion

            #region Keywords

            var k_AND = Keyword("and");
            var k_ABSTRACT = Keyword("abstract");
            var k_AUTO = Keyword("auto");
            var k_BOOL = Keyword("bool");
            var k_BREAK = Keyword("break");
            var k_CASE = Keyword("case");
            var k_CAST = Keyword("cast");
            var k_CLASS = Keyword("class");
            var k_CONST = Keyword("const");
            var k_CONTINUE = Keyword("continue");
            var k_DEFAULT = Keyword("default");
            var k_DO = Keyword("do");
            var k_DOUBLE = Keyword("double");
            var k_ELSE = Keyword("else");
            var k_ENUM = Keyword("enum");
            var k_FALSE = Keyword("false");
            var k_FINAL = Keyword("final");
            var k_FLOAT = Keyword("float");
            var k_FOR = Keyword("for");
            var k_FROM = Keyword("from");
            var k_FUNCDEF = Keyword("funcdef");
            var k_GET = Keyword("get");
            var k_IF = Keyword("if");
            var k_IMPORT = Keyword("import");
            var k_IN = Keyword("in");
            var k_INOUT = Keyword("inout");
            var k_INT = Keyword("int");
            var k_INTERFACE = Keyword("interface");
            var k_INT8 = Keyword("int8");
            var k_INT16 = Keyword("int16");
            var k_INT32 = Keyword("int32");
            var k_INT64 = Keyword("int64");
            var k_IS = Keyword("is");
            var k_MIXIN = Keyword("mixin");
            var k_NAMESPACE = Keyword("namespace");
            var k_NOT = Keyword("not");
            var k_NULL = Keyword("null");
            var k_OR = Keyword("or");
            var k_OUT = Keyword("out");
            var k_OVERRIDE = Keyword("override");
            var k_PRIVATE = Keyword("private");
            var k_PROTECTED = Keyword("protected");
            var k_RETURN = Keyword("return");
            var k_SET = Keyword("set");
            var k_SHARED = Keyword("shared");
            var k_SUPER = Keyword("super");
            var k_SWITCH = Keyword("switch");
            var k_THIS = Keyword("this");
            var k_TRUE = Keyword("true");
            var k_TYPEDEF = Keyword("typedef");
            var k_UINT = Keyword("uint");
            var k_UINT8 = Keyword("uint8");
            var k_UINT16 = Keyword("uint16");
            var k_UINT32 = Keyword("uint32");
            var k_UINT64 = Keyword("uint64");
            var k_VOID = Keyword("void");
            var k_WHILE = Keyword("while");
            var k_XOR = Keyword("xor");

            #endregion

            var NUMBER = CreateAngelScriptNumber("number"); // new NumberLiteral("number");// new NonTerminal("number");                 // ::= single token:  includes integers and real numbers, same as C++
            var STRING = new StringLiteral("string", "\"");//new NonTerminal("string");                 // ::= single token:  single quoted ', double quoted ", or heredoc multi-line string """
            var BITS = new NumberLiteral("bits");//new NonTerminal("bits");                     // ::= single token:  binary 0b or 0B, octal 0o or 0O, decimal 0d or 0D, hexadecimal 0x or 0X
            var IDENTIFIER = new IdentifierTerminal("identifier");

            var SCOPE_0_opt_0_opt = new NonTerminal("scope_0_opt_0_opt");
            var SCOPE_0_opt_1 = new NonTerminal("scope_0_opt_1");
            var SCOPE_0_opt_1_list = new NonTerminal("scope_0_opt_1_list");
            var SCOPE_0_opt = new NonTerminal("scope_0_opt");
            var SCOPE = new NonTerminal("scope");
            var TYPEMOD_0_opt_0_opt = new NonTerminal("typemod_0_opt_0_opt");
            var TYPEMOD_0_opt = new NonTerminal("typemod_0_opt");
            var TYPEMOD = new NonTerminal("typemod");
            var TYPE_0_opt = new NonTerminal("type_0_opt");
            var TYPE_1_opt_0 = new NonTerminal("type_1_opt_0");
            var TYPE_1_opt_0_list = new NonTerminal("type_1_opt_0_list");
            var TYPE_1_opt = new NonTerminal("type_1_opt");
            var TYPE_2 = new NonTerminal("type_2");
            var TYPE_2_list = new NonTerminal("type_2_list");
            var TYPE = new NonTerminal("type");
            var DATATYPE = new NonTerminal("datatype");
            var PRIMTYPE = new NonTerminal("primtype");
            var PARAMLIST_0_opt = new NonTerminal("paramlist_0_opt");
            var PARAMLIST_1_opt = new NonTerminal("paramlist_1_opt");
            var PARAMLIST_2_list_0_opt = new NonTerminal("paramlist_2_list_0_opt");
            var PARAMLIST_2_list_1_opt = new NonTerminal("paramlist_2_list_1_opt");
            var PARAMLIST_2 = new NonTerminal("paramlist_2");
            var PARAMLIST_2_list = new NonTerminal("paramlist_2_list");
            var PARAMLIST = new NonTerminal("paramlist");
            var CAST = new NonTerminal("cast");
            var EXPRVALUE = new NonTerminal("exprvalue");
            var LITERAL = new NonTerminal("literal");
            var FUNCCALL = new NonTerminal("funccall");
            var VARACCESS = new NonTerminal("varaccess");
            var CONSTRUCTCALL = new NonTerminal("constructcall");
            var ARGLIST_0_opt = new NonTerminal("arglist_0_opt");
            var ARGLIST_1_list_0_opt = new NonTerminal("arglist_1_list_0_opt");
            var ARGLIST_1 = new NonTerminal("arglist_1");
            var ARGLIST_1_list = new NonTerminal("arglist_1_list");
            var ARGLIST = new NonTerminal("arglist");
            var ASSIGN_0_opt = new NonTerminal("assign_0_opt");
            var ASSIGN = new NonTerminal("assign");
            var CONDITION_0_opt = new NonTerminal("condition_0_opt");
            var CONDITION = new NonTerminal("condition");
            var EXPR_0 = new NonTerminal("expr_0");
            var EXPR_0_list = new NonTerminal("expr_0_list");
            var EXPR = new NonTerminal("expr");
            var EXPRTERM_0 = new NonTerminal("exprterm_0");
            var EXPRTERM_0_list = new NonTerminal("exprterm_0_list");
            var EXPRTERM_1 = new NonTerminal("exprterm_1");
            var EXPRTERM_1_list = new NonTerminal("exprterm_1_list");
            var EXPRTERM = new NonTerminal("exprterm");
            var EXPRPREOP = new NonTerminal("exprpreop");
            var EXPRPOSTOP_0_opt = new NonTerminal("exprpostop_0_opt");
            var EXPRPOSTOP_1_list_0_opt = new NonTerminal("exprpostop_1_list_0_opt");
            var EXPRPOSTOP_1 = new NonTerminal("exprpostop_1");
            var EXPRPOSTOP_1_list = new NonTerminal("exprpostop_1_list");
            var EXPRPOSTOP = new NonTerminal("exprpostop");
            var EXPROP = new NonTerminal("exprop");
            var MATHOP = new NonTerminal("mathop");
            var COMPOP = new NonTerminal("compop");
            var LOGICOP = new NonTerminal("logicop");
            var BITOP = new NonTerminal("bitop");
            var ASSIGNOP = new NonTerminal("assignop");
            var IMPORT_0_opt = new NonTerminal("import_0_opt");
            var IMPORT = new NonTerminal("import");
            var SCRIPT_0 = new NonTerminal("script_0");
            var SCRIPT_0_list = new NonTerminal("script_0_list");
            var SCRIPT = new NonTerminal("script");
            var NAMESPACE = new NonTerminal("namespace");
            var ENUM_0_opt = new NonTerminal("enum_0_opt");
            var ENUM_1_opt = new NonTerminal("enum_1_opt");
            var ENUM_2_list_0_opt = new NonTerminal("enum_2_list_0_opt");
            var ENUM_2 = new NonTerminal("enum_2");
            var ENUM_2_list = new NonTerminal("enum_2_list");
            var ENUM = new NonTerminal("enum");
            var FUNCDEF_0_opt = new NonTerminal("funcdef_0_opt");
            var FUNCDEF = new NonTerminal("funcdef");
            var FUNC_0_opt = new NonTerminal("func_0_opt");
            var FUNC_1_opt_0_opt = new NonTerminal("func_1_opt_0_opt");
            var FUNC_1_opt = new NonTerminal("func_1_opt");
            var FUNC_2_opt = new NonTerminal("func_2_opt");
            var FUNC_3 = new NonTerminal("func_3");
            var FUNC_3_list = new NonTerminal("func_3_list");
            var FUNC = new NonTerminal("func");
            var INTFMTHD_0_opt = new NonTerminal("intfmthd_0_opt");
            var INTFMTHD_1_opt = new NonTerminal("intfmthd_1_opt");
            var INTFMTHD = new NonTerminal("intfmthd");
            var VIRTPROP_0_opt = new NonTerminal("virtprop_0_opt");
            var VIRTPROP_1_opt = new NonTerminal("virtprop_1_opt");
            var VIRTPROP_2_list_0_opt = new NonTerminal("virtprop_2_list_0_opt");
            var VIRTPROP_2_list_1_opt = new NonTerminal("virtprop_2_list_1_opt");
            var VIRTPROP_2 = new NonTerminal("virtprop_2");
            var VIRTPROP_2_list = new NonTerminal("virtprop_2_list");
            var VIRTPROP = new NonTerminal("virtprop");
            var INTERFACE_0_opt = new NonTerminal("interface_0_opt");
            var INTERFACE_1_opt_0 = new NonTerminal("interface_1_opt_0");
            var INTERFACE_1_opt_0_list = new NonTerminal("interface_1_opt_0_list");
            var INTERFACE_1_opt = new NonTerminal("interface_1_opt");
            var INTERFACE_2 = new NonTerminal("interface_2");
            var INTERFACE_2_list = new NonTerminal("interface_2_list");
            var INTERFACE = new NonTerminal("interface");
            var MIXIN = new NonTerminal("mixin");
            var CLASS_0 = new NonTerminal("class_0");
            var CLASS_0_list = new NonTerminal("class_0_list");
            var CLASS_1_opt_0 = new NonTerminal("class_1_opt_0");
            var CLASS_1_opt_0_list = new NonTerminal("class_1_opt_0_list");
            var CLASS_1_opt = new NonTerminal("class_1_opt");
            var CLASS_2 = new NonTerminal("class_2");
            var CLASS_2_list = new NonTerminal("class_2_list");
            var CLASS = new NonTerminal("class");
            var STATBLOCK_0 = new NonTerminal("statblock_0");
            var STATBLOCK_0_list = new NonTerminal("statblock_0_list");
            var STATBLOCK = new NonTerminal("statblock");
            var INITLIST_0_opt = new NonTerminal("initlist_0_opt");
            var INITLIST_1_list_0_opt = new NonTerminal("initlist_1_list_0_opt");
            var INITLIST_1 = new NonTerminal("initlist_1");
            var INITLIST_1_list = new NonTerminal("initlist_1_list");
            var INITLIST = new NonTerminal("initlist");
            var VAR_0_opt = new NonTerminal("var_0_opt");
            var VAR_1_opt = new NonTerminal("var_1_opt");
            var VAR_2_list_0_opt = new NonTerminal("var_2_list_0_opt");
            var VAR_2 = new NonTerminal("var_2");
            var VAR_2_list = new NonTerminal("var_2_list");
            var VAR = new NonTerminal("var");
            var STATEMENT = new NonTerminal("statement");
            var EXPRSTAT_0_opt = new NonTerminal("exprstat_0_opt");
            var EXPRSTAT = new NonTerminal("exprstat");
            var SWITCH_0 = new NonTerminal("switch_0");
            var SWITCH_0_list = new NonTerminal("switch_0_list");
            var SWITCH = new NonTerminal("switch");
            var CASE_0 = new NonTerminal("case_0");
            var CASE_0_list = new NonTerminal("case_0_list");
            var CASE = new NonTerminal("case");
            var IF_0_opt = new NonTerminal("if_0_opt");
            var IF = new NonTerminal("if");
            var FOR_0_opt = new NonTerminal("for_0_opt");
            var FOR = new NonTerminal("for");
            var WHILE = new NonTerminal("while");
            var DOWHILE = new NonTerminal("dowhile");
            var RETURN_0_opt = new NonTerminal("return_0_opt");
            var RETURN = new NonTerminal("return");
            var BREAK = new NonTerminal("break");
            var CONTINUE = new NonTerminal("continue");
            var TYPEDEF = new NonTerminal("typedef");

            this.Root = SCRIPT;

            SCOPE_0_opt_0_opt.Rule = Empty | IDENTIFIER;
            SCOPE_0_opt_1.Rule = IDENTIFIER + "::";
            SCOPE_0_opt_1_list.Rule = MakeStarRule(SCOPE_0_opt_1_list, null, SCOPE_0_opt_1);
            SCOPE_0_opt.Rule = Empty | SCOPE_0_opt_0_opt + "::" + SCOPE_0_opt_1_list;

            // SCOPE ::=  [[IDENTIFIER] '::' {IDENTIFIER '::'}]
            SCOPE.Rule = SCOPE_0_opt;

            TYPEMOD_0_opt_0_opt.Rule = Empty | "in" | "out" | "inout";
            TYPEMOD_0_opt.Rule = Empty | "&" + TYPEMOD_0_opt_0_opt;

            // TYPEMOD ::=  ['&' ['in' | 'out' | 'inout']]
            TYPEMOD.Rule = TYPEMOD_0_opt;

            TYPE_0_opt.Rule = Empty | "const";
            TYPE_1_opt_0.Rule = "," + TYPE;
            TYPE_1_opt_0_list.Rule = MakeStarRule(TYPE_1_opt_0_list, null, TYPE_1_opt_0);
            TYPE_1_opt.Rule = Empty | "<" + TYPE + TYPE_1_opt_0_list + ">";
            TYPE_2.Rule = (ToTerm("[") + "]") | "@";
            TYPE_2_list.Rule = MakeStarRule(TYPE_2_list, null, TYPE_2);

            // TYPE ::=  ['const'] SCOPE DATATYPE ['<' TYPE {',' TYPE} '>'] { ('[' ']') | '@' }
            TYPE.Rule = TYPE_0_opt + SCOPE + DATATYPE + TYPE_1_opt + TYPE_2_list;

            // DATATYPE ::=  (IDENTIFIER | PRIMTYPE | '?' | 'auto')
            DATATYPE.Rule = (PRIMTYPE | "?" | "auto" | IDENTIFIER);

            // PRIMTYPE ::=  'void' | 'int' | 'int8' | 'int16' | 'int32' | 'int64' | 'uint' | 'uint8' | 'uint16' | 'uint32' | 'uint64' | 'float' | 'double' | 'bool'
            PRIMTYPE.Rule = ToTerm("void") | "int8" | "int16" | "int32" | "int64" | "int" | "uint8" | "uint16" | "uint32" | "uint64" | "uint" | "float" | "double" | "bool";

            PARAMLIST_0_opt.Rule = Empty | IDENTIFIER;
            PARAMLIST_1_opt.Rule = Empty | "=" + EXPR;
            PARAMLIST_2_list_0_opt.Rule = Empty | IDENTIFIER;
            PARAMLIST_2_list_1_opt.Rule = Empty | "=" + EXPR;
            PARAMLIST_2.Rule = "," + TYPE + TYPEMOD + PARAMLIST_2_list_0_opt + PARAMLIST_2_list_1_opt;
            PARAMLIST_2_list.Rule = MakeStarRule(PARAMLIST_2_list, null, PARAMLIST_2);

            // PARAMLIST ::=  '(' ('void' | (TYPE TYPEMOD [IDENTIFIER] ['=' EXPR] {',' TYPE TYPEMOD [IDENTIFIER] ['=' EXPR]}) ')'
            PARAMLIST.Rule = "(" + ("void" | (TYPE + TYPEMOD + PARAMLIST_0_opt + PARAMLIST_1_opt + PARAMLIST_2_list)) + ")";

            // CAST ::=  'cast' '<' TYPE '>' '(' ASSIGN ')'
            CAST.Rule = "cast" + "<" + TYPE + ">" + "(" + ASSIGN + ")";

            // EXPRVALUE ::=  'void' | CONSTRUCTCALL | FUNCCALL | VARACCESS | CAST | LITERAL | '(' ASSIGN ')'
            EXPRVALUE.Rule = "void" | CONSTRUCTCALL | FUNCCALL | VARACCESS | CAST | LITERAL | "(" + ASSIGN + ")";

            // LITERAL ::=  NUMBER | STRING | BITS | 'true' | 'false' | 'null'
            LITERAL.Rule = NUMBER | STRING | BITS | "true" | "false" | "null";

            // FUNCCALL ::=  SCOPE IDENTIFIER ARGLIST
            FUNCCALL.Rule = SCOPE + IDENTIFIER + ARGLIST;

            // VARACCESS ::=  SCOPE IDENTIFIER
            VARACCESS.Rule = SCOPE + IDENTIFIER;

            // CONSTRUCTCALL ::=  TYPE ARGLIST
            CONSTRUCTCALL.Rule = TYPE + ARGLIST;

            ARGLIST_0_opt.Rule = Empty | IDENTIFIER + ":";
            ARGLIST_1_list_0_opt.Rule = Empty | IDENTIFIER + ":";
            ARGLIST_1.Rule = "," + ARGLIST_1_list_0_opt + ASSIGN;
            ARGLIST_1_list.Rule = MakeStarRule(ARGLIST_1_list, null, ARGLIST_1);

            // ARGLIST ::=  '(' [IDENTIFIER ':'] ASSIGN {',' [IDENTIFIER ':'] ASSIGN} ')'
            ARGLIST.Rule = "(" + ARGLIST_0_opt + ASSIGN + ARGLIST_1_list + ")";

            ASSIGN_0_opt.Rule = Empty | ASSIGNOP + ASSIGN;

            // ASSIGN ::=  CONDITION [ ASSIGNOP ASSIGN ]
            ASSIGN.Rule = CONDITION + ASSIGN_0_opt;

            CONDITION_0_opt.Rule = Empty | "?" + ASSIGN + ":" + ASSIGN;

            // CONDITION ::=  EXPR ['?' ASSIGN ':' ASSIGN]
            CONDITION.Rule = EXPR + CONDITION_0_opt;

            EXPR_0.Rule = EXPROP + EXPRTERM;
            EXPR_0_list.Rule = MakeStarRule(EXPR_0_list, null, EXPR_0);

            // EXPR ::=  (TYPE '=' INILIST) | (EXPRTERM {EXPROP EXPRTERM})
            EXPR.Rule = (TYPE + "=" + INITLIST) | (EXPRTERM + EXPR_0_list);

            EXPRTERM_0.Rule = EXPRPREOP;
            EXPRTERM_0_list.Rule = MakeStarRule(EXPRTERM_0_list, null, EXPRTERM_0);
            EXPRTERM_1.Rule = EXPRPOSTOP;
            EXPRTERM_1_list.Rule = MakeStarRule(EXPRTERM_1_list, null, EXPRTERM_1);

            // EXPRTERM ::=  {EXPRPREOP} EXPRVALUE {EXPRPOSTOP}
            EXPRTERM.Rule = EXPRTERM_0_list + EXPRVALUE + EXPRTERM_1_list;

            // EXPRPREOP ::=  '-' | '+' | '!' | '++' | '--' | '~' | '@'
            EXPRPREOP.Rule = ToTerm("-") | "+" | "!" | "++" | "--" | "~" | "@";

            EXPRPOSTOP_0_opt.Rule = Empty | IDENTIFIER + ":";
            EXPRPOSTOP_1_list_0_opt.Rule = Empty | IDENTIFIER + ":";
            EXPRPOSTOP_1.Rule = "," + EXPRPOSTOP_1_list_0_opt + ASSIGN;
            EXPRPOSTOP_1_list.Rule = MakeStarRule(EXPRPOSTOP_1_list, null, EXPRPOSTOP_1);

            // EXPRPOSTOP ::=  ('.' (FUNCCALL | IDENTIFIER)) | ('[' [IDENTIFIER ':'] ASSIGN {',' [IDENTIFIER ':'] ASSIGN} ']') | ARGLIST | '++' | '--'
            EXPRPOSTOP.Rule = ("." + (FUNCCALL | IDENTIFIER)) | ("[" + EXPRPOSTOP_0_opt + ASSIGN + EXPRPOSTOP_1_list + "]") | ARGLIST | "++" | "--";

            // EXPROP ::=  MATHOP | COMPOP | LOGICOP | BITOP
            EXPROP.Rule = MATHOP | COMPOP | LOGICOP | BITOP;

            // MATHOP ::=  '+' | '-' | '*' | '/' | '%' | '**'
            MATHOP.Rule = ToTerm("+") | "-" | "/" | "%" | "**" | "*";

            // COMPOP ::=  '==' | '!=' | '<' | '<=' | '>' | '>=' | 'is' | '!is'
            COMPOP.Rule = ToTerm("==") | "!=" | "<=" | "<" | ">=" | ">" | "is" | "!is";

            // LOGICOP ::=  '&&' | '||' | '^^' | 'and' | 'or' | 'xor'
            LOGICOP.Rule = ToTerm("&&") | "||" | "^^" | "and" | "or" | "xor";

            // BITOP ::=  '&' | '|' | '^' | '<<' | '>>' | '>>>'
            BITOP.Rule = ToTerm("&") | "|" | "^" | "<<" | ">>>" | ">>";

            // ASSIGNOP ::=  '=' | '+=' | '-=' | '*=' | '/=' | '|=' | '&=' | '^=' | '%=' | '**=' | '<<=' | '>>=' | '>>>='
            ASSIGNOP.Rule = ToTerm("=") | "+=" | "-=" | "/=" | "|=" | "&=" | "^=" | "%=" | "**=" | "*=" | "<<=" | ">>>=" | ">>=";

            IMPORT_0_opt.Rule = Empty | "&";

            // IMPORT ::=  'import' TYPE ['&'] IDENTIFIER PARAMLIST 'from' STRING ';'
            IMPORT.Rule = "import" + TYPE + IMPORT_0_opt + IDENTIFIER + PARAMLIST + "from" + STRING + ";";

            SCRIPT_0.Rule = IMPORT | ENUM | TYPEDEF | CLASS | MIXIN | INTERFACE | FUNCDEF | VIRTPROP | FUNC | VAR | NAMESPACE | ";";
            SCRIPT_0_list.Rule = MakeStarRule(SCRIPT_0_list, null, SCRIPT_0);

            // SCRIPT ::=  {IMPORT | ENUM | TYPEDEF | CLASS | MIXIN | INTERFACE | FUNCDEF | VIRTPROP | VAR | FUNC | NAMESPACE | ';'}
            SCRIPT.Rule = SCRIPT_0_list;

            // NAMESPACE ::=  'namespace' IDENTIFIER '{' SCRIPT '}'
            NAMESPACE.Rule = "namespace" + IDENTIFIER + "{" + SCRIPT + "}";

            ENUM_0_opt.Rule = Empty | "shared";
            ENUM_1_opt.Rule = Empty | "=" + EXPR;
            ENUM_2_list_0_opt.Rule = Empty | "=" + EXPR;
            ENUM_2.Rule = "," + IDENTIFIER + ENUM_2_list_0_opt;
            ENUM_2_list.Rule = MakeStarRule(ENUM_2_list, null, ENUM_2);

            // ENUM ::=  ['shared'] 'enum' IDENTIFIER '{' IDENTIFIER ['=' EXPR] {',' IDENTIFIER ['=' EXPR]} '}'
            ENUM.Rule = ENUM_0_opt + "enum" + IDENTIFIER + "{" + IDENTIFIER + ENUM_1_opt + ENUM_2_list + "}";

            FUNCDEF_0_opt.Rule = Empty | "&";

            // FUNCDEF ::=  'funcdef' TYPE ['&'] IDENTIFIER PARAMLIST ';'
            FUNCDEF.Rule = "funcdef" + TYPE + FUNCDEF_0_opt + IDENTIFIER + PARAMLIST + ";";

            FUNC_0_opt.Rule = Empty | "private" | "protected" | "shared";
            FUNC_1_opt_0_opt.Rule = Empty | "&";
            FUNC_1_opt.Rule = Empty | ((TYPE + FUNC_1_opt_0_opt) | "~");
            FUNC_2_opt.Rule = Empty | "const";
            FUNC_3.Rule = ToTerm("override") | "final";
            FUNC_3_list.Rule = MakeStarRule(FUNC_3_list, null, FUNC_3);

            // FUNC ::=  ['private' | 'protected' | 'shared'] [((TYPE ['&']) | '~')] IDENTIFIER PARAMLIST ['const'] {'override' | 'final'} STATBLOCK
            FUNC.Rule = FUNC_0_opt + FUNC_1_opt + IDENTIFIER + PARAMLIST + FUNC_2_opt + FUNC_3_list + STATBLOCK;

            INTFMTHD_0_opt.Rule = Empty | "&";
            INTFMTHD_1_opt.Rule = Empty | "const";

            // INTFMTHD ::=  TYPE ['&'] IDENTIFIER PARAMLIST ['const'] ';'
            INTFMTHD.Rule = TYPE + INTFMTHD_0_opt + IDENTIFIER + PARAMLIST + INTFMTHD_1_opt + ";";

            VIRTPROP_0_opt.Rule = Empty | "private" | "protected";
            VIRTPROP_1_opt.Rule = Empty | "&";
            VIRTPROP_2_list_0_opt.Rule = Empty | "const";
            VIRTPROP_2_list_1_opt.Rule = Empty | (ToTerm("override") | "final");
            VIRTPROP_2.Rule = (ToTerm("get") | "set") + VIRTPROP_2_list_0_opt + VIRTPROP_2_list_1_opt + (STATBLOCK | ";");
            VIRTPROP_2_list.Rule = MakeStarRule(VIRTPROP_2_list, null, VIRTPROP_2);

            // VIRTPROP ::=  ['private' | 'protected'] TYPE ['&'] IDENTIFIER '{' {('get' | 'set') ['const'] [('override' | 'final')] (STATBLOCK | ';')} '}'
            VIRTPROP.Rule = VIRTPROP_0_opt + TYPE + VIRTPROP_1_opt + IDENTIFIER + "{" + VIRTPROP_2_list + "}";

            INTERFACE_0_opt.Rule = Empty | "shared";
            INTERFACE_1_opt_0.Rule = "," + IDENTIFIER;
            INTERFACE_1_opt_0_list.Rule = MakeStarRule(INTERFACE_1_opt_0_list, null, INTERFACE_1_opt_0);
            INTERFACE_1_opt.Rule = Empty | ":" + IDENTIFIER + INTERFACE_1_opt_0_list;
            INTERFACE_2.Rule = VIRTPROP | INTFMTHD;
            INTERFACE_2_list.Rule = MakeStarRule(INTERFACE_2_list, null, INTERFACE_2);

            // INTERFACE ::=  ['shared'] 'interface' IDENTIFIER [':' IDENTIFIER {',' IDENTIFIER}] '{' {VIRTPROP | INTFMTHD} '}'
            INTERFACE.Rule = INTERFACE_0_opt + "interface" + IDENTIFIER + INTERFACE_1_opt + "{" + INTERFACE_2_list + "}";

            // MIXIN ::=  'mixin' CLASS
            MIXIN.Rule = "mixin" + CLASS;

            CLASS_0.Rule = ToTerm("shared") | "abstract" | "final";
            CLASS_0_list.Rule = MakeStarRule(CLASS_0_list, null, CLASS_0);
            CLASS_1_opt_0.Rule = "," + IDENTIFIER;
            CLASS_1_opt_0_list.Rule = MakeStarRule(CLASS_1_opt_0_list, null, CLASS_1_opt_0);
            CLASS_1_opt.Rule = Empty | ":" + IDENTIFIER + CLASS_1_opt_0_list;
            CLASS_2.Rule = VIRTPROP | FUNC | VAR;
            CLASS_2_list.Rule = MakeStarRule(CLASS_2_list, null, CLASS_2);

            // CLASS ::=  {'shared' | 'abstract' | 'final'} 'class' IDENTIFIER [':' IDENTIFIER {',' IDENTIFIER}] '{' {VIRTPROP | FUNC | VAR} '}'
            CLASS.Rule = CLASS_0_list + "class" + IDENTIFIER + CLASS_1_opt + "{" + CLASS_2_list + "}";

            STATBLOCK_0.Rule = VAR | STATEMENT;
            STATBLOCK_0_list.Rule = MakeStarRule(STATBLOCK_0_list, null, STATBLOCK_0);

            // STATBLOCK ::=  '{' {VAR | STATEMENT} '}'
            STATBLOCK.Rule = "{" + STATBLOCK_0_list + "}";

            INITLIST_0_opt.Rule = Empty | ASSIGN | INITLIST;
            INITLIST_1_list_0_opt.Rule = Empty | ASSIGN | INITLIST;
            INITLIST_1.Rule = "," + INITLIST_1_list_0_opt;
            INITLIST_1_list.Rule = MakeStarRule(INITLIST_1_list, null, INITLIST_1);

            // INITLIST ::=  '{' [ASSIGN | INITLIST] {',' [ASSIGN | INITLIST]} '}'
            INITLIST.Rule = "{" + INITLIST_0_opt + INITLIST_1_list + "}";

            VAR_0_opt.Rule = Empty | "private" | "protected";
            VAR_1_opt.Rule = Empty | (ToTerm("=") + (INITLIST | EXPR)) | ARGLIST;
            VAR_2_list_0_opt.Rule = Empty | (ToTerm("=") + (INITLIST | EXPR)) | ARGLIST;
            VAR_2.Rule = "," + IDENTIFIER + VAR_2_list_0_opt;
            VAR_2_list.Rule = MakeStarRule(VAR_2_list, null, VAR_2);

            // VAR ::=  ['private'|'protected'] TYPE IDENTIFIER [( '=' (INITLIST | EXPR)) | ARGLIST] {',' IDENTIFIER [( '=' (INITLIST | EXPR)) | ARGLIST]} ';'
            VAR.Rule = VAR_0_opt + TYPE + IDENTIFIER + VAR_1_opt + VAR_2_list + ";";

            // STATEMENT ::=  (IF | FOR | WHILE | RETURN | STATBLOCK | BREAK | CONTINUE | DOWHILE | SWITCH | EXPRSTAT)
            STATEMENT.Rule = (IF | FOR | WHILE | RETURN | STATBLOCK | BREAK | CONTINUE | DOWHILE | SWITCH | EXPRSTAT);

            EXPRSTAT_0_opt.Rule = Empty | ASSIGN;

            // EXPRSTAT ::=  [ASSIGN] ';'
            EXPRSTAT.Rule = EXPRSTAT_0_opt + ";";

            SWITCH_0.Rule = CASE;
            SWITCH_0_list.Rule = MakeStarRule(SWITCH_0_list, null, SWITCH_0);

            // SWITCH ::=  'switch' '(' ASSIGN ')' '{' {CASE} '}'
            SWITCH.Rule = "switch" + "(" + ASSIGN + ")" + "{" + SWITCH_0_list + "}";

            CASE_0.Rule = STATEMENT;
            CASE_0_list.Rule = MakeStarRule(CASE_0_list, null, CASE_0);

            // CASE ::=  (('case' EXPR) | 'default') ':' {STATEMENT}
            CASE.Rule = (("case" + EXPR) | "default") + ":" + CASE_0_list;

            IF_0_opt.Rule = Empty | "else" + STATEMENT;

            // IF ::=  'if' '(' ASSIGN ')' STATEMENT ['else' STATEMENT]
            IF.Rule = "if" + "(" + ASSIGN + ")" + STATEMENT + IF_0_opt;

            FOR_0_opt.Rule = Empty | ASSIGN;

            // FOR ::=  'for' '(' (VAR | EXPRSTAT) EXPRSTAT [ASSIGN] ')' STATEMENT
            FOR.Rule = "for" + "(" + (VAR | EXPRSTAT) + EXPRSTAT + FOR_0_opt + ")" + STATEMENT;

            // WHILE ::=  'while' '(' ASSIGN ')' STATEMENT
            WHILE.Rule = "while" + "(" + ASSIGN + ")" + STATEMENT;

            // DOWHILE ::=  'do' STATEMENT 'while' '(' ASSIGN ')' ';'
            DOWHILE.Rule = "do" + STATEMENT + "while" + "(" + ASSIGN + ")" + ";";

            RETURN_0_opt.Rule = Empty | ASSIGN;

            // RETURN ::=  'return' [ASSIGN] ';'
            RETURN.Rule = "return" + RETURN_0_opt + ";";

            // BREAK ::=  'break' ';'
            BREAK.Rule = "break" + ";";

            // CONTINUE ::=  'continue' ';'
            CONTINUE.Rule = "continue" + ";";

            // TYPEDEF ::=  'typedef' PRIMTYPE IDENTIFIER ';'
            TYPEDEF.Rule = "typedef" + PRIMTYPE + IDENTIFIER + ";";

            this.RegisterBracePair("[", "]");
            this.RegisterBracePair("<", ">");
            this.RegisterBracePair("(", ")");
            this.RegisterBracePair("{", "}");

            this.MarkPunctuation(",", ";", "(", ")", "{", "}");

            this.RegisterOperators(1, OpeOR);
            this.RegisterOperators(2, OpeAND);
            this.RegisterOperators(3, OpeBigEQ, OpeBig, OpeSm, OpeSmEQ, OpeNEQ, OpeEQ);
            this.RegisterOperators(4, OpeAdd, OpeSub);
            this.RegisterOperators(5, OpeMul, OpeDiv, OpePre);
            this.RegisterOperators(6, OpeNOT);
            this.RegisterOperators(7, Associativity.Right, OpePow);
        }

        BnfExpression MakeStarRule(BnfTerm term)
        {
            var s = MakeStarRule(new NonTerminal(term.Name + "*"), term);
            s.Name = term.Name + "**";
            return s;
        }

        BnfExpression MakeStarRule(string n, BnfTerm term)
        {
            var s = base.MakeStarRule(new NonTerminal(n + "*"), term);
            s.Name = n + "**";
            return s;
        }

        BnfExpression Q(string n, BnfTerm terms)
        {
            var q = terms.Q();
            q.Name = n + "?";
            return q;
        }

        //Must create new overrides here in order to support the "Operator" token color
        public new void RegisterOperators(int precedence, params string[] opSymbols)
        {
            RegisterOperators(precedence, Associativity.Left, opSymbols);
        }

        //Must create new overrides here in order to support the "Operator" token color
        public new void RegisterOperators(int precedence, Associativity associativity, params string[] opSymbols)
        {
            foreach (string op in opSymbols)
            {
                KeyTerm opSymbol = Operator(op);
                opSymbol.Precedence = precedence;
                opSymbol.Associativity = associativity;
            }
        }

        public KeyTerm Keyword(string keyword)
        {
            var term = ToTerm(keyword);
            // term.SetOption(TermOptions.IsKeyword, true);
            // term.SetOption(TermOptions.IsReservedWord, true);

            this.MarkReservedWords(keyword);
            term.EditorInfo = new TokenEditorInfo(TokenType.Keyword, TokenColor.Keyword, TokenTriggers.None);

            return term;
        }

        public KeyTerm Operator(string op)
        {
            string opCased = this.CaseSensitive ? op : op.ToLower();
            var term = new KeyTerm(opCased, op);
            //term.SetOption(TermOptions.IsOperator, true);

            term.EditorInfo = new TokenEditorInfo(TokenType.Operator, TokenColor.Keyword, TokenTriggers.None);

            return term;
        }
        protected static NumberLiteral CreateAngelScriptNumber(string name)
        {
            NumberLiteral term = new NumberLiteral(name, NumberOptions.AllowStartEndDot);
            //default int types are Integer (32bit) -> LongInteger (BigInt); Try Int64 before BigInt: Better performance?
            term.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64 };
            term.DefaultFloatType = TypeCode.Double; // it is default
            term.AddPrefix("0x", NumberOptions.Hex);
            term.AddPrefix("0b", NumberOptions.Binary);
            term.AddPrefix("0d", NumberOptions.IntOnly);
            term.AddSuffix("f", TypeCode.Double);

            return term;
        }
    }
}