示例#1
0
  /**
   * Constructs a new prover with the given <code>SymbolTable</code> and sets it immediately to work
   * on the verification conditions represented in the provided <code>Collection</code> of <code>
   * AssertiveCode</code>. If this constructor returns without throwing an exception, the VCs have
   * been proved. Otherwise, an exception is thrown indicating which VC could not be proved (or was
   * proved inconsistent).
   *
   * @param symbolTable The current symbol table. May not be <code>null</code>.
   * @param vCs A list of verification conditions in the form of <code>AssertiveCode</code>. May not
   *     be <code>null</code>.
   * @param maxDepth The maximum length of proof the prover should consider.
   * @throws UnableToProveException If a given VC cannot be proved in a reasonable amount of time.
   * @throws VCInconsistentException If a given VC can be proved inconsistent.
   * @throes NullPointerException If <code>symbolTable</code> or <code>vC</code> is <code>null
   *     </code>.
   */
  public Prover(
      final MathExpTypeResolver typer,
      final Iterable<VerificationCondition> vCs,
      final CompileEnvironment instanceEnvironment)
      throws ProverException {

    if (instanceEnvironment.flags.isFlagSet(FLAG_TIMEOUT)) {
      TIMEOUT =
          Long.parseLong(
              instanceEnvironment.flags.getFlagArgument(FLAG_TIMEOUT, FLAG_TIMEOUT_ARG_NAME));
    } else {
      TIMEOUT = Integer.MAX_VALUE;
    }

    myInstanceEnvironment = instanceEnvironment;

    allProved = true;

    if (!myInstanceEnvironment.flags.isFlagSet(FLAG_NOGUI)) {
      myProgressWindow = new ProofProgressWindow("VC", null);
    }

    myTyper = typer;
    buildTheories();

    try {
      proveVCs(vCs);

      CompileReport myReport = myInstanceEnvironment.getCompileReport();
      if (!myReport.hasError() && allProved) {
        myReport.setProveSuccess();
      }
    } catch (UnsupportedOperationException e) {
      // Exp.equivalent() is not consistently implemented throughout the
      // absyn package. By default, it will just throw an
      // UnsupportedOperationException if it is called and has not been
      // overridden. This will catch this case and produce a useful
      // error message.

      // On the other hand, it's sometimes useful for debugging to see a
      // full stack trace. Uncomment this next line to see that instead:
      if (true) throw new RuntimeException(e);

      ErrorHandler handler = myInstanceEnvironment.getErrorHandler();
      handler.error(e.getMessage() + "\n\nTry disabling the -prove option.");
    }

    if (!myInstanceEnvironment.flags.isFlagSet(FLAG_NOGUI)) {
      myProgressWindow.dispose();
    }
  }
示例#2
0
  /**
   * Attempts to prove a single VC. If this method returns without throwing an exception, then the
   * VC was proved.
   *
   * @param vC The verification condition to be proved. May not be <code>null</code>.
   * @param theorems A list of theorems that may be applied as part of the proof. May not be <code>
   *     null</code>.
   * @param maxDepth The maximum number of steps the prover should attempt before giving up on a
   *     proof.
   * @param metrics A reference to the metrics the prover should keep on the proof in progress. May
   *     not be <code>null</code>.
   * @param p The prover to be used if we're using the new prover, or <code>null</code> if we're
   *     supposed to use to legacy prover.
   * @throws UnableToProveException If the VC cannot be proved in a reasonable amount of time.
   * @throws VCInconsistentException If the VC can be proved inconsistent.
   * @throws NullPointerException If <code>vC</code>, <code>theorems</code>, or <code>metrics</code>
   *     is <code>null</code>.
   */
  private void proveVC(
      final VerificationCondition vC, final Metrics metrics, FileWriter proofFile, VCProver p)
      throws VCInconsistentException {

    if (myInstanceEnvironment.flags.isFlagSet(FLAG_VERBOSE)) {
      System.out.println("\n\n############################# VC " + "#############################");

      System.out.println(vC);
    }

    long startTime = System.currentTimeMillis();
    vC.propagateExpansionsInPlace();

    ProverException exitInformation = null;

    ActionCanceller c = new ActionCanceller();

    if (!myInstanceEnvironment.flags.isFlagSet(FLAG_NOGUI)) {
      myProgressWindow.setTitle("VC " + vC.getName());
      myProgressWindow.setActionCanceller(c);
    }

    if (p == null) {
      if (myInstanceEnvironment.flags.isFlagSet(FLAG_DEBUG)) {
        p = setUpOldProverDebug(vC);
      } else {
        p = setUpOldProver(vC);
      }
    }
    if (myInstanceEnvironment.flags.isFlagSet(ResolveCompiler.FLAG_WEB)) {
      output.append("<vcProve id=\"" + vC.getName() + "\">");
    } else {
      output.append(vC.getName() + " ");
    }
    // System.out.print(vC.getName() + " ");

    try {
      p.prove(vC.copy(), myProgressWindow, c, System.currentTimeMillis() + TIMEOUT);
    } catch (UnableToProveException e) {
      exitInformation = e;
      output.append("Skipped after ");
      // System.out.print("Skipped after ");
      allProved = false;

      if (proofFile != null) {
        try {
          proofFile.append(vC.getName() + " failed.\n\n");
        } catch (IOException ex) {
        }
      }
    } catch (VCProvedException e) {
      exitInformation = e;
      output.append("Proved in ");
      // System.out.print("Proved in ");

      if (proofFile != null) {
        try {
          proofFile.append(vC.getName() + " succeeded.\n\n");
          proofFile.append(e.toString());
        } catch (IOException ex) {
        }
      }
    }

    printExitReport(startTime, exitInformation);
    if (myInstanceEnvironment.flags.isFlagSet(ResolveCompiler.FLAG_WEB)) {
      output.append("</vcProve>");
      myInstanceEnvironment.getCompileReport().setProveVCs(output.toString());
    }
  }