/**
  * Read all printer formats from config file.
  *
  * <pre>
  *   <bild-format name="13 x 15" papier-format="F2" breite-mm="130" hoehe-mm="150" />
  * </pre>
  */
 private void setPrinterFormat() {
   PM_PictureFormatCollection instance = PM_PictureFormatCollection.getInstance();
   List formatList = PM_XML_Utils.getElementListe(document, "//" + TAG_BILD_FORMAT);
   // loop over all tags
   for (Iterator itFormate = formatList.iterator(); itFormate.hasNext(); ) {
     Element format = (Element) itFormate.next();
     String name = PM_XML_Utils.getAttribute(format, ATTR_FORMAT_NAME);
     String papierFormatString = PM_XML_Utils.getAttribute(format, ATTR_FORMAT_FORMAT);
     int breite = PM_XML_Utils.getAttributeInt(format, ATTR_FORMAT_BREITE);
     int hoehe = PM_XML_Utils.getAttributeInt(format, ATTR_FORMAT_HOEHE);
     PM_PaperFormat papierFormat = PM_PaperFormat.getPaperFormat(papierFormatString);
     if (papierFormat == null) {
       continue;
     }
     if (hoehe == 0 || breite == 0) continue; // unzul�ssige Eingaben
     instance.addBildFormat(
         new PM_PictureFormatFix(papierFormat, new Rectangle(breite, hoehe), name));
   }
 }
  private void setAllPrinter() {
    java.util.List systemDruckerList =
        PM_XML_Utils.getElementListe(document, "//" + TAG_SYSTEM_DRUCKER);
    // --------------------------------------------------------------
    // Loop ueber ALLE Systemdrucker
    // --------------------------------------------------------------
    for (Iterator itSystemDrucker = systemDruckerList.iterator(); itSystemDrucker.hasNext(); ) {
      Element systemDrucker = (Element) itSystemDrucker.next();
      String systemPrinterName = PM_XML_Utils.getAttribute(systemDrucker, ATTR_SYSTEM_DRUCKER_NAME);
      PM_SystemPrinter systemPrinter = systemPrinters.getSystemPrinter(systemPrinterName);
      if (systemPrinter == null) {
        continue; // system printer not found
      }
      // --------------------------------------------------------------
      // loop ueber alle pm-drucker innerhalb EINES Systemdruckers
      // --------------------------------------------------------------
      java.util.List pmDruckerList = PM_XML_Utils.getElementListe(systemDrucker, TAG_PM_DRUCKER);
      for (Iterator itPmDrucker = pmDruckerList.iterator(); itPmDrucker.hasNext(); ) {
        Element pmDrucker = (Element) itPmDrucker.next();
        String pmDruckerName = PM_XML_Utils.getAttribute(pmDrucker, ATTR_PM_DRUCKER_NAME);
        // init pmPrinter
        PM_PmPrinter pmPrinter = new PM_PmPrinter(systemPrinter, pmDruckerName);
        // add to system printer
        systemPrinter.addPmDrucker(pmPrinter);
        // drucker.setPapierBereich(papierBereich);
        // ---- Druck-Bereich innerhalb eines pm-druckers -------
        Element druckBereichElement = pmDrucker.element(TAG_DRUCK_BEREICH);
        if (druckBereichElement != null) {
          double oben =
              PM_XML_Utils.getAttributeDouble(druckBereichElement, ATTR_DRUCK_BEREICH_OBEN);
          double rechts =
              PM_XML_Utils.getAttributeDouble(druckBereichElement, ATTR_DRUCK_BEREICH_RECHTS);
          double unten =
              PM_XML_Utils.getAttributeDouble(druckBereichElement, ATTR_DRUCK_BEREICH_UNTEN);
          double links =
              PM_XML_Utils.getAttributeDouble(druckBereichElement, ATTR_DRUCK_BEREICH_LINKS);
          pmPrinter.setDruckBereichGesamtRaender(oben, rechts, unten, links);
        }
      } // ende alle pm-drucker fuer einen system-drucker
    } // ende alle Systemdrucker

    // Wenn kein Drucker, dann Default-Drucker anlegen

  }
    private void add(PptTopLevel ppt, ValueTuple vt) {
      // Add the sample to any splitters
      if (ppt.has_splitters()) {
        for (PptSplitter ppt_split : ppt.splitters) {
          PptConditional ppt_cond = ppt_split.choose_conditional(vt);
          if (ppt_cond != null) add(ppt_cond, vt);
          else debug.fine(": sample doesn't pick conditional");
        }
      }

      // if this is a numbered exit, apply to the combined exit as well
      if (!(ppt instanceof PptConditional) && ppt.ppt_name.isNumberedExitPoint()) {
        PptTopLevel parent = all_ppts.get(ppt.ppt_name.makeExit());
        if (parent != null) {
          parent.get_missingOutOfBounds(ppt, vt);
          add(parent, vt);
        }
      }

      // If the point has no variables, skip it
      if (ppt.var_infos.length == 0) return;

      // We should have received sample here before, or there is nothing
      // to check.
      // Yoav added: It can be that the different dtrace and inv files have different program points
      if (false && ppt.num_samples() <= 0)
        Assert.assertTrue(
            ppt.num_samples() > 0,
            "ppt " + ppt.name + " has 0 samples and " + ppt.var_infos.length + " variables");

      // Loop through each slice
      slice_loop:
      for (Iterator<PptSlice> i = ppt.views_iterator(); i.hasNext(); ) {
        PptSlice slice = i.next();
        if (debug_detail.isLoggable(Level.FINE))
          debug_detail.fine(
              ": processing slice " + slice + "vars: " + Debug.toString(slice.var_infos, vt));

        // If any variables are missing, skip this slice
        for (int j = 0; j < slice.var_infos.length; j++) {
          VarInfo v = slice.var_infos[j];
          int mod = vt.getModified(v);
          if (v.isMissing(vt)) {
            if (debug_detail.isLoggable(Level.FINE))
              debug_detail.fine(": : Skipping slice, " + v.name() + " missing");
            continue slice_loop;
          }
          if (v.missingOutOfBounds()) {
            if (debug_detail.isLoggable(Level.FINE))
              debug.fine(": : Skipping slice, " + v.name() + " out of bounds");
            continue slice_loop;
          }
        }

        // Loop through each invariant
        for (Invariant inv : slice.invs) {
          if (debug_detail.isLoggable(Level.FINE))
            debug_detail.fine(": : Processing invariant: " + inv);
          if (!inv.isActive()) {
            if (debug_detail.isLoggable(Level.FINE))
              debug_detail.fine(": : skipped non-active " + inv);
            continue;
          }

          // Yoav added
          if (!activeInvariants.contains(inv)) {
            // System.out.printf ("skipping invariant %s:%s\n", inv.ppt.name(),
            //                   inv.format());
            continue;
          }

          // String invRep = invariant2str(ppt, inv);
          testedInvariants.add(inv);

          InvariantStatus status = inv.add_sample(vt, 1);
          sample_cnt++;
          if (status != InvariantStatus.NO_CHANGE) {
            LineNumberReader lnr = FileIO.data_trace_state.reader;
            String line = (lnr == null) ? "?" : String.valueOf(lnr.getLineNumber());
            if (!quiet) {
              output_stream.println(
                  "At ppt "
                      + ppt.name
                      + ", Invariant '"
                      + inv.format()
                      + "' invalidated by sample "
                      + Debug.toString(slice.var_infos, vt)
                      + "at line "
                      + line
                      + " in file "
                      + FileIO.data_trace_state.filename);
            }
            failedInvariants.add(inv);
            activeInvariants.remove(inv);
            error_cnt++;
          }
        }
      }
    }
  private static void checkInvariants() throws IOException {
    // Read the invariant file
    PptMap ppts = FileIO.read_serialized_pptmap(inv_file, true);

    // Yoav: make sure we have unique invariants
    InvariantFilters fi = InvariantFilters.defaultFilters();
    // Set<String> allInvariantsStr = new HashSet<String>();
    Set<Invariant> allInvariants = new HashSet<Invariant>();
    for (PptTopLevel ppt : ppts.all_ppts())
      for (Iterator<PptSlice> i = ppt.views_iterator(); i.hasNext(); ) {
        PptSlice slice = i.next();
        for (Invariant inv : slice.invs) {
          if (doConf && inv.getConfidence() < Invariant.dkconfig_confidence_limit) {
            // System.out.printf ("inv ignored (conf): %s:%s\n", inv.ppt.name(),
            //                   inv.format());
            continue;
          }

          if (doFilter && fi.shouldKeep(inv) == null) {
            // System.out.printf ("inv ignored (filter): %s:%s\n",
            //                     inv.ppt.name(), inv.format());
            continue;
          }
          activeInvariants.add(inv);

          // String n = invariant2str(ppt, inv);
          // if (!allInvariants.contains(inv) && allInvariantsStr.contains(n)) throw new
          // Daikon.TerminationMessage("Two invariants have the same ppt.name+inv.rep:"+n);
          allInvariants.add(inv);
          // allInvariantsStr.add(n);
        }
      }

    // Read and process the data trace files
    FileIO.Processor processor = new InvariantCheckProcessor();

    Daikon.FileIOProgress progress = new Daikon.FileIOProgress();
    progress.start();
    progress.clear();
    FileIO.read_data_trace_files(dtrace_files, ppts, processor, false);
    progress.shouldStop = true;
    System.out.println();
    System.out.printf(
        "%s: %,d errors found in %,d samples (%s)\n",
        inv_file, error_cnt, sample_cnt, toPercentage(error_cnt, sample_cnt));
    int failedCount = failedInvariants.size();
    int testedCount = testedInvariants.size();
    String percent = toPercentage(failedCount, testedCount);
    System.out.println(
        inv_file
            + ": "
            + failedCount
            + " false positives, out of "
            + testedCount
            + ", which is "
            + percent
            + ".");
    if (false) {
      for (Invariant inv : failedInvariants) {
        System.out.printf("+%s:%s\n", inv.ppt.name(), inv.format());
      }
    }
  }