protected virtual StatementSequenceNode ParseStatementSequence(IStatementParentNode parent, Token token)
{
// PARSE: (<expression> ['.' [<statements>]])
StatementSequenceNode result = new StatementSequenceNode(parent);
ExpressionNode expression = this.ParseExpression(result, token);
if (expression == null)
{
this.ReportParserError(result, SemanticErrors.MissingExpression, token);
}
SpecialCharacterToken period = null;
token = this.GetNextTokenxx(Preference.Default);
if (Parser.IsStatementDelimiter(token))
{
period = (SpecialCharacterToken)token;
}
else
{
result.SetContents(expression, null, null);
this.ResidueToken = token;
return(result);
}
// ['.' [<statements>]])
token = this.GetNextTokenxx(Preference.NegativeSign);
if (token is EofToken)
{
result.SetContents(expression, period, null);
this.ResidueToken = token;
return(result);
}
if (Parser.IsBlockEndDelimiter(token))
{
result.SetContents(expression, period, null);
this.ResidueToken = token;
return(result);
}
else if (Parser.IsStatementDelimiter(token))
{
this.ReportParserError(result, SemanticErrors.MissingStatement, token);
result.SetContents(expression, period, null);
this.ResidueToken = token;
return(result);
}
StatementNode nextStatement = this.ParseStatement(result, token);
result.SetContents(expression, period, nextStatement);
return(result);
}
/// <summary>
/// Visits the Statement Sequence node.
/// </summary>
/// <param name="node">The node to visit.</param>
public virtual TResult VisitStatementSequence(StatementSequenceNode node)
{
if (node.Expression != null)
{
node.Expression.Accept(this);
}
if (node.NextStatement != null)
{
node.NextStatement.Accept(this);
}
return(default(TResult)); // The default naive implementation
}
/// <summary>
/// Visits the Statement Sequence node.
/// </summary>
/// <param name="node">The node to visit.</param>
public override bool VisitStatementSequence(StatementSequenceNode node)
{
if (node.Parent == null)
{
return(false);
}
if ((node.Expression == null) || !node.Expression.Accept(this))
{
return(false);
}
if ((node.NextStatement != null) && !node.NextStatement.Accept(this))
{
return(false);
}
return(true);
}
public override List <Expression> VisitStatementSequence(StatementSequenceNode node)
{
if (this.HasReturned)
{
throw (new SemanticCodeGenerationException(CodeGenerationErrors.CodeAfterReturnStatement)).SetErrorLocation(node);
}
Expression statementCode = node.Expression.Accept(new ExpressionVisitor(this));
statementCode = this.Context.Compiler.AddDebugInfo(statementCode, node.Expression);
this.Expressions.Add(statementCode);
if (node.NextStatement != null)
{
node.NextStatement.Accept(this);
}
return(this.Expressions);
}
private void AddEmitterToRoot(StatementSequenceEmitter rootEmitter, StatementSequenceNode astNode)
{
foreach (var astSubNode in astNode.SubNodes)
{
StatementSequenceEmitter emittedNode = new NoOpEmitter();
TypeSwitch.On(astSubNode)
.Case((VariableDeclarationNode variableDeclarationNode) =>
{
emittedNode = new VariableDeclarationNodeEmitter(variableDeclarationNode);
})
.Case((ReturnStatementNode returnStatementNode) =>
{
emittedNode = new ReturnStatementNodeEmitter(returnStatementNode);
});
if (astSubNode is StatementSequenceNode)
{
AddEmitterToRoot(emittedNode, astSubNode as StatementSequenceNode); //Also copy subnodes
}
rootEmitter.SubNodes.Add(emittedNode);
}
}
void DimStatement(ref StatementNode node)
{
var list = new List <StatementNode>();
StatementNode stmt = null;
Expect(45);
DimContent(ref stmt);
list.Add(stmt);
while (la.kind == 15)
{
Get();
DimContent(ref stmt);
list.Add(stmt);
}
if (list.Count > 1)
{
node = new StatementSequenceNode(list);
}
else
{
node = list[0];
}
}
/// <summary>
/// Visits the Statement Sequence node.
/// </summary>
/// <param name="node">The node to visit.</param>
public virtual TResult VisitStatementSequence(StatementSequenceNode node)
{
throw new NotImplementedException();
}
