Examples with SAXNotSupportedException org.xml.sax.SAXNotSupportedException used on opensource projects

Example 21 with SAXNotSupportedException

use of org.xml.sax.SAXNotSupportedException in project XobotOS by xamarin.

the class ExpatReader method parse.

public void parse(InputSource input) throws IOException, SAXException {
    if (processNamespacePrefixes && processNamespaces) {
        /*
             * Expat has XML_SetReturnNSTriplet, but that still doesn't
             * include xmlns attributes like this feature requires. We may
             * have to implement namespace processing ourselves if we want
             * this (not too difficult). We obviously "support" namespace
             * prefixes if namespaces are disabled.
             */
        throw new SAXNotSupportedException("The 'namespace-prefix' " + "feature is not supported while the 'namespaces' " + "feature is enabled.");
    }
    // Try the character stream.
    Reader reader = input.getCharacterStream();
    if (reader != null) {
        try {
            parse(reader, input.getPublicId(), input.getSystemId());
        } finally {
            IoUtils.closeQuietly(reader);
        }
        return;
    }
    // Try the byte stream.
    InputStream in = input.getByteStream();
    String encoding = input.getEncoding();
    if (in != null) {
        try {
            parse(in, encoding, input.getPublicId(), input.getSystemId());
        } finally {
            IoUtils.closeQuietly(in);
        }
        return;
    }
    String systemId = input.getSystemId();
    if (systemId == null) {
        throw new SAXException("No input specified.");
    }
    // Try the system id.
    in = ExpatParser.openUrl(systemId);
    try {
        parse(in, encoding, input.getPublicId(), systemId);
    } finally {
        IoUtils.closeQuietly(in);
    }
}

Example 22 with SAXNotSupportedException

use of org.xml.sax.SAXNotSupportedException in project robovm by robovm.

the class DTMManagerDefault method getDTM.

/**
   * Get an instance of a DTM, loaded with the content from the
   * specified source.  If the unique flag is true, a new instance will
   * always be returned.  Otherwise it is up to the DTMManager to return a
   * new instance or an instance that it already created and may be being used
   * by someone else.
   * 
   * A bit of magic in this implementation: If the source is null, unique is true,
   * and incremental and doIndexing are both false, we return an instance of
   * SAX2RTFDTM, which see.
   * 
   * (I think more parameters will need to be added for error handling, and entity
   * resolution, and more explicit control of the RTF situation).
   *
   * @param source the specification of the source object.
   * @param unique true if the returned DTM must be unique, probably because it
   * is going to be mutated.
   * @param whiteSpaceFilter Enables filtering of whitespace nodes, and may
   *                         be null.
   * @param incremental true if the DTM should be built incrementally, if
   *                    possible.
   * @param doIndexing true if the caller considers it worth it to use
   *                   indexing schemes.
   *
   * @return a non-null DTM reference.
   */
