public override Template Visit(ExprBracket expr)
{
Template template = new Template("(<expr>)");
template.Add("expr", expr.Expr.Accept(this));
return template;
}
public override Template Visit(StmtForEach stmt_for_each)
{
if (stmt_for_each.Var is ExprConst)
{
ExprConst expr = (ExprConst) stmt_for_each.Var;
Template template = new Template("for (auto <var> : <expr>) {\n <body>\n}");
template.Add("var", expr.Text);
template.Add("expr", stmt_for_each.Target.Accept(this));
template.Add("body", stmt_for_each.Body.Accept(this));
return template;
}
else if (stmt_for_each.Var is ExprCall)
{
ExprCall expr = (ExprCall)stmt_for_each.Var;
List<Stmt> stmt_list = new List<Stmt>();
List<Expr> condition_list = new List<Expr>();
int i = 0;
foreach (var argument in expr.Args)
{
ExprCall get = new ExprCall(new ExprConst("std::get", ConstType.Ident), new List<string> {i.ToString()},
new List<Expr> {new ExprConst("_t_match", ConstType.Ident)});
i++;
if (argument is ExprConst && ((ExprConst)argument).Type == ConstType.Ident && !((ExprConst)argument).Text.StartsWith("@"))
{
ExprConst const_expr = (ExprConst)argument;
if (const_expr.Text == "_")
{
continue;
}
stmt_list.Add(new StmtExpr(new ExprAlloc("auto", new List<string> { const_expr.Text }, new List<Expr>{ get }, true)));
}
else
{
if (((ExprConst)argument).Text.StartsWith("@"))
{
((ExprConst)argument).Text = ((ExprConst)argument).Text.Substring(1);
}
condition_list.Add(new ExprBin("==", get, argument));
}
}
StmtBlock block = new StmtBlock();
foreach (var item in stmt_list)
{
block.StmtList.Add(item);
}
foreach (var item in stmt_for_each.Body.StmtList)
{
block.StmtList.Add(item);
}
if (condition_list.Count() > 0)
{
StmtBlock if_body = new StmtBlock();
if_body.StmtList.Add(new StmtExpr(new ExprAlloc("auto&&", new List<string> { "_t_match" }, new List<Expr> { new ExprCall(new ExprAccess(new ExprConst("_t_iterator", ConstType.Ident), ".", "Unapply"), null, null) }, true)));
Expr condition = null;
foreach (var item in condition_list)
{
if (condition == null)
{
condition = item;
if (condition_list.Count() > 1)
{
condition = new ExprBracket(condition);
}
}
else
{
condition = new ExprBin("&&", condition, new ExprBracket(item));
}
}
StmtIf stmt_if = new StmtIf(condition, block, null);
if_body.StmtList.Add(stmt_if);
block = if_body;
}
else
{
block.StmtList.Insert(0, new StmtExpr(new ExprAlloc("auto&&", new List<string> { "_t_match" }, new List<Expr> { new ExprCall(new ExprAccess(new ExprConst("_t_iterator", ConstType.Ident), ".", "Unapply"), null, null) }, true)));
}
StmtForEach for_each = new StmtForEach(new ExprConst("_t_iterator", ConstType.Ident), stmt_for_each.Target, block);
return for_each.Accept(this);
}
else if (stmt_for_each.Var is ExprTuple)
{
ExprTuple expr = (ExprTuple)stmt_for_each.Var;
List<Stmt> stmt_list = new List<Stmt>();
List<Expr> condition_list = new List<Expr>();
int i = 0;
foreach (var argument in expr.ExprList)
{
ExprCall get = new ExprCall(new ExprConst("get", ConstType.Ident), new List<string> { i.ToString() },
new List<Expr> { new ExprConst("_t_match", ConstType.Ident) });
i++;
if (argument is ExprConst && ((ExprConst)argument).Type == ConstType.Ident)
{
ExprConst const_expr = (ExprConst)argument;
if (const_expr.Text == "_")
{
continue;
}
stmt_list.Add(new StmtExpr(new ExprAlloc("auto", new List<string> { const_expr.Text }, new List<Expr> { get }, true)));
}
else
{
condition_list.Add(new ExprBin("==", get, argument));
}
}
StmtBlock block = new StmtBlock();
foreach (var item in stmt_list)
{
block.StmtList.Add(item);
}
foreach (var item in stmt_for_each.Body.StmtList)
{
block.StmtList.Add(item);
}
if (condition_list.Count() > 0)
{
StmtBlock if_body = new StmtBlock();
Expr condition = null;
foreach (var item in condition_list)
{
if (condition == null)
{
condition = item;
if (condition_list.Count() > 1)
{
condition = new ExprBracket(condition);
}
}
else
{
condition = new ExprBin("&&", condition, new ExprBracket(item));
}
}
StmtIf stmt_if = new StmtIf(condition, block, null);
if_body.StmtList.Add(stmt_if);
block = if_body;
}
StmtForEach for_each = new StmtForEach(new ExprConst("_t_match", ConstType.Ident), stmt_for_each.Target, block);
return for_each.Accept(this);
}
else
{
throw new Exception(string.Format("Iterators in foreach must be either variable or pattern matching"));
}
}
private Expr expr()
{
EnterRule_expr();
EnterRule("expr", 47);
TraceIn("expr", 47);
Expr value = default(Expr);
CommonTree op = default(CommonTree);
CommonTree text = default(CommonTree);
ExprTuple tuple = default(ExprTuple);
ExprAlloc alloc = default(ExprAlloc);
MatchTuple match = default(MatchTuple);
ExprCall call = default(ExprCall);
ExprCall call_with = default(ExprCall);
Expr dict = default(Expr);
ExprLambda lambda = default(ExprLambda);
ExprCast cast = default(ExprCast);
ExprList list = default(ExprList);
Expr expr_new = default(Expr);
string ident_text = default(string);
Expr a = default(Expr);
Expr b = default(Expr);
Expr c = default(Expr);
Expr chain = default(Expr);
string text_ident = default(string);
try { DebugEnterRule(GrammarFileName, "expr");
DebugLocation(567, 1);
try
{
// SugarWalker.g:568:5: (tuple= expr_tuple |alloc= alloc_expr |match= match_tuple |call= call_expr |call_with= call_with_expr |dict= dict_expr |lambda= lambda_expr |cast= cast_expr |list= list_expr |expr_new= new_expr | ^( Expr_Infix ident_text= ident a= expr b= expr ) | ^( Expr_Cond a= expr b= expr c= expr ) | ^( Expr_Cond_Not_Null a= expr b= expr ) | ^( Expr_Not_Null a= expr ) | ^( Expr_Access op= ( '.' | '::' | '->' | '->*' | '.*' ) a= expr ident_text= ident ) |chain= chain_expr | ^( Expr_Bin op= ( '+' | '-' | '*' | '/' | '%' | '<' | '<=' | '>' | '>=' | '==' | '!=' | '<<' | '>>' | '&' | '^' | '|' | '&&' | '||' | 'is' | 'isnt' | 'and' | 'or' ) a= expr b= expr ) | ^(op= ( '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '^=' | '|=' | '<<=' | '>>=' ) a= expr b= expr ) | ^( '@' text_ident= ident ) | ^( Expr_Bracket a= expr ) | ^( Expr_Suffix op= ( '++' | '--' ) a= expr ) | ^( Expr_Prefix op= ( '!' | '~' | '++' | '--' | '-' | '+' | '*' | '&' ) a= expr ) | ^( ':=' a= expr b= expr ) |text_ident= ident |text= ( NUMBER | DOUBLE ) |text= STRING )
int alt73=26;
try { DebugEnterDecision(73, false);
switch (input.LA(1))
{
case Expr_Tuple:
{
alt73 = 1;
}
break;
case Expr_Alloc_Bracket:
case Expr_Alloc_Equal:
{
alt73 = 2;
}
break;
case Match_Tuple:
{
alt73 = 3;
}
break;
case Expr_Call:
{
alt73 = 4;
}
break;
case Expr_Call_With:
{
alt73 = 5;
}
break;
case Expr_Dict:
{
alt73 = 6;
}
break;
case Expr_Lambda:
{
alt73 = 7;
}
break;
case Expr_Cast:
{
alt73 = 8;
}
break;
case Expr_List:
{
alt73 = 9;
}
break;
case Expr_New_Array:
case Expr_New_Type:
{
alt73 = 10;
}
break;
case Expr_Infix:
{
alt73 = 11;
}
break;
case Expr_Cond:
{
alt73 = 12;
}
break;
case Expr_Cond_Not_Null:
{
alt73 = 13;
}
break;
case Expr_Not_Null:
{
alt73 = 14;
}
break;
case Expr_Access:
{
alt73 = 15;
}
break;
case Expr_Chain:
{
alt73 = 16;
}
break;
case Expr_Bin:
{
alt73 = 17;
}
break;
case 75:
case 78:
case 82:
case 85:
case 89:
case 95:
case 102:
case 104:
case 110:
case 117:
case 150:
{
alt73 = 18;
}
break;
case 113:
{
alt73 = 19;
}
break;
case Expr_Bracket:
{
alt73 = 20;
}
break;
case Expr_Suffix:
{
alt73 = 21;
}
break;
case Expr_Prefix:
{
alt73 = 22;
}
break;
case 98:
{
alt73 = 23;
}
break;
case IDENT:
{
alt73 = 24;
}
break;
case NUMBER:
case DOUBLE:
{
alt73 = 25;
}
break;
case STRING:
{
alt73 = 26;
}
break;
default:
{
NoViableAltException nvae = new NoViableAltException("", 73, 0, input);
DebugRecognitionException(nvae);
throw nvae;
}
}
} finally { DebugExitDecision(73); }
switch (alt73)
{
case 1:
DebugEnterAlt(1);
// SugarWalker.g:568:7: tuple= expr_tuple
{
DebugLocation(568, 12);
PushFollow(Follow._expr_tuple_in_expr2302);
tuple=expr_tuple();
PopFollow();
DebugLocation(569, 2);
value = tuple;
}
break;
case 2:
DebugEnterAlt(2);
// SugarWalker.g:572:4: alloc= alloc_expr
{
DebugLocation(572, 9);
PushFollow(Follow._alloc_expr_in_expr2312);
alloc=alloc_expr();
PopFollow();
DebugLocation(573, 2);
value = alloc;
}
break;
case 3:
DebugEnterAlt(3);
// SugarWalker.g:576:4: match= match_tuple
{
DebugLocation(576, 9);
PushFollow(Follow._match_tuple_in_expr2322);
match=match_tuple();
PopFollow();
DebugLocation(577, 2);
value = match;
}
break;
case 4:
DebugEnterAlt(4);
// SugarWalker.g:580:4: call= call_expr
{
DebugLocation(580, 8);
PushFollow(Follow._call_expr_in_expr2332);
call=call_expr();
PopFollow();
DebugLocation(581, 2);
value = call;
}
break;
case 5:
DebugEnterAlt(5);
// SugarWalker.g:584:4: call_with= call_with_expr
{
DebugLocation(584, 13);
PushFollow(Follow._call_with_expr_in_expr2342);
call_with=call_with_expr();
PopFollow();
DebugLocation(585, 2);
value = call_with;
}
break;
case 6:
DebugEnterAlt(6);
// SugarWalker.g:588:4: dict= dict_expr
{
DebugLocation(588, 8);
PushFollow(Follow._dict_expr_in_expr2352);
dict=dict_expr();
PopFollow();
DebugLocation(589, 2);
value = dict;
}
break;
case 7:
DebugEnterAlt(7);
// SugarWalker.g:592:4: lambda= lambda_expr
{
DebugLocation(592, 10);
PushFollow(Follow._lambda_expr_in_expr2362);
lambda=lambda_expr();
PopFollow();
DebugLocation(593, 2);
value = lambda;
}
break;
case 8:
DebugEnterAlt(8);
// SugarWalker.g:596:4: cast= cast_expr
{
DebugLocation(596, 8);
PushFollow(Follow._cast_expr_in_expr2372);
cast=cast_expr();
PopFollow();
DebugLocation(597, 2);
value = cast;
}
break;
case 9:
DebugEnterAlt(9);
// SugarWalker.g:600:4: list= list_expr
{
DebugLocation(600, 8);
PushFollow(Follow._list_expr_in_expr2382);
list=list_expr();
PopFollow();
DebugLocation(601, 2);
value = list;
}
break;
case 10:
DebugEnterAlt(10);
// SugarWalker.g:604:4: expr_new= new_expr
{
DebugLocation(604, 12);
PushFollow(Follow._new_expr_in_expr2392);
expr_new=new_expr();
PopFollow();
DebugLocation(605, 2);
value = expr_new;
}
break;
case 11:
DebugEnterAlt(11);
// SugarWalker.g:608:4: ^( Expr_Infix ident_text= ident a= expr b= expr )
{
DebugLocation(608, 4);
DebugLocation(608, 6);
Match(input,Expr_Infix,Follow._Expr_Infix_in_expr2401);
Match(input, TokenTypes.Down, null);
DebugLocation(608, 27);
PushFollow(Follow._ident_in_expr2405);
ident_text=ident();
PopFollow();
DebugLocation(608, 35);
PushFollow(Follow._expr_in_expr2409);
a=expr();
PopFollow();
DebugLocation(608, 42);
PushFollow(Follow._expr_in_expr2413);
b=expr();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(609, 2);
value = new ExprInfix(ident_text, a, b);
}
break;
case 12:
DebugEnterAlt(12);
// SugarWalker.g:612:4: ^( Expr_Cond a= expr b= expr c= expr )
{
DebugLocation(612, 4);
DebugLocation(612, 6);
Match(input,Expr_Cond,Follow._Expr_Cond_in_expr2423);
Match(input, TokenTypes.Down, null);
DebugLocation(612, 17);
PushFollow(Follow._expr_in_expr2427);
a=expr();
PopFollow();
DebugLocation(612, 24);
PushFollow(Follow._expr_in_expr2431);
b=expr();
PopFollow();
DebugLocation(612, 31);
PushFollow(Follow._expr_in_expr2435);
c=expr();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(613, 2);
value = new ExprCond(a, b, c);
}
break;
case 13:
DebugEnterAlt(13);
// SugarWalker.g:616:4: ^( Expr_Cond_Not_Null a= expr b= expr )
{
DebugLocation(616, 4);
DebugLocation(616, 6);
Match(input,Expr_Cond_Not_Null,Follow._Expr_Cond_Not_Null_in_expr2445);
Match(input, TokenTypes.Down, null);
DebugLocation(616, 26);
PushFollow(Follow._expr_in_expr2449);
a=expr();
PopFollow();
DebugLocation(616, 33);
PushFollow(Follow._expr_in_expr2453);
b=expr();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(617, 2);
value = new ExprCond(new ExprBin("!=", a, new ExprConst("nullptr", ConstType.Ident)), a, b);
}
break;
case 14:
DebugEnterAlt(14);
// SugarWalker.g:620:4: ^( Expr_Not_Null a= expr )
{
DebugLocation(620, 4);
DebugLocation(620, 6);
Match(input,Expr_Not_Null,Follow._Expr_Not_Null_in_expr2463);
Match(input, TokenTypes.Down, null);
DebugLocation(620, 21);
PushFollow(Follow._expr_in_expr2467);
a=expr();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(621, 2);
value = new ExprBin("!=", a, new ExprConst("nullptr", ConstType.Ident));
}
break;
case 15:
DebugEnterAlt(15);
// SugarWalker.g:624:4: ^( Expr_Access op= ( '.' | '::' | '->' | '->*' | '.*' ) a= expr ident_text= ident )
{
DebugLocation(624, 4);
DebugLocation(624, 6);
Match(input,Expr_Access,Follow._Expr_Access_in_expr2477);
Match(input, TokenTypes.Down, null);
DebugLocation(624, 20);
op=(CommonTree)input.LT(1);
if ((input.LA(1)>=90 && input.LA(1)<=93)||input.LA(1)==97)
{
input.Consume();
state.errorRecovery=false;
}
else
{
MismatchedSetException mse = new MismatchedSetException(null,input);
DebugRecognitionException(mse);
throw mse;
}
DebugLocation(624, 57);
PushFollow(Follow._expr_in_expr2503);
a=expr();
PopFollow();
DebugLocation(624, 73);
PushFollow(Follow._ident_in_expr2507);
ident_text=ident();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(625, 2);
value = new ExprAccess(a, op.Text, ident_text);
}
break;
case 16:
DebugEnterAlt(16);
// SugarWalker.g:628:4: chain= chain_expr
{
DebugLocation(628, 10);
PushFollow(Follow._chain_expr_in_expr2520);
chain=chain_expr();
PopFollow();
DebugLocation(629, 2);
value = chain;
}
break;
case 17:
DebugEnterAlt(17);
// SugarWalker.g:632:4: ^( Expr_Bin op= ( '+' | '-' | '*' | '/' | '%' | '<' | '<=' | '>' | '>=' | '==' | '!=' | '<<' | '>>' | '&' | '^' | '|' | '&&' | '||' | 'is' | 'isnt' | 'and' | 'or' ) a= expr b= expr )
{
DebugLocation(632, 4);
DebugLocation(632, 6);
Match(input,Expr_Bin,Follow._Expr_Bin_in_expr2529);
Match(input, TokenTypes.Down, null);
DebugLocation(632, 17);
op=(CommonTree)input.LT(1);
if ((input.LA(1)>=73 && input.LA(1)<=74)||(input.LA(1)>=76 && input.LA(1)<=77)||input.LA(1)==81||input.LA(1)==83||input.LA(1)==87||input.LA(1)==94||input.LA(1)==99||input.LA(1)==101||input.LA(1)==103||input.LA(1)==105||(input.LA(1)>=107 && input.LA(1)<=109)||input.LA(1)==116||input.LA(1)==119||(input.LA(1)>=133 && input.LA(1)<=134)||input.LA(1)==138||input.LA(1)==149||input.LA(1)==151)
{
input.Consume();
state.errorRecovery=false;
}
else
{
MismatchedSetException mse = new MismatchedSetException(null,input);
DebugRecognitionException(mse);
throw mse;
}
DebugLocation(639, 9);
PushFollow(Follow._expr_in_expr2660);
a=expr();
PopFollow();
DebugLocation(639, 16);
PushFollow(Follow._expr_in_expr2664);
b=expr();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(640, 2);
value = new ExprBin(Alias(op.Text), a, b);
}
break;
case 18:
DebugEnterAlt(18);
// SugarWalker.g:643:4: ^(op= ( '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '^=' | '|=' | '<<=' | '>>=' ) a= expr b= expr )
{
DebugLocation(643, 4);
DebugLocation(643, 8);
op=(CommonTree)input.LT(1);
if (input.LA(1)==75||input.LA(1)==78||input.LA(1)==82||input.LA(1)==85||input.LA(1)==89||input.LA(1)==95||input.LA(1)==102||input.LA(1)==104||input.LA(1)==110||input.LA(1)==117||input.LA(1)==150)
{
input.Consume();
state.errorRecovery=false;
}
else
{
MismatchedSetException mse = new MismatchedSetException(null,input);
DebugRecognitionException(mse);
throw mse;
}
Match(input, TokenTypes.Down, null);
DebugLocation(643, 88);
PushFollow(Follow._expr_in_expr2722);
a=expr();
PopFollow();
DebugLocation(643, 95);
PushFollow(Follow._expr_in_expr2726);
b=expr();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(644, 2);
value = new ExprBin(op.Text, a, b);
}
break;
case 19:
DebugEnterAlt(19);
// SugarWalker.g:647:4: ^( '@' text_ident= ident )
{
DebugLocation(647, 4);
DebugLocation(647, 6);
Match(input,113,Follow._113_in_expr2736);
Match(input, TokenTypes.Down, null);
DebugLocation(647, 20);
PushFollow(Follow._ident_in_expr2740);
text_ident=ident();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(648, 2);
value = new ExprAccess(new ExprConst("this", ConstType.Ident), "->", text_ident);
}
break;
case 20:
DebugEnterAlt(20);
// SugarWalker.g:651:4: ^( Expr_Bracket a= expr )
{
DebugLocation(651, 4);
DebugLocation(651, 6);
Match(input,Expr_Bracket,Follow._Expr_Bracket_in_expr2750);
Match(input, TokenTypes.Down, null);
DebugLocation(651, 20);
PushFollow(Follow._expr_in_expr2754);
a=expr();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(652, 2);
value = new ExprBracket(a);
}
break;
case 21:
DebugEnterAlt(21);
// SugarWalker.g:655:4: ^( Expr_Suffix op= ( '++' | '--' ) a= expr )
{
DebugLocation(655, 4);
DebugLocation(655, 6);
Match(input,Expr_Suffix,Follow._Expr_Suffix_in_expr2764);
Match(input, TokenTypes.Down, null);
DebugLocation(655, 20);
op=(CommonTree)input.LT(1);
if (input.LA(1)==84||input.LA(1)==88)
{
input.Consume();
state.errorRecovery=false;
}
else
{
MismatchedSetException mse = new MismatchedSetException(null,input);
DebugRecognitionException(mse);
throw mse;
}
DebugLocation(655, 36);
PushFollow(Follow._expr_in_expr2778);
a=expr();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(656, 2);
value = new ExprSuffix(op.Text, a);
}
break;
case 22:
DebugEnterAlt(22);
// SugarWalker.g:659:4: ^( Expr_Prefix op= ( '!' | '~' | '++' | '--' | '-' | '+' | '*' | '&' ) a= expr )
{
DebugLocation(659, 4);
DebugLocation(659, 6);
Match(input,Expr_Prefix,Follow._Expr_Prefix_in_expr2788);
Match(input, TokenTypes.Down, null);
DebugLocation(659, 20);
op=(CommonTree)input.LT(1);
if (input.LA(1)==72||input.LA(1)==77||input.LA(1)==81||(input.LA(1)>=83 && input.LA(1)<=84)||(input.LA(1)>=87 && input.LA(1)<=88)||input.LA(1)==152)
{
input.Consume();
state.errorRecovery=false;
}
else
{
MismatchedSetException mse = new MismatchedSetException(null,input);
DebugRecognitionException(mse);
throw mse;
}
DebugLocation(659, 72);
PushFollow(Follow._expr_in_expr2826);
a=expr();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(660, 2);
value = new ExprPrefix(op.Text, a);
}
break;
case 23:
DebugEnterAlt(23);
// SugarWalker.g:663:4: ^( ':=' a= expr b= expr )
{
DebugLocation(663, 4);
DebugLocation(663, 6);
Match(input,98,Follow._98_in_expr2836);
Match(input, TokenTypes.Down, null);
DebugLocation(663, 12);
PushFollow(Follow._expr_in_expr2840);
a=expr();
PopFollow();
DebugLocation(663, 19);
PushFollow(Follow._expr_in_expr2844);
b=expr();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(664, 2);
if (!(a is ExprConst))
{
throw new Exception("Assert failed.");
}
value = new ExprAlloc("auto", new List<string> { ((ExprConst)a).Text }, new List<Expr> { b }, true);
}
break;
case 24:
DebugEnterAlt(24);
// SugarWalker.g:671:4: text_ident= ident
{
DebugLocation(671, 15);
PushFollow(Follow._ident_in_expr2857);
text_ident=ident();
PopFollow();
DebugLocation(672, 2);
if (text_ident == "nil") text_ident = "nullptr";
value = new ExprConst(text_ident, ConstType.Ident);
}
break;
case 25:
DebugEnterAlt(25);
// SugarWalker.g:676:4: text= ( NUMBER | DOUBLE )
{
DebugLocation(676, 8);
text=(CommonTree)input.LT(1);
if (input.LA(1)==NUMBER||input.LA(1)==DOUBLE)
{
input.Consume();
state.errorRecovery=false;
}
else
{
MismatchedSetException mse = new MismatchedSetException(null,input);
DebugRecognitionException(mse);
throw mse;
}
DebugLocation(677, 5);
value = new ExprConst(text.Text, ConstType.Number);
}
break;
case 26:
DebugEnterAlt(26);
// SugarWalker.g:680:4: text= STRING
{
DebugLocation(680, 9);
text=(CommonTree)Match(input,STRING,Follow._STRING_in_expr2888);
DebugLocation(681, 2);
value = new ExprConst(text.Text, ConstType.String);
}
break;
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
}
finally
{
TraceOut("expr", 47);
LeaveRule("expr", 47);
LeaveRule_expr();
}
DebugLocation(684, 1);
} finally { DebugExitRule(GrammarFileName, "expr"); }
return value;
}
public abstract Template Visit(ExprBracket expr);
public abstract Template Visit(ExprBracket expr);
private Expr expr()
{
EnterRule_expr();
EnterRule("expr", 60);
TraceIn("expr", 60);
Expr value = default(Expr);
CommonTree op = default(CommonTree);
CommonTree text = default(CommonTree);
ExprTuple tuple = default(ExprTuple);
ExprAlloc alloc = default(ExprAlloc);
MatchTuple match = default(MatchTuple);
ExprCall call = default(ExprCall);
ExprCall call_with = default(ExprCall);
Expr dict = default(Expr);
Expr lambda = default(Expr);
ExprCast cast = default(ExprCast);
ExprList list = default(ExprList);
ExprListGeneration list_generation = default(ExprListGeneration);
Expr expr_new = default(Expr);
Expr where = default(Expr);
Expr expr_match = default(Expr);
string ident_text = default(string);
Expr a = default(Expr);
Expr b = default(Expr);
Expr c = default(Expr);
Expr chain = default(Expr);
string text_ident = default(string);
try { DebugEnterRule(GrammarFileName, "expr");
DebugLocation(764, 1);
try
{
// SugarWalker.g:765:5: (tuple= expr_tuple |alloc= alloc_expr |match= match_tuple |call= call_expr |call_with= call_with_expr |dict= dict_expr |lambda= lambda_expr |cast= cast_expr |list= list_expr |list_generation= list_generation_expr |expr_new= new_expr |where= where_expr |expr_match= match_expr | ^( Expr_Infix ident_text= ident a= expr b= expr ) | ^( Expr_Cond a= expr b= expr c= expr ) | ^( Expr_Cond_Not_Null a= expr b= expr ) | ^( Expr_Not_Null a= expr ) | ^( Expr_Access op= ( '.' | '::' | '->' | '->*' | '.*' ) a= expr ident_text= ident ) |chain= chain_expr | ^( Expr_Bin op= ( '+' | '-' | '*' | '/' | '%' | '<' | '<=' | '>' | '>=' | '==' | '!=' | '<<' | '>>' | '&' | '^' | '|' | '&&' | '||' | 'is' | 'isnt' | 'and' | 'or' ) a= expr b= expr ) | ^(op= ( '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '^=' | '|=' | '<<=' | '>>=' ) a= expr b= expr ) | ^( '@' text_ident= ident ) | ^( Expr_Bracket a= expr ) | ^( Expr_Suffix op= ( '++' | '--' ) a= expr ) | ^( Expr_Prefix op= ( '!' | '~' | '++' | '--' | '-' | '+' | '*' | '&' | 'not' ) a= expr ) | ^( ':=' a= expr b= expr ) |text_ident= ident |text= ( NUMBER | DOUBLE ) |text= STRING )
int alt90=29;
try { DebugEnterDecision(90, false);
switch (input.LA(1))
{
case Expr_Tuple:
{
alt90 = 1;
}
break;
case Expr_Alloc_Bracket:
case Expr_Alloc_Equal:
{
alt90 = 2;
}
break;
case Match_Tuple:
{
alt90 = 3;
}
break;
case Expr_Call:
{
alt90 = 4;
}
break;
case Expr_Call_With:
{
alt90 = 5;
}
break;
case Expr_Dict:
{
alt90 = 6;
}
break;
case Expr_Lambda:
{
alt90 = 7;
}
break;
case Expr_Cast:
{
alt90 = 8;
}
break;
case Expr_List:
{
alt90 = 9;
}
break;
case Expr_List_Generation:
{
alt90 = 10;
}
break;
case Expr_New_Array:
case Expr_New_Type:
{
alt90 = 11;
}
break;
case Expr_Where:
{
alt90 = 12;
}
break;
case Match_Expr:
{
alt90 = 13;
}
break;
case Expr_Infix:
{
alt90 = 14;
}
break;
case Expr_Cond:
{
alt90 = 15;
}
break;
case Expr_Cond_Not_Null:
{
alt90 = 16;
}
break;
case Expr_Not_Null:
{
alt90 = 17;
}
break;
case Expr_Access:
{
alt90 = 18;
}
break;
case Expr_Chain:
{
alt90 = 19;
}
break;
case Expr_Bin:
{
alt90 = 20;
}
break;
case 89:
case 92:
case 96:
case 99:
case 104:
case 110:
case 118:
case 121:
case 128:
case 135:
case 183:
{
alt90 = 21;
}
break;
case 131:
{
alt90 = 22;
}
break;
case Expr_Bracket:
{
alt90 = 23;
}
break;
case Expr_Suffix:
{
alt90 = 24;
}
break;
case Expr_Prefix:
{
alt90 = 25;
}
break;
case 113:
{
alt90 = 26;
}
break;
case IDENT:
{
alt90 = 27;
}
break;
case NUMBER:
case DOUBLE:
{
alt90 = 28;
}
break;
case STRING:
{
alt90 = 29;
}
break;
default:
{
NoViableAltException nvae = new NoViableAltException("", 90, 0, input);
DebugRecognitionException(nvae);
throw nvae;
}
}
} finally { DebugExitDecision(90); }
switch (alt90)
{
case 1:
DebugEnterAlt(1);
// SugarWalker.g:765:7: tuple= expr_tuple
{
DebugLocation(765, 12);
PushFollow(Follow._expr_tuple_in_expr3006);
tuple=expr_tuple();
PopFollow();
DebugLocation(766, 2);
value = tuple;
}
break;
case 2:
DebugEnterAlt(2);
// SugarWalker.g:769:4: alloc= alloc_expr
{
DebugLocation(769, 9);
PushFollow(Follow._alloc_expr_in_expr3016);
alloc=alloc_expr();
PopFollow();
DebugLocation(770, 2);
value = alloc;
}
break;
case 3:
DebugEnterAlt(3);
// SugarWalker.g:773:4: match= match_tuple
{
DebugLocation(773, 9);
PushFollow(Follow._match_tuple_in_expr3026);
match=match_tuple();
PopFollow();
DebugLocation(774, 2);
value = match;
}
break;
case 4:
DebugEnterAlt(4);
// SugarWalker.g:777:4: call= call_expr
{
DebugLocation(777, 8);
PushFollow(Follow._call_expr_in_expr3036);
call=call_expr();
PopFollow();
DebugLocation(778, 2);
value = call;
}
break;
case 5:
DebugEnterAlt(5);
// SugarWalker.g:781:4: call_with= call_with_expr
{
DebugLocation(781, 13);
PushFollow(Follow._call_with_expr_in_expr3046);
call_with=call_with_expr();
PopFollow();
DebugLocation(782, 2);
value = call_with;
}
break;
case 6:
DebugEnterAlt(6);
// SugarWalker.g:785:4: dict= dict_expr
{
DebugLocation(785, 8);
PushFollow(Follow._dict_expr_in_expr3056);
dict=dict_expr();
PopFollow();
DebugLocation(786, 2);
value = dict;
}
break;
case 7:
DebugEnterAlt(7);
// SugarWalker.g:789:4: lambda= lambda_expr
{
DebugLocation(789, 10);
PushFollow(Follow._lambda_expr_in_expr3066);
lambda=lambda_expr();
PopFollow();
DebugLocation(790, 2);
value = lambda;
}
break;
case 8:
DebugEnterAlt(8);
// SugarWalker.g:793:4: cast= cast_expr
{
DebugLocation(793, 8);
PushFollow(Follow._cast_expr_in_expr3076);
cast=cast_expr();
PopFollow();
DebugLocation(794, 2);
value = cast;
}
break;
case 9:
DebugEnterAlt(9);
// SugarWalker.g:797:4: list= list_expr
{
DebugLocation(797, 8);
PushFollow(Follow._list_expr_in_expr3086);
list=list_expr();
PopFollow();
DebugLocation(798, 2);
value = list;
}
break;
case 10:
DebugEnterAlt(10);
// SugarWalker.g:801:4: list_generation= list_generation_expr
{
DebugLocation(801, 19);
PushFollow(Follow._list_generation_expr_in_expr3096);
list_generation=list_generation_expr();
PopFollow();
DebugLocation(802, 2);
value = list_generation;
}
break;
case 11:
DebugEnterAlt(11);
// SugarWalker.g:805:4: expr_new= new_expr
{
DebugLocation(805, 12);
PushFollow(Follow._new_expr_in_expr3106);
expr_new=new_expr();
PopFollow();
DebugLocation(806, 2);
value = expr_new;
}
break;
case 12:
DebugEnterAlt(12);
// SugarWalker.g:809:4: where= where_expr
{
DebugLocation(809, 9);
PushFollow(Follow._where_expr_in_expr3116);
where=where_expr();
PopFollow();
DebugLocation(810, 2);
value = where;
}
break;
case 13:
DebugEnterAlt(13);
// SugarWalker.g:813:4: expr_match= match_expr
{
DebugLocation(813, 14);
PushFollow(Follow._match_expr_in_expr3126);
expr_match=match_expr();
PopFollow();
DebugLocation(814, 2);
value = expr_match;
}
break;
case 14:
DebugEnterAlt(14);
// SugarWalker.g:817:4: ^( Expr_Infix ident_text= ident a= expr b= expr )
{
DebugLocation(817, 4);
DebugLocation(817, 6);
Match(input,Expr_Infix,Follow._Expr_Infix_in_expr3135);
Match(input, TokenTypes.Down, null);
DebugLocation(817, 27);
PushFollow(Follow._ident_in_expr3139);
ident_text=ident();
PopFollow();
DebugLocation(817, 35);
PushFollow(Follow._expr_in_expr3143);
a=expr();
PopFollow();
DebugLocation(817, 42);
PushFollow(Follow._expr_in_expr3147);
b=expr();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(818, 2);
value = new ExprInfix(ident_text, a, b);
}
break;
case 15:
DebugEnterAlt(15);
// SugarWalker.g:821:4: ^( Expr_Cond a= expr b= expr c= expr )
{
DebugLocation(821, 4);
DebugLocation(821, 6);
Match(input,Expr_Cond,Follow._Expr_Cond_in_expr3157);
Match(input, TokenTypes.Down, null);
DebugLocation(821, 17);
PushFollow(Follow._expr_in_expr3161);
a=expr();
PopFollow();
DebugLocation(821, 24);
PushFollow(Follow._expr_in_expr3165);
b=expr();
PopFollow();
DebugLocation(821, 31);
PushFollow(Follow._expr_in_expr3169);
c=expr();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(822, 2);
value = new ExprCond(a, b, c);
}
break;
case 16:
DebugEnterAlt(16);
// SugarWalker.g:825:4: ^( Expr_Cond_Not_Null a= expr b= expr )
{
DebugLocation(825, 4);
DebugLocation(825, 6);
Match(input,Expr_Cond_Not_Null,Follow._Expr_Cond_Not_Null_in_expr3179);
Match(input, TokenTypes.Down, null);
DebugLocation(825, 26);
PushFollow(Follow._expr_in_expr3183);
a=expr();
PopFollow();
DebugLocation(825, 33);
PushFollow(Follow._expr_in_expr3187);
b=expr();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(826, 2);
value = new ExprCond(new ExprBin("!=", a, new ExprConst("NULL", ConstType.Ident)), a, b);
}
break;
case 17:
DebugEnterAlt(17);
// SugarWalker.g:829:4: ^( Expr_Not_Null a= expr )
{
DebugLocation(829, 4);
DebugLocation(829, 6);
Match(input,Expr_Not_Null,Follow._Expr_Not_Null_in_expr3197);
Match(input, TokenTypes.Down, null);
DebugLocation(829, 21);
PushFollow(Follow._expr_in_expr3201);
a=expr();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(830, 2);
value = new ExprBin("!=", a, new ExprConst("NULL", ConstType.Ident));
}
break;
case 18:
DebugEnterAlt(18);
// SugarWalker.g:833:4: ^( Expr_Access op= ( '.' | '::' | '->' | '->*' | '.*' ) a= expr ident_text= ident )
{
DebugLocation(833, 4);
DebugLocation(833, 6);
Match(input,Expr_Access,Follow._Expr_Access_in_expr3211);
Match(input, TokenTypes.Down, null);
DebugLocation(833, 20);
op=(CommonTree)input.LT(1);
if ((input.LA(1)>=105 && input.LA(1)<=108)||input.LA(1)==112)
{
input.Consume();
state.errorRecovery=false;
}
else
{
MismatchedSetException mse = new MismatchedSetException(null,input);
DebugRecognitionException(mse);
throw mse;
}
DebugLocation(833, 57);
PushFollow(Follow._expr_in_expr3237);
a=expr();
PopFollow();
DebugLocation(833, 73);
PushFollow(Follow._ident_in_expr3241);
ident_text=ident();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(834, 2);
value = new ExprAccess(a, op.Text, ident_text);
}
break;
case 19:
DebugEnterAlt(19);
// SugarWalker.g:837:4: chain= chain_expr
{
DebugLocation(837, 10);
PushFollow(Follow._chain_expr_in_expr3254);
chain=chain_expr();
PopFollow();
DebugLocation(838, 2);
value = chain;
}
break;
case 20:
DebugEnterAlt(20);
// SugarWalker.g:841:4: ^( Expr_Bin op= ( '+' | '-' | '*' | '/' | '%' | '<' | '<=' | '>' | '>=' | '==' | '!=' | '<<' | '>>' | '&' | '^' | '|' | '&&' | '||' | 'is' | 'isnt' | 'and' | 'or' ) a= expr b= expr )
{
DebugLocation(841, 4);
DebugLocation(841, 6);
Match(input,Expr_Bin,Follow._Expr_Bin_in_expr3263);
Match(input, TokenTypes.Down, null);
DebugLocation(841, 17);
op=(CommonTree)input.LT(1);
if ((input.LA(1)>=87 && input.LA(1)<=88)||(input.LA(1)>=90 && input.LA(1)<=91)||input.LA(1)==95||input.LA(1)==97||input.LA(1)==101||input.LA(1)==109||input.LA(1)==115||input.LA(1)==117||input.LA(1)==119||input.LA(1)==122||(input.LA(1)>=125 && input.LA(1)<=127)||input.LA(1)==134||input.LA(1)==137||(input.LA(1)>=153 && input.LA(1)<=154)||input.LA(1)==162||input.LA(1)==182||input.LA(1)==185)
{
input.Consume();
state.errorRecovery=false;
}
else
{
MismatchedSetException mse = new MismatchedSetException(null,input);
DebugRecognitionException(mse);
throw mse;
}
DebugLocation(848, 9);
PushFollow(Follow._expr_in_expr3394);
a=expr();
PopFollow();
DebugLocation(848, 16);
PushFollow(Follow._expr_in_expr3398);
b=expr();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(849, 2);
value = new ExprBin(Alias(op.Text), a, b);
}
break;
case 21:
DebugEnterAlt(21);
// SugarWalker.g:852:4: ^(op= ( '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '^=' | '|=' | '<<=' | '>>=' ) a= expr b= expr )
{
DebugLocation(852, 4);
DebugLocation(852, 8);
op=(CommonTree)input.LT(1);
if (input.LA(1)==89||input.LA(1)==92||input.LA(1)==96||input.LA(1)==99||input.LA(1)==104||input.LA(1)==110||input.LA(1)==118||input.LA(1)==121||input.LA(1)==128||input.LA(1)==135||input.LA(1)==183)
{
input.Consume();
state.errorRecovery=false;
}
else
{
MismatchedSetException mse = new MismatchedSetException(null,input);
DebugRecognitionException(mse);
throw mse;
}
Match(input, TokenTypes.Down, null);
DebugLocation(852, 88);
PushFollow(Follow._expr_in_expr3456);
a=expr();
PopFollow();
DebugLocation(852, 95);
PushFollow(Follow._expr_in_expr3460);
b=expr();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(853, 2);
value = new ExprBin(op.Text, a, b);
}
break;
case 22:
DebugEnterAlt(22);
// SugarWalker.g:856:4: ^( '@' text_ident= ident )
{
DebugLocation(856, 4);
DebugLocation(856, 6);
Match(input,131,Follow._131_in_expr3470);
Match(input, TokenTypes.Down, null);
DebugLocation(856, 20);
PushFollow(Follow._ident_in_expr3474);
text_ident=ident();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(857, 2);
value = new ExprBracket(new ExprAccess(new ExprConst("this", ConstType.Ident), "->", text_ident));
}
break;
case 23:
DebugEnterAlt(23);
// SugarWalker.g:860:4: ^( Expr_Bracket a= expr )
{
DebugLocation(860, 4);
DebugLocation(860, 6);
Match(input,Expr_Bracket,Follow._Expr_Bracket_in_expr3484);
Match(input, TokenTypes.Down, null);
DebugLocation(860, 20);
PushFollow(Follow._expr_in_expr3488);
a=expr();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(861, 2);
value = new ExprBracket(a);
}
break;
case 24:
DebugEnterAlt(24);
// SugarWalker.g:864:4: ^( Expr_Suffix op= ( '++' | '--' ) a= expr )
{
DebugLocation(864, 4);
DebugLocation(864, 6);
Match(input,Expr_Suffix,Follow._Expr_Suffix_in_expr3498);
Match(input, TokenTypes.Down, null);
DebugLocation(864, 20);
op=(CommonTree)input.LT(1);
if (input.LA(1)==98||input.LA(1)==102)
{
input.Consume();
state.errorRecovery=false;
}
else
{
MismatchedSetException mse = new MismatchedSetException(null,input);
DebugRecognitionException(mse);
throw mse;
}
DebugLocation(864, 36);
PushFollow(Follow._expr_in_expr3512);
a=expr();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(865, 2);
value = new ExprSuffix(op.Text, a);
}
break;
case 25:
DebugEnterAlt(25);
// SugarWalker.g:868:4: ^( Expr_Prefix op= ( '!' | '~' | '++' | '--' | '-' | '+' | '*' | '&' | 'not' ) a= expr )
{
DebugLocation(868, 4);
DebugLocation(868, 6);
Match(input,Expr_Prefix,Follow._Expr_Prefix_in_expr3522);
Match(input, TokenTypes.Down, null);
DebugLocation(868, 20);
op=(CommonTree)input.LT(1);
if (input.LA(1)==86||input.LA(1)==91||input.LA(1)==95||(input.LA(1)>=97 && input.LA(1)<=98)||(input.LA(1)>=101 && input.LA(1)<=102)||input.LA(1)==161||input.LA(1)==186)
{
input.Consume();
state.errorRecovery=false;
}
else
{
MismatchedSetException mse = new MismatchedSetException(null,input);
DebugRecognitionException(mse);
throw mse;
}
DebugLocation(868, 80);
PushFollow(Follow._expr_in_expr3564);
a=expr();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(869, 2);
value = new ExprPrefix(Alias(op.Text), a);
}
break;
case 26:
DebugEnterAlt(26);
// SugarWalker.g:872:4: ^( ':=' a= expr b= expr )
{
DebugLocation(872, 4);
DebugLocation(872, 6);
Match(input,113,Follow._113_in_expr3574);
Match(input, TokenTypes.Down, null);
DebugLocation(872, 12);
PushFollow(Follow._expr_in_expr3578);
a=expr();
PopFollow();
DebugLocation(872, 19);
PushFollow(Follow._expr_in_expr3582);
b=expr();
PopFollow();
Match(input, TokenTypes.Up, null);
DebugLocation(873, 2);
if (!(a is ExprConst))
{
throw new Exception("Assert failed.");
}
value = new ExprAlloc(new AutoType(), ((ExprConst)a).Text, b, AllocType.Equal);
}
break;
case 27:
DebugEnterAlt(27);
// SugarWalker.g:880:4: text_ident= ident
{
DebugLocation(880, 15);
PushFollow(Follow._ident_in_expr3595);
text_ident=ident();
PopFollow();
DebugLocation(881, 2);
if (text_ident == "nil") text_ident = "NULL";
value = new ExprConst(text_ident, ConstType.Ident);
}
break;
case 28:
DebugEnterAlt(28);
// SugarWalker.g:885:4: text= ( NUMBER | DOUBLE )
{
DebugLocation(885, 8);
text=(CommonTree)input.LT(1);
if (input.LA(1)==NUMBER||input.LA(1)==DOUBLE)
{
input.Consume();
state.errorRecovery=false;
}
else
{
MismatchedSetException mse = new MismatchedSetException(null,input);
DebugRecognitionException(mse);
throw mse;
}
DebugLocation(886, 5);
value = new ExprConst(text.Text, ConstType.Number);
}
break;
case 29:
DebugEnterAlt(29);
// SugarWalker.g:889:4: text= STRING
{
DebugLocation(889, 9);
text=(CommonTree)Match(input,STRING,Follow._STRING_in_expr3626);
DebugLocation(890, 2);
value = new ExprConst(text.Text, ConstType.String);
}
break;
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
}
finally
{
TraceOut("expr", 60);
LeaveRule("expr", 60);
LeaveRule_expr();
}
DebugLocation(893, 1);
} finally { DebugExitRule(GrammarFileName, "expr"); }
return value;
}