Esempio n. 1
0
 /**
  * Is specified schema supported by this <code>SchemaFactory</code>?
  *
  * @param schemaLanguage Specifies the schema language which the returned <code>SchemaFactory
  *     </code> will understand. <code>schemaLanguage</code> must specify a <a
  *     href="#schemaLanguage">valid</a> schema language.
  * @return <code>true</code> if <code>SchemaFactory</code> supports <code>schemaLanguage</code>,
  *     else <code>false</code>.
  * @throws NullPointerException If <code>schemaLanguage</code> is <code>null</code>.
  * @throws IllegalArgumentException If <code>schemaLanguage.length() == 0</code> or <code>
  *     schemaLanguage</code> does not specify a <a href="#schemaLanguage">valid</a> schema
  *     language.
  */
 public boolean isSchemaLanguageSupported(String schemaLanguage) {
   if (schemaLanguage == null) {
     throw new NullPointerException(
         JAXPValidationMessageFormatter.formatMessage(
             Locale.getDefault(), "SchemaLanguageNull", null));
   }
   if (schemaLanguage.length() == 0) {
     throw new IllegalArgumentException(
         JAXPValidationMessageFormatter.formatMessage(
             Locale.getDefault(), "SchemaLanguageLengthZero", null));
   }
   // only W3C XML Schema 1.0 is supported
   return schemaLanguage.equals(XMLConstants.W3C_XML_SCHEMA_NS_URI);
 }
Esempio n. 2
0
 public void setProperty(String name, Object object)
     throws SAXNotRecognizedException, SAXNotSupportedException {
   if (name == null) {
     throw new NullPointerException(
         JAXPValidationMessageFormatter.formatMessage(
             Locale.getDefault(), "ProperyNameNull", null));
   }
   if (name.equals(SECURITY_MANAGER)) {
     fSecurityManager = (SecurityManager) object;
     fXMLSchemaLoader.setProperty(SECURITY_MANAGER, fSecurityManager);
     return;
   } else if (name.equals(XMLGRAMMAR_POOL)) {
     throw new SAXNotSupportedException(
         SAXMessageFormatter.formatMessage(
             Locale.getDefault(), "property-not-supported", new Object[] {name}));
   }
   try {
     fXMLSchemaLoader.setProperty(name, object);
   } catch (XMLConfigurationException e) {
     String identifier = e.getIdentifier();
     if (e.getType() == XMLConfigurationException.NOT_RECOGNIZED) {
       throw new SAXNotRecognizedException(
           SAXMessageFormatter.formatMessage(
               Locale.getDefault(), "property-not-recognized", new Object[] {identifier}));
     } else {
       throw new SAXNotSupportedException(
           SAXMessageFormatter.formatMessage(
               Locale.getDefault(), "property-not-supported", new Object[] {identifier}));
     }
   }
 }
Esempio n. 3
0
 public void setFeature(String name, boolean value)
     throws SAXNotRecognizedException, SAXNotSupportedException {
   if (name == null) {
     throw new NullPointerException(
         JAXPValidationMessageFormatter.formatMessage(
             Locale.getDefault(), "FeatureNameNull", null));
   }
   if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) {
     fSecurityManager = value ? new SecurityManager() : null;
     fXMLSchemaLoader.setProperty(SECURITY_MANAGER, fSecurityManager);
     return;
   }
   try {
     fXMLSchemaLoader.setFeature(name, value);
   } catch (XMLConfigurationException e) {
     String identifier = e.getIdentifier();
     if (e.getType() == XMLConfigurationException.NOT_RECOGNIZED) {
       throw new SAXNotRecognizedException(
           SAXMessageFormatter.formatMessage(
               Locale.getDefault(), "feature-not-recognized", new Object[] {identifier}));
     } else {
       throw new SAXNotSupportedException(
           SAXMessageFormatter.formatMessage(
               Locale.getDefault(), "feature-not-supported", new Object[] {identifier}));
     }
   }
 }
