public static ExpressionNode Parse(ContextNode context, IAbstractSyntaxTree lexerNode, TypeReference expectedType = null) { Contract.Ensures(Contract.Result <ExpressionNode>() != null); ExpressionNode ret = null; switch (lexerNode.Type) { case Lexer.TokenType.FullSymbol: case Lexer.TokenType.Symbol: ret = DotOperatorNode.Parse(context, lexerNode); break; case Lexer.TokenType.LiteralNode: ret = LiteralNode.Parse(context, lexerNode); break; case Lexer.TokenType.Value: ret = ExpressionNode.Parse(context, lexerNode.Children[0], expectedType); break; case Lexer.TokenType.Function: ret = MethodNode.Parse(context, lexerNode); break; case Lexer.TokenType.InfixNode: ret = InfixParser.Parse(context, lexerNode); break; case Lexer.TokenType.PostfixNode: case Lexer.TokenType.PrefixNode: ret = UnaryOperators.Parse(context, lexerNode); break; case Lexer.TokenType.ParenthesesNode: ret = ExpressionNode.Parse(context, lexerNode.Children[1], expectedType); break; case Lexer.TokenType.ArrayLiteral: ret = ArrayCreationNode.Parse(context, lexerNode); break; case Lexer.TokenType.Null: ret = NullNode.Parse(context, lexerNode); break; default: ContractsHelper.AssumeUnreachable("Unknown expression type {0}", lexerNode.Type); break; } if (!(expectedType == null || expectedType.IsAuto())) { var ambiguous = ret as IAmbiguousNode; if (ambiguous != null) { ret = ambiguous.RemoveAmbiguity(context, expectedType); } } return(ret); }
public static ExpressionNode Parse(ContextNode context, IAbstractSyntaxTree lexerNode) { var left = ExpressionNode.Parse(context, lexerNode.Children[0]); var right = ExpressionNode.Parse(context, lexerNode.Children[1], left.IsGettable ? left.ExpressionReturnType : null); var point = context.Parser.GetSequencePoint(lexerNode); return(Create(context, LexerToAssignemnt[lexerNode.Children[2].Type], left, right, point)); }
public static ExpressionNode Parse(ContextNode context, IAbstractSyntaxTree lexerNode) { Contract.Requires(lexerNode.Type == Lexer.TokenType.InfixNode); var left = ExpressionNode.Parse(context, lexerNode.Children[0]); var right = ExpressionNode.Parse(context, lexerNode.Children[1]); var opType = lexerNode.Children[2].Type; return(Create(context, Operators[opType], left, right, context.Parser.GetSequencePoint(lexerNode))); }
public static WhileBlock Parse(ContextNode context, IAbstractSyntaxTree lexerNode) { Contract.Requires(lexerNode.Type == TokenType.WhileLoop); var point = context.Parser.GetSequencePoint(lexerNode); var condition = ExpressionNode.Parse(context, lexerNode.Children[2]); var block = CodeBlockNode.Parse(context, lexerNode.Children[4]); return(Create(context, condition, block, point)); }
public static ExpressionNode Parse(ContextNode context, IAbstractSyntaxTree lexerNode) { Contract.Requires(lexerNode.Type == Lexer.TokenType.PostfixNode); Contract.Requires(lexerNode.Children[1].Type == Lexer.TokenType.FunctionArgumentsList); var function = ExpressionNode.Parse(context, lexerNode.Children[0]); var args = ParseArgList(context, lexerNode.Children[1]); var point = context.Parser.GetSequencePoint(lexerNode.Children[1]); return(Create(context, function, args, point)); }
public static SymbolDeclarationNode Parse(ContextNode context, IAbstractSyntaxTree lexerNode) { Contract.Requires(lexerNode.Type == Lexer.TokenType.DeclarationNode); var info = DeclarationInfo.Parse(context.Parser, lexerNode); var name = info.SymbolName.GetSingleSymbolOrThrow(); var declaredType = TypeNode.Parse(context, info.Type); var point = context.Parser.GetSequencePoint(lexerNode); ExpressionNode initializer = info.Initializer == null ? null : ExpressionNode.Parse(context, info.Initializer, declaredType); return(Create(context, info.Modifiers, declaredType, name, initializer, point)); }
public static ReturnNode Parse(CodeBlockNode context, IAbstractSyntaxTree lexerNode) { Contract.Requires(lexerNode.Type == Lexer.TokenType.ReturnNode); var point = context.Parser.GetSequencePoint(lexerNode); var returnType = context.GetMethod().MethodReturnType; ExpressionNode expression = null; if (lexerNode.Children.Count == 2) { expression = ExpressionNode.Parse(context, lexerNode.Children[1], returnType); } return(Create(context, expression, point)); }
public static ConditionBlockNode Parse(ContextNode context, IAbstractSyntaxTree lexerNode) { Contract.Requires(lexerNode.Type == TokenType.ConditionalSentence); Contract.Ensures(Contract.Result <ConditionBlockNode>() != null); var point = context.Parser.GetSequencePoint(lexerNode); var condition = ExpressionNode.Parse(context, lexerNode.Children[2]); var trueBlock = CodeBlockNode.Parse(context, lexerNode.Children[4]); CodeBlockNode falseBlock = null; if (lexerNode.Children.Count > 5) { falseBlock = CodeBlockNode.Parse(context, lexerNode.Children[6]); } return(Create(context, condition, trueBlock, falseBlock, point)); }
public CodeBlockNode AddStatement(IAbstractSyntaxTree lexerNode) { switch (lexerNode.Type) { case Lexer.TokenType.DeclarationNode: return(AddNode(SymbolDeclarationNode.Parse(this, lexerNode))); case Lexer.TokenType.Value: return(AddNode(ExpressionNode.Parse(this, lexerNode))); case Lexer.TokenType.ReturnNode: return(AddNode(ReturnNode.Parse(this, lexerNode))); default: ErrorCode.InvalidStructure.ReportAndThrow(Parser.GetSequencePoint(lexerNode), "Unexpected statement {0} in while parsing code block", lexerNode.Type); return(Utils.Utils.Fail <CodeBlockNode>()); } }
public static ExpressionNode Parse(ContextNode context, IAbstractSyntaxTree lexerNode) { Contract.Requires(lexerNode.Type == Lexer.TokenType.PrefixNode); Contract.Requires(lexerNode.Children[1].Type == Lexer.TokenType.CastOperator); var type = TypeNode.Parse(context, lexerNode.Children[1].Children[1]); var target = ExpressionNode.Parse(context, lexerNode.Children[0], type); if (!target.IsGettable) { ErrorCode.NotAnRValue.ReportAndThrow(target.SequencePoint, "The expression being cast must be gettable"); } if (!target.ExpressionReturnType.IsCastableTo(type)) { ErrorCode.IllegalCast.ReportAndThrow(context.Parser.GetSequencePoint(lexerNode), "Cannot cast expression of type {0} to {1}", target.ExpressionReturnType, type); } return(new CastNode(type, target, context.Parser.GetSequencePoint(lexerNode))); }
public void Initialize() { if (initializer == null) { if (TypeReference.IsAuto()) { ErrorCode.MissingInit.ReportAndThrow(SequencePoint, "Type inference requires initialization"); } return; } Initializer = ExpressionNode.Parse(this, initializer, TypeReference); if (!Initializer.IsGettable) { ErrorCode.NotAnRValue.ReportAndThrow(Initializer.SequencePoint, "Initializer must be a gettable expression"); } if (TypeReference.IsAuto()) { if (Initializer.ExpressionReturnType.IsTypeless()) { ErrorCode.InferrenceFromTypeless.ReportAndThrow(Initializer.SequencePoint, "Cannot infer type from a typeless expression"); } TypeReference = Initializer.ExpressionReturnType; DeclareField(); } else { if (!Initializer.ExpressionReturnType.IsAssignableTo(TypeReference)) { ErrorCode.TypeMismatch.ReportAndThrow(Initializer.SequencePoint, "Field of type {0} initialized with {1}", TypeReference, Initializer.ExpressionReturnType); } } if (Parser.ProjectParser.ShouldEmit) { GetClass().TypeEmitter.AddFieldInitializer(FieldDefinition, Initializer); } }
private static ExpressionNode ParsePrefix(ContextNode context, IAbstractSyntaxTree lexerNode) { var opType = lexerNode.Children[1].Type; if (opType == Lexer.TokenType.CastOperator) { return(CastNode.Parse(context, lexerNode)); } else { InternalUnaryOperatorType op; switch (opType) { case Lexer.TokenType.PlusPlus: op = InternalUnaryOperatorType.PreIncrement; break; case Lexer.TokenType.MinusMinus: op = InternalUnaryOperatorType.PreDecrement; break; case Lexer.TokenType.Not: op = InternalUnaryOperatorType.LogicalNot; break; case Lexer.TokenType.BitwiseComplement: op = InternalUnaryOperatorType.BinaryNot; break; case Lexer.TokenType.Minus: op = InternalUnaryOperatorType.Negation; break; default: ContractsHelper.AssertUnreachable("Unknown prefix op {0}", opType); return(null); //unreachable } return(Create(context, ExpressionNode.Parse(context, lexerNode.Children[0]), op)); } }
public static InitializerList Parse(ContextNode context, IAbstractSyntaxTree lexerNode) { Contract.Requires(lexerNode.Type == Lexer.TokenType.InitializerList); Contract.Ensures(Contract.Result <InitializerList>() != null); var point = context.Parser.GetSequencePoint(lexerNode); var instance = new InitializerList(point); var members = new List <ExpressionNode>(); foreach (var node in lexerNode.Children) { switch (node.Type) { case Lexer.TokenType.LeftCurlyBrace: case Lexer.TokenType.RightCurlyBrace: case Lexer.TokenType.Comma: break; case Lexer.TokenType.Value: members.Add(ExpressionNode.Parse(context, node)); break; } } var arrays = members.Select(m => m as ArrayCreationNode); //implicit = initializer list if (arrays.Any(a => a != null && a.IsImplicit)) { if (arrays.Any(a => a == null || !a.IsImplicit)) { ErrorCode.MisshapedMatrix.ReportAndThrow(point, "An initializer list can only contain another initializer list if all members are lists of the same dimmensions and types"); } var lists = arrays.Select(a => a.InitializerList); return(Create(context, lists, point)); } return(Create(context, members, point)); }
public static ForEachNode Parse(ContextNode context, IAbstractSyntaxTree lexerNode) { //For + LeftParenthesis + ForEachDeclaration + In + Value + RightParenthesis + CodeConstruct), Contract.Requires(lexerNode.Type == Lexer.TokenType.ForEachLoop); var instance = new ForEachNode(context, context.Parser.GetSequencePoint(lexerNode)); var collection = ExpressionNode.Parse(context, lexerNode.Children[4]); if (!collection.IsGettable) { ErrorCode.NotAnRValue.ReportAndThrow(collection.SequencePoint, "collection must be a gettable expression"); } if (collection.ExpressionReturnType.IsTypeless()) { ErrorCode.InvalidForEachCollection.ReportAndThrow(collection.SequencePoint, "collection must not be a typeless expression"); } var collectionElementType = collection.ExpressionReturnType.GetEnumerableElementType(); if (collectionElementType == null) { ErrorCode.InvalidForEachCollection.ReportAndThrow(collection.SequencePoint, "Cannot iterate over expression type {0}", collection.ExpressionReturnType); } var declaration = LoopVariableDeclaration.Parse(context, lexerNode.Children[2], collectionElementType); if (!collectionElementType.IsAssignableTo(declaration.Variable.VariableType)) { ErrorCode.TypeMismatch.ReportAndThrow(declaration.SequencePoint, "Cannot assign collection elements of type {0} to {1}", collectionElementType, declaration.Variable.VariableType); } instance.collection = collection; instance.variable = declaration; instance.body = CodeBlockNode.Parse(instance, lexerNode.Children[6]); return(instance); }
public static ExpressionNode Parse(ContextNode context, IAbstractSyntaxTree lexerNode) { Contract.Requires(lexerNode.Children[1].Type == Lexer.TokenType.IndexNode); Contract.Ensures(Contract.Result <ExpressionNode>() != null); var point = context.Parser.GetSequencePoint(lexerNode); var array = ExpressionNode.Parse(context, lexerNode.Children[0]); var indexer = lexerNode.Children[1]; if (IsEmptyIndexer(indexer)) { var type = array as TypeNode; if (type == null) { ErrorCode.TypeExpected.ReportAndThrow(point, "Type expected"); } int rank = CountEmptyIndexerDims(indexer); return(TypeNode.Create(AssemblyRegistry.GetArrayType(type.ParsedType, rank), context, point)); } var indices = ParseIndex(context, indexer); return(Create(context, array, indices, point)); }
private static ExpressionNode ParseSuffix(ContextNode context, IAbstractSyntaxTree lexerNode) { var opType = lexerNode.Children[1].Type; switch (opType) { case Lexer.TokenType.PlusPlus: return(Create(context, ExpressionNode.Parse(context, lexerNode.Children[0]), InternalUnaryOperatorType.PostIncrement)); case Lexer.TokenType.MinusMinus: return(Create(context, ExpressionNode.Parse(context, lexerNode.Children[0]), InternalUnaryOperatorType.PostDecrement)); case Lexer.TokenType.FunctionArgumentsList: return(MethodCallNode.Parse(context, lexerNode)); case Lexer.TokenType.IndexNode: return(ArrayAccessNode.Parse(context, lexerNode)); default: ContractsHelper.AssertUnreachable("Unknown postfix op {0}", opType); return(null); //unreachable } }
public static ParserNode Parse(ContextNode context, IAbstractSyntaxTree lexerNode) { Contract.Requires(context != null); CodeBlockNode init = null; ExpressionNode condition = null; CodeBlockNode increment = null; IAbstractSyntaxTree initNode = lexerNode.Children[2]; IAbstractSyntaxTree conditionNode = lexerNode.Children[4]; IAbstractSyntaxTree incrementNode = lexerNode.Children[6]; IAbstractSyntaxTree bodyNode = lexerNode.Children[8]; if (initNode.Type != TokenType.Empty) { init = CodeBlockNode.Create(context, context.Parser.GetSequencePoint(initNode)); init.AddStatement(initNode); //makes init scope encompass for scope context = init; } if (conditionNode.Type != TokenType.Empty) { condition = ExpressionNode.Parse(context, conditionNode, context.Parser.Bool); } if (incrementNode.Type != TokenType.Empty) { increment = CodeBlockNode.Create(context, context.Parser.GetSequencePoint(incrementNode)); increment.AddStatement(incrementNode); } var body = CodeBlockNode.Parse(context, bodyNode); return(ForLoopNode.Create(context, init, condition, increment, body, context.Parser.GetSequencePoint(lexerNode))); }
private static List <ExpressionNode> ParseArgList(ContextNode parent, IAbstractSyntaxTree lexerNode) { var args = new List <ExpressionNode>(); foreach (var node in lexerNode.Children) { switch (node.Type) { case Lexer.TokenType.LeftParenthesis: case Lexer.TokenType.RightParenthesis: case Lexer.TokenType.Comma: break; case Lexer.TokenType.Value: args.Add(ExpressionNode.Parse(parent, node)); break; default: ContractsHelper.AssertUnreachable("Unexpected node {0} in call", node.Type); break; } } return(args); }
public static ExpressionNode Parse(ContextNode context, IAbstractSyntaxTree lexerNode) { Contract.Requires( lexerNode.Type == Lexer.TokenType.InfixNode && lexerNode.Children[2].Type == Lexer.TokenType.Period || lexerNode.Type == Lexer.TokenType.FullSymbol || lexerNode.Type == Lexer.TokenType.Symbol); Contract.Ensures(Contract.Result <ExpressionNode>() != null); var instance = new DotOperatorNode(context); if (lexerNode.Type == Lexer.TokenType.Symbol) { instance.Append(new SymbolNode(lexerNode.Content, context, context.Parser.GetSequencePoint(lexerNode))); return(instance.builtNode); } foreach (var node in lexerNode.Children) { var point = context.Parser.GetSequencePoint(node); switch (node.Type) { case Lexer.TokenType.Period: break; case Lexer.TokenType.Symbol: instance.Append(new SymbolNode(node.Content, context, point)); break; default: instance.Append(ExpressionNode.Parse(context, node)); break; } } return(instance.builtNode); }
public static IReadOnlyList <ExpressionNode> ParseIndex(ContextNode context, IAbstractSyntaxTree lexerNode) { Contract.Requires(lexerNode.Type == Lexer.TokenType.IndexNode); Contract.Requires(!IsEmptyIndexer(lexerNode)); return(lexerNode.Children.AsEnumerable().Where(n => n.Type == Lexer.TokenType.Value).Select(n => ExpressionNode.Parse(context, n)).ToArray()); }