/** Creates a SAXParseException from an XMLParseException. */
 protected static SAXParseException createSAXParseException(XMLParseException exception) {
   return new SAXParseException(
       exception.getMessage(),
       exception.getPublicId(),
       exception.getExpandedSystemId(),
       exception.getLineNumber(),
       exception.getColumnNumber(),
       exception.getException());
 } // createSAXParseException(XMLParseException):SAXParseException
Exemple #2
0
 public static SAXParseException toSAXParseException(XMLParseException e) {
   if (e.getException() instanceof SAXParseException) return (SAXParseException) e.getException();
   return new SAXParseException(
       e.getMessage(),
       e.getPublicId(),
       e.getExpandedSystemId(),
       e.getLineNumber(),
       e.getColumnNumber(),
       e.getException());
 }
  /**
   * parse
   *
   * @param inputSource
   * @exception org.xml.sax.SAXException
   * @exception java.io.IOException
   */
  public void parse(InputSource inputSource) throws SAXException, IOException {

    // parse document
    try {
      XMLInputSource xmlInputSource =
          new XMLInputSource(inputSource.getPublicId(), inputSource.getSystemId(), null);
      xmlInputSource.setByteStream(inputSource.getByteStream());
      xmlInputSource.setCharacterStream(inputSource.getCharacterStream());
      xmlInputSource.setEncoding(inputSource.getEncoding());
      parse(xmlInputSource);
    }

    // wrap XNI exceptions as SAX exceptions
    catch (XMLParseException e) {
      Exception ex = e.getException();
      if (ex == null) {
        // must be a parser exception; mine it for locator info and throw
        // a SAXParseException
        LocatorImpl locatorImpl = new LocatorImpl();
        locatorImpl.setPublicId(e.getPublicId());
        locatorImpl.setSystemId(e.getExpandedSystemId());
        locatorImpl.setLineNumber(e.getLineNumber());
        locatorImpl.setColumnNumber(e.getColumnNumber());
        throw new SAXParseException(e.getMessage(), locatorImpl);
      }
      if (ex instanceof SAXException) {
        // why did we create an XMLParseException?
        throw (SAXException) ex;
      }
      if (ex instanceof IOException) {
        throw (IOException) ex;
      }
      throw new SAXException(ex);
    } catch (XNIException e) {
      Exception ex = e.getException();
      if (ex == null) {
        throw new SAXException(e.getMessage());
      }
      if (ex instanceof SAXException) {
        throw (SAXException) ex;
      }
      if (ex instanceof IOException) {
        throw (IOException) ex;
      }
      throw new SAXException(ex);
    }
  } // parse(InputSource)
 /**
  * Reports an error. Errors are non-fatal and usually signify that the document is invalid with
  * respect to its grammar(s).
  *
  * @param domain The domain of the error. The domain can be any string but is suggested to be a
  *     valid URI. The domain can be used to conveniently specify a web site location of the
  *     relevent specification or document pertaining to this error.
  * @param key The error key. This key can be any string and is implementation dependent.
  * @param exception Exception.
  * @throws XNIException Thrown to signal that the parser should stop parsing the document.
  */
 public void error(String domain, String key, XMLParseException exception) throws XNIException {
   fDOMError.fSeverity = DOMError.SEVERITY_ERROR;
   fDOMError.fException = exception;
   // REVISIT: May need to lookup from DOMErrorTypeMap in the future.
   fDOMError.fType = key;
   fDOMError.fRelatedData = fDOMError.fMessage = exception.getMessage();
   DOMLocatorImpl locator = fDOMError.fLocator;
   if (locator != null) {
     locator.fColumnNumber = exception.getColumnNumber();
     locator.fLineNumber = exception.getLineNumber();
     locator.fUtf16Offset = exception.getCharacterOffset();
     locator.fUri = exception.getExpandedSystemId();
     locator.fRelatedNode = fCurrentNode;
   }
   if (fDomErrorHandler != null) {
     fDomErrorHandler.handleError(fDOMError);
   }
 } // error(String,String,XMLParseException)
  /**
   * Parses the input source specified by the given system identifier.
   *
   * <p>This method is equivalent to the following:
   *
   * <pre>
   *     parse(new InputSource(systemId));
   * </pre>
   *
   * @param systemId The system identifier (URI).
   * @exception org.xml.sax.SAXException Throws exception on SAX error.
   * @exception java.io.IOException Throws exception on i/o error.
   */
  public void parse(String systemId) throws SAXException, IOException {

    // parse document
    XMLInputSource source = new XMLInputSource(null, systemId, null);
    try {
      parse(source);
    }

    // wrap XNI exceptions as SAX exceptions
    catch (XMLParseException e) {
      Exception ex = e.getException();
      if (ex == null) {
        // must be a parser exception; mine it for locator info and throw
        // a SAXParseException
        LocatorImpl locatorImpl = new LocatorImpl();
        locatorImpl.setPublicId(e.getPublicId());
        locatorImpl.setSystemId(e.getExpandedSystemId());
        locatorImpl.setLineNumber(e.getLineNumber());
        locatorImpl.setColumnNumber(e.getColumnNumber());
        throw new SAXParseException(e.getMessage(), locatorImpl);
      }
      if (ex instanceof SAXException) {
        // why did we create an XMLParseException?
        throw (SAXException) ex;
      }
      if (ex instanceof IOException) {
        throw (IOException) ex;
      }
      throw new SAXException(ex);
    } catch (XNIException e) {
      e.printStackTrace();
      Exception ex = e.getException();
      if (ex == null) {
        throw new SAXException(e.getMessage());
      }
      if (ex instanceof SAXException) {
        throw (SAXException) ex;
      }
      if (ex instanceof IOException) {
        throw (IOException) ex;
      }
      throw new SAXException(ex);
    }
  } // parse(String)
 /**
  * Report a fatal error. Fatal errors usually occur when the document is not well-formed and
  * signifies that the parser cannot continue normal operation.
  *
  * <p><strong>Note:</strong> The error handler should <em>always</em> throw an <code>XNIException
  * </code> from this method. This exception can either be the same exception that is passed as a
  * parameter to the method or a new XNI exception object. If the registered error handler fails to
  * throw an exception, the continuing operation of the parser is undetermined.
  *
  * @param domain The domain of the fatal error. The domain can be any string but is suggested to
  *     be a valid URI. The domain can be used to conveniently specify a web site location of the
  *     relevent specification or document pertaining to this fatal error.
  * @param key The fatal error key. This key can be any string and is implementation dependent.
  * @param exception Exception.
  * @throws XNIException Thrown to signal that the parser should stop parsing the document.
  */
 public void fatalError(String domain, String key, XMLParseException exception)
     throws XNIException {
   fDOMError.fSeverity = DOMError.SEVERITY_FATAL_ERROR;
   fDOMError.fException = exception;
   fErrorCode.setValues(domain, key);
   String domErrorType = DOMErrorTypeMap.getDOMErrorType(fErrorCode);
   fDOMError.fType = (domErrorType != null) ? domErrorType : key;
   fDOMError.fRelatedData = fDOMError.fMessage = exception.getMessage();
   DOMLocatorImpl locator = fDOMError.fLocator;
   if (locator != null) {
     locator.fColumnNumber = exception.getColumnNumber();
     locator.fLineNumber = exception.getLineNumber();
     locator.fUtf16Offset = exception.getCharacterOffset();
     locator.fUri = exception.getExpandedSystemId();
     locator.fRelatedNode = fCurrentNode;
   }
   if (fDomErrorHandler != null) {
     fDomErrorHandler.handleError(fDOMError);
   }
 } // fatalError(String,String,XMLParseException)