auto_ptr<Rule> exstatik::CreateLexer_Simple() { auto_ptr<Rule> lexer(STAR("lexer")); Rule* or_ = lexer->AddChild(OR("or")); or_->AddChild(KEYWORD("new")); or_->AddChild(KEYWORD("del")); or_->AddChild(KEYWORD(";")); return lexer; }
auto_ptr<Rule> exstatik::CreateLexer_Splash() { auto_ptr<Rule> lexer(STAR("star")); Rule* or_ = lexer->AddChild(OR("or")); or_->AddChild(KEYWORD("cat")); or_->AddChild(KEYWORD("dog")); or_->AddChild(KEYWORD("car")); return lexer; }
auto_ptr<Rule> exstatik::CreateLexer_JSON() { auto_ptr<Rule> lexer(STAR("lexer")); Rule* or_ = lexer->AddChild(OR("Or")); or_->AddChild(KEYWORD("=")); or_->AddChild(KEYWORD("{")); or_->AddChild(KEYWORD("}")); or_->AddChild(KEYWORD(";")); or_->AddChild(REGEXP("ID", boost::regex("[A-Za-z_][0-9A-Za-z_]*"))); or_->AddChild(REGEXP("INT", boost::regex("[0-9]+"))); or_->AddChild(REGEXP("STR", boost::regex("(\'([^\'\\\\\\\\]|\\\\.)*\')|(\\\"([^\\\"\\\\\\\\]|\\\\.)*\\\")"))); or_->AddChild(REGEXP("WS", boost::regex("[ \t\r]+"))); return lexer; }
auto_ptr<Rule> exstatik::CreateLexer_Moderate() { auto_ptr<Rule> lexer(STAR("lexer")); Rule* or_ = lexer->AddChild(OR("Or")); or_->AddChild(KEYWORD("new")); or_->AddChild(KEYWORD("del")); or_->AddChild(REGEXP("ID", boost::regex("[A-Za-z_][0-9A-Za-z_]*"))); or_->AddChild(REGEXP("INT", boost::regex("[0-9]+"))); or_->AddChild(REGEXP("WS", boost::regex("[ \t\r]+"))); or_->AddChild(KEYWORD(";")); return lexer; }
// parser = ((new ;)|(del ;))* auto_ptr<Rule> exstatik::CreateParser_Simple() { auto_ptr<Rule> parser(STAR("parser")); Rule* stmts_ = parser->AddChild(OR("Or (stmts)")) ->CapOutput("cmd"); Rule* newstmt_ = stmts_->AddChild(SEQ("new stmt")); newstmt_->AddChild(META("new")); //newstmt_->AddChild(META("x")); newstmt_->AddChild(META(";")) ->SilenceOutput(); Rule* delstmt_ = stmts_->AddChild(SEQ("del stmt")); delstmt_->AddChild(META("del")); //delstmt_->AddChild(META("x")); delstmt_->AddChild(META(";")) ->SilenceOutput(); return parser; }
auto_ptr<Rule> exstatik::CreateLexer_Seq() { auto_ptr<Rule> lexer(SEQ("seq")); lexer->AddChild(KEYWORD("cat")); lexer->AddChild(KEYWORD("dog")); Rule* optmoo = lexer->AddChild(OPT("opt")); optmoo->AddChild(KEYWORD("moo")); lexer->AddChild(KEYWORD("car")); return lexer; }
auto_ptr<Rule> exstatik::CreateLexer_Nick() { auto_ptr<Rule> lexer(STAR("star")); Rule* or1_ = lexer->AddChild(OR("or1")); or1_->AddChild(KEYWORD("car")); or1_->AddChild(KEYWORD("cat")); Rule* star2_ = or1_->AddChild(STAR("star2")); star2_->AddChild(KEYWORD("dog")); return lexer; }
auto_ptr<Rule> exstatik::CreateLexer_Complex() { auto_ptr<Rule> lexer(STAR("lexer")); Rule* or_ = lexer->AddChild(OR("Or")); or_->AddChild(KEYWORD("exit")); or_->AddChild(KEYWORD("new")); or_->AddChild(KEYWORD("renew")); or_->AddChild(KEYWORD("del")); or_->AddChild(KEYWORD("@")); or_->AddChild(KEYWORD("return")); or_->AddChild(KEYWORD("if")); or_->AddChild(KEYWORD("elif")); or_->AddChild(KEYWORD("else")); or_->AddChild(KEYWORD("while")); or_->AddChild(KEYWORD("loop")); or_->AddChild(KEYWORD("times")); or_->AddChild(KEYWORD("not")); or_->AddChild(KEYWORD("nor")); or_->AddChild(KEYWORD("and")); or_->AddChild(KEYWORD("or")); or_->AddChild(KEYWORD("xor")); or_->AddChild(KEYWORD("<")); or_->AddChild(KEYWORD("<=")); or_->AddChild(KEYWORD(">")); or_->AddChild(KEYWORD(">=")); or_->AddChild(KEYWORD("==")); or_->AddChild(KEYWORD("!=")); or_->AddChild(KEYWORD("+")); or_->AddChild(KEYWORD("-")); or_->AddChild(KEYWORD("*")); or_->AddChild(KEYWORD("/")); or_->AddChild(KEYWORD("%")); or_->AddChild(KEYWORD("^")); or_->AddChild(KEYWORD("|")); or_->AddChild(KEYWORD("&")); or_->AddChild(KEYWORD("~~")); or_->AddChild(KEYWORD("~")); or_->AddChild(KEYWORD("=")); or_->AddChild(KEYWORD("+=")); or_->AddChild(KEYWORD("-=")); or_->AddChild(KEYWORD("*=")); or_->AddChild(KEYWORD("/=")); or_->AddChild(KEYWORD("%=")); or_->AddChild(KEYWORD("^=")); or_->AddChild(KEYWORD("|=")); or_->AddChild(KEYWORD("&=")); or_->AddChild(KEYWORD("~~=")); or_->AddChild(KEYWORD("~=")); or_->AddChild(KEYWORD("->")); or_->AddChild(KEYWORD("(")); or_->AddChild(KEYWORD(")")); or_->AddChild(KEYWORD("[")); or_->AddChild(KEYWORD("]")); or_->AddChild(KEYWORD("{")); or_->AddChild(KEYWORD("}")); or_->AddChild(KEYWORD(",")); or_->AddChild(KEYWORD(".")); or_->AddChild(KEYWORD(":")); or_->AddChild(KEYWORD(";")); or_->AddChild(KEYWORD("\n")); or_->AddChild(REGEXP("INT", boost::regex("[0-9]+"))); or_->AddChild(REGEXP("STR", boost::regex("(\\\'([^\\\'\\\\\\\\]|\\\\.)*\\\')|(\\\"([^\\\"\\\\\\\\]|\\\\.)*\\\")"))); or_->AddChild(REGEXP("ID", boost::regex("[A-Za-z_][0-9A-Za-z_]*"))); or_->AddChild(REGEXP("WS", boost::regex("[ \t\r]+"))); return lexer; }
auto_ptr<Rule> exstatik::CreateLexer_C() { auto_ptr<Rule> lexer(STAR("C")); Rule* or_ = lexer->AddChild(OR("or")); // symbols or_->AddChild(KEYWORD(";")); or_->AddChild(KEYWORD("{")); or_->AddChild(KEYWORD("}")); or_->AddChild(KEYWORD(",")); or_->AddChild(KEYWORD("=")); or_->AddChild(KEYWORD(":")); or_->AddChild(KEYWORD("(")); or_->AddChild(KEYWORD(")")); or_->AddChild(KEYWORD("[")); or_->AddChild(KEYWORD("]")); or_->AddChild(KEYWORD("*")); or_->AddChild(KEYWORD("...")); // keywords or_->AddChild(KEYWORD("if")); or_->AddChild(KEYWORD("else")); or_->AddChild(KEYWORD("switch")); or_->AddChild(KEYWORD("while")); or_->AddChild(KEYWORD("do")); or_->AddChild(KEYWORD("for")); or_->AddChild(KEYWORD("goto")); or_->AddChild(KEYWORD("continue")); or_->AddChild(KEYWORD("break")); or_->AddChild(KEYWORD("return")); // assignment operators or_->AddChild(KEYWORD("*=")); or_->AddChild(KEYWORD("/=")); or_->AddChild(KEYWORD("%=")); or_->AddChild(KEYWORD("+=")); or_->AddChild(KEYWORD("-=")); or_->AddChild(KEYWORD("<<=")); or_->AddChild(KEYWORD(">>=")); or_->AddChild(KEYWORD("&=")); or_->AddChild(KEYWORD("^=")); or_->AddChild(KEYWORD("|=")); // expression symbols or_->AddChild(KEYWORD("?")); or_->AddChild(KEYWORD("||")); or_->AddChild(KEYWORD("&&")); // operators or_->AddChild(KEYWORD("|")); or_->AddChild(KEYWORD("^")); or_->AddChild(KEYWORD("&")); or_->AddChild(KEYWORD("==")); or_->AddChild(KEYWORD("!=")); or_->AddChild(KEYWORD("<=")); or_->AddChild(KEYWORD(">=")); or_->AddChild(KEYWORD("<<")); or_->AddChild(KEYWORD(">>")); or_->AddChild(KEYWORD("<")); or_->AddChild(KEYWORD(">")); or_->AddChild(KEYWORD("+")); or_->AddChild(KEYWORD("-")); or_->AddChild(KEYWORD("/")); or_->AddChild(KEYWORD("%")); or_->AddChild(KEYWORD("++")); or_->AddChild(KEYWORD("--")); or_->AddChild(KEYWORD("~")); or_->AddChild(KEYWORD("!")); // accessors or_->AddChild(KEYWORD(".")); or_->AddChild(KEYWORD("->")); // storage-class-specifier or_->AddChild(KEYWORD("auto")); or_->AddChild(KEYWORD("register")); or_->AddChild(KEYWORD("static")); or_->AddChild(KEYWORD("extern")); or_->AddChild(KEYWORD("typedef")); // type-specifier or_->AddChild(KEYWORD("void")); or_->AddChild(KEYWORD("char")); or_->AddChild(KEYWORD("short")); or_->AddChild(KEYWORD("int")); or_->AddChild(KEYWORD("long")); or_->AddChild(KEYWORD("float")); or_->AddChild(KEYWORD("double")); or_->AddChild(KEYWORD("signed")); or_->AddChild(KEYWORD("unsigned")); // type-qualifier or_->AddChild(KEYWORD("const")); or_->AddChild(KEYWORD("volatile")); // regexps or_->AddChild(REGEXP("ID", boost::regex("[A-Za-z_][0-9A-Za-z_]*"))); or_->AddChild(REGEXP("INT", boost::regex("[0-9]+"))); or_->AddChild(REGEXP("WS", boost::regex("[ \t\r\n]+"))) ->SilenceOutput(); return lexer; }
// parser = ((cmd|codeblock)end)* auto_ptr<Rule> exstatik::CreateParser_Complex() { auto_ptr<Rule> parser(STAR("parser")); Rule* line = parser->AddChild(SEQ("line")); //line->AddChild(META("WS")); Rule* cmdorcode = line->AddChild(OR("Or (cmdorcode)")); Rule* end = line->AddChild(OR("end")); end->AddChild(META(";")); end->AddChild(META("\n")); Rule* cmdline = cmdorcode->AddChild(SEQ("cmdline")); cmdline->AddChild(META("ID", "program")); Rule* cmdargs = cmdline->AddChild(STAR("* (cmdargs)")); Rule* cmdarg = cmdargs->AddChild(SEQ("cmdarg")); cmdarg->AddChild(META("WS")); cmdarg->AddChild(META("arg")); Rule* codeblock = cmdorcode->AddChild(SEQ("codeblock")); codeblock->AddChild(META("{")); Rule* stmts = codeblock->AddChild(STAR("* (stmts)")); codeblock->AddChild(META("}")); Rule* stmt = stmts->AddChild(OR("Or (stmt)")); Rule* newstmt = stmt->AddChild(SEQ("new stmt")); newstmt->AddChild(META("new")); newstmt->AddChild(META("WS")); newstmt->AddChild(META("identifier", "ID")); newstmt->AddChild(META(";")); Rule* delstmt = stmt->AddChild(SEQ("del stmt")); delstmt->AddChild(META("del")); delstmt->AddChild(META("WS")); delstmt->AddChild(META("identifier", "ID")); delstmt->AddChild(META(";")); return parser; }
// parser = ((new WS ID ;)|(del WS ID ;))* auto_ptr<Rule> exstatik::CreateParser_Moderate() { auto_ptr<Rule> parser(STAR("parser")); Rule* stmts_ = parser->AddChild(OR("Or (stmts)")) ->CapOutput("cmd"); Rule* newstmt_ = stmts_->AddChild(SEQ("new stmt")); newstmt_->AddChild(META("new")); newstmt_->AddChild(META("WS")) ->SilenceOutput(); newstmt_->AddChild(META("identifier", "ID")); newstmt_->AddChild(META(";")) ->SilenceOutput(); Rule* delstmt_ = stmts_->AddChild(SEQ("del stmt")); delstmt_->AddChild(META("del")); delstmt_->AddChild(META("WS")) ->SilenceOutput(); delstmt_->AddChild(META("identifier", "ID")); delstmt_->AddChild(META(";")) ->SilenceOutput(); return parser; }
// C parser auto_ptr<Rule> exstatik::CreateParser_C() { auto_ptr<Rule> identifier_(META("identifier", "ID")); // goto_statement_ auto_ptr<Rule> integer_constant_(META("integer", "INT")); // constant_ auto_ptr<Rule> character_constant_(META("char", "CHAR")); // constant_ auto_ptr<Rule> floating_constant_(META("float", "FLOAT")); // constant_ auto_ptr<Rule> enumeration_constant_(META("enum", "ENUM")); // constant_ auto_ptr<Rule> constant_(OR("constant")); // FAKE constant_expression_ constant_->AddChild(integer_constant_); constant_->AddChild(character_constant_); constant_->AddChild(floating_constant_); constant_->AddChild(enumeration_constant_); /* postfix-expression: primary-expression postfix-expression [ expression ] postfix-expression ( argument-expression-list_OPT ) postfix-expression . identifier postfix-expression -> identifier postfix-expression ++ postfix-expression -- primary-expression: identifier constant string ( expression ) argument-expression-list: assignment-expression argument-expression-list , assignment-expression */ auto_ptr<Rule> unary_operator_(OR("unary-operator")); unary_operator_->AddChild(META("&", "&")); unary_operator_->AddChild(META("*", "*")); unary_operator_->AddChild(META("+", "+")); unary_operator_->AddChild(META("-", "-")); unary_operator_->AddChild(META("~", "~")); unary_operator_->AddChild(META("!", "!")); // FAKE auto_ptr<Rule> constant_expression_(constant_); // FAKE direct-declarator-suffix-1 /* conditional-expression: logical-OR-expression logical-OR-expression ? expression : conditional-expression constant-expression: conditional-expression logical-OR-expression: logical-AND-expression logical-OR-expression || logical-AND-expression logical-AND-expression: inclusive-OR-expression logical-AND-expression && inclusive-OR-expression inclusive-OR-expression: exclusive-OR-expression inclusive-OR-expression | exclusive-OR-expression exclusive-OR-expression: AND-expression exclusive-OR-expression ^ AND-expression AND-expression: equality-expression AND-expression & equality-expression equality-expression: relational-expression equality-expression == relational-expression equality-expression != relational-expression relational-expression: shift-expression relational-expression < shift-expression relational-expression > shift-expression relational-expression <= shift-expression relational-expression >= shift-expression shift-expression: additive-expression shift-expression << additive-expression shift-expression >> additive-expression additive-expression: multiplicative-expression additive-expression + multiplicative-expression additive-expression - multiplicative-expression multiplicative-expression: cast-expression multiplicative-expression * cast-expression multiplicative-expression / cast-expression multiplicative-expression % cast-expression cast-expression: unary-expression ( type-name ) cast-expression unary-expression: postfix-expression ++ unary-expression -- unary-expression unary-operator cast-expression sizeof unary-expression sizeof ( type-name ) */ auto_ptr<Rule> assignment_operator_(OR("assignment-operator")); // FAKE assignment_expression_ assignment_operator_->AddChild(META("=", "=")); assignment_operator_->AddChild(META("*=", "*=")); assignment_operator_->AddChild(META("/=", "/=")); assignment_operator_->AddChild(META("%=", "%=")); assignment_operator_->AddChild(META("+=", "+=")); assignment_operator_->AddChild(META("-=", "+=")); assignment_operator_->AddChild(META("<<=", "<<=")); assignment_operator_->AddChild(META(">>=", ">>=")); assignment_operator_->AddChild(META("&=", "&=")); assignment_operator_->AddChild(META("^=", "^=")); assignment_operator_->AddChild(META("|=", "|=")); /* expression: assignment-expression (, assignmentexpression)* assignment-expression: conditional-expression unary-expression assignment-operator assignment-expression */ // FAKE auto_ptr<Rule> assignment_expression_(assignment_operator_); auto_ptr<Rule> return_statement_(SEQ("return-statement")); // jump_statement_ return_statement_->AddChild(META("return", "return")); //return_statement_->AddChild(OPT(expression_)); return_statement_->AddChild(META(";", ";")); auto_ptr<Rule> break_statement_(SEQ("break-statement")); // jump_statement_ break_statement_->AddChild(META("break", "break")); break_statement_->AddChild(META(";", ";")); auto_ptr<Rule> continue_statement_(SEQ("continue-statement")); // jump_statement_ continue_statement_->AddChild(META("continue", "continue")); continue_statement_->AddChild(META(";", ";")); auto_ptr<Rule> goto_statement_(SEQ("goto-statement")); // jump_statement_ goto_statement_->AddChild(META("goto", "goto")); Rule* identifier_REC = goto_statement_->AddChild(identifier_); goto_statement_->AddChild(META(";", ";")); auto_ptr<Rule> jump_statement_(OR("jump-statement")); // statement_ jump_statement_->AddChild(goto_statement_); jump_statement_->AddChild(continue_statement_); jump_statement_->AddChild(break_statement_); jump_statement_->AddChild(return_statement_); /* labeled-statement: identifier : statement case constant-expression : statement default : statement expression-statement: expression_OPT ; (compound-statement) selection-statement: if ( expression ) statement if ( expression ) statement else statement switch ( expression ) statement iteration-statement: while ( expression ) statement do statement while ( expression ) ; for ( expression_OPT ; expression_OPT ; expression_OPT ) statement */ auto_ptr<Rule> statement_(OR("statement")); // compound_statement_ //statement_->AddChild(labeled_statement_); //statement_->AddChild(expression_statement_); //statement_->AddChild(selection_statement_); //statement_->AddChild(iteration_statement_); statement_->AddChild(jump_statement_); auto_ptr<Rule> compound_statement_(SEQ("compound-statement")); // function_definition_ compound_statement_->CapOutput("compound-statement"); compound_statement_->AddChild(META("{", "{")); Rule* declaration_STAR = compound_statement_->AddChild(STAR("declaration-STAR")); Rule* statement_STAR = compound_statement_->AddChild(STAR("statement-STAR")); Rule* statement_REC = statement_STAR->AddChild(statement_); compound_statement_->AddChild(META("}", "}")); /* type-name: specifier-qualifier-list abstract-declarator_OPT */ auto_ptr<Rule> direct_abstract_declarator_3(SEQ("direct-abstract-declarator-3")); // direct_abstract_declarator_ auto_ptr<Rule> direct_abstract_declarator_2(SEQ("direct-abstract-declarator-2")); // direct_abstract_declarator_ auto_ptr<Rule> direct_abstract_declarator_1(SEQ("direct-abstract-declarator-1")); // direct_abstract_declarator_ auto_ptr<Rule> direct_abstract_declarator_(OR("direct-abstract-declarator")); // abstract_declarator_1 Rule* direct_abstract_declarator_1_REC = direct_abstract_declarator_->AddChild(direct_abstract_declarator_1); Rule* direct_abstract_declarator_2_REC = direct_abstract_declarator_->AddChild(direct_abstract_declarator_2); Rule* direct_abstract_declarator_3_REC = direct_abstract_declarator_->AddChild(direct_abstract_declarator_3); auto_ptr<Rule> abstract_declarator_1(SEQ("abstract-declarator-1")); // abstract_declarator_ auto_ptr<Rule> abstract_declarator_(OR("abstract-declarator")); // parameter_declaration_1 auto_ptr<Rule> initializer_2(SEQ("initializer-2")); // initializer_1 auto_ptr<Rule> initializer_1(SEQ("initializer-1")); // initializer_ auto_ptr<Rule> initializer_(OR("initializer")); // init_declarator_ initializer_->AddChild(assignment_expression_); Rule* initializer_1_REC = initializer_->AddChild(initializer_1); Rule* initializer_2_REC = initializer_->AddChild(initializer_2); auto_ptr<Rule> identifier_list_1(SEQ("identifier-list-1")); // identifier_list_ identifier_list_1->AddChild(META(",", ",")); identifier_list_1->AddChildRecursive(identifier_REC); auto_ptr<Rule> identifier_list_(SEQ("identifier-list")); // direct_declarator_suffix_3 identifier_list_->AddChildRecursive(identifier_REC); Rule* identifier_list_1_STAR = identifier_list_->AddChild(STAR("identifier-list-1-STAR")); identifier_list_1_STAR->AddChild(identifier_list_1); auto_ptr<Rule> parameter_declaration_1(OR("parameter-declaration-1")); // parameter_declaration_ auto_ptr<Rule> parameter_declaration_(SEQ("parameter-declaration")); // parameter_list_1 auto_ptr<Rule> parameter_list_1(SEQ("parameter-list-1")); // parameter_list_ parameter_list_1->AddChild(META(",", ",")); Rule* parameter_declaration_REC = parameter_list_1->AddChild(parameter_declaration_); auto_ptr<Rule> parameter_list_(SEQ("parameter-list")); // parameter_type_list_ parameter_list_->CapOutput("parameter-list"); parameter_list_->AddChildRecursive(parameter_declaration_REC); Rule* parameter_list_1_STAR = parameter_list_->AddChild(STAR("parameter-list-1-STAR")); parameter_list_1_STAR->AddChild(parameter_list_1); auto_ptr<Rule> parameter_type_list_1(SEQ("parameter-type-list-1")); // parameter_type_list_ parameter_type_list_1->AddChild(META(",", ",")); parameter_type_list_1->AddChild(META("...", "...")); auto_ptr<Rule> parameter_type_list_(SEQ("parameter-type-list")); // direct_declarator_suffix_ parameter_type_list_->AddChild(parameter_list_); Rule* parameter_type_list_1_OPT = parameter_type_list_->AddChild(OPT("parameter-type-list-1-OPT")); parameter_type_list_1_OPT->AddChild(parameter_type_list_1); auto_ptr<Rule> pointer_1(SEQ("pointer-1")); // pointer_ auto_ptr<Rule> pointer_(PLUS("pointer")); // declarator_ pointer_->CapOutput("pointer"); Rule* pointer_1_REC = pointer_->AddChild(pointer_1); auto_ptr<Rule> direct_declarator_suffix_3(SEQ("direct-declarator-suffix-3")); // direct_declarator_suffix_ direct_declarator_suffix_3->AddChild(META("(", "(")); Rule* identifier_list_OPT = direct_declarator_suffix_3->AddChild(OPT("identifier-list-OPT")); identifier_list_OPT->AddChild(identifier_list_); direct_declarator_suffix_3->AddChild(META(")", ")")); auto_ptr<Rule> direct_declarator_suffix_2(SEQ("direct-declarator-suffix-2")); // direct_declarator_suffix_ direct_declarator_suffix_2->AddChild(META("(", "(")); Rule* parameter_type_list_REC = direct_declarator_suffix_2->AddChild(parameter_type_list_); direct_declarator_suffix_2->AddChild(META(")", ")")); auto_ptr<Rule> direct_declarator_suffix_1(SEQ("direct-declarator-suffix-1")); // direct_declarator_suffix_ direct_declarator_suffix_1->AddChild(META("[", "[")); Rule* constant_expression_REC = direct_declarator_suffix_1->AddChild(constant_expression_); direct_declarator_suffix_1->AddChild(META("]", "]")); auto_ptr<Rule> direct_declarator_suffix_(OR("direct-declarator-suffix")); // direct_declarator_2 direct_declarator_suffix_->AddChild(direct_declarator_suffix_1); direct_declarator_suffix_->AddChild(direct_declarator_suffix_2); direct_declarator_suffix_->AddChild(direct_declarator_suffix_3); auto_ptr<Rule> direct_declarator_2(SEQ("direct-declarator-2")); // direct_declarator_ auto_ptr<Rule> direct_declarator_1(SEQ("direct-declarator-1")); // direct_declarator_ auto_ptr<Rule> direct_declarator_(OR("direct-declarator")); // declarator_ Rule* direct_declarator_1_REC = direct_declarator_->AddChild(direct_declarator_1); Rule* direct_declarator_2_REC = direct_declarator_->AddChild(direct_declarator_2); auto_ptr<Rule> declarator_(SEQ("declarator")); // struct_declarator_1 declarator_->CapOutput("declarator"); Rule* pointer_OPT = declarator_->AddChild(OPT("pointer-OPT")); Rule* pointer_REC = pointer_OPT->AddChild(pointer_); declarator_->AddChild(direct_declarator_); /* auto_ptr<Rule> enumerator_1(SEQ("enumerator-1")); enumerator_1->AddChild(META("=", "=")); enumerator_1->AddChildRecursive(constant_expression_REC); auto_ptr<Rule> enumerator_(SEQ("enumerator")); enumerator_->AddChild(identifier_); enumerator_->AddChild(OPT(enumerator_1)); auto_ptr<Rule> enumerator_list_1(SEQ("enumerator-list-1")); enumerator_list_1->AddChild(META(",", ",")); enumerator_list_1->AddChild(enumerator_); auto_ptr<Rule> enumerator_list_(SEQ("enumerator-list")); enumerator_list->AddChild(enumerator_); enumerator_list->AddChild(STAR(enumerator_list_1)); auto_ptr<Rule> enum_specifier_1(SEQ("enum-specifier-1")); enum_specifier_1->AddChild(META("enum", "enum")); enum_specifier_1->AddChild(identifier_); auto_ptr<Rule> enum_specifier_2(SEQ("enum-specifier-2")); enum_specifier_2->AddChild(META("enum", "enum")); enum_specifier_2->AddChild(OPT(identifier_)); enum_specifier_2->AddChild(META("{", "{")); enum_specifier_2->AddChild(enumerator_list_); enum_specifier_2->AddChild(META("}", "}")); auto_ptr<Rule> enum_specifier_(OR("enum-specifier")); enum_specifier_->AddChild(enum_specifier_1); enum_specifier_->AddChild(enum_specifier_2); */ auto_ptr<Rule> struct_declarator_1(SEQ("struct-declarator-1")); // struct_declarator_ Rule* declarator_OPT = struct_declarator_1->AddChild(OPT("declarator-OPT")); Rule* declarator_REC = declarator_OPT->AddChild(declarator_); auto_ptr<Rule> struct_declarator_(OR("struct-declarator")); // struct_declarator_list_ struct_declarator_->AddChildRecursive(declarator_REC); Rule* struct_declarator_1_REC = struct_declarator_->AddChild(struct_declarator_1); auto_ptr<Rule> struct_declarator_list_1(OR("struct-declarator-list-1")); // struct_declarator_list_ struct_declarator_list_1->AddChild(META(",", ",")); Rule* struct_declarator_REC = struct_declarator_list_1->AddChild(struct_declarator_); auto_ptr<Rule> struct_declarator_list_(SEQ("struct-declarator-list")); // specifier_qualifier_list_1 struct_declarator_list_->AddChildRecursive(struct_declarator_REC); struct_declarator_list_->AddChild(struct_declarator_list_1); auto_ptr<Rule> specifier_qualifier_list_1(SEQ("specifier-qualifier-list-1")); // specifier_qualifier_list_ auto_ptr<Rule> specifier_qualifier_list_2(SEQ("specifier-qualifier-list-2")); // specifier_qualifier_list_ auto_ptr<Rule> specifier_qualifier_list_(OR("specifier-qualifier-list")); // struct_declaration_ Rule* specifier_qualifier_list_1_REC = specifier_qualifier_list_->AddChild(specifier_qualifier_list_1); Rule* specifier_qualifier_list_2_REC = specifier_qualifier_list_->AddChild(specifier_qualifier_list_2); auto_ptr<Rule> struct_declaration_(SEQ("struct-declaration")); // struct_or_union_specifier_ auto_ptr<Rule> init_declarator_1(OR("init-declarator-1")); // init_declarator_ init_declarator_1->AddChildRecursive(declarator_REC); init_declarator_1->AddChild(META("=", "=")); Rule* initializer_REC = init_declarator_1->AddChild(initializer_); auto_ptr<Rule> init_declarator_(OR("init-declarator")); // init_declarator_list_1 init_declarator_->AddChildRecursive(declarator_REC); init_declarator_->AddChild(init_declarator_1); auto_ptr<Rule> init_declarator_list_1(SEQ("init-declarator-list-1")); // init_declarator_list_1_STAR init_declarator_list_1->AddChild(META(",", ",")); Rule* init_declarator_REC = init_declarator_list_1->AddChild(init_declarator_); auto_ptr<Rule> init_declarator_list_(SEQ("init-declarator-list")); // declaration_ init_declarator_list_->AddChildRecursive(init_declarator_REC); Rule* init_declarator_list_1_STAR = init_declarator_list_->AddChild(STAR("init-declarator-list-1-STAR")); init_declarator_list_1_STAR->AddChild(init_declarator_list_1); auto_ptr<Rule> struct_or_union_(OR("struct-or-union")); // struct_or_union_specifier_1 struct_or_union_->AddChild(META("struct", "struct")); struct_or_union_->AddChild(META("union", "union")); auto_ptr<Rule> struct_or_union_specifier_1(SEQ("struct-or-union-specifier-1")); // struct_or_union_specifier_ Rule* struct_or_union_REC = struct_or_union_specifier_1->AddChild(struct_or_union_); Rule* identifier_OPT = struct_or_union_specifier_1->AddChild(OPT("identifier-OPT")); identifier_OPT->AddChildRecursive(identifier_REC); struct_or_union_specifier_1->AddChild(META("{", "{")); Rule* struct_declaration_PLUS = struct_or_union_specifier_1->AddChild(PLUS("struct-declaration-PLUS")); Rule* struct_declaration_REC = struct_declaration_PLUS->AddChild(struct_declaration_); struct_or_union_specifier_1->AddChild(META("}", "}")); auto_ptr<Rule> struct_or_union_specifier_2(SEQ("struct-or-union-specifier-2")); // struct_or_union_specifier_ struct_or_union_specifier_2->AddChildRecursive(struct_or_union_REC); struct_or_union_specifier_1->AddChildRecursive(identifier_REC); auto_ptr<Rule> struct_or_union_specifier_(OR("struct-or-union-specifier")); // type_specifier_ struct_or_union_specifier_->AddChild(struct_or_union_specifier_1); struct_or_union_specifier_->AddChild(struct_or_union_specifier_2); auto_ptr<Rule> typedef_name_(META("identifier", "ID")); // type_specifier_ auto_ptr<Rule> type_qualifier_(OR("type-qualifier")); // declaration_specifiers_1 type_qualifier_->CapOutput("type-qualifier"); type_qualifier_->AddChild(META("const", "const")); type_qualifier_->AddChild(META("volatile", "volatile")); auto_ptr<Rule> type_specifier_(OR("type-specifier")); // declaration_specifiers_1 type_specifier_->CapOutput("type-specifier"); type_specifier_->AddChild(META("void", "void")); type_specifier_->AddChild(META("char", "char")); type_specifier_->AddChild(META("short", "short")); type_specifier_->AddChild(META("int", "int")); type_specifier_->AddChild(META("long", "long")); type_specifier_->AddChild(META("float", "float")); type_specifier_->AddChild(META("double", "double")); type_specifier_->AddChild(META("signed", "signed")); type_specifier_->AddChild(META("unsigned", "unsigned")); type_specifier_->AddChild(struct_or_union_specifier_); //type_specifier_->AddChild(enum_specifier_); type_specifier_->AddChild(typedef_name_); auto_ptr<Rule> storage_class_specifier_(OR("storage-class-specifier")); // declaration_specifiers_1 storage_class_specifier_->CapOutput("storage-class-specifier"); storage_class_specifier_->AddChild(META("auto", "auto")); storage_class_specifier_->AddChild(META("register", "register")); storage_class_specifier_->AddChild(META("static", "static")); storage_class_specifier_->AddChild(META("extern", "extern")); storage_class_specifier_->AddChild(META("typedef", "typedef")); auto_ptr<Rule> declaration_specifiers_1(OR("declaration-specifiers-1")); // declaration_specifiers_ declaration_specifiers_1->AddChild(storage_class_specifier_); Rule* type_specifier_REC = declaration_specifiers_1->AddChild(type_specifier_); Rule* type_qualifier_REC = declaration_specifiers_1->AddChild(type_qualifier_); auto_ptr<Rule> declaration_specifiers_(SEQ("declaration-specifiers")); // declaration_ declaration_specifiers_->AddChild(declaration_specifiers_1); Rule* declaration_specifiers_OPT = declaration_specifiers_->AddChild(OPT("declaration-specifiers-OPT")); auto_ptr<Rule> declaration_(SEQ("declaration")); // external_declaration_ declaration_->CapOutput("declaration"); Rule* declaration_specifiers_REC = declaration_->AddChild(declaration_specifiers_); Rule* init_declarator_list_OPT = declaration_->AddChild(OPT("init-declarator-list-OPT")); init_declarator_list_OPT->AddChild(init_declarator_list_); declaration_->AddChild(META(";", ";")); auto_ptr<Rule> function_definition_(SEQ("function-definition")); // external_declaration_ function_definition_->CapOutput("function-definition"); function_definition_->AddChildRecursive(declaration_specifiers_OPT); function_definition_->AddChildRecursive(declarator_REC); function_definition_->AddChildRecursive(declaration_STAR); Rule* compound_statement_REC = function_definition_->AddChild(compound_statement_); // { ... } auto_ptr<Rule> external_declaration_(OR("external-declaration")); // translation_unit_ external_declaration_->CapOutput("external-declaration"); external_declaration_->AddChild(function_definition_); Rule* declaration_REC = external_declaration_->AddChild(declaration_); auto_ptr<Rule> translation_unit_(PLUS("C_parser")); translation_unit_->AddChild(external_declaration_); // recursive reckoning declaration_specifiers_OPT->AddChildRecursive(declaration_specifiers_REC); declaration_STAR->AddChildRecursive(declaration_REC); specifier_qualifier_list_1_REC->AddChildRecursive(type_specifier_REC); Rule* struct_declarator_list_OPT = specifier_qualifier_list_1_REC->AddChild(OPT("struct-declarator-list-OPT")); Rule* struct_declarator_list_REC = struct_declarator_list_OPT->AddChild(struct_declarator_list_); specifier_qualifier_list_2_REC->AddChildRecursive(type_qualifier_REC); specifier_qualifier_list_2_REC->AddChildRecursive(struct_declarator_list_REC); struct_declaration_REC->AddChild(specifier_qualifier_list_); struct_declaration_REC->AddChildRecursive(struct_declarator_list_REC); struct_declaration_REC->AddChild(META(";", ";")); direct_declarator_2_REC->AddChild(META("(", "(")); direct_declarator_2_REC->AddChildRecursive(declarator_REC); direct_declarator_2_REC->AddChild(META(")", ")")); Rule* direct_declarator_suffix_STAR = direct_declarator_2_REC->AddChild(STAR("direct-declarator-suffix-STAR")); direct_declarator_suffix_STAR->AddChild(direct_declarator_suffix_); direct_declarator_1_REC->AddChildRecursive(identifier_REC); direct_declarator_1_REC->AddChildRecursive(direct_declarator_suffix_STAR); parameter_declaration_1->AddChildRecursive(declarator_REC); Rule* abstract_declarator_OPT = parameter_declaration_1->AddChild(OPT("abstract-declarator-OPT")); Rule* abstract_declarator_REC = abstract_declarator_OPT->AddChild(abstract_declarator_); parameter_declaration_REC->AddChildRecursive(declaration_specifiers_REC); parameter_declaration_REC->AddChild(parameter_declaration_1); struct_declarator_1_REC->AddChild(META(":", ":")); struct_declarator_1_REC->AddChildRecursive(constant_expression_REC); initializer_2_REC->AddChild(META(",", ",")); Rule* initializer_OPT = initializer_2_REC->AddChild(OPT("initializer-OPT")); initializer_OPT->AddChildRecursive(initializer_REC); initializer_1_REC->AddChild(META("{", "{")); initializer_1_REC->AddChildRecursive(initializer_REC); Rule* initializer_2_OPT = initializer_1_REC->AddChild(OPT("initializer-2-OPT")); initializer_2_OPT->AddChild(initializer_2); initializer_1_REC->AddChild(META("}", "}")); pointer_1_REC->AddChild(META("*", "*")); Rule* type_qualifier_STAR = pointer_1_REC->AddChild(STAR("type-qualifier-STAR")); type_qualifier_STAR->AddChildRecursive(type_qualifier_REC); abstract_declarator_1->AddChildRecursive(pointer_OPT); Rule* direct_abstract_declarator_REC = abstract_declarator_1->AddChild(direct_abstract_declarator_); Rule* direct_abstract_declarator_OPT = direct_abstract_declarator_3_REC->AddChild(OPT("direct-abstract-declarator-OPT")); direct_abstract_declarator_OPT->AddChildRecursive(direct_abstract_declarator_REC); direct_abstract_declarator_3_REC->AddChild(META("[", "[")); Rule* constant_expression_OPT = direct_abstract_declarator_3_REC->AddChild(OPT("constant-expression-OPT")); constant_expression_OPT->AddChildRecursive(constant_expression_REC); direct_abstract_declarator_3_REC->AddChild(META("]", "]")); direct_abstract_declarator_2_REC->AddChildRecursive(direct_abstract_declarator_OPT); direct_abstract_declarator_2_REC->AddChild(META("[", "[")); Rule* parameter_type_list_OPT = direct_abstract_declarator_2_REC->AddChild(OPT("parameter-type-list-OPT")); parameter_type_list_OPT->AddChildRecursive(parameter_type_list_REC); direct_abstract_declarator_2_REC->AddChild(META("]", "]")); direct_abstract_declarator_1_REC->AddChild(META("(", "(")); direct_abstract_declarator_1_REC->AddChildRecursive(abstract_declarator_REC); direct_abstract_declarator_1_REC->AddChild(META(")", ")")); abstract_declarator_REC->AddChildRecursive(pointer_REC); abstract_declarator_REC->AddChild(abstract_declarator_1); statement_REC->AddChildRecursive(compound_statement_REC); return translation_unit_; }
// JSON parser auto_ptr<Rule> exstatik::CreateParser_JSON() { auto_ptr<Rule> parser(STAR("JSON")); Rule* var_ = parser->AddChild(SEQ("var")) ->CapOutput("var"); Rule* ws_OPT = var_->AddChild(OPT("ws?")); ws_OPT->AddChild(META("WS", "WS")); var_->AddChild(META("name", "ID")); var_->AddChildRecursive(ws_OPT); var_->AddChild(META("=", "=")); var_->AddChildRecursive(ws_OPT); Rule* value_ = var_->AddChild(OR("value")); Rule* semi_OPT = var_->AddChild(OPT("semi?")); var_->AddChildRecursive(ws_OPT); semi_OPT->AddChild(META(";", ";")); var_->AddChildRecursive(ws_OPT); value_->AddChild(META("string", "STR")); Rule* object_ = value_->AddChild(SEQ("object")); object_->AddChild(META("{", "{")); Rule* var_STAR = object_->AddChild(STAR("varstar")); var_STAR->AddChildRecursive(var_); object_->AddChild(META("}", "}")); return parser; }
// Nifty parser auto_ptr<Rule> exstatik::CreateParser_Nifty() { auto_ptr<Rule> parser(STAR("parser")); Rule* stmts_ = parser->AddChild(OR("Or (stmts)")) ->CapOutput("stmt"); /* Rule* cmd_ = stmts_->AddChild(SEQ("cmd stmt")); cmd_->AddChild(META("cmd", "ID")); Rule* cmdexts_ = cmd_->AddChild(STAR("cmdexts")); Rule* cmdext_ = cmdexts_->AddChild(SEQ("cmdext")); cmdext_->AddChild(META("cmd", "WS")); cmdext_->AddChild(META("cmd", "ID")); */ Rule* newstmt_ = stmts_->AddChild(SEQ("new stmt")); newstmt_->AddChild(META("new")); newstmt_->AddChild(META("WS")) ->SilenceOutput(); Rule* newor_ = newstmt_->AddChild(STAR("new*")); newor_->AddChildRecursive(newstmt_); newstmt_->AddChild(META("identifier", "ID")); newstmt_->AddChild(META(";")) ->SilenceOutput(); Rule* delstmt_ = stmts_->AddChild(SEQ("del stmt")); delstmt_->AddChild(META("del")); delstmt_->AddChild(META("WS")) ->SilenceOutput(); delstmt_->AddChild(META("identifier", "ID")); delstmt_->AddChild(META(";")) ->SilenceOutput(); return parser; }