protected Templates getTemplates(String filename) {

    File file = new File(filename);

    // check timestamp if we have it already
    long lastModified = file.lastModified();
    TemplatesCache cache = (TemplatesCache) xslCache.get(file);
    if (cache != null && cache.timestamp == lastModified) return cache.templates;

    cache = new TemplatesCache();
    cache.timestamp = lastModified;

    // get a new
    try {
      TransformerFactory factory = TransformerFactory.newInstance();
      cache.templates = factory.newTemplates(new StreamSource(file));
    } catch (TransformerConfigurationException e) {
      throw new RuntimeException(
          "Exception reading templates from " + filename + ": " + e.getMessage());
    }

    // keep it
    xslCache.put(file, cache);

    // done
    return cache.templates;
  }
  // taken from
  // http://www.exampledepot.com/egs/javax.xml.transform/BasicXsl.html
  // This method applies the xslFilename to inFilename and writes
  // the output to outFilename.
  public static void xsl(File inFile, File outFile, InputStream xslStream) throws Exception {
    try {
      // Create transformer factory
      TransformerFactory factory = TransformerFactory.newInstance();

      // Use the factory to create a template containing the xsl file
      Templates template = factory.newTemplates(new StreamSource(xslStream));

      // Use the template to create a transformer
      Transformer xformer = template.newTransformer();

      // Prepare the input and output files
      Source source = new StreamSource(new FileInputStream(inFile));
      Result result = new StreamResult(new FileOutputStream(outFile));

      // Apply the xsl file to the source file and write the result to the
      // output file
      xformer.transform(source, result);
    } catch (TransformerException e) {
      // An error occurred while applying the XSL file
      // Get location of error in input file
      SourceLocator locator = e.getLocator();
      int col = locator.getColumnNumber();
      int line = locator.getLineNumber();
      throw new Exception(
          String.format("XSL exception line %d col %d message: %s", line, col, e.getMessage()));
    }
  }
Exemple #3
0
  /**
   * Sets the XSLT transformer from a Source
   *
   * @param source the source
   * @throws TransformerConfigurationException is thrown if creating a XSLT transformer failed.
   */
  public void setTransformerSource(Source source) throws TransformerConfigurationException {
    TransformerFactory factory = converter.getTransformerFactory();
    if (errorListener != null) {
      factory.setErrorListener(errorListener);
    } else {
      // use a logger error listener so users can see from the logs what the error may be
      factory.setErrorListener(new XsltErrorListener());
    }
    if (getUriResolver() != null) {
      factory.setURIResolver(getUriResolver());
    }

    // Check that the call to newTemplates() returns a valid template instance.
    // In case of an xslt parse error, it will return null and we should stop the
    // deployment and raise an exception as the route will not be setup properly.
    Templates templates = factory.newTemplates(source);
    if (templates != null) {
      setTemplate(templates);
    } else {
      throw new TransformerConfigurationException(
          "Error creating XSLT template. "
              + "This is most likely be caused by a XML parse error. "
              + "Please verify your XSLT file configured.");
    }
  }
  private String importXMI(File sourceFile)
      throws FileNotFoundException, TransformerConfigurationException, TransformerException {

    BufferedReader styledata;
    StreamSource sourcedata;
    Templates stylesheet;
    Transformer trans;

    // Get the stylesheet file stream

    styledata =
        new BufferedReader(
            new FileReader(
                new File(
                    getClass().getClassLoader().getResource("verifier/xmi2lem.xsl").getFile())));
    sourcedata = new StreamSource(new FileReader(sourceFile));

    // Initialize Saxon
    TransformerFactory factory = TransformerFactoryImpl.newInstance();
    stylesheet = factory.newTemplates(new StreamSource(styledata));

    // Apply the transformation
    trans = stylesheet.newTransformer();
    StringWriter sw = new StringWriter();
    trans.transform(sourcedata, new StreamResult(sw));

    // return sw.toString();
    return sw.getBuffer().substring(sw.getBuffer().indexOf("model"));
  }
 public Schema createSchema(InputSource in, PropertyMap properties)
     throws IOException, SAXException, IncorrectSchemaException {
   ErrorHandler eh = ValidateProperty.ERROR_HANDLER.get(properties);
   SAXErrorListener errorListener = new SAXErrorListener(eh, in.getSystemId());
   UserWrapErrorHandler ueh1 = new UserWrapErrorHandler(eh);
   UserWrapErrorHandler ueh2 = new UserWrapErrorHandler(eh);
   try {
     PropertyMapBuilder builder = new PropertyMapBuilder(properties);
     ValidateProperty.ERROR_HANDLER.put(builder, ueh1);
     SAXSource source = createValidatingSource(in, builder.toPropertyMap(), ueh1);
     source =
         createTransformingSource(
             source,
             SchematronProperty.PHASE.get(properties),
             properties.contains(SchematronProperty.DIAGNOSE),
             in.getSystemId(),
             ueh2);
     TransformerFactory transformerFactory =
         (TransformerFactory) transformerFactoryClass.newInstance();
     initTransformerFactory(transformerFactory);
     transformerFactory.setErrorListener(errorListener);
     Templates templates = transformerFactory.newTemplates(source);
     return new SchemaImpl(templates, properties, supportedPropertyIds);
   } catch (TransformerConfigurationException e) {
     throw toSAXException(
         e,
         errorListener.getHadError()
             || ueh1.getHadErrorOrFatalError()
             || ueh2.getHadErrorOrFatalError());
   } catch (InstantiationException e) {
     throw new SAXException(e);
   } catch (IllegalAccessException e) {
     throw new SAXException(e);
   }
 }
  /** Gets an XSLT template from the given resource location. */
  public static Templates getStylesheet(String resourcePath, Class<?> sourceClass) {
    InputStream xsltStream;
    if (sourceClass == null) {
      try {
        xsltStream = new FileInputStream(resourcePath);
      } catch (IOException exc) {
        LOGGER.debug("Could not open file", exc);
        return null;
      }
    } else {
      xsltStream = sourceClass.getResourceAsStream(resourcePath);
    }

    try {
      StreamSource xsltSource = new StreamSource(xsltStream);
      // Java XML factories are not declared to be thread safe
      TransformerFactory transformerFactory = TransformerFactory.newInstance();
      transformerFactory.setErrorListener(new XMLListener());
      return transformerFactory.newTemplates(xsltSource);
    } catch (TransformerConfigurationException exc) {
      LOGGER.debug("Could not construct template", exc);
    } finally {
      try {
        if (xsltStream != null) xsltStream.close();
      } catch (IOException e) {
        LOGGER.debug("Could not close file", e);
      }
    }
    return null;
  }
  private void showResults(HttpSession session, HttpServletResponse response) {

    Document xmlDocument = null;

    try {
      PrintWriter writer = response.getWriter();

      xmlDocument = (Document) session.getAttribute("queryResults");

      String xslPath =
          ContextUtil.getRealPath(session.getServletContext(), XSL_TBLTEXT_RELATIVE_PATH);

      StreamSource s =
          new StreamSource(
              new InputStreamReader(new BufferedInputStream(new FileInputStream(xslPath))));
      Templates cachedXSLT = factory.newTemplates(s);
      Transformer transformer = cachedXSLT.newTransformer();
      DocumentSource source = new DocumentSource(xmlDocument);

      StreamResult result = new StreamResult(writer);
      transformer.transform(source, result);
    } catch (Exception ex) {

    }
  }
