public void PrintInfo(TokenTextWriter writer) { if (writer == null) { return; } writer.WriteLine("================================="); writer.WriteLine("Here's what we know of the program:"); writer.Write("Declared globals: "); foreach (var g in declaredGlobals) { writer.Write(g.Key + " "); } writer.Write("\n"); writer.Write("Modified globals: "); foreach (var g in modifiedGlobals) { writer.Write(g.Key + " "); } writer.Write("\n"); writer.WriteLine("Main procedure: {0}", mainProcName); writer.WriteLine("================================="); }
public void Emit(TokenTextWriter t) { Console.Write("\t"); Source.Emit(t, 0); if (!Cons.IsTrue()) { t.WriteLine("\t\tPre: "); t.Write("\t\t\t"); Cons.Emit(t); t.WriteLine(); } if (Gammas.Count != 0) { t.WriteLine("\t\tGammas:"); for (int i = 0; i < Gammas.Count; i++) { if (Gammas.Count > 1) { t.WriteLine("\t\t\t" + i + ": "); } Gammas[i].Emit(t); t.WriteLine("==============="); } } }
public static void PrintBplFile(string filename, Program program, bool allowPrintDesugaring) { Contract.Requires(program != null); Contract.Requires(filename != null); bool oldPrintDesugaring = CommandLineOptions.Clo.PrintDesugarings; if (!allowPrintDesugaring) { CommandLineOptions.Clo.PrintDesugarings = false; } using (TokenTextWriter writer = filename == "-" ? new TokenTextWriter("<console>", Console.Out, false) : new TokenTextWriter(filename, false)) { if (CommandLineOptions.Clo.ShowEnv != CommandLineOptions.ShowEnvironment.Never) { writer.WriteLine("// " + CommandLineOptions.Clo.Version); writer.WriteLine("// " + CommandLineOptions.Clo.Environment); } writer.WriteLine(); program.Emit(writer); } CommandLineOptions.Clo.PrintDesugarings = oldPrintDesugaring; }
private static void setupPrint(PersistentCBAProgram program, ErrorTrace trace, string file) { // Set output files pathFile = file == null ? null : new TokenTextWriter(file + "_trace.txt"); if (pathFile != null) { program.writeToFile(file + ".bpl"); } Program prog = program.getProgram(); // Initialization initialize(prog, trace, file == null ? null : file + ".bpl"); if (pathFile != null) { if (traceFormat == TraceFormat.ConcurrencyExplorer) { pathFile.WriteLine("s"); pathFile.WriteLine("#"); } else if (traceFormat == TraceFormat.SDV) { pathFile.WriteLine("0 \"?\" 0 false ^ Call \"OS\" \"main\""); } } }
// Prints the policy public void print(TokenTextWriter writer) { if (writer == null) { return; } writer.WriteLine("================================="); writer.WriteLine("The instrumentation policy:"); writer.Write(" Globals to instrument: "); foreach (var s in globalsToInstrument) { writer.Write("{0} ", s); } writer.WriteLine(); /* * writer.Write(" Procedures without implementation: "); * foreach (var s in procsWithoutImpl) * { * writer.Write("{0} ", s); * } * writer.WriteLine(); * * writer.WriteLine(" Atomic-block procedures: {0} {1}", atomicBeginProcName, atomicEndProcName); * writer.WriteLine(" Assertion procedure: {0}", assertNotReachableName); */ writer.WriteLine("================================="); }
public static void DumpExceptionInformation(Exception e) { if (e.ToString().Contains("An attempt was made to load an assembly from a network location")) { Console.Error.WriteLine(); Console.Error.WriteLine("GPUVerify has had trouble loading one of its components due to security settings."); Console.Error.WriteLine(); Console.Error.WriteLine("In order to run GPUVerify successfully you need to unblock the archive before unzipping it."); Console.Error.WriteLine(); Console.Error.WriteLine("To do this:"); Console.Error.WriteLine(" - Right click on the .zip file"); Console.Error.WriteLine(" - Click \"Properties\""); Console.Error.WriteLine(" - At the bottom of the \"General\" tab you should see:"); Console.Error.WriteLine(" Security: This file came from another computer and might be blocked"); Console.Error.WriteLine(" to help protect this computer."); Console.Error.WriteLine(" - Click \"Unblock\""); Console.Error.WriteLine(" - Click \"OK\""); Console.Error.WriteLine("Once this is done, unzip GPUVerify afresh and this issue should be resolved."); Environment.Exit((int)ToolExitCodes.INTERNAL_ERROR); } const string DUMP_FILE = "__gvdump.txt"; // Give generic internal error message Console.Error.WriteLine("\nGPUVerify: an internal error has occurred, details written to " + DUMP_FILE + "."); Console.Error.WriteLine(); Console.Error.WriteLine("Please consult the troubleshooting guide in the GPUVerify documentation"); Console.Error.WriteLine("for common problems, and if this does not help, raise an issue via the"); Console.Error.WriteLine("GPUVerify issue tracker:"); Console.Error.WriteLine(); Console.Error.WriteLine(" https://github.com/mc-imperial/gpuverify"); Console.Error.WriteLine(); // Now try to give the user a specific hint if this looks like a common problem if (e is ProverException) { Console.Error.WriteLine("Hint: It looks like GPUVerify is having trouble invoking its"); Console.Error.WriteLine("supporting theorem prover, which by default is Z3. Have you"); Console.Error.WriteLine("installed Z3?"); } // Write details of the exception to the dump file using (TokenTextWriter writer = new TokenTextWriter(DUMP_FILE, false)) { writer.WriteLine("An exception occured:"); writer.WriteLine(e.ToString()); } }
public void Emit(TokenTextWriter t) { t.WriteLine(Source.Label + ":"); foreach (SymbolicCmd c in SCmds) { c.Emit(t); } }
// Returns file and line of the failing assert. Dumps // error trace to disk. public Tuple <string, int> PrintErrorTrace(cba.ErrorTrace trace, string filename, List <Tuple <string, int, string> > eeSlicedSourceLines, string failStatus) { trace = mapBackTrace(trace); if (Driver.printTraceMode == Driver.PRINT_TRACE_MODE.Boogie) { cba.PrintProgramPath.print(input, trace, filename); return(null); } else { // relevant lines cba.PrintSdvPath.relevantLines = null; if (eeSlicedSourceLines != null) { cba.PrintSdvPath.relevantLines = new HashSet <Tuple <string, int> >(); eeSlicedSourceLines.Iter(tup => cba.PrintSdvPath.relevantLines.Add(Tuple.Create(tup.Item1, tup.Item2))); } cba.PrintSdvPath.failingLocation = null; cba.PrintSdvPath.failStatus = failStatus; cba.PrintSdvPath.Print(input.getProgram(), trace, new HashSet <string>(), "", filename + ".tt", filename + "stack.txt"); if (cba.PrintSdvPath.abortMessage != null) { var am = new TokenTextWriter(filename + ".txt"); am.WriteLine(cba.PrintSdvPath.abortMessage); am.Close(); } if (cba.PrintSdvPath.lastDriverLocation == null) { return(null); } cba.PrintSdvPath.failingLocation = Tuple.Create(cba.PrintSdvPath.lastDriverLocation.Item1, cba.PrintSdvPath.lastDriverLocation.Item3); cba.PrintSdvPath.Print(input.getProgram(), trace, new HashSet <string>(), "", filename + ".tt", filename + "stack.txt"); if (cba.PrintSdvPath.abortMessage != null) { var am = new TokenTextWriter(filename + ".txt"); am.WriteLine(cba.PrintSdvPath.abortMessage); am.Close(); } cba.PrintSdvPath.relevantLines = null; cba.PrintSdvPath.failingLocation = null; cba.PrintSdvPath.failStatus = null; return(Tuple.Create(cba.PrintSdvPath.lastDriverLocation.Item1, cba.PrintSdvPath.lastDriverLocation.Item3)); } }
private static void setupPrint(PersistentCBAProgram program, ErrorTrace trace, string file) { // Set output files pathFile = file == null ? null : new TokenTextWriter(file + "_trace.txt"); if (pathFile != null) { program.writeToFile(file + ".bpl"); } Program prog = program.getProgram(); // Initialization initialize(prog, trace, file == null ? null : file + ".bpl"); if (pathFile != null) { pathFile.WriteLine("s"); } if (pathFile != null) { pathFile.WriteLine("#"); } }
public void Emit(TokenTextWriter t) { t.Write("vtask: (" + Eq.Name + ", " + Left.Name + ", " + Right.Name + ")"); if (DesiredOutputVars.Count > 0) { t.Write(" / "); foreach (var v in DesiredOutputVars) { t.Write(v.Name + "; "); } } t.WriteLine(); }
private static void printLabels(Counterexample cex, TokenTextWriter ttw, int indent) { for (int numBlock = 0; numBlock < cex.Trace.Count; numBlock++) { Block b = cex.Trace[numBlock]; printIndent(ttw, indent); ttw.WriteLine(b.Label); for (int numInstr = 0; numInstr < b.Cmds.Count; numInstr++) { Cmd c = b.Cmds[numInstr]; var loc = new TraceLocation(numBlock, numInstr); if (cex.calleeCounterexamples.ContainsKey(loc)) { printIndent(ttw, indent); ttw.WriteLine("call to {0}:", (c as CallCmd).Proc.Name); printLabels(cex.calleeCounterexamples[loc].counterexample, ttw, indent + 1); printIndent(ttw, indent); ttw.WriteLine("return from {0}.", (c as CallCmd).Proc.Name); printIndent(ttw, indent); ttw.WriteLine(b.Label); } } } }
public static void Main(string[] args) { CommandLineOptions.Parse(args); Microsoft.Boogie.CommandLineOptions.Install(new OverrideCommandLineOptions()); string file = CommandLineOptions.Files[0]; Program program; var defines = new List <string>() { "FILE_0" }; int errors = Parser.Parse(file, defines, out program); Debug.Assert(errors == 0, String.Format("Parse errors discovered in '{0}'", file)); errors = program.Resolve(); errors = program.Typecheck(); Microsoft.Boogie.CommandLineOptions.Clo.PrintUnstructured = 2; using (TokenTextWriter writer = new TokenTextWriter(file + ".unstructured")) { writer.WriteLine(); program.Emit(writer); } Start(program, CommandLineOptions.ThreadID, CommandLineOptions.GroupID, Print.verbose, Print.debug); }
public override void Emit(TokenTextWriter stream, int level) { //Contract.Requires(stream != null); stream.WriteLine(); stream.WriteLine("{0};", Indent(level)); first.Emit(stream, level + 1); second.Emit(stream, level + 1); }
public override void Emit(TokenTextWriter stream, int level) { //Contract.Requires(stream != null); stream.Write(this, level, "const "); EmitAttributes(stream); if (this.Unique) { stream.Write(this, level, "unique "); } EmitVitals(stream, level, false); if (Parents != null || ChildrenComplete) { stream.Write(this, level, " extends"); string/*!*/ sep = " "; foreach (ConstantParent/*!*/ p in cce.NonNull(Parents)) { Contract.Assert(p != null); stream.Write(this, level, sep); sep = ", "; if (p.Unique) stream.Write(this, level, "unique "); p.Parent.Emit(stream); } if (ChildrenComplete) stream.Write(this, level, " complete"); } stream.WriteLine(";"); }
public void Emit(TokenTextWriter stream, int level) { Contract.Requires(stream != null); if (Comment != null) { stream.WriteLine(this, level, "// " + Comment); } stream.Write(this, level, "{0}ensures ", Free ? "free " : ""); Cmd.EmitAttributes(stream, Attributes); this.Condition.Emit(stream); stream.WriteLine(";"); }
public override void Emit(TokenTextWriter stream, int level) { if (Label == null) { stream.WriteLine(level, "break;"); } else { stream.WriteLine(level, "break {0};", Label); } }
public void Emit(TokenTextWriter stream, int level) { Contract.Requires(stream != null); if (!Anonymous) { stream.WriteLine(level, "{0}:", CommandLineOptions.Clo.PrintWithUniqueASTIds ? String.Format("h{0}^^{1}", this.GetHashCode(), this.LabelName) : this.LabelName); } foreach (Cmd/*!*/ c in this.simpleCmds) { Contract.Assert(c != null); c.Emit(stream, level + 1); } if (this.ec != null) { this.ec.Emit(stream, level + 1); } else if (this.tc != null) { this.tc.Emit(stream, level + 1); } }
public override void Emit(TokenTextWriter stream, int level) { stream.Write(this, level, ""); string/*!*/ sep = ""; foreach (AssignLhs/*!*/ l in Lhss) { Contract.Assert(l != null); stream.Write(sep); sep = ", "; l.Emit(stream); } stream.Write(" := "); sep = ""; foreach (Expr/*!*/ e in Rhss) { Contract.Assert(e != null); stream.Write(sep); sep = ", "; e.Emit(stream); } stream.WriteLine(";"); }
public override void Emit(TokenTextWriter stream, int level) { if (this.Comment.Contains("\n")) { stream.WriteLine(this, level, "/* {0} */", this.Comment); } else { stream.WriteLine(this, level, "// {0}", this.Comment); } }
public override void Emit(TokenTextWriter stream, int level) { //Contract.Requires(stream != null); stream.Write(this, level, "implementation "); EmitAttributes(stream); stream.Write(this, level, "{0}", TokenTextWriter.SanitizeIdentifier(this.Name)); EmitSignature(stream, false); stream.WriteLine(); stream.WriteLine(level, "{0}", '{'); foreach (Variable/*!*/ v in this.LocVars) { Contract.Assert(v != null); v.Emit(stream, level + 1); } if (this.StructuredStmts != null && !CommandLineOptions.Clo.PrintInstrumented && !CommandLineOptions.Clo.PrintInlined) { if (this.LocVars.Count > 0) { stream.WriteLine(); } if (CommandLineOptions.Clo.PrintUnstructured < 2) { if (CommandLineOptions.Clo.PrintUnstructured == 1) { stream.WriteLine(this, level + 1, "/*** structured program:"); } this.StructuredStmts.Emit(stream, level + 1); if (CommandLineOptions.Clo.PrintUnstructured == 1) { stream.WriteLine(level + 1, "**** end structured program */"); } } } if (this.StructuredStmts == null || 1 <= CommandLineOptions.Clo.PrintUnstructured || CommandLineOptions.Clo.PrintInstrumented || CommandLineOptions.Clo.PrintInlined) { foreach (Block b in this.Blocks) { b.Emit(stream, level + 1); } } stream.WriteLine(level, "{0}", '}'); stream.WriteLine(); stream.WriteLine(); }
public static void ProcessCounterexamplesWOSymbolicOut(SDiffCounterexamples errors, List <Variable> globals, List <Variable> eqLocVars, Implementation vtLeftProcImpl, Implementation vtRightProcImpl, List <Declaration> consts, List <Model> errModelList, string v1Name, string v2Name) { List <Expr> constraintExprs = new List <Expr>(); List <Block> listBlocksV1 = new List <Block>(); List <Block> listBlocksV2 = new List <Block>(); Model[] errModelArray = errModelList.ToArray(); var label = new GotoCmd(Token.NoToken, new List <String>() { "DONE" }); label.labelNames = new List <string>(); // label.labelTargets = new List<Block>(); label.labelNames.Add("DONE"); //label.labelTargets.Add("DONE"); // First block var labels = new List <String>(); for (int j = 0; j < errors.Count; j++) { labels.Add("Cex" + j); } labels.Add("ELSE"); var labelEntry = new GotoCmd(Token.NoToken, labels); labelEntry.labelTargets = new List <Block>(); for (int j = 0; j < errors.Count; j++) { labelEntry.labelNames.Add("Cex" + j);//labelEntry.labelTargets.Add("Cex" + j); } for (int i = 0; i < errors.Count; i++) { var impl = errors[i].Impl; var trace = errors[i].Trace; //Log.Out(Log.Normal, "Attempting symbolic execution of [" + i + "] $ " + impl.Name); if (Options.GenerateCTrace) { Log.Out(Log.Normal, "Constructing metatrace from location annotations"); var extractor = new SDiff.SymEx.TraceExtractor(); extractor.VisitTrace(trace); //Log.Out(Log.CTrace, CTrace.Make(extractor.metaTrace)); var cTrace = CTrace.Make(extractor.metaTrace, consts, errModelArray[i], v1Name, v2Name); //var cTrace = ""; if (cTrace.Trim() != "") { //note that the index for cex on the output shows 1,2,..., instead of 0,1,2.... var fname = impl.Name + "_cex_" + (i + 1) + "_out.c"; var cexOut = new TokenTextWriter(impl.Name + "_cex_" + (i + 1) + "_out.c", true); cexOut.WriteLine(cTrace); cexOut.Close(); Log.Out(Log.CTrace, "n:" + (i + 1) + ":" + fname); Log.Out(Log.CTrace, "w:" + fname); } } Log.Out(Log.Normal, "Desugaring calls"); //HACK!!!: changes havoc x; assume (x= uf(..)); --> x := uf(...) var deCall = new SDiff.SymEx.DesugarCallCmds(); trace = deCall.VisitTrace(trace); //symbolic constants var symInParams = new List <Variable>(impl.InParams); foreach (var g in globals) { symInParams.Add(g); } Log.Out(Log.Normal, "Executing trace downward"); //symbolic stores (look at symex.cs for the datastructure) // var sTrace = SDiff.SymEx.Cexecutor.ExecDown(trace, symInParams); Log.Out(Log.Normal, "Executing trace upward"); //looks at each assume to create the path constants //clean up the duplication of assignments //SDiff.SymEx.Cexecutor.ExecUp(sTrace); Log.Out(Log.Normal, "Grabbing final execution values"); // var lastStore = sTrace.LastSCmd().Gammas.Last(); // var firstCons = sTrace.FirstSCmd().Cons; // constraintExprs.Add(firstCons.Conjoin()); //#hemr - generating new strategy right here with inlining counterexamples! // Second block List <Cmd> cmdsV1_Diff_inline = new List <Cmd>(); List <Cmd> cmdsV2_Diff_inline = new List <Cmd>(); Substitution replaceScopeV1 = delegate(Variable x) { return(replaceScopeGeneric(vtLeftProcImpl, x)); }; Substitution replaceScopeV2 = delegate(Variable x) { return(replaceScopeGeneric(vtRightProcImpl, x)); }; foreach (Block currentBlock in trace) { if (currentBlock.ToString().Contains("inline$" + v1Name)) { foreach (Cmd currentCmd in currentBlock.Cmds) { Cmd newCmd = Substituter.Apply(replaceScopeV1, currentCmd); cmdsV1_Diff_inline.Add(newCmd); } } else if (currentBlock.ToString().Contains("inline$" + v2Name)) { foreach (Cmd currentCmd in currentBlock.Cmds) { Cmd newCmd = Substituter.Apply(replaceScopeV2, currentCmd); cmdsV2_Diff_inline.Add(newCmd); } } } Block blockV1 = new Block(Token.NoToken, "Cex" + i, cmdsV1_Diff_inline, label); Block blockV2 = new Block(Token.NoToken, "Cex" + i, cmdsV2_Diff_inline, label); listBlocksV1.Add(blockV1); listBlocksV2.Add(blockV2); //#hemr - displaying values related to error model (at console level) Model currentModel = errModelArray[i]; //var keys = currentModel.identifierToPartition.Keys; var keys = currentModel.Functions.Where(f => f.Arity == 0).Select(f => f.GetConstant()); } Expr disjunctionDiffCond = Expr.False; foreach (Expr currentExpr in constraintExprs) { disjunctionDiffCond = Expr.Or(disjunctionDiffCond, currentExpr); } ProcessCounterexampleForDiffInliningWOSymbolicOut(eqLocVars, vtLeftProcImpl, vtRightProcImpl, v1Name, v2Name, listBlocksV1, listBlocksV2, labelEntry); }
public static void ProcessCounterexamples(SDiffCounterexamples errors, List <Variable> globals, List <Variable> outputVars, Program prog, Implementation vtLeftProcImpl, Implementation vtRightProcImpl) { List <Expr> constraintExprs = new List <Expr>(); for (int i = 0; i < errors.Count; i++) { var impl = errors[i].Impl; var trace = errors[i].Trace; Log.Out(Log.Normal, "Attempting symbolic execution of [" + (i + 1) + "] $ " + impl.Name); if (Options.GenerateCTrace) { Log.Out(Log.Normal, "Constructing metatrace from location annotations"); var extractor = new SDiff.SymEx.TraceExtractor(); extractor.VisitTrace(trace); //Log.Out(Log.CTrace, CTrace.Make(extractor.metaTrace)); var cTrace = CTrace.Make(extractor.metaTrace, null, null, "", ""); //var cTrace = ""; if (cTrace.Trim() != "") { var fname = impl.Name + "_cex_" + (i + 1) + "_out.c"; var cexOut = new TokenTextWriter(impl.Name + "_cex_" + (i + 1) + "_out.c", true); cexOut.WriteLine(cTrace); cexOut.Close(); Log.Out(Log.CTrace, "n:" + (i + 1) + ":" + fname); Log.Out(Log.CTrace, "w:" + fname); } } Log.Out(Log.Normal, "Desugaring calls"); //HACK!!!: changes havoc x; assume (x= uf(..)); --> x := uf(...) var deCall = new SDiff.SymEx.DesugarCallCmds(); trace = deCall.VisitTrace(trace); //symbolic constants var symInParams = new List <Variable>(impl.InParams); foreach (var g in globals) { symInParams.Add(g); } Log.Out(Log.Normal, "Executing trace downward"); //symbolic stores (look at symex.cs for the datastructure) var sTrace = SDiff.SymEx.Cexecutor.ExecDown(trace, symInParams); Log.Out(Log.Normal, "Executing trace upward"); //looks at each assume to create the path constants //clean up the duplication of assignments SDiff.SymEx.Cexecutor.ExecUp(sTrace); if (Options.DumpSymTrace) { SDiff.SymEx.CexDumper.PrintSymbolicTrace(sTrace); } //printing the symbolic stores at exit //still in SSA form Log.Out(Log.Normal, "Grabbing final execution values"); var lastStore = sTrace.LastSCmd().Gammas.Last(); var firstCons = sTrace.FirstSCmd().Cons; //resolves the outputs to be expressions over uif and symbolic constants only Log.Out(Log.Normal, "Resolving result expressions"); var outSymExprs = new List <Expr>(); foreach (var v in outputVars) { outSymExprs.Add(SymEx.ResolveSymExpr.Resolve(v, lastStore)); } Log.Out(Log.SymEx, "SymEx Results==================================="); Log.Out(Log.SymEx, "Input constraint"); if (Options.EraseUFArgumentsOnPrintout) // f(..) { var eraser = new ArgumentParameterEraser(); var duper = new Duplicator(); var dupConst = new SDiff.SymEx.Constraint(firstCons, true); foreach (var e in dupConst.Conjuncts) { eraser.VisitExpr(e); } Log.LogEmit(Log.SymEx, 1, dupConst.Emit); } else { Log.LogEmit(Log.SymEx, 1, firstCons.Emit); } constraintExprs.Add(firstCons.Conjoin()); Console.WriteLine(); Log.Out(Log.SymEx, "Symbolic output values"); var outSymExprsPrintable = outSymExprs; if (Options.EraseUFArgumentsOnPrintout) // f(..) { outSymExprsPrintable = new List <Expr>(); var eraser = new ArgumentParameterEraser(); var duper = new Duplicator(); foreach (Expr e in outSymExprs) { var ex = duper.VisitExpr(e); eraser.VisitExpr(ex); outSymExprsPrintable.Add(ex); } } //if the output variables aren't paired, iterate through normally if (outputVars.Count % 2 != 0) { for (int j = 0; j < outputVars.Count; j++) { Log.Out(Log.SymEx, "\t" + outputVars[j].ToString() + ": "); Log.LogEmit(Log.SymEx, 2, outSymExprsPrintable[j].Emit); Log.Out(Log.Normal, ""); } } //otherwise don't print a pair if it's syntactically equal else { for (int j = 0; j < outputVars.Count; j += 2) { if (!outSymExprs[j].StringEquals(outSymExprs[j + 1])) { Log.Out(Log.SymEx, "\t" + outputVars[j].ToString() + ": "); Log.LogEmit(Log.SymEx, 2, outSymExprsPrintable[j].Emit); Log.Out(Log.Normal, ""); Log.Out(Log.SymEx, "\t" + outputVars[j + 1].ToString() + ": "); Log.LogEmit(Log.SymEx, 2, outSymExprsPrintable[j + 1].Emit); Log.Out(Log.Normal, ""); } } } } Expr disjunctionDiffCond = Expr.False; if (Options.PropagateSingleDifference && errors.Count > 1) { var t = constraintExprs.First(); disjunctionDiffCond = Expr.Or(disjunctionDiffCond, constraintExprs.First()); } else { foreach (Expr currentExpr in constraintExprs) { disjunctionDiffCond = Expr.Or(disjunctionDiffCond, currentExpr); } } ProcessCounterexampleForDiffInline(errors, vtLeftProcImpl, vtRightProcImpl, disjunctionDiffCond); }
public override void Emit(TokenTextWriter stream, int level) { //Contract.Requires(stream != null); stream.WriteLine(); stream.WriteLine("{0}[]", Indent(level)); foreach (RE/*!*/ r in rs) { Contract.Assert(r != null); r.Emit(stream, level + 1); } }
public override void Emit(TokenTextWriter stream, int level) { stream.Write(level, "while ("); if (Guard == null) { stream.Write("*"); } else { Guard.Emit(stream); } stream.WriteLine(")"); foreach (PredicateCmd inv in Invariants) { if (inv is AssumeCmd) { stream.Write(level + 1, "free invariant "); } else { stream.Write(level + 1, "invariant "); } Cmd.EmitAttributes(stream, inv.Attributes); inv.Expr.Emit(stream); stream.WriteLine(";"); } stream.WriteLine(level, "{"); Body.Emit(stream, level + 1); stream.WriteLine(level, "}"); }
public override void Emit(TokenTextWriter stream, int level) { //Contract.Requires(stream != null); stream.WriteLine(this, level, "yield;"); }
public override void Emit(TokenTextWriter stream, int level) { //Contract.Requires(stream != null); Contract.Assume(this.labelNames != null); stream.Write(this, level, "goto "); if (CommandLineOptions.Clo.PrintWithUniqueASTIds) { if (labelTargets == null) { string sep = ""; foreach (string name in labelNames) { stream.Write("{0}{1}^^{2}", sep, "NoDecl", name); sep = ", "; } } else { string sep = ""; foreach (Block/*!*/ b in labelTargets) { Contract.Assert(b != null); stream.Write("{0}h{1}^^{2}", sep, b.GetHashCode(), b.Label); sep = ", "; } } } else { labelNames.Emit(stream); } stream.WriteLine(";"); }
public override void Emit(TokenTextWriter stream, int level) { //Contract.Requires(stream != null); stream.Write(this, level, "assume "); EmitAttributes(stream, Attributes); this.Expr.Emit(stream); stream.WriteLine(";"); }
public override void Emit(TokenTextWriter stream, int level) { //Contract.Requires(stream != null); stream.Write(this, level, "havoc "); Vars.Emit(stream, true); stream.WriteLine(";"); }
public void Emit(TokenTextWriter stream, int level) { Contract.Requires(stream != null); stream.WriteLine(); stream.WriteLine( this, level, "{0}:{1}", CommandLineOptions.Clo.PrintWithUniqueASTIds ? String.Format("h{0}^^{1}", this.GetHashCode(), this.Label) : this.Label, this.widenBlock ? " // cut point" : ""); foreach (Cmd/*!*/ c in this.Cmds) { Contract.Assert(c != null); c.Emit(stream, level + 1); } Contract.Assume(this.TransferCmd != null); this.TransferCmd.Emit(stream, level + 1); }
public override void Emit(TokenTextWriter stream, int level) { stream.Write(level, "if ("); IfCmd/*!*/ ifcmd = this; while (true) { if (ifcmd.Guard == null) { stream.Write("*"); } else { ifcmd.Guard.Emit(stream); } stream.WriteLine(")"); stream.WriteLine(level, "{"); ifcmd.thn.Emit(stream, level + 1); stream.WriteLine(level, "}"); if (ifcmd.elseIf != null) { stream.Write(level, "else if ("); ifcmd = ifcmd.elseIf; continue; } else if (ifcmd.elseBlock != null) { stream.WriteLine(level, "else"); stream.WriteLine(level, "{"); ifcmd.elseBlock.Emit(stream, level + 1); stream.WriteLine(level, "}"); } break; } }
public override void Emit(TokenTextWriter stream, int level) { //Contract.Requires(stream != null); stream.Write(this, level, ""); if (IsFree) { stream.Write("free "); } if (IsAsync) { stream.Write("async "); } stream.Write("call "); EmitAttributes(stream, Attributes); string sep = ""; if (Outs.Count > 0) { foreach (Expr arg in Outs) { stream.Write(sep); sep = ", "; if (arg == null) { stream.Write("*"); } else { arg.Emit(stream); } } stream.Write(" := "); } stream.Write(TokenTextWriter.SanitizeIdentifier(callee)); stream.Write("("); sep = ""; foreach (Expr arg in Ins) { stream.Write(sep); sep = ", "; if (arg == null) { stream.Write("*"); } else { arg.Emit(stream); } } stream.WriteLine(");"); base.Emit(stream, level); }
public override void Emit(TokenTextWriter stream, int level) { //Contract.Requires(stream != null); stream.Write(this, level, "var "); EmitVitals(stream, level, true); stream.WriteLine(";"); }
public override void Emit(TokenTextWriter stream, int level) { //Contract.Requires(stream != null); stream.Write(this, level, "procedure "); EmitAttributes(stream); stream.Write(this, level, "{0}", TokenTextWriter.SanitizeIdentifier(this.Name)); EmitSignature(stream, false); stream.WriteLine(";"); level++; foreach (Requires/*!*/ e in this.Requires) { Contract.Assert(e != null); e.Emit(stream, level); } if (this.Modifies.Count > 0) { stream.Write(level, "modifies "); this.Modifies.Emit(stream, false); stream.WriteLine(";"); } foreach (Ensures/*!*/ e in this.Ensures) { Contract.Assert(e != null); e.Emit(stream, level); } if (!CommandLineOptions.Clo.IntraproceduralInfer) { for (int s = 0; s < this.Summary.Count; s++) { ProcedureSummaryEntry/*!*/ entry = cce.NonNull(this.Summary[s]); stream.Write(level + 1, "// "); stream.WriteLine(); } } stream.WriteLine(); stream.WriteLine(); }
// prints the list of statements, not the surrounding curly braces public void Emit(TokenTextWriter stream, int level) { Contract.Requires(stream != null); bool needSeperator = false; foreach (BigBlock b in BigBlocks) { Contract.Assert(b != null); Contract.Assume(cce.IsPeerConsistent(b)); if (needSeperator) { stream.WriteLine(); } b.Emit(stream, level); needSeperator = true; } }
public override void Emit(TokenTextWriter stream, int level) { //Contract.Requires(stream != null); if (Comment != null) { stream.WriteLine(this, level, "// " + Comment); } stream.Write(this, level, "function "); EmitAttributes(stream); if (Body != null && !QKeyValue.FindBoolAttribute(Attributes, "inline")) { // Boogie inlines any function whose .Body field is non-null. The parser populates the .Body field // is the :inline attribute is present, but if someone creates the Boogie file directly as an AST, then // the :inline attribute may not be there. We'll make sure it's printed, so one can see that this means // that the body will be inlined. stream.Write("{:inline} "); } if (CommandLineOptions.Clo.PrintWithUniqueASTIds) { stream.Write("h{0}^^{1}", this.GetHashCode(), TokenTextWriter.SanitizeIdentifier(this.Name)); } else { stream.Write("{0}", TokenTextWriter.SanitizeIdentifier(this.Name)); } EmitSignature(stream, true); if (Body != null) { stream.WriteLine(); stream.WriteLine("{"); stream.Write(level + 1, ""); Body.Emit(stream); stream.WriteLine(); stream.WriteLine("}"); } else { stream.WriteLine(";"); } }
public override void Emit(TokenTextWriter stream, int level) { //Contract.Requires(stream != null); if (CommandLineOptions.Clo.PrintDesugarings) { stream.WriteLine(this, level, "/*** desugaring:"); Desugaring.Emit(stream, level); stream.WriteLine(level, "**** end desugaring */"); } }
public override void Emit(TokenTextWriter stream, int level) { //Contract.Requires(stream != null); stream.Write(this, level, "type "); EmitAttributes(stream); stream.Write("{0}", TokenTextWriter.SanitizeIdentifier(Name)); for (int i = 0; i < Arity; ++i) stream.Write(" _"); stream.WriteLine(";"); }
public static void Emit(this List<Declaration/*!*/>/*!*/ decls, TokenTextWriter stream) { Contract.Requires(stream != null); Contract.Requires(cce.NonNullElements(decls)); bool first = true; foreach (Declaration d in decls) { if (d == null) continue; if (first) { first = false; } else { stream.WriteLine(); } d.Emit(stream, 0); } }
public override void Emit(TokenTextWriter stream, int level) { //Contract.Requires(stream != null); stream.Write(this, level, "return "); this.Expr.Emit(stream); stream.WriteLine(";"); }
public override void Emit(TokenTextWriter stream, int level) { //Contract.Requires(stream != null); stream.Write(this, level, "type "); EmitAttributes(stream); stream.Write("{0}", TokenTextWriter.SanitizeIdentifier(Name)); if (TypeParameters.Count > 0) stream.Write(" "); TypeParameters.Emit(stream, " "); stream.Write(" = "); Body.Emit(stream); stream.WriteLine(";"); }
public override void Emit(TokenTextWriter stream, int level) { //Contract.Requires(stream != null); stream.WriteLine(this, level, "{"); foreach (Variable/*!*/ v in Locals) { Contract.Assert(v != null); v.Emit(stream, level + 1); } foreach (Cmd/*!*/ c in Cmds) { Contract.Assert(c != null); c.Emit(stream, level + 1); } stream.WriteLine(level, "}"); }
public override void Emit(TokenTextWriter stream, int level) { //Contract.Requires(stream != null); if (Comment != null) { stream.WriteLine(this, level, "// " + Comment); } stream.Write(this, level, "axiom "); EmitAttributes(stream); this.Expr.Emit(stream); stream.WriteLine(";"); }