public void Visit(ReturnStmt returnStmt, object[] args)
{
RightValue returnValue = exprProcessor.Eval(returnStmt.Expression);
int id;
do
{
id = kernel.RuntimeData.InstructionStack.Pop();
if (id == InstructionStack.CLOSE_LOCAL_SCOPE_FLAG)
{
kernel.RuntimeData.ScopeStack.Close();
}
else if (id == InstructionStack.CLOSE_FORMAL_SCOPE_FLAG)
{
kernel.RuntimeData.ScopeStack.Close();
}
else if (id == InstructionStack.CALL_FLAG)
{
CallStackElement elem = kernel.RuntimeData.CallStack.Pop();
if (elem.ReturnDest != null)
{
kernel.RuntimeData.ScopeStack.SetValue(elem.ReturnDest, returnValue);
}
}
} while (id != InstructionStack.CALL_FLAG);
kernel.Next();
}
public LuaValue Execute(out bool isBreak)
{
foreach (Statement statement in Statements)
{
ReturnStmt returnStmt = statement as ReturnStmt;
if (returnStmt != null)
{
isBreak = false;
return(LuaMultiValue.WrapLuaValues(returnStmt.ExprList.ConvertAll(expr => expr.Evaluate(this.Enviroment)).ToArray()));
}
else if (statement is BreakStmt)
{
isBreak = true;
return(null);
}
else
{
var returnValue = statement.Execute(this.Enviroment, out isBreak);
if (returnValue != null || isBreak == true)
{
return(returnValue);
}
}
}
isBreak = false;
return(null);
}
public object Visit(ReturnStmt stmt)
{
DataType type2 = stmt.Expression.Accept(this);
ApplyCastingRuleIfNeeded(new Pos(0, 0), type2, _currentFunctionType, stmt.Expression);
return(null);
}
public void Visit(ReturnStmt returnStmt, object[] args)
{
string expr = reader.ReadString();
Expr.Expression result = exprParser.ParseExpr(expr,
new Location(file, reader.LineNumber, reader.LinePosition).Offset(8));
returnStmt.Expression = result;
}
public void AcceptMethodCallsVisitOnVisitorWithThis()
{
var target = new ReturnStmt(new ConstantExpr(8484));
var visitor = new Mock<IExpressionVisitor<string, int>>();
target.Accept(visitor.Object, 0);
visitor.Verify(x => x.Visit(target, 0), Times.Once);
}
public void AcceptMethodCallsVisitOnVisitorWithThis()
{
var target = new ReturnStmt(new ConstantExpr(8484));
var visitor = new Mock <IExpressionVisitor <string, int> >();
target.Accept(visitor.Object, 0);
visitor.Verify(x => x.Visit(target, 0), Times.Once);
}
public void AcceptMethodCallsOnlyVisitOnVisitorWithThisAndNoOtherVisitMethods()
{
var target = new ReturnStmt(new ConstantExpr(1357));
// throw exception is any other methods called other than the ReturnStmt overload.
var visitor = new Mock<IExpressionVisitor<string, int>>(MockBehavior.Strict);
visitor.Setup(x => x.Visit(target, 0)).Returns("");
target.Accept(visitor.Object, 0);
}
public virtual bool VisitReturnStmt(ReturnStmt stmt)
{
if (!VisitStmt(stmt))
{
return(false);
}
return(true);
}
public void AcceptMethodCallsOnlyVisitOnVisitorWithThisAndNoOtherVisitMethods()
{
var target = new ReturnStmt(new ConstantExpr(1357));
// throw exception is any other methods called other than the ReturnStmt overload.
var visitor = new Mock <IExpressionVisitor <string, int> >(MockBehavior.Strict);
visitor.Setup(x => x.Visit(target, 0)).Returns("");
target.Accept(visitor.Object, 0);
}
public object Visit(ReturnStmt stmt)
{
LLVMValueRef exprValue = stmt.Expression.Accept(this);
exprValue = CastIfNeeded(exprValue, stmt.Expression.Cast);
LLVM.BuildRet(_builder, exprValue);
return(null);
}
public void visit_return(ReturnStmt return_stmt)
{
object value = null;
if (return_stmt.value != null)
{
value = evaluate(return_stmt.value);
}
// Throw a new return exception for the loop/function to catch
throw new ReturnException(value);
}
public void TestReturnInFunctionWithoutValue()
{
var program = new ProgramNode(0, 0);
program.Block = new BlockStmt(0, 0);
var returnStmt = new ReturnStmt(0, 0);
var funcBlock = new BlockStmt(0, 0);
funcBlock.Statements.Add(returnStmt);
program.Block.Statements.Add(CreateFunction("func", funcBlock));
AssertErrorContains(program, "Return statement can't be empty in a function");
}
public void TestCorrectReturnInFuction()
{
var program = new ProgramNode(0, 0);
program.Block = new BlockStmt(0, 0);
var funcBlock = new BlockStmt(0, 0);
var returnStmt = new ReturnStmt(0, 0);
returnStmt.ReturnExpression = new IntLiteralExpr(0, 0, 0);
funcBlock.Statements.Add(returnStmt);
program.Block.Statements.Add(CreateFunction("func", funcBlock));
AssertNoErrors(program);
}
public void TestFunctionParametersAreAccessible()
{
var program = new ProgramNode(0, 0);
program.Block = new BlockStmt(0, 0);
var funcBlock = new BlockStmt(0, 0);
var ret = new ReturnStmt(0, 0);
ret.ReturnExpression = new VariableExpr(0, 0, "arg1");
var function = CreateFunction("func", funcBlock);
program.Block.Statements.Add(function);
AssertNoErrors(program);
}
public virtual void Visit(ReturnStmt returnStatement)
{
VisitNullableAttributes(returnStatement.Attributes);
if (returnStatement.rhss != null)
{
// In integration test run on ubuntu showed that this might be null.
// https://github.com/DafnyVSCode/language-server-csharp/runs/1390714082?check_suite_focus=true#step:9:907
// At the time of this writing, there is no contract in dafny-lang enforcing non-null - so this should be true.
foreach (var rhs in returnStatement.rhss)
{
Visit(rhs);
}
}
}
public void TestReturnOfWrongType()
{
var program = new ProgramNode(0, 0);
program.Block = new BlockStmt(0, 0);
var returnStmt = new ReturnStmt(0, 0);
returnStmt.ReturnExpression = new StringLiteralExpr(0, 0, "asd");
var funcBlock = new BlockStmt(0, 0);
funcBlock.Statements.Add(returnStmt);
program.Block.Statements.Add(CreateFunction("func", funcBlock));
AssertErrorContains(program, "Can't return a value of type String in a function of type Int");
}
public void visit_return(ReturnStmt return_stmt)
{
if (function_type == FunctionType.None)
{
throw new RuntimeException("Cannot return from a non-function");
}
if (return_stmt.value != null)
{
if (function_type == FunctionType.Constructor)
{
throw new RuntimeException("Cannot return from a constructor");
}
resolve(return_stmt.value);
}
}
public void TestReturnValueInProcedure()
{
var program = new ProgramNode(0, 0);
program.Block = new BlockStmt(0, 0);
var declaration = new ProcedureDeclarationStmt(0, 0);
declaration.Identifier = "func";
declaration.ProcedureBlock = new BlockStmt(0, 0);
var returnStmt = new ReturnStmt(0, 0);
returnStmt.ReturnExpression = new StringLiteralExpr(0, 0, "asd");
declaration.ProcedureBlock.Statements.Add(returnStmt);
program.Block.Statements.Add(declaration);
AssertErrorContains(program, "Can't return a value in a procedure");
}
protected override void MatchReturnStmt(ReturnStmt stmt)
{
if (_currentFunction == FunctionType.NONE)
{
Lox.Error(stmt.Keyword, "Cannot return from top-level code.");
}
if (stmt.Value != null)
{
if (_currentFunction == FunctionType.INITIALIZER)
{
Lox.Error(stmt.Keyword, "Cannot return a value from an initializer.");
}
Resolve(stmt.Value);
}
}
public override void Visit(ReturnStmt stmt)
{
if (isNewLine)
{
isNewLine = false;
AddStr(WS());
}
AddStr("return");
if (stmt.value != null)
{
AddStr(" ");
stmt.value.Accept(this);
}
AddStr(";");
NewLine();
}
public void ReturnStatementVisitTest()
{
var target = new EvaluateVisitor();
var returnValue = RandomGenerator.String();
var returnStmt = new ReturnStmt(new ConstantExpr(returnValue));
try
{
target.Visit(returnStmt, _scope);
Assert.Fail("No exception thrown");
}
catch (ReturnStatementException rse)
{
Assert.AreEqual(returnValue, rse.Value.ToObject());
}
catch (Exception)
{
Assert.Fail("Incorrect exception type caught");
}
}
public static object Eval(ICallerContext context, string expression, IDictionary <object, object> globals, object locals)
{
if (locals != null && PythonOperator.IsMappingType(context, locals) == Ops.FALSE)
{
throw Ops.TypeError("locals must be mapping");
}
CompilerContext cc = context.CreateCompilerContext();
Parser p = Parser.FromString(context.SystemState, cc, expression.TrimStart(' ', '\t'));
Expr e = p.ParseTestListAsExpression();
PythonModule mod = new PythonModule("<eval>", globals, context.SystemState, null, context.ContextFlags);
if (Options.FastEval) //!!! experimenting with a HUGE (>100x) performance boost to simple evals
{
return(e.Evaluate(new NameEnv(mod, locals)));
}
else
{
Stmt s = new ReturnStmt(e);
FrameCode fc = OutputGenerator.GenerateSnippet(cc, s, false);
return(fc.Run(new Frame(mod, globals, locals)));
}
}
public void TestFunctionDeclaration()
{
var programSource = new TokenList()
{
{ TokenType.KwFunction },
{ TokenType.Identifier, "func" },
{ TokenType.LParen },
{ TokenType.Identifier, "par1" },
{ TokenType.Colon },
{ TokenType.Identifier, "int" },
{ TokenType.RParen },
{ TokenType.Colon },
{ TokenType.Identifier, "bool" },
{ TokenType.LineTerm },
{ TokenType.KwBegin },
{ TokenType.KwReturn },
{ TokenType.IntLiteral, "123" },
{ TokenType.KwEnd }
};
Parser parser = new Parser(CreateMockScanner(programSource), new ErrorHandler());
ProgramNode program = parser.Parse();
var declr = new FunctionDeclarationStmt(0, 0);
declr.Identifier = "func";
declr.ReturnType = new SimpleType(0, 0, ExprType.Bool);
declr.AddParameter("par1", new SimpleType(0, 0, ExprType.Int), false);
declr.ProcedureBlock = new BlockStmt(0, 0);
var returnStmt = new ReturnStmt(0, 0);
returnStmt.ReturnExpression = new IntLiteralExpr(0, 0, 123);
declr.ProcedureBlock.Statements.Add(returnStmt);
expected.Block.Statements.Add(declr);
program.ShouldBeEquivalentTo(expected);
}
public void ValueExpressionIsAvailableFromTheReturnExpressionProperty(object value)
{
var target = new ReturnStmt(new ConstantExpr(value));
Assert.AreSame(value, ((ConstantExpr)target.ReturnExpression).Value);
}
public override Null Visit(ReturnStmt node)
{
Type returnType = node.info.funcDef.symbol.type.ReturnType();
context = new Context { targetType = returnType };
base.Visit(node);
if ((node.value == null) != (returnType is VoidType)) {
log.ErrorVoidReturn(node.location, returnType is VoidType);
} else if (node.value != null && !node.value.computedType.EqualsType(returnType)) {
if (node.value.computedType.CanImplicitlyConvertTo(returnType)) {
node.value = InsertCast(node.value, returnType);
} else {
log.ErrorTypeMismatch(node.location, returnType, node.value.computedType);
}
}
return null;
}
void ReturnStmt(out Statement/*!*/ s)
{
IToken returnTok = null;
List<AssignmentRhs> rhss = null;
AssignmentRhs r;
bool isYield = false;
if (la.kind == 96) {
Get();
returnTok = t;
} else if (la.kind == 90) {
Get();
returnTok = t; isYield = true;
} else SynErr(196);
if (StartOf(26)) {
Rhs(out r);
rhss = new List<AssignmentRhs>(); rhss.Add(r);
while (la.kind == 22) {
Get();
Rhs(out r);
rhss.Add(r);
}
}
Expect(28);
if (isYield) {
s = new YieldStmt(returnTok, t, rhss);
} else {
s = new ReturnStmt(returnTok, t, rhss);
}
}
public virtual void Visit(ReturnStmt stmt)
{
}
public override Null Visit(ReturnStmt node)
{
// Return statements stop flow completely
next.Set(new BlockerNode(next.Get()));
next.Set(new FlowNode(next.Get()));
base.Visit(node);
return null;
}
public string Visit(ReturnStmt returnExpr, Scope scope)
{
return("return " + returnExpr.ReturnExpression.Accept(this, scope));
}
private void visitMainContent(ASTNode parent, List <Statement> content)
{
bool endWithBr = false;
while (reader.Read())
{
reader.MoveToContent();
Location location = new Location(file, reader.LineNumber, reader.LinePosition);
switch (reader.NodeType)
{
case XmlNodeType.Text:
string text = reader.Value;
string[] lines = text.Split(new char[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string line in lines)
{
string trimed = line.Trim();
if (trimed.Length == 0)
{
continue;
}
if (endWithBr && content.Count > 0 && content[content.Count - 1] is DialogStmt)
{
DialogStmt dialog = content[content.Count - 1] as DialogStmt;
dialog.Text += Environment.NewLine + trimed;
}
else
{
DialogStmt dialog = new DialogStmt();
dialog.Parent = parent;
dialog.Location = location;
dialog.Text = trimed;
content.Add(dialog);
}
endWithBr = false;
}
break;
case XmlNodeType.Element:
Statement statement = null;
switch (dic[reader.Name])
{
case "br":
endWithBr = true;
continue;
case "expr":
statement = new ExpressionStmt();
break;
case "return":
statement = new ReturnStmt();
break;
case "include":
statement = new IncludeStmt();
break;
case "actor":
statement = new ActorStmt();
break;
case "bg":
statement = new BackgroundStmt();
break;
case "echo":
statement = new EchoStmt();
break;
case "select":
statement = new SelectStmt();
break;
case "selectWithValue":
statement = new SelectStmt();
break;
case "if":
statement = new IfStmt();
break;
case "else":
return;
case "elseif":
return;
case "switch":
statement = new SwitchStmt();
break;
case "break":
statement = new BreakStmt();
break;
case "continue":
statement = new ContinueStmt();
break;
case "loop":
statement = new LoopStmt();
break;
case "music":
statement = new MusicStmt();
break;
case "musicStop":
statement = new MusicStopStmt();
break;
case "musicVol":
statement = new MusicVolStmt();
break;
default:
statement = new FunctionCallStmt();
break;
}
statement.Parent = parent;
statement.Location = location;
statement.Accept(this);
content.Add(statement);
break;
case XmlNodeType.EndElement:
//reader.Read(); //MainContent结束
return;
}
}
}
public virtual Statement CloneStmt(Statement stmt) {
if (stmt == null) {
return null;
}
Statement r;
if (stmt is AssertStmt) {
var s = (AssertStmt)stmt;
r = new AssertStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Expr), null);
} else if (stmt is AssumeStmt) {
var s = (AssumeStmt)stmt;
r = new AssumeStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Expr), null);
} else if (stmt is TacticInvariantStmt) {
var s = (TacticInvariantStmt)stmt;
r = new TacticInvariantStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Expr), null, s.IsObjectLevel);
} else if (stmt is TacticAssertStmt) {
var s = (TacticAssertStmt)stmt;
r = new TacticAssertStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Expr), null, s.IsObjectLevel);
} else if (stmt is PrintStmt) {
var s = (PrintStmt)stmt;
r = new PrintStmt(Tok(s.Tok), Tok(s.EndTok), s.Args.ConvertAll(CloneExpr));
} else if (stmt is BreakStmt) {
var s = (BreakStmt)stmt;
if (s.TargetLabel != null) {
r = new BreakStmt(Tok(s.Tok), Tok(s.EndTok), s.TargetLabel);
} else {
r = new BreakStmt(Tok(s.Tok), Tok(s.EndTok), s.BreakCount);
}
} else if (stmt is ReturnStmt) {
var s = (ReturnStmt)stmt;
r = new ReturnStmt(Tok(s.Tok), Tok(s.EndTok), s.rhss == null ? null : s.rhss.ConvertAll(CloneRHS));
} else if (stmt is YieldStmt) {
var s = (YieldStmt)stmt;
r = new YieldStmt(Tok(s.Tok), Tok(s.EndTok), s.rhss == null ? null : s.rhss.ConvertAll(CloneRHS));
} else if (stmt is AssignStmt) {
var s = (AssignStmt)stmt;
r = new AssignStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Lhs), CloneRHS(s.Rhs));
} else if (stmt is BlockStmt) {
r = CloneBlockStmt((BlockStmt)stmt);
} else if (stmt is IfStmt) {
var s = (IfStmt)stmt;
r = new IfStmt(Tok(s.Tok), Tok(s.EndTok), s.IsExistentialGuard, CloneExpr(s.Guard), CloneBlockStmt(s.Thn), CloneStmt(s.Els));
} else if (stmt is AlternativeStmt) {
var s = (AlternativeStmt)stmt;
r = new AlternativeStmt(Tok(s.Tok), Tok(s.EndTok), s.Alternatives.ConvertAll(CloneGuardedAlternative));
} else if (stmt is WhileStmt) {
var s = (WhileStmt)stmt;
r = new WhileStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Guard), s.Invariants.ConvertAll(CloneMayBeFreeExpr), CloneSpecExpr(s.Decreases), CloneSpecFrameExpr(s.Mod), CloneBlockStmt(s.Body));
((WhileStmt)r).TacAps = s.TacAps;
} else if (stmt is AlternativeLoopStmt) {
var s = (AlternativeLoopStmt)stmt;
r = new AlternativeLoopStmt(Tok(s.Tok), Tok(s.EndTok), s.Invariants.ConvertAll(CloneMayBeFreeExpr), CloneSpecExpr(s.Decreases), CloneSpecFrameExpr(s.Mod), s.Alternatives.ConvertAll(CloneGuardedAlternative));
} else if (stmt is ForallStmt) {
var s = (ForallStmt)stmt;
r = new ForallStmt(Tok(s.Tok), Tok(s.EndTok), s.BoundVars.ConvertAll(CloneBoundVar), null, CloneExpr(s.Range), s.Ens.ConvertAll(CloneMayBeFreeExpr), CloneStmt(s.Body));
if (s.ForallExpressions != null) {
((ForallStmt)r).ForallExpressions = s.ForallExpressions.ConvertAll(CloneExpr);
}
} else if (stmt is CalcStmt) {
var s = (CalcStmt)stmt;
// calc statements have the unusual property that the last line is duplicated. If that is the case (which
// we expect it to be here), we share the clone of that line as well.
var lineCount = s.Lines.Count;
var lines = new List<Expression>(lineCount);
for (int i = 0; i < lineCount; i++) {
lines.Add(i == lineCount - 1 && 2 <= lineCount && s.Lines[i] == s.Lines[i - 1] ? lines[i - 1] : CloneExpr(s.Lines[i]));
}
Contract.Assert(lines.Count == lineCount);
r = new CalcStmt(Tok(s.Tok), Tok(s.EndTok), CloneCalcOp(s.Op), lines, s.Hints.ConvertAll(CloneBlockStmt), s.StepOps.ConvertAll(CloneCalcOp), CloneCalcOp(s.ResultOp), CloneAttributes(s.Attributes));
} else if (stmt is MatchStmt) {
var s = (MatchStmt)stmt;
r = new MatchStmt(Tok(s.Tok), Tok(s.EndTok), CloneExpr(s.Source),
s.Cases.ConvertAll(CloneMatchCaseStmt), s.UsesOptionalBraces);
} else if (stmt is AssignSuchThatStmt) {
var s = (AssignSuchThatStmt)stmt;
r = new AssignSuchThatStmt(Tok(s.Tok), Tok(s.EndTok), s.Lhss.ConvertAll(CloneExpr), CloneExpr(s.Expr), s.AssumeToken == null ? null : Tok(s.AssumeToken), null);
} else if (stmt is UpdateStmt) {
var s = (UpdateStmt)stmt;
r = new UpdateStmt(Tok(s.Tok), Tok(s.EndTok), s.Lhss.ConvertAll(CloneExpr), s.Rhss.ConvertAll(CloneRHS), s.CanMutateKnownState);
} else if (stmt is VarDeclStmt) {
var s = (VarDeclStmt)stmt;
var lhss = s.Locals.ConvertAll(c => new LocalVariable(Tok(c.Tok), Tok(c.EndTok), c.Name, CloneType(c.OptionalType), c.IsGhost));
r = new VarDeclStmt(Tok(s.Tok), Tok(s.EndTok), lhss, (ConcreteUpdateStatement)CloneStmt(s.Update));
} else if (stmt is LetStmt) {
var s = (LetStmt)stmt;
r = new LetStmt(Tok(s.Tok), Tok(s.EndTok), s.LHSs.ConvertAll(CloneCasePattern), s.RHSs.ConvertAll(CloneExpr));
} else if (stmt is ModifyStmt) {
var s = (ModifyStmt)stmt;
var mod = CloneSpecFrameExpr(s.Mod);
var body = s.Body == null ? null : CloneBlockStmt(s.Body);
r = new ModifyStmt(Tok(s.Tok), Tok(s.EndTok), mod.Expressions, mod.Attributes, body);
} else if (stmt is TacnyCasesBlockStmt) {
var s = (TacnyCasesBlockStmt)stmt;
var guard = CloneExpr(s.Guard);
var body = s.Body == null ? null : CloneBlockStmt(s.Body);
r = new TacnyCasesBlockStmt(Tok(s.Tok), Tok(s.EndTok), guard, body);
} else if (stmt is TacnyChangedBlockStmt) {
var s = (TacnyChangedBlockStmt)stmt;
var body = s.Body == null ? null : CloneBlockStmt(s.Body);
r = new TacnyChangedBlockStmt(Tok(s.Tok), Tok(s.EndTok), body);
} else if (stmt is TacnySolvedBlockStmt) {
var s = (TacnySolvedBlockStmt)stmt;
var body = s.Body == null ? null : CloneBlockStmt(s.Body);
r = new TacnySolvedBlockStmt(Tok(s.Tok), Tok(s.EndTok), body);
} else if (stmt is TacnyTryCatchBlockStmt) {
var s = (TacnyTryCatchBlockStmt)stmt;
var body = s.Body == null ? null : CloneBlockStmt(s.Body);
var c = s.Ctch == null ? null : CloneBlockStmt(s.Ctch);
r = new TacnyTryCatchBlockStmt(Tok(s.Tok), Tok(s.EndTok), body, c);
} else if (stmt is TacticVarDeclStmt) {
var s = (TacticVarDeclStmt)stmt;
var lhss = s.Locals.ConvertAll(c => new LocalVariable(Tok(c.Tok), Tok(c.EndTok), c.Name, CloneType(c.OptionalType), c.IsGhost));
r = new TacticVarDeclStmt(Tok(s.Tok), Tok(s.EndTok), lhss, (ConcreteUpdateStatement)CloneStmt(s.Update));
} else {
Contract.Assert(false); throw new cce.UnreachableException(); // unexpected statement
}
// add labels to the cloned statement
AddStmtLabels(r, stmt.Labels);
r.Attributes = CloneAttributes(stmt.Attributes);
return r;
}
public Value Visit(ReturnStmt expr, Scope scope)
{
throw new ReturnStatementException(expr.ReturnExpression.Accept(this, scope));
}
protected abstract void MatchReturnStmt(ReturnStmt returnStmt);
public void ReturnStatementVisitTest()
{
var target = new EvaluateVisitor();
var returnValue = RandomGenerator.String();
var returnStmt = new ReturnStmt(new ConstantExpr(returnValue));
try
{
target.Visit(returnStmt, _scope);
Assert.Fail("No exception thrown");
}
catch (ReturnStatementException rse)
{
Assert.AreEqual(returnValue, rse.Value.ToObject());
}
catch (Exception)
{
Assert.Fail("Incorrect exception type caught");
}
}
public void ValueExpressionIsAvailableFromTheReturnExpressionProperty(object value)
{
var target = new ReturnStmt(new ConstantExpr(value));
Assert.AreSame(value, ((ConstantExpr)target.ReturnExpression).Value);
}
public override void Compile_FunctionAsMethod(Function function, Dictionary<TypeParameter,Type> typeArgs,
Dictionary<string,TypeParameter> substArgs)
{
var tok = function.tok;
if (Attributes.Contains(function.Attributes, "CompiledSpec"))
{
string specName = function.Name.Substring("CompiledSpec_".Length);
function = FindFunction(specName);
}
bool hidden = Attributes.Contains(function.Attributes, "opaque");
Formal result = new Formal(function.tok, "__result", function.ResultType, false, function.IsGhost);
string funName = function.Name;
string name = FunName(DafnySpec.SimpleSanitizedName(function));
FunctionCallExpr call = new FunctionCallExpr(tok, name, new ThisExpr(tok), tok,
function.Formals.ConvertAll(f => (Expression)
MakeIdentifierExpr(f.Name, f.Type, f.IsGhost)));
call.Function = function;
call.TypeArgumentSubstitutions = typeArgs;
call.Type = function.ResultType;
CallStmt revealCall = null;
if (hidden)
{
var selectExpr = new MemberSelectExpr(tok, new ThisExpr(tok), "reveal_" + function.Name);
selectExpr.Member = FindMethod(selectExpr.MemberName); // Manually resolve here
selectExpr.TypeApplication = new List<Type>(); // Manually resolve here
selectExpr.Type = new InferredTypeProxy(); // Manually resolve here
revealCall = new CallStmt(tok, tok, new List<Expression>(), selectExpr, new List<Expression>());
revealCall.IsGhost = true;
ClassDecl cls = (ClassDecl)function.EnclosingClass;
string fullName = "#" + function.Name + "_FULL";
function = (Function)cls.Members.Find(m => m.Name == fullName);
if (function == null)
{
throw new Exception("internal error: could not find function " + fullName);
}
substArgs = new Dictionary<string,TypeParameter>();
function.TypeArgs.ForEach(t => substArgs.Add(t.Name, t));
typeArgs = typeArgs.ToDictionary(p => substArgs[p.Key.Name], p => p.Value);
}
Expression funBody = function.Body;
BlockStmt body = null;
if (funBody != null)
{
ReturnStmt retStmt = new ReturnStmt(tok, tok, new List<AssignmentRhs>() {
new ExprRhs(funBody)
});
body = new BlockStmt(tok, tok,
hidden
? (new List<Statement>() { revealCall, retStmt })
: (new List<Statement>() { retStmt }));
}
List<Expression> ens = new List<Expression> {
MakeBinaryExpr(BinaryExpr.Opcode.Eq, BinaryExpr.ResolvedOpcode.EqCommon, Type.Bool,
MakeIdentifierExpr("__result", function.ResultType, function.IsGhost),
call)
}.Concat(function.Ens).ToList();
Method method = new Method(tok, funName, function.IsStatic, function.IsGhost,
function.TypeArgs, function.Formals, new List<Formal> { result },
function.Req.ConvertAll(e => new MaybeFreeExpression(e)),
new Specification<FrameExpression>(new List<FrameExpression>(), null),
ens.ConvertAll(e => new MaybeFreeExpression(e)),
function.Decreases,
body, function.Attributes, function.SignatureEllipsis);
method.EnclosingClass = function.EnclosingClass;
Compile_Method(method, typeArgs);
}
public void Visit(ReturnStmt returnStmt, object[] args)
{
throw new NotImplementedException();
}
static string Example6()
{
AtomExprList ael1 = new AtomExprList();
Call c1 = new Call("foo", ael1);
CallStmt cs1 = new CallStmt(c1);
NumLiteral n1 = new NumLiteral(3.14);
TmpNumReg tnr0 = new TmpNumReg(0);
Assign a1 = new Assign(tnr0, n1);
TmpIntReg tir0 = new TmpIntReg(0);
IntLiteral i1 = new IntLiteral(42);
StringLiteral s1 = new StringLiteral("hi");
AtomExprList ael2 = new AtomExprList();
ael2.Add(tir0);
ael2.Add(i1);
ael2.Add(s1);
Call c2 = new Call("bar", ael2);
CallStmt cs2 = new CallStmt(c2);
NamedReg a = new NamedReg("a");
LocalDecl ld1 = new LocalDecl(new IntType(), a);
NamedReg b = new NamedReg("b");
LocalDecl ld2 = new LocalDecl(new NumType(), b);
NamedReg c = new NamedReg("c");
LocalDecl ld3 = new LocalDecl(new StringType(), c);
TmpNumReg tnr2 = new TmpNumReg(2);
NumLiteral n2 = new NumLiteral(2.7);
Assign a2 = new Assign(tnr2, n2);
StringLiteral s2 = new StringLiteral("hello yourself");
AtomExprList ael3 = new AtomExprList();
ael3.Add(tnr2);
ael3.Add(s2);
Call c3 = new Call("baz", ael3);
RegList rl4 = new RegList();
rl4.Add(a);
rl4.Add(b);
rl4.Add(c);
Assign a3 = new Assign(rl4, c3);
StmtList sl1 = new StmtList();
sl1.Add(cs1);
sl1.Add(a1);
sl1.Add(cs2);
sl1.Add(ld1);
sl1.Add(ld2);
sl1.Add(ld3);
sl1.Add(a2);
sl1.Add(a3);
Sub main = new Sub("main", sl1);
StringLiteral s3 = new StringLiteral("Foo!\n");
Call c4 = new Call("print", s3);
CallStmt cs3 = new CallStmt(c4);
StmtList sl2 = new StmtList();
sl2.Add(cs3);
Sub foo = new Sub("foo", sl2);
NamedReg i = new NamedReg("i");
ParamDecl pd1 = new ParamDecl(new NumType(), i);
NamedReg answer = new NamedReg("answer");
ParamDecl pd2 = new ParamDecl(new IntType(), answer);
NamedReg message = new NamedReg("message");
ParamDecl pd3 = new ParamDecl(new StringType(), message);
StringLiteral s4 = new StringLiteral("Bar!\n");
Call print1 = new Call("print", s4);
CallStmt cs4 = new CallStmt(print1);
Call print2 = new Call("print", i);
CallStmt cs5 = new CallStmt(print2);
StringLiteral s5 = new StringLiteral("\n");
Call print3 = new Call("print", s5);
CallStmt cs6 = new CallStmt(print3);
Call print4 = new Call("print", answer);
CallStmt cs7 = new CallStmt(print4);
CallStmt cs8 = new CallStmt(print3);
Call print5 = new Call("print", message);
CallStmt cs9 = new CallStmt(print5);
StmtList sl3 = new StmtList();
sl3.Add(pd1);
sl3.Add(pd2);
sl3.Add(pd3);
sl3.Add(cs4);
sl3.Add(cs5);
sl3.Add(cs6);
sl3.Add(cs7);
sl3.Add(cs8);
sl3.Add(cs9);
Sub bar = new Sub("bar", sl3);
NamedReg e = new NamedReg("e");
ParamDecl pd4 = new ParamDecl(new NumType(), e);
NamedReg msg = new NamedReg("msg");
ParamDecl pd5 = new ParamDecl(new StringType(), msg);
StringLiteral s6 = new StringLiteral("Baz!\n");
Call print7 = new Call("print", s6);
CallStmt cs10 = new CallStmt(print7);
Call print8 = new Call("print", e);
CallStmt cs11 = new CallStmt(print8);
Call print9 = new Call("print", s5);
CallStmt cs12 = new CallStmt(print9);
Call print10 = new Call("print", msg);
CallStmt cs13 = new CallStmt(print10);
AtomExprList ael4 = new AtomExprList();
ael4.Add(new IntLiteral(1000));
ael4.Add(new NumLiteral(1.23));
ael4.Add(new StringLiteral("hi from baz"));
ReturnStmt rs1 = new ReturnStmt(ael4);
StmtList sl4 = new StmtList();
sl4.Add(pd4);
sl4.Add(pd5);
sl4.Add(cs10);
sl4.Add(cs11);
sl4.Add(cs12);
sl4.Add(cs13);
sl4.Add(rs1);
Sub baz = new Sub("baz", sl4);
Pirate p = new Pirate();
p.Add(main);
p.Add(foo);
p.Add(bar);
p.Add(baz);
StringWriter sw = new StringWriter();
PirateWriter pv = new PirateWriter(sw);
DynamicVisitor.accept(p, pv);
return sw.ToString();
}
static string Example5()
{
NamedReg x1 = new NamedReg();
x1.name = "x1";
NamedReg x2 = new NamedReg();
x2.name = "x2";
IdList idl1 = new IdList();
idl1.Add(x1);
idl1.Add(x2);
LocalDecl ld1 = new LocalDecl();
ld1.type = new NumType();
ld1.id_list = idl1;
AtomExprList ael1 = new AtomExprList();
ael1.Add(x1);
ael1.Add(x2);
ReturnStmt rs1 = new ReturnStmt();
rs1.rv = ael1;
StmtList sl1 = new StmtList();
sl1.Add(ld1);
sl1.Add(rs1);
Sub abc = new Sub("abc", sl1);
Pirate p = new Pirate();
p.Add(abc);
StringWriter sw = new StringWriter();
PirateWriter pv = new PirateWriter(sw);
DynamicVisitor.accept(p, pv);
return sw.ToString();
}
public bool VisitReturnStmt(ReturnStmt stmt)
{
throw new NotImplementedException();
}
public ValueType Visit(ReturnStmt expr, Scope scope)
{
return(expr.ReturnExpression.Accept(this, scope));
}
