Esempio n. 1
0
    static int InjectAssertionInBpl(string bplFileName, string fileName, int lineNumber, int columnNumber) {
      Bpl.CommandLineOptions.Install(new Bpl.CommandLineOptions());
      Bpl.CommandLineOptions.Clo.DoModSetAnalysis = true;
      var returnValue = errorValue; 
      Bpl.Program program;
      Bpl.Parser.Parse(bplFileName, new List<string>(), out program);
      int errorCount = program.Resolve();
      if (errorCount != 0) {
        Console.WriteLine("{0} name resolution errors detected in {1}", errorCount, bplFileName);
        return returnValue;
      }
      errorCount = program.Typecheck();
      if (errorCount != 0) {
        Console.WriteLine("{0} type checking errors detected in {1}", errorCount, bplFileName);
        return returnValue;
      }

      GetMeHereBplInjector bplInjector = new GetMeHereBplInjector(fileName, lineNumber, columnNumber);
      bplInjector.Visit(program);
      using (Bpl.TokenTextWriter writer = new Bpl.TokenTextWriter(bplFileName)) {
        Bpl.CommandLineOptions.Clo.PrintInstrumented = true;
        program.Emit(writer);
      }
      return returnValue;
    }
Esempio n. 2
0
            public Expr Rename(Expr e)
            {
                Expr ne;

                if (!cache.TryGetValue(e, out ne))
                {
                    boundVarCount = 0;
                    freeVarCount  = 0;
                    freeVarMap    = new Dictionary <Variable, FreeVariable>();

                    ne       = VisitExpr(e);
                    cache[e] = ne;
#if DEBUG_ALPHA_RENAMING
                    var wr = new TokenTextWriter("<console>", Console.Out, true);
                    Console.Write("nm( ");
                    e.Emit(wr);
                    Console.WriteLine(" )");
                    Console.Write("  = ");
                    ne.Emit(wr);
                    Console.WriteLine("");
                    Console.WriteLine("h = " + ne.GetHashCode());
#endif
                }
                return(ne);
            }
Esempio n. 3
0
        public override void Emit(TokenTextWriter stream, int contextBindingStrength, bool fragileContext)
        {
            //Contract.Requires(stream != null);
            stream.push();
            stream.Write(this, "(var ");

            string sep = "";

            stream.push();
            foreach (var v in Dummies)
            {
                stream.Write("{0}", sep);
                v.EmitVitals(stream, 0, true, false);
                sep = ", ";
                stream.sep();
            }
            stream.pop();

            stream.Write(" := ");
            this.Rhss.Emit(stream);
            stream.Write("; ");
            stream.sep();
            for (QKeyValue kv = this.Attributes; kv != null; kv = kv.Next)
            {
                kv.Emit(stream);
                stream.Write(" ");
            }
            stream.sep();

            this.Body.Emit(stream);
            stream.Write(")");
            stream.pop();
        }
Esempio n. 4
0
    public static Program Desugar(Program program, out List<Expr /*!*/> /*!*/ axioms,
      out List<Function /*!*/> /*!*/ functions)
    {
      Contract.Requires(program != null);
      Contract.Ensures(cce.NonNullElements(Contract.ValueAtReturn(out functions)));
      Contract.Ensures(cce.NonNullElements(Contract.ValueAtReturn(out axioms)));
      Contract.Ensures(Contract.Result<Program>() != null);
      LambdaVisitor v = new LambdaVisitor();
      program = v.VisitProgram(program);
      axioms = v.lambdaAxioms;
      functions = v.lambdaFunctions;
      if (CommandLineOptions.Clo.TraceVerify)
      {
        Console.WriteLine("Desugaring of lambda expressions produced {0} functions and {1} axioms:", functions.Count,
          axioms.Count);
        TokenTextWriter wr = new TokenTextWriter("<console>", Console.Out, /*pretty=*/ false);
        foreach (Function f in functions)
        {
          f.Emit(wr, 0);
        }

        foreach (Expr ax in axioms)
        {
          ax.Emit(wr);
          Console.WriteLine();
        }
      }

      return program;
    }
Esempio n. 5
0
        static int InjectAssertionInBpl(string bplFileName, string fileName, int lineNumber, int columnNumber)
        {
            Bpl.CommandLineOptions.Install(new Bpl.CommandLineOptions());
            Bpl.CommandLineOptions.Clo.DoModSetAnalysis = true;
            var returnValue = errorValue;

            Bpl.Program program;
            Bpl.Parser.Parse(bplFileName, new List <string>(), out program);
            int errorCount = program.Resolve();

            if (errorCount != 0)
            {
                Console.WriteLine("{0} name resolution errors detected in {1}", errorCount, bplFileName);
                return(returnValue);
            }
            errorCount = program.Typecheck();
            if (errorCount != 0)
            {
                Console.WriteLine("{0} type checking errors detected in {1}", errorCount, bplFileName);
                return(returnValue);
            }

            GetMeHereBplInjector bplInjector = new GetMeHereBplInjector(fileName, lineNumber, columnNumber);

            bplInjector.Visit(program);
            using (Bpl.TokenTextWriter writer = new Bpl.TokenTextWriter(bplFileName)) {
                Bpl.CommandLineOptions.Clo.PrintInstrumented = true;
                program.Emit(writer);
            }
            return(returnValue);
        }
Esempio n. 6
0
        public void Test()
        {
            ErrorReporter reporter = new ConsoleErrorReporter();
            var           options  = new DafnyOptions(reporter);

            options.DafnyPrelude = "../../../../../Binaries/DafnyPrelude.bpl";
            DafnyOptions.Install(options);

            var        programString = @"trait Trait<A, B> { }";
            ModuleDecl module        = new LiteralModuleDecl(new DefaultModuleDecl(), null);

            Microsoft.Dafny.Type.ResetScopes();
            BuiltIns builtIns = new BuiltIns();

            Parser.Parse(programString, "virtual", "virtual", module, builtIns, reporter);
            var dafnyProgram = new Program("programName", module, builtIns, reporter);

            Main.Resolve(dafnyProgram, reporter);
            foreach (var prog in Translator.Translate(dafnyProgram, dafnyProgram.reporter))
            {
                var writer      = new StringWriter();
                var tokenWriter = new Bpl.TokenTextWriter("virtual", writer, true);
                prog.Item2.Emit(tokenWriter);
                var parseErrorCount = Bpl.Parser.Parse(writer.ToString(), "virtualBoogie", out var boogieProgram);
                Assert.Equal(0, parseErrorCount);
            }
        }