Esempio n. 4
0
 /**
  * Throws a {@link IllegalStateException} if we are not in the startElement callback. the JAXP
  * API requires this for most of the public methods.
  */
 private void checkState(boolean forElementInfo) {
   if (!(fInStartElement || (fInEndElement && forElementInfo))) {
     throw new IllegalStateException(
         JAXPValidationMessageFormatter.formatMessage(
             Locale.getDefault(), "TypeInfoProviderIllegalState", null));
   }
 }
 public boolean getFeature(String name)
     throws SAXNotRecognizedException, SAXNotSupportedException {
   if (name == null) {
     throw new NullPointerException(
         JAXPValidationMessageFormatter.formatMessage(
             fXMLSchemaLoader.getLocale(), "FeatureNameNull", null));
   }
   if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) {
     return (fSecurityManager != null);
   }
   try {
     return fXMLSchemaLoader.getFeature(name);
   } catch (XMLConfigurationException e) {
     String identifier = e.getIdentifier();
     if (e.getType() == Status.NOT_RECOGNIZED) {
       throw new SAXNotRecognizedException(
           SAXMessageFormatter.formatMessage(
               fXMLSchemaLoader.getLocale(), "feature-not-recognized", new Object[] {identifier}));
     } else {
       throw new SAXNotSupportedException(
           SAXMessageFormatter.formatMessage(
               fXMLSchemaLoader.getLocale(), "feature-not-supported", new Object[] {identifier}));
     }
   }
 }
 public void validate(Source source, Result result) throws SAXException, IOException {
   if (result instanceof StAXResult || result == null) {
     StAXSource staxSource = (StAXSource) source;
     StAXResult staxResult = (StAXResult) result;
     try {
       XMLStreamReader streamReader = staxSource.getXMLStreamReader();
       if (streamReader != null) {
         // Hand off to XMLStreamReader helper.
         if (fStreamHelper == null) {
           fStreamHelper = new StreamHelper();
         }
         fStreamHelper.validate(streamReader, staxResult);
       } else {
         // Hand off to XMLEventReader helper.
         if (fEventHelper == null) {
           fEventHelper = new EventHelper();
         }
         fEventHelper.validate(staxSource.getXMLEventReader(), staxResult);
       }
     } catch (XMLStreamException e) {
       throw new SAXException(e);
     } catch (XMLParseException e) {
       throw Util.toSAXParseException(e);
     } catch (XNIException e) {
       throw Util.toSAXException(e);
     } finally {
       // Release references to application objects
       fCurrentEvent = null;
       fStAXLocationWrapper.setLocation(null);
       fXMLStreamReaderLocation.setXMLStreamReader(null);
       if (fStAXValidatorHandler != null) {
         fStAXValidatorHandler.setStAXResult(null);
       }
     }
     return;
   }
   throw new IllegalArgumentException(
       JAXPValidationMessageFormatter.formatMessage(
           fComponentManager.getLocale(),
           "SourceResultMismatch",
           new Object[] {source.getClass().getName(), result.getClass().getName()}));
 }
  public void validate(Source source, Result result) throws SAXException, IOException {

    if (result == null || result instanceof StAXResult) {

      if (identityTransformer1 == null) {
        try {
          SAXTransformerFactory tf =
              fComponentManager.getFeature(Constants.ORACLE_FEATURE_SERVICE_MECHANISM)
                  ? (SAXTransformerFactory) SAXTransformerFactory.newInstance()
                  : (SAXTransformerFactory)
                      TransformerFactory.newInstance(
                          DEFAULT_TRANSFORMER_IMPL, StAXValidatorHelper.class.getClassLoader());
          identityTransformer1 = tf.newTransformer();
          identityTransformer2 = tf.newTransformerHandler();
        } catch (TransformerConfigurationException e) {
          // this is impossible, but again better safe than sorry
          throw new TransformerFactoryConfigurationError(e);
        }
      }

      handler = new ValidatorHandlerImpl(fComponentManager);
      if (result != null) {
        handler.setContentHandler(identityTransformer2);
        identityTransformer2.setResult(result);
      }

      try {
        identityTransformer1.transform(source, new SAXResult(handler));
      } catch (TransformerException e) {
        if (e.getException() instanceof SAXException) throw (SAXException) e.getException();
        throw new SAXException(e);
      } finally {
        handler.setContentHandler(null);
      }
      return;
    }
    throw new IllegalArgumentException(
        JAXPValidationMessageFormatter.formatMessage(
            Locale.getDefault(),
            "SourceResultMismatch",
            new Object[] {source.getClass().getName(), result.getClass().getName()}));
  }
 public void setFeature(String name, boolean value)
     throws SAXNotRecognizedException, SAXNotSupportedException {
   if (name == null) {
     throw new NullPointerException(
         JAXPValidationMessageFormatter.formatMessage(
             fXMLSchemaLoader.getLocale(), "FeatureNameNull", null));
   }
   if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) {
     if (System.getSecurityManager() != null && (!value)) {
       throw new SAXNotSupportedException(
           SAXMessageFormatter.formatMessage(null, "jaxp-secureprocessing-feature", null));
     }
     fSecurityManager = value ? new SecurityManager() : null;
     fXMLSchemaLoader.setProperty(SECURITY_MANAGER, fSecurityManager);
     fXMLSchemaLoader.setProperty(ACCESS_EXTERNAL_DTD, Constants.EXTERNAL_ACCESS_DEFAULT_FSP);
     fXMLSchemaLoader.setProperty(ACCESS_EXTERNAL_SCHEMA, Constants.EXTERNAL_ACCESS_DEFAULT_FSP);
     return;
   } else if (name.equals(Constants.ORACLE_FEATURE_SERVICE_MECHANISM)) {
     // in secure mode, let _useServicesMechanism be determined by the constructor
     if (System.getSecurityManager() != null) return;
   }
   try {
     fXMLSchemaLoader.setFeature(name, value);
   } catch (XMLConfigurationException e) {
     String identifier = e.getIdentifier();
     if (e.getType() == Status.NOT_RECOGNIZED) {
       throw new SAXNotRecognizedException(
           SAXMessageFormatter.formatMessage(
               fXMLSchemaLoader.getLocale(), "feature-not-recognized", new Object[] {identifier}));
     } else {
       throw new SAXNotSupportedException(
           SAXMessageFormatter.formatMessage(
               fXMLSchemaLoader.getLocale(), "feature-not-supported", new Object[] {identifier}));
     }
   }
 }
 final void validate(XMLEventReader reader, StAXResult result)
     throws SAXException, XMLStreamException {
   fCurrentEvent = reader.peek();
   if (fCurrentEvent != null) {
     int eventType = fCurrentEvent.getEventType();
     if (eventType != XMLStreamConstants.START_DOCUMENT
         && eventType != XMLStreamConstants.START_ELEMENT) {
       throw new SAXException(
           JAXPValidationMessageFormatter.formatMessage(
               fComponentManager.getLocale(), "StAXIllegalInitialState", null));
     }
     setup(null, result, false);
     fSchemaValidator.startDocument(fStAXLocationWrapper, null, fNamespaceContext, null);
     loop:
     while (reader.hasNext()) {
       fCurrentEvent = reader.nextEvent();
       eventType = fCurrentEvent.getEventType();
       switch (eventType) {
         case XMLStreamConstants.START_ELEMENT:
           ++fDepth;
           StartElement start = fCurrentEvent.asStartElement();
           fillQName(fElementQName, start.getName());
           fillXMLAttributes(start);
           fillDeclaredPrefixes(start);
           fNamespaceContext.setNamespaceContext(start.getNamespaceContext());
           fStAXLocationWrapper.setLocation(start.getLocation());
           fSchemaValidator.startElement(fElementQName, fAttributes, null);
           break;
         case XMLStreamConstants.END_ELEMENT:
           EndElement end = fCurrentEvent.asEndElement();
           fillQName(fElementQName, end.getName());
           fillDeclaredPrefixes(end);
           fStAXLocationWrapper.setLocation(end.getLocation());
           fSchemaValidator.endElement(fElementQName, null);
           if (--fDepth <= 0) {
             break loop;
           }
           break;
         case XMLStreamConstants.CHARACTERS:
         case XMLStreamConstants.SPACE:
           if (fStAXValidatorHandler != null) {
             Characters chars = fCurrentEvent.asCharacters();
             fStAXValidatorHandler.setIgnoringCharacters(true);
             sendCharactersToValidator(chars.getData());
             fStAXValidatorHandler.setIgnoringCharacters(false);
             fStAXValidatorHandler.characters(chars);
           } else {
             sendCharactersToValidator(fCurrentEvent.asCharacters().getData());
           }
           break;
         case XMLStreamConstants.CDATA:
           if (fStAXValidatorHandler != null) {
             Characters chars = fCurrentEvent.asCharacters();
             fStAXValidatorHandler.setIgnoringCharacters(true);
             fSchemaValidator.startCDATA(null);
             sendCharactersToValidator(fCurrentEvent.asCharacters().getData());
             fSchemaValidator.endCDATA(null);
             fStAXValidatorHandler.setIgnoringCharacters(false);
             fStAXValidatorHandler.cdata(chars);
           } else {
             fSchemaValidator.startCDATA(null);
             sendCharactersToValidator(fCurrentEvent.asCharacters().getData());
             fSchemaValidator.endCDATA(null);
           }
           break;
         case XMLStreamConstants.START_DOCUMENT:
           ++fDepth;
           if (fStAXValidatorHandler != null) {
             fStAXValidatorHandler.startDocument((StartDocument) fCurrentEvent);
           }
           break;
         case XMLStreamConstants.END_DOCUMENT:
           if (fStAXValidatorHandler != null) {
             fStAXValidatorHandler.endDocument((EndDocument) fCurrentEvent);
           }
           break;
         case XMLStreamConstants.PROCESSING_INSTRUCTION:
           if (fStAXValidatorHandler != null) {
             fStAXValidatorHandler.processingInstruction((ProcessingInstruction) fCurrentEvent);
           }
           break;
         case XMLStreamConstants.COMMENT:
           if (fStAXValidatorHandler != null) {
             fStAXValidatorHandler.comment((Comment) fCurrentEvent);
           }
           break;
         case XMLStreamConstants.ENTITY_REFERENCE:
           if (fStAXValidatorHandler != null) {
             fStAXValidatorHandler.entityReference((EntityReference) fCurrentEvent);
           }
           break;
         case XMLStreamConstants.DTD:
           DTD dtd = (DTD) fCurrentEvent;
           processEntityDeclarations(dtd.getEntities());
           if (fStAXValidatorHandler != null) {
             fStAXValidatorHandler.doctypeDecl(dtd);
           }
           break;
       }
     }
     fSchemaValidator.endDocument(null);
   }
 }
 final void validate(XMLStreamReader reader, StAXResult result)
     throws SAXException, XMLStreamException {
   if (reader.hasNext()) {
     int eventType = reader.getEventType();
     if (eventType != XMLStreamConstants.START_DOCUMENT
         && eventType != XMLStreamConstants.START_ELEMENT) {
       throw new SAXException(
           JAXPValidationMessageFormatter.formatMessage(
               fComponentManager.getLocale(), "StAXIllegalInitialState", null));
     }
     fXMLStreamReaderLocation.setXMLStreamReader(reader);
     setup(
         fXMLStreamReaderLocation,
         result,
         Boolean.TRUE.equals(reader.getProperty(STRING_INTERNING)));
     fSchemaValidator.startDocument(fStAXLocationWrapper, null, fNamespaceContext, null);
     do {
       switch (eventType) {
         case XMLStreamConstants.START_ELEMENT:
           ++fDepth;
           fillQName(
               fElementQName,
               reader.getNamespaceURI(),
               reader.getLocalName(),
               reader.getPrefix());
           fillXMLAttributes(reader);
           fillDeclaredPrefixes(reader);
           fNamespaceContext.setNamespaceContext(reader.getNamespaceContext());
           fSchemaValidator.startElement(fElementQName, fAttributes, null);
           break;
         case XMLStreamConstants.END_ELEMENT:
           fillQName(
               fElementQName,
               reader.getNamespaceURI(),
               reader.getLocalName(),
               reader.getPrefix());
           fillDeclaredPrefixes(reader);
           fNamespaceContext.setNamespaceContext(reader.getNamespaceContext());
           fSchemaValidator.endElement(fElementQName, null);
           --fDepth;
           break;
         case XMLStreamConstants.CHARACTERS:
         case XMLStreamConstants.SPACE:
           fTempString.setValues(
               reader.getTextCharacters(), reader.getTextStart(), reader.getTextLength());
           fSchemaValidator.characters(fTempString, null);
           break;
         case XMLStreamConstants.CDATA:
           fSchemaValidator.startCDATA(null);
           fTempString.setValues(
               reader.getTextCharacters(), reader.getTextStart(), reader.getTextLength());
           fSchemaValidator.characters(fTempString, null);
           fSchemaValidator.endCDATA(null);
           break;
         case XMLStreamConstants.START_DOCUMENT:
           ++fDepth;
           if (fStAXValidatorHandler != null) {
             fStAXValidatorHandler.startDocument(reader);
           }
           break;
         case XMLStreamConstants.PROCESSING_INSTRUCTION:
           if (fStAXValidatorHandler != null) {
             fStAXValidatorHandler.processingInstruction(reader);
           }
           break;
         case XMLStreamConstants.COMMENT:
           if (fStAXValidatorHandler != null) {
             fStAXValidatorHandler.comment(reader);
           }
           break;
         case XMLStreamConstants.ENTITY_REFERENCE:
           if (fStAXValidatorHandler != null) {
             fStAXValidatorHandler.entityReference(reader);
           }
           break;
         case XMLStreamConstants.DTD:
           processEntityDeclarations((List) reader.getProperty("javax.xml.stream.entities"));
           break;
       }
       eventType = reader.next();
     } while (reader.hasNext() && fDepth > 0);
     fSchemaValidator.endDocument(null);
     if (eventType == XMLStreamConstants.END_DOCUMENT && fStAXValidatorHandler != null) {
       fStAXValidatorHandler.endDocument(reader);
     }
   }
 }
