public void ParseMethodBody() { TypeBodyParser parser = new TypeBodyParser(); const string input = @" int GetValue(int someValue, System.Collections.Generic.Dictionary<int, UnityEngine.Vector3> dict) { var f; int localVar = 4; string str; return someValue; } "; TypeBodyNode astNode = parser.Parse(input, "", 0); Assert.AreEqual(1, astNode.nodes.size); MethodNode methodNode = (MethodNode)astNode.nodes[0]; Assert.AreEqual(4, methodNode.body.statements.size); Assert.IsInstanceOf <LocalVariableNode>(methodNode.body.statements[0]); Assert.IsInstanceOf <LocalVariableNode>(methodNode.body.statements[1]); Assert.IsInstanceOf <LocalVariableNode>(methodNode.body.statements[2]); Assert.IsInstanceOf <ReturnStatementNode>(methodNode.body.statements[3]); LocalVariableNode f = (LocalVariableNode)methodNode.body.statements[0]; LocalVariableNode localVar = (LocalVariableNode)methodNode.body.statements[1]; LocalVariableNode str = (LocalVariableNode)methodNode.body.statements[2]; ReturnStatementNode retn = (ReturnStatementNode)methodNode.body.statements[3]; Assert.AreEqual("f", f.name); Assert.AreEqual(default, f.typeLookup.typeName);
public override dynamic Visit(ReturnStatementNode node) { node.Expression = Replace(node.Expression); node.Expression.Accept(this); return(null); }
public override void Visit(ReturnStatementNode node) { Console.WriteLine(this.indentation + "return ---- Statement ----"); indentation = indentation + " "; node.expression.Accept(this); indentation = indentation.Substring(0, indentation.Length - 3); }
private Statement BindReturnStatement(ReturnStatementNode syntax) { if (Function == null) { diagnostics.ReportInvalidReturn(syntax.ReturnToken); return(new InvalidStatement()); } var expression = syntax.Expression == null ? null : BindExpression(syntax.Expression); var expressionType = expression?.Type ?? BuiltinTypes.Void; if (expressionType != Function.Type) { if (expression == null) { diagnostics.ReportInconsistentReturnType(syntax.ReturnToken, Function, Function.Type, expressionType); } else { expression = BindConversion(syntax.Expression, expression, Function.Type, noDiagnostics: true); if (expression is InvalidExpression) { diagnostics.ReportInconsistentReturnType(syntax.ReturnToken, Function, Function.Type, expressionType); } } } return(new ReturnStatement(Scope, expression)); }
public void genReturnStatement(ReturnStatementNode stmt) { if (stmt.retval != null) { genExpression(stmt.retval); assembly.addLine("pop eax"); //eax <--- return val } }
protected override Boolean handleReturn(ReturnStatementNode returnStatement, HashSet <StatementNode> visited) { if (returnStatement.Value != null) { expressionChecker.handleExpression(returnStatement.Value, null, true); } return(Boolean.FALSE); }
protected override Void handleReturn(ReturnStatementNode returnStatement, Set <TypeInfo> dependencies) { if (returnStatement.Value != null) { expressionHandler.handleExpression(returnStatement.Value, dependencies, true); } return(null); }
private ReturnStatementNode BuildReturnStatementNode(LexSpan lex) { var res = new ReturnStatementNode(); res.AddNode(new ReturnToken(lex)); return(res); }
/// <summary> /// 返回语句 /// </summary> /// <param name="node"></param> public void Visit(ReturnStatementNode node) { var builder = new StringBuilder(); builder.AppendLine("返回语句:"); Console.WriteLine(builder.ToString()); Visit((Object)node.ValueExpression); }
/// <summary> /// Visits the Return Statement node. /// </summary> /// <param name="node">The node to visit.</param> public virtual TResult VisitReturnStatement(ReturnStatementNode node) { if (node.Expression != null) { node.Expression.Accept(this); } return(default(TResult)); // The default naive implementation }
private ReturnStatementNode BuildReturnStatementNode(LexSpan lex, SyntaxNodeOrToken node) { var res = new ReturnStatementNode(); res.AddNode(new ReturnToken(lex)); res.AddNode(node); return(res); }
public override dynamic Visit(ReturnStatementNode node) { CurrentBlock.Child = null; CurrentBlock.AddStatement(node); CurrentBlock.Returned = true; return(null); }
public Node ReturnStatement() { var return_node = new ReturnStatementNode() { AnchorToken = Expect(TokenCategory.RETURN) }; return_node.Add(Optional(firstOfExpression, Expression)); Expect(TokenCategory.SEMICOLON); return(return_node); }
public override List <Expression> VisitReturnStatement(ReturnStatementNode node) { if (this.HasReturned) { throw (new SemanticCodeGenerationException(CodeGenerationErrors.CodeAfterReturnStatement)).SetErrorLocation(node); } this.HasReturned = true; this.Expressions.Add(this.Context.Return(node.Expression.Accept(new ExpressionVisitor(this)))); return(this.Expressions); }
private void Write(ReturnStatementNode stmt, bool notlambda = true) { if (notlambda) { Fill(); _code.Append("return "); } if (stmt.Children.Any()) { Write(stmt.Children[0]); } }
private void EmitReturnStatement(ReturnStatementNode returnStatement) { output.Append("return"); if (returnStatement.ReturnExpressionNode != null) { output.Append(' '); EmitExpression(returnStatement.ReturnExpressionNode); } output.Append(';'); }
public virtual Value evaluate(Context cx, ReturnStatementNode node) { output("<ReturnStatementNode position=\"" + node.pos() + "\">"); indent_Renamed_Field++; if (node.expr != null) { node.expr.evaluate(cx, this); } indent_Renamed_Field--; output("</ReturnStatementNode>"); return(null); }
protected override List <AssemblyElement> VisitReturnStatement(ReturnStatementNode node) { List <AssemblyElement> instructions = new List <AssemblyElement>(); if (node.ExpressionNode != null) { instructions.AddRange(Visit(node.ExpressionNode)); } instructions.Add(new Ret()); return(instructions); }
private static PythonNode Wrap(ReturnStatement stmt, PythonNode parent) { var result = new ReturnStatementNode(stmt) { Parent = parent }; if (stmt.Expression != null) { result.AddChild(Wrap(stmt.Expression, result)); } return(result); }
public void Visit(ReturnStatementNode node) { Cell cell = sender.GetCurrentCell(); Symbol state = Stbl.st.Retrieve(node.Identifier.Label); if (state is StateSymbol s) { sender.SetCell(cell, s.Copy()); } else { throw new TheLanguageErrorException($"Return statement. Unexpected type { state } expected State"); } sender.ReturnStatementHasBeenHit = true; }
public void Visit(ReturnStatementNode node) { bool returnsSomething = node.Count() != 0; string procedureName = currentScope; Type returnType = procedureTable[procedureName].type; if (returnsSomething) { Visit((dynamic)node[0]); } else { string defaultValue = GetTypeDefaultCilValue(returnType); builder.AppendLine($"\t\t{defaultValue}"); } builder.AppendLine("\t\tret"); }
public Type Visit(ReturnStatementNode node) { if (currentScope == "") { throw new SemanticError("Unexpected return statement", node.AnchorToken); } Type type = node.Count() == 0 ? Type.VOID : Visit((dynamic)node[0]); var procedureType = procedureTable[currentScope].type; if (!procedureType.CompatibleWith(type)) { throw new SemanticError($"Invalid return type {type} for procedure of type {procedureType}", node.AnchorToken); } return(type); }
protected override Void handleReturn(ReturnStatementNode returnStatement, Void source) { var returnType = context.CodeValidationContext.CurrentMethod.ReturnType; if (returnType == null) { if (returnStatement.Value != null) { this.ExpressionValidator.handleExpression(returnStatement.Value, null, true); var rinfo = returnStatement.Value.getUserData(typeof(ExpressionInfo)); if (rinfo == null) { context.CodeValidationContext.LambdaReturnTypes.add(null); } else { context.CodeValidationContext.LambdaReturnTypes.add(ValidationHelper.getType(context, returnStatement.Value)); } } } else if (returnType == context.TypeSystem.VoidType) { if (returnStatement.Value != null) { context.addError(CompileErrorId.ReturnVoid, returnStatement); } } else if (returnStatement.Value == null) { context.addError(CompileErrorId.ReturnNotVoid, returnStatement); } else { this.ExpressionValidator.handleExpression(returnStatement.Value, returnType, true); ValidationHelper.setBoxing(context, returnType, returnStatement.Value); if (!ValidationHelper.isAssignable(context, returnType, returnStatement.Value)) { var vinfo = returnStatement.Value.getUserData(typeof(ExpressionInfo)); context.addError(CompileErrorId.NoImplicitConversion, returnStatement.Value, BytecodeHelper.getDisplayName((vinfo == null) ? null : vinfo.Type), BytecodeHelper.getDisplayName(returnType)); } } return(null); }
protected virtual ReturnStatementNode ParseReturnStatement(IStatementParentNode parent, ReturnOperatorToken returnOperator) { // PARSE: <return statement> ::= returnOperator <expression> // Also: <statements> ::= <return statement> [’.’] ReturnStatementNode result = new ReturnStatementNode(parent, returnOperator); Token token = this.GetNextTokenxx(Preference.NegativeSign); 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; token = this.GetNextTokenxx(Preference.Default); } result.SetContents(expression, period); // Returns statement ... should have reached the end of the statement. this.ResidueToken = token; if (token is EofToken) { return(result); // OK } else if (Parser.IsBlockEndDelimiter(token)) { return(result); // OK; } else if (Parser.IsStatementDelimiter(token)) { this.ReportParserError(result, SemanticErrors.MissingStatement, token); } else { this.ReportParserError(result, SemanticErrors.CodeAfterReturnStatement, token); } return(result); }
/// <summary> /// Visits the Return Statement node. /// </summary> /// <param name="node">The node to visit.</param> public override bool VisitReturnStatement(ReturnStatementNode node) { if (node.Parent == null) { return(false); } if (node.Token == null) { return(false); } if ((node.Expression == null) || !node.Expression.Accept(this)) { return(false); } return(true); }
public override void Visit(ReturnStatementNode node) { try { node.expression.Accept(this); if (node.expression.ExpressionType.GetType() == typeof(ClassType) && !IsClassCompatible((ClassType)node.expression.ExpressionType, (ClassType)MethodBeingVisited.ReturnType)) { throw new Exception("Return Expression should have compatible Type as in the Method Declaration!"); } else if (!AreTypeCompatible(node.expression.ExpressionType.GetType(), MethodBeingVisited.ReturnType.GetType())) { throw new Exception("Return Expression should have compatible Type as in the Method Declaration!"); } } catch (Exception e) { Analysis.LogSemanticError(e.Message, node.lineNumber); } }
public override dynamic Visit(ReturnStatementNode node) { var currentNode = (IdNode)FunctionStack.Peek(); var id = currentNode.Id.Accept(this); node.Expression.Accept(this); var type = currentNode.Type; var expressionType = node.Expression.Type.PrimitiveType; var expressionSubType = node.Expression.Type is ArrayTypeNode eat ? eat.SubType : PrimitiveType.Void; if (!(node.Expression is NoOpNode) && currentNode.Type.PrimitiveType == PrimitiveType.Void && expressionType != PrimitiveType.Void) { Context.ErrorService.Add( ErrorType.Unknown, node.Expression.Token ?? currentNode.Id.Token, $"cannot return a value from procedure {id}" ); } //throw new Exception($"cannot return a value from procedure {id}"); if (node.Expression is NoOpNode && expressionType != PrimitiveType.Void && currentNode.Type.PrimitiveType != PrimitiveType.Void) { Context.ErrorService.Add( ErrorType.Unknown, node.Expression.Token, $"must return value of {type} from function {id}" ); } // throw new Exception($"must return value of {type} from function {id}"); if (type is ArrayTypeNode at) { if (expressionType != PrimitiveType.Array) { Context.ErrorService.Add( ErrorType.Unknown, node.Expression.Token, $"must return array of type {at.SubType} from function{id}, tried to return {expressionType}" ); //throw new Exception( // $"must return array of type {at.SubType} from function{id}, tried to return {expressionType}"); } if (at.SubType != expressionSubType) { Context.ErrorService.Add( ErrorType.Unknown, node.Expression.Token, $"must return array of type {at.SubType} from function{id}, tried to return array of {expressionSubType}" ); //throw new Exception( // $"must return array of type {at.SubType} from function{id}, tried to return array of {expressionSubType}"); } } else { if (expressionType != type.PrimitiveType && currentNode.Type.PrimitiveType != PrimitiveType.Void) { Context.ErrorService.Add( ErrorType.Unknown, node.Expression.Token ?? currentNode.Id.Token, $"must return value of type {type.PrimitiveType} from function {id}, tried to return {expressionType}" ); } //throw new Exception( // $"must return value of type {type.PrimitiveType} from function{id}, tried to return {expressionType}"); } return(null); }
static bool CheckReturnStatement(ReturnStatementNode node, List <string> validVariables, List <string> validMethods, List <string> variableTypes, ClassDeclarationNode currentClass, string targetReturnType) { return(CheckExpression(node.expression, validVariables, validMethods, variableTypes, currentClass, targetReturnType)); }
public override void Visit(ReturnStatementNode node) { node.expression.Accept(this); }
/// <summary> /// Visits the Return Statement node. /// </summary> /// <param name="node">The node to visit.</param> public virtual TResult VisitReturnStatement(ReturnStatementNode node) { throw new NotImplementedException(); }
public virtual Value evaluate(Context cx, ReturnStatementNode node) { output("<ReturnStatementNode position=\"" + node.pos() + "\">"); indent_Renamed_Field++; if (node.expr != null) { node.expr.evaluate(cx, this); } indent_Renamed_Field--; output("</ReturnStatementNode>"); return null; }