Exemple #8
0
    public synchronized Transformer getTransformer(String framework, String filename) {
      if (filename == null || filename.length() == 0) {
        throw new IllegalArgumentException("filename cannot be null or empty");
      }
      String key = framework + "-" + filename;

      Templates t = (Templates) pool.getTemplates().get(key);
      String s = null;

      if (t == null) {
        try {
          WOApplication app = WOApplication.application();
          WOResourceManager rm = app.resourceManager();

          TransformerFactory fac = TransformerFactory.newInstance();

          log.debug("creating template for file " + filename + " in framework " + framework);
          InputStream is = rm.inputStreamForResourceNamed(filename, framework, null);
          if (is == null) {
            log.debug("trying with framework = null");
            is = rm.inputStreamForResourceNamed(filename, null, null);
            if (is == null) {
              throw new IllegalArgumentException("inputStream is null");
            }
          }
          if (is.available() == 0) {
            throw new IllegalArgumentException(
                "InputStream has 0 bytes available, cannot read xsl file!");
          }
          s = ERXFileUtilities.stringFromInputStream(is);
          s = templateParser.parseTemplateWithObject(s, "@@", app);
          t = fac.newTemplates(new StreamSource(new ByteArrayInputStream(s.getBytes())));

          if (app.isCachingEnabled()) {
            templates.put(key, t);
          }
        } catch (IOException e1) {
          throw NSForwardException._runtimeExceptionForThrowable(e1);
        } catch (TransformerConfigurationException tce) {
          log.error("could not create template " + tce.getLocationAsString(), tce);
          log.error("  cause", tce.getCause());
          if (tce.getCause() != null && tce.getCause() instanceof org.xml.sax.SAXParseException) {
            org.xml.sax.SAXParseException e = (org.xml.sax.SAXParseException) tce.getCause();
            log.error(
                "SAXParseException: line " + e.getLineNumber() + ", column " + e.getColumnNumber());
          }
          log.error("this is the incorrect xsl:>>>" + s + "<<<");
          return null;
        }
      }

      try {
        return t.newTransformer();
      } catch (TransformerConfigurationException tce) {
        log.error("could not create template " + tce.getLocationAsString(), tce);
        log.error("  cause", tce.getCause());
        return null;
      }
    }
  private void transform(StreamSource xmlStream, StreamSource xslStream, StreamResult result) {
    try {
      TransformerFactory factory = TransformerFactory.newInstance();
      Templates template = factory.newTemplates(xslStream);
      Transformer transformer = template.newTransformer();

      transformer.transform(xmlStream, result);
    } catch (TransformerException e) {
      e.printStackTrace();
    }
  }
  protected static void initTransformers() throws Exception {
    transformers = new HashMap<String, Transformer>();
    TransformerFactory xformFactory = new org.apache.xalan.processor.TransformerFactoryImpl();

    transformers.put(
        "WADL",
        xformFactory
            .newTemplates(
                new StreamSource(
                    SoapUI.class.getResourceAsStream(
                        "/com/eviware/soapui/resources/doc/wadl_documentation.xsl")))
            .newTransformer());
  }
Exemple #11
0
  /** Maintain prepared stylesheets in memory for reuse */
  public static Templates tryTemplCache(String path)
      throws TransformerException, FileNotFoundException, CitationStyleManagerException {
    Utils.checkName(path, "Empty XSLT name.");

    InputStream is = ResourceUtil.getResourceAsStream(path, XmlHelper.class.getClassLoader());

    Templates x = templCache.get(path);
    if (x == null) {
      x = tf.newTemplates(new StreamSource(is));
      templCache.put(path, x);
    }
    return x;
  }
Exemple #12
0
  protected static void prettify(OMElement wsdlElement, OutputStream out) throws Exception {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    wsdlElement.serialize(baos);

    Source stylesheetSource =
        new StreamSource(new ByteArrayInputStream(prettyPrintStylesheet.getBytes()));
    Source xmlSource = new StreamSource(new ByteArrayInputStream(baos.toByteArray()));

    TransformerFactory tf = TransformerFactory.newInstance();
    Templates templates = tf.newTemplates(stylesheetSource);
    Transformer transformer = templates.newTransformer();
    transformer.transform(xmlSource, new StreamResult(out));
  }
  @Test
  public void testTransformInitialDoc() throws Exception {
    TransformerFactory factory = TransformerFactory.newInstance();
    Source styleSheet =
        new StreamSource(this.getClass().getClassLoader().getResourceAsStream(STYLESHEET_RESOURCE));
    Templates templates = templates = factory.newTemplates(styleSheet);
    Transformer transformer = templates.newTransformer();
    transformer.setOutputProperty("indent", "yes");
    transformer.setParameter("readOnly", "false");
    // transformer.setParameter("docType", docType);
    // transformer.setParameter("schema", schema);

    Source input = new StreamSource(this.getClass().getResourceAsStream(INITIAL_EDOC_XML));
    transformer.transform(input, new StreamResult(System.out));
  }
Exemple #14
0
  public static void xslt(Document data, Document xsl, Result result, boolean outHead)
      throws TransformerException {
    TransformerFactory factory = TransformerFactory.newInstance();
    Templates templates = factory.newTemplates(new DOMSource(xsl));
    Transformer transformer = templates.newTransformer();

    if (!outHead) {
      transformer.setOutputProperty("omit-xml-declaration", "yes");
    } else {
      transformer.setOutputProperty("omit-xml-declaration", "no");
    }

    transformer.setOutputProperty("encoding", encoding);
    transformer.transform(new DOMSource(data), result);
  }
  @Override
  protected Object read(InputStream in) throws IOException {
    // store in a string so that we can perform validation
    String xslt = IOUtils.toString(in);

    try {
      Source xslSource = new StreamSource(new StringReader(xslt));
      TransformerFactory tf = TransformerFactory.newInstance();
      tf.newTemplates(xslSource);
    } catch (Exception e) {
      throw new RestletException(
          "Invalid XSLT : " + e.getMessage(), Status.CLIENT_ERROR_BAD_REQUEST);
    }

    return xslt;
  }
Exemple #16
0
 private Transform() {
   try {
     ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
     Resource[] resources = resolver.getResources(TEMPLATES_PATH);
     for (Resource resource : resources) {
       templates.put(
           getName(resource),
           transformerFactory.newTemplates(new StreamSource(resource.getURL().openStream())));
     }
   } catch (IOException e) {
     throw new RuntimeException(
         "Failed to discover XSLT resources in '" + TEMPLATES_PATH + "'", e);
   } catch (TransformerConfigurationException e) {
     throw new RuntimeException("Error loading XSLT stylesheets", e);
   }
   if (log.isDebugEnabled()) {
     log.debug("templates=" + new TreeSet<String>(templates.keySet()));
   }
 }
 SchemaReaderImpl(TransformerFactory transformerFactory)
     throws TransformerConfigurationException, IncorrectSchemaException {
   this.transformerFactoryClass = transformerFactory.getClass();
   String resourceName = fullResourceName(SCHEMATRON_STYLESHEET);
   StreamSource source = new StreamSource(getResourceAsStream(resourceName));
   initTransformerFactory(transformerFactory);
   schematron = transformerFactory.newTemplates(source);
   InputSource schemaSource =
       new InputSource(getResourceAsStream(fullResourceName(SCHEMATRON_SCHEMA)));
   PropertyMapBuilder builder = new PropertyMapBuilder();
   ValidateProperty.ERROR_HANDLER.put(builder, new DraconianErrorHandler());
   RngProperty.CHECK_ID_IDREF.add(builder);
   try {
     schematronSchema =
         CompactSchemaReader.getInstance().createSchema(schemaSource, builder.toPropertyMap());
   } catch (SAXException e) {
     throw new IncorrectSchemaException();
   } catch (IOException e) {
     throw new IncorrectSchemaException();
   }
 }
 // 使用XSLT模板对Document进行转化
 public static Document getStyleDocument(Document document, String xsltfile) throws Exception {
   InputStream in = null;
   if (CommonPath.path == null || CommonPath.path.equals("")) {
     in = ClassLoader.getSystemResourceAsStream(xsltfile);
   } else {
     String[] ss = xsltfile.split("/");
     String filename = ss[ss.length - 1];
     File file = new File(CommonPath.path + filename);
     in = new FileInputStream(file);
   }
   DocumentSource docSource = new DocumentSource(document);
   DocumentResult docResult = new DocumentResult();
   TransformerFactory factory = TransformerFactory.newInstance();
   Templates cachedXSLT = factory.newTemplates(new StreamSource(in));
   Transformer transformer = cachedXSLT.newTransformer();
   if (transformer != null) {
     transformer.transform(docSource, docResult);
   }
   Document resultDoc = docResult.getDocument();
   return resultDoc;
 }
  private Transformer getTransformer()
      throws TransformerConfigurationException, FileNotFoundException {

    if (this.cachedXslt == null) {

      TransformerFactory factory = TransformerFactory.newInstance();
      // Get Filter

      InputStream is = null;
      Source xslt = null;

      if (StringUtil.isNotEmpty(customFilterPath)) {

        File file = new File(customFilterPath);

        if (!file.exists()) {
          throw new FileNotFoundException("Could not Find Swiper XSLT Filter");
        }
        xslt = new StreamSource(file);

      } else {
        is = getClass().getResourceAsStream(DEFAULT_FILTER);
        xslt = new StreamSource(is);
      }

      this.cachedXslt = factory.newTemplates(xslt);

      try {

        if (is != null) {
          is.close();
        }

      } catch (IOException e) {

      }
    }

    return cachedXslt.newTransformer();
  }
