void P::factor() {
returnAST = RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
RefBasicAST factor_AST = RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
try { // for error handling
factor2();
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
{ // ( ... )*
for (;;) {
if ((LA(1) == MOD || LA(1) == EXP)) {
{
switch ( LA(1)) {
case EXP:
{
RefBinaryCompArithOpAST tmp11_AST = RefBinaryCompArithOpAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp11_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp11_AST));
match(EXP);
break;
}
case MOD:
{
RefBinaryCompArithOpAST tmp12_AST = RefBinaryCompArithOpAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp12_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp12_AST));
match(MOD);
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
factor2();
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
}
else {
goto _loop14;
}
}
_loop14:;
} // ( ... )*
factor_AST = RefBasicAST(currentAST.root);
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_3);
}
returnAST = factor_AST;
}
void P::arith_exp() {
returnAST = RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
RefBasicAST arith_exp_AST = RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
try { // for error handling
term();
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
{ // ( ... )*
for (;;) {
if ((LA(1) == PLUS || LA(1) == MINUS)) {
{
switch ( LA(1)) {
case PLUS:
{
RefBinaryCompArithOpAST tmp7_AST = RefBinaryCompArithOpAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp7_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp7_AST));
match(PLUS);
break;
}
case MINUS:
{
RefBinaryCompArithOpAST tmp8_AST = RefBinaryCompArithOpAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp8_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp8_AST));
match(MINUS);
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
term();
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
}
else {
goto _loop6;
}
}
_loop6:;
} // ( ... )*
arith_exp_AST = RefBasicAST(currentAST.root);
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_1);
}
returnAST = arith_exp_AST;
}
void P::const_lit() {
returnAST = RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
RefBasicAST const_lit_AST = RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
try { // for error handling
switch ( LA(1)) {
case INT:
{
RefDataTypeAST tmp22_AST = RefDataTypeAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp22_AST = astFactory->create(LT(1));
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp22_AST));
match(INT);
const_lit_AST = RefBasicAST(currentAST.root);
break;
}
case FLOAT:
{
RefDataTypeAST tmp23_AST = RefDataTypeAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp23_AST = astFactory->create(LT(1));
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp23_AST));
match(FLOAT);
const_lit_AST = RefBasicAST(currentAST.root);
break;
}
case STRING:
{
RefDataTypeAST tmp24_AST = RefDataTypeAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp24_AST = astFactory->create(LT(1));
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp24_AST));
match(STRING);
const_lit_AST = RefBasicAST(currentAST.root);
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_5);
}
returnAST = const_lit_AST;
}
RefAST CommonAST::clone( void ) const
{
CommonAST *ast = new CommonAST( *this );
return RefAST(ast);
}
RefAST ASTNULLType::getNextSibling() const
{
return RefAST(this);
}
RefAST ASTNULLType::getFirstChild() const
{
return RefAST(this);
}
RefAST ASTNULLType::clone( void ) const
{
return RefAST(this);
}
/** Get the root AST node of the generated AST. When using a custom AST type
* or heterogenous AST's, you'll have to convert it to the right type
* yourself.
*/
virtual RefAST getAST() {
return RefAST();
}
CalcChecker::CalcChecker()
: ANTLR_USE_NAMESPACE(antlr)TreeParser() {
}
void CalcChecker::program(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
ANTLR_USE_NAMESPACE(antlr)RefAST program_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
try { // for error handling
ANTLR_USE_NAMESPACE(antlr)RefAST __t71 = _t;
ANTLR_USE_NAMESPACE(antlr)RefAST tmp1_AST_in = _t;
match(_t,PROGRAM_AST);
_t = _t->getFirstChild();
{ // ( ... )+
int _cnt73=0;
for (;;) {
if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = ASTNULL;
switch ( _t->getType()) {
case DECL:
{
declaration(_t);
_t = _retTree;
break;
}
case PRINT:
case BECOMES:
{
statement(_t);
_t = _retTree;
break;
}
default:
{
if ( _cnt73>=1 ) { goto _loop73; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
}
}
_cnt73++;
}
_loop73:;
} // ( ... )+
_t = __t71;
_t = _t->getNextSibling();
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = _t->getNextSibling();
}
_retTree = _t;
}
void CalcChecker::declaration(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
ANTLR_USE_NAMESPACE(antlr)RefAST declaration_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
ANTLR_USE_NAMESPACE(antlr)RefAST id = ANTLR_USE_NAMESPACE(antlr)nullAST;
try { // for error handling
ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t;
match(_t,DECL);
_t = _t->getFirstChild();
type(_t);
_t = _retTree;
id = _t;
match(_t,IDENTIFIER);
_t = _t->getNextSibling();
_t = __t75;
_t = _t->getNextSibling();
#line 231 "Calc.g"
if (isDeclared(id->getText())){
cerr << id->getText() << " is already declared" << endl;
exit(-1);
}
else
declare(id->getText());
#line 88 "CalcChecker.cpp"
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = _t->getNextSibling();
}
_retTree = _t;
}
void CalcChecker::statement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
ANTLR_USE_NAMESPACE(antlr)RefAST statement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
ANTLR_USE_NAMESPACE(antlr)RefAST id = ANTLR_USE_NAMESPACE(antlr)nullAST;
try { // for error handling
if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = ASTNULL;
switch ( _t->getType()) {
case BECOMES:
{
ANTLR_USE_NAMESPACE(antlr)RefAST __t77 = _t;
ANTLR_USE_NAMESPACE(antlr)RefAST tmp3_AST_in = _t;
match(_t,BECOMES);
_t = _t->getFirstChild();
id = _t;
match(_t,IDENTIFIER);
_t = _t->getNextSibling();
expr(_t);
_t = _retTree;
_t = __t77;
_t = _t->getNextSibling();
#line 243 "Calc.g"
if (!isDeclared(id->getText()))
{
cerr << id->getText() << " is not declared" << endl;
exit(-1);
}
//TODO: type checking
#line 130 "CalcChecker.cpp"
break;
}
case PRINT:
{
ANTLR_USE_NAMESPACE(antlr)RefAST __t78 = _t;
ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
match(_t,PRINT);
_t = _t->getFirstChild();
expr(_t);
_t = _retTree;
_t = __t78;
_t = _t->getNextSibling();
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = _t->getNextSibling();
}
_retTree = _t;
}
void CalcChecker::type(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
ANTLR_USE_NAMESPACE(antlr)RefAST type_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
try { // for error handling
if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = ASTNULL;
switch ( _t->getType()) {
case INT:
{
ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
match(_t,INT);
_t = _t->getNextSibling();
break;
}
case FLOAT:
{
ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t;
match(_t,FLOAT);
_t = _t->getNextSibling();
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = _t->getNextSibling();
}
_retTree = _t;
}
void CalcChecker::expr(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
ANTLR_USE_NAMESPACE(antlr)RefAST expr_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
try { // for error handling
if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = ASTNULL;
switch ( _t->getType()) {
case INT:
case FLOAT:
case IDENTIFIER:
{
operand(_t);
_t = _retTree;
break;
}
case PLUS:
{
ANTLR_USE_NAMESPACE(antlr)RefAST __t80 = _t;
ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t;
match(_t,PLUS);
_t = _t->getFirstChild();
expr(_t);
_t = _retTree;
expr(_t);
_t = _retTree;
_t = __t80;
_t = _t->getNextSibling();
#line 258 "Calc.g"
/*TODO: type checking*/
#line 223 "CalcChecker.cpp"
break;
}
case MINUS:
{
ANTLR_USE_NAMESPACE(antlr)RefAST __t81 = _t;
ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
match(_t,MINUS);
_t = _t->getFirstChild();
expr(_t);
_t = _retTree;
expr(_t);
_t = _retTree;
_t = __t81;
_t = _t->getNextSibling();
#line 259 "Calc.g"
/*TODO: type checking*/
#line 240 "CalcChecker.cpp"
break;
}
case MUL:
{
ANTLR_USE_NAMESPACE(antlr)RefAST __t82 = _t;
ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
match(_t,MUL);
_t = _t->getFirstChild();
expr(_t);
_t = _retTree;
expr(_t);
_t = _retTree;
_t = __t82;
_t = _t->getNextSibling();
#line 260 "Calc.g"
/*TODO: type checking*/
#line 257 "CalcChecker.cpp"
break;
}
case DIV:
{
ANTLR_USE_NAMESPACE(antlr)RefAST __t83 = _t;
ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
match(_t,DIV);
_t = _t->getFirstChild();
expr(_t);
_t = _retTree;
expr(_t);
_t = _retTree;
_t = __t83;
_t = _t->getNextSibling();
#line 261 "Calc.g"
/*TODO: type checking*/
#line 274 "CalcChecker.cpp"
break;
}
case POW:
{
ANTLR_USE_NAMESPACE(antlr)RefAST __t84 = _t;
ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
match(_t,POW);
_t = _t->getFirstChild();
expr(_t);
_t = _retTree;
expr(_t);
_t = _retTree;
_t = __t84;
_t = _t->getNextSibling();
#line 262 "Calc.g"
/*TODO: type checking*/
#line 291 "CalcChecker.cpp"
break;
}
case SIGN_MINUS:
{
ANTLR_USE_NAMESPACE(antlr)RefAST __t85 = _t;
ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
match(_t,SIGN_MINUS);
_t = _t->getFirstChild();
expr(_t);
_t = _retTree;
_t = __t85;
_t = _t->getNextSibling();
#line 263 "Calc.g"
/*TODO: type checking*/
#line 306 "CalcChecker.cpp"
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = _t->getNextSibling();
}
_retTree = _t;
}
void CalcChecker::operand(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
ANTLR_USE_NAMESPACE(antlr)RefAST operand_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
ANTLR_USE_NAMESPACE(antlr)RefAST id = ANTLR_USE_NAMESPACE(antlr)nullAST;
try { // for error handling
if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = ASTNULL;
switch ( _t->getType()) {
case IDENTIFIER:
{
id = _t;
match(_t,IDENTIFIER);
_t = _t->getNextSibling();
#line 268 "Calc.g"
if (!isDeclared(id->getText())){
cerr << id->getText() << " is not declared" << endl;
exit(-1);
}
#line 342 "CalcChecker.cpp"
break;
}
case INT:
{
ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
match(_t,INT);
_t = _t->getNextSibling();
break;
}
case FLOAT:
{
ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
match(_t,FLOAT);
_t = _t->getNextSibling();
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
_t = _t->getNextSibling();
}
_retTree = _t;
}
void CalcChecker::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
{
}
const char* CalcChecker::tokenNames[] = {
"<0>",
"EOF",
"<2>",
"NULL_TREE_LOOKAHEAD",
"\"print\"",
"\"int\"",
"\"float\"",
"BECOMES",
"PLUS",
"MINUS",
"MUL",
"DIV",
"MOD",
"POW",
"COLON",
"SEMICOLON",
"LPAREN",
"RPAREN",
"LBRACKET",
"RBRACKET",
"COMMA",
"LOWER",
"UPPER",
"DIGIT",
"IDENTIFIER",
"NUMBER",
"COMMENT",
"WS",
"PROGRAM_AST",
"DECL",
"SIGN_MINUS",
"SIGN_PLUS",
0
};
RefAST CommonASTWithHiddenTokens::clone( void ) const
{
CommonASTWithHiddenTokens *ast = new CommonASTWithHiddenTokens( *this );
return RefAST(ast);
}
RefAST CommonASTWithHiddenTokens::factory()
{
return RefAST(new CommonASTWithHiddenTokens);
}
void P::startRule() {
returnAST = RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
RefBasicAST startRule_AST = RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
try { // for error handling
arith_exp();
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
{
switch ( LA(1)) {
case EQ:
{
RefBinaryCompArithOpAST tmp1_AST = RefBinaryCompArithOpAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp1_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp1_AST));
match(EQ);
break;
}
case NE:
{
RefBinaryCompArithOpAST tmp2_AST = RefBinaryCompArithOpAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp2_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp2_AST));
match(NE);
break;
}
case LE:
{
RefBinaryCompArithOpAST tmp3_AST = RefBinaryCompArithOpAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp3_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp3_AST));
match(LE);
break;
}
case OP_LT:
{
RefBinaryCompArithOpAST tmp4_AST = RefBinaryCompArithOpAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp4_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp4_AST));
match(OP_LT);
break;
}
case GT:
{
RefBinaryCompArithOpAST tmp5_AST = RefBinaryCompArithOpAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp5_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp5_AST));
match(GT);
break;
}
case GE:
{
RefBinaryCompArithOpAST tmp6_AST = RefBinaryCompArithOpAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp6_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp6_AST));
match(GE);
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
arith_exp();
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
startRule_AST = RefBasicAST(currentAST.root);
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_0);
}
returnAST = startRule_AST;
}
void P::factor2() {
returnAST = RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
RefBasicAST factor2_AST = RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
try { // for error handling
switch ( LA(1)) {
case OPEN_PAREN:
{
match(OPEN_PAREN);
arith_exp();
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
match(CLOSE_PAREN);
factor2_AST = RefBasicAST(currentAST.root);
break;
}
case INT:
case FLOAT:
case STRING:
{
const_lit();
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
factor2_AST = RefBasicAST(currentAST.root);
break;
}
default:
if ((LA(1) == ATTR_OR_FUNC_NAME) && (_tokenSet_4.member(LA(2)))) {
{
if ((LA(1) == ATTR_OR_FUNC_NAME) && (LA(2) == DOT)) {
RefAttrAST tmp15_AST = RefAttrAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp15_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp15_AST));
match(ATTR_OR_FUNC_NAME);
RefBasicAST tmp16_AST = RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
tmp16_AST = astFactory->create(LT(1));
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp16_AST));
match(DOT);
}
else if ((LA(1) == ATTR_OR_FUNC_NAME) && (_tokenSet_5.member(LA(2)))) {
}
else {
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
RefAttrAST tmp17_AST = RefAttrAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp17_AST = astFactory->create(LT(1));
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp17_AST));
match(ATTR_OR_FUNC_NAME);
factor2_AST = RefBasicAST(currentAST.root);
}
else if ((LA(1) == ATTR_OR_FUNC_NAME) && (LA(2) == OPEN_PAREN)) {
RefAttrAST tmp18_AST = RefAttrAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));
tmp18_AST = astFactory->create(LT(1));
astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp18_AST));
match(ATTR_OR_FUNC_NAME);
RefBasicAST tmp19_AST = RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
tmp19_AST = astFactory->create(LT(1));
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp19_AST));
match(OPEN_PAREN);
{
switch ( LA(1)) {
case INT:
case FLOAT:
case STRING:
case ATTR_OR_FUNC_NAME:
case OPEN_PAREN:
{
arith_exp();
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
{ // ( ... )*
for (;;) {
if ((LA(1) == COMMA)) {
match(COMMA);
arith_exp();
astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
}
else {
goto _loop19;
}
}
_loop19:;
} // ( ... )*
break;
}
case CLOSE_PAREN:
{
break;
}
default:
{
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
match(CLOSE_PAREN);
factor2_AST = RefBasicAST(currentAST.root);
}
else {
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
}
}
}
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
reportError(ex);
recover(ex,_tokenSet_5);
}
returnAST = factor2_AST;
}
