| /* |
| * The Apache Software License, Version 1.1 |
| * |
| * |
| * Copyright (c) 2000,2001 The Apache Software Foundation. All rights |
| * reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * 3. The end-user documentation included with the redistribution, |
| * if any, must include the following acknowledgment: |
| * "This product includes software developed by the |
| * Apache Software Foundation (http://www.apache.org/)." |
| * Alternately, this acknowledgment may appear in the software itself, |
| * if and wherever such third-party acknowledgments normally appear. |
| * |
| * 4. The names "Xerces" and "Apache Software Foundation" must |
| * not be used to endorse or promote products derived from this |
| * software without prior written permission. For written |
| * permission, please contact apache@apache.org. |
| * |
| * 5. Products derived from this software may not be called "Apache", |
| * nor may "Apache" appear in their name, without prior written |
| * permission of the Apache Software Foundation. |
| * |
| * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR |
| * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF |
| * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
| * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| * ==================================================================== |
| * |
| * This software consists of voluntary contributions made by many |
| * individuals on behalf of the Apache Software Foundation and was |
| * originally based on software copyright (c) 2001, International |
| * Business Machines, Inc., http://www.apache.org. For more |
| * information on the Apache Software Foundation, please see |
| * <http://www.apache.org/>. |
| */ |
| |
| package org.apache.xerces.parsers; |
| |
| import java.io.InputStream; |
| import java.io.IOException; |
| import java.io.Reader; |
| import java.util.Hashtable; |
| import java.util.Stack; |
| import java.util.Vector; |
| |
| import org.w3c.dom.DOMException; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Node; |
| |
| import org.apache.xerces.dom3.DOMErrorHandler; |
| import org.apache.xerces.dom3.ls.DOMBuilder; |
| import org.apache.xerces.dom3.ls.DOMEntityResolver; |
| import org.apache.xerces.dom3.ls.DOMBuilderFilter; |
| import org.apache.xerces.dom3.ls.DOMInputSource; |
| |
| import org.apache.xerces.util.DOMEntityResolverWrapper; |
| import org.apache.xerces.util.SymbolTable; |
| import org.apache.xerces.util.DOMErrorHandlerWrapper; |
| import org.apache.xerces.impl.Constants; |
| import org.apache.xerces.impl.validation.GrammarPool; |
| import org.apache.xerces.xni.XNIException; |
| import org.apache.xerces.xni.parser.XMLConfigurationException; |
| import org.apache.xerces.xni.parser.XMLInputSource; |
| import org.apache.xerces.xni.parser.XMLParserConfiguration; |
| |
| |
| /** |
| * This is Xerces DOM Builder class. It uses the abstract DOM |
| * parser with a document scanner, a dtd scanner, and a validator, as |
| * well as a grammar pool. |
| * |
| * @author Pavani Mukthipudi, Sun Microsystems Inc. |
| * @author Elena Litani, IBM |
| * @author Rahul Srivastava, Sun Microsystems Inc. |
| * |
| */ |
| |
| // REVISIT: |
| // 1. "load-as-infoset" should be implemented |
| // 2. why do we need so many fields in this class (why don't we use AbstractDomParser fields) |
| // 3. implementation of setFeature method (we are going via switch several times) |
| // 4. include-comments - I've defined a constant for DOM feature in Constants. |
| // I don't think we need to define corresponding feature for Xerces parser |
| // (with Xerces prefix). |
| // We probably should define all DOM Feature constants in Constants.java |
| // --el |
| |
| public class DOMBuilderImpl |
| extends AbstractDOMParser implements DOMBuilder { |
| |
| // |
| // Constants |
| // |
| |
| // feature ids |
| |
| /** Feature id: namespace declarations. */ |
| protected static final String NAMESPACE_DECLARATIONS = |
| "namespace-declarations"; |
| |
| /** Feature id: validation. */ |
| protected static final String VALIDATION = |
| "validation"; |
| |
| /** Feature id: external parameter entities. */ |
| protected static final String EXTERNAL_PARAMETER_ENTITIES = |
| "external-parameter-entities"; |
| |
| /** Feature id: external general entities. */ |
| protected static final String EXTERNAL_GENERAL_ENTITIES = |
| "external-general-entities"; |
| |
| /** Feature id: external dtd subset. */ |
| protected static final String EXTERNAL_DTD_SUBSET = |
| "external-dtd-subset"; |
| |
| /** Feature id: validate if schema. */ |
| protected static final String VALIDATE_IF_SCHEMA = |
| "validate-if-schema"; |
| |
| /** Feature id: validate against dtd. */ |
| protected static final String VALIDATE_AGAINST_DTD = |
| "validate-against-dtd"; |
| |
| /** Feature id: datatype normalization. */ |
| protected static final String DATATYPE_NORMALIZATION = |
| "datatype-normalization"; |
| |
| /** Feature id: create entity ref nodes. */ |
| protected static final String CREATE_ENTITY_REFERENCE_NODES = |
| "create-entity-ref-nodes"; |
| |
| /** Feature id: create entity nodes. */ |
| protected static final String CREATE_ENTITY_NODES = |
| "create-entity-nodes"; |
| |
| /** Feature id: whitespace in element content. */ |
| protected static final String WHITESPACE_IN_ELEMENT_CONTENT = |
| "whitespace-in-element-content"; |
| |
| /** Feature id: comments. */ |
| protected static final String COMMENTS = |
| "comments"; |
| |
| /** Feature id: charset overrides xml encoding. */ |
| protected static final String CHARSET_OVERRIDES_XML_ENCODING = |
| "charset-overrides-xml-encoding"; |
| |
| /** Feature id: load as infoset. */ |
| protected static final String LOAD_AS_INFOSET = |
| "load-as-infoset"; |
| |
| /** Feature id: supported mediatypes only. */ |
| protected static final String SUPPORTED_MEDIATYPES_ONLY = |
| "supported-mediatypes-only"; |
| |
| // SAX & Xerces feature ids |
| |
| /** Feature id: validation. */ |
| protected static final String VALIDATION_FEATURE = |
| Constants.SAX_FEATURE_PREFIX+Constants.VALIDATION_FEATURE; |
| |
| /** Feature id: external parameter entities. */ |
| protected static final String EXTERNAL_PARAMETER_ENTITIES_FEATURE = |
| Constants.SAX_FEATURE_PREFIX+Constants.EXTERNAL_PARAMETER_ENTITIES_FEATURE; |
| |
| /** Feature id: external general entities. */ |
| protected static final String EXTERNAL_GENERAL_ENTITIES_FEATURE = |
| Constants.SAX_FEATURE_PREFIX+Constants.EXTERNAL_GENERAL_ENTITIES_FEATURE; |
| |
| /** Feature id: load external dtd. */ |
| protected static final String LOAD_EXTERNAL_DTD_FEATURE = |
| Constants.XERCES_FEATURE_PREFIX+Constants.LOAD_EXTERNAL_DTD_FEATURE; |
| |
| // |
| // Data |
| // |
| |
| // features |
| |
| /** Namespace declarations. */ |
| protected boolean fNamespaceDeclarations; |
| |
| /** Validate if schema */ |
| protected boolean fValidateIfSchema; |
| |
| /** Validate against DTD */ |
| protected boolean fValidateAgainstDTD; |
| |
| /** Datatype normalization */ |
| protected boolean fDatatypeNormalization; |
| |
| /** Create entity nodes */ |
| protected boolean fCreateEntityNodes; |
| |
| /** Whitespace in element content */ |
| protected boolean fWhitespaceInElementContent; |
| |
| /** Charset overrides xml encoding */ |
| protected boolean fCharsetOverridesXmlEncoding; |
| |
| /** Load as infoset */ |
| protected boolean fLoadAsInfoset; |
| |
| /** Supported mediatypes only */ |
| protected boolean fSupportedMediatypesOnly; |
| |
| // |
| // Constructors |
| // |
| |
| /** |
| * Constructs a DOM Builder using the dtd/xml schema parser configuration. |
| */ |
| public DOMBuilderImpl() { |
| this(new DTDXSParserConfiguration()); |
| } // <init> |
| |
| /** |
| * Constructs a DOM Builder using the specified parser configuration. |
| */ |
| public DOMBuilderImpl(XMLParserConfiguration config) { |
| super(config); |
| |
| // add recognized features |
| final String[] domRecognizedFeatures = { |
| NAMESPACE_DECLARATIONS, |
| VALIDATE_IF_SCHEMA, |
| VALIDATE_AGAINST_DTD, |
| DATATYPE_NORMALIZATION, |
| CREATE_ENTITY_NODES, |
| WHITESPACE_IN_ELEMENT_CONTENT, |
| CHARSET_OVERRIDES_XML_ENCODING, |
| LOAD_AS_INFOSET, |
| SUPPORTED_MEDIATYPES_ONLY |
| }; |
| |
| fConfiguration.addRecognizedFeatures(domRecognizedFeatures); |
| |
| // set default values |
| fConfiguration.setFeature(NAMESPACE_DECLARATIONS, true); |
| fConfiguration.setFeature(VALIDATE_IF_SCHEMA, false); |
| fConfiguration.setFeature(VALIDATE_AGAINST_DTD, false); |
| fConfiguration.setFeature(DATATYPE_NORMALIZATION, false); |
| fConfiguration.setFeature(CREATE_ENTITY_NODES, true); |
| fConfiguration.setFeature(WHITESPACE_IN_ELEMENT_CONTENT, true); |
| fConfiguration.setFeature(CHARSET_OVERRIDES_XML_ENCODING, true); |
| fConfiguration.setFeature(LOAD_AS_INFOSET, false); |
| fConfiguration.setFeature(SUPPORTED_MEDIATYPES_ONLY, false); |
| |
| } // <init>(XMLParserConfiguration) |
| |
| /** |
| * Constructs a DOM Builder using the specified symbol table. |
| */ |
| public DOMBuilderImpl(SymbolTable symbolTable) { |
| this(new DTDXSParserConfiguration(symbolTable)); |
| } // <init>(SymbolTable) |
| |
| |
| /** |
| * Constructs a DOM Builder using the specified symbol table and |
| * grammar pool. |
| */ |
| public DOMBuilderImpl(SymbolTable symbolTable, GrammarPool grammarPool) { |
| this(new DTDXSParserConfiguration(symbolTable, grammarPool)); |
| } |
| |
| /** |
| * Resets the parser state. |
| * |
| * @throws SAXException Thrown on initialization error. |
| */ |
| public void reset() { |
| super.reset(); |
| try { |
| fNamespaceDeclarations = fConfiguration.getFeature(NAMESPACE_DECLARATIONS); |
| fValidateIfSchema = fConfiguration.getFeature(VALIDATE_IF_SCHEMA); |
| fValidateAgainstDTD = fConfiguration.getFeature(VALIDATE_AGAINST_DTD); |
| fDatatypeNormalization = fConfiguration.getFeature(DATATYPE_NORMALIZATION); |
| fWhitespaceInElementContent = fConfiguration.getFeature(WHITESPACE_IN_ELEMENT_CONTENT); |
| fCharsetOverridesXmlEncoding = fConfiguration.getFeature(CHARSET_OVERRIDES_XML_ENCODING); |
| fLoadAsInfoset = fConfiguration.getFeature(LOAD_AS_INFOSET); |
| fSupportedMediatypesOnly = fConfiguration.getFeature(SUPPORTED_MEDIATYPES_ONLY); |
| } |
| catch (XMLConfigurationException e) { |
| if (e.getType() == XMLConfigurationException.NOT_RECOGNIZED) { |
| throw new DOMException(DOMException.NOT_FOUND_ERR, e.getMessage()); |
| } |
| else { |
| throw new DOMException(DOMException.NOT_SUPPORTED_ERR, e.getMessage()); |
| } |
| } |
| |
| } // reset() |
| |
| // |
| // DOMBuilder methods |
| // |
| |
| /** |
| * If a <code>DOMEntityResolver</code> has been specified, each time a |
| * reference to an external entity is encountered the |
| * <code>DOMBuilder</code> will pass the public and system IDs to the |
| * entity resolver, which can then specify the actual source of the |
| * entity. |
| */ |
| public DOMEntityResolver getEntityResolver() { |
| DOMEntityResolver domEntityResolver = null; |
| try { |
| DOMEntityResolver entityResolver = (DOMEntityResolver)fConfiguration.getProperty(ENTITY_RESOLVER); |
| if (entityResolver != null && |
| entityResolver instanceof DOMEntityResolverWrapper) { |
| domEntityResolver = ((DOMEntityResolverWrapper)entityResolver).getEntityResolver(); |
| } |
| } |
| catch (XMLConfigurationException e) { |
| |
| } |
| return domEntityResolver; |
| } |
| |
| /** |
| * If a <code>DOMEntityResolver</code> has been specified, each time a |
| * reference to an external entity is encountered the |
| * <code>DOMBuilder</code> will pass the public and system IDs to the |
| * entity resolver, which can then specify the actual source of the |
| * entity. |
| */ |
| public void setEntityResolver(DOMEntityResolver entityResolver) { |
| try { |
| fConfiguration.setProperty(ENTITY_RESOLVER, |
| new DOMEntityResolverWrapper(entityResolver)); |
| } |
| catch (XMLConfigurationException e) { |
| |
| } |
| } |
| |
| /** |
| * In the event that an error is encountered in the XML document being |
| * parsed, the <code>DOMDcoumentBuilder</code> will call back to the |
| * <code>errorHandler</code> with the error information. When the |
| * document loading process calls the error handler the node closest to |
| * where the error occured is passed to the error handler if the |
| * implementation, if the implementation is unable to pass the node |
| * where the error occures the document Node is passed to the error |
| * handler. Mutations to the document from within an error handler will |
| * result in implementation dependent behavour. |
| */ |
| public DOMErrorHandler getErrorHandler() { |
| DOMErrorHandler errorHandler = null; |
| try { |
| DOMErrorHandler domErrorHandler = |
| (DOMErrorHandler)fConfiguration.getProperty(ERROR_HANDLER); |
| if (domErrorHandler != null && |
| domErrorHandler instanceof DOMErrorHandlerWrapper) { |
| errorHandler = ((DOMErrorHandlerWrapper)domErrorHandler).getErrorHandler(); |
| } |
| } |
| catch (XMLConfigurationException e) { |
| |
| } |
| return errorHandler; |
| } |
| |
| /** |
| * In the event that an error is encountered in the XML document being |
| * parsed, the <code>DOMDcoumentBuilder</code> will call back to the |
| * <code>errorHandler</code> with the error information. When the |
| * document loading process calls the error handler the node closest to |
| * where the error occured is passed to the error handler if the |
| * implementation, if the implementation is unable to pass the node |
| * where the error occures the document Node is passed to the error |
| * handler. Mutations to the document from within an error handler will |
| * result in implementation dependent behavour. |
| */ |
| public void setErrorHandler(DOMErrorHandler errorHandler) { |
| try { |
| fConfiguration.setProperty(ERROR_HANDLER, |
| new DOMErrorHandlerWrapper(errorHandler)); |
| } |
| catch (XMLConfigurationException e) { |
| |
| } |
| } |
| |
| /** |
| * When the application provides a filter, the parser will call out to |
| * the filter at the completion of the construction of each |
| * <code>Element</code> node. The filter implementation can choose to |
| * remove the element from the document being constructed (unless the |
| * element is the document element) or to terminate the parse early. If |
| * the document is being validated when it's loaded the validation |
| * happens before the filter is called. |
| */ |
| public DOMBuilderFilter getFilter() { |
| throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Not supported"); |
| } |
| |
| /** |
| * When the application provides a filter, the parser will call out to |
| * the filter at the completion of the construction of each |
| * <code>Element</code> node. The filter implementation can choose to |
| * remove the element from the document being constructed (unless the |
| * element is the document element) or to terminate the parse early. If |
| * the document is being validated when it's loaded the validation |
| * happens before the filter is called. |
| */ |
| public void setFilter(DOMBuilderFilter filter) { |
| throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Not supported"); |
| } |
| |
| /** |
| * Set the state of a feature. |
| * |
| * <br>The feature name has the same form as a DOM hasFeature string. |
| * <br>It is possible for a <code>DOMBuilder</code> to recognize a feature |
| * name but to be unable to set its value. |
| * |
| * @param name The feature name. |
| * @param state The requested state of the feature (<code>true</code> or |
| * <code>false</code>). |
| * @exception DOMException |
| * Raise a NOT_SUPPORTED_ERR exception when the <code>DOMBuilder</code> |
| * recognizes the feature name but cannot set the requested value. |
| * <br>Raise a NOT_FOUND_ERR When the <code>DOMBuilder</code> does not |
| * recognize the feature name. |
| */ |
| public void setFeature(String name, boolean state) throws DOMException { |
| try { |
| if (canSetFeature(name, state)) { |
| if (name.equals(VALIDATION)) { |
| fConfiguration.setFeature(VALIDATION_FEATURE, state); |
| } |
| else if (name.equals(EXTERNAL_PARAMETER_ENTITIES)) { |
| fConfiguration.setFeature(EXTERNAL_PARAMETER_ENTITIES_FEATURE, state); |
| } |
| else if (name.equals(EXTERNAL_GENERAL_ENTITIES)) { |
| fConfiguration.setFeature(EXTERNAL_GENERAL_ENTITIES_FEATURE, state); |
| } |
| else if (name.equals(EXTERNAL_DTD_SUBSET)) { |
| fConfiguration.setFeature(LOAD_EXTERNAL_DTD_FEATURE, state); |
| } |
| else if (name.equals(COMMENTS)) { |
| fConfiguration.setFeature(INCLUDE_COMMENTS_FEATURE, state); |
| } |
| else if(name.equals(CREATE_ENTITY_REFERENCE_NODES)) { |
| fConfiguration.setFeature(CREATE_ENTITY_REF_NODES, state); |
| } |
| else { |
| fConfiguration.setFeature(name, state); |
| } |
| } |
| else { |
| throw new DOMException(DOMException.NOT_SUPPORTED_ERR,"Feature \""+name+"\" cannot be set to \""+state+"\""); |
| } |
| } |
| catch (XMLConfigurationException e) { |
| if (e.getType() == XMLConfigurationException.NOT_RECOGNIZED) { |
| throw new DOMException(DOMException.NOT_FOUND_ERR,"Feature \""+name+"\" not recognized"); |
| } |
| else { |
| throw new DOMException(DOMException.NOT_SUPPORTED_ERR,"Feature \""+name+"\" not supported"); |
| } |
| } |
| } |
| |
| /** |
| * Query whether setting a feature to a specific value is supported. |
| * <br>The feature name has the same form as a DOM hasFeature string. |
| * |
| * @param name The feature name, which is a DOM has-feature style string. |
| * @param state The requested state of the feature (<code>true</code> or |
| * <code>false</code>). |
| * @return <code>true</code> if the feature could be successfully set to |
| * the specified value, or <code>false</code> if the feature is not |
| * recognized or the requested value is not supported. The value of |
| * the feature itself is not changed. |
| */ |
| public boolean canSetFeature(String name, boolean state) { |
| if (name.equals(NAMESPACE_DECLARATIONS) && !state) { |
| return false; |
| } |
| else if(name.equals(VALIDATE_IF_SCHEMA) && state) { |
| return false; |
| } |
| else if(name.equals(VALIDATE_AGAINST_DTD) && state) { |
| return false; |
| } |
| else if(name.equals(CREATE_ENTITY_NODES) && !state) { |
| return false; |
| } |
| else if(name.equals(WHITESPACE_IN_ELEMENT_CONTENT) && !state) { |
| return false; |
| } |
| else if(name.equals(LOAD_AS_INFOSET) && state) { |
| return false; |
| } |
| else if(name.equals(SUPPORTED_MEDIATYPES_ONLY) && state) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /** |
| * Look up the value of a feature. |
| * <br>The feature name has the same form as a DOM hasFeature string |
| * |
| * @param name The feature name, which is a string with DOM has-feature |
| * syntax. |
| * @return The current state of the feature (<code>true</code> or |
| * <code>false</code>). |
| * @exception DOMException |
| * Raise a NOT_FOUND_ERR When the <code>DOMBuilder</code> does not |
| * recognize the feature name. |
| */ |
| public boolean getFeature(String name) throws DOMException { |
| try { |
| if (name.equals(VALIDATION)) { |
| return fConfiguration.getFeature(VALIDATION_FEATURE); |
| } |
| else if (name.equals(EXTERNAL_PARAMETER_ENTITIES)) { |
| return fConfiguration.getFeature(EXTERNAL_PARAMETER_ENTITIES_FEATURE); |
| } |
| else if (name.equals(EXTERNAL_GENERAL_ENTITIES)) { |
| return fConfiguration.getFeature(EXTERNAL_GENERAL_ENTITIES_FEATURE); |
| } |
| else if (name.equals(EXTERNAL_DTD_SUBSET)) { |
| return fConfiguration.getFeature(LOAD_EXTERNAL_DTD_FEATURE); |
| } |
| else if (name.equals(COMMENTS)) { |
| return fConfiguration.getFeature(INCLUDE_COMMENTS_FEATURE); |
| } |
| else if(name.equals(CREATE_ENTITY_REFERENCE_NODES)) { |
| return fConfiguration.getFeature(CREATE_ENTITY_REF_NODES); |
| } |
| else { |
| return fConfiguration.getFeature(name); |
| } |
| } |
| catch (XMLConfigurationException e) { |
| if (e.getType() == XMLConfigurationException.NOT_RECOGNIZED) { |
| throw new DOMException(DOMException.NOT_FOUND_ERR,"Feature \""+name+"\" not recognized"); |
| } |
| else { |
| throw new DOMException(DOMException.NOT_SUPPORTED_ERR,"Feature \""+name+"\" not supported"); |
| } |
| } |
| } |
| |
| /** |
| * Parse an XML document from a location identified by an URI reference. |
| * If the URI contains a fragment identifier (see section 4.1 in ), the |
| * behavior is not defined by this specification. |
| * |
| * @param uri The location of the XML document to be read. |
| * @return If the <code>DOMBuilder</code> is a synchronous |
| * <code>DOMBuilder</code> the newly created and populated |
| * <code>Document</code> is returned. If the <code>DOMBuilder</code> |
| * is asynchronous then <code>null</code> is returned since the |
| * document object is not yet parsed when this method returns. |
| * @exception DOMSystemException |
| * Exceptions raised by <code>parseURI</code> originate with the |
| * installed ErrorHandler, and thus depend on the implementation of |
| * the <code>DOMErrorHandler</code> interfaces. The default error |
| * handlers will raise a DOMSystemException if any form I/O or other |
| * system error occurs during the parse, but application defined error |
| * handlers are not required to do so. |
| */ |
| public Document parseURI(String uri) throws Exception { |
| XMLInputSource source = new XMLInputSource(null, uri, null); |
| try { |
| parse(source); |
| } |
| |
| catch (XNIException e) { |
| Exception ex = e.getException(); |
| throw ex; |
| } |
| |
| // close stream opened by the parser |
| finally { |
| try { |
| Reader reader = source.getCharacterStream(); |
| if (reader != null) { |
| reader.close(); |
| } |
| else { |
| InputStream is = source.getByteStream(); |
| if (is != null) { |
| is.close(); |
| } |
| } |
| } |
| catch (IOException e) { |
| // ignore |
| } |
| } |
| return getDocument(); |
| } |
| |
| /** |
| * Parse an XML document from a resource identified by an |
| * <code>DOMInputSource</code>. |
| * |
| * @param is The <code>DOMInputSource</code> from which the source |
| * document is to be read. |
| * @return If the <code>DOMBuilder</code> is a synchronous |
| * <code>DOMBuilder</code> the newly created and populated |
| * <code>Document</code> is returned. If the <code>DOMBuilder</code> |
| * is asynchronous then <code>null</code> is returned since the |
| * document object is not yet parsed when this method returns. |
| * @exception DOMSystemException |
| * Exceptions raised by <code>parse</code> originate with the installed |
| * ErrorHandler, and thus depend on the implementation of the |
| * <code>DOMErrorHandler</code> interfaces. The default ErrorHandlers |
| * will raise a <code>DOMSystemException</code> if any form I/O or |
| * other system error occurs during the parse, but application defined |
| * ErrorHandlers are not required to do so. |
| */ |
| public Document parse(DOMInputSource is) throws Exception { |
| |
| try { |
| XMLInputSource xmlInputSource = |
| new XMLInputSource(is.getPublicId(), is.getSystemId(), is.getBaseURI()); |
| xmlInputSource.setByteStream(is.getByteStream()); |
| xmlInputSource.setCharacterStream(is.getCharacterStream()); |
| xmlInputSource.setEncoding(is.getEncoding()); |
| parse(xmlInputSource); |
| } |
| catch (XNIException e) { |
| Exception ex = e.getException(); |
| throw ex; |
| } |
| |
| return getDocument(); |
| } |
| |
| /** |
| * Parse an XML document or fragment from a resource identified by an |
| * <code>DOMInputSource</code> and insert the content into an existing |
| * document at the position epcified with the <code>contextNode</code> |
| * and <code>action</code> arguments. When parsing the input stream the |
| * context node is used for resolving unbound namespace prefixes. |
| * |
| * @param is The <code>DOMInputSource</code> from which the source |
| * document is to be read. |
| * @param cnode The <code>Node</code> that is used as the context for |
| * the data that is being parsed. |
| * @param action This parameter describes which action should be taken |
| * between the new set of node being inserted and the existing |
| * children of the context node. The set of possible actions is |
| * defined above. |
| * @exception DOMException |
| * HIERARCHY_REQUEST_ERR: Thrown if this action results in an invalid |
| * hierarchy (i.e. a Document with more than one document element). |
| */ |
| public void parseWithContext(DOMInputSource is, Node cnode, |
| short action) throws DOMException { |
| // REVISIT: need to implement. |
| throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Not supported"); |
| } |
| |
| |
| } // class DOMASBuilderImpl |