Exemple #20
0
  /**
   * Constructs a new object.
   *
   * @param source the source URL of this endpoint
   * @exception IOException error creating the receiver
   */
  public MmiReceiver(final String source) throws IOException {
    listeners = new java.util.ArrayList<MMIEventListener>();
    sourceUrl = source;

    final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    factory.setNamespaceAware(true);

    // Configure the factory to ignore comments
    factory.setIgnoringComments(true);
    try {
      builder = factory.newDocumentBuilder();
    } catch (ParserConfigurationException e) {
      throw new IOException(e.getMessage(), e);
    }
    TransformerFactory transFact = TransformerFactory.newInstance();
    try {
      final URL xsltURL = UmundoETLProtocolAdapter.class.getResource("VoiceXmlTemplate.xsl");
      final String xsltSystemID = xsltURL.toExternalForm();
      template = transFact.newTemplates(new StreamSource(xsltSystemID));
    } catch (TransformerConfigurationException tce) {
      throw new IOException("Unable to compile stylesheet", tce);
    }
  }
Exemple #21
0
  private void doWork(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    response.setDateHeader("Expires", 0);
    response.setHeader("Cache-Control", "no-cache");
    response.setHeader("Pragma", "no-cache");
    response.setContentType("text/html; charset=UTF-8");

    // identificador de archivo de usuario.
    Integer archiveId = RequestUtils.parseRequestParameterAsInteger(request, "ArchiveId");
    // Identificador de carpeta.
    Integer folderId = RequestUtils.parseRequestParameterAsInteger(request, "FolderId");
    // Obtenemos la sesión asociada al usuario.
    HttpSession session = request.getSession();
    // Texto del idioma. Ej: EU_
    String idioma = (String) session.getAttribute(Keys.J_IDIOMA);
    // Número del idioma. Ej: 10
    Long numIdioma = (Long) session.getAttribute(Keys.J_NUM_IDIOMA);
    // Formulario o no.
    Boolean form = (Boolean) session.getAttribute(Keys.J_OPENFOLDER_FORM);
    // Obtenemos el objeto de configuración del servidor de aplicaciones y el identificador
    // de sesión para este usuario en el servidor de aplicaciones.
    UseCaseConf useCaseConf = (UseCaseConf) session.getAttribute(J_USECASECONF);
    // response.getWriter().write(ACTIVATE_TREE_1);
    // response.getWriter().write("LISTA DE DISTRIBUCION");
    PrintWriter writer = response.getWriter();
    try {
      Document xmlDocument =
          bookUseCase.getDtrFdrResults(useCaseConf, archiveId, folderId.intValue());

      String xslPath =
          ContextUtil.getRealPath(session.getServletContext(), XSL_DTRLISTFDR_RELATIVE_PATH);
      StreamSource s =
          new StreamSource(
              new InputStreamReader(new BufferedInputStream(new FileInputStream(xslPath))));
      Templates cachedXSLT = factory.newTemplates(s);
      Transformer transformer = cachedXSLT.newTransformer();
      DocumentSource source = new DocumentSource(xmlDocument);

      StreamResult result = new StreamResult(writer);
      transformer.transform(source, result);

    } catch (ValidationException e) {
      _logger.fatal("Error de validacion", e);
      writer.write(ACTIVATE_TREE_1);
      ResponseUtils.generateJavaScriptLog(
          writer,
          RBUtil.getInstance(useCaseConf.getLocale())
              .getProperty(Keys.I18N_EXCEPTION_VALIDATIONEXCEPTION));
    } catch (BookException e) {
      _logger.fatal("Error en el libro", e);
      writer.write(ACTIVATE_TREE_1);
      ResponseUtils.generateJavaScriptError(writer, e);
    } catch (SessionException e) {
      _logger.fatal("Error en la sesion", e);
      ResponseUtils.generateJavaScriptLogSessionExpiredDtrfdr(
          writer, e.getMessage(), idioma, numIdioma);
      // ResponseUtils.generateJavaScriptError(response, e);
    } catch (TransformerConfigurationException e) {
      _logger.fatal("Error en la distribucion", e);
      writer.write(ACTIVATE_TREE_1);
      ResponseUtils.generateJavaScriptLog(
          writer,
          RBUtil.getInstance(useCaseConf.getLocale())
              .getProperty(Keys.I18N_ISICRESSRV_ERR_CREATING_DTR_OBJ));
    } catch (TransformerFactoryConfigurationError e) {
      _logger.fatal("Error en la distribucion", e);
      writer.write(ACTIVATE_TREE_1);
      ResponseUtils.generateJavaScriptLog(
          writer,
          RBUtil.getInstance(useCaseConf.getLocale())
              .getProperty(Keys.I18N_ISICRESSRV_ERR_CREATING_DTR_OBJ));
    } catch (TransformerException e) {
      _logger.fatal("Error en la distribucion", e);
      writer.write(ACTIVATE_TREE_1);
      ResponseUtils.generateJavaScriptLog(
          writer,
          RBUtil.getInstance(useCaseConf.getLocale())
              .getProperty(Keys.I18N_ISICRESSRV_ERR_CREATING_DTR_OBJ));
    } catch (Exception e) {
      _logger.fatal("Error en la distribucion", e);
      writer.write(ACTIVATE_TREE_1);
      ResponseUtils.generateJavaScriptLog(
          writer,
          RBUtil.getInstance(useCaseConf.getLocale())
              .getProperty(Keys.I18N_ISICRESSRV_ERR_CREATING_DTR_OBJ));
    }
  }
