public override Node VisitBlockStatement(MetaCodeParser.BlockStatementContext context)
{
var attributes = GetAttributes(context.attribute());
var body = context.statement()
.Select(stmt => stmt.Accept(this) as StatementNodeBase)
.ToArray();
return StatementFactory.Block(body, attributes);
}
public override Node VisitWhileStatement(MetaCodeParser.WhileStatementContext context)
{
var attributes = GetAttributes(context.attribute());
var condition = context.ConditionExpression.Accept(this) as ExpressionNode;
var body = context.Body.Accept(this) as StatementNodeBase;
return StatementFactory.While(condition, body, attributes);
}
public override Node VisitTypeName(MetaCodeParser.TypeNameContext context)
{
var attributes = context.attribute()
.Select(attribute => attribute.Accept(this) as AttributeNode)
.ToArray();
var identifiers = context.ID()
.Select(id => id.GetText())
.ToArray();
return ExpressionFactory.Type(string.Join(".", identifiers), attributes);
}
public override Node VisitIfStatement(MetaCodeParser.IfStatementContext context)
{
var attributes = GetAttributes(context.attribute());
var condition = context.Condition.Accept(this) as ExpressionNode;
var statements = context.Statements.Accept(this) as BlockStatementNode;
var elseIfStatements = context.elseIfStatement()
.Select(elseIf => elseIf.Accept(this) as IfStatementNode)
.ToArray();
var elseStatements = context.ElseStatements.With(statement => statement.Accept(this)) as BlockStatementNode;
return StatementFactory.IfThenElse(condition, statements, elseIfStatements, elseStatements, attributes);
}
/*public override Node VisitFunctionExpression(MetaCodeParser.FunctionExpressionContext context)
{
var identifier = context.FunctionName.With(functionName => functionName.Text);
var returnType = context.ReturnType.Accept(this) as TypeNameNode;
var parameters = context.Parameters;
var formalParameters = new Func<FormalParameterNode[]>(() => {
if (parameters == null)
return new FormalParameterNode[0];
var result = parameters.formalParameter().Select(param => {
return ExpressionFactory.FormalParameter(param.Identifier.Text,
param.VariableType.With(type => type.Accept(this) as TypeNameNode),
null);
});
return result.ToArray();
})();
if (context.BodyExpression != null)
return ExpressionFactory.Function(identifier,
returnType.VariableType,
formalParameters,
new Lazy<ExpressionNode>(() => context.BodyExpression.Accept(this) as ExpressionNode));
return ExpressionFactory.Function(identifier,
returnType.VariableType,
formalParameters,
new Lazy<BlockStatementNode>(() => context.BodyStatements.Accept(this) as BlockStatementNode));
}*/
public override Node VisitPrimaryExpression(MetaCodeParser.PrimaryExpressionContext context)
{
var attributes = context.attribute()
.Select(attribute => attribute.Accept(this) as AttributeNode)
.ToArray();
if (context.Constant != null)
{
var constant = context.Constant.Accept(this) as ConstantLiteralNode;
return ExpressionFactory.Constant(constant, attributes);
}
if (context.Id != null)
return ExpressionFactory.Identifier(context.Id.Text, attributes);
if (context.Assignment != null)
{
var assignment = context.Assignment;
var member = assignment.LeftValue.With(leftValue => leftValue.Accept(this) as MemberExpressionNode) ??
ExpressionFactory.Member(new[] { assignment.VariableName.Text });
var value = assignment.RightValue.Accept(this) as ExpressionNode;
return ExpressionFactory.Assignment(member, value, attributes);
}
if (context.InnerExpression != null)
return ExpressionFactory.InnerExpression(context.InnerExpression.Accept(this) as ExpressionNode, attributes);
return base.VisitPrimaryExpression(context);
}
public override Node VisitForeachStatement(MetaCodeParser.ForeachStatementContext context)
{
var attributes = GetAttributes(context.attribute());
var identifier = context.Id.Text;
var arrayExpression = context.ArrayExpression.Accept(this) as ExpressionNode;
var variableType = context.VariableType.With(variable => variable.Accept(this)) as TypeNameNode;
return StatementFactory.Foreach(identifier,
variableType,
arrayExpression,
context.Body.Accept(this) as StatementNodeBase,
attributes);
}
public override Node VisitFormalParameter(MetaCodeParser.FormalParameterContext context)
{
var parameterName = context.Name.Text;
var typeName = context.Type.Accept(this) as TypeNameNode;
var attributes = context.attribute()
.Select(attribute => attribute.Accept(this) as AttributeNode)
.ToArray();
return StatementFactory.FormalParameter(parameterName, typeName, attributes);
}
public override Node VisitAttributeDeclaration(MetaCodeParser.AttributeDeclarationContext context)
{
var attributes = GetAttributes(context.attribute());
var attributeName = context.AttributeName.Text;
var parameters = context.formalParameter()
.Select(parameter => parameter.Accept(this) as FormalParameterNode)
.ToArray();
return StatementFactory.Attribute(attributeName, parameters, attributes);
}
public override Node VisitFunctionStatement(MetaCodeParser.FunctionStatementContext context)
{
var attributes = GetAttributes(context.attribute());
var functionName = context.FunctionName.Text;
var returnType = context.ReturnType.With(type => type.Accept(this) as TypeNameNode);
var parameters = context.formalParameter()
.Select(parameter => parameter.Accept(this) as FormalParameterNode)
.ToArray();
var body = context.BodyStatements.Accept(this) as BlockStatementNode;
return StatementFactory.Function(functionName, returnType, parameters, body, attributes);
}
public override Node VisitVariableDeclaration(MetaCodeParser.VariableDeclarationContext context)
{
var attributes = GetAttributes(context.attribute());
var name = context.VariableName.Text;
var typeName = context.VariableType.With(variable => variable.Accept(this)) as TypeNameNode;
var defaultValue = context.VariableDefaultValue.With(expression => expression.Accept(this)) as ExpressionNode;
return StatementFactory.DeclareVariable(name, typeName, defaultValue, attributes);
}