Esempio n. 11
0
  public Schema newSchema(Source[] schemas) throws SAXException {

    // this will let the loader store parsed Grammars into the pool.
    XMLGrammarPoolImplExtension pool = new XMLGrammarPoolImplExtension();
    fXMLGrammarPoolWrapper.setGrammarPool(pool);

    XMLInputSource[] xmlInputSources = new XMLInputSource[schemas.length];
    InputStream inputStream;
    Reader reader;
    for (int i = 0; i < schemas.length; i++) {
      Source source = schemas[i];
      if (source instanceof StreamSource) {
        StreamSource streamSource = (StreamSource) source;
        String publicId = streamSource.getPublicId();
        String systemId = streamSource.getSystemId();
        inputStream = streamSource.getInputStream();
        reader = streamSource.getReader();
        xmlInputSources[i] = new XMLInputSource(publicId, systemId, null);
        xmlInputSources[i].setByteStream(inputStream);
        xmlInputSources[i].setCharacterStream(reader);
      } else if (source instanceof SAXSource) {
        SAXSource saxSource = (SAXSource) source;
        InputSource inputSource = saxSource.getInputSource();
        if (inputSource == null) {
          throw new SAXException(
              JAXPValidationMessageFormatter.formatMessage(
                  Locale.getDefault(), "SAXSourceNullInputSource", null));
        }
        xmlInputSources[i] = new SAXInputSource(saxSource.getXMLReader(), inputSource);
      } else if (source instanceof DOMSource) {
        DOMSource domSource = (DOMSource) source;
        Node node = domSource.getNode();
        String systemID = domSource.getSystemId();
        xmlInputSources[i] = new DOMInputSource(node, systemID);
      } else if (source == null) {
        throw new NullPointerException(
            JAXPValidationMessageFormatter.formatMessage(
                Locale.getDefault(), "SchemaSourceArrayMemberNull", null));
      } else {
        throw new IllegalArgumentException(
            JAXPValidationMessageFormatter.formatMessage(
                Locale.getDefault(),
                "SchemaFactorySourceUnrecognized",
                new Object[] {source.getClass().getName()}));
      }
    }

    try {
      fXMLSchemaLoader.loadGrammar(xmlInputSources);
    } catch (XNIException e) {
      // this should have been reported to users already.
      throw Util.toSAXException(e);
    } catch (IOException e) {
      // this hasn't been reported, so do so now.
      SAXParseException se = new SAXParseException(e.getMessage(), null, e);
      fErrorHandler.error(se);
      throw se; // and we must throw it.
    }

    // Clear reference to grammar pool.
    fXMLGrammarPoolWrapper.setGrammarPool(null);

    // Select Schema implementation based on grammar count.
    final int grammarCount = pool.getGrammarCount();
    if (grammarCount > 1) {
      return new XMLSchema(new ReadOnlyGrammarPool(pool));
    } else if (grammarCount == 1) {
      Grammar[] grammars = pool.retrieveInitialGrammarSet(XMLGrammarDescription.XML_SCHEMA);
      return new SimpleXMLSchema(grammars[0]);
    } else {
      return EmptyXMLSchema.getInstance();
    }
  }