Exemple #22
0
  // J2SE does not support Xalan interpretive
  // main -> _main
  public static void _main(String argv[]) {

    // Runtime.getRuntime().traceMethodCalls(false); // turns Java tracing off
    boolean doStackDumpOnError = false;
    boolean setQuietMode = false;
    boolean doDiag = false;
    String msg = null;
    boolean isSecureProcessing = false;

    // Runtime.getRuntime().traceMethodCalls(false);
    // Runtime.getRuntime().traceInstructions(false);

    /** The default diagnostic writer... */
    java.io.PrintWriter diagnosticsWriter = new PrintWriter(System.err, true);
    java.io.PrintWriter dumpWriter = diagnosticsWriter;
    ResourceBundle resbundle =
        (SecuritySupport.getResourceBundle(
            com.sun.org.apache.xml.internal.utils.res.XResourceBundle.ERROR_RESOURCES));
    String flavor = "s2s";

    if (argv.length < 1) {
      printArgOptions(resbundle);
    } else {
      // J2SE does not support Xalan interpretive
      // false -> true
      boolean useXSLTC = true;
      for (int i = 0; i < argv.length; i++) {
        if ("-XSLTC".equalsIgnoreCase(argv[i])) {
          useXSLTC = true;
        }
      }

      TransformerFactory tfactory;
      if (useXSLTC) {
        String key = "javax.xml.transform.TransformerFactory";
        String value = "com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl";
        Properties props = System.getProperties();
        props.put(key, value);
        System.setProperties(props);
      }

      try {
        tfactory = TransformerFactory.newInstance();
        tfactory.setErrorListener(new DefaultErrorHandler());
      } catch (TransformerFactoryConfigurationError pfe) {
        pfe.printStackTrace(dumpWriter);
        //      "XSL Process was not successful.");
        msg = XSLMessages.createMessage(XSLTErrorResources.ER_NOT_SUCCESSFUL, null);
        diagnosticsWriter.println(msg);

        tfactory = null; // shut up compiler

        doExit(msg);
      }

      boolean formatOutput = false;
      boolean useSourceLocation = false;
      String inFileName = null;
      String outFileName = null;
      String dumpFileName = null;
      String xslFileName = null;
      String treedumpFileName = null;
      // J2SE does not support Xalan interpretive
      /*
      PrintTraceListener tracer = null;
      */
      String outputType = null;
      String media = null;
      Vector params = new Vector();
      boolean quietConflictWarnings = false;
      URIResolver uriResolver = null;
      EntityResolver entityResolver = null;
      ContentHandler contentHandler = null;
      int recursionLimit = -1;

      for (int i = 0; i < argv.length; i++) {
        if ("-XSLTC".equalsIgnoreCase(argv[i])) {
          // The -XSLTC option has been processed.
        }
        // J2SE does not support Xalan interpretive
        /*
        else if ("-TT".equalsIgnoreCase(argv[i]))
        {
          if (!useXSLTC)
          {
            if (null == tracer)
              tracer = new PrintTraceListener(diagnosticsWriter);

            tracer.m_traceTemplates = true;
          }
          else
            printInvalidXSLTCOption("-TT");

          // tfactory.setTraceTemplates(true);
        }
        else if ("-TG".equalsIgnoreCase(argv[i]))
        {
          if (!useXSLTC)
          {
            if (null == tracer)
              tracer = new PrintTraceListener(diagnosticsWriter);

            tracer.m_traceGeneration = true;
          }
          else
            printInvalidXSLTCOption("-TG");

          // tfactory.setTraceSelect(true);
        }
        else if ("-TS".equalsIgnoreCase(argv[i]))
        {
          if (!useXSLTC)
          {
            if (null == tracer)
              tracer = new PrintTraceListener(diagnosticsWriter);

            tracer.m_traceSelection = true;
          }
          else
            printInvalidXSLTCOption("-TS");

          // tfactory.setTraceTemplates(true);
        }
        else if ("-TTC".equalsIgnoreCase(argv[i]))
        {
          if (!useXSLTC)
          {
            if (null == tracer)
              tracer = new PrintTraceListener(diagnosticsWriter);

            tracer.m_traceElements = true;
          }
          else
            printInvalidXSLTCOption("-TTC");

          // tfactory.setTraceTemplateChildren(true);
        }
        */
        else if ("-INDENT".equalsIgnoreCase(argv[i])) {
          int indentAmount;

          if (((i + 1) < argv.length) && (argv[i + 1].charAt(0) != '-')) {
            indentAmount = Integer.parseInt(argv[++i]);
          } else {
            indentAmount = 0;
          }

          // TBD:
          // xmlProcessorLiaison.setIndent(indentAmount);
        } else if ("-IN".equalsIgnoreCase(argv[i])) {
          if (i + 1 < argv.length && argv[i + 1].charAt(0) != '-') inFileName = argv[++i];
          else
            System.err.println(
                XSLMessages.createMessage(
                    XSLTErrorResources.ER_MISSING_ARG_FOR_OPTION,
                    new Object[] {"-IN"})); // "Missing argument for);
        } else if ("-MEDIA".equalsIgnoreCase(argv[i])) {
          if (i + 1 < argv.length) media = argv[++i];
          else
            System.err.println(
                XSLMessages.createMessage(
                    XSLTErrorResources.ER_MISSING_ARG_FOR_OPTION,
                    new Object[] {"-MEDIA"})); // "Missing argument for);
        } else if ("-OUT".equalsIgnoreCase(argv[i])) {
          if (i + 1 < argv.length && argv[i + 1].charAt(0) != '-') outFileName = argv[++i];
          else
            System.err.println(
                XSLMessages.createMessage(
                    XSLTErrorResources.ER_MISSING_ARG_FOR_OPTION,
                    new Object[] {"-OUT"})); // "Missing argument for);
        } else if ("-XSL".equalsIgnoreCase(argv[i])) {
          if (i + 1 < argv.length && argv[i + 1].charAt(0) != '-') xslFileName = argv[++i];
          else
            System.err.println(
                XSLMessages.createMessage(
                    XSLTErrorResources.ER_MISSING_ARG_FOR_OPTION,
                    new Object[] {"-XSL"})); // "Missing argument for);
        } else if ("-FLAVOR".equalsIgnoreCase(argv[i])) {
          if (i + 1 < argv.length) {
            flavor = argv[++i];
          } else
            System.err.println(
                XSLMessages.createMessage(
                    XSLTErrorResources.ER_MISSING_ARG_FOR_OPTION,
                    new Object[] {"-FLAVOR"})); // "Missing argument for);
        } else if ("-PARAM".equalsIgnoreCase(argv[i])) {
          if (i + 2 < argv.length) {
            String name = argv[++i];

            params.addElement(name);

            String expression = argv[++i];

            params.addElement(expression);
          } else
            System.err.println(
                XSLMessages.createMessage(
                    XSLTErrorResources.ER_MISSING_ARG_FOR_OPTION,
                    new Object[] {"-PARAM"})); // "Missing argument for);
        } else if ("-E".equalsIgnoreCase(argv[i])) {

          // TBD:
          // xmlProcessorLiaison.setShouldExpandEntityRefs(false);
        } else if ("-V".equalsIgnoreCase(argv[i])) {
          diagnosticsWriter.println(
              resbundle.getString("version") // ">>>>>>> Xalan Version "
                  + Version.getVersion()
                  + ", "
                  +

                  /* xmlProcessorLiaison.getParserDescription()+ */
                  resbundle.getString("version2")); // "<<<<<<<");
        }
        // J2SE does not support Xalan interpretive
        /*
        else if ("-QC".equalsIgnoreCase(argv[i]))
        {
          if (!useXSLTC)
            quietConflictWarnings = true;
          else
            printInvalidXSLTCOption("-QC");
        }
        */
        else if ("-Q".equalsIgnoreCase(argv[i])) {
          setQuietMode = true;
        } else if ("-DIAG".equalsIgnoreCase(argv[i])) {
          doDiag = true;
        } else if ("-XML".equalsIgnoreCase(argv[i])) {
          outputType = "xml";
        } else if ("-TEXT".equalsIgnoreCase(argv[i])) {
          outputType = "text";
        } else if ("-HTML".equalsIgnoreCase(argv[i])) {
          outputType = "html";
        } else if ("-EDUMP".equalsIgnoreCase(argv[i])) {
          doStackDumpOnError = true;

          if (((i + 1) < argv.length) && (argv[i + 1].charAt(0) != '-')) {
            dumpFileName = argv[++i];
          }
        } else if ("-URIRESOLVER".equalsIgnoreCase(argv[i])) {
          if (i + 1 < argv.length) {
            try {
              uriResolver = (URIResolver) ObjectFactory.newInstance(argv[++i], true);

              tfactory.setURIResolver(uriResolver);
            } catch (ConfigurationError cnfe) {
              msg =
                  XSLMessages.createMessage(
                      XSLTErrorResources.ER_CLASS_NOT_FOUND_FOR_OPTION,
                      new Object[] {"-URIResolver"});
              System.err.println(msg);
              doExit(msg);
            }
          } else {
            msg =
                XSLMessages.createMessage(
                    XSLTErrorResources.ER_MISSING_ARG_FOR_OPTION,
                    new Object[] {"-URIResolver"}); // "Missing argument for);
            System.err.println(msg);
            doExit(msg);
          }
        } else if ("-ENTITYRESOLVER".equalsIgnoreCase(argv[i])) {
          if (i + 1 < argv.length) {
            try {
              entityResolver = (EntityResolver) ObjectFactory.newInstance(argv[++i], true);
            } catch (ConfigurationError cnfe) {
              msg =
                  XSLMessages.createMessage(
                      XSLTErrorResources.ER_CLASS_NOT_FOUND_FOR_OPTION,
                      new Object[] {"-EntityResolver"});
              System.err.println(msg);
              doExit(msg);
            }
          } else {
            //            "Missing argument for);
            msg =
                XSLMessages.createMessage(
                    XSLTErrorResources.ER_MISSING_ARG_FOR_OPTION, new Object[] {"-EntityResolver"});
            System.err.println(msg);
            doExit(msg);
          }
        } else if ("-CONTENTHANDLER".equalsIgnoreCase(argv[i])) {
          if (i + 1 < argv.length) {
            try {
              contentHandler = (ContentHandler) ObjectFactory.newInstance(argv[++i], true);
            } catch (ConfigurationError cnfe) {
              msg =
                  XSLMessages.createMessage(
                      XSLTErrorResources.ER_CLASS_NOT_FOUND_FOR_OPTION,
                      new Object[] {"-ContentHandler"});
              System.err.println(msg);
              doExit(msg);
            }
          } else {
            //            "Missing argument for);
            msg =
                XSLMessages.createMessage(
                    XSLTErrorResources.ER_MISSING_ARG_FOR_OPTION, new Object[] {"-ContentHandler"});
            System.err.println(msg);
            doExit(msg);
          }
        }
        // J2SE does not support Xalan interpretive
        /*
        else if ("-L".equalsIgnoreCase(argv[i]))
        {
          if (!useXSLTC)
            tfactory.setAttribute(XalanProperties.SOURCE_LOCATION, Boolean.TRUE);
          else
            printInvalidXSLTCOption("-L");
        }
        else if ("-INCREMENTAL".equalsIgnoreCase(argv[i]))
        {
          if (!useXSLTC)
            tfactory.setAttribute
              ("http://xml.apache.org/xalan/features/incremental",
               java.lang.Boolean.TRUE);
          else
            printInvalidXSLTCOption("-INCREMENTAL");
        }
        else if ("-NOOPTIMIZE".equalsIgnoreCase(argv[i]))
        {
          // Default is true.
          //
          // %REVIEW% We should have a generalized syntax for negative
          // switches...  and probably should accept the inverse even
          // if it is the default.
          if (!useXSLTC)
            tfactory.setAttribute
              ("http://xml.apache.org/xalan/features/optimize",
               java.lang.Boolean.FALSE);
          else
            printInvalidXSLTCOption("-NOOPTIMIZE");
        }
        else if ("-RL".equalsIgnoreCase(argv[i]))
        {
          if (!useXSLTC)
          {
            if (i + 1 < argv.length)
              recursionLimit = Integer.parseInt(argv[++i]);
            else
              System.err.println(
                XSLMessages.createMessage(
                  XSLTErrorResources.ER_MISSING_ARG_FOR_OPTION,
                  new Object[]{ "-rl" }));  //"Missing argument for);
          }
          else
          {
            if (i + 1 < argv.length && argv[i + 1].charAt(0) != '-')
             i++;

            printInvalidXSLTCOption("-RL");
          }
        }
        */
        // Generate the translet class and optionally specify the name
        // of the translet class.
        else if ("-XO".equalsIgnoreCase(argv[i])) {
          if (useXSLTC) {
            if (i + 1 < argv.length && argv[i + 1].charAt(0) != '-') {
              tfactory.setAttribute("generate-translet", "true");
              tfactory.setAttribute("translet-name", argv[++i]);
            } else tfactory.setAttribute("generate-translet", "true");
          } else {
            if (i + 1 < argv.length && argv[i + 1].charAt(0) != '-') i++;
            printInvalidXalanOption("-XO");
          }
        }
        // Specify the destination directory for the translet classes.
        else if ("-XD".equalsIgnoreCase(argv[i])) {
          if (useXSLTC) {
            if (i + 1 < argv.length && argv[i + 1].charAt(0) != '-')
              tfactory.setAttribute("destination-directory", argv[++i]);
            else
              System.err.println(
                  XSLMessages.createMessage(
                      XSLTErrorResources.ER_MISSING_ARG_FOR_OPTION,
                      new Object[] {"-XD"})); // "Missing argument for);

          } else {
            if (i + 1 < argv.length && argv[i + 1].charAt(0) != '-') i++;

            printInvalidXalanOption("-XD");
          }
        }
        // Specify the jar file name which the translet classes are packaged into.
        else if ("-XJ".equalsIgnoreCase(argv[i])) {
          if (useXSLTC) {
            if (i + 1 < argv.length && argv[i + 1].charAt(0) != '-') {
              tfactory.setAttribute("generate-translet", "true");
              tfactory.setAttribute("jar-name", argv[++i]);
            } else
              System.err.println(
                  XSLMessages.createMessage(
                      XSLTErrorResources.ER_MISSING_ARG_FOR_OPTION,
                      new Object[] {"-XJ"})); // "Missing argument for);
          } else {
            if (i + 1 < argv.length && argv[i + 1].charAt(0) != '-') i++;

            printInvalidXalanOption("-XJ");
          }

        }
        // Specify the package name prefix for the generated translet classes.
        else if ("-XP".equalsIgnoreCase(argv[i])) {
          if (useXSLTC) {
            if (i + 1 < argv.length && argv[i + 1].charAt(0) != '-')
              tfactory.setAttribute("package-name", argv[++i]);
            else
              System.err.println(
                  XSLMessages.createMessage(
                      XSLTErrorResources.ER_MISSING_ARG_FOR_OPTION,
                      new Object[] {"-XP"})); // "Missing argument for);
          } else {
            if (i + 1 < argv.length && argv[i + 1].charAt(0) != '-') i++;

            printInvalidXalanOption("-XP");
          }

        }
        // Enable template inlining.
        else if ("-XN".equalsIgnoreCase(argv[i])) {
          if (useXSLTC) {
            tfactory.setAttribute("enable-inlining", "true");
          } else printInvalidXalanOption("-XN");
        }
        // Turns on additional debugging message output
        else if ("-XX".equalsIgnoreCase(argv[i])) {
          if (useXSLTC) {
            tfactory.setAttribute("debug", "true");
          } else printInvalidXalanOption("-XX");
        }
        // Create the Transformer from the translet if the translet class is newer
        // than the stylesheet.
        else if ("-XT".equalsIgnoreCase(argv[i])) {
          if (useXSLTC) {
            tfactory.setAttribute("auto-translet", "true");
          } else printInvalidXalanOption("-XT");
        } else if ("-SECURE".equalsIgnoreCase(argv[i])) {
          isSecureProcessing = true;
          try {
            tfactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
          } catch (TransformerConfigurationException e) {
          }
        } else
          System.err.println(
              XSLMessages.createMessage(
                  XSLTErrorResources.ER_INVALID_OPTION,
                  new Object[] {argv[i]})); // "Invalid argument:);
      }

      // Print usage instructions if no xml and xsl file is specified in the command line
      if (inFileName == null && xslFileName == null) {
        msg = resbundle.getString("xslProc_no_input");
        System.err.println(msg);
        doExit(msg);
      }

      // Note that there are usage cases for calling us without a -IN arg
      // The main XSL transformation occurs here!
      try {
        long start = System.currentTimeMillis();

        if (null != dumpFileName) {
          dumpWriter = new PrintWriter(new FileWriter(dumpFileName));
        }

        Templates stylesheet = null;

        if (null != xslFileName) {
          if (flavor.equals("d2d")) {

            // Parse in the xml data into a DOM
            DocumentBuilderFactory dfactory = DocumentBuilderFactory.newInstance();

            dfactory.setNamespaceAware(true);

            if (isSecureProcessing) {
              try {
                dfactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
              } catch (ParserConfigurationException pce) {
              }
            }

            DocumentBuilder docBuilder = dfactory.newDocumentBuilder();
            Node xslDOM = docBuilder.parse(new InputSource(xslFileName));

            stylesheet = tfactory.newTemplates(new DOMSource(xslDOM, xslFileName));
          } else {
            // System.out.println("Calling newTemplates: "+xslFileName);
            stylesheet = tfactory.newTemplates(new StreamSource(xslFileName));
            // System.out.println("Done calling newTemplates: "+xslFileName);
          }
        }

        PrintWriter resultWriter;
        StreamResult strResult;

        if (null != outFileName) {
          strResult = new StreamResult(new FileOutputStream(outFileName));
          // One possible improvement might be to ensure this is
          //  a valid URI before setting the systemId, but that
          //  might have subtle changes that pre-existing users
          //  might notice; we can think about that later -sc r1.46
          strResult.setSystemId(outFileName);
        } else {
          strResult = new StreamResult(System.out);
          // We used to default to incremental mode in this case.
          // We've since decided that since the -INCREMENTAL switch is
          // available, that default is probably not necessary nor
          // necessarily a good idea.
        }

        SAXTransformerFactory stf = (SAXTransformerFactory) tfactory;

        // J2SE does not support Xalan interpretive
        /*
                // This is currently controlled via TransformerFactoryImpl.
        if (!useXSLTC && useSourceLocation)
           stf.setAttribute(XalanProperties.SOURCE_LOCATION, Boolean.TRUE);
        */

        // Did they pass in a stylesheet, or should we get it from the
        // document?
        if (null == stylesheet) {
          Source source =
              stf.getAssociatedStylesheet(new StreamSource(inFileName), media, null, null);

          if (null != source) stylesheet = tfactory.newTemplates(source);
          else {
            if (null != media)
              throw new TransformerException(
                  XSLMessages.createMessage(
                      XSLTErrorResources.ER_NO_STYLESHEET_IN_MEDIA,
                      new Object[] {inFileName, media})); // "No stylesheet found in: "
            // + inFileName + ", media="
            // + media);
            else
              throw new TransformerException(
                  XSLMessages.createMessage(
                      XSLTErrorResources.ER_NO_STYLESHEET_PI,
                      new Object[] {inFileName})); // "No xml-stylesheet PI found in: "
            // + inFileName);
          }
        }

        if (null != stylesheet) {
          Transformer transformer = flavor.equals("th") ? null : stylesheet.newTransformer();
          transformer.setErrorListener(new DefaultErrorHandler());

          // Override the output format?
          if (null != outputType) {
            transformer.setOutputProperty(OutputKeys.METHOD, outputType);
          }

          // J2SE does not support Xalan interpretive
          /*
          if (transformer instanceof com.sun.org.apache.xalan.internal.transformer.TransformerImpl)
          {
            com.sun.org.apache.xalan.internal.transformer.TransformerImpl impl = (com.sun.org.apache.xalan.internal.transformer.TransformerImpl)transformer;
            TraceManager tm = impl.getTraceManager();

            if (null != tracer)
              tm.addTraceListener(tracer);

            impl.setQuietConflictWarnings(quietConflictWarnings);

                        // This is currently controlled via TransformerFactoryImpl.
            if (useSourceLocation)
              impl.setProperty(XalanProperties.SOURCE_LOCATION, Boolean.TRUE);

            if(recursionLimit>0)
              impl.setRecursionLimit(recursionLimit);

            // sc 28-Feb-01 if we re-implement this, please uncomment helpmsg in printArgOptions
            // impl.setDiagnosticsOutput( setQuietMode ? null : diagnosticsWriter );
          }
          */

          int nParams = params.size();

          for (int i = 0; i < nParams; i += 2) {
            transformer.setParameter(
                (String) params.elementAt(i), (String) params.elementAt(i + 1));
          }

          if (uriResolver != null) transformer.setURIResolver(uriResolver);

          if (null != inFileName) {
            if (flavor.equals("d2d")) {

              // Parse in the xml data into a DOM
              DocumentBuilderFactory dfactory = DocumentBuilderFactory.newInstance();

              dfactory.setCoalescing(true);
              dfactory.setNamespaceAware(true);

              if (isSecureProcessing) {
                try {
                  dfactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
                } catch (ParserConfigurationException pce) {
                }
              }

              DocumentBuilder docBuilder = dfactory.newDocumentBuilder();

              if (entityResolver != null) docBuilder.setEntityResolver(entityResolver);

              Node xmlDoc = docBuilder.parse(new InputSource(inFileName));
              Document doc = docBuilder.newDocument();
              org.w3c.dom.DocumentFragment outNode = doc.createDocumentFragment();

              transformer.transform(new DOMSource(xmlDoc, inFileName), new DOMResult(outNode));

              // Now serialize output to disk with identity transformer
              Transformer serializer = stf.newTransformer();
              serializer.setErrorListener(new DefaultErrorHandler());

              Properties serializationProps = stylesheet.getOutputProperties();

              serializer.setOutputProperties(serializationProps);

              if (contentHandler != null) {
                SAXResult result = new SAXResult(contentHandler);

                serializer.transform(new DOMSource(outNode), result);
              } else serializer.transform(new DOMSource(outNode), strResult);
            } else if (flavor.equals("th")) {
              for (int i = 0; i < 1; i++) // Loop for diagnosing bugs with inconsistent behavior
              {
                // System.out.println("Testing the TransformerHandler...");

                XMLReader reader = null;

                // Use JAXP1.1 ( if possible )
                try {
                  javax.xml.parsers.SAXParserFactory factory =
                      javax.xml.parsers.SAXParserFactory.newInstance();

                  factory.setNamespaceAware(true);

                  if (isSecureProcessing) {
                    try {
                      factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
                    } catch (org.xml.sax.SAXException se) {
                    }
                  }

                  javax.xml.parsers.SAXParser jaxpParser = factory.newSAXParser();

                  reader = jaxpParser.getXMLReader();
                } catch (javax.xml.parsers.ParserConfigurationException ex) {
                  throw new org.xml.sax.SAXException(ex);
                } catch (javax.xml.parsers.FactoryConfigurationError ex1) {
                  throw new org.xml.sax.SAXException(ex1.toString());
                } catch (NoSuchMethodError ex2) {
                } catch (AbstractMethodError ame) {
                }

                if (null == reader) {
                  reader = XMLReaderFactory.createXMLReader();
                }

                // J2SE does not support Xalan interpretive
                /*
                if (!useXSLTC)
                  stf.setAttribute(com.sun.org.apache.xalan.internal.processor.TransformerFactoryImpl.FEATURE_INCREMENTAL,
                     Boolean.TRUE);
                */

                TransformerHandler th = stf.newTransformerHandler(stylesheet);

                reader.setContentHandler(th);
                reader.setDTDHandler(th);

                if (th instanceof org.xml.sax.ErrorHandler)
                  reader.setErrorHandler((org.xml.sax.ErrorHandler) th);

                try {
                  reader.setProperty("http://xml.org/sax/properties/lexical-handler", th);
                } catch (org.xml.sax.SAXNotRecognizedException e) {
                } catch (org.xml.sax.SAXNotSupportedException e) {
                }
                try {
                  reader.setFeature("http://xml.org/sax/features/namespace-prefixes", true);
                } catch (org.xml.sax.SAXException se) {
                }

                th.setResult(strResult);

                reader.parse(new InputSource(inFileName));
              }
            } else {
              if (entityResolver != null) {
                XMLReader reader = null;

                // Use JAXP1.1 ( if possible )
                try {
                  javax.xml.parsers.SAXParserFactory factory =
                      javax.xml.parsers.SAXParserFactory.newInstance();

                  factory.setNamespaceAware(true);

                  if (isSecureProcessing) {
                    try {
                      factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
                    } catch (org.xml.sax.SAXException se) {
                    }
                  }

                  javax.xml.parsers.SAXParser jaxpParser = factory.newSAXParser();

                  reader = jaxpParser.getXMLReader();
                } catch (javax.xml.parsers.ParserConfigurationException ex) {
                  throw new org.xml.sax.SAXException(ex);
                } catch (javax.xml.parsers.FactoryConfigurationError ex1) {
                  throw new org.xml.sax.SAXException(ex1.toString());
                } catch (NoSuchMethodError ex2) {
                } catch (AbstractMethodError ame) {
                }

                if (null == reader) {
                  reader = XMLReaderFactory.createXMLReader();
                }

                reader.setEntityResolver(entityResolver);

                if (contentHandler != null) {
                  SAXResult result = new SAXResult(contentHandler);

                  transformer.transform(new SAXSource(reader, new InputSource(inFileName)), result);
                } else {
                  transformer.transform(
                      new SAXSource(reader, new InputSource(inFileName)), strResult);
                }
              } else if (contentHandler != null) {
                SAXResult result = new SAXResult(contentHandler);

                transformer.transform(new StreamSource(inFileName), result);
              } else {
                // System.out.println("Starting transform");
                transformer.transform(new StreamSource(inFileName), strResult);
                // System.out.println("Done with transform");
              }
            }
          } else {
            StringReader reader = new StringReader("<?xml version=\"1.0\"?> <doc/>");

            transformer.transform(new StreamSource(reader), strResult);
          }
        } else {
          //          "XSL Process was not successful.");
          msg = XSLMessages.createMessage(XSLTErrorResources.ER_NOT_SUCCESSFUL, null);
          diagnosticsWriter.println(msg);
          doExit(msg);
        }

        // close output streams
        if (null != outFileName && strResult != null) {
          java.io.OutputStream out = strResult.getOutputStream();
          java.io.Writer writer = strResult.getWriter();
          try {
            if (out != null) out.close();
            if (writer != null) writer.close();
          } catch (java.io.IOException ie) {
          }
        }

        long stop = System.currentTimeMillis();
        long millisecondsDuration = stop - start;

        if (doDiag) {
          Object[] msgArgs = new Object[] {inFileName, xslFileName, new Long(millisecondsDuration)};
          msg = XSLMessages.createMessage("diagTiming", msgArgs);
          diagnosticsWriter.println('\n');
          diagnosticsWriter.println(msg);
        }

      } catch (Throwable throwable) {
        while (throwable instanceof com.sun.org.apache.xml.internal.utils.WrappedRuntimeException) {
          throwable =
              ((com.sun.org.apache.xml.internal.utils.WrappedRuntimeException) throwable)
                  .getException();
        }

        if ((throwable instanceof NullPointerException)
            || (throwable instanceof ClassCastException)) doStackDumpOnError = true;

        diagnosticsWriter.println();

        if (doStackDumpOnError) throwable.printStackTrace(dumpWriter);
        else {
          DefaultErrorHandler.printLocation(diagnosticsWriter, throwable);
          diagnosticsWriter.println(
              XSLMessages.createMessage(XSLTErrorResources.ER_XSLT_ERROR, null)
                  + " ("
                  + throwable.getClass().getName()
                  + "): "
                  + throwable.getMessage());
        }

        // diagnosticsWriter.println(XSLMessages.createMessage(XSLTErrorResources.ER_NOT_SUCCESSFUL,
        // null)); //"XSL Process was not successful.");
        if (null != dumpFileName) {
          dumpWriter.close();
        }

        doExit(throwable.getMessage());
      }

      if (null != dumpFileName) {
        dumpWriter.close();
      }

      if (null != diagnosticsWriter) {

        // diagnosticsWriter.close();
      }

      // if(!setQuietMode)
      //  diagnosticsWriter.println(resbundle.getString("xsldone")); //"Xalan: done");
      // else
      // diagnosticsWriter.println("");  //"Xalan: done");
    }
  }
