// $ANTLR start "param"
// abevformula.g:29:0: param : ( word | sentence | funcwithparams );
private abevformulaParser.param_return param( )
{
abevformulaParser.param_return retval = new abevformulaParser.param_return();
retval.start = input.LT(1);
int param_StartIndex = input.Index;
CommonTree root_0 = null;
abevformulaParser.word_return word13 = default(abevformulaParser.word_return);
abevformulaParser.sentence_return sentence14 = default(abevformulaParser.sentence_return);
abevformulaParser.funcwithparams_return funcwithparams15 = default(abevformulaParser.funcwithparams_return);
try
{
if (state.backtracking > 0 && AlreadyParsedRule(input, 7))
{
return(retval);
}
// abevformula.g:29:10: ( word | sentence | funcwithparams )
int alt2 = 3;
switch (input.LA(1))
{
case WORD:
{
alt2 = 1;
}
break;
case STRING:
{
alt2 = 2;
}
break;
case 9:
{
alt2 = 3;
}
break;
default:
{
if (state.backtracking > 0)
{
state.failed = true; return(retval);
}
NoViableAltException nvae = new NoViableAltException("", 2, 0, input);
throw nvae;
}
}
switch (alt2)
{
case 1:
// abevformula.g:29:10: word
{
root_0 = (CommonTree)adaptor.Nil();
PushFollow(Follow._word_in_param180);
word13 = word();
state._fsp--;
if (state.failed)
{
return(retval);
}
if (state.backtracking == 0)
{
adaptor.AddChild(root_0, word13.Tree);
}
}
break;
case 2:
// abevformula.g:30:6: sentence
{
root_0 = (CommonTree)adaptor.Nil();
PushFollow(Follow._sentence_in_param188);
sentence14 = sentence();
state._fsp--;
if (state.failed)
{
return(retval);
}
if (state.backtracking == 0)
{
adaptor.AddChild(root_0, sentence14.Tree);
}
}
break;
case 3:
// abevformula.g:31:6: funcwithparams
{
root_0 = (CommonTree)adaptor.Nil();
PushFollow(Follow._funcwithparams_in_param195);
funcwithparams15 = funcwithparams();
state._fsp--;
if (state.failed)
{
return(retval);
}
if (state.backtracking == 0)
{
adaptor.AddChild(root_0, funcwithparams15.Tree);
}
}
break;
}
retval.stop = input.LT(-1);
if (state.backtracking == 0)
{
retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re);
}
finally
{
if (state.backtracking > 0)
{
Memoize(input, 7, param_StartIndex);
}
}
return(retval);
}
// $ANTLR start "paramlist"
// abevformula.g:26:0: paramlist : param ( ',' param )* -> ( param )+ ;
private abevformulaParser.paramlist_return paramlist( )
{
abevformulaParser.paramlist_return retval = new abevformulaParser.paramlist_return();
retval.start = input.LT(1);
int paramlist_StartIndex = input.Index;
CommonTree root_0 = null;
IToken char_literal9 = null;
abevformulaParser.param_return param8 = default(abevformulaParser.param_return);
abevformulaParser.param_return param10 = default(abevformulaParser.param_return);
CommonTree char_literal9_tree = null;
RewriteRuleITokenStream stream_8 = new RewriteRuleITokenStream(adaptor, "token 8");
RewriteRuleSubtreeStream stream_param = new RewriteRuleSubtreeStream(adaptor, "rule param");
try
{
if (state.backtracking > 0 && AlreadyParsedRule(input, 4))
{
return(retval);
}
// abevformula.g:26:13: ( param ( ',' param )* -> ( param )+ )
// abevformula.g:26:13: param ( ',' param )*
{
PushFollow(Follow._param_in_paramlist143);
param8 = param();
state._fsp--;
if (state.failed)
{
return(retval);
}
if (state.backtracking == 0)
{
stream_param.Add(param8.Tree);
}
// abevformula.g:26:19: ( ',' param )*
for ( ; ;)
{
int alt1 = 2;
int LA1_0 = input.LA(1);
if ((LA1_0 == 8))
{
alt1 = 1;
}
switch (alt1)
{
case 1:
// abevformula.g:26:20: ',' param
{
char_literal9 = (IToken)Match(input, 8, Follow._8_in_paramlist146); if (state.failed)
{
return(retval);
}
if (state.backtracking == 0)
{
stream_8.Add(char_literal9);
}
PushFollow(Follow._param_in_paramlist148);
param10 = param();
state._fsp--;
if (state.failed)
{
return(retval);
}
if (state.backtracking == 0)
{
stream_param.Add(param10.Tree);
}
}
break;
default:
goto loop1;
}
}
loop1:
;
{
// AST REWRITE
// elements: param
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0)
{
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null?retval.tree:null);
root_0 = (CommonTree)adaptor.Nil();
// 26:32: -> ( param )+
{
if (!(stream_param.HasNext))
{
throw new RewriteEarlyExitException();
}
while (stream_param.HasNext)
{
adaptor.AddChild(root_0, stream_param.NextTree());
}
stream_param.Reset();
}
retval.tree = root_0;
}
}
}
retval.stop = input.LT(-1);
if (state.backtracking == 0)
{
retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0);
adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop);
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re);
}
finally
{
if (state.backtracking > 0)
{
Memoize(input, 4, paramlist_StartIndex);
}
}
return(retval);
}
