//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 void Visit(ReturnNode node)
{
if (node != null)
{
if (node.Operand != null)
{
node.Operand.Accept(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);
}
}
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);
}