Esempio n. 7
0
        public void Emit(TokenTextWriter stream)
        {
            Contract.Requires(stream != null);
            stream.Write("{:");
            stream.Write(Key);
            string sep = " ";

            foreach (object p in Params)
            {
                stream.Write(sep);
                sep = ", ";
                if (p is string)
                {
                    stream.Write("\"");
                    stream.Write((string)p);
                    stream.Write("\"");
                }
                else
                {
                    ((Expr)p).Emit(stream);
                }
            }

            stream.Write("}");
        }
Esempio n. 8
0
 protected override void EmitTriggers(TokenTextWriter stream)
 {
     //Contract.Requires(stream != null);
     for (Trigger tr = this.Triggers; tr != null; tr = tr.Next)
     {
         tr.Emit(stream);
         stream.Write(" ");
     }
 }
Esempio n. 9
0
        private static void init()
        {
            if (noDebuggingOutput)
            {
                return;
            }

            if (debugOut == null)
            {
                debugOut = new TokenTextWriter("corraldebug.out");
            }
        }
Esempio n. 10
0
        private string Format(string msg, params object[] args)
        {
            Contract.Requires(msg != null);
            Contract.Ensures(Contract.Result <string>() != null);
            if (System.Type.GetType("Mono.Runtime") != null)
            {
                // MONO
                // something in mono seems to be broken so that calling
                // NamedDeclarations.ToString (and similar ToString methods)
                // causes a stack overflow. We therefore convert those to
                // strings by hand
                object[] fixedArgs = new object[cce.NonNull(args).Length];
                for (int i = 0; i < args.Length; ++i)
                {
                    if (args[i] is NamedDeclaration)
                    {
                        fixedArgs[i] = cce.NonNull((NamedDeclaration)args[i]).Name;
                    }
                    else if (args[i] is Type)
                    {
                        System.IO.StringWriter buffer = new System.IO.StringWriter();
                        using (TokenTextWriter stream =
                                   new TokenTextWriter("<buffer>", buffer, /*setTokens=*/ false, /*pretty=*/ false))
                        {
                            cce.NonNull((Type)args[i]).Emit(stream);
                        }

                        fixedArgs[i] = buffer.ToString();
                    }
                    else if (args[i] is Expr)
                    {
                        System.IO.StringWriter buffer = new System.IO.StringWriter();
                        using (TokenTextWriter stream =
                                   new TokenTextWriter("<buffer>", buffer, /*setTokens=*/ false, /*pretty=*/ false))
                        {
                            cce.NonNull((Expr /*!*/)args[i]).Emit(stream, 0, false);
                        }

                        fixedArgs[i] = buffer.ToString();
                    }
                    else
                    {
                        fixedArgs[i] = args[i];
                    }
                }

                args = fixedArgs;
            }

            return(string.Format(msg, args));
        }
Esempio n. 11
0
        public void Emit(TokenTextWriter stream)
        {
            Contract.Requires(stream != null);
            stream.SetToken(this);
            Contract.Assert(this.Tr.Count >= 1);
            string /*!*/ sep = Pos ? "{ " : "{:nopats ";

            foreach (Expr /*!*/ e in this.Tr)
            {
                Contract.Assert(e != null);
                stream.Write(sep);
                sep = ", ";
                e.Emit(stream);
            }
            stream.Write(" }");
        }
Esempio n. 12
0
        public override void Emit(TokenTextWriter stream, int contextBindingStrength, bool fragileContext)
        {
            //Contract.Requires(stream != null);
            stream.Write(this, "({0}", Kind.ToString().ToLower());
            this.EmitTypeHint(stream);
            Type.EmitOptionalTypeParams(stream, TypeParameters);
            stream.Write(this, " ");
            this.Dummies.Emit(stream, true);
            stream.Write(" :: ");
            for (QKeyValue kv = this.Attributes; kv != null; kv = kv.Next)
            {
                kv.Emit(stream);
                stream.Write(" ");
            }
            this.EmitTriggers(stream);

            this.Body.Emit(stream);
            stream.Write(")");
        }
Esempio n. 13
0
 public static int TranslateAssemblyAndWriteOutput(List <string> assemblyNames, HeapFactory heapFactory, Options options, List <Regex> exemptionList, bool whiteList)
 {
     Contract.Requires(assemblyNames != null);
     Contract.Requires(heapFactory != null);
     try {
         var pgm      = TranslateAssembly(assemblyNames, heapFactory, options, exemptionList, whiteList);
         var fileName = assemblyNames[0];
         fileName = Path.GetFileNameWithoutExtension(fileName);
         string outputFileName = fileName + ".bpl";
         using (var writer = new Microsoft.Boogie.TokenTextWriter(outputFileName)) {
             Prelude.Emit(writer);
             pgm.Emit(writer);
             writer.Close();
         }
         return(0);          // success
     } catch (Exception e) { // swallow everything and just return an error code
         Console.WriteLine("The byte-code translator failed: {0}", e.Message);
         Console.WriteLine("Stack trace: {0}", e.StackTrace);
         return(-1);
     }
 }
