private Expression ParseLambda(
TokenStream tokens,
Token firstToken,
IList <AType> argTypes,
IList <Token> args,
Node owner)
{
tokens.PopExpected("=>");
Lambda lambda = new Lambda(firstToken, owner, args, argTypes);
IList <Executable> lambdaCode;
if (tokens.IsNext("{"))
{
lambdaCode = this.parser.ExecutableParser.ParseBlock(tokens, false, lambda, false);
}
else
{
Expression lambdaBodyExpression = this.parser.ExpressionParser.ParseTernary(tokens, lambda);
lambdaCode = new Executable[] { new ExpressionAsExecutable(lambdaBodyExpression, lambda) };
}
if (lambdaCode.Count == 1 && lambdaCode[0] is ExpressionAsExecutable)
{
// If a lambda contains a single expression as its code body, then this is an implicit return statement.
ExpressionAsExecutable eae = (ExpressionAsExecutable)lambdaCode[0];
lambdaCode[0] = new ReturnStatement(eae.FirstToken, eae.Expression, lambda);
}
lambda.Code = lambdaCode.ToArray();
return(lambda);
}
protected abstract void TranslateExpressionAsExecutable(List <string> output, ExpressionAsExecutable exprAsExec);
protected override void TranslateExpressionAsExecutable(List <string> output, ExpressionAsExecutable exprAsExec)
{
output.Add(this.CurrentTabIndention);
TranslateExpression(output, exprAsExec.Expression);
output.Add(";" + this.NL);
}
private void CompileExpressionAsExecutable(ParserContext parser, ByteBuffer buffer, ExpressionAsExecutable expr)
{
this.CompileExpression(parser, buffer, expr.Expression, false);
}
public static Executable Parse(ParserContext context, TokenStream tokens, TopLevelEntity parent, bool enableSemicolon)
{
switch (tokens.PeekValue())
{
case "for": return(ParseForLoop(context, tokens, parent));
case "foreach": return(ParseForEachLoop(context, tokens, parent));
case "if": return(ParseIfStatement(context, tokens, parent));
case "while": return(ParseWhileLoop(context, tokens, parent));
case "do": return(ParseDoWhileLoop(context, tokens, parent));
case "switch": return(ParseSwitchStatement(context, tokens, parent));
case "throw": return(ParseThrowStatement(context, tokens, parent));
case "return": return(ParseReturnStatement(context, tokens, parent));
case "using": return(ParseUsingStatement(context, tokens, parent));
case "try": return(ParseTryStatement(context, tokens, parent));
default:
break;
}
// check for variable declaration
int state = tokens.CurrentState;
CSharpType variableDeclarationType = CSharpType.TryParse(tokens);
if (variableDeclarationType != null)
{
Token variableName = tokens.PopWordIfPresent();
if (variableName != null && (tokens.IsNext(";") || tokens.IsNext("=") || tokens.IsNext(",")))
{
// This is a variable declaration.
Executable varDecl = ParseVariableDeclaration(context, tokens, variableDeclarationType, variableName, parent);
if (enableSemicolon)
{
tokens.PopExpected(";");
}
return(varDecl);
}
tokens.RestoreState(state);
}
Expression expr = ExpressionParser.Parse(context, tokens, parent);
Executable exec;
string nextToken = tokens.PeekValue();
switch (nextToken)
{
case "=":
case "+=":
case "-=":
case "*=":
case "/=":
case "%=":
case "|=":
case "&=":
case "^=":
case "<<=":
case ">>=":
Token assignmentOpToken = tokens.Pop();
Expression assignmentValue = ExpressionParser.Parse(context, tokens, parent);
exec = new AssignmentStatement(expr.FirstToken, expr, assignmentOpToken, assignmentValue, parent);
break;
default:
exec = new ExpressionAsExecutable(expr, parent);
break;
}
if (enableSemicolon)
{
tokens.PopExpected(";");
}
return(exec);
}
