public override Node VisitStatements(MetaCodeParser.StatementsContext context) { return StatementFactory.Block(context.statement() .Select(statement => statement.Accept(this) as StatementNodeBase) .ToArray() ); }
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); }
private Node VisitUnaryOperands(MetaCodeParser.ExpressionContext expression, IToken @operator) { if (new object[] { expression, @operator }.Any(value => value == null)) return null; var expr = expression.Accept(this) as ExpressionNode; var op = @operator.Text; return ExpressionFactory.UnaryOperand(expr, op); }
public override Node VisitArrayConstant(MetaCodeParser.ArrayConstantContext context) { var text = context.GetText(); var expressions = context.expression() .Select(expression => expression.Accept(this)) .OfType<ExpressionNode>() .ToArray(); return ConstantLiteralFactory.Array(expressions); }
public override Node VisitConstant(MetaCodeParser.ConstantContext context) { if (context.Null != null) return new NullConstantLiteralNode(); return GetNodeFromContext(context.String, context.Number, context.Boolean, context.Array, context.Interval); }
public override Node VisitExpression(MetaCodeParser.ExpressionContext context) { var result = GetNodeFromContext( context.PrimaryExpression, context.FunctionCallExpression, context.MacroCallExpression, context.MemberExpression) ?? VisitBinaryOperands(context.Left, context.Right, context.Operator) ?? VisitUnaryOperands(context.Expression, context.Operator); return result; }
private Node VisitBinaryOperands(MetaCodeParser.ExpressionContext left, MetaCodeParser.ExpressionContext right, IToken @operator) { if (new object[] { left, right, @operator }.Any(obj => obj == null)) return null; var leftExpression = left.Accept(this) as ExpressionNode; var rightExpression = right.Accept(this) as ExpressionNode; var operatorText = @operator.Text; return ExpressionFactory.BinaryOperand(leftExpression, rightExpression, operatorText); }
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 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 VisitStatement(MetaCodeParser.StatementContext context) { return GetNodeFromContext( context.Block, context.If, context.While, context.Foreach, context.Skip, context.VariableDeclaration, context.FunctionDeclaration, context.ObjectDeclaration, context.AttributeDeclaration, context.MacroDeclaration, context.Return ) ?? new ExpressionStatementNode(context.Expression.Accept(this) as ExpressionNode); }
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 VisitMacroCallExpression(MetaCodeParser.MacroCallExpressionContext context) { var macroName = context.macroName.Text; var statements = context.statement() .Select(statement => statement.Accept(this) as StatementNodeBase) .ToArray(); return ExpressionFactory.MacroCall(macroName, statements); }
public override Node VisitInit(MetaCodeParser.InitContext context) { var result = base.VisitInit(context) as BlockStatementNode; return StatementFactory.CompilationUnit(result); }
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 VisitStringConstant(MetaCodeParser.StringConstantContext context) { return new StringConstantLiteralNode(context.GetText().Trim('"').Trim('\'')); }
public override Node VisitReturnStatement(MetaCodeParser.ReturnStatementContext context) { var expression = context.ReturnExpression.Accept(this) as ExpressionNode; return StatementFactory.Return(expression); }
public override Node VisitMacroFormalParameter(MetaCodeParser.MacroFormalParameterContext context) { var identifier = context.Name.Text; var treeSelector = context.Selector.Text; return new MacroFormalParameterNode(identifier, treeSelector); }
public override Node VisitSkipStatement(MetaCodeParser.SkipStatementContext context) { return StatementFactory.Skip(); }
public override Node VisitElseIfStatement(MetaCodeParser.ElseIfStatementContext context) { var condition = context.Condition.Accept(this) as ExpressionNode; var statements = context.Statements.Accept(this) as BlockStatementNode; return StatementFactory.IfThenElse(condition, statements, new AttributeNode[0]); }
/*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 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 VisitNumberConstant(MetaCodeParser.NumberConstantContext context) { var text = context.GetText(); return ConstantLiteralFactory.Number(text); }
public override Node VisitMemberExpression(MetaCodeParser.MemberExpressionContext context) { var ids = context.ID().Select(id => id.GetText()).ToArray(); return ExpressionFactory.Member(ids); }
public override Node VisitBooleanConstant(MetaCodeParser.BooleanConstantContext context) { var text = context.GetText(); return ConstantLiteralFactory.Logical(text); }
public override Node VisitFunctionCallExpression(MetaCodeParser.FunctionCallExpressionContext context) { var functionName = context.functionName.Text; var expressions = context.expression() .Select(expression => expression.Accept(this) as ExpressionNode) .ToArray(); return ExpressionFactory.FunctionCall(functionName, expressions); }
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 VisitMacroStatement(MetaCodeParser.MacroStatementContext context) { var identifier = context.MacroName.Text; var body = context.BodyStatements.Accept(this) as BlockStatementNode; var parameters = context.macroFormalParameter() .Select(param => param.Accept(this) as MacroFormalParameterNode) .ToArray(); //var type = context.Type.Text == "implicit" ? MacroType.Implicit : MacroType.Explicit; return StatementFactory.Macro(identifier, parameters, body, MacroType.Implicit); }
public override Node VisitAttribute(MetaCodeParser.AttributeContext context) { var name = context.Name.Text; var expressions = context.expression() .Select(expression => expression.Accept(this) as ExpressionNode) .ToArray(); return ConstantLiteralFactory.Attribute(name, expressions); }
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); }