public override IAstNode VisitAssignFieldStmt(MicroCParser.AssignFieldStmtContext context) { var label = ++_label; string recName = context.name.Text; string fieldName = context.field.Text; var recSymbol = _symbolTable.LookupSymbol(recName); if (recSymbol == null) { throw new ArgumentException($"Record: {recName} does not exist"); } var fieldSymbol = recSymbol.Children.SingleOrDefault(f => f.Name == fieldName); if (fieldSymbol == null) { throw new ArgumentException($"Record: {recName} does not include a field: {fieldName}"); } var recIdent = new Identifier(recName, recSymbol.Type, recSymbol.Id); var fieldIdent = new Identifier(fieldName, fieldSymbol.Type, fieldSymbol.Id); RecordAccess left = new RecordAccess(recIdent, fieldIdent); IAExpr right = Visit(context.a_expr()) as IAExpr; var assignStmt = new AssignStmt(left, right); assignStmt.Label = label; return(assignStmt); }
Stmt parseAssignTo(Exp start) { AssignStmt stmtassign = new AssignStmt(); stmtassign.IsAssignTo = true; stmtassign.RightValueExp = start; MoveNext(); stmtassign.LeftToExp = parseExp(); matchSemiOrNewLine();//match(TokenKind.Semi); return(stmtassign); }
private (VariableAccessExpr, IPStmt) SaveInTemporary(IPExpr expr, PLanguageType tempType) { Antlr4.Runtime.ParserRuleContext location = expr.SourceLocation; Variable temp = function.Scope.Put($"$tmp{numTemp++}", location, VariableRole.Local | VariableRole.Temp); Debug.Assert(tempType.IsAssignableFrom(expr.Type)); temp.Type = tempType; function.AddLocalVariable(temp); AssignStmt stmt = new AssignStmt(location, new VariableAccessExpr(location, temp), expr); return(new VariableAccessExpr(location, temp), stmt); }
private IADomain AssignTransfer(AssignStmt assignStmt, IADomain domain) { var newDomain = CopyDomain(domain); if (domain.IsBottom()) { return(newDomain); } var ident = assignStmt.Left switch { VarAccess varAccess => varAccess.Left, ArrayAccess arrayAccess => arrayAccess.Left, RecordAccess recordAccess => recordAccess.Right, }; var newValue = assignStmt.Left switch { VarAccess varAccess => IAUtil.Arithmetic(assignStmt.Right, domain), RecordAccess recordAccess => IAUtil.Arithmetic(assignStmt.Right, domain), ArrayAccess arrayAccess => IAUtil.Arithmetic(assignStmt.Right, domain) .Join(domain[ident]), //.Join(IAUtil.Arithmetic(arrayAccess.Right, domain)), }; if (assignStmt.Left is ArrayAccess) { var ra = assignStmt.Left as ArrayAccess; var indexInterval = IAUtil.Arithmetic(ra.Right, domain); if (indexInterval.IsBottom) { return(Bottom().GetDomain()); } var arrayIndices = new Interval(new ExtendedZ(0), new ExtendedZ(ra.Left.Size - 1)); var meet = indexInterval.Meet(arrayIndices); if (indexInterval.Meet(arrayIndices).IsBottom) { return(Bottom().GetDomain()); } } if (newValue.IsBottom) { return(Bottom().GetDomain()); } newDomain[ident] = newValue.ToIntervalK(_program); return(newDomain); }
Stmt parseAssign(Exp start) { AssignStmt stmtassign = new AssignStmt(); stmtassign.LeftToExp = start; //if(start is FTextExp) //{ // FTextExp idexp = start as FTextExp; // //spliter.Add(idexp.IdToken); //} MoveNext(); stmtassign.RightValueExp = parseExp(); matchSemiOrNewLine();//match(TokenKind.Semi); return(stmtassign); }
public override IAstNode VisitAssignStmt(MicroCParser.AssignStmtContext context) { var label = ++_label; var name = context.IDENT().GetText(); var symbol = _symbolTable.LookupSymbol(name); var ident = new Identifier(name, symbol.Type, symbol.Id); // TODO: Type check the symbol VarAccess left = new VarAccess(ident); IAExpr right = Visit(context.a_expr()) as IAExpr; var assignStmt = new AssignStmt(left, right); assignStmt.Label = label; return(assignStmt); }
public string GenerateString(AssignStmt statement, int tabs) { var bob = new StringBuilder(); if (statement.Rhs is ExprRhs) { ApplyIndentation(bob, tabs); bob.Append(GenerateString(statement.Lhs) + " " + statement.Tok.val + " " + GenerateString((statement.Rhs as ExprRhs).Expr) + statement.EndTok.val); } return(bob.ToString()); }
private List <IPStmt> SimplifyStatement(IPStmt statement) { Antlr4.Runtime.ParserRuleContext location = statement?.SourceLocation; switch (statement) { case null: throw new ArgumentNullException(nameof(statement)); case AnnounceStmt announceStmt: (IExprTerm annEvt, List <IPStmt> annEvtDeps) = SimplifyExpression(announceStmt.PEvent); (IExprTerm annPayload, List <IPStmt> annPayloadDeps) = announceStmt.Payload == null ? (null, new List <IPStmt>()) : SimplifyExpression(announceStmt.Payload); return(annEvtDeps.Concat(annPayloadDeps) .Concat(new[] { new AnnounceStmt(location, annEvt, annPayload) }) .ToList()); case AssertStmt assertStmt: (IExprTerm assertExpr, List <IPStmt> assertDeps) = SimplifyExpression(assertStmt.Assertion); (IExprTerm messageExpr, List <IPStmt> messageDeps) = SimplifyExpression(assertStmt.Message); return(assertDeps.Concat(messageDeps).Concat(new[] { new AssertStmt(location, assertExpr, messageExpr) }) .ToList()); case AssignStmt assignStmt: (IPExpr assignLV, List <IPStmt> assignLVDeps) = SimplifyLvalue(assignStmt.Location); (IExprTerm assignRV, List <IPStmt> assignRVDeps) = SimplifyRvalue(assignStmt.Value); IPStmt assignment; // If temporary returned, then automatically move. if (assignRV is VariableAccessExpr variableRef && variableRef.Variable.Role.HasFlag(VariableRole.Temp)) { assignment = new MoveAssignStmt(location, assignLV, variableRef.Variable); } else { assignment = new AssignStmt(location, assignLV, new CloneExpr(assignRV)); } return(assignLVDeps.Concat(assignRVDeps).Concat(new[] { assignment }).ToList());
public override IAstNode VisitAssignArrayStmt(MicroCParser.AssignArrayStmtContext context) { var label = ++_label; string name = context.IDENT().GetText(); var symbol = _symbolTable.LookupSymbol(name); var ident = new Identifier(name, symbol.Type, symbol.Id, symbol.Size); // TODO: Type check the symbol IAExpr index = Visit(context.index) as IAExpr; ArrayAccess left = new ArrayAccess(ident, index); IAExpr right = Visit(context.value) as IAExpr; var assignStmt = new AssignStmt(left, right); assignStmt.Label = label; return(assignStmt); }
protected override ILattice <FVDomain> TransferFunctions(int label) { var block = GetBlock(label); var domain = _analysisCircle[label].GetDomain(); var newDomain = block switch { AssignStmt assignStmt => AssignTransfer(assignStmt, domain), RecAssignStmt recAssignStmt => RecAssignTransfer(recAssignStmt, domain), IfStmt ifStmt => ConditionTransfer(ifStmt.Condition, domain), IfElseStmt ifElseStmt => ConditionTransfer(ifElseStmt.Condition, domain), WhileStmt whileStmt => ConditionTransfer(whileStmt.Condition, domain), WriteStmt writeStmt => WriteTransfer(writeStmt, domain), ReadStmt readStmt => ReadTransfer(readStmt, domain), _ => new FVDomain(), }; return(new FVLattice(newDomain)); }
protected override ILattice <IADomain> TransferFunctions(int label) { var block = GetBlock(label); var domain = _analysisCircle[label].GetDomain(); var newDomain = block switch { IntDecl intDecl => IntDeclTransfer(intDecl, domain), ArrayDecl arrayDecl => ArrayDeclTransfer(arrayDecl, domain), RecordDecl recordDecl => RecDeclTransfer(recordDecl, domain), AssignStmt assignStmt => AssignTransfer(assignStmt, domain), RecAssignStmt recAssignStmt => RecAssignTransfer(recAssignStmt, domain), IfStmt ifStmt => IdTransfer(ifStmt, domain), IfElseStmt ifElseStmt => IdTransfer(ifElseStmt, domain), WhileStmt whileStmt => IdTransfer(whileStmt, domain), WriteStmt writeStmt => IdTransfer(writeStmt, domain), ReadStmt readStmt => ReadTransfer(readStmt, domain), _ => Bottom().GetDomain(), }; return(new IALattice(newDomain)); }
private DSDomain AssignTransfer(AssignStmt assignStmt, DSDomain domain) { var ident = assignStmt.Left switch { VarAccess varAccess => varAccess.Left, ArrayAccess arrayAccess => arrayAccess.Left, RecordAccess recordAccess => recordAccess.Right, }; var newDomain = CopyDomain(domain); var newValue = assignStmt.Left switch { VarAccess varAccess => DSUtil.Arithmetic(assignStmt.Right, domain), RecordAccess recordAccess => DSUtil.Arithmetic(assignStmt.Right, domain), ArrayAccess arrayAccess => DSUtil.Arithmetic(assignStmt.Right, domain) .Union(domain[ident]) //.Union(DSUtil.Arithmetic(arrayAccess.Right, domain)), }; newDomain[ident] = newValue.ToHashSet(); return(newDomain); }
private FVDomain AssignTransfer(AssignStmt assignStmt, FVDomain domain) { var ident = assignStmt.Left switch { VarAccess varAccess => varAccess.Left, ArrayAccess arrayAccess => arrayAccess.Left, RecordAccess recordAccess => recordAccess.Right, }; if (!domain.Contains(ident)) { return(domain); } var fv = AnalysisUtil.FreeVariables(assignStmt.Right); var fv2 = assignStmt.Left switch { ArrayAccess arrayAccess => AnalysisUtil.FreeVariables(arrayAccess.Right), _ => new HashSet <Identifier>(), }; var freeVariables = fv.Union(fv2); return(domain.Except(ident.Singleton()).Union(freeVariables).ToFVDomain()); }
public void FinalizeStatement() { Statement = new AssignStmt(Id, Exp.GetExp()); }
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 virtual void AddResolvedGhostStatement(Statement stmt) { BlockStmt block = stmt as BlockStmt; IfStmt ifStmt = stmt as IfStmt; AssertStmt assertStmt = stmt as AssertStmt; AssignStmt assignStmt = stmt as AssignStmt; CallStmt callStmt = stmt as CallStmt; VarDecl varDecl = stmt as VarDecl; CalcStmt calcStmt = stmt as CalcStmt; ForallStmt forallStmt = stmt as ForallStmt; AssignSuchThatStmt existsStmt = stmt as AssignSuchThatStmt; if (block != null) { var oldRenamer = PushRename(); block.Body.ForEach(AddGhostStatement); PopRename(oldRenamer); } else if (varDecl != null) { AddGhostVarDecl(varDecl.Name, varDecl.Type, varDecl.IsGhost); } else if (minVerify) { return; } else if (assignStmt != null) { ExprRhs expRhs = assignStmt.Rhs as ExprRhs; if (expRhs != null) { FieldSelectExpr fieldSelect = assignStmt.Lhs as FieldSelectExpr; RtlVar destVar; if (fieldSelect != null) { destVar = new RtlVar(GhostVar(fieldSelect.FieldName), true, fieldSelect.Type); } else { destVar = AsVar(assignStmt.Lhs); Util.Assert(destVar != null); } stmts.Add(new RtlGhostMove(new RtlVar[] { destVar }, new RtlExp[] { GhostExpression(expRhs.Expr) })); } else { throw new Exception("not implemented: " + assignStmt.Rhs); } } else if (callStmt != null) { AddGhostCall(callStmt.Lhs.ConvertAll(AsVar), callStmt.Args, dafnySpec.Compile_Method(callStmt.Method, callStmt.TypeArgumentSubstitutions.ToDictionary(p => p.Key, p => AppType(p.Value))), DafnySpec.IsHeapMethod(callStmt.Method)); SymdiffLinearityPoint(); } else if (ifStmt != null) { stmts.Add(new RtlGhostStmtComputed(s => "if (" + s.args[0] + ") {", new RtlExp[] { GhostExpression(ifStmt.Guard) })); Indent(); AddGhostStatement(ifStmt.Thn); Unindent(); stmts.Add(new RtlGhostStmtComputed(s => "}", new RtlExp[0])); if (ifStmt.Els != null) { stmts.Add(new RtlGhostStmtComputed(s => "if (" + s.args[0] + ") {", new RtlExp[] { GhostExpression(new UnaryExpr(Bpl.Token.NoToken, UnaryExpr.Opcode.Not, ifStmt.Guard)) })); Indent(); AddGhostStatement(ifStmt.Els); Unindent(); stmts.Add(new RtlGhostStmtComputed(s => "}", new RtlExp[0])); } } else if (assertStmt != null) { stmts.Add(new RtlAssert(GhostExpression(assertStmt.Expr))); } else if (forallStmt != null) { var oldRenamer = PushRename(forallStmt.BoundVars.Select(v => v.Name)); RtlExp ens = new RtlLiteral("true"); foreach (var e in forallStmt.Ens) { ens = new RtlBinary("&&", ens, GhostExpression(e.E)); } RtlExp range = (forallStmt.Range == null) ? new RtlLiteral("true") : GhostExpression(forallStmt.Range); List <RtlExp> wellFormed = GetTypeWellFormed(forallStmt.BoundVars. Select(x => Tuple.Create(GhostVar(x.Name), x.IsGhost, x.Type)).ToList()); wellFormed.ForEach(e => range = new RtlBinary("&&", e, range)); ens = new RtlBinary("==>", range, ens); string vars = String.Join(", ", forallStmt.BoundVars.Select(x => GhostVar(x.Name) + ":" + TypeString(AppType(x.Type)))); stmts.Add(new RtlGhostStmtComputed(s => "forall " + vars + "::(" + s.args[0] + ")", new List <RtlExp> { ens })); stmts.Add(new RtlGhostStmtComputed(s => "{", new RtlExp[0])); Indent(); stmts.Add(PushForall()); stmts.Add(new RtlGhostStmtComputed(s => "if (" + s.args[0] + ")", new List <RtlExp> { range })); stmts.Add(new RtlGhostStmtComputed(s => "{", new RtlExp[0])); Indent(); AddGhostStatement(forallStmt.Body); foreach (var e in forallStmt.Ens) { stmts.Add(new RtlAssert(GhostExpression(e.E))); } PopForall(); Unindent(); stmts.Add(new RtlGhostStmtComputed(s => "}", new RtlExp[0])); Unindent(); stmts.Add(new RtlGhostStmtComputed(s => "}", new RtlExp[0])); PopRename(oldRenamer); } else if (existsStmt != null) { List <RtlStmt> assigns = new List <RtlStmt>(); List <RtlVar> tmps = new List <RtlVar>(); List <Tuple <string, bool, Type> > varTuples = new List <Tuple <string, bool, Type> >(); var oldRenamer = PushRename(); foreach (var lhs in existsStmt.Lhss) { IdentifierExpr idExp = lhs.Resolved as IdentifierExpr; RtlVar origVar = AsVar(lhs); AddRename(idExp.Name); RtlVar renameVar = AsVar(lhs); tmps.Add(renameVar); varTuples.Add(Tuple.Create(renameVar.ToString(), true, idExp.Type)); assigns.Add(new RtlGhostMove(new RtlVar[] { origVar }, new RtlExp[] { renameVar })); } string vars = String.Join(", ", tmps.Select(x => x.getName() + ":" + TypeString(AppType(x.type)))); stmts.Add(new RtlGhostStmtComputed(s => "exists " + vars + "::(" + s.args[0] + ");", new List <RtlExp> { GetTypeWellFormedExp(varTuples.ToList(), "&&", GhostExpression(existsStmt.Expr)) })); stmts.AddRange(assigns); PopRename(oldRenamer); } else if (calcStmt != null) { Util.Assert(calcStmt.Steps.Count == calcStmt.Hints.Count); CalcStmt.BinaryCalcOp binOp = calcStmt.Op as CalcStmt.BinaryCalcOp; bool isImply = binOp != null && binOp.Op == BinaryExpr.Opcode.Imp && calcStmt.Steps.Count > 0; if (isImply) { stmts.Add(new RtlGhostStmtComputed(s => "if (" + s.args[0] + ")", new RtlExp[] { GhostExpression(CalcStmt.Lhs(calcStmt.Steps[0])) })); stmts.Add(new RtlGhostStmtComputed(s => "{", new RtlExp[0])); Indent(); } var stepCount = calcStmt.Hints.Last().Body.Count == 0 ? calcStmt.Steps.Count - 1 : calcStmt.Steps.Count; for (int i = 0; i < stepCount; i++) { if (calcStmt.Hints[i] == null) { stmts.Add(new RtlAssert(GhostExpression(calcStmt.Steps[i]))); } else { stmts.Add(new RtlGhostStmtComputed(s => "forall::(" + s.args[0] + ")", new List <RtlExp> { GhostExpression(calcStmt.Steps[i]) })); stmts.Add(new RtlGhostStmtComputed(s => "{", new RtlExp[0])); Indent(); var dict = new Dictionary <string, RtlVar>(); stmts.Add(new RtlGhostStmtComputed(s => String.Concat(dict.Values.Select( x => "var " + x.x + ":" + TypeString(x.type) + ";")), new RtlExp[0])); forallVars.Add(dict); AddGhostStatement(calcStmt.Hints[i]); forallVars.RemoveAt(forallVars.Count - 1); Unindent(); stmts.Add(new RtlGhostStmtComputed(s => "}", new RtlExp[0])); } } if (isImply) { Unindent(); stmts.Add(new RtlGhostStmtComputed(s => "}", new RtlExp[0])); } } else { throw new Exception("not implemented in ghost methods: " + stmt); } }
static void Main(string[] args) { // Example 1 Statement stmt1 = new CompStmt( new OpenFileStmt("1stFile.txt", "1stFile"), new CompStmt(new PrintStmt(new ArithmeticExpr('-', new ConstExpr(10), new ConstExpr(5))), new CompStmt(new AssignStmt(new ConstExpr(11), "b"), new CompStmt(new IfStmt(new ConstExpr(0), new PrintStmt(new ConstExpr(1)), new PrintStmt(new ConstExpr(2))), new AssignStmt(new ConstExpr(10), "x"))))); PrgState prg1 = new PrgState(stmt1, new ExeStack <Statement>(), new SymbolTable <string, int>(), new FileTable <int, FileStream>(), new Output <int>()); IRepository repo1 = new Repository("logFile.txt", prg1); Controller ctrl1 = new Controller(repo1); // Example 2 Statement stmt2 = new AssignStmt(new ArithmeticExpr('/', new ConstExpr(3), new ConstExpr(0)), "var"); PrgState prg2 = new PrgState(stmt2, new ExeStack <Statement>(), new SymbolTable <string, int>(), new FileTable <int, FileStream>(), new Output <int>()); IRepository repo2 = new Repository("logFile.txt", prg2); Controller ctrl2 = new Controller(repo2); // Example 3 Statement stmt3 = new CompStmt( new OpenFileStmt("2ndFile.txt", "2ndFile"), new CompStmt(new ReadFileStmt("2ndFile.txt", "h1"), new CompStmt(new ReadFileStmt("2ndFile.txt", "h2"), new CloseFileStmt("2ndFile.txt")))); PrgState prg3 = new PrgState(stmt3, new ExeStack <Statement>(), new SymbolTable <string, int>(), new FileTable <int, FileStream>(), new Output <int>()); IRepository repo3 = new Repository("logFile.txt", prg3); Controller ctrl3 = new Controller(repo3); // Example 4 Statement stmt4 = new CompStmt( new OpenFileStmt("2ndFile.txt", "2ndFile"), new CompStmt(new CompStmt(new ReadFileStmt("2ndFile.txt", "h1"), new CompStmt(new ReadFileStmt("2ndFile.txt", "h2"), new CloseFileStmt("2ndFile.txt"))), new CompStmt(new OpenFileStmt("1stFile.txt", "1stFile"), new CompStmt(new ReadFileStmt("1stFile.txt", "h"), new CloseFileStmt("1stFile.txt"))))); PrgState prg4 = new PrgState(stmt4, new ExeStack <Statement>(), new SymbolTable <string, int>(), new FileTable <int, FileStream>(), new Output <int>()); IRepository repo4 = new Repository("logFile.txt", prg4); Controller ctrl4 = new Controller(repo4); // MENU TextMenu menu = new TextMenu(); menu.addCommand(new ExitCommand("0", "exit")); menu.addCommand(new RunExample("1", stmt1.ToString(), ctrl1)); menu.addCommand(new RunExample("2", stmt2.ToString(), ctrl2)); menu.addCommand(new RunExample("3", stmt3.ToString(), ctrl3)); menu.addCommand(new RunExample("4", stmt4.ToString(), ctrl4)); menu.show(); }