} // NT_DeleteStat
private static void NT_ReturnStat(out Stat s)
{
Expr e = null;
SrcPos sp = null;
s = null;
for (;;)
{
switch (Syn.Interpret())
{
case 0:
return;
case 1: // SEM
sp = new SrcPos();
break;
case 2:
NT_Expr(out e);
break;
case 3: // SEM
s = new ReturnStat(sp, curFuncSy, e);
break;
} // switch
} // for
} // NT_ReturnStat
public override void Visit(ReturnStat returnStat)
{
this.LoadAndStore(returnStat.ReturnValueExpression, 4, returnStat.ReturnValueExpression.NodeMemorySize, $"Returning {returnStat.ReturnValueExpression}");
InstructionStream.Add(new string[] {
"lw r15, 0(r14)",
"jr r15"
}, "Load the return address, and return.");
}
public override void Visit(ReturnStat returnStat)
{
returnStat.SemanticalType = ((Node)returnStat.ReturnValueExpression).SemanticalType;
if (this._lastFunctionRequiredReturnType == "__MAIN__")
{
ErrorManager.Add("Cannot return in main.", returnStat.Location);
return;
}
if (this._lastFunctionRequiredReturnType != returnStat.SemanticalType)
{
ErrorManager.Add($"Must return a value of type {this._lastFunctionRequiredReturnType}. Cannot convert {returnStat.SemanticalType} to it.", returnStat.Location);
}
}
ReturnStat ParseReturnStat(ParseTreeNode node)
{
if (node.Term.Name == "ReturnStat")
{
ReturnStat ret = new ReturnStat();
var child = node.ChildNodes[1];
while (child.ChildNodes.Count > 0)
{
child = child.ChildNodes[0];
ret.Expressions.Add(ParseExpression(child.ChildNodes[0]));
child = child.ChildNodes[1];
}
return(ret);
}
throw new Exception("Invalid ReturnStat node");
}
public bool Match(XMLLuaSearchReturnStatement req, ReturnStat real)
{
Logger.Debug($"return_statement");
if (req.Expressions.Count != real.Expressions.Count)
{
return(false);
}
for (var i = 0; i < req.Expressions.Count; i++)
{
if (!Match(req.Expressions[i], real.Expressions[i]))
{
return(false);
}
}
SetSelectionIfSelected(real.Span, req);
return(true);
}
private object NoASS()
{
string first = "if for get put return";
this.SkipErrors(first);
var lookaheadToken = this.TokenStream.Peek();
string lookahead = lookaheadToken.AToCCFormat();
if ("if".HasToken(lookahead))
{
this.ApplyDerivation("noASS -> 'if' '(' expr ')' 'then' statBlock 'else' statBlock ';'");
var ifStatement = new IfStat(lookaheadToken.SourceLocation);
Match("if");
Match("(");
var expr = Expr();
Match(")");
Match("then");
var trueBlock = StatBlock();
Match("else");
var elseBlock = StatBlock();
Match(";");
ifStatement.Condition = expr;
ifStatement.TrueBlock = trueBlock;
ifStatement.ElseBlock = elseBlock;
return(ifStatement);
}
if ("for".HasToken(lookahead))
{
this.ApplyDerivation("noASS -> 'for' '(' type 'id' '=' expr ';' relExpr ';' assignStat ')' statBlock ';'");
var forStat = new ForStat(lookaheadToken.SourceLocation);
Match("for");
Match("(");
string type = Type();
var idLocation = this.TokenStream.Peek().SourceLocation;
string id = Match("id");
Match("=");
var initExpr = Expr();
Match(";");
var condition = RelExpr();
Match(";");
var assignStat = AssignStat();
Match(")");
var statBlock = StatBlock();
Match(";");
forStat.Type = type;
forStat.Id = id;
forStat.Initialization = initExpr;
forStat.Condition = condition;
forStat.Update = assignStat;
forStat.LoopBlock = statBlock;
forStat.IdLocation = idLocation;
return(forStat);
}
if ("get".HasToken(lookahead))
{
this.ApplyDerivation("noASS -> 'get' '(' variable ')' ';'");
var getStatement = new GetStat(lookaheadToken.SourceLocation);
Match("get");
Match("(");
var variable = Variable();
Match(")");
Match(";");
getStatement.Variable = variable;
return(getStatement);
}
if ("put".HasToken(lookahead))
{
this.ApplyDerivation("noASS -> 'put' '(' expr ')' ';'");
var putStatement = new PutStat(lookaheadToken.SourceLocation);
Match("put");
Match("(");
var expr = Expr();
Match(")");
Match(";");
putStatement.Expression = expr;
return(putStatement);
}
if ("return".HasToken(lookahead))
{
this.ApplyDerivation("noASS -> 'return' '(' expr ')' ';'");
var returnStatement = new ReturnStat(lookaheadToken.SourceLocation);
Match("return");
Match("(");
var expr = Expr();
Match(")");
Match(";");
returnStatement.ReturnValueExpression = expr;
return(returnStatement);
}
return(null);
}
internal static LuaArguments EvalBlock(Block Block, LuaContext Context, out LuaReturnStatus returned)
{
returned.broke = false;
returned.returned = false;
LuaArguments obj = new LuaObject[] { LuaObject.Nil };
foreach (IStatement stat in Block.Statements)
{
if (stat is Assignment)
{
Assignment assign = stat as Assignment;
LuaArguments values = null;
foreach (IExpression expr in assign.Expressions)
{
if (values == null)
{
values = EvalExpression(expr, Context);
}
else
{
values.Concat(EvalExpression(expr, Context));
}
}
for (int i = 0; i < assign.Variables.Count; i++)
{
SetAssignable(assign.Variables[i], values[i], Context);
}
}
else if (stat is LocalAssignment)
{
LocalAssignment assign = stat as LocalAssignment;
LuaArguments values = null;
foreach (IExpression expr in assign.Values)
{
if (values == null)
{
values = EvalExpression(expr, Context);
}
else
{
values.Concat(EvalExpression(expr, Context));
}
}
for (int i = 0; i < assign.Names.Count; i++)
{
Context.SetLocal(assign.Names[i], values[i]);
}
}
else if (stat is ReturnStat)
{
ReturnStat ret = stat as ReturnStat;
returned.returned = true;
List <LuaObject> values = new List <LuaObject>();
int i = 0;
foreach (IExpression expr in ret.Expressions)
{
if (i == ret.Expressions.Count - 1)
{
values.AddRange(EvalExpression(expr, Context));
}
else
{
values.Add(EvalExpression(expr, Context)[0]);
}
i++;
}
return(values.ToArray());
}
else if (stat is FunctionCall)
{
FunctionCall call = stat as FunctionCall;
EvalFunctionCall(call, Context);
}
else if (stat is Block)
{
Block block = stat as Block;
LuaContext ctx = new LuaContext(Context);
obj = EvalBlock(block, ctx, out returned);
if (returned.returned)
{
return(obj);
}
}
else if (stat is IfStat)
{
obj = EvalIf(stat as IfStat, Context, out returned);
if (returned.returned)
{
return(obj);
}
}
else if (stat is WhileStat)
{
obj = EvalWhile(stat as WhileStat, Context, out returned);
if (returned.returned)
{
return(obj);
}
}
else if (stat is RepeatStat)
{
obj = EvalRepeat(stat as RepeatStat, Context, out returned);
if (returned.returned)
{
return(obj);
}
}
else if (stat is BreakStat)
{
returned.returned = false;
returned.broke = true;
return(Lua.Return(LuaObject.Nil));
}
else if (stat is NumericFor)
{
obj = EvalNumericFor(stat as NumericFor, Context, out returned);
if (returned.returned)
{
return(obj);
}
}
else
{
obj = EvalGenericFor(stat as GenericFor, Context, out returned);
if (returned.returned)
{
return(obj);
}
}
}
return(obj);
}
} // DumpSymTab
// === generate source text from symbol table and AST ===
public static void WriteStat(Stat stat)
{
switch (stat.kind)
{
case Stat.Kind.emptyStatKind:
genMcpp.WriteLine(Indent() + ";");
break;
case Stat.Kind.blockStatKind:
BlockStat b_s = (BlockStat)stat;
genMcpp.WriteLine(Indent() + "{");
IncIndent();
WriteStatList(b_s.statList);
DecIndent();
genMcpp.WriteLine(Indent() + "}");
break;
case Stat.Kind.incStatKind:
IncStat i_s = (IncStat)stat;
genMcpp.WriteLine(Indent() + i_s.vo.sy + "++;");
break;
case Stat.Kind.decStatKind:
DecStat d_s = (DecStat)stat;
genMcpp.WriteLine(Indent() + d_s.vo.sy + "--;");
break;
case Stat.Kind.assignStatKind:
AssignStat a_s = (AssignStat)stat;
genMcpp.WriteLine(Indent() + a_s.lhs + " = " + a_s.rhs + ";");
break;
case Stat.Kind.callStatKind:
CallStat c_s = (CallStat)stat;
genMcpp.WriteLine(Indent() + c_s.func + "(" + c_s.apl + ");");
break;
case Stat.Kind.ifStatKind:
IfStat if_s = (IfStat)stat;
genMcpp.WriteLine(Indent() + "if (" + if_s.cond + ")");
IncIndent();
WriteStatList(if_s.thenStat);
DecIndent();
if (if_s.elseStat != null)
{
genMcpp.WriteLine(Indent() + "else ");
IncIndent();
WriteStatList(if_s.elseStat);
DecIndent();
} // if
break;
case Stat.Kind.whileStatKind:
WhileStat w_s = (WhileStat)stat;
genMcpp.WriteLine(Indent() + "while (" + w_s.cond + ")");
IncIndent();
WriteStatList(w_s.body);
DecIndent();
break;
case Stat.Kind.breakStatKind:
genMcpp.WriteLine(Indent() + "break;");
break;
case Stat.Kind.inputStatKind:
InputStat in_s = (InputStat)stat;
genMcpp.WriteLine(Indent() + "cin >> " + in_s.vo.sy + ";");
break;
case Stat.Kind.outputStatKind:
OutputStat out_s = (OutputStat)stat;
genMcpp.Write(Indent() + "cout");
foreach (Object o in out_s.values)
{
genMcpp.Write(" << ");
if (o is Expr)
{
genMcpp.Write(o);
}
else if (o is String)
{
String s = o as String;
if (s == "\n")
{
genMcpp.Write("endl");
}
else
{
genMcpp.Write('"' + s + '"');
}
}
else
{
throw new Exception("invalid value");
}
} // foreach
genMcpp.WriteLine(";");
break;
case Stat.Kind.deleteStatKind:
DeleteStat del_s = (DeleteStat)stat;
genMcpp.WriteLine(Indent() + "delete[] " +
NameList.NameOf(del_s.vo.sy.spix) + ";");
break;
case Stat.Kind.returnStatKind:
ReturnStat r_s = (ReturnStat)stat;
genMcpp.Write(Indent() + "return");
if (r_s.e != null)
{
genMcpp.Write(" " + r_s.e);
}
genMcpp.WriteLine(";");
break;
default:
throw new Exception("invalid statement kind");
} // switch
} // WriteStatList
public virtual void Visit(ReturnStat returnStat)
{
}
public async Task ExecuteReturnStat(ReturnStat stat, LuaState state, CancellationToken token = default)
{
state.FunctionState.SetResult(new LuaArguments(await _engine.EvaluateExpression(stat.Expressions, state, token)));
}
