/** * Implements javax.xml.transform.sax.TransformerHandler.setResult() Enables the user of the * TransformerHandler to set the to set the Result for the transformation. * * @param result A Result instance, should not be null * @throws IllegalArgumentException if result is invalid for some reason */ public void setResult(Result result) throws IllegalArgumentException { _result = result; if (null == result) { ErrorMsg err = new ErrorMsg(ErrorMsg.ER_RESULT_NULL); throw new IllegalArgumentException(err.toString()); // "result should not be null"); } if (_isIdentity) { try { // Connect this object with output system directly SerializationHandler outputHandler = _transformer.getOutputHandler(result); _transformer.transferOutputProperties(outputHandler); _handler = outputHandler; _lexHandler = outputHandler; } catch (TransformerException e) { _result = null; } } else if (_done) { // Run the transformation now, if not already done try { _transformer.setDOM(_dom); _transformer.transform(null, _result); } catch (TransformerException e) { // What the hell are we supposed to do with this??? throw new IllegalArgumentException(e.getMessage()); } } }
/** * javax.xml.transform.sax.TransformerFactory implementation. Look up the value of a feature (to * see if it is supported). This method must be updated as the various methods and features of * this class are implemented. * * @param name The feature name * @return 'true' if feature is supported, 'false' if not */ public boolean getFeature(String name) { // All supported features should be listed here String[] features = { DOMSource.FEATURE, DOMResult.FEATURE, SAXSource.FEATURE, SAXResult.FEATURE, StreamSource.FEATURE, StreamResult.FEATURE }; // feature name cannot be null if (name == null) { ErrorMsg err = new ErrorMsg(ErrorMsg.JAXP_GET_FEATURE_NULL_NAME); throw new NullPointerException(err.toString()); } // Inefficient, but it really does not matter in a function like this for (int i = 0; i < features.length; i++) { if (name.equals(features[i])) return true; } // secure processing? if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) { return featureSecureProcessing; } // unknown feature return false; }
/** * Implements org.xml.sax.ContentHandler.startDocument() Receive notification of the beginning of * a document. */ public void startDocument() throws SAXException { // Make sure setResult() was called before the first SAX event if (_result == null) { ErrorMsg err = new ErrorMsg(ErrorMsg.JAXP_SET_RESULT_ERR); throw new SAXException(err.toString()); } if (!_isIdentity) { boolean hasIdCall = (_translet != null) ? _translet.hasIdCall() : false; XSLTCDTMManager dtmManager = null; // Create an internal DOM (not W3C) and get SAX2 input handler try { dtmManager = (XSLTCDTMManager) _transformer.getTransformerFactory().getDTMManagerClass().newInstance(); } catch (Exception e) { throw new SAXException(e); } DTMWSFilter wsFilter; if (_translet != null && _translet instanceof StripFilter) { wsFilter = new DOMWSFilter(_translet); } else { wsFilter = null; } // Construct the DTM using the SAX events that come through _dom = (SAXImpl) dtmManager.getDTM(null, false, wsFilter, true, false, hasIdCall); _handler = _dom.getBuilder(); _lexHandler = (LexicalHandler) _handler; _dtdHandler = (DTDHandler) _handler; _declHandler = (DeclHandler) _handler; // Set document URI _dom.setDocumentURI(_systemId); if (_locator != null) { _handler.setDocumentLocator(_locator); } } // Proxy call _handler.startDocument(); }
/** * Set a feature for this <code>SmartTransformerFactory</code> and <code>Transformer</code>s or * <code>Template</code>s created by this factory. * * <p>Feature names are fully qualified {@link java.net.URI}s. Implementations may define their * own features. An {@link TransformerConfigurationException} is thrown if this <code> * TransformerFactory</code> or the <code>Transformer</code>s or <code>Template</code>s it creates * cannot support the feature. It is possible for an <code>TransformerFactory</code> to expose a * feature value but be unable to change its state. * * <p>See {@link javax.xml.transform.TransformerFactory} for full documentation of specific * features. * * @param name Feature name. * @param value Is feature state <code>true</code> or <code>false</code>. * @throws TransformerConfigurationException if this <code>TransformerFactory</code> or the <code> * Transformer</code>s or <code>Template</code>s it creates cannot support this feature. * @throws NullPointerException If the <code>name</code> parameter is null. */ public void setFeature(String name, boolean value) throws TransformerConfigurationException { // feature name cannot be null if (name == null) { ErrorMsg err = new ErrorMsg(ErrorMsg.JAXP_SET_FEATURE_NULL_NAME); throw new NullPointerException(err.toString()); } // secure processing? else if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) { featureSecureProcessing = value; // all done processing feature return; } else { // unknown feature ErrorMsg err = new ErrorMsg(ErrorMsg.JAXP_UNSUPPORTED_FEATURE, name); throw new TransformerConfigurationException(err.toString()); } }
/** Compute the JVM signature for the class. */ static final String getSignature(Class clazz) { if (clazz.isArray()) { final StringBuffer sb = new StringBuffer(); Class cl = clazz; while (cl.isArray()) { sb.append("["); cl = cl.getComponentType(); } sb.append(getSignature(cl)); return sb.toString(); } else if (clazz.isPrimitive()) { if (clazz == Integer.TYPE) { return "I"; } else if (clazz == Byte.TYPE) { return "B"; } else if (clazz == Long.TYPE) { return "J"; } else if (clazz == Float.TYPE) { return "F"; } else if (clazz == Double.TYPE) { return "D"; } else if (clazz == Short.TYPE) { return "S"; } else if (clazz == Character.TYPE) { return "C"; } else if (clazz == Boolean.TYPE) { return "Z"; } else if (clazz == Void.TYPE) { return "V"; } else { final String name = clazz.toString(); ErrorMsg err = new ErrorMsg(ErrorMsg.UNKNOWN_SIG_TYPE_ERR, name); throw new Error(err.toString()); } } else { return "L" + clazz.getName().replace('.', '/') + ';'; } }
/** Creates a SAX2 InputSource object from a TrAX Source object */ public static InputSource getInputSource(XSLTC xsltc, Source source) throws TransformerConfigurationException { InputSource input = null; String systemId = source.getSystemId(); try { // Try to get InputSource from SAXSource input if (source instanceof SAXSource) { final SAXSource sax = (SAXSource) source; input = sax.getInputSource(); // Pass the SAX parser to the compiler try { XMLReader reader = sax.getXMLReader(); /* * Fix for bug 24695 * According to JAXP 1.2 specification if a SAXSource * is created using a SAX InputSource the Transformer or * TransformerFactory creates a reader via the * XMLReaderFactory if setXMLReader is not used */ if (reader == null) { try { reader = XMLReaderFactory.createXMLReader(); } catch (Exception e) { try { // Incase there is an exception thrown // resort to JAXP SAXParserFactory parserFactory = SAXParserFactory.newInstance(); parserFactory.setNamespaceAware(true); if (xsltc.isSecureProcessing()) { try { parserFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true); } catch (org.xml.sax.SAXException se) { } } reader = parserFactory.newSAXParser().getXMLReader(); } catch (ParserConfigurationException pce) { throw new TransformerConfigurationException("ParserConfigurationException", pce); } } } reader.setFeature("http://xml.org/sax/features/namespaces", true); reader.setFeature("http://xml.org/sax/features/namespace-prefixes", false); xsltc.setXMLReader(reader); } catch (SAXNotRecognizedException snre) { throw new TransformerConfigurationException("SAXNotRecognizedException ", snre); } catch (SAXNotSupportedException snse) { throw new TransformerConfigurationException("SAXNotSupportedException ", snse); } catch (SAXException se) { throw new TransformerConfigurationException("SAXException ", se); } } // handle DOMSource else if (source instanceof DOMSource) { final DOMSource domsrc = (DOMSource) source; final Document dom = (Document) domsrc.getNode(); final DOM2SAX dom2sax = new DOM2SAX(dom); xsltc.setXMLReader(dom2sax); // Try to get SAX InputSource from DOM Source. input = SAXSource.sourceToInputSource(source); if (input == null) { input = new InputSource(domsrc.getSystemId()); } } // Try to get InputStream or Reader from StreamSource else if (source instanceof StreamSource) { final StreamSource stream = (StreamSource) source; final InputStream istream = stream.getInputStream(); final Reader reader = stream.getReader(); xsltc.setXMLReader(null); // Clear old XML reader // Create InputSource from Reader or InputStream in Source if (istream != null) { input = new InputSource(istream); } else if (reader != null) { input = new InputSource(reader); } else { input = new InputSource(systemId); } } else { ErrorMsg err = new ErrorMsg(ErrorMsg.JAXP_UNKNOWN_SOURCE_ERR); throw new TransformerConfigurationException(err.toString()); } input.setSystemId(systemId); } catch (NullPointerException e) { ErrorMsg err = new ErrorMsg(ErrorMsg.JAXP_NO_SOURCE_ERR, "TransformerFactory.newTemplates()"); throw new TransformerConfigurationException(err.toString()); } catch (SecurityException e) { ErrorMsg err = new ErrorMsg(ErrorMsg.FILE_ACCESS_ERR, systemId); throw new TransformerConfigurationException(err.toString()); } return input; }