Exemple #23
0
  /**
   * @param path Path, starting with /, relative to context root, of xsl
   * @return The jaxp object for the specified path.
   * @exception ConfigException
   */
  protected Templates loadTemplate(String path, ServletContext servletCtx) throws ConfigException {
    boolean pathIsFileUrl = false;
    boolean pathIsOtherUrl = false;
    java.net.URL resURL = null;

    if (this.isMonitoredFile && this.monitoredFile != null) {
      // This happens if the file is monitored and it has changed on the filesystem
      try {
        resURL = this.monitoredFile.toURI().toURL();
        this.monitoredFileLastModified = this.monitoredFile.lastModified();
      } catch (MalformedURLException me) {
        log.error("Eror parsing monitored template URL " + path + ":  " + me.toString());
        throw new ConfigException(me);
      } catch (SecurityException se) {
        log.error("Unable to access monitored template " + path + ":  " + se.toString());
        throw new ConfigException(se);
      }
    } else {
      // Check to see if the path is a URL and what type, otherwise make sure
      // it's a proper servlet resource path
      if (path.toLowerCase().startsWith("file:")) pathIsFileUrl = true;
      else if (path.toLowerCase().startsWith("http:")
          || path.toLowerCase().startsWith("https:")
          || path.toLowerCase().startsWith("ftp:")) pathIsOtherUrl = true;
      else if (!path.startsWith("/")) path = "/" + path;

      try {
        if (pathIsFileUrl && this.isMonitoredFile) {
          resURL = new java.net.URL(path);
          this.monitoredFile = new File(resURL.getFile());

          if (this.monitoredFile == null || !this.monitoredFile.canRead()) {
            this.monitoredFile = null;
            log.error("Resource not found or unable to read file:  " + path);
            throw new ConfigException("Resource not found or unable to read file:  " + path);
          }

          this.monitoredFileLastModified = this.monitoredFile.lastModified();
        } else if (pathIsFileUrl || pathIsOtherUrl) resURL = new java.net.URL(path);
        else resURL = servletCtx.getResource(path);

        if (resURL == null) {
          log.error("Resource not found:  " + path);
          throw new ConfigException("Resource not found:  " + path);
        }
      } catch (MalformedURLException me) {
        log.error("Eror parsing template URL " + path + ":  " + me.toString());
        throw new ConfigException(me);
      }
    }

    try {
      TransformerFactory tFactory = TransformerFactory.newInstance();
      if (this.uriResolver != null) tFactory.setURIResolver(this.uriResolver);

      return tFactory.newTemplates(new StreamSource(resURL.openStream(), resURL.toString()));
    } catch (TransformerException ex) {
      log.error("Error loading template " + path + ":  " + ex.toString());
      throw new ConfigException(ex);
    } catch (IOException ex) {
      log.error("Eror loading template " + path + ":  " + ex.toString());
      throw new ConfigException(ex);
    }
  }
