Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 123456]

ccc::alsoStyle< T >
myparser::RuleLine< RL >::Helper< N, I >
myparser::Node
myparser::NodeError< E >
myparser::NodeList< TX >
myparser::NodeText< TX >
myparser::NodeList<>
myparser::NodeListIndexed< I >
myparser::NodeSpace< I >
myparser::NodeTypedProto< BuiltinSpace, NodeSpace< I > >
myparser::NodeTyped< BuiltinSpace, NodeListIndexed< I > >
myparser::NodeText<>
myparser::NodeTextOrError< E >
myparser::NodeData< T, E >
myparser::NodeTextOrError< ErrorId >
myparser::NodeId< TX >
myparser::NodeId<>
myparser::NodeTypedProto< RuleId, NodeId<> >
myparser::NodeTyped< RuleId, NodeText<> >
myparser::Parser< N >
myparser::Pass< I >
myparser::Pass< PASS_FIN >
myparser::PassBase
myparser::PassProto< I >
myparser::PassProto< PASS_FILTER >
myparser::Pass< PASS_FILTER >
myparser::PassProto< PASS_REPR >
myparser::Pass< PASS_REPR >
myparser::PassReprFull< TX >
myparser::PassReprJSON< TX >
myparser::PassReprSimple< TX >
myparser::PassReprText< TX >
myparser::Rule
myparser::RuleNamed< N >
myparser::RuleDef< N >
myparser::RuleList< N, RL >
myparser::RuleRegex< N, RX >
myparser::RuleNamed< BuiltinError >
myparser::RuleDef< BuiltinError >
myparser::RuleNamed< MP_STR("access operation", 16) >
myparser::RuleList< MP_STR("access operation", 16), RuleLine< RuleItemRef< MP_STR("argument apply", 14)>, RuleItemSpace<>, RuleItemRef< MP_STR("access operation", 16)> >, RuleLine< RuleItemKeyword< MP_STR(".", 1)>, RuleItemSpace<>, RuleItemRef< MP_STR("id", 2)>, RuleItemSpace<>, RuleItemRef< MP_STR("access operation", 16)> >, RuleLine< > >
myparser::RuleDef< MP_STR("access operation", 16)>
myparser::RuleNamed< MP_STR("addition", 8) >
myparser::RuleList< MP_STR("addition", 8), RuleLine< RuleItemRef< MP_STR("addsub", 6)> >, RuleLine< RuleItemKeyword< MP_STR("or", 2)> >, RuleLine< RuleItemKeyword< MP_STR("xor", 3)> > >
myparser::RuleDef< MP_STR("addition", 8)>
myparser::RuleNamed< MP_STR("additive expression", 19) >
myparser::RuleList< MP_STR("additive expression", 19), RuleLine< RuleItemRef< MP_STR("multiplicative expression", 25)>, RuleItemSpace<>, RuleItemRef< MP_STR("additive operation", 18)> > >
myparser::RuleDef< MP_STR("additive expression", 19)>
myparser::RuleNamed< MP_STR("additive operation", 18) >
myparser::RuleList< MP_STR("additive operation", 18), RuleLine< RuleItemRef< MP_STR("addition", 8)>, RuleItemSpace<>, RuleItemRef< MP_STR("additive expression", 19)> >, RuleLine< > >
myparser::RuleDef< MP_STR("additive operation", 18)>
myparser::RuleNamed< MP_STR("addsub", 6) >
myparser::RuleRegex< MP_STR("addsub", 6), >
myparser::RuleDef< MP_STR("addsub", 6)>
myparser::RuleNamed< MP_STR("argument apply", 14) >
myparser::RuleList< MP_STR("argument apply", 14), RuleLine< RuleItemRef< MP_STR("literal", 7)> >, RuleLine< RuleItemRef< MP_STR("id", 2)> >, RuleLine< RuleItemKeyword< MP_STR("(", 1)>, RuleItemSpace<>, RuleItemRef< MP_STR("expression list", 15)>, RuleItemSpace<>, RuleItemKeyword< MP_STR(")", 1)> > >
myparser::RuleDef< MP_STR("argument apply", 14)>
myparser::RuleNamed< MP_STR("argument list", 13) >
myparser::RuleList< MP_STR("argument list", 13), RuleLine< RuleItemRef< MP_STR("argument option", 15)>, RuleItemSpace<>, RuleItemRef< MP_STR("id", 2)>, RuleItemSpace<>, RuleItemKeyword< MP_STR(",", 1)>, RuleItemSpace<>, RuleItemRef< MP_STR("argument list", 13)> >, RuleLine< RuleItemRef< MP_STR("argument option", 15)>, RuleItemSpace<>, RuleItemRef< MP_STR("id", 2)> >, RuleLine< > >
myparser::RuleDef< MP_STR("argument list", 13)>
myparser::RuleNamed< MP_STR("argument option", 15) >
myparser::RuleList< MP_STR("argument option", 15), RuleLine< RuleItemKeyword< MP_STR("in", 2)> >, RuleLine< RuleItemKeyword< MP_STR("out", 3)> >, RuleLine< RuleItemKeyword< MP_STR("fast", 4)>, RuleItemSpace<>, RuleItemRef< MP_STR("id", 2)> >, RuleLine< > >
myparser::RuleDef< MP_STR("argument option", 15)>
myparser::RuleNamed< MP_STR("array", 5) >
myparser::RuleList< MP_STR("array", 5), RuleLine< RuleItemKeyword< MP_STR("array", 5)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("of", 2)>, RuleItemSpace<>, RuleItemRef< MP_STR("integer", 7)>, RuleItemSpace<>, RuleItemRef< MP_STR("type", 4)> > >
myparser::RuleDef< MP_STR("array", 5)>
myparser::RuleNamed< MP_STR("assign sign", 11) >
myparser::RuleRegex< MP_STR("assign sign", 11), >
myparser::RuleDef< MP_STR("assign sign", 11)>
myparser::RuleNamed< MP_STR("assignment", 10) >
myparser::RuleList< MP_STR("assignment", 10), RuleLine< RuleItemRef< MP_STR("expression", 10)>, RuleItemSpace<>, RuleItemRef< MP_STR("assign sign", 11)>, RuleItemSpace<>, RuleItemRef< MP_STR("expression", 10)> > >
myparser::RuleDef< MP_STR("assignment", 10)>
myparser::RuleNamed< MP_STR("boolean", 7) >
myparser::RuleList< MP_STR("boolean", 7), RuleLine< RuleItemKeyword< MP_STR("yes", 3)> >, RuleLine< RuleItemKeyword< MP_STR("no", 2)> > >
myparser::RuleDef< MP_STR("boolean", 7)>
myparser::RuleNamed< MP_STR("byte", 4) >
myparser::RuleRegex< MP_STR("byte", 4), >
myparser::RuleDef< MP_STR("byte", 4)>
myparser::RuleNamed< MP_STR("class", 5) >
myparser::RuleList< MP_STR("class", 5), RuleLine< RuleItemKeyword< MP_STR("class", 5)>, RuleItemSpace<>, RuleItemRef< MP_STR("main body", 9)> > >
myparser::RuleDef< MP_STR("class", 5)>
myparser::RuleNamed< MP_STR("code block", 10) >
myparser::RuleList< MP_STR("code block", 10), RuleLine< RuleItemKeyword< MP_STR("begin", 5)>, RuleItemSpace<>, RuleItemRef< MP_STR("statement list", 14)> >, RuleLine< > >
myparser::RuleDef< MP_STR("code block", 10)>
myparser::RuleNamed< MP_STR("comparison", 10) >
myparser::RuleRegex< MP_STR("comparison", 10), >
myparser::RuleDef< MP_STR("comparison", 10)>
myparser::RuleNamed< MP_STR("condition chain", 15) >
myparser::RuleList< MP_STR("condition chain", 15), RuleLine< RuleItemKeyword< MP_STR("elif", 4)>, RuleItemSpace<>, RuleItemRef< MP_STR("expression", 10)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("then", 4)>, RuleItemSpace<>, RuleItemRef< MP_STR("statement list", 14)>, RuleItemSpace<>, RuleItemRef< MP_STR("condition chain", 15)> >, RuleLine< RuleItemKeyword< MP_STR("else", 4)>, RuleItemSpace<>, RuleItemRef< MP_STR("statement list", 14)> >, RuleLine< > >
myparser::RuleDef< MP_STR("condition chain", 15)>
myparser::RuleNamed< MP_STR("const definition", 16) >
myparser::RuleList< MP_STR("const definition", 16), RuleLine< RuleItemKeyword< MP_STR("const", 5)>, RuleItemSpace<>, RuleItemRef< MP_STR("id", 2)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("is", 2)>, RuleItemSpace<>, RuleItemRef< MP_STR("type", 4)> > >
myparser::RuleDef< MP_STR("const definition", 16)>
myparser::RuleNamed< MP_STR("definition", 10) >
myparser::RuleList< MP_STR("definition", 10), RuleLine< RuleItemRef< MP_STR("var definition", 14)>, RuleItemSpace<>, RuleItemKeyword< MP_STR(";", 1)> >, RuleLine< RuleItemRef< MP_STR("const definition", 16)>, RuleItemSpace<>, RuleItemKeyword< MP_STR(";", 1)> >, RuleLine< RuleItemRef< MP_STR("static definition", 17)>, RuleItemSpace<>, RuleItemKeyword< MP_STR(";", 1)> >, RuleLine< RuleItemRef< MP_STR("type definition", 15)>, RuleItemSpace<>, RuleItemKeyword< MP_STR(";", 1)> >, RuleLine< RuleItemRef< MP_STR("program", 7)>, RuleItemSpace<>, RuleItemKeyword< MP_STR(";", 1)> >, RuleLine< RuleItemRef< MP_STR("function", 8)>, RuleItemSpace<>, RuleItemKeyword< MP_STR(";", 1)> >, RuleLine< RuleItemRef< MP_STR("return definition", 17)>, RuleItemSpace<>, RuleItemKeyword< MP_STR(";", 1)> >, RuleLine< RuleItemKeyword< MP_STR(";", 1)> > >
myparser::RuleDef< MP_STR("definition", 10)>
myparser::RuleNamed< MP_STR("expression list", 15) >
myparser::RuleList< MP_STR("expression list", 15), RuleLine< RuleItemRef< MP_STR("expression", 10)>, RuleItemSpace<>, RuleItemKeyword< MP_STR(",", 1)>, RuleItemSpace<>, RuleItemRef< MP_STR("expression list", 15)> >, RuleLine< RuleItemRef< MP_STR("expression", 10)> >, RuleLine< > >
myparser::RuleDef< MP_STR("expression list", 15)>
myparser::RuleNamed< MP_STR("expression", 10) >
myparser::RuleList< MP_STR("expression", 10), RuleLine< RuleItemRef< MP_STR("relative expression", 19)> > >
myparser::RuleDef< MP_STR("expression", 10)>
myparser::RuleNamed< MP_STR("for range", 9) >
myparser::RuleList< MP_STR("for range", 9), RuleLine< RuleItemRef< MP_STR("expression", 10)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("to", 2)>, RuleItemSpace<>, RuleItemRef< MP_STR("expression", 10)> >, RuleLine< RuleItemRef< MP_STR("expression", 10)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("downto", 6)>, RuleItemSpace<>, RuleItemRef< MP_STR("expression", 10)> > >
myparser::RuleDef< MP_STR("for range", 9)>
myparser::RuleNamed< MP_STR("function proto", 14) >
myparser::RuleList< MP_STR("function proto", 14), RuleLine< RuleItemRef< MP_STR("id", 2)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("(", 1)>, RuleItemSpace<>, RuleItemRef< MP_STR("argument list", 13)>, RuleItemSpace<>, RuleItemKeyword< MP_STR(")", 1)> > >
myparser::RuleDef< MP_STR("function proto", 14)>
myparser::RuleNamed< MP_STR("function type", 13) >
myparser::RuleList< MP_STR("function type", 13), RuleLine< RuleItemKeyword< MP_STR("function", 8)>, RuleItemSpace<>, RuleItemRef< MP_STR("id", 2)> > >
myparser::RuleDef< MP_STR("function type", 13)>
myparser::RuleNamed< MP_STR("function", 8) >
myparser::RuleList< MP_STR("function", 8), RuleLine< RuleItemKeyword< MP_STR("function", 8)>, RuleItemSpace<>, RuleItemRef< MP_STR("function proto", 14)>, RuleItemSpace<>, RuleItemRef< MP_STR("main body", 9)> > >
myparser::RuleDef< MP_STR("function", 8)>
myparser::RuleNamed< MP_STR("id", 2) >
myparser::RuleRegex< MP_STR("id", 2), >
myparser::RuleDef< MP_STR("id", 2)>
myparser::RuleNamed< MP_STR("ignored", 7) >
myparser::RuleRegex< MP_STR("ignored", 7), >
myparser::RuleDef< MP_STR("ignored", 7)>
myparser::RuleNamed< MP_STR("instant array", 13) >
myparser::RuleList< MP_STR("instant array", 13), RuleLine< RuleItemKeyword< MP_STR("[", 1)>, RuleItemSpace<>, RuleItemRef< MP_STR("expression list", 15)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("]", 1)> > >
myparser::RuleDef< MP_STR("instant array", 13)>
myparser::RuleNamed< MP_STR("integer", 7) >
myparser::RuleRegex< MP_STR("integer", 7), >
myparser::RuleDef< MP_STR("integer", 7)>
myparser::RuleNamed< MP_STR("interface block", 15) >
myparser::RuleList< MP_STR("interface block", 15), RuleLine< RuleItemRef< MP_STR("definition", 10)>, RuleItemSpace<>, RuleItemRef< MP_STR("interface block", 15)> >, RuleLine< > >
myparser::RuleDef< MP_STR("interface block", 15)>
myparser::RuleNamed< MP_STR("is block", 8) >
myparser::RuleList< MP_STR("is block", 8), RuleLine< RuleItemKeyword< MP_STR("is", 2)>, RuleItemSpace<>, RuleItemRef< MP_STR("interface block", 15)> >, RuleLine< > >
myparser::RuleDef< MP_STR("is block", 8)>
myparser::RuleNamed< MP_STR("keyword", 7) >
myparser::RuleList< MP_STR("keyword", 7), RuleLine< RuleItemRef< MP_STR("reserved id", 11)> >, RuleLine< RuleItemRef< MP_STR("sign", 4)> > >
myparser::RuleDef< MP_STR("keyword", 7)>
myparser::RuleNamed< MP_STR("literal", 7) >
myparser::RuleList< MP_STR("literal", 7), RuleLine< RuleItemRef< MP_STR("boolean", 7)> >, RuleLine< RuleItemRef< MP_STR("byte", 4)> >, RuleLine< RuleItemRef< MP_STR("integer", 7)> >, RuleLine< RuleItemRef< MP_STR("real", 4)> >, RuleLine< RuleItemRef< MP_STR("string", 6)> >, RuleLine< RuleItemRef< MP_STR("instant array", 13)> > >
myparser::RuleDef< MP_STR("literal", 7)>
myparser::RuleNamed< MP_STR("main body", 9) >
myparser::RuleList< MP_STR("main body", 9), RuleLine< RuleItemRef< MP_STR("specific list", 13)>, RuleItemSpace<>, RuleItemRef< MP_STR("interface block", 15)>, RuleItemSpace<>, RuleItemRef< MP_STR("is block", 8)>, RuleItemSpace<>, RuleItemRef< MP_STR("code block", 10)>, RuleItemSpace<>, RuleItemRef< MP_STR("main end", 8)> > >
myparser::RuleDef< MP_STR("main body", 9)>
myparser::RuleNamed< MP_STR("main end", 8) >
myparser::RuleList< MP_STR("main end", 8), RuleLine< RuleItemKeyword< MP_STR("end", 3)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("program", 7)>, RuleItemSpace<>, RuleItemRef< MP_STR("id", 2)> >, RuleLine< RuleItemKeyword< MP_STR("end", 3)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("function", 8)>, RuleItemSpace<>, RuleItemRef< MP_STR("id", 2)> >, RuleLine< RuleItemKeyword< MP_STR("end", 3)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("class", 5)> >, RuleLine< RuleItemKeyword< MP_STR("end", 3)> > >
myparser::RuleDef< MP_STR("main end", 8)>
myparser::RuleNamed< MP_STR("main structure", 14) >
myparser::RuleList< MP_STR("main structure", 14), RuleLine< RuleItemRef< MP_STR("program", 7)> >, RuleLine< RuleItemRef< MP_STR("function", 8)> >, RuleLine< RuleItemRef< MP_STR("class", 5)> > >
myparser::RuleDef< MP_STR("main structure", 14)>
myparser::RuleNamed< MP_STR("muldiv", 6) >
myparser::RuleRegex< MP_STR("muldiv", 6), >
myparser::RuleDef< MP_STR("muldiv", 6)>
myparser::RuleNamed< MP_STR("multiplication", 14) >
myparser::RuleList< MP_STR("multiplication", 14), RuleLine< RuleItemRef< MP_STR("muldiv", 6)> >, RuleLine< RuleItemKeyword< MP_STR("div", 3)> >, RuleLine< RuleItemKeyword< MP_STR("mod", 3)> >, RuleLine< RuleItemKeyword< MP_STR("and", 3)> >, RuleLine< RuleItemKeyword< MP_STR("shl", 3)> >, RuleLine< RuleItemKeyword< MP_STR("shr", 3)> >, RuleLine< RuleItemKeyword< MP_STR("rol", 3)> >, RuleLine< RuleItemKeyword< MP_STR("ror", 3)> > >
myparser::RuleDef< MP_STR("multiplication", 14)>
myparser::RuleNamed< MP_STR("multiplicative expression", 25) >
myparser::RuleList< MP_STR("multiplicative expression", 25), RuleLine< RuleItemRef< MP_STR("unary expression", 16)>, RuleItemSpace<>, RuleItemRef< MP_STR("multiplicative operation", 24)> > >
myparser::RuleDef< MP_STR("multiplicative expression", 25)>
myparser::RuleNamed< MP_STR("multiplicative operation", 24) >
myparser::RuleList< MP_STR("multiplicative operation", 24), RuleLine< RuleItemRef< MP_STR("multiplication", 14)>, RuleItemSpace<>, RuleItemRef< MP_STR("multiplicative expression", 25)> >, RuleLine< > >
myparser::RuleDef< MP_STR("multiplicative operation", 24)>
myparser::RuleNamed< MP_STR("native type", 11) >
myparser::RuleList< MP_STR("native type", 11), RuleLine< RuleItemKeyword< MP_STR("void", 4)> >, RuleLine< RuleItemKeyword< MP_STR("boolean", 7)> >, RuleLine< RuleItemKeyword< MP_STR("byte", 4)> >, RuleLine< RuleItemKeyword< MP_STR("integer", 7)> >, RuleLine< RuleItemKeyword< MP_STR("real", 4)> >, RuleLine< RuleItemKeyword< MP_STR("bitset", 6)> > >
myparser::RuleDef< MP_STR("native type", 11)>
myparser::RuleNamed< MP_STR("pointer", 7) >
myparser::RuleList< MP_STR("pointer", 7), RuleLine< RuleItemKeyword< MP_STR("pointer", 7)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("of", 2)>, RuleItemSpace<>, RuleItemRef< MP_STR("type", 4)> > >
myparser::RuleDef< MP_STR("pointer", 7)>
myparser::RuleNamed< MP_STR("program type", 12) >
myparser::RuleList< MP_STR("program type", 12), RuleLine< RuleItemKeyword< MP_STR("program", 7)>, RuleItemSpace<>, RuleItemRef< MP_STR("id", 2)> > >
myparser::RuleDef< MP_STR("program type", 12)>
myparser::RuleNamed< MP_STR("program", 7) >
myparser::RuleList< MP_STR("program", 7), RuleLine< RuleItemKeyword< MP_STR("program", 7)>, RuleItemSpace<>, RuleItemRef< MP_STR("function proto", 14)>, RuleItemSpace<>, RuleItemRef< MP_STR("main body", 9)> > >
myparser::RuleDef< MP_STR("program", 7)>
myparser::RuleNamed< MP_STR("real", 4) >
myparser::RuleRegex< MP_STR("real", 4), >
myparser::RuleDef< MP_STR("real", 4)>
myparser::RuleNamed< MP_STR("reference", 9) >
myparser::RuleList< MP_STR("reference", 9), RuleLine< RuleItemKeyword< MP_STR("reference", 9)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("of", 2)>, RuleItemSpace<>, RuleItemRef< MP_STR("type", 4)> > >
myparser::RuleDef< MP_STR("reference", 9)>
myparser::RuleNamed< MP_STR("relation", 8) >
myparser::RuleList< MP_STR("relation", 8), RuleLine< RuleItemRef< MP_STR("comparison", 10)> >, RuleLine< RuleItemKeyword< MP_STR("in", 2)> > >
myparser::RuleDef< MP_STR("relation", 8)>
myparser::RuleNamed< MP_STR("relative expression", 19) >
myparser::RuleList< MP_STR("relative expression", 19), RuleLine< RuleItemRef< MP_STR("additive expression", 19)>, RuleItemSpace<>, RuleItemRef< MP_STR("relative operation", 18)> > >
myparser::RuleDef< MP_STR("relative expression", 19)>
myparser::RuleNamed< MP_STR("relative operation", 18) >
myparser::RuleList< MP_STR("relative operation", 18), RuleLine< RuleItemRef< MP_STR("relation", 8)>, RuleItemSpace<>, RuleItemRef< MP_STR("relative expression", 19)> >, RuleLine< > >
myparser::RuleDef< MP_STR("relative operation", 18)>
myparser::RuleNamed< MP_STR("repeat", 6) >
myparser::RuleList< MP_STR("repeat", 6), RuleLine< RuleItemKeyword< MP_STR("repeat", 6)>, RuleItemSpace<>, RuleItemRef< MP_STR("statement list", 14)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("until", 5)>, RuleItemSpace<>, RuleItemRef< MP_STR("expression", 10)> > >
myparser::RuleDef< MP_STR("repeat", 6)>
myparser::RuleNamed< MP_STR("reserved id", 11) >
myparser::RuleRegex< MP_STR("reserved id", 11), >
myparser::RuleDef< MP_STR("reserved id", 11)>
myparser::RuleNamed< MP_STR("return definition", 17) >
myparser::RuleList< MP_STR("return definition", 17), RuleLine< RuleItemKeyword< MP_STR("return", 6)>, RuleItemSpace<>, RuleItemRef< MP_STR("id", 2)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("is", 2)>, RuleItemSpace<>, RuleItemRef< MP_STR("type", 4)> >, RuleLine< RuleItemKeyword< MP_STR("return", 6)>, RuleItemSpace<>, RuleItemRef< MP_STR("type", 4)> > >
myparser::RuleDef< MP_STR("return definition", 17)>
myparser::RuleNamed< MP_STR("return", 6) >
myparser::RuleList< MP_STR("return", 6), RuleLine< RuleItemKeyword< MP_STR("return", 6)>, RuleItemSpace<>, RuleItemRef< MP_STR("expression", 10)> >, RuleLine< RuleItemKeyword< MP_STR("return", 6)> > >
myparser::RuleDef< MP_STR("return", 6)>
myparser::RuleNamed< MP_STR("root", 4) >
myparser::RuleList< MP_STR("root", 4), RuleLine< RuleItemSpace<>, RuleItemRef< MP_STR("main structure", 14)>, RuleItemSpace<>, RuleItemKeyword< MP_STR(";", 1)>, RuleItemSpace<> >, RuleLine< RuleItemSpace<>, RuleItemRef< MP_STR("main structure", 14)>, RuleItemSpace<> >, RuleLine< RuleItemError< MP_STR("Syntax error", 12)> > >
myparser::RuleDef< MP_STR("root", 4)>
myparser::RuleNamed< MP_STR("sign", 4) >
myparser::RuleRegex< MP_STR("sign", 4), >
myparser::RuleDef< MP_STR("sign", 4)>
myparser::RuleNamed< MP_STR("space", 5) >
myparser::RuleList< MP_STR("space", 5), RuleLine< RuleItemRef< MP_STR("ignored", 7)> > >
myparser::RuleDef< MP_STR("space", 5)>
myparser::RuleNamed< MP_STR("specific list", 13) >
myparser::RuleList< MP_STR("specific list", 13), RuleLine< RuleItemRef< MP_STR("specific", 8)>, RuleItemSpace<>, RuleItemKeyword< MP_STR(",", 1)>, RuleItemSpace<>, RuleItemRef< MP_STR("specific list", 13)> >, RuleLine< RuleItemRef< MP_STR("specific", 8)> >, RuleLine< > >
myparser::RuleDef< MP_STR("specific list", 13)>
myparser::RuleNamed< MP_STR("specific", 8) >
myparser::RuleList< MP_STR("specific", 8), RuleLine< RuleItemKeyword< MP_STR("extends", 7)>, RuleItemSpace<>, RuleItemRef< MP_STR("type", 4)> >, RuleLine< RuleItemKeyword< MP_STR("encloses", 8)>, RuleItemSpace<>, RuleItemRef< MP_STR("expression", 10)> > >
myparser::RuleDef< MP_STR("specific", 8)>
myparser::RuleNamed< MP_STR("statement list", 14) >
myparser::RuleList< MP_STR("statement list", 14), RuleLine< RuleItemRef< MP_STR("statement", 9)>, RuleItemSpace<>, RuleItemRef< MP_STR("statement list", 14)> >, RuleLine< > >
myparser::RuleDef< MP_STR("statement list", 14)>
myparser::RuleNamed< MP_STR("statement", 9) >
myparser::RuleList< MP_STR("statement", 9), RuleLine< RuleItemRef< MP_STR("expression", 10)>, RuleItemSpace<>, RuleItemKeyword< MP_STR(";", 1)> >, RuleLine< RuleItemRef< MP_STR("assignment", 10)>, RuleItemSpace<>, RuleItemKeyword< MP_STR(";", 1)> >, RuleLine< RuleItemRef< MP_STR("return", 6)>, RuleItemSpace<>, RuleItemKeyword< MP_STR(";", 1)> >, RuleLine< RuleItemRef< MP_STR("structure", 9)> >, RuleLine< RuleItemRef< MP_STR("repeat", 6)>, RuleItemSpace<>, RuleItemKeyword< MP_STR(";", 1)> >, RuleLine< RuleItemKeyword< MP_STR(";", 1)> > >
myparser::RuleDef< MP_STR("statement", 9)>
myparser::RuleNamed< MP_STR("static definition", 17) >
myparser::RuleList< MP_STR("static definition", 17), RuleLine< RuleItemKeyword< MP_STR("static", 6)>, RuleItemSpace<>, RuleItemRef< MP_STR("id", 2)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("is", 2)>, RuleItemSpace<>, RuleItemRef< MP_STR("type", 4)> > >
myparser::RuleDef< MP_STR("static definition", 17)>
myparser::RuleNamed< MP_STR("string", 6) >
myparser::RuleRegex< MP_STR("string", 6), >
myparser::RuleDef< MP_STR("string", 6)>
myparser::RuleNamed< MP_STR("structure end", 13) >
myparser::RuleList< MP_STR("structure end", 13), RuleLine< RuleItemKeyword< MP_STR("end", 3)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("if", 2)> >, RuleLine< RuleItemKeyword< MP_STR("end", 3)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("for", 3)> >, RuleLine< RuleItemKeyword< MP_STR("end", 3)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("foreach", 7)> >, RuleLine< RuleItemKeyword< MP_STR("end", 3)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("while", 5)> > >
myparser::RuleDef< MP_STR("structure end", 13)>
myparser::RuleNamed< MP_STR("structure", 9) >
myparser::RuleList< MP_STR("structure", 9), RuleLine< RuleItemKeyword< MP_STR("if", 2)>, RuleItemSpace<>, RuleItemRef< MP_STR("expression", 10)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("then", 4)>, RuleItemSpace<>, RuleItemRef< MP_STR("statement list", 14)>, RuleItemSpace<>, RuleItemRef< MP_STR("condition chain", 15)>, RuleItemSpace<>, RuleItemRef< MP_STR("structure end", 13)> >, RuleLine< RuleItemKeyword< MP_STR("for", 3)>, RuleItemSpace<>, RuleItemRef< MP_STR("id", 2)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("in", 2)>, RuleItemSpace<>, RuleItemRef< MP_STR("for range", 9)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("do", 2)>, RuleItemSpace<>, RuleItemRef< MP_STR("statement list", 14)>, RuleItemSpace<>, RuleItemRef< MP_STR("structure end", 13)> >, RuleLine< RuleItemKeyword< MP_STR("foreach", 7)>, RuleItemSpace<>, RuleItemRef< MP_STR("id", 2)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("in", 2)>, RuleItemSpace<>, RuleItemRef< MP_STR("expression", 10)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("do", 2)>, RuleItemSpace<>, RuleItemRef< MP_STR("statement list", 14)>, RuleItemSpace<>, RuleItemRef< MP_STR("structure end", 13)> >, RuleLine< RuleItemKeyword< MP_STR("while", 5)>, RuleItemSpace<>, RuleItemRef< MP_STR("expression", 10)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("do", 2)>, RuleItemSpace<>, RuleItemRef< MP_STR("statement list", 14)>, RuleItemSpace<>, RuleItemRef< MP_STR("structure end", 13)> > >
myparser::RuleDef< MP_STR("structure", 9)>
myparser::RuleNamed< MP_STR("type definition", 15) >
myparser::RuleList< MP_STR("type definition", 15), RuleLine< RuleItemKeyword< MP_STR("type", 4)>, RuleItemSpace<>, RuleItemRef< MP_STR("id", 2)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("is", 2)>, RuleItemSpace<>, RuleItemRef< MP_STR("type", 4)> > >
myparser::RuleDef< MP_STR("type definition", 15)>
myparser::RuleNamed< MP_STR("type inference", 14) >
myparser::RuleList< MP_STR("type inference", 14), RuleLine< RuleItemKeyword< MP_STR("type", 4)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("of", 2)>, RuleItemSpace<>, RuleItemRef< MP_STR("expression", 10)> > >
myparser::RuleDef< MP_STR("type inference", 14)>
myparser::RuleNamed< MP_STR("type", 4) >
myparser::RuleList< MP_STR("type", 4), RuleLine< RuleItemRef< MP_STR("native type", 11)> >, RuleLine< RuleItemRef< MP_STR("wrap type", 9)> >, RuleLine< RuleItemRef< MP_STR("program type", 12)> >, RuleLine< RuleItemRef< MP_STR("function type", 13)> >, RuleLine< RuleItemRef< MP_STR("type inference", 14)> >, RuleLine< RuleItemRef< MP_STR("class", 5)> >, RuleLine< RuleItemRef< MP_STR("id", 2)> > >
myparser::RuleDef< MP_STR("type", 4)>
myparser::RuleNamed< MP_STR("unary expression", 16) >
myparser::RuleList< MP_STR("unary expression", 16), RuleLine< RuleItemRef< MP_STR("unary operator", 14)>, RuleItemSpace<>, RuleItemRef< MP_STR("unary expression", 16)> >, RuleLine< RuleItemRef< MP_STR("literal", 7)>, RuleItemSpace<>, RuleItemRef< MP_STR("access operation", 16)> >, RuleLine< RuleItemRef< MP_STR("id", 2)>, RuleItemSpace<>, RuleItemRef< MP_STR("access operation", 16)> >, RuleLine< RuleItemKeyword< MP_STR("(", 1)>, RuleItemSpace<>, RuleItemRef< MP_STR("expression", 10)>, RuleItemSpace<>, RuleItemKeyword< MP_STR(")", 1)> > >
myparser::RuleDef< MP_STR("unary expression", 16)>
myparser::RuleNamed< MP_STR("unary operator", 14) >
myparser::RuleList< MP_STR("unary operator", 14), RuleLine< RuleItemRef< MP_STR("addsub", 6)> >, RuleLine< RuleItemKeyword< MP_STR("not", 3)> > >
myparser::RuleDef< MP_STR("unary operator", 14)>
myparser::RuleNamed< MP_STR("var definition", 14) >
myparser::RuleList< MP_STR("var definition", 14), RuleLine< RuleItemKeyword< MP_STR("var", 3)>, RuleItemSpace<>, RuleItemRef< MP_STR("id", 2)>, RuleItemSpace<>, RuleItemKeyword< MP_STR("is", 2)>, RuleItemSpace<>, RuleItemRef< MP_STR("type", 4)> > >
myparser::RuleDef< MP_STR("var definition", 14)>
myparser::RuleNamed< MP_STR("wrap type", 9) >
myparser::RuleList< MP_STR("wrap type", 9), RuleLine< RuleItemRef< MP_STR("array", 5)> >, RuleLine< RuleItemRef< MP_STR("pointer", 7)> >, RuleLine< RuleItemRef< MP_STR("reference", 9)> > >
myparser::RuleDef< MP_STR("wrap type", 9)>
myparser::RuleLine< RL >
myparser::StaticStr< C >
T
myparser::NodeTypedProto< N, T, I >
myparser::NodeTypedProto< N, T >
myparser::NodeTyped< N, T >
TAG
myparser::RuleItemError< E, TAG >
myparser::RuleItemKeyword< KW, N, TAG >
myparser::RuleItemRef< N, TAG >
myparser::RuleItemSpace< N, TAG >
myparser::Tag< L, M >