Esempio n. 14
0
      /// <summary>
      /// Performs lambda lifting (see <see cref="LambdaHelper.ExpandLambdas"/>) by replacing the lambda's
      /// free variables with bound ones.
      /// </summary>
      /// <param name="lambda">A lambda expression
      ///   <code>(lambda x1: T1 ... x_n: T_n :: t)</code>
      /// where <c>t</c> contains the free variables <c>y1</c>, ..., <c>y_m</c>.
      /// </param>
      /// <returns>
      /// <list type="bullet">
      ///   <item>
      ///     A function application <c>f(y1, ..., y_m)</c> where <c>f</c>'s body is defined to be the result of
      ///     replacing the free variables <c>y1</c>, ..., <c>y_m</c> in <c>t</c> with bound variables
      ///     <c>b1</c>, ..., <c>b_m</c>.
      ///   </item>
      ///   <item>
      ///     Adds a definition and axiom for <c>f</c> to <see cref="lambdaFunctions"/> and <see cref="lambdaAxioms"/>.
      ///     Memoizes <c>f</c> as the lifted lambda for <para>lambda</para>.
      ///   </item>
      /// </list>
      /// </returns>
      private Expr LiftLambdaFreeVars(LambdaExpr lambda)
      {
        // We start by getting rid of any use of "old" inside the lambda.  This is done as follows.
        // For each variable "g" occurring inside lambda as "old(... g ...)", create a new name "og".
        // Replace each old occurrence of "g" with "og", removing the enclosing "old" wrappers.
        var oldFinder = new OldFinder();
        oldFinder.Visit(lambda);
        var oldSubst = new Dictionary<Variable, Expr>(); // g -> g0
        var callOldMapping = new Dictionary<Variable, Expr>(); // g0 -> old(g)
        foreach (var v in oldFinder.FreeOldVars)
        {
          var g = v as GlobalVariable;
          if (g != null)
          {
            var g0 = new GlobalVariable(g.tok, new TypedIdent(g.tok, g.TypedIdent.Name + "@old", g.TypedIdent.Type));
            oldSubst.Add(g, new IdentifierExpr(g0.tok, g0));
            callOldMapping.Add(g0, new OldExpr(g0.tok, new IdentifierExpr(g.tok, g)));
          }
        }

        var lambdaBody = Substituter.ApplyReplacingOldExprs(
          Substituter.SubstitutionFromDictionary(new Dictionary<Variable, Expr>()),
          Substituter.SubstitutionFromDictionary(oldSubst),
          lambda.Body);
        var lambdaAttrs = Substituter.ApplyReplacingOldExprs(
          Substituter.SubstitutionFromDictionary(new Dictionary<Variable, Expr>()),
          Substituter.SubstitutionFromDictionary(oldSubst),
          lambda.Attributes);

        if (0 < CommandLineOptions.Clo.VerifySnapshots &&
            QKeyValue.FindStringAttribute(lambdaAttrs, "checksum") == null)
        {
          // Attach a dummy checksum to avoid issues in the dependency analysis.
          var checksumAttr = new QKeyValue(lambda.tok, "checksum", new List<object> {"lambda expression"}, null);
          if (lambdaAttrs == null)
          {
            lambdaAttrs = checksumAttr;
          }
          else
          {
            lambdaAttrs.AddLast(checksumAttr);
          }
        }

        // this is ugly, the output will depend on hashing order
        var subst = new Dictionary<Variable, Expr>();
        var substFnAttrs = new Dictionary<Variable, Expr>();
        var formals = new List<Variable>();
        var callArgs = new List<Expr>();
        var axCallArgs = new List<Expr>();
        var dummies = new List<Variable>(lambda.Dummies);
        var freeTypeVars = new List<TypeVariable>();
        var fnTypeVarActuals = new List<Type /*!*/>();
        var freshTypeVars = new List<TypeVariable>(); // these are only used in the lambda@n function's definition

        // compute the free variables of the lambda expression, but with lambdaBody instead of lambda.Body
        Set freeVars = new Set();
        BinderExpr.ComputeBinderFreeVariables(lambda.TypeParameters, lambda.Dummies, lambdaBody, null, lambdaAttrs,
          freeVars);

        foreach (object o in freeVars)
        {
          // 'o' is either a Variable or a TypeVariable.
          if (o is Variable)
          {
            var v = o as Variable;
            var ti = new TypedIdent(v.TypedIdent.tok, v.TypedIdent.Name, v.TypedIdent.Type);
            var f = new Formal(v.tok, ti, true);
            formals.Add(f);
            substFnAttrs.Add(v, new IdentifierExpr(f.tok, f));
            var b = new BoundVariable(v.tok, ti);
            dummies.Add(b);
            if (callOldMapping.ContainsKey(v))
            {
              callArgs.Add(callOldMapping[v]);
            }
            else
            {
              callArgs.Add(new IdentifierExpr(v.tok, v));
            }

            Expr id = new IdentifierExpr(b.tok, b);
            subst.Add(v, id);
            axCallArgs.Add(id);
          }
          else
          {
            var tv = (TypeVariable) o;
            freeTypeVars.Add(tv);
            fnTypeVarActuals.Add(tv);
            freshTypeVars.Add(new TypeVariable(tv.tok, tv.Name));
          }
        }

        var sw = new System.IO.StringWriter();
        var wr = new TokenTextWriter(sw, true);
        lambda.Emit(wr);
        string lam_str = sw.ToString();

        FunctionCall fcall;
        IToken tok = lambda.tok;
        Formal res = new Formal(tok, new TypedIdent(tok, TypedIdent.NoName, cce.NonNull(lambda.Type)), false);

        if (liftedLambdas.TryGetValue(lambda, out fcall))
        {
          if (CommandLineOptions.Clo.TraceVerify)
          {
            Console.WriteLine("Old lambda: {0}", lam_str);
          }
        }
        else
        {
          if (CommandLineOptions.Clo.TraceVerify)
          {
            Console.WriteLine("New lambda: {0}", lam_str);
          }

          Function fn = new Function(tok, FreshLambdaFunctionName(), freshTypeVars, formals, res,
            "auto-generated lambda function",
            Substituter.Apply(Substituter.SubstitutionFromDictionary(substFnAttrs), lambdaAttrs));
          fn.OriginalLambdaExprAsString = lam_str;

          fcall = new FunctionCall(new IdentifierExpr(tok, fn.Name));
          fcall.Func = fn; // resolve here
          liftedLambdas[lambda] = fcall;

          List<Expr /*!*/> selectArgs = new List<Expr /*!*/>();
          foreach (Variable /*!*/ v in lambda.Dummies)
          {
            Contract.Assert(v != null);
            selectArgs.Add(new IdentifierExpr(v.tok, v));
          }

          NAryExpr axcall = new NAryExpr(tok, fcall, axCallArgs);
          axcall.Type = res.TypedIdent.Type;
          axcall.TypeParameters = SimpleTypeParamInstantiation.From(freeTypeVars, fnTypeVarActuals);
          NAryExpr select = Expr.Select(axcall, selectArgs);
          select.Type = lambdaBody.Type;
          List<Type /*!*/> selectTypeParamActuals = new List<Type /*!*/>();
          List<TypeVariable> forallTypeVariables = new List<TypeVariable>();
          foreach (TypeVariable /*!*/ tp in lambda.TypeParameters)
          {
            Contract.Assert(tp != null);
            selectTypeParamActuals.Add(tp);
            forallTypeVariables.Add(tp);
          }

          forallTypeVariables.AddRange(freeTypeVars);
          select.TypeParameters = SimpleTypeParamInstantiation.From(lambda.TypeParameters, selectTypeParamActuals);

          Expr bb = Substituter.Apply(Substituter.SubstitutionFromDictionary(subst), lambdaBody);
          NAryExpr body = Expr.Eq(select, bb);
          body.Type = Type.Bool;
          body.TypeParameters = SimpleTypeParamInstantiation.EMPTY;
          Trigger trig = new Trigger(select.tok, true, new List<Expr> {select});

          lambdaFunctions.Add(fn);
          lambdaAxioms.Add(new ForallExpr(tok, forallTypeVariables, dummies,
            Substituter.Apply(Substituter.SubstitutionFromDictionary(subst), lambdaAttrs),
            trig, body));
        }

        NAryExpr call = new NAryExpr(tok, fcall, callArgs);
        call.Type = res.TypedIdent.Type;
        call.TypeParameters = SimpleTypeParamInstantiation.From(freeTypeVars, fnTypeVarActuals);

        return call;
      }
