Ejemplo n.º 1
0
        /// <summary>
        /// Prelude that is shared by all translated programs, no matter
        /// what the heap representation is.
        /// </summary>
        public static void Emit(Microsoft.Boogie.TokenTextWriter wr)
        {
            wr.Write(@"// Copyright (c) 2010, Microsoft Corp.
// Bytecode Translator prelude

");
        }
Ejemplo n.º 2
0
        protected override bool UpdateAssignmentWorkList(ProverInterface.Outcome outcome,
                                                         List <Counterexample> errors)
        {
            Contract.Assume(currentHoudiniState.Implementation != null);
            bool dequeue = true;

            switch (outcome)
            {
            case ProverInterface.Outcome.Valid:
                //yeah, dequeue
                break;

            case ProverInterface.Outcome.Invalid:
                Contract.Assume(errors != null);

                foreach (Counterexample error in errors)
                {
                    RefutedAnnotation refutedAnnotation = ExtractRefutedAnnotation(error);
                    // some candidate annotation removed
                    if (refutedAnnotation != null)
                    {
                        refutedSharedAnnotations.TryAdd(refutedAnnotation.Constant.Name, refutedAnnotation);
                        AddRelatedToWorkList(refutedAnnotation);
                        UpdateAssignment(refutedAnnotation);
                        dequeue = false;

                        #region Extra debugging output
                        if (CommandLineOptions.Clo.Trace)
                        {
                            using (var cexWriter = new System.IO.StreamWriter(cexTraceFile, true)) {
                                cexWriter.WriteLine("Counter example for " + refutedAnnotation.Constant);
                                cexWriter.Write(error.ToString());
                                cexWriter.WriteLine();
                                using (var writer = new Microsoft.Boogie.TokenTextWriter(cexWriter))
                                    foreach (Microsoft.Boogie.Block blk in error.Trace)
                                    {
                                        blk.Emit(writer, 15);
                                    }
                                //cexWriter.WriteLine();
                            }
                        }
                        #endregion
                    }
                }

                if (ExchangeRefutedAnnotations())
                {
                    dequeue = false;
                }

                break;

            default:
                if (CommandLineOptions.Clo.Trace)
                {
                    Console.WriteLine("Timeout/Spaceout while verifying " + currentHoudiniState.Implementation.Name);
                }

                HoudiniSession houdiniSession;
                houdiniSessions.TryGetValue(currentHoudiniState.Implementation, out houdiniSession);

                foreach (Variable v in houdiniSession.houdiniAssertConstants)
                {
                    if (CommandLineOptions.Clo.Trace)
                    {
                        Console.WriteLine("Removing " + v);
                    }
                    currentHoudiniState.Assignment.Remove(v);
                    currentHoudiniState.Assignment.Add(v, false);
                    this.NotifyConstant(v.Name);
                }

                currentHoudiniState.addToBlackList(currentHoudiniState.Implementation.Name);
                break;
            }

            return(dequeue);
        }
Ejemplo n.º 3
0
        protected override bool UpdateAssignmentWorkList(ProverInterface.Outcome outcome,
            List<Counterexample> errors)
        {
            Contract.Assume(currentHoudiniState.Implementation != null);
              bool dequeue = true;

              switch (outcome) {
            case ProverInterface.Outcome.Valid:
            //yeah, dequeue
            break;

            case ProverInterface.Outcome.Invalid:
            Contract.Assume(errors != null);

            foreach (Counterexample error in errors) {
              RefutedAnnotation refutedAnnotation = ExtractRefutedAnnotation(error);
              // some candidate annotation removed
              if (refutedAnnotation != null) {
            refutedSharedAnnotations.TryAdd(refutedAnnotation.Constant.Name, refutedAnnotation);
            AddRelatedToWorkList(refutedAnnotation);
            UpdateAssignment(refutedAnnotation);
            dequeue = false;

            #region Extra debugging output
            if (CommandLineOptions.Clo.Trace) {
              using (var cexWriter = new System.IO.StreamWriter(cexTraceFile, true)) {
                cexWriter.WriteLine("Counter example for " + refutedAnnotation.Constant);
                cexWriter.Write(error.ToString());
                cexWriter.WriteLine();
                using (var writer = new Microsoft.Boogie.TokenTextWriter(cexWriter))
                  foreach (Microsoft.Boogie.Block blk in error.Trace)
                    blk.Emit(writer, 15);
                //cexWriter.WriteLine();
              }
            }
            #endregion
              }
            }

            if (ExchangeRefutedAnnotations()) dequeue = false;

            break;
            default:
            if (CommandLineOptions.Clo.Trace) {
              Console.WriteLine("Timeout/Spaceout while verifying " + currentHoudiniState.Implementation.Name);
            }

            HoudiniSession houdiniSession;
            houdiniSessions.TryGetValue(currentHoudiniState.Implementation, out houdiniSession);

            foreach (Variable v in houdiniSession.houdiniAssertConstants) {
              if (CommandLineOptions.Clo.Trace) {
            Console.WriteLine("Removing " + v);
              }
              currentHoudiniState.Assignment.Remove(v);
              currentHoudiniState.Assignment.Add(v, false);
              this.NotifyConstant(v.Name);
            }

            currentHoudiniState.addToBlackList(currentHoudiniState.Implementation.Name);
            break;
              }

              return dequeue;
        }