public abstract Template Visit(ExprCurryLambda expr);
public override Template Visit(ExprCurryLambda expr) { if (expr.Args.Count() <= 1) { return (new ExprLambda(expr.Block, expr.Args, expr.IsRef, expr.Type)).Accept(this); } Stack<ExprAlloc> stack = new Stack<ExprAlloc>(); foreach (var x in expr.Args) stack.Push(x); Stack<string> capture_args = new Stack<string>(); foreach (var x in expr.Args) capture_args.Push(x.Name.First()); Template template = null; foreach (var x in stack) { Template node = null; if (template == null) { node = new Template("([<ref><capture>](<arg>)<type> {\n <block>\n})"); if (expr.Type == null) { node.Add("type", ""); } else { Template type = new Template(" -> <type>"); type.Add("type", expr.Type.Accept(this)); node.Add("type", type); } node.Add("block", expr.Block.Accept(this)); } else { node = new Template("([<ref><capture>](<arg>) {\n return <expr>;\n})"); node.Add("expr", template); } node.Add("ref", expr.IsRef ? "&" : "="); node.Add("arg", x.Accept(this)); capture_args.Pop(); string capture_by_value = ""; foreach (var name in capture_args) { capture_by_value = capture_by_value + ", " + name; } if (!expr.IsRef) capture_by_value = ""; node.Add("capture", capture_by_value); template = node; } return template; }
private Expr lambda_expr() { EnterRule_lambda_expr(); EnterRule("lambda_expr", 50); TraceIn("lambda_expr", 50); Expr value = default(Expr); List<ExprAlloc> b = default(List<ExprAlloc>); SugarType t = default(SugarType); StmtBlock a = default(StmtBlock); try { DebugEnterRule(GrammarFileName, "lambda_expr"); DebugLocation(640, 1); try { // SugarWalker.g:641:2: ( ^( Expr_Lambda '->' (b= func_args )? (t= type_name )? a= stmt_block ) | ^( Expr_Lambda '=>' (b= func_args )? (t= type_name )? a= stmt_block ) | ^( Expr_Lambda '-->' (b= func_args )? (t= type_name )? a= stmt_block ) | ^( Expr_Lambda '==>' (b= func_args )? (t= type_name )? a= stmt_block ) ) int alt82=4; try { DebugEnterDecision(82, false); int LA82_0 = input.LA(1); if ((LA82_0==Expr_Lambda)) { int LA82_1 = input.LA(2); if ((LA82_1==DOWN)) { switch (input.LA(3)) { case 105: { alt82 = 1; } break; case 124: { alt82 = 2; } break; case 103: { alt82 = 3; } break; case 123: { alt82 = 4; } break; default: { NoViableAltException nvae = new NoViableAltException("", 82, 2, input); DebugRecognitionException(nvae); throw nvae; } } } else { NoViableAltException nvae = new NoViableAltException("", 82, 1, input); DebugRecognitionException(nvae); throw nvae; } } else { NoViableAltException nvae = new NoViableAltException("", 82, 0, input); DebugRecognitionException(nvae); throw nvae; } } finally { DebugExitDecision(82); } switch (alt82) { case 1: DebugEnterAlt(1); // SugarWalker.g:641:4: ^( Expr_Lambda '->' (b= func_args )? (t= type_name )? a= stmt_block ) { DebugLocation(641, 4); DebugLocation(641, 6); Match(input,Expr_Lambda,Follow._Expr_Lambda_in_lambda_expr2444); Match(input, TokenTypes.Down, null); DebugLocation(641, 18); Match(input,105,Follow._105_in_lambda_expr2446); DebugLocation(641, 23); // SugarWalker.g:641:23: (b= func_args )? int alt74=2; try { DebugEnterSubRule(74); try { DebugEnterDecision(74, false); int LA74_0 = input.LA(1); if ((LA74_0==Func_Args)) { alt74 = 1; } } finally { DebugExitDecision(74); } switch (alt74) { case 1: DebugEnterAlt(1); // SugarWalker.g:641:24: b= func_args { DebugLocation(641, 25); PushFollow(Follow._func_args_in_lambda_expr2451); b=func_args(); PopFollow(); } break; } } finally { DebugExitSubRule(74); } DebugLocation(641, 38); // SugarWalker.g:641:38: (t= type_name )? int alt75=2; try { DebugEnterSubRule(75); try { DebugEnterDecision(75, false); int LA75_0 = input.LA(1); if (((LA75_0>=Type_Array && LA75_0<=Type_Ident)||(LA75_0>=Type_Ref && LA75_0<=Type_Template))) { alt75 = 1; } } finally { DebugExitDecision(75); } switch (alt75) { case 1: DebugEnterAlt(1); // SugarWalker.g:641:39: t= type_name { DebugLocation(641, 40); PushFollow(Follow._type_name_in_lambda_expr2458); t=type_name(); PopFollow(); } break; } } finally { DebugExitSubRule(75); } DebugLocation(641, 54); PushFollow(Follow._stmt_block_in_lambda_expr2464); a=stmt_block(); PopFollow(); Match(input, TokenTypes.Up, null); DebugLocation(642, 2); value = new ExprLambda(a, b, true, t); } break; case 2: DebugEnterAlt(2); // SugarWalker.g:645:4: ^( Expr_Lambda '=>' (b= func_args )? (t= type_name )? a= stmt_block ) { DebugLocation(645, 4); DebugLocation(645, 6); Match(input,Expr_Lambda,Follow._Expr_Lambda_in_lambda_expr2474); Match(input, TokenTypes.Down, null); DebugLocation(645, 18); Match(input,124,Follow._124_in_lambda_expr2476); DebugLocation(645, 23); // SugarWalker.g:645:23: (b= func_args )? int alt76=2; try { DebugEnterSubRule(76); try { DebugEnterDecision(76, false); int LA76_0 = input.LA(1); if ((LA76_0==Func_Args)) { alt76 = 1; } } finally { DebugExitDecision(76); } switch (alt76) { case 1: DebugEnterAlt(1); // SugarWalker.g:645:24: b= func_args { DebugLocation(645, 25); PushFollow(Follow._func_args_in_lambda_expr2481); b=func_args(); PopFollow(); } break; } } finally { DebugExitSubRule(76); } DebugLocation(645, 38); // SugarWalker.g:645:38: (t= type_name )? int alt77=2; try { DebugEnterSubRule(77); try { DebugEnterDecision(77, false); int LA77_0 = input.LA(1); if (((LA77_0>=Type_Array && LA77_0<=Type_Ident)||(LA77_0>=Type_Ref && LA77_0<=Type_Template))) { alt77 = 1; } } finally { DebugExitDecision(77); } switch (alt77) { case 1: DebugEnterAlt(1); // SugarWalker.g:645:39: t= type_name { DebugLocation(645, 40); PushFollow(Follow._type_name_in_lambda_expr2488); t=type_name(); PopFollow(); } break; } } finally { DebugExitSubRule(77); } DebugLocation(645, 54); PushFollow(Follow._stmt_block_in_lambda_expr2494); a=stmt_block(); PopFollow(); Match(input, TokenTypes.Up, null); DebugLocation(646, 2); value = new ExprLambda(a, b, false, t); } break; case 3: DebugEnterAlt(3); // SugarWalker.g:649:4: ^( Expr_Lambda '-->' (b= func_args )? (t= type_name )? a= stmt_block ) { DebugLocation(649, 4); DebugLocation(649, 6); Match(input,Expr_Lambda,Follow._Expr_Lambda_in_lambda_expr2504); Match(input, TokenTypes.Down, null); DebugLocation(649, 18); Match(input,103,Follow._103_in_lambda_expr2506); DebugLocation(649, 24); // SugarWalker.g:649:24: (b= func_args )? int alt78=2; try { DebugEnterSubRule(78); try { DebugEnterDecision(78, false); int LA78_0 = input.LA(1); if ((LA78_0==Func_Args)) { alt78 = 1; } } finally { DebugExitDecision(78); } switch (alt78) { case 1: DebugEnterAlt(1); // SugarWalker.g:649:25: b= func_args { DebugLocation(649, 26); PushFollow(Follow._func_args_in_lambda_expr2511); b=func_args(); PopFollow(); } break; } } finally { DebugExitSubRule(78); } DebugLocation(649, 39); // SugarWalker.g:649:39: (t= type_name )? int alt79=2; try { DebugEnterSubRule(79); try { DebugEnterDecision(79, false); int LA79_0 = input.LA(1); if (((LA79_0>=Type_Array && LA79_0<=Type_Ident)||(LA79_0>=Type_Ref && LA79_0<=Type_Template))) { alt79 = 1; } } finally { DebugExitDecision(79); } switch (alt79) { case 1: DebugEnterAlt(1); // SugarWalker.g:649:40: t= type_name { DebugLocation(649, 41); PushFollow(Follow._type_name_in_lambda_expr2518); t=type_name(); PopFollow(); } break; } } finally { DebugExitSubRule(79); } DebugLocation(649, 55); PushFollow(Follow._stmt_block_in_lambda_expr2524); a=stmt_block(); PopFollow(); Match(input, TokenTypes.Up, null); DebugLocation(650, 2); value = new ExprCurryLambda(a, b, true, t); } break; case 4: DebugEnterAlt(4); // SugarWalker.g:653:4: ^( Expr_Lambda '==>' (b= func_args )? (t= type_name )? a= stmt_block ) { DebugLocation(653, 4); DebugLocation(653, 6); Match(input,Expr_Lambda,Follow._Expr_Lambda_in_lambda_expr2534); Match(input, TokenTypes.Down, null); DebugLocation(653, 18); Match(input,123,Follow._123_in_lambda_expr2536); DebugLocation(653, 24); // SugarWalker.g:653:24: (b= func_args )? int alt80=2; try { DebugEnterSubRule(80); try { DebugEnterDecision(80, false); int LA80_0 = input.LA(1); if ((LA80_0==Func_Args)) { alt80 = 1; } } finally { DebugExitDecision(80); } switch (alt80) { case 1: DebugEnterAlt(1); // SugarWalker.g:653:25: b= func_args { DebugLocation(653, 26); PushFollow(Follow._func_args_in_lambda_expr2541); b=func_args(); PopFollow(); } break; } } finally { DebugExitSubRule(80); } DebugLocation(653, 39); // SugarWalker.g:653:39: (t= type_name )? int alt81=2; try { DebugEnterSubRule(81); try { DebugEnterDecision(81, false); int LA81_0 = input.LA(1); if (((LA81_0>=Type_Array && LA81_0<=Type_Ident)||(LA81_0>=Type_Ref && LA81_0<=Type_Template))) { alt81 = 1; } } finally { DebugExitDecision(81); } switch (alt81) { case 1: DebugEnterAlt(1); // SugarWalker.g:653:40: t= type_name { DebugLocation(653, 41); PushFollow(Follow._type_name_in_lambda_expr2548); t=type_name(); PopFollow(); } break; } } finally { DebugExitSubRule(81); } DebugLocation(653, 55); PushFollow(Follow._stmt_block_in_lambda_expr2554); a=stmt_block(); PopFollow(); Match(input, TokenTypes.Up, null); DebugLocation(654, 2); value = new ExprCurryLambda(a, b, false, t); } break; } } catch (RecognitionException re) { ReportError(re); Recover(input,re); } finally { TraceOut("lambda_expr", 50); LeaveRule("lambda_expr", 50); LeaveRule_lambda_expr(); } DebugLocation(657, 1); } finally { DebugExitRule(GrammarFileName, "lambda_expr"); } return value; }