// private methods
 private synchronized void writeToSAX(ContentHandler handler) {
   // nothing must go wrong with this parse...
   SAXParser parser = fGrammar.getSAXParser();
   StringReader aReader = new StringReader(fData);
   InputSource aSource = new InputSource(aReader);
   parser.setContentHandler(handler);
   try {
     parser.parse(aSource);
   } catch (SAXException e) {
     // this should never happen!
     // REVISIT:  what to do with this?; should really not
     // eat it...
   } catch (IOException i) {
     // ditto with above
   }
 }
  private void parseDocument(Boolean typeFile, String reportName) {
    final InputStream jasperreportDtd =
        ReportManager.class
            .getClassLoader()
            .getResourceAsStream("net/sf/jasperreports/engine/dtds/jasperreport.dtd");
    InputStream xmlSource = null;

    parsingStart = System.currentTimeMillis();
    log.debug("parseDocument - [start] " + reportName);
    try {
      SAXParser sp = new SAXParser();
      log.debug(
          "parseDocument -   newSAXParser=" + (System.currentTimeMillis() - parsingStart) + " ms.");

      ClassLoader loader = (ReportManager.class).getClassLoader();
      File f = null;
      try {
        if (typeFile == true) f = new File(loader.getResource(reportName).toURI());
        else f = new File(reportName);
      } catch (URISyntaxException e) {
        e.printStackTrace();
      }
      log.debug(
          "parseDocument -   getResource=" + (System.currentTimeMillis() - parsingStart) + " ms.");

      xmlSource = new FileInputStream(f);

      sp.setContentHandler(this);
      sp.setEntityResolver(
          new EntityResolver() {
            public InputSource resolveEntity(String publicId, String systemId)
                throws SAXException, IOException {
              if (publicId.equals("//JasperReports//DTD Report Design//EN")
                  || systemId.equals(
                      "http://jasperreports.sourceforge.net/dtds/jasperreport.dtd")) {
                return new InputSource(jasperreportDtd);
              } else {
                String msg =
                    "DTD ("
                        + publicId
                        + " "
                        + systemId
                        + ") cannot be resolved by ReportManager: "
                        + "please change TNTConcept to add the new DTD or change your JasperReport's JRXML file "
                        + "to use the standard DTD";
                log.error("parseDocument - " + msg);
                throw new IllegalArgumentException(msg);
              }
            }
          });

      sp.parse(new InputSource(xmlSource));
    } catch (FinalizeParsingException fpe) {
      // ignore this exception as it is thrown as an optimization
    } catch (SAXException se) {
      log.error("parseDocument - exception", se);
    } catch (IOException ie) {
      log.error("parseDocument - exception", ie);
    } finally {
      if (xmlSource != null) {
        try {
          xmlSource.close();
        } catch (IOException e) {
          // ignored
        }
      }
      try {
        jasperreportDtd.close();
      } catch (IOException e) {
        // ignored
      }
      log.info(
          "parseDocument - "
              + reportName
              + " ("
              + (System.currentTimeMillis() - parsingStart)
              + " ms.)");
    }
  }
  public void validate(Source source, Result result) throws SAXException, IOException {
    if (result instanceof StreamResult || result == null) {
      final StreamSource streamSource = (StreamSource) source;
      final StreamResult streamResult = (StreamResult) result;
      XMLInputSource input =
          new XMLInputSource(streamSource.getPublicId(), streamSource.getSystemId(), null);
      input.setByteStream(streamSource.getInputStream());
      input.setCharacterStream(streamSource.getReader());

      // Gets the parser configuration. We'll create and initialize a new one, if we
      // haven't created one before or if the previous one was garbage collected.
      boolean newConfig = false;
      XMLParserConfiguration config = (XMLParserConfiguration) fConfiguration.get();
      if (config == null) {
        config = initialize();
        newConfig = true;
      }
      // If settings have changed on the component manager, refresh the error handler and entity
      // resolver.
      else if (fComponentManager.getFeature(PARSER_SETTINGS)) {
        config.setProperty(ENTITY_RESOLVER, fComponentManager.getProperty(ENTITY_RESOLVER));
        config.setProperty(ERROR_HANDLER, fComponentManager.getProperty(ERROR_HANDLER));
        config.setProperty(SECURITY_MANAGER, fComponentManager.getProperty(SECURITY_MANAGER));
      }

      // prepare for parse
      fComponentManager.reset();

      if (streamResult != null) {
        if (fSerializerFactory == null) {
          fSerializerFactory = SerializerFactory.getSerializerFactory(Method.XML);
        }

        // there doesn't seem to be a way to reset a serializer, so we need to make
        // a new one each time.
        Serializer ser;
        if (streamResult.getWriter() != null) {
          ser = fSerializerFactory.makeSerializer(streamResult.getWriter(), new OutputFormat());
        } else if (streamResult.getOutputStream() != null) {
          ser =
              fSerializerFactory.makeSerializer(streamResult.getOutputStream(), new OutputFormat());
        } else if (streamResult.getSystemId() != null) {
          String uri = streamResult.getSystemId();
          OutputStream out = XMLEntityManager.createOutputStream(uri);
          ser = fSerializerFactory.makeSerializer(out, new OutputFormat());
        } else {
          throw new IllegalArgumentException(
              JAXPValidationMessageFormatter.formatMessage(
                  fComponentManager.getLocale(), "StreamResultNotInitialized", null));
        }

        // we're using the parser only as an XNI-to-SAX converter,
        // so that we can use the SAX-based serializer
        SAXParser parser = (SAXParser) fParser.get();
        if (newConfig || parser == null) {
          parser = new SAXParser(config);
          fParser = new SoftReference(parser);
        } else {
          parser.reset();
        }
        config.setDocumentHandler(fSchemaValidator);
        fSchemaValidator.setDocumentHandler(parser);
        parser.setContentHandler(ser.asContentHandler());
      } else {
        fSchemaValidator.setDocumentHandler(null);
      }

      try {
        config.parse(input);
      } catch (XMLParseException e) {
        throw Util.toSAXParseException(e);
      } catch (XNIException e) {
        throw Util.toSAXException(e);
      } finally {
        // release the references to the SAXParser and Serializer
        fSchemaValidator.setDocumentHandler(null);
      }

      return;
    }
    throw new IllegalArgumentException(
        JAXPValidationMessageFormatter.formatMessage(
            fComponentManager.getLocale(),
            "SourceResultMismatch",
            new Object[] {source.getClass().getName(), result.getClass().getName()}));
  }