//TODO check if return type is correct from the function context private bool ParseReturnStatement(ref int at) { ReturnNode rNode = new ReturnNode(); //first Signature is return kw second should be return value or ';' at++; //now parse the return value ValueNode returnValue = ParseValueNode(ref at); if (returnValue == null) { return(false); } rNode.Value = new VarNode(returnValue); //now signature should be END at++; if (Ast[at].Signature != Signature.END) { return(false); } Tree.Current.AddChild(rNode); return(true); }
public override void VisitReturn(ReturnNode returnInstruction) { if (_problemRound && IsSqlGeneratingFunction(_currentMember)) { if (returnInstruction.Expression != null && IsStringIsh(returnInstruction.Expression.Type) && !IsConst(returnInstruction.Expression) && !_dirty.IsSafe(returnInstruction.Expression)) { if (!_params.Contains(returnInstruction.Expression.UniqueKey) || _dirty.MarkedDirtyInsideMethod(returnInstruction.Expression)) //if the return IS a param, then it's also got to be marked dirty inside the method (like if you pass a SQL builder in, append stuff to it, and then return it back out) { Problems.Add(new Problem(this.GetResolution(returnInstruction.Expression.GetName(), _dirty.GetDirtyDetails(returnInstruction.Expression, returnInstruction, true)), returnInstruction.SourceContext)); } } var currentMethod = _currentMember as Method; foreach (var p in currentMethod.Parameters.Where(w => !IsTypeSafe(w.Type))) { //if it's been marked dirty (aside from being a param), DANGER! if (_dirty.MarkedDirtyInsideMethod(p)) { Problems.Add(new Problem(this.GetResolution(p.GetName(), _dirty.GetDirtyDetails(p, returnInstruction, false)), returnInstruction.SourceContext)); } } } base.VisitReturn(returnInstruction); }
public static void ReturnNode() { var a = new ReturnNode(); var b = SerializationUtil.Reserialize(a); Assert.AreEqual(a, b); }
public void Accept(ReturnNode node) { node.VisitChildren(this); append("pop a"); append("pop {0}", BP); append("ret a"); }
public override void Visit(ReturnNode node) { base.Visit(node); string funcType = SymbolTable.GetCurrentFunctionType(); if (funcType is null) { throw new ReturnOutsideFunctionException(node, "Return was called outside function scope, which is not allowed"); } if (node.Inner is not null) { if (node.Inner.Type != funcType) { throw new InvalidOperationException( $"Function has return type: {funcType} but you are returning a {node.Inner.Type}.\n"); } node.Type = node.Inner.Type; } else if (funcType is not "void") { throw new InvalidOperationException( $"Function has return type: {funcType} but you are returning a void.\n"); } }
public override AstNode VisitReturnstmt(ALangParser.ReturnstmtContext context) { var returnNode = new ReturnNode(context); returnNode.Value = context.primaryExpression().Accept(this); return(returnNode); }
// TODO(AFL): Redo this such that r13 contains absolute address of result. // IDEA: put result in tempvar, pass on absolute address to it public void Visit(ReturnNode n) { var table = (FunctionSymbolTableEntry)n.SymTable; var children = n.GetChildren(); foreach (var child in children) { child.Accept(this); } var valueVar = children[0].TemporaryVariableName; var valueOffset = table.MemoryLayout.GetOffset(valueVar); var r13 = Registers.R13; var r15 = Registers.R15; // Set return value register to absolute address of return value _writer.WriteInstruction(Instructions.Sub, r13, r13, r13); _writer.WriteInstruction(Instructions.Add, r13, r13, FSPReg); _writer.WriteInstruction(Instructions.Addi, r13, r13, $"{valueOffset}"); // Jump to return address _writer.WriteInstruction(Instructions.Lw, r15, $"-4({FSPReg})"); _writer.WriteInstruction(Instructions.Jr, r15); }
public void Visit(ReturnNode node) { foreach (var subnode in node) { Visit((dynamic)subnode); } }
public XmlElement Visit(ReturnNode n) { var el = makeNode(n, "return"); addProperty(el, "value", n.Value); return(el); }
public Word Visit(ReturnNode returnNode) { if (returnNode.Expr == null) { return(new Return()); } var result = returnNode.Expr.Accept(this); PyObj pyObj; if (IsError(result)) { ErrorFactory.CantReturnError(returnNode.Expr, result); return(new Return(MyNull.GetInstance())); } if (IsMemoryBlock(result))//comentar ese if else si se hace la desereferencia en atomic expr. { pyObj = ((MemoryBlock)result).Value; } else { pyObj = (PyObj)result; } //pyObj = (PyObj)result;//Descomentar esta linea si se hace la desereferencia en atomic expr. return(new Return(pyObj)); }
public ReturnNode GetAccessTokenByPass(LoginInput input) { var user = dbContext.User.Where(u => u.Name == input.account && u.Pass == input.pass).FirstOrDefault(); if (user == null) { return(ReturnNode.ReturnError("登录失败")); } var tokenExpiration = TimeSpan.FromDays(14); ClaimsIdentity identity = new ClaimsIdentity(OAuthDefaults.AuthenticationType); identity.AddClaim(new Claim(ClaimTypes.Name, "zzzili")); identity.AddClaim(new Claim(ClaimTypes.Sid, "1")); var props = new AuthenticationProperties() { IssuedUtc = DateTime.UtcNow, ExpiresUtc = DateTime.UtcNow.Add(tokenExpiration), }; var ticket = new AuthenticationTicket(identity, props); var accessToken = Startup.OAuthOptions.AccessTokenFormat.Protect(ticket); JObject tokenResponse = new JObject( new JProperty("userName", "zzzili"), new JProperty("access_token", accessToken), new JProperty("token_type", "bearer"), new JProperty("expires_in", tokenExpiration.TotalSeconds.ToString()), new JProperty(".issued", ticket.Properties.IssuedUtc.ToString()), new JProperty(".expires", ticket.Properties.ExpiresUtc.ToString())); return(ReturnNode.ReturnSuccess(tokenResponse)); }
public bool VisitReturnNode(ReturnNode node, CompilationState state) { state.Write("return "); node.Value.AcceptVisitor(this, state); state.Write(";"); return(true); }
/// <summary> /// This method prints the returnNode and make an indentation /// Then accepts the value of the return /// Then it outdent /// </summary> /// <param name="returnNode">The node to print.</param> /// <returns>Returns null</returns> public override object Visit(ReturnNode returnNode) { Print("ReturnNode"); Indent++; returnNode.ReturnValue.Accept(this); Indent--; return(null); }
public override AbstractNode VisitReturnBlock([NotNull] GiraphParser.ReturnBlockContext context) { ReturnNode RNode = new ReturnNode(context.Start.Line, context.Start.Column); RNode.FuncName = _funcName; RNode.AdoptChildren(Visit(context.GetChild(1))); return(RNode); }
public override void Visit(ReturnNode node) { VisitChildren(node); _symbolTable.SetCurrentNode(node); AllType funcType = _symbolTable.RetrieveSymbol(node.FuncName, out bool FuncTypeCollection, false) ?? AllType.UNKNOWNTYPE; CheckAllowedCast(funcType, node.Children[0].Type_enum); }
/// <summary> /// This node visits a return node /// It accetps the return value and write "return, the value and add a semicolom /// </summary> /// <param name="returnNode"></param> /// <returns></returns> public override object Visit(ReturnNode returnNode) { string ret = "return "; ret += returnNode.ReturnValue.Accept(this); ret += ";"; return(ret); }
public void Visit(ReturnNode returnNode) { if (returnNode.Result != null) { returnNode.Result.Parent = returnNode; returnNode.Result.Accept(this); } }
private ReturnNode ReadReturn(ContextualType responseType, AssemblyNode assembly, XElement?documentationNode, ActionNode actionNode) { var returnNode = new ReturnNode(ReadType(responseType, assembly, new Type[0], actionNode)) { Documentation = documentation.ParseDocumentation(documentationNode), }; return(returnNode); }
public void Visit(ReturnNode n) { var children = n.GetChildren(); foreach (var child in children) { child.Accept(this); } }
public void Visit(ReturnNode n) { PrintDOTIDLabel(n); PrintDOTParentChild(n); foreach (var child in n.GetChildren()) { child.Accept(this); } }
public ReturnBuilder(ReturnNode returnNode) { node = returnNode; DotDefinition = new List <IDotElement>(); CreateNode(); CreateEdgeToNextSibling(); CreateSpecialEdge(); }
/// <summary> /// Parses a return statement (_returnSyntaxRegex) /// </summary> /// <param name="tokenCount"></param> private void ParseReturn(int tokenCount) { if (tokenCount != 2 && tokenCount != 3) { throw new ParsingException("[BUG] Return parsing requires either two or three tokens."); } var tokens = _remainingTokens.GetRange(0, tokenCount); _remainingTokens.RemoveRange(0, tokenCount); if (_locationStack.Peek() == Location.Program || _currentNode == Program) { throw new ParsingException("[BUG] Return should not be reachable in a program location."); } ReturnNode returnNode = null; int index = 0; var returnKeyword = (ReturnKeywordToken)tokens[index++]; if (tokenCount == 2) { // returning, no value returnNode = new ReturnNode(_currentNode); } else if (tokenCount == 3) { var returnValueToken = tokens[index++]; if (returnValueToken is IntegerLiteralToken) { // returning an int returnNode = new ReturnNode(_currentNode, new IntNode(null, (returnValueToken as IntegerLiteralToken).Value)); } else if (returnValueToken is UnsignedIntegerLiteralToken) { // returning an uint returnNode = new ReturnNode(_currentNode, new UIntNode(null, (returnValueToken as UnsignedIntegerLiteralToken).Value)); } else if (returnValueToken is IdentifierToken) { // returning an identifier returnNode = new ReturnNode(_currentNode, new IdentifierNode(null, (returnValueToken as IdentifierToken).Contents)); } else { throw new ParsingException("[BUG] Return token was passed with unexpected value token."); } } if (returnNode == null) { throw new ParsingException("[BUG] Return node was not generated."); } _currentNode.AddChild(returnNode); }
public AstNode VisitReturn(ReturnNode n) { Append("return"); if (n.Expression != null) { Append(" "); Visit(n.Expression); } return(n); }
public override void VisitReturnNode(ReturnNode node) { node.Expression.Visit(this); var @return = ReturnStatement(expressions.Pop()); @return = GetNodeWithAnnotation(@return, node.Location) as ReturnStatementSyntax; AddStatementToCurrentBlock(@return); }
public override void Visit(ReturnNode node) { if (node.Inner is null) { Emit("return;\n"); } Emit("return "); Visit(node.Inner); Emit(";\n"); }
private TypeInfo Visit(ReturnNode node, MethodBuilder builder, CodegenContext context) { builder.ClearStack(); var res = Visit(node.Expression, builder, context); builder.Ret(); return(res); }
private ReturnNode ReadReturn(Type responseType, AssemblyNode assembly, XElement documentationNode, ActionNode actionNode) { var returnNode = new ReturnNode { Documentation = documentation.ParseDocumentation(documentationNode), Type = ReadType(responseType, assembly, new Type[0], actionNode) }; return(returnNode); }
public virtual void Visit(ReturnNode node) { if (node != null) { if (node.Operand != null) { node.Operand.Accept(this); } } }
public override bool Walk(ReturnNode node) { var fnScope = CurrentFunction; if (node.Operand != null && fnScope != null) { var lookupRes = _eval.Evaluate(node.Operand); fnScope.AddReturnTypes(node, _unit, lookupRes); } return(false); }
public void Visit(ReturnNode node) { source.Append("return"); var val = node.GetValue(); if (val != null) { source.Append(" "); val.Visit(this); } }
public virtual bool Walk(ReturnNode node) { return true; }
public virtual void PostWalk(ReturnNode node) { }
private void ParseReturn(Node subtree) { //Return expr delim ReturnNode node = new ReturnNode(subtree); tokens.ConsumeToken(TokenType.Return); if(tokens.CurrentToken != TokenType.Delim) ParseExpression(node); }
private static void GenerateReturn(ReturnNode node, DataContext data) { StartLine(data, "return "); GenerateExpression(node.ValueExpression, data); EndLine(data, ";"); }
public virtual void Visit(ReturnNode node) { if (node != null) { AcceptChildren(node); } }