Esempio n. 15
0
    public static int Inline(string bplFileName) {
      Bpl.CommandLineOptions options = new Bpl.CommandLineOptions();
      Bpl.CommandLineOptions.Install(options);
      Bpl.CommandLineOptions.Clo.DoModSetAnalysis = true;
      Bpl.Program program;
      string _bplFileName = "_" + bplFileName;

      Bpl.Parser.Parse(_bplFileName, new List<string>(), out program);
      int errorCount = program.Resolve();
      if (errorCount != 0) {
        Console.WriteLine("{0} name resolution errors detected in {1}", errorCount, _bplFileName);
        return -1;
      }
      errorCount = program.Typecheck();
      if (errorCount != 0) {
        Console.WriteLine("{0} type checking errors detected in {1}", errorCount, _bplFileName);
        return -1;
      }
      bool inline = false;
      foreach (var d in program.TopLevelDeclarations) {
        if (d.FindExprAttribute("inline") != null) {
          inline = true;
        }
      }
      if (inline) {
        foreach (var d in program.TopLevelDeclarations) {
          var impl = d as Bpl.Implementation;
          if (impl != null) {
            impl.OriginalBlocks = impl.Blocks;
            impl.OriginalLocVars = impl.LocVars;
          }
        }
        foreach (var d in program.TopLevelDeclarations) {
          var impl = d as Bpl.Implementation;
          if (impl != null && !impl.SkipVerification) {
            Bpl.Inliner.ProcessImplementation(program, impl);
          }
        }
        foreach (var d in program.TopLevelDeclarations) {
          var impl = d as Bpl.Implementation;
          if (impl != null) {
            impl.OriginalBlocks = null;
            impl.OriginalLocVars = null;
          }
        }
      }
      Microsoft.Boogie.TokenTextWriter writer = new Microsoft.Boogie.TokenTextWriter(bplFileName);
      options.PrintInstrumented = true;
      program.Emit(writer);
      writer.Close();
      return 0;
    }
Esempio n. 16
0
 public static int TranslateAssemblyAndWriteOutput(List<string> assemblyNames, HeapFactory heapFactory, Options options, List<Regex> exemptionList, bool whiteList) {
   Contract.Requires(assemblyNames != null);
   Contract.Requires(heapFactory != null);
   try {
     var pgm = TranslateAssembly(assemblyNames, heapFactory, options, exemptionList, whiteList);
     var fileName = assemblyNames[0];
     fileName = Path.GetFileNameWithoutExtension(fileName);
     string outputFileName = fileName + ".bpl";
     using (var writer = new Microsoft.Boogie.TokenTextWriter(outputFileName)) {
       Prelude.Emit(writer);
       pgm.Emit(writer);
       writer.Close();
     }
     return 0; // success
   } catch (Exception e) { // swallow everything and just return an error code
     Console.WriteLine("The byte-code translator failed: {0}", e.Message);
     // Console.WriteLine("Stack trace: {0}", e.StackTrace);
     return -1;
   }
 }
Esempio n. 17
0
 protected virtual void EmitTriggers(TokenTextWriter stream)
 {
     Contract.Requires(stream != null);
 }
