/**
* $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 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;
}