public synchronized DTM getDTM(Source source, boolean unique, DTMWSFilter whiteSpaceFilter, boolean incremental, boolean doIndexing) {
    if (DEBUG && null != source)
        System.out.println("Starting " + (unique ? "UNIQUE" : "shared") + " source: " + source.getSystemId());
    XMLStringFactory xstringFactory = m_xsf;
    int dtmPos = getFirstFreeDTMID();
    int documentID = dtmPos << IDENT_DTM_NODE_BITS;
    if ((null != source) && source instanceof DOMSource) {
        DOM2DTM dtm = new DOM2DTM(this, (DOMSource) source, documentID, whiteSpaceFilter, xstringFactory, doIndexing);
        addDTM(dtm, dtmPos, 0);
        return dtm;
    } else {
        boolean isSAXSource = (null != source) ? (source instanceof SAXSource) : true;
        boolean isStreamSource = (null != source) ? (source instanceof StreamSource) : false;
        if (isSAXSource || isStreamSource) {
            XMLReader reader = null;
            SAX2DTM dtm;
            try {
                InputSource xmlSource;
                if (null == source) {
                    xmlSource = null;
                } else {
                    reader = getXMLReader(source);
                    xmlSource = SAXSource.sourceToInputSource(source);
                    String urlOfSource = xmlSource.getSystemId();
                    if (null != urlOfSource) {
                        try {
                            urlOfSource = SystemIDResolver.getAbsoluteURI(urlOfSource);
                        } catch (Exception e) {
                            // %REVIEW% Is there a better way to send a warning?
                            System.err.println("Can not absolutize URL: " + urlOfSource);
                        }
                        xmlSource.setSystemId(urlOfSource);
                    }
                }
                if (source == null && unique && !incremental && !doIndexing) {
                    // Special case to support RTF construction into shared DTM.
                    // It should actually still work for other uses,
                    // but may be slightly deoptimized relative to the base
                    // to allow it to deal with carrying multiple documents.
                    //
                    // %REVIEW% This is a sloppy way to request this mode;
                    // we need to consider architectural improvements.
                    dtm = new SAX2RTFDTM(this, source, documentID, whiteSpaceFilter, xstringFactory, doIndexing);
                } else /**************************************************************
          // EXPERIMENTAL 3/22/02
          else if(JKESS_XNI_EXPERIMENT && m_incremental) {        	
            dtm = new XNI2DTM(this, source, documentID, whiteSpaceFilter,
                              xstringFactory, doIndexing);
          }
          **************************************************************/
                // Create the basic SAX2DTM.
                {
                    dtm = new SAX2DTM(this, source, documentID, whiteSpaceFilter, xstringFactory, doIndexing);
                }
                // Go ahead and add the DTM to the lookup table.  This needs to be
                // done before any parsing occurs. Note offset 0, since we've just
                // created a new DTM.
                addDTM(dtm, dtmPos, 0);
                boolean haveXercesParser = (null != reader) && (reader.getClass().getName().equals("org.apache.xerces.parsers.SAXParser"));
                if (haveXercesParser) {
                    // No matter what.  %REVIEW%
                    incremental = true;
                }
                // build, then we still want to set up the IncrementalSAXSource stuff.
                if (m_incremental && incremental) /* || ((null == reader) && incremental) */
                {
                    IncrementalSAXSource coParser = null;
                    if (haveXercesParser) {
                        // IncrementalSAXSource_Xerces to avoid threading.
                        try {
                            coParser = (IncrementalSAXSource) Class.forName("org.apache.xml.dtm.ref.IncrementalSAXSource_Xerces").newInstance();
                        } catch (Exception ex) {
                            ex.printStackTrace();
                            coParser = null;
                        }
                    }
                    if (coParser == null) {
                        // Create a IncrementalSAXSource to run on the secondary thread.
                        if (null == reader) {
                            coParser = new IncrementalSAXSource_Filter();
                        } else {
                            IncrementalSAXSource_Filter filter = new IncrementalSAXSource_Filter();
                            filter.setXMLReader(reader);
                            coParser = filter;
                        }
                    }
                    /**************************************************************
            // EXPERIMENTAL 3/22/02
            if (JKESS_XNI_EXPERIMENT && m_incremental &&
                  dtm instanceof XNI2DTM && 
                  coParser instanceof IncrementalSAXSource_Xerces) {
                org.apache.xerces.xni.parser.XMLPullParserConfiguration xpc=
                      ((IncrementalSAXSource_Xerces)coParser)
                                           .getXNIParserConfiguration();
              if (xpc!=null) {
                // Bypass SAX; listen to the XNI stream
                ((XNI2DTM)dtm).setIncrementalXNISource(xpc);
              } else {
                  // Listen to the SAX stream (will fail, diagnostically...)
                dtm.setIncrementalSAXSource(coParser);
              }
            } else
            ***************************************************************/
                    // Have the DTM set itself up as IncrementalSAXSource's listener.
                    dtm.setIncrementalSAXSource(coParser);
                    if (null == xmlSource) {
                        // Then the user will construct it themselves.
                        return dtm;
                    }
                    if (null == reader.getErrorHandler()) {
                        reader.setErrorHandler(dtm);
                    }
                    reader.setDTDHandler(dtm);
                    try {
                        // Launch parsing coroutine.  Launches a second thread,
                        // if we're using IncrementalSAXSource.filter().
                        coParser.startParse(xmlSource);
                    } catch (RuntimeException re) {
                        dtm.clearCoRoutine();
                        throw re;
                    } catch (Exception e) {
                        dtm.clearCoRoutine();
                        throw new org.apache.xml.utils.WrappedRuntimeException(e);
                    }
                } else {
                    if (null == reader) {
                        // Then the user will construct it themselves.
                        return dtm;
                    }
                    // not incremental
                    reader.setContentHandler(dtm);
                    reader.setDTDHandler(dtm);
                    if (null == reader.getErrorHandler()) {
                        reader.setErrorHandler(dtm);
                    }
                    try {
                        reader.setProperty("http://xml.org/sax/properties/lexical-handler", dtm);
                    } catch (SAXNotRecognizedException e) {
                    } catch (SAXNotSupportedException e) {
                    }
                    try {
                        reader.parse(xmlSource);
                    } catch (RuntimeException re) {
                        dtm.clearCoRoutine();
                        throw re;
                    } catch (Exception e) {
                        dtm.clearCoRoutine();
                        throw new org.apache.xml.utils.WrappedRuntimeException(e);
                    }
                }
                if (DUMPTREE) {
                    System.out.println("Dumping SAX2DOM");
                    dtm.dumpDTM(System.err);
                }
                return dtm;
            } finally {
                // after creating the DTM.
                if (reader != null && !(m_incremental && incremental)) {
                    reader.setContentHandler(m_defaultHandler);
                    reader.setDTDHandler(m_defaultHandler);
                    reader.setErrorHandler(m_defaultHandler);
                    // Reset the LexicalHandler to null after creating the DTM.
                    try {
                        reader.setProperty("http://xml.org/sax/properties/lexical-handler", null);
                    } catch (Exception e) {
                    }
                }
                releaseXMLReader(reader);
            }
        } else {
            //"Not supported: " + source);
            throw new DTMException(XMLMessages.createXMLMessage(XMLErrorResources.ER_NOT_SUPPORTED, new Object[] { source }));
        }
    }
}