Esempio n. 18
0
        public override Cmd VisitCallCmd(CallCmd node)
        {
            var result = base.VisitCallCmd(node);

            var oldProc = programInCachedSnapshot.FindProcedure(node.Proc.Name);

            if (oldProc != null &&
                oldProc.DependencyChecksum != node.Proc.DependencyChecksum &&
                node.AssignedAssumptionVariable == null)
            {
                var  before = new List <Cmd>();
                var  beforePreconditionCheck = new List <Cmd>();
                var  after       = new List <Cmd>();
                var  axioms      = new List <Axiom>();
                Expr assumedExpr = new LiteralExpr(Token.NoToken, false);
                // TODO(wuestholz): Try out two alternatives: only do this for low priority implementations or not at all.
                var canUseSpecs = DependencyCollector.CanExpressOldSpecs(oldProc, Program);
                if (canUseSpecs && oldProc.SignatureEquals(node.Proc))
                {
                    var desugaring = node.Desugaring;
                    Contract.Assert(desugaring != null);
                    var precond = node.CheckedPrecondition(oldProc, Program, e => FunctionExtractor.Extract(e, Program, axioms));
                    if (precond != null)
                    {
                        var assume = new AssumeCmd(node.tok, precond,
                                                   new QKeyValue(Token.NoToken, "precondition_previous_snapshot", new List <object>(), null));
                        assume.IrrelevantForChecksumComputation = true;
                        beforePreconditionCheck.Add(assume);
                    }

                    var unmods = node.UnmodifiedBefore(oldProc);
                    var eqs    = new List <Expr>();
                    foreach (var unmod in unmods)
                    {
                        var oldUnmod = new LocalVariable(Token.NoToken,
                                                         new TypedIdent(Token.NoToken, string.Format("{0}##old##{1}", unmod.Name, FreshTemporaryVariableName),
                                                                        unmod.Type));
                        var lhs = new SimpleAssignLhs(Token.NoToken, new IdentifierExpr(Token.NoToken, oldUnmod));
                        var rhs = new IdentifierExpr(Token.NoToken, unmod.Decl);
                        var cmd = new AssignCmd(Token.NoToken, new List <AssignLhs> {
                            lhs
                        }, new List <Expr> {
                            rhs
                        });
                        cmd.IrrelevantForChecksumComputation = true;
                        before.Add(cmd);
                        var eq = LiteralExpr.Eq(new IdentifierExpr(Token.NoToken, oldUnmod),
                                                new IdentifierExpr(Token.NoToken, unmod.Decl));
                        eq.Type           = Type.Bool;
                        eq.TypeParameters = SimpleTypeParamInstantiation.EMPTY;
                        eqs.Add(eq);
                    }

                    var mods     = node.ModifiedBefore(oldProc);
                    var oldSubst = new Dictionary <Variable, Expr>();
                    foreach (var mod in mods)
                    {
                        var oldMod = new LocalVariable(Token.NoToken,
                                                       new TypedIdent(Token.NoToken, string.Format("{0}##old##{1}", mod.Name, FreshTemporaryVariableName),
                                                                      mod.Type));
                        oldSubst[mod.Decl] = new IdentifierExpr(Token.NoToken, oldMod);
                        var lhs = new SimpleAssignLhs(Token.NoToken, new IdentifierExpr(Token.NoToken, oldMod));
                        var rhs = new IdentifierExpr(Token.NoToken, mod.Decl);
                        var cmd = new AssignCmd(Token.NoToken, new List <AssignLhs> {
                            lhs
                        }, new List <Expr> {
                            rhs
                        });
                        cmd.IrrelevantForChecksumComputation = true;
                        before.Add(cmd);
                    }

                    assumedExpr = node.Postcondition(oldProc, eqs, oldSubst, Program,
                                                     e => FunctionExtractor.Extract(e, Program, axioms));
                    if (assumedExpr == null)
                    {
                        assumedExpr = new LiteralExpr(Token.NoToken, true);
                    }
                }

                if (assumedExpr != null)
                {
                    var lv = new LocalVariable(Token.NoToken,
                                               new TypedIdent(Token.NoToken, string.Format("a##cached##{0}", FreshAssumptionVariableName), Type.Bool),
                                               new QKeyValue(Token.NoToken, "assumption", new List <object>(), null));
                    node.AssignedAssumptionVariable = lv;
                    currentImplementation.InjectAssumptionVariable(lv, !canUseSpecs);
                    var lhs     = new SimpleAssignLhs(Token.NoToken, new IdentifierExpr(Token.NoToken, lv));
                    var rhs     = LiteralExpr.And(new IdentifierExpr(Token.NoToken, lv), assumedExpr);
                    var assumed = new AssignCmd(node.tok, new List <AssignLhs> {
                        lhs
                    }, new List <Expr> {
                        rhs
                    });
                    assumed.IrrelevantForChecksumComputation = true;
                    after.Add(assumed);
                }

                node.ExtendDesugaring(before, beforePreconditionCheck, after);
                if (CommandLineOptions.Clo.TraceCachingForTesting || CommandLineOptions.Clo.TraceCachingForBenchmarking)
                {
                    using (var tokTxtWr = new TokenTextWriter("<console>", Console.Out, false, false))
                    {
                        var loc = node.tok != null && node.tok != Token.NoToken
              ? string.Format("{0}({1},{2})", node.tok.filename, node.tok.line, node.tok.col)
              : "<unknown location>";
                        Console.Out.WriteLine("Processing call to procedure {0} in implementation {1} (at {2}):", node.Proc.Name,
                                              currentImplementation.Name, loc);
                        foreach (var a in axioms)
                        {
                            Console.Out.Write("  >>> added axiom: ");
                            a.Expr.Emit(tokTxtWr);
                            Console.Out.WriteLine();
                        }

                        foreach (var b in before)
                        {
                            Console.Out.Write("  >>> added before: ");
                            b.Emit(tokTxtWr, 0);
                        }

                        foreach (var b in beforePreconditionCheck)
                        {
                            Console.Out.Write("  >>> added before precondition check: ");
                            b.Emit(tokTxtWr, 0);
                        }

                        foreach (var a in after)
                        {
                            Console.Out.Write("  >>> added after: ");
                            a.Emit(tokTxtWr, 0);
                        }
                    }
                }
            }

            return(result);
        }
Esempio n. 19
0
        public Implementation Inject(Implementation implementation, Program programInCachedSnapshot)
        {
            Contract.Requires(implementation != null && programInCachedSnapshot != null);

            this.programInCachedSnapshot = programInCachedSnapshot;
            assumptionVariableCount      = 0;
            temporaryVariableCount       = 0;
            currentImplementation        = implementation;

            #region Introduce explict assumption about the precondition.

            var oldProc = programInCachedSnapshot.FindProcedure(currentImplementation.Proc.Name);
            if (oldProc != null &&
                oldProc.DependencyChecksum != currentImplementation.Proc.DependencyChecksum &&
                currentImplementation.ExplicitAssumptionAboutCachedPrecondition == null)
            {
                var  axioms      = new List <Axiom>();
                var  after       = new List <Cmd>();
                Expr assumedExpr = new LiteralExpr(Token.NoToken, false);
                var  canUseSpecs = DependencyCollector.CanExpressOldSpecs(oldProc, Program, true);
                if (canUseSpecs && oldProc.SignatureEquals(currentImplementation.Proc))
                {
                    var always = Substituter.SubstitutionFromHashtable(currentImplementation.GetImplFormalMap(), true,
                                                                       currentImplementation.Proc);
                    var forOld  = Substituter.SubstitutionFromHashtable(new Dictionary <Variable, Expr>());
                    var clauses = oldProc.Requires.Select(r =>
                                                          Substituter.FunctionCallReresolvingApply(always, forOld, r.Condition, Program));
                    var conj = Expr.And(clauses, true);
                    assumedExpr = conj != null
            ? FunctionExtractor.Extract(conj, Program, axioms)
            : new LiteralExpr(Token.NoToken, true);
                }

                if (assumedExpr != null)
                {
                    var lv = new LocalVariable(Token.NoToken,
                                               new TypedIdent(Token.NoToken, string.Format("a##cached##{0}", FreshAssumptionVariableName), Type.Bool),
                                               new QKeyValue(Token.NoToken, "assumption", new List <object>(), null));
                    currentImplementation.InjectAssumptionVariable(lv, !canUseSpecs);
                    var lhs     = new SimpleAssignLhs(Token.NoToken, new IdentifierExpr(Token.NoToken, lv));
                    var rhs     = LiteralExpr.And(new IdentifierExpr(Token.NoToken, lv), assumedExpr);
                    var assumed = new AssignCmd(currentImplementation.tok, new List <AssignLhs> {
                        lhs
                    }, new List <Expr> {
                        rhs
                    });
                    assumed.IrrelevantForChecksumComputation = true;
                    currentImplementation.ExplicitAssumptionAboutCachedPrecondition = assumed;
                    after.Add(assumed);
                }

                if (CommandLineOptions.Clo.TraceCachingForTesting || CommandLineOptions.Clo.TraceCachingForBenchmarking)
                {
                    using (var tokTxtWr = new TokenTextWriter("<console>", Console.Out, false, false))
                    {
                        var loc = currentImplementation.tok != null && currentImplementation.tok != Token.NoToken
              ? string.Format("{0}({1},{2})", currentImplementation.tok.filename, currentImplementation.tok.line,
                              currentImplementation.tok.col)
              : "<unknown location>";
                        Console.Out.WriteLine("Processing implementation {0} (at {1}):", currentImplementation.Name, loc);
                        foreach (var a in axioms)
                        {
                            Console.Out.Write("  >>> added axiom: ");
                            a.Expr.Emit(tokTxtWr);
                            Console.Out.WriteLine();
                        }

                        foreach (var b in after)
                        {
                            Console.Out.Write("  >>> added after assuming the current precondition: ");
                            b.Emit(tokTxtWr, 0);
                        }
                    }
                }
            }

            #endregion

            var result = VisitImplementation(currentImplementation);
            currentImplementation        = null;
            this.programInCachedSnapshot = null;
            return(result);
        }
