private bool ParseIfStatement(TokenReader reader, out Statement statement)
{
Token start = reader.Peek();
statement = null;
if (!this.Expect(reader, Keyword.If))
{
return false;
}
IfStatement ifStatement = new IfStatement(start);
Expression condition = null;
if (!this.ParseExpression(reader, out condition))
{
return false;
}
ifStatement.Condition = condition;
if (!this.Expect(reader, Keyword.Then))
{
return false;
}
Statement trueStatement = null;
if (!this.ParseStatement(reader, out trueStatement))
{
return false;
}
ifStatement.TrueStatement = trueStatement;
Token tok = reader.Peek();
if (tok.Is(Keyword.Else))
{
reader.Read();
Statement falseStatement = null;
if (!this.ParseStatement(reader, out falseStatement))
{
return false;
}
ifStatement.FalseStatement = falseStatement;
}
statement = ifStatement;
return true;
}
private bool ParseDeleteStatement(TokenReader reader, out Statement statement)
{
statement = null;
Token start = reader.Peek();
if (!this.Expect(reader, Keyword.Delete))
{
return false;
}
Expression operand = null;
if (!this.ParseExpression(reader, out operand))
{
return false;
}
statement = new DeleteStatement(start, operand);
return true;
}
private bool ParseWhileStatement(TokenReader reader, out Statement statement)
{
Token start = reader.Peek();
statement = null;
if (!this.Expect(reader, Keyword.While))
{
return false;
}
WhileStatement whileStatement = new WhileStatement(start);
Expression condition = null;
if (!this.ParseExpression(reader, out condition))
{
return false;
}
whileStatement.Condition = condition;
if (!this.Expect(reader, Keyword.Do))
{
return false;
}
Statement bodyStatement = null;
if (!this.ParseStatement(reader, out bodyStatement))
{
return false;
}
whileStatement.BodyStatement = bodyStatement;
statement = whileStatement;
return true;
}
private bool ParseStatement(TokenReader reader, out Statement result)
{
result = null;
Token tok = reader.Peek();
Token start = tok;
if (tok.Is(Keyword.SemiColon))
{
return true; // empty statement.
}
if (tok.Is(Keyword.If))
{
return this.ParseIfStatement(reader, out result);
}
if (tok.Is(Keyword.While))
{
return this.ParseWhileStatement(reader, out result);
}
if (tok.Is(Keyword.Delete))
{
return this.ParseDeleteStatement(reader, out result);
}
if (tok.Is(Keyword.Begin))
{
BlockStatement block = null;
bool success = this.ParseBlockStatement(reader, out block);
result = block;
return success;
}
ReferenceExpression lhs = null;
if (!this.ParseReferenceExpression(reader, out lhs))
{
return false;
}
tok = reader.Peek();
if (tok.Is(Keyword.Assign))
{
reader.Read();
Expression rhs = null;
if (!this.ParseExpression(reader, out rhs))
{
return false;
}
result = new AssignmentStatement(start, lhs, rhs);
return true;
}
else
{
result = new CallStatement(start, lhs);
return true;
}
}
private bool TryEmitStatement(
Statement statement,
CompilerContext context,
Scope scope,
MethodImpl method)
{
AssignmentStatement assignmentStatement = statement as AssignmentStatement;
if (assignmentStatement != null)
{
return TryEmitAssignment(assignmentStatement, context, scope, method);
}
else
{
CallStatement callStatement = statement as CallStatement;
if (callStatement != null)
{
return TryEmitCall(callStatement, context, scope, method);
}
else
{
IfStatement ifStatement = statement as IfStatement;
if (ifStatement != null)
{
return TryEmitIfStatement(ifStatement, context, scope, method);
}
else
{
WhileStatement whileStatement = statement as WhileStatement;
if (whileStatement != null)
{
return TryEmitWhileStatement(whileStatement, context, scope, method);
}
else
{
BlockStatement blockStatement = statement as BlockStatement;
if (blockStatement != null)
{
return TryEmitBlockStatement(blockStatement, context, scope, method);
}
else
{
DeleteStatement deleteStatement = statement as DeleteStatement;
if (deleteStatement != null)
{
return TryEmitDeleteStatement(deleteStatement, context, scope, method);
}
}
}
}
}
}
return false;
}
public void AddStatement(Statement statement)
{
this.statements.Add(statement);
}