Esempio n. 12
0
  public void validate(Source source, Result result) throws SAXException, IOException {
    if (result instanceof StreamResult || result == null) {
      final StreamSource streamSource = (StreamSource) source;
      final StreamResult streamResult = (StreamResult) result;
      XMLInputSource input =
          new XMLInputSource(streamSource.getPublicId(), streamSource.getSystemId(), null);
      input.setByteStream(streamSource.getInputStream());
      input.setCharacterStream(streamSource.getReader());

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

      // prepare for parse
      fComponentManager.reset();

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

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

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

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

      return;
    }
    throw new IllegalArgumentException(
        JAXPValidationMessageFormatter.formatMessage(
            fComponentManager.getLocale(),
            "SourceResultMismatch",
            new Object[] {source.getClass().getName(), result.getClass().getName()}));
  }
Esempio n. 13
0
  public void validate(Source source, Result result) throws SAXException, IOException {
    if (result instanceof SAXResult || result == null) {
      final SAXSource saxSource = (SAXSource) source;
      final SAXResult saxResult = (SAXResult) result;

      if (result != null) {
        setContentHandler(saxResult.getHandler());
      }

      try {
        XMLReader reader = saxSource.getXMLReader();
        if (reader == null) {
          // create one now
          SAXParserFactory spf = SAXParserFactory.newInstance();
          spf.setNamespaceAware(true);
          try {
            reader = spf.newSAXParser().getXMLReader();
            // If this is a Xerces SAX parser, set the security manager if there is one
            if (reader instanceof com.sun.org.apache.xerces.internal.parsers.SAXParser) {
              SecurityManager securityManager =
                  (SecurityManager) fComponentManager.getProperty(SECURITY_MANAGER);
              if (securityManager != null) {
                try {
                  reader.setProperty(SECURITY_MANAGER, securityManager);
                }
                // Ignore the exception if the security manager cannot be set.
                catch (SAXException exc) {
                }
              }
            }
          } catch (Exception e) {
            // this is impossible, but better safe than sorry
            throw new FactoryConfigurationError(e);
          }
        }

        // If XML names and Namespace URIs are already internalized we
        // can avoid running them through the SymbolTable.
        try {
          fStringsInternalized = reader.getFeature(STRING_INTERNING);
        } catch (SAXException exc) {
          // The feature isn't recognized or getting it is not supported.
          // In either case, assume that strings are not internalized.
          fStringsInternalized = false;
        }

        ErrorHandler errorHandler = fComponentManager.getErrorHandler();
        reader.setErrorHandler(
            errorHandler != null ? errorHandler : DraconianErrorHandler.getInstance());
        reader.setEntityResolver(fResolutionForwarder);
        fResolutionForwarder.setEntityResolver(fComponentManager.getResourceResolver());
        reader.setContentHandler(this);
        reader.setDTDHandler(this);

        InputSource is = saxSource.getInputSource();
        reader.parse(is);
      } finally {
        // release the reference to user's handler ASAP
        setContentHandler(null);
      }
      return;
    }
    throw new IllegalArgumentException(
        JAXPValidationMessageFormatter.formatMessage(
            Locale.getDefault(),
            "SourceResultMismatch",
            new Object[] {source.getClass().getName(), result.getClass().getName()}));
  }