Example 23 with SAXNotSupportedException

use of org.xml.sax.SAXNotSupportedException in project webtools.sourceediting by eclipse.

the class XslOutputMethodSniffer method createParser.

/**
 * Creates a new SAX parser for use within this instance.
 *
 * @return The newly created parser.
 *
 * @throws ParserConfigurationException
 *             If a parser of the given configuration cannot be created.
 * @throws SAXException
 *             If something in general goes wrong when creating the parser.
 * @throws SAXNotRecognizedException
 *             If the <code>XMLReader</code> does not recognize the
 *             lexical handler configuration option.
 * @throws SAXNotSupportedException
 *             If the <code>XMLReader</code> does not support the lexical
 *             handler configuration option.
 */
private final SAXParser createParser(SAXParserFactory parserFactory) throws ParserConfigurationException, SAXException, SAXNotRecognizedException, SAXNotSupportedException {
    // Initialize the parser.
    final SAXParser parser = parserFactory.newSAXParser();
    final XMLReader reader = parser.getXMLReader();
    try {
        // be sure validation is "off" or the feature to ignore DTD's will not apply
        // $NON-NLS-1$
        reader.setFeature("http://xml.org/sax/features/validation", false);
        // $NON-NLS-1$
        reader.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
    } catch (SAXNotRecognizedException e) {
    // not a big deal if the parser does not recognize the features
    } catch (SAXNotSupportedException e) {
    // not a big deal if the parser does not support the features
    }
    return parser;
}

Example 24 with SAXNotSupportedException

use of org.xml.sax.SAXNotSupportedException in project webtools.sourceediting by eclipse.

the class XMLProcessingInstructionSniffer method createParser.

/**
 * Creates a new SAX parser for use within this instance.
 *
 * @return The newly created parser.
 *
 * @throws ParserConfigurationException
 *             If a parser of the given configuration cannot be created.
 * @throws SAXException
 *             If something in general goes wrong when creating the parser.
 * @throws SAXNotRecognizedException
 *             If the <code>XMLReader</code> does not recognize the
 *             lexical handler configuration option.
 * @throws SAXNotSupportedException
 *             If the <code>XMLReader</code> does not support the lexical
 *             handler configuration option.
 */
private final SAXParser createParser(SAXParserFactory parserFactory) throws ParserConfigurationException, SAXException, SAXNotRecognizedException, SAXNotSupportedException {
    // Initialize the parser.
    final SAXParser parser = parserFactory.newSAXParser();
    final XMLReader reader = parser.getXMLReader();
    // disable DTD validation (bug 63625)
    try {
        // be sure validation is "off" or the feature to ignore DTD's will not apply
        // $NON-NLS-1$
        reader.setFeature("http://xml.org/sax/features/validation", false);
        // $NON-NLS-1$
        reader.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
    } catch (SAXNotRecognizedException e) {
    // not a big deal if the parser does not recognize the features
    } catch (SAXNotSupportedException e) {
    // not a big deal if the parser does not support the features
    }
    return parser;
}

Example 25 with SAXNotSupportedException

use of org.xml.sax.SAXNotSupportedException in project iaf by ibissource.

the class MyErrorHandler method getValidatorHandler.

public ValidatorHandler getValidatorHandler(IPipeLineSession session, ValidationContext context) throws ConfigurationException, PipeRunException {
    ValidatorHandler validatorHandler = null;
    try {
        XMLSchemaFactory schemaFactory = new XMLSchemaFactory();
        javax.xml.validation.Schema schemaObject = schemaFactory.newSchema(((XercesValidationContext) context).getGrammarPool());
        validatorHandler = schemaObject.newValidatorHandler();
    } catch (SAXException e) {
        throw new ConfigurationException(logPrefix + "Cannot create schema", e);
    }
    try {
        // validatorHandler.setFeature(NAMESPACES_FEATURE_ID, true);
        validatorHandler.setFeature(VALIDATION_FEATURE_ID, true);
        validatorHandler.setFeature(SCHEMA_VALIDATION_FEATURE_ID, true);
        validatorHandler.setFeature(SCHEMA_FULL_CHECKING_FEATURE_ID, isFullSchemaChecking());
        validatorHandler.setErrorHandler(context.getErrorHandler());
    } catch (SAXNotRecognizedException e) {
        throw new ConfigurationException(logPrefix + "ValidatorHandler does not recognize necessary feature", e);
    } catch (SAXNotSupportedException e) {
        throw new ConfigurationException(logPrefix + "ValidatorHandler does not support necessary feature", e);
    }
    return validatorHandler;
}