Esempio n. 20
0
    static int Main(string[] args)
    {
      int errorReturnValue = -1;

      #region Parse options and check for errors
      var options = new Options();
      options.Parse(args);
      if (options.HelpRequested) {
        options.PrintOptions("");
        return errorReturnValue;
      }
      if (options.HasErrors) {
        options.PrintErrorsAndExit(Console.Out);
      }
      if (!String.IsNullOrWhiteSpace(options.exemptionFile)) {
        string fileName = options.exemptionFile;
        var c = fileName[fileName.Length - 1];
        if (c == '+' || c == '-') fileName = options.exemptionFile.Remove(fileName.Length - 1);
        if (!File.Exists(fileName)) {
          Console.WriteLine("Specified exemption file '{0}' not found.", fileName);
        }
      }
      if (options.stub != null) {
        Console.WriteLine("/s is no longer used to specify stub assemblies");
        return errorReturnValue;
      }

      if (options.modelExceptions == 1 && !options.wholeProgram) {
        Console.WriteLine("can specify a precise modeling of exceptions only when doing whole program analysis");
        return errorReturnValue;
      }

      if (options.breakIntoDebugger) {
        System.Diagnostics.Debugger.Launch();
      }

      #endregion

      var assemblyNames = options.assemblies;
      if (assemblyNames == null || assemblyNames.Count == 0) {
        assemblyNames = new List<string>();
        foreach (var g in options.GeneralArguments) {
          assemblyNames.Add(g);
        }
      }

      #region If an exclusion file has been specified, read in each line as a regular expression
      List<Regex> exemptionList = null;
      bool whiteList = false;
      if (!String.IsNullOrWhiteSpace(options.exemptionFile)) {
        int i = 0;
        exemptionList = new List<Regex>();
        string fileName = options.exemptionFile;
        var c = fileName[fileName.Length - 1];
        whiteList = true;
        if (c == '+' || c == '-') {
          fileName = options.exemptionFile.Remove(fileName.Length - 1);
          if (c == '-') whiteList = false;
        }
        try {
          // Create an instance of StreamReader to read from a file.
          // The using statement also closes the StreamReader.
          using (StreamReader sr = new StreamReader(fileName)) {
            String line;
            // Read and display lines from the file until the end of 
            // the file is reached.
            while ((line = sr.ReadLine()) != null) {
              exemptionList.Add(new Regex(line));
              i++;
            }
            //Console.WriteLine("Read {0} lines from the exclusion file '{1}'.",
            //  i, options.exemptionFile);
          }
        } catch (Exception e) {
          Console.WriteLine("Something went wrong reading the exclusion file '{0}'; read in {1} lines, continuing processing.",
            fileName, i);
          Console.WriteLine(e.Message);
        }
      }
      #endregion

      try {
        HeapFactory heap;
        switch (options.heapRepresentation) {
          case Options.HeapRepresentation.splitFields:
            heap = new SplitFieldsHeap();
            break;
          case Options.HeapRepresentation.general:
            heap = new GeneralHeap();
            break;
          default:
            Console.WriteLine("Unknown setting for /heap");
            return 1;
        }

        if ((options.phoneFeedbackCode || options.phoneNavigationCode) && (options.phoneControls == null || options.phoneControls == "")) {
          Console.WriteLine("Options /phoneNavigationCode and /phoneFeedbackCode need /phoneControls option set.");
          return 1;
        }

        var pgm = TranslateAssembly(assemblyNames, heap, options, exemptionList, whiteList);
        var fileName = assemblyNames[0];
        fileName = Path.GetFileNameWithoutExtension(fileName);
        string outputFileName = fileName + ".bpl";
        // Microsoft.Boogie.TokenTextWriter writer = new Microsoft.Boogie.TokenTextWriter("_" + outputFileName);
        Microsoft.Boogie.TokenTextWriter writer = new Microsoft.Boogie.TokenTextWriter(outputFileName);
        Prelude.Emit(writer);
        pgm.Emit(writer);
        writer.Close();
        return 0;
        // return Inline(outputFileName);
      } catch (Exception e) { // swallow everything and just return an error code
        Console.WriteLine("The byte-code translator failed: {0}", e.Message);
        // Console.WriteLine("Stack trace: {0}", e.StackTrace);
        return -1;
      }
    }
