/** * $ANTLR start program * TestGrammar.g:7:1: program : HELLO WORLD ; */ static void program(pTestGrammarParser ctx) { /* Initialize rule variables */ { // TestGrammar.g:7:9: ( HELLO WORLD ) // TestGrammar.g:7:11: HELLO WORLD { MATCHT(HELLO, &FOLLOW_HELLO_in_program24); if (HASEXCEPTION()) { goto ruleprogramEx; } MATCHT(WORLD, &FOLLOW_WORLD_in_program26); if (HASEXCEPTION()) { goto ruleprogramEx; } } } // This is where rules clean up and exit // goto ruleprogramEx; /* Prevent compiler warnings */ ruleprogramEx: ; if (HASEXCEPTION()) { PREPORTERROR(); PRECOVER(); } return ; }
/** * $ANTLR start line * corpconf.g:72:1: line[CorpInfo &c] : ( ( 'ATTRIBUTE' v= value | 'STRUCTURE' v= value | 'PROCESS' v= value ) ( LBRACE NL block[*b] r= RBRACE )? NL | a= ATTR v= value NL ); */ static corpconfParser_line_return line(pcorpconfParser ctx, CorpInfo &c) { corpconfParser_line_return retval; pANTLR3_BASE_TREE root_0; pANTLR3_COMMON_TOKEN r; pANTLR3_COMMON_TOKEN a; pANTLR3_COMMON_TOKEN string_literal5; pANTLR3_COMMON_TOKEN string_literal6; pANTLR3_COMMON_TOKEN string_literal7; pANTLR3_COMMON_TOKEN LBRACE8; pANTLR3_COMMON_TOKEN NL9; pANTLR3_COMMON_TOKEN NL11; pANTLR3_COMMON_TOKEN NL12; corpconfParser_value_return v; #undef RETURN_TYPE_v #define RETURN_TYPE_v corpconfParser_value_return corpconfParser_block_return block10; #undef RETURN_TYPE_block10 #define RETURN_TYPE_block10 corpconfParser_block_return pANTLR3_BASE_TREE r_tree; pANTLR3_BASE_TREE a_tree; pANTLR3_BASE_TREE string_literal5_tree; pANTLR3_BASE_TREE string_literal6_tree; pANTLR3_BASE_TREE string_literal7_tree; pANTLR3_BASE_TREE LBRACE8_tree; pANTLR3_BASE_TREE NL9_tree; pANTLR3_BASE_TREE NL11_tree; pANTLR3_BASE_TREE NL12_tree; /* Initialize rule variables */ root_0 = NULL; CorpInfo *b; r = NULL; a = NULL; string_literal5 = NULL; string_literal6 = NULL; string_literal7 = NULL; LBRACE8 = NULL; NL9 = NULL; NL11 = NULL; NL12 = NULL; v.tree = NULL; block10.tree = NULL; retval.start = LT(1); retval.stop = retval.start; r_tree = NULL; a_tree = NULL; string_literal5_tree = NULL; string_literal6_tree = NULL; string_literal7_tree = NULL; LBRACE8_tree = NULL; NL9_tree = NULL; NL11_tree = NULL; NL12_tree = NULL; retval.tree = NULL; { { // corpconf.g:74:2: ( ( 'ATTRIBUTE' v= value | 'STRUCTURE' v= value | 'PROCESS' v= value ) ( LBRACE NL block[*b] r= RBRACE )? NL | a= ATTR v= value NL ) ANTLR3_UINT32 alt4; alt4=2; switch ( LA(1) ) { case 11: case 12: case 13: { alt4=1; } break; case ATTR: { alt4=2; } break; default: CONSTRUCTEX(); EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; EXCEPTION->message = (void *)""; EXCEPTION->decisionNum = 4; EXCEPTION->state = 0; goto rulelineEx; } switch (alt4) { case 1: // corpconf.g:75:3: ( 'ATTRIBUTE' v= value | 'STRUCTURE' v= value | 'PROCESS' v= value ) ( LBRACE NL block[*b] r= RBRACE )? NL { root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); // corpconf.g:75:3: ( 'ATTRIBUTE' v= value | 'STRUCTURE' v= value | 'PROCESS' v= value ) { int alt2=3; switch ( LA(1) ) { case 11: { alt2=1; } break; case 12: { alt2=2; } break; case 13: { alt2=3; } break; default: CONSTRUCTEX(); EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; EXCEPTION->message = (void *)""; EXCEPTION->decisionNum = 2; EXCEPTION->state = 0; goto rulelineEx; } switch (alt2) { case 1: // corpconf.g:75:5: 'ATTRIBUTE' v= value { string_literal5 = (pANTLR3_COMMON_TOKEN) MATCHT(11, &FOLLOW_11_in_line319); if (HASEXCEPTION()) { goto rulelineEx; } string_literal5_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal5)); ADAPTOR->addChild(ADAPTOR, root_0, string_literal5_tree); FOLLOWPUSH(FOLLOW_value_in_line323); v=value(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto rulelineEx; } ADAPTOR->addChild(ADAPTOR, root_0, v.tree); { b = new CorpInfo(); c.attrs.push_back (std::pair<std::string,CorpInfo*>(v.v, b)); } } break; case 2: // corpconf.g:79:5: 'STRUCTURE' v= value { string_literal6 = (pANTLR3_COMMON_TOKEN) MATCHT(12, &FOLLOW_12_in_line334); if (HASEXCEPTION()) { goto rulelineEx; } string_literal6_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal6)); ADAPTOR->addChild(ADAPTOR, root_0, string_literal6_tree); FOLLOWPUSH(FOLLOW_value_in_line338); v=value(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto rulelineEx; } ADAPTOR->addChild(ADAPTOR, root_0, v.tree); { b = new CorpInfo(); c.structs.push_back (std::pair<std::string,CorpInfo*>(v.v, b)); } } break; case 3: // corpconf.g:83:5: 'PROCESS' v= value { string_literal7 = (pANTLR3_COMMON_TOKEN) MATCHT(13, &FOLLOW_13_in_line349); if (HASEXCEPTION()) { goto rulelineEx; } string_literal7_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal7)); ADAPTOR->addChild(ADAPTOR, root_0, string_literal7_tree); FOLLOWPUSH(FOLLOW_value_in_line353); v=value(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto rulelineEx; } ADAPTOR->addChild(ADAPTOR, root_0, v.tree); { b = new CorpInfo(); c.procs.push_back (std::pair<std::string,CorpInfo*>(v.v, b)); } } break; } } // corpconf.g:88:3: ( LBRACE NL block[*b] r= RBRACE )? { int alt3=2; switch ( LA(1) ) { case LBRACE: { alt3=1; } break; } switch (alt3) { case 1: // corpconf.g:88:4: LBRACE NL block[*b] r= RBRACE { LBRACE8 = (pANTLR3_COMMON_TOKEN) MATCHT(LBRACE, &FOLLOW_LBRACE_in_line367); if (HASEXCEPTION()) { goto rulelineEx; } LBRACE8_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, LBRACE8)); ADAPTOR->addChild(ADAPTOR, root_0, LBRACE8_tree); NL9 = (pANTLR3_COMMON_TOKEN) MATCHT(NL, &FOLLOW_NL_in_line369); if (HASEXCEPTION()) { goto rulelineEx; } NL9_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, NL9)); ADAPTOR->addChild(ADAPTOR, root_0, NL9_tree); FOLLOWPUSH(FOLLOW_block_in_line371); block10=block(ctx, *b); FOLLOWPOP(); if (HASEXCEPTION()) { goto rulelineEx; } ADAPTOR->addChild(ADAPTOR, root_0, block10.tree); r = (pANTLR3_COMMON_TOKEN) MATCHT(RBRACE, &FOLLOW_RBRACE_in_line376); if (HASEXCEPTION()) { goto rulelineEx; } r_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, r)); ADAPTOR->addChild(ADAPTOR, root_0, r_tree); } break; } } NL11 = (pANTLR3_COMMON_TOKEN) MATCHT(NL, &FOLLOW_NL_in_line380); if (HASEXCEPTION()) { goto rulelineEx; } NL11_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, NL11)); ADAPTOR->addChild(ADAPTOR, root_0, NL11_tree); } break; case 2: // corpconf.g:89:4: a= ATTR v= value NL { root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); a = (pANTLR3_COMMON_TOKEN) MATCHT(ATTR, &FOLLOW_ATTR_in_line387); if (HASEXCEPTION()) { goto rulelineEx; } a_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, a)); ADAPTOR->addChild(ADAPTOR, root_0, a_tree); FOLLOWPUSH(FOLLOW_value_in_line391); v=value(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto rulelineEx; } ADAPTOR->addChild(ADAPTOR, root_0, v.tree); NL12 = (pANTLR3_COMMON_TOKEN) MATCHT(NL, &FOLLOW_NL_in_line393); if (HASEXCEPTION()) { goto rulelineEx; } NL12_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, NL12)); ADAPTOR->addChild(ADAPTOR, root_0, NL12_tree); { c.opts [std::string((const char *) (a->getText(a))->chars)] = v.v; } } break; } } } // This is where rules clean up and exit // goto rulelineEx; /* Prevent compiler warnings */ rulelineEx: ; retval.stop = LT(-1); retval.stop = LT(-1); retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); if (HASEXCEPTION()) { /* catch(decl,action) */ { PREPORTERROR(); RECOGNIZER->consumeUntil(RECOGNIZER, NL); block(CTX, *b); } } else { } return retval; }
/** * $ANTLR start config * corpconf.g:59:1: config[CorpInfo &c] : block[c] EOF ; */ static corpconfParser_config_return config(pcorpconfParser ctx, CorpInfo &c) { corpconfParser_config_return retval; pANTLR3_BASE_TREE root_0; pANTLR3_COMMON_TOKEN EOF2; corpconfParser_block_return block1; #undef RETURN_TYPE_block1 #define RETURN_TYPE_block1 corpconfParser_block_return pANTLR3_BASE_TREE EOF2_tree; /* Initialize rule variables */ root_0 = NULL; EOF2 = NULL; block1.tree = NULL; retval.start = LT(1); retval.stop = retval.start; EOF2_tree = NULL; retval.tree = NULL; { // corpconf.g:60:2: ( block[c] EOF ) // corpconf.g:60:4: block[c] EOF { root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); FOLLOWPUSH(FOLLOW_block_in_config269); block1=block(ctx, c); FOLLOWPOP(); if (HASEXCEPTION()) { goto ruleconfigEx; } ADAPTOR->addChild(ADAPTOR, root_0, block1.tree); EOF2 = (pANTLR3_COMMON_TOKEN) MATCHT(EOF, &FOLLOW_EOF_in_config272); if (HASEXCEPTION()) { goto ruleconfigEx; } EOF2_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, EOF2)); ADAPTOR->addChild(ADAPTOR, root_0, EOF2_tree); } } // This is where rules clean up and exit // goto ruleconfigEx; /* Prevent compiler warnings */ ruleconfigEx: ; retval.stop = LT(-1); retval.stop = LT(-1); retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); if (HASEXCEPTION()) { /* catch(decl,action) */ { PREPORTERROR(); RECOGNIZER->consumeUntil(RECOGNIZER, NL); config(CTX, c); } } else { } return retval; }
/** * $ANTLR start block * corpconf.g:68:1: block[CorpInfo &c] : ( line[c] | NL )* ; */ static corpconfParser_block_return block(pcorpconfParser ctx, CorpInfo &c) { corpconfParser_block_return retval; pANTLR3_BASE_TREE root_0; pANTLR3_COMMON_TOKEN NL4; corpconfParser_line_return line3; #undef RETURN_TYPE_line3 #define RETURN_TYPE_line3 corpconfParser_line_return pANTLR3_BASE_TREE NL4_tree; /* Initialize rule variables */ root_0 = NULL; NL4 = NULL; line3.tree = NULL; retval.start = LT(1); retval.stop = retval.start; NL4_tree = NULL; retval.tree = NULL; { // corpconf.g:69:2: ( ( line[c] | NL )* ) // corpconf.g:69:4: ( line[c] | NL )* { root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); // corpconf.g:69:4: ( line[c] | NL )* for (;;) { int alt1=3; switch ( LA(1) ) { case ATTR: case 11: case 12: case 13: { alt1=1; } break; case NL: { alt1=2; } break; } switch (alt1) { case 1: // corpconf.g:69:5: line[c] { FOLLOWPUSH(FOLLOW_line_in_block293); line3=line(ctx, c); FOLLOWPOP(); if (HASEXCEPTION()) { goto ruleblockEx; } ADAPTOR->addChild(ADAPTOR, root_0, line3.tree); } break; case 2: // corpconf.g:69:13: NL { NL4 = (pANTLR3_COMMON_TOKEN) MATCHT(NL, &FOLLOW_NL_in_block296); if (HASEXCEPTION()) { goto ruleblockEx; } NL4_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, NL4)); ADAPTOR->addChild(ADAPTOR, root_0, NL4_tree); } break; default: goto loop1; /* break out of the loop */ break; } } loop1: ; /* Jump out to here if this rule does not match */ } } // This is where rules clean up and exit // goto ruleblockEx; /* Prevent compiler warnings */ ruleblockEx: ; retval.stop = LT(-1); retval.stop = LT(-1); retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); if (HASEXCEPTION()) { PREPORTERROR(); PRECOVER(); retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); } return retval; }
/** * $ANTLR start value * corpconf.g:98:1: value returns [std::string v] : (s= STR | p= PATH | 'AT' a= PATH ); */ static corpconfParser_value_return value(pcorpconfParser ctx) { corpconfParser_value_return retval; pANTLR3_BASE_TREE root_0; pANTLR3_COMMON_TOKEN s; pANTLR3_COMMON_TOKEN p; pANTLR3_COMMON_TOKEN a; pANTLR3_COMMON_TOKEN string_literal13; pANTLR3_BASE_TREE s_tree; pANTLR3_BASE_TREE p_tree; pANTLR3_BASE_TREE a_tree; pANTLR3_BASE_TREE string_literal13_tree; /* Initialize rule variables */ root_0 = NULL; s = NULL; p = NULL; a = NULL; string_literal13 = NULL; retval.start = LT(1); retval.stop = retval.start; s_tree = NULL; p_tree = NULL; a_tree = NULL; string_literal13_tree = NULL; retval.tree = NULL; { { // corpconf.g:99:2: (s= STR | p= PATH | 'AT' a= PATH ) ANTLR3_UINT32 alt5; alt5=3; switch ( LA(1) ) { case STR: { alt5=1; } break; case PATH: { alt5=2; } break; case 14: { alt5=3; } break; default: CONSTRUCTEX(); EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; EXCEPTION->message = (void *)""; EXCEPTION->decisionNum = 5; EXCEPTION->state = 0; goto rulevalueEx; } switch (alt5) { case 1: // corpconf.g:99:4: s= STR { root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); s = (pANTLR3_COMMON_TOKEN) MATCHT(STR, &FOLLOW_STR_in_value422); if (HASEXCEPTION()) { goto rulevalueEx; } s_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, s)); ADAPTOR->addChild(ADAPTOR, root_0, s_tree); { retval.v= std::string((const char *) (s->getText(s))->chars); } } break; case 2: // corpconf.g:100:4: p= PATH { root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); p = (pANTLR3_COMMON_TOKEN) MATCHT(PATH, &FOLLOW_PATH_in_value442); if (HASEXCEPTION()) { goto rulevalueEx; } p_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, p)); ADAPTOR->addChild(ADAPTOR, root_0, p_tree); { retval.v= std::string((const char *) (p->getText(p))->chars); } } break; case 3: // corpconf.g:101:4: 'AT' a= PATH { root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); string_literal13 = (pANTLR3_COMMON_TOKEN) MATCHT(14, &FOLLOW_14_in_value459); if (HASEXCEPTION()) { goto rulevalueEx; } string_literal13_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal13)); ADAPTOR->addChild(ADAPTOR, root_0, string_literal13_tree); a = (pANTLR3_COMMON_TOKEN) MATCHT(PATH, &FOLLOW_PATH_in_value463); if (HASEXCEPTION()) { goto rulevalueEx; } a_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, a)); ADAPTOR->addChild(ADAPTOR, root_0, a_tree); { retval.v= std::string("@") + std::string((const char *) (a->getText(a))->chars); } } break; } } } // This is where rules clean up and exit // goto rulevalueEx; /* Prevent compiler warnings */ rulevalueEx: ; retval.stop = LT(-1); retval.stop = LT(-1); retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); if (HASEXCEPTION()) { PREPORTERROR(); PRECOVER(); retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); } return retval; }