Exemple #24
0
  private void createTemplate(Source xslSource) throws TransformerException {

    if (m_template == null) {
      m_template = m_tFactory.newTemplates(xslSource);
    }
  }
  private boolean processOneXMLFile(
      String xmlfilename, String xslfilename, String outputfilename, Result result, Job parentJob) {
    boolean retval = false;
    FileObject xmlfile = null;
    FileObject xslfile = null;
    FileObject outputfile = null;

    try {
      xmlfile = KettleVFS.getFileObject(xmlfilename, this);
      xslfile = KettleVFS.getFileObject(xslfilename, this);
      outputfile = KettleVFS.getFileObject(outputfilename, this);

      if (xmlfile.exists() && xslfile.exists()) {
        if (outputfile.exists() && iffileexists == 2) {
          // Output file exists
          // User want to fail
          logError(
              BaseMessages.getString(PKG, "JobEntryXSLT.OuputFileExists1.Label")
                  + outputfilename
                  + BaseMessages.getString(PKG, "JobEntryXSLT.OuputFileExists2.Label"));
          return retval;

        } else if (outputfile.exists() && iffileexists == 1) {
          // Do nothing
          if (log.isDebug()) {
            logDebug(
                BaseMessages.getString(PKG, "JobEntryXSLT.OuputFileExists1.Label")
                    + outputfilename
                    + BaseMessages.getString(PKG, "JobEntryXSLT.OuputFileExists2.Label"));
          }
          retval = true;
          return retval;

        } else {
          if (outputfile.exists() && iffileexists == 0) {
            // the output file exists and user want to create new one with unique name
            // Format Date

            // Try to clean filename (without wildcard)
            String wildcard =
                outputfilename.substring(outputfilename.length() - 4, outputfilename.length());
            if (wildcard.substring(0, 1).equals(".")) {
              // Find wildcard
              outputfilename =
                  outputfilename.substring(0, outputfilename.length() - 4)
                      + "_"
                      + StringUtil.getFormattedDateTimeNow(true)
                      + wildcard;
            } else {
              // did not find wildcard
              outputfilename = outputfilename + "_" + StringUtil.getFormattedDateTimeNow(true);
            }
            if (log.isDebug()) {
              logDebug(
                  BaseMessages.getString(PKG, "JobEntryXSLT.OuputFileExists1.Label")
                      + outputfilename
                      + BaseMessages.getString(PKG, "JobEntryXSLT.OuputFileExists2.Label"));
              logDebug(
                  BaseMessages.getString(PKG, "JobEntryXSLT.OuputFileNameChange1.Label")
                      + outputfilename
                      + BaseMessages.getString(PKG, "JobEntryXSLT.OuputFileNameChange2.Label"));
            }
          }

          // Create transformer factory
          TransformerFactory factory = TransformerFactory.newInstance();

          if (xsltfactory.equals(FACTORY_SAXON)) {
            // Set the TransformerFactory to the SAXON implementation.
            factory = new net.sf.saxon.TransformerFactoryImpl();
          }

          if (log.isDetailed()) {
            log.logDetailed(
                BaseMessages.getString(PKG, "JobEntryXSL.Log.TransformerFactoryInfos"),
                BaseMessages.getString(
                    PKG, "JobEntryXSL.Log.TransformerFactory", factory.getClass().getName()));
          }

          InputStream xslInputStream = KettleVFS.getInputStream(xslfile);
          InputStream xmlInputStream = KettleVFS.getInputStream(xmlfile);
          OutputStream os = null;
          try {
            // Use the factory to create a template containing the xsl file
            Templates template = factory.newTemplates(new StreamSource(xslInputStream));

            // Use the template to create a transformer
            Transformer xformer = template.newTransformer();

            if (log.isDetailed()) {
              log.logDetailed(
                  BaseMessages.getString(PKG, "JobEntryXSL.Log.TransformerClassInfos"),
                  BaseMessages.getString(
                      PKG, "JobEntryXSL.Log.TransformerClass", xformer.getClass().getName()));
            }

            // Do we need to set output properties?
            if (setOutputProperties) {
              xformer.setOutputProperties(outputProperties);
            }

            // Do we need to pass parameters?
            if (useParameters) {
              for (int i = 0; i < nrParams; i++) {
                xformer.setParameter(nameOfParams[i], valueOfParams[i]);
              }
            }

            // Prepare the input and output files
            Source source = new StreamSource(xmlInputStream);
            os = KettleVFS.getOutputStream(outputfile, false);
            StreamResult resultat = new StreamResult(os);

            // Apply the xsl file to the source file and write the result to the output file
            xformer.transform(source, resultat);

            if (isAddFileToResult()) {
              // Add output filename to output files
              ResultFile resultFile =
                  new ResultFile(
                      ResultFile.FILE_TYPE_GENERAL,
                      KettleVFS.getFileObject(outputfilename, this),
                      parentJob.getJobname(),
                      toString());
              result.getResultFiles().put(resultFile.getFile().toString(), resultFile);
            }

            // Everything is OK
            retval = true;
          } finally {
            try {
              xslInputStream.close();
            } catch (IOException ignored) {
              // ignore IO Exception on close
            }
            try {
              xmlInputStream.close();
            } catch (IOException ignored) {
              // ignore IO Exception on close
            }
            try {
              if (os != null) {
                os.close();
              }
            } catch (IOException ignored) {
              // ignore IO Exception on close
            }
          }
        }
      } else {

        if (!xmlfile.exists()) {
          logError(
              BaseMessages.getString(PKG, "JobEntryXSLT.FileDoesNotExist1.Label")
                  + xmlfilename
                  + BaseMessages.getString(PKG, "JobEntryXSLT.FileDoesNotExist2.Label"));
        }
        if (!xslfile.exists()) {
          logError(
              BaseMessages.getString(PKG, "JobEntryXSLT.FileDoesNotExist1.Label")
                  + xmlfilename
                  + BaseMessages.getString(PKG, "JobEntryXSLT.FileDoesNotExist2.Label"));
        }
      }
    } catch (Exception e) {
      logError(
          BaseMessages.getString(PKG, "JobEntryXSLT.ErrorXLST.Label")
              + BaseMessages.getString(PKG, "JobEntryXSLT.ErrorXLSTXML1.Label")
              + xmlfilename
              + BaseMessages.getString(PKG, "JobEntryXSLT.ErrorXLSTXML2.Label")
              + BaseMessages.getString(PKG, "JobEntryXSLT.ErrorXLSTXSL1.Label")
              + xslfilename
              + BaseMessages.getString(PKG, "JobEntryXSLT.ErrorXLSTXSL2.Label")
              + e.getMessage());
    } finally {
      try {
        if (xmlfile != null) {
          xmlfile.close();
        }

        if (xslfile != null) {
          xslfile.close();
        }
        if (outputfile != null) {
          outputfile.close();
        }
      } catch (IOException e) {
        logError("Unable to close file", e);
      }
    }

    return retval;
  }