Esempio n. 21
0
        static void Main(string[] args)
        {
            con = new Context();

            string
                inFileName           = null,
                unrolledFileName     = null,
                tidRewrittenFileName = null,
                expandedFileName     = null,
                annotatedFileName    = null,
                splitFileName        = null,
                yieldedFileName      = null,
                instantiatedFileName = null,
                finalFileName        = null,
                mhpFileName          = null,
                hmifFileName         = null;

            dbg = false;

            inFileName = parseCommandLine(args);

            string[] parts = inFileName.Split('.');
            if (parts.Count() == 1)
            {
                unrolledFileName     = inFileName + "_unrolled";
                hmifFileName         = inFileName + "_hmif";
                expandedFileName     = inFileName + "_expanded";
                tidRewrittenFileName = inFileName + "_tidRewritten";
                annotatedFileName    = inFileName + "_annotated";
                splitFileName        = inFileName + "_split";
                yieldedFileName      = inFileName + "_yielded";
                finalFileName        = inFileName + "_final";
                mhpFileName          = inFileName + "_mhp";
                instantiatedFileName = inFileName + "_inst";
            }
            else
            {
                string name = parts[0];
                unrolledFileName     = name + "_unrolled";
                hmifFileName         = name + "_hmif";
                expandedFileName     = name + "_expanded";
                annotatedFileName    = name + "_annotated";
                splitFileName        = name + "_split";
                yieldedFileName      = name + "_yielded";
                finalFileName        = name + "_final";
                mhpFileName          = name + "_mhp";
                instantiatedFileName = name + "_inst";
                tidRewrittenFileName = name + "_tidRewritten";
                for (int i = 1; i < parts.Count(); ++i)
                {
                    unrolledFileName     += "." + parts[i];
                    hmifFileName         += "." + parts[i];
                    expandedFileName     += "." + parts[i];
                    annotatedFileName    += "." + parts[i];
                    splitFileName        += "." + parts[i];
                    yieldedFileName      += "." + parts[i];
                    finalFileName        += "." + parts[i];
                    tidRewrittenFileName += "." + parts[i];
                    mhpFileName          += "." + parts[i];
                    instantiatedFileName += "." + parts[i];
                }
            }

            var tmpFileName = "og__tmp.bpl";

            ExecutionEngine.printer = new ConsolePrinter();
            //CommanLineOptions will control how boogie parses the program and gives us the IR
            CommandLineOptions.Install(new CommandLineOptions());
            CommandLineOptions.Clo.Parse(new string[] { });
            CommandLineOptions.Clo.PrintInstrumented         = true;
            CommandLineOptions.Clo.StratifiedInliningVerbose = 2;
            CommandLineOptions.Clo.UseArrayTheory            = true;
            CommandLineOptions.Clo.TypeEncodingMethod        = CommandLineOptions.TypeEncoding.Monomorphic;

            Program program;

            program = BoogieUtil.ReadAndOnlyResolve(inFileName);

            // TODO: assert that no procedure can be called in both sync and async mode!


            // Find entrypoint and initialize con
            var entry = program.TopLevelDeclarations.OfType <Procedure>()
                        .Where(proc => QKeyValue.FindBoolAttribute(proc.Attributes, "entrypoint"))
                        .FirstOrDefault();

            if (entry == null)
            {
                Console.WriteLine("Warning: No entrypoint given");
                con.entryFunc = null;
            }
            else
            {
                con.entryFunc = entry.Name;
            }

            // Remove unreachable procedures
            BoogieUtil.pruneProcs(program, con.entryFunc);

            // Extract loops
            if (extractLoops)
            {
                program.ExtractLoops();
            }

            BoogieUtil.DoModSetAnalysis(program);

            if (pruneAsserts)
            {
                program = og.GuardAsserts(program);
            }

            if (injectYields)
            {
                program = og.InsertYields(program);
            }

            if (instantiateTemplates)
            {
                var inst = new TemplateInstantiator(program);
                inst.Instantiate(program);
                program = BoogieUtil.ReResolve(program, dbg ? instantiatedFileName : tmpFileName);
            }

            var sp   = new SplitThreads(con, dbg);
            var hmif = new HowManyInstanceFinder(con, dbg);

            var split = new Converter <Program, Program>(sp.split);
            var findHowManyInstances = new Converter <Program, Program>(hmif.Compute);

            if (entry != null && splitThreads)
            {
                if (dbg)
                {
                    Console.WriteLine("Splitting procedures on thread entry: {0}", splitFileName);
                }

                program = split(program);
                program = BoogieUtil.ReResolve(program, dbg ? hmifFileName : tmpFileName);

                program = findHowManyInstances(program);
                program = BoogieUtil.ReResolve(program, dbg ? splitFileName : tmpFileName);
            }

            // Get rid of corral_yield
            program = og.RemoveCorralYield(program, con.yieldProc);


            var yieldedProgram = new ProgTransformation.PersistentProgram(program);

            if (dbg)
            {
                Console.WriteLine("Instrumenting: {0}", annotatedFileName);
            }

            if (!noTid)
            {
                program = og.InstrumentTid(program);
            }

            program = og.InstrumentAtomicBlocks(program);

            if (instrumentPermissions)
            {
                program = og.InstrumentPermissions(program);
            }

            program = BoogieUtil.ReResolve(program, dbg ? annotatedFileName : tmpFileName);

            CommandLineOptions.Clo.ContractInfer     = true;
            CommandLineOptions.Clo.AbstractHoudini   = absDomain;
            CommandLineOptions.Clo.UseProverEvaluate = true;
            CommandLineOptions.Clo.ModelViewFile     = "z3model";
            Microsoft.Boogie.Houdini.AbstractDomainFactory.Initialize(program);

            // First, do sequential
            var answer = DoInference(program, InferenceMode.SEQUENTIAL, annotatedFileName, expandedFileName);

            program = BoogieUtil.ReadAndOnlyResolve(dbg ? annotatedFileName : tmpFileName);

            // prune "true" functions
            var progFuncs = new Dictionary <string, Function>();

            program.TopLevelDeclarations.OfType <Function>()
            .Iter(f => progFuncs.Add(f.Name, f));

            var truefuncs = new List <Function>();

            foreach (var f in answer)
            {
                if (f.Body is LiteralExpr && (f.Body as LiteralExpr).IsTrue)
                {
                    truefuncs.Add(f);
                    var actualf = progFuncs[f.Name];
                    actualf.Attributes = BoogieUtil.removeAttr("existential", actualf.Attributes);
                    actualf.Body       = Expr.True;
                }
            }
            Console.WriteLine("Sequential check pruned away {0} functions, {1} remain", truefuncs.Count, answer.Count() - truefuncs.Count);

            // now do concurrent
            answer = DoInference(program, InferenceMode.CONCURRENT, annotatedFileName, expandedFileName);
            answer = answer.Concat(truefuncs);

            var provedAsserts = new Dictionary <string, bool>();

            answer.Where(func => QKeyValue.FindBoolAttribute(func.Attributes, "assertGuard"))
            .Iter(func => {
                var le = func.Body as LiteralExpr;
                System.Diagnostics.Debug.Assert(le != null);
                provedAsserts.Add(func.Name, le.IsFalse);
            });

            // remove injected existential functions
            answer = answer.Where(func => !QKeyValue.FindBoolAttribute(func.Attributes, "chignore") &&
                                  !QKeyValue.FindBoolAttribute(func.Attributes, "assertGuard"));

            if (printAssignment)
            {
                using (var tt = new TokenTextWriter(Console.Out))
                    answer.ToList().Iter(func => func.Emit(tt, 0));
            }


            if (dbg)
            {
                Console.WriteLine("Injecting invariants back into the original program: {0}", finalFileName);
            }

            program = yieldedProgram.getProgram();

            // remove existential functions
            program.RemoveTopLevelDeclarations(decl => (decl is Function) && QKeyValue.FindBoolAttribute((decl as Function).Attributes, "existential"));
            program.AddTopLevelDeclarations(answer);

            program = og.PruneProvedAsserts(program, f => provedAsserts[f]);

            // Remove ensures and requires
            program = og.RemoveRequiresAndEnsures(program);
            // Remove tid func
            program = og.RemoveThreadIdFunc(program);
            using (Microsoft.Boogie.TokenTextWriter writer = new Microsoft.Boogie.TokenTextWriter(finalFileName))
                program.Emit(writer);
        }
