/** * Report version info from DOM interfaces. * * <p>Currently distinguishes between pre-DOM level 2, the DOM level 2 working draft, the DOM * level 2 final draft, and not found. * * @param h Hashtable to put information in */ protected void checkDOMVersion(Hashtable h) { if (null == h) h = new Hashtable(); final String DOM_LEVEL2_CLASS = "org.w3c.dom.Document"; final String DOM_LEVEL2_METHOD = "createElementNS"; // String, String final String DOM_LEVEL3_METHOD = "getDoctype"; // no parameter final String DOM_LEVEL2WD_CLASS = "org.w3c.dom.Node"; final String DOM_LEVEL2WD_METHOD = "supported"; // String, String final String DOM_LEVEL2FD_CLASS = "org.w3c.dom.Node"; final String DOM_LEVEL2FD_METHOD = "isSupported"; // String, String final Class twoStringArgs[] = {java.lang.String.class, java.lang.String.class}; try { Class clazz = ObjectFactory.findProviderClass(DOM_LEVEL2_CLASS, true); Method method = clazz.getMethod(DOM_LEVEL2_METHOD, twoStringArgs); // If we succeeded, we have loaded interfaces from a // level 2 DOM somewhere h.put(VERSION + "DOM", "2.0"); try { // Check for the working draft version, which is // commonly found, but won't work anymore clazz = ObjectFactory.findProviderClass(DOM_LEVEL2WD_CLASS, true); method = clazz.getMethod(DOM_LEVEL2WD_METHOD, twoStringArgs); h.put(ERROR + VERSION + "DOM.draftlevel", "2.0wd"); h.put(ERROR, ERROR_FOUND); } catch (Exception e2) { try { // Check for the final draft version as well clazz = ObjectFactory.findProviderClass(DOM_LEVEL2FD_CLASS, true); method = clazz.getMethod(DOM_LEVEL2FD_METHOD, twoStringArgs); h.put(VERSION + "DOM.draftlevel", "2.0fd"); } catch (Exception e3) { h.put(ERROR + VERSION + "DOM.draftlevel", "2.0unknown"); h.put(ERROR, ERROR_FOUND); } } } catch (Exception e) { h.put(ERROR + VERSION + "DOM", "ERROR attempting to load DOM level 2 class: " + e.toString()); h.put(ERROR, ERROR_FOUND); } // @todo load an actual DOM implmementation and query it as well // @todo load an actual DOM implmementation and check if // isNamespaceAware() == true, which is needed to parse // xsl stylesheet files into a DOM }
/** * Report product version information from common parsers. * * <p>Looks for version info in xerces.jar/xercesImpl.jar/crimson.jar. * * <p>//@todo actually look up version info in crimson manifest * * @param h Hashtable to put information in */ protected void checkParserVersion(Hashtable h) { if (null == h) h = new Hashtable(); try { final String XERCES1_VERSION_CLASS = "com.sun.org.apache.xerces.internal.framework.Version"; Class clazz = ObjectFactory.findProviderClass(XERCES1_VERSION_CLASS, true); // Found Xerces-J 1.x, grab it's version fields Field f = clazz.getField("fVersion"); String parserVersion = (String) f.get(null); h.put(VERSION + "xerces1", parserVersion); } catch (Exception e) { h.put(VERSION + "xerces1", CLASS_NOTPRESENT); } // Look for xerces1 and xerces2 parsers separately try { final String XERCES2_VERSION_CLASS = "com.sun.org.apache.xerces.internal.impl.Version"; Class clazz = ObjectFactory.findProviderClass(XERCES2_VERSION_CLASS, true); // Found Xerces-J 2.x, grab it's version fields Field f = clazz.getField("fVersion"); String parserVersion = (String) f.get(null); h.put(VERSION + "xerces2", parserVersion); } catch (Exception e) { h.put(VERSION + "xerces2", CLASS_NOTPRESENT); } try { final String CRIMSON_CLASS = "org.apache.crimson.parser.Parser2"; Class clazz = ObjectFactory.findProviderClass(CRIMSON_CLASS, true); // @todo determine specific crimson version h.put(VERSION + "crimson", CLASS_PRESENT); } catch (Exception e) { h.put(VERSION + "crimson", CLASS_NOTPRESENT); } }
/** * Report version information about JAXP interfaces. * * <p>Currently distinguishes between JAXP 1.0.1 and JAXP 1.1, and not found; only tests the * interfaces, and does not check for reference implementation versions. * * @param h Hashtable to put information in */ protected void checkJAXPVersion(Hashtable h) { if (null == h) h = new Hashtable(); Class clazz = null; try { final String JAXP1_CLASS = "javax.xml.stream.XMLStreamConstants"; clazz = ObjectFactory.findProviderClass(JAXP1_CLASS, true); // If we succeeded, we have JAXP 1.4 available h.put(VERSION + "JAXP", "1.4"); } catch (Exception e) { h.put(ERROR + VERSION + "JAXP", "1.3"); h.put(ERROR, ERROR_FOUND); } }
/** * Report product version information from Ant. * * @param h Hashtable to put information in */ protected void checkAntVersion(Hashtable h) { if (null == h) h = new Hashtable(); try { final String ANT_VERSION_CLASS = "org.apache.tools.ant.Main"; final String ANT_VERSION_METHOD = "getAntVersion"; // noArgs final Class noArgs[] = new Class[0]; Class clazz = ObjectFactory.findProviderClass(ANT_VERSION_CLASS, true); Method method = clazz.getMethod(ANT_VERSION_METHOD, noArgs); Object returnValue = method.invoke(null, new Object[0]); h.put(VERSION + "ant", (String) returnValue); } catch (Exception e) { h.put(VERSION + "ant", CLASS_NOTPRESENT); } }
/** * Report version info from DOM interfaces. * * @param h Hashtable to put information in */ protected boolean checkDOML3(Hashtable h) { if (null == h) h = new Hashtable(); final String DOM_CLASS = "org.w3c.dom.Document"; final String DOM_LEVEL3_METHOD = "getDoctype"; // no parameter try { Class clazz = ObjectFactory.findProviderClass(DOM_CLASS, true); Method method = clazz.getMethod(DOM_LEVEL3_METHOD, (Class<?>[]) null); // If we succeeded, we have loaded interfaces from a // level 3 DOM somewhere h.put(VERSION + "DOM", "3.0"); return true; } catch (Exception e) { return false; } }
/* */ public final void initialize(int node, int last, DOM dom, SortSettings settings) /* */ throws TransletException /* */ { /* 104 */ this._dom = dom; /* 105 */ this._node = node; /* 106 */ this._last = last; /* 107 */ this._settings = settings; /* */ /* 109 */ int levels = settings.getSortOrders().length; /* 110 */ this._values = new Object[levels]; /* */ /* 112 */ String colFactClassname = null; /* */ try /* */ { /* 115 */ colFactClassname = SecuritySupport.getSystemProperty( "com.sun.org.apache.xalan.internal.xsltc.COLLATOR_FACTORY"); /* */ } /* */ catch (SecurityException e) /* */ { /* */ } /* */ /* 122 */ if (colFactClassname != null) { /* */ try { /* 124 */ Object candObj = ObjectFactory.findProviderClass(colFactClassname, true); /* 125 */ this._collatorFactory = ((CollatorFactory) candObj); /* */ } catch (ClassNotFoundException e) { /* 127 */ throw new TransletException(e); /* */ } /* 129 */ Locale[] locales = settings.getLocales(); /* 130 */ this._collators = new Collator[levels]; /* 131 */ for (int i = 0; i < levels; i++) { /* 132 */ this._collators[i] = this._collatorFactory.getCollator(locales[i]); /* */ } /* 134 */ this._collator = this._collators[0]; /* */ } else { /* 136 */ this._collators = settings.getCollators(); /* 137 */ this._collator = this._collators[0]; /* */ } /* */ }
/** * Returns a serializer for the specified output method. The output method is specified by the * value of the property associated with the "method" key. If no implementation exists that * supports the specified output method an exception of some type will be thrown. For a list of * the output "method" key values see {@link Method}. * * @param format The output format, minimally the "method" property must be set. * @return A suitable serializer. * @throws IllegalArgumentException if method is null or an appropriate serializer can't be found * @throws Exception if the class for the serializer is found but does not implement * ContentHandler. * @throws WrappedRuntimeException if an exception is thrown while trying to find serializer */ public static Serializer getSerializer(Properties format) { Serializer ser; try { String method = format.getProperty(OutputKeys.METHOD); if (method == null) { String msg = Utils.messages.createMessage( MsgKey.ER_FACTORY_PROPERTY_MISSING, new Object[] {OutputKeys.METHOD}); throw new IllegalArgumentException(msg); } String className = format.getProperty(OutputPropertiesFactory.S_KEY_CONTENT_HANDLER); if (null == className) { // Missing Content Handler property, load default using OutputPropertiesFactory Properties methodDefaults = OutputPropertiesFactory.getDefaultMethodProperties(method); className = methodDefaults.getProperty(OutputPropertiesFactory.S_KEY_CONTENT_HANDLER); if (null == className) { String msg = Utils.messages.createMessage( MsgKey.ER_FACTORY_PROPERTY_MISSING, new Object[] {OutputPropertiesFactory.S_KEY_CONTENT_HANDLER}); throw new IllegalArgumentException(msg); } } Class cls = ObjectFactory.findProviderClass(className, true); // _serializers.put(method, cls); Object obj = cls.newInstance(); if (obj instanceof SerializationHandler) { // this is one of the supplied serializers ser = (Serializer) cls.newInstance(); ser.setOutputFormat(format); } else { /* * This must be a user defined Serializer. * It had better implement ContentHandler. */ if (obj instanceof ContentHandler) { /* * The user defined serializer defines ContentHandler, * but we need to wrap it with ToXMLSAXHandler which * will collect SAX-like events and emit true * SAX ContentHandler events to the users handler. */ className = SerializerConstants.DEFAULT_SAX_SERIALIZER; cls = ObjectFactory.findProviderClass(className, true); SerializationHandler sh = (SerializationHandler) cls.newInstance(); sh.setContentHandler((ContentHandler) obj); sh.setOutputFormat(format); ser = sh; } else { // user defined serializer does not implement // ContentHandler, ... very bad throw new Exception( Utils.messages.createMessage( MsgKey.ER_SERIALIZER_NOT_CONTENTHANDLER, new Object[] {className})); } } } catch (Exception e) { throw new com.sun.org.apache.xml.internal.serializer.utils.WrappedRuntimeException(e); } // If we make it to here ser is not null. return ser; }
/** * Report version info from SAX interfaces. * * <p>Currently distinguishes between SAX 2, SAX 2.0beta2, SAX1, and not found. * * @param h Hashtable to put information in */ protected void checkSAXVersion(Hashtable h) { if (null == h) h = new Hashtable(); final String SAX_VERSION1_CLASS = "org.xml.sax.Parser"; final String SAX_VERSION1_METHOD = "parse"; // String final String SAX_VERSION2_CLASS = "org.xml.sax.XMLReader"; final String SAX_VERSION2_METHOD = "parse"; // String final String SAX_VERSION2BETA_CLASSNF = "org.xml.sax.helpers.AttributesImpl"; final String SAX_VERSION2BETA_METHODNF = "setAttributes"; // Attributes final Class oneStringArg[] = {java.lang.String.class}; // Note this introduces a minor compile dependency on SAX... final Class attributesArg[] = {org.xml.sax.Attributes.class}; try { // This method was only added in the final SAX 2.0 release; // see changes.html "Changes from SAX 2.0beta2 to SAX 2.0prerelease" Class clazz = ObjectFactory.findProviderClass(SAX_VERSION2BETA_CLASSNF, true); Method method = clazz.getMethod(SAX_VERSION2BETA_METHODNF, attributesArg); // If we succeeded, we have loaded interfaces from a // real, final SAX version 2.0 somewhere h.put(VERSION + "SAX", "2.0"); } catch (Exception e) { // If we didn't find the SAX 2.0 class, look for a 2.0beta2 h.put( ERROR + VERSION + "SAX", "ERROR attempting to load SAX version 2 class: " + e.toString()); h.put(ERROR, ERROR_FOUND); try { Class clazz = ObjectFactory.findProviderClass(SAX_VERSION2_CLASS, true); Method method = clazz.getMethod(SAX_VERSION2_METHOD, oneStringArg); // If we succeeded, we have loaded interfaces from a // SAX version 2.0beta2 or earlier; these might work but // you should really have the final SAX 2.0 h.put(VERSION + "SAX-backlevel", "2.0beta2-or-earlier"); } catch (Exception e2) { // If we didn't find the SAX 2.0beta2 class, look for a 1.0 one h.put( ERROR + VERSION + "SAX", "ERROR attempting to load SAX version 2 class: " + e.toString()); h.put(ERROR, ERROR_FOUND); try { Class clazz = ObjectFactory.findProviderClass(SAX_VERSION1_CLASS, true); Method method = clazz.getMethod(SAX_VERSION1_METHOD, oneStringArg); // If we succeeded, we have loaded interfaces from a // SAX version 1.0 somewhere; which won't work very // well for JAXP 1.1 or beyond! h.put(VERSION + "SAX-backlevel", "1.0"); } catch (Exception e3) { // If we didn't find the SAX 2.0 class, look for a 1.0 one // Note that either 1.0 or no SAX are both errors h.put( ERROR + VERSION + "SAX-backlevel", "ERROR attempting to load SAX version 1 class: " + e3.toString()); } } } }
/** * Report product version information from Xalan-J. * * <p>Looks for version info in xalan.jar from Xalan-J products. * * @param h Hashtable to put information in */ protected void checkProcessorVersion(Hashtable h) { if (null == h) h = new Hashtable(); try { final String XALAN1_VERSION_CLASS = "com.sun.org.apache.xalan.internal.xslt.XSLProcessorVersion"; Class clazz = ObjectFactory.findProviderClass(XALAN1_VERSION_CLASS, true); // Found Xalan-J 1.x, grab it's version fields StringBuffer buf = new StringBuffer(); Field f = clazz.getField("PRODUCT"); buf.append(f.get(null)); buf.append(';'); f = clazz.getField("LANGUAGE"); buf.append(f.get(null)); buf.append(';'); f = clazz.getField("S_VERSION"); buf.append(f.get(null)); buf.append(';'); h.put(VERSION + "xalan1", buf.toString()); } catch (Exception e1) { h.put(VERSION + "xalan1", CLASS_NOTPRESENT); } try { // NOTE: This is the old Xalan 2.0, 2.1, 2.2 version class, // is being replaced by class below final String XALAN2_VERSION_CLASS = "com.sun.org.apache.xalan.internal.processor.XSLProcessorVersion"; Class clazz = ObjectFactory.findProviderClass(XALAN2_VERSION_CLASS, true); // Found Xalan-J 2.x, grab it's version fields StringBuffer buf = new StringBuffer(); Field f = clazz.getField("S_VERSION"); buf.append(f.get(null)); h.put(VERSION + "xalan2x", buf.toString()); } catch (Exception e2) { h.put(VERSION + "xalan2x", CLASS_NOTPRESENT); } try { // NOTE: This is the new Xalan 2.2+ version class final String XALAN2_2_VERSION_CLASS = "com.sun.org.apache.xalan.internal.Version"; final String XALAN2_2_VERSION_METHOD = "getVersion"; final Class noArgs[] = new Class[0]; Class clazz = ObjectFactory.findProviderClass(XALAN2_2_VERSION_CLASS, true); Method method = clazz.getMethod(XALAN2_2_VERSION_METHOD, noArgs); Object returnValue = method.invoke(null, new Object[0]); h.put(VERSION + "xalan2_2", (String) returnValue); } catch (Exception e2) { h.put(VERSION + "xalan2_2", CLASS_NOTPRESENT); } }
/* */ private void doTransform() { /* */ try { /* 101 */ Class clazz = ObjectFactory.findProviderClass(this._className, true); /* 102 */ AbstractTranslet translet = (AbstractTranslet) clazz.newInstance(); /* 103 */ translet.postInitialization(); /* */ /* 106 */ SAXParserFactory factory = SAXParserFactory.newInstance(); /* */ try { /* 108 */ factory.setFeature("http://xml.org/sax/features/namespaces", true); /* */ } /* */ catch (Exception e) { /* 111 */ factory.setNamespaceAware(true); /* */ } /* 113 */ SAXParser parser = factory.newSAXParser(); /* 114 */ XMLReader reader = parser.getXMLReader(); /* */ /* 117 */ XSLTCDTMManager dtmManager = (XSLTCDTMManager) XSLTCDTMManager.getDTMManagerClass().newInstance(); /* */ DTMWSFilter wsfilter; /* */ DTMWSFilter wsfilter; /* 122 */ if ((translet != null) && ((translet instanceof StripFilter))) /* 123 */ wsfilter = new DOMWSFilter(translet); /* */ else { /* 125 */ wsfilter = null; /* */ } /* */ /* 128 */ DOMEnhancedForDTM dom = (DOMEnhancedForDTM) dtmManager.getDTM( new SAXSource(reader, new InputSource(this._fileName)), false, wsfilter, true, false, translet.hasIdCall()); /* */ /* 133 */ dom.setDocumentURI(this._fileName); /* 134 */ translet.prepassDocument(dom); /* */ /* 137 */ int n = this._params.size(); /* 138 */ for (int i = 0; i < n; i++) { /* 139 */ Parameter param = (Parameter) this._params.elementAt(i); /* 140 */ translet.addParameter(param._name, param._value); /* */ } /* */ /* 144 */ TransletOutputHandlerFactory tohFactory = TransletOutputHandlerFactory.newInstance(); /* */ /* 146 */ tohFactory.setOutputType(0); /* 147 */ tohFactory.setEncoding(translet._encoding); /* 148 */ tohFactory.setOutputMethod(translet._method); /* */ /* 150 */ if (this._iterations == -1) { /* 151 */ translet.transform(dom, tohFactory.getSerializationHandler()); /* */ } /* 153 */ else if (this._iterations > 0) { /* 154 */ long mm = System.currentTimeMillis(); /* 155 */ for (int i = 0; i < this._iterations; i++) { /* 156 */ translet.transform(dom, tohFactory.getSerializationHandler()); /* */ } /* */ /* 159 */ mm = System.currentTimeMillis() - mm; /* */ /* 161 */ System.err.println("\n<!--"); /* 162 */ System.err.println(" transform = " + mm / this._iterations + " ms"); /* */ /* 165 */ System.err.println( " throughput = " + 1000.0D / (mm / this._iterations) + " tps"); /* */ /* 169 */ System.err.println("-->"); /* */ } /* */ } /* */ catch (TransletException e) { /* 173 */ if (this._debug) e.printStackTrace(); /* 174 */ System.err.println(new ErrorMsg("RUNTIME_ERROR_KEY") + e.getMessage()); /* */ } /* */ catch (RuntimeException e) /* */ { /* 178 */ if (this._debug) e.printStackTrace(); /* 179 */ System.err.println(new ErrorMsg("RUNTIME_ERROR_KEY") + e.getMessage()); /* */ } /* */ catch (FileNotFoundException e) /* */ { /* 183 */ if (this._debug) e.printStackTrace(); /* 184 */ ErrorMsg err = new ErrorMsg("FILE_NOT_FOUND_ERR", this._fileName); /* 185 */ System.err.println(new ErrorMsg("RUNTIME_ERROR_KEY") + err.toString()); /* */ } /* */ catch (MalformedURLException e) /* */ { /* 189 */ if (this._debug) e.printStackTrace(); /* 190 */ ErrorMsg err = new ErrorMsg("INVALID_URI_ERR", this._fileName); /* 191 */ System.err.println(new ErrorMsg("RUNTIME_ERROR_KEY") + err.toString()); /* */ } /* */ catch (ClassNotFoundException e) /* */ { /* 195 */ if (this._debug) e.printStackTrace(); /* 196 */ ErrorMsg err = new ErrorMsg("CLASS_NOT_FOUND_ERR", this._className); /* 197 */ System.err.println(new ErrorMsg("RUNTIME_ERROR_KEY") + err.toString()); /* */ } /* */ catch (UnknownHostException e) /* */ { /* 201 */ if (this._debug) e.printStackTrace(); /* 202 */ ErrorMsg err = new ErrorMsg("INVALID_URI_ERR", this._fileName); /* 203 */ System.err.println(new ErrorMsg("RUNTIME_ERROR_KEY") + err.toString()); /* */ } /* */ catch (SAXException e) /* */ { /* 207 */ Exception ex = e.getException(); /* 208 */ if (this._debug) { /* 209 */ if (ex != null) ex.printStackTrace(); /* 210 */ e.printStackTrace(); /* */ } /* 212 */ System.err.print(new ErrorMsg("RUNTIME_ERROR_KEY")); /* 213 */ if (ex != null) /* 214 */ System.err.println(ex.getMessage()); /* */ else /* 216 */ System.err.println(e.getMessage()); /* */ } /* */ catch (Exception e) { /* 219 */ if (this._debug) e.printStackTrace(); /* 220 */ System.err.println(new ErrorMsg("RUNTIME_ERROR_KEY") + e.getMessage()); /* */ } /* */ }
// 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"); } }