Esempio n. 22
0
        public static int Inline(string bplFileName)
        {
            Bpl.CommandLineOptions options = new Bpl.CommandLineOptions();
            Bpl.CommandLineOptions.Install(options);
            Bpl.CommandLineOptions.Clo.DoModSetAnalysis = true;
            Bpl.Program program;
            string      _bplFileName = "_" + bplFileName;

            Bpl.Parser.Parse(_bplFileName, new List <string>(), out program);
            int errorCount = program.Resolve();

            if (errorCount != 0)
            {
                Console.WriteLine("{0} name resolution errors detected in {1}", errorCount, _bplFileName);
                return(-1);
            }
            errorCount = program.Typecheck();
            if (errorCount != 0)
            {
                Console.WriteLine("{0} type checking errors detected in {1}", errorCount, _bplFileName);
                return(-1);
            }
            bool inline = false;

            foreach (var d in program.TopLevelDeclarations)
            {
                if (d.FindExprAttribute("inline") != null)
                {
                    inline = true;
                }
            }
            if (inline)
            {
                foreach (var d in program.TopLevelDeclarations)
                {
                    var impl = d as Bpl.Implementation;
                    if (impl != null)
                    {
                        impl.OriginalBlocks  = impl.Blocks;
                        impl.OriginalLocVars = impl.LocVars;
                    }
                }
                foreach (var d in program.TopLevelDeclarations)
                {
                    var impl = d as Bpl.Implementation;
                    if (impl != null && !impl.SkipVerification)
                    {
                        Bpl.Inliner.ProcessImplementation(program, impl);
                    }
                }
                foreach (var d in program.TopLevelDeclarations)
                {
                    var impl = d as Bpl.Implementation;
                    if (impl != null)
                    {
                        impl.OriginalBlocks  = null;
                        impl.OriginalLocVars = null;
                    }
                }
            }
            Microsoft.Boogie.TokenTextWriter writer = new Microsoft.Boogie.TokenTextWriter(bplFileName);
            options.PrintInstrumented = true;
            program.Emit(writer);
            writer.Close();
            return(0);
        }
Esempio n. 23
0
        static int Main(string[] args)
        {
            int errorReturnValue = -1;

            #region Parse options and check for errors
            var options = new Options();
            options.Parse(args);
            if (options.HelpRequested)
            {
                options.PrintOptions("");
                return(errorReturnValue);
            }
            if (options.HasErrors)
            {
                options.PrintErrorsAndExit(Console.Out);
            }
            if (!String.IsNullOrWhiteSpace(options.exemptionFile))
            {
                string fileName = options.exemptionFile;
                var    c        = fileName[fileName.Length - 1];
                if (c == '+' || c == '-')
                {
                    fileName = options.exemptionFile.Remove(fileName.Length - 1);
                }
                if (!File.Exists(fileName))
                {
                    Console.WriteLine("Specified exemption file '{0}' not found.", fileName);
                }
            }
            if (options.stub != null)
            {
                Console.WriteLine("/s is no longer used to specify stub assemblies");
                return(errorReturnValue);
            }

            if (options.modelExceptions == 1 && !options.wholeProgram)
            {
                Console.WriteLine("can specify a precise modeling of exceptions only when doing whole program analysis");
                return(errorReturnValue);
            }

            if (options.breakIntoDebugger)
            {
                System.Diagnostics.Debugger.Launch();
            }

            #endregion

            var assemblyNames = options.assemblies;
            if (assemblyNames == null || assemblyNames.Count == 0)
            {
                assemblyNames = new List <string>();
                foreach (var g in options.GeneralArguments)
                {
                    assemblyNames.Add(g);
                }
            }

            #region If an exclusion file has been specified, read in each line as a regular expression
            List <Regex> exemptionList = null;
            bool         whiteList     = false;
            if (!String.IsNullOrWhiteSpace(options.exemptionFile))
            {
                int i = 0;
                exemptionList = new List <Regex>();
                string fileName = options.exemptionFile;
                var    c        = fileName[fileName.Length - 1];
                whiteList = true;
                if (c == '+' || c == '-')
                {
                    fileName = options.exemptionFile.Remove(fileName.Length - 1);
                    if (c == '-')
                    {
                        whiteList = false;
                    }
                }
                try {
                    // Create an instance of StreamReader to read from a file.
                    // The using statement also closes the StreamReader.
                    using (StreamReader sr = new StreamReader(fileName)) {
                        String line;
                        // Read and display lines from the file until the end of
                        // the file is reached.
                        while ((line = sr.ReadLine()) != null)
                        {
                            exemptionList.Add(new Regex(line));
                            i++;
                        }
                        //Console.WriteLine("Read {0} lines from the exclusion file '{1}'.",
                        //  i, options.exemptionFile);
                    }
                } catch (Exception e) {
                    Console.WriteLine("Something went wrong reading the exclusion file '{0}'; read in {1} lines, continuing processing.",
                                      fileName, i);
                    Console.WriteLine(e.Message);
                }
            }
            #endregion

            try {
                HeapFactory heap;
                switch (options.heapRepresentation)
                {
                case Options.HeapRepresentation.splitFields:
                    heap = new SplitFieldsHeap();
                    break;

                case Options.HeapRepresentation.general:
                    heap = new GeneralHeap();
                    break;

                default:
                    Console.WriteLine("Unknown setting for /heap");
                    return(1);
                }

                var pgm      = TranslateAssembly(assemblyNames, heap, options, exemptionList, whiteList);
                var fileName = assemblyNames[0];
                fileName = Path.GetFileNameWithoutExtension(fileName);
                string outputFileName = fileName + ".bpl";
                // Microsoft.Boogie.TokenTextWriter writer = new Microsoft.Boogie.TokenTextWriter("_" + outputFileName);
                Microsoft.Boogie.TokenTextWriter writer = new Microsoft.Boogie.TokenTextWriter(outputFileName);
                Prelude.Emit(writer);
                pgm.Emit(writer);
                writer.Close();
                return(0);
                // return Inline(outputFileName);
            } catch (Exception e) { // swallow everything and just return an error code
                Console.WriteLine("The byte-code translator failed: {0}", e.Message);
                Console.WriteLine("Stack trace: {0}", e.StackTrace);
                return(-1);
            }
        }