feat(jdk8): move files to new folder to avoid resources compiled.
This commit is contained in:
281
jdkSrc/jdk8/jdk/internal/org/xml/sax/Attributes.java
Normal file
281
jdkSrc/jdk8/jdk/internal/org/xml/sax/Attributes.java
Normal file
@@ -0,0 +1,281 @@
|
||||
/*
|
||||
* Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
// Attributes.java - attribute list with Namespace support
|
||||
// http://www.saxproject.org
|
||||
// Written by David Megginson
|
||||
// NO WARRANTY! This class is in the public domain.
|
||||
// $Id: Attributes.java,v 1.2 2004/11/03 22:44:51 jsuttor Exp $
|
||||
|
||||
package jdk.internal.org.xml.sax;
|
||||
|
||||
|
||||
/**
|
||||
* Interface for a list of XML attributes.
|
||||
*
|
||||
* <blockquote>
|
||||
* <em>This module, both source code and documentation, is in the
|
||||
* Public Domain, and comes with <strong>NO WARRANTY</strong>.</em>
|
||||
* See <a href='http://www.saxproject.org'>http://www.saxproject.org</a>
|
||||
* for further information.
|
||||
* </blockquote>
|
||||
*
|
||||
* <p>This interface allows access to a list of attributes in
|
||||
* three different ways:</p>
|
||||
*
|
||||
* <ol>
|
||||
* <li>by attribute index;</li>
|
||||
* <li>by Namespace-qualified name; or</li>
|
||||
* <li>by qualified (prefixed) name.</li>
|
||||
* </ol>
|
||||
*
|
||||
* <p>The list will not contain attributes that were declared
|
||||
* #IMPLIED but not specified in the start tag. It will also not
|
||||
* contain attributes used as Namespace declarations (xmlns*) unless
|
||||
* the <code>http://xml.org/sax/features/namespace-prefixes</code>
|
||||
* feature is set to <var>true</var> (it is <var>false</var> by
|
||||
* default).
|
||||
* Because SAX2 conforms to the original "Namespaces in XML"
|
||||
* recommendation, it normally does not
|
||||
* give namespace declaration attributes a namespace URI.
|
||||
* </p>
|
||||
*
|
||||
* <p>Some SAX2 parsers may support using an optional feature flag
|
||||
* (<code>http://xml.org/sax/features/xmlns-uris</code>) to request
|
||||
* that those attributes be given URIs, conforming to a later
|
||||
* backwards-incompatible revision of that recommendation. (The
|
||||
* attribute's "local name" will be the prefix, or "xmlns" when
|
||||
* defining a default element namespace.) For portability, handler
|
||||
* code should always resolve that conflict, rather than requiring
|
||||
* parsers that can change the setting of that feature flag. </p>
|
||||
*
|
||||
* <p>If the namespace-prefixes feature (see above) is
|
||||
* <var>false</var>, access by qualified name may not be available; if
|
||||
* the <code>http://xml.org/sax/features/namespaces</code> feature is
|
||||
* <var>false</var>, access by Namespace-qualified names may not be
|
||||
* available.</p>
|
||||
*
|
||||
* <p>This interface replaces the now-deprecated SAX1 {@link
|
||||
* org.xml.sax.AttributeList AttributeList} interface, which does not
|
||||
* contain Namespace support. In addition to Namespace support, it
|
||||
* adds the <var>getIndex</var> methods (below).</p>
|
||||
*
|
||||
* <p>The order of attributes in the list is unspecified, and will
|
||||
* vary from implementation to implementation.</p>
|
||||
*
|
||||
* @since SAX 2.0
|
||||
* @author David Megginson
|
||||
* @see org.xml.sax.helpers.AttributesImpl
|
||||
* @see org.xml.sax.ext.DeclHandler#attributeDecl
|
||||
*/
|
||||
public interface Attributes
|
||||
{
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Indexed access.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* Return the number of attributes in the list.
|
||||
*
|
||||
* <p>Once you know the number of attributes, you can iterate
|
||||
* through the list.</p>
|
||||
*
|
||||
* @return The number of attributes in the list.
|
||||
* @see #getURI(int)
|
||||
* @see #getLocalName(int)
|
||||
* @see #getQName(int)
|
||||
* @see #getType(int)
|
||||
* @see #getValue(int)
|
||||
*/
|
||||
public abstract int getLength ();
|
||||
|
||||
|
||||
/**
|
||||
* Look up an attribute's Namespace URI by index.
|
||||
*
|
||||
* @param index The attribute index (zero-based).
|
||||
* @return The Namespace URI, or the empty string if none
|
||||
* is available, or null if the index is out of
|
||||
* range.
|
||||
* @see #getLength
|
||||
*/
|
||||
public abstract String getURI (int index);
|
||||
|
||||
|
||||
/**
|
||||
* Look up an attribute's local name by index.
|
||||
*
|
||||
* @param index The attribute index (zero-based).
|
||||
* @return The local name, or the empty string if Namespace
|
||||
* processing is not being performed, or null
|
||||
* if the index is out of range.
|
||||
* @see #getLength
|
||||
*/
|
||||
public abstract String getLocalName (int index);
|
||||
|
||||
|
||||
/**
|
||||
* Look up an attribute's XML qualified (prefixed) name by index.
|
||||
*
|
||||
* @param index The attribute index (zero-based).
|
||||
* @return The XML qualified name, or the empty string
|
||||
* if none is available, or null if the index
|
||||
* is out of range.
|
||||
* @see #getLength
|
||||
*/
|
||||
public abstract String getQName (int index);
|
||||
|
||||
|
||||
/**
|
||||
* Look up an attribute's type by index.
|
||||
*
|
||||
* <p>The attribute type is one of the strings "CDATA", "ID",
|
||||
* "IDREF", "IDREFS", "NMTOKEN", "NMTOKENS", "ENTITY", "ENTITIES",
|
||||
* or "NOTATION" (always in upper case).</p>
|
||||
*
|
||||
* <p>If the parser has not read a declaration for the attribute,
|
||||
* or if the parser does not report attribute types, then it must
|
||||
* return the value "CDATA" as stated in the XML 1.0 Recommendation
|
||||
* (clause 3.3.3, "Attribute-Value Normalization").</p>
|
||||
*
|
||||
* <p>For an enumerated attribute that is not a notation, the
|
||||
* parser will report the type as "NMTOKEN".</p>
|
||||
*
|
||||
* @param index The attribute index (zero-based).
|
||||
* @return The attribute's type as a string, or null if the
|
||||
* index is out of range.
|
||||
* @see #getLength
|
||||
*/
|
||||
public abstract String getType (int index);
|
||||
|
||||
|
||||
/**
|
||||
* Look up an attribute's value by index.
|
||||
*
|
||||
* <p>If the attribute value is a list of tokens (IDREFS,
|
||||
* ENTITIES, or NMTOKENS), the tokens will be concatenated
|
||||
* into a single string with each token separated by a
|
||||
* single space.</p>
|
||||
*
|
||||
* @param index The attribute index (zero-based).
|
||||
* @return The attribute's value as a string, or null if the
|
||||
* index is out of range.
|
||||
* @see #getLength
|
||||
*/
|
||||
public abstract String getValue (int index);
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Name-based query.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* Look up the index of an attribute by Namespace name.
|
||||
*
|
||||
* @param uri The Namespace URI, or the empty string if
|
||||
* the name has no Namespace URI.
|
||||
* @param localName The attribute's local name.
|
||||
* @return The index of the attribute, or -1 if it does not
|
||||
* appear in the list.
|
||||
*/
|
||||
public int getIndex (String uri, String localName);
|
||||
|
||||
|
||||
/**
|
||||
* Look up the index of an attribute by XML qualified (prefixed) name.
|
||||
*
|
||||
* @param qName The qualified (prefixed) name.
|
||||
* @return The index of the attribute, or -1 if it does not
|
||||
* appear in the list.
|
||||
*/
|
||||
public int getIndex (String qName);
|
||||
|
||||
|
||||
/**
|
||||
* Look up an attribute's type by Namespace name.
|
||||
*
|
||||
* <p>See {@link #getType(int) getType(int)} for a description
|
||||
* of the possible types.</p>
|
||||
*
|
||||
* @param uri The Namespace URI, or the empty String if the
|
||||
* name has no Namespace URI.
|
||||
* @param localName The local name of the attribute.
|
||||
* @return The attribute type as a string, or null if the
|
||||
* attribute is not in the list or if Namespace
|
||||
* processing is not being performed.
|
||||
*/
|
||||
public abstract String getType (String uri, String localName);
|
||||
|
||||
|
||||
/**
|
||||
* Look up an attribute's type by XML qualified (prefixed) name.
|
||||
*
|
||||
* <p>See {@link #getType(int) getType(int)} for a description
|
||||
* of the possible types.</p>
|
||||
*
|
||||
* @param qName The XML qualified name.
|
||||
* @return The attribute type as a string, or null if the
|
||||
* attribute is not in the list or if qualified names
|
||||
* are not available.
|
||||
*/
|
||||
public abstract String getType (String qName);
|
||||
|
||||
|
||||
/**
|
||||
* Look up an attribute's value by Namespace name.
|
||||
*
|
||||
* <p>See {@link #getValue(int) getValue(int)} for a description
|
||||
* of the possible values.</p>
|
||||
*
|
||||
* @param uri The Namespace URI, or the empty String if the
|
||||
* name has no Namespace URI.
|
||||
* @param localName The local name of the attribute.
|
||||
* @return The attribute value as a string, or null if the
|
||||
* attribute is not in the list.
|
||||
*/
|
||||
public abstract String getValue (String uri, String localName);
|
||||
|
||||
|
||||
/**
|
||||
* Look up an attribute's value by XML qualified (prefixed) name.
|
||||
*
|
||||
* <p>See {@link #getValue(int) getValue(int)} for a description
|
||||
* of the possible values.</p>
|
||||
*
|
||||
* @param qName The XML qualified name.
|
||||
* @return The attribute value as a string, or null if the
|
||||
* attribute is not in the list or if qualified names
|
||||
* are not available.
|
||||
*/
|
||||
public abstract String getValue (String qName);
|
||||
|
||||
}
|
||||
|
||||
// end of Attributes.java
|
||||
443
jdkSrc/jdk8/jdk/internal/org/xml/sax/ContentHandler.java
Normal file
443
jdkSrc/jdk8/jdk/internal/org/xml/sax/ContentHandler.java
Normal file
@@ -0,0 +1,443 @@
|
||||
/*
|
||||
* Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
// ContentHandler.java - handle main document content.
|
||||
// http://www.saxproject.org
|
||||
// Written by David Megginson
|
||||
// NO WARRANTY! This class is in the public domain.
|
||||
// $Id: ContentHandler.java,v 1.2 2004/11/03 22:44:51 jsuttor Exp $
|
||||
|
||||
package jdk.internal.org.xml.sax;
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of the logical content of a document.
|
||||
*
|
||||
* <blockquote>
|
||||
* <em>This module, both source code and documentation, is in the
|
||||
* Public Domain, and comes with <strong>NO WARRANTY</strong>.</em>
|
||||
* See <a href='http://www.saxproject.org'>http://www.saxproject.org</a>
|
||||
* for further information.
|
||||
* </blockquote>
|
||||
*
|
||||
* <p>This is the main interface that most SAX applications
|
||||
* implement: if the application needs to be informed of basic parsing
|
||||
* events, it implements this interface and registers an instance with
|
||||
* the SAX parser using the {@link org.xml.sax.XMLReader#setContentHandler
|
||||
* setContentHandler} method. The parser uses the instance to report
|
||||
* basic document-related events like the start and end of elements
|
||||
* and character data.</p>
|
||||
*
|
||||
* <p>The order of events in this interface is very important, and
|
||||
* mirrors the order of information in the document itself. For
|
||||
* example, all of an element's content (character data, processing
|
||||
* instructions, and/or subelements) will appear, in order, between
|
||||
* the startElement event and the corresponding endElement event.</p>
|
||||
*
|
||||
* <p>This interface is similar to the now-deprecated SAX 1.0
|
||||
* DocumentHandler interface, but it adds support for Namespaces
|
||||
* and for reporting skipped entities (in non-validating XML
|
||||
* processors).</p>
|
||||
*
|
||||
* <p>Implementors should note that there is also a
|
||||
* <code>ContentHandler</code> class in the <code>java.net</code>
|
||||
* package; that means that it's probably a bad idea to do</p>
|
||||
*
|
||||
* <pre>import java.net.*;
|
||||
* import org.xml.sax.*;
|
||||
* </pre>
|
||||
*
|
||||
* <p>In fact, "import ...*" is usually a sign of sloppy programming
|
||||
* anyway, so the user should consider this a feature rather than a
|
||||
* bug.</p>
|
||||
*
|
||||
* @since SAX 2.0
|
||||
* @author David Megginson
|
||||
* @see org.xml.sax.XMLReader
|
||||
* @see org.xml.sax.DTDHandler
|
||||
* @see org.xml.sax.ErrorHandler
|
||||
*/
|
||||
public interface ContentHandler
|
||||
{
|
||||
|
||||
/**
|
||||
* Receive an object for locating the origin of SAX document events.
|
||||
*
|
||||
* <p>SAX parsers are strongly encouraged (though not absolutely
|
||||
* required) to supply a locator: if it does so, it must supply
|
||||
* the locator to the application by invoking this method before
|
||||
* invoking any of the other methods in the ContentHandler
|
||||
* interface.</p>
|
||||
*
|
||||
* <p>The locator allows the application to determine the end
|
||||
* position of any document-related event, even if the parser is
|
||||
* not reporting an error. Typically, the application will
|
||||
* use this information for reporting its own errors (such as
|
||||
* character content that does not match an application's
|
||||
* business rules). The information returned by the locator
|
||||
* is probably not sufficient for use with a search engine.</p>
|
||||
*
|
||||
* <p>Note that the locator will return correct information only
|
||||
* during the invocation SAX event callbacks after
|
||||
* {@link #startDocument startDocument} returns and before
|
||||
* {@link #endDocument endDocument} is called. The
|
||||
* application should not attempt to use it at any other time.</p>
|
||||
*
|
||||
* @param locator an object that can return the location of
|
||||
* any SAX document event
|
||||
* @see org.xml.sax.Locator
|
||||
*/
|
||||
public void setDocumentLocator (Locator locator);
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of the beginning of a document.
|
||||
*
|
||||
* <p>The SAX parser will invoke this method only once, before any
|
||||
* other event callbacks (except for {@link #setDocumentLocator
|
||||
* setDocumentLocator}).</p>
|
||||
*
|
||||
* @throws org.xml.sax.SAXException any SAX exception, possibly
|
||||
* wrapping another exception
|
||||
* @see #endDocument
|
||||
*/
|
||||
public void startDocument ()
|
||||
throws SAXException;
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of the end of a document.
|
||||
*
|
||||
* <p><strong>There is an apparent contradiction between the
|
||||
* documentation for this method and the documentation for {@link
|
||||
* org.xml.sax.ErrorHandler#fatalError}. Until this ambiguity is
|
||||
* resolved in a future major release, clients should make no
|
||||
* assumptions about whether endDocument() will or will not be
|
||||
* invoked when the parser has reported a fatalError() or thrown
|
||||
* an exception.</strong></p>
|
||||
*
|
||||
* <p>The SAX parser will invoke this method only once, and it will
|
||||
* be the last method invoked during the parse. The parser shall
|
||||
* not invoke this method until it has either abandoned parsing
|
||||
* (because of an unrecoverable error) or reached the end of
|
||||
* input.</p>
|
||||
*
|
||||
* @throws org.xml.sax.SAXException any SAX exception, possibly
|
||||
* wrapping another exception
|
||||
* @see #startDocument
|
||||
*/
|
||||
public void endDocument()
|
||||
throws SAXException;
|
||||
|
||||
|
||||
/**
|
||||
* Begin the scope of a prefix-URI Namespace mapping.
|
||||
*
|
||||
* <p>The information from this event is not necessary for
|
||||
* normal Namespace processing: the SAX XML reader will
|
||||
* automatically replace prefixes for element and attribute
|
||||
* names when the <code>http://xml.org/sax/features/namespaces</code>
|
||||
* feature is <var>true</var> (the default).</p>
|
||||
*
|
||||
* <p>There are cases, however, when applications need to
|
||||
* use prefixes in character data or in attribute values,
|
||||
* where they cannot safely be expanded automatically; the
|
||||
* start/endPrefixMapping event supplies the information
|
||||
* to the application to expand prefixes in those contexts
|
||||
* itself, if necessary.</p>
|
||||
*
|
||||
* <p>Note that start/endPrefixMapping events are not
|
||||
* guaranteed to be properly nested relative to each other:
|
||||
* all startPrefixMapping events will occur immediately before the
|
||||
* corresponding {@link #startElement startElement} event,
|
||||
* and all {@link #endPrefixMapping endPrefixMapping}
|
||||
* events will occur immediately after the corresponding
|
||||
* {@link #endElement endElement} event,
|
||||
* but their order is not otherwise
|
||||
* guaranteed.</p>
|
||||
*
|
||||
* <p>There should never be start/endPrefixMapping events for the
|
||||
* "xml" prefix, since it is predeclared and immutable.</p>
|
||||
*
|
||||
* @param prefix the Namespace prefix being declared.
|
||||
* An empty string is used for the default element namespace,
|
||||
* which has no prefix.
|
||||
* @param uri the Namespace URI the prefix is mapped to
|
||||
* @throws org.xml.sax.SAXException the client may throw
|
||||
* an exception during processing
|
||||
* @see #endPrefixMapping
|
||||
* @see #startElement
|
||||
*/
|
||||
public void startPrefixMapping (String prefix, String uri)
|
||||
throws SAXException;
|
||||
|
||||
|
||||
/**
|
||||
* End the scope of a prefix-URI mapping.
|
||||
*
|
||||
* <p>See {@link #startPrefixMapping startPrefixMapping} for
|
||||
* details. These events will always occur immediately after the
|
||||
* corresponding {@link #endElement endElement} event, but the order of
|
||||
* {@link #endPrefixMapping endPrefixMapping} events is not otherwise
|
||||
* guaranteed.</p>
|
||||
*
|
||||
* @param prefix the prefix that was being mapped.
|
||||
* This is the empty string when a default mapping scope ends.
|
||||
* @throws org.xml.sax.SAXException the client may throw
|
||||
* an exception during processing
|
||||
* @see #startPrefixMapping
|
||||
* @see #endElement
|
||||
*/
|
||||
public void endPrefixMapping (String prefix)
|
||||
throws SAXException;
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of the beginning of an element.
|
||||
*
|
||||
* <p>The Parser will invoke this method at the beginning of every
|
||||
* element in the XML document; there will be a corresponding
|
||||
* {@link #endElement endElement} event for every startElement event
|
||||
* (even when the element is empty). All of the element's content will be
|
||||
* reported, in order, before the corresponding endElement
|
||||
* event.</p>
|
||||
*
|
||||
* <p>This event allows up to three name components for each
|
||||
* element:</p>
|
||||
*
|
||||
* <ol>
|
||||
* <li>the Namespace URI;</li>
|
||||
* <li>the local name; and</li>
|
||||
* <li>the qualified (prefixed) name.</li>
|
||||
* </ol>
|
||||
*
|
||||
* <p>Any or all of these may be provided, depending on the
|
||||
* values of the <var>http://xml.org/sax/features/namespaces</var>
|
||||
* and the <var>http://xml.org/sax/features/namespace-prefixes</var>
|
||||
* properties:</p>
|
||||
*
|
||||
* <ul>
|
||||
* <li>the Namespace URI and local name are required when
|
||||
* the namespaces property is <var>true</var> (the default), and are
|
||||
* optional when the namespaces property is <var>false</var> (if one is
|
||||
* specified, both must be);</li>
|
||||
* <li>the qualified name is required when the namespace-prefixes property
|
||||
* is <var>true</var>, and is optional when the namespace-prefixes property
|
||||
* is <var>false</var> (the default).</li>
|
||||
* </ul>
|
||||
*
|
||||
* <p>Note that the attribute list provided will contain only
|
||||
* attributes with explicit values (specified or defaulted):
|
||||
* #IMPLIED attributes will be omitted. The attribute list
|
||||
* will contain attributes used for Namespace declarations
|
||||
* (xmlns* attributes) only if the
|
||||
* <code>http://xml.org/sax/features/namespace-prefixes</code>
|
||||
* property is true (it is false by default, and support for a
|
||||
* true value is optional).</p>
|
||||
*
|
||||
* <p>Like {@link #characters characters()}, attribute values may have
|
||||
* characters that need more than one <code>char</code> value. </p>
|
||||
*
|
||||
* @param uri the Namespace URI, or the empty string if the
|
||||
* element has no Namespace URI or if Namespace
|
||||
* processing is not being performed
|
||||
* @param localName the local name (without prefix), or the
|
||||
* empty string if Namespace processing is not being
|
||||
* performed
|
||||
* @param qName the qualified name (with prefix), or the
|
||||
* empty string if qualified names are not available
|
||||
* @param atts the attributes attached to the element. If
|
||||
* there are no attributes, it shall be an empty
|
||||
* Attributes object. The value of this object after
|
||||
* startElement returns is undefined
|
||||
* @throws org.xml.sax.SAXException any SAX exception, possibly
|
||||
* wrapping another exception
|
||||
* @see #endElement
|
||||
* @see org.xml.sax.Attributes
|
||||
* @see org.xml.sax.helpers.AttributesImpl
|
||||
*/
|
||||
public void startElement (String uri, String localName,
|
||||
String qName, Attributes atts)
|
||||
throws SAXException;
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of the end of an element.
|
||||
*
|
||||
* <p>The SAX parser will invoke this method at the end of every
|
||||
* element in the XML document; there will be a corresponding
|
||||
* {@link #startElement startElement} event for every endElement
|
||||
* event (even when the element is empty).</p>
|
||||
*
|
||||
* <p>For information on the names, see startElement.</p>
|
||||
*
|
||||
* @param uri the Namespace URI, or the empty string if the
|
||||
* element has no Namespace URI or if Namespace
|
||||
* processing is not being performed
|
||||
* @param localName the local name (without prefix), or the
|
||||
* empty string if Namespace processing is not being
|
||||
* performed
|
||||
* @param qName the qualified XML name (with prefix), or the
|
||||
* empty string if qualified names are not available
|
||||
* @throws org.xml.sax.SAXException any SAX exception, possibly
|
||||
* wrapping another exception
|
||||
*/
|
||||
public void endElement (String uri, String localName,
|
||||
String qName)
|
||||
throws SAXException;
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of character data.
|
||||
*
|
||||
* <p>The Parser will call this method to report each chunk of
|
||||
* character data. SAX parsers may return all contiguous character
|
||||
* data in a single chunk, or they may split it into several
|
||||
* chunks; however, all of the characters in any single event
|
||||
* must come from the same external entity so that the Locator
|
||||
* provides useful information.</p>
|
||||
*
|
||||
* <p>The application must not attempt to read from the array
|
||||
* outside of the specified range.</p>
|
||||
*
|
||||
* <p>Individual characters may consist of more than one Java
|
||||
* <code>char</code> value. There are two important cases where this
|
||||
* happens, because characters can't be represented in just sixteen bits.
|
||||
* In one case, characters are represented in a <em>Surrogate Pair</em>,
|
||||
* using two special Unicode values. Such characters are in the so-called
|
||||
* "Astral Planes", with a code point above U+FFFF. A second case involves
|
||||
* composite characters, such as a base character combining with one or
|
||||
* more accent characters. </p>
|
||||
*
|
||||
* <p> Your code should not assume that algorithms using
|
||||
* <code>char</code>-at-a-time idioms will be working in character
|
||||
* units; in some cases they will split characters. This is relevant
|
||||
* wherever XML permits arbitrary characters, such as attribute values,
|
||||
* processing instruction data, and comments as well as in data reported
|
||||
* from this method. It's also generally relevant whenever Java code
|
||||
* manipulates internationalized text; the issue isn't unique to XML.</p>
|
||||
*
|
||||
* <p>Note that some parsers will report whitespace in element
|
||||
* content using the {@link #ignorableWhitespace ignorableWhitespace}
|
||||
* method rather than this one (validating parsers <em>must</em>
|
||||
* do so).</p>
|
||||
*
|
||||
* @param ch the characters from the XML document
|
||||
* @param start the start position in the array
|
||||
* @param length the number of characters to read from the array
|
||||
* @throws org.xml.sax.SAXException any SAX exception, possibly
|
||||
* wrapping another exception
|
||||
* @see #ignorableWhitespace
|
||||
* @see org.xml.sax.Locator
|
||||
*/
|
||||
public void characters (char ch[], int start, int length)
|
||||
throws SAXException;
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of ignorable whitespace in element content.
|
||||
*
|
||||
* <p>Validating Parsers must use this method to report each chunk
|
||||
* of whitespace in element content (see the W3C XML 1.0
|
||||
* recommendation, section 2.10): non-validating parsers may also
|
||||
* use this method if they are capable of parsing and using
|
||||
* content models.</p>
|
||||
*
|
||||
* <p>SAX parsers may return all contiguous whitespace in a single
|
||||
* chunk, or they may split it into several chunks; however, all of
|
||||
* the characters in any single event must come from the same
|
||||
* external entity, so that the Locator provides useful
|
||||
* information.</p>
|
||||
*
|
||||
* <p>The application must not attempt to read from the array
|
||||
* outside of the specified range.</p>
|
||||
*
|
||||
* @param ch the characters from the XML document
|
||||
* @param start the start position in the array
|
||||
* @param length the number of characters to read from the array
|
||||
* @throws org.xml.sax.SAXException any SAX exception, possibly
|
||||
* wrapping another exception
|
||||
* @see #characters
|
||||
*/
|
||||
public void ignorableWhitespace (char ch[], int start, int length)
|
||||
throws SAXException;
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of a processing instruction.
|
||||
*
|
||||
* <p>The Parser will invoke this method once for each processing
|
||||
* instruction found: note that processing instructions may occur
|
||||
* before or after the main document element.</p>
|
||||
*
|
||||
* <p>A SAX parser must never report an XML declaration (XML 1.0,
|
||||
* section 2.8) or a text declaration (XML 1.0, section 4.3.1)
|
||||
* using this method.</p>
|
||||
*
|
||||
* <p>Like {@link #characters characters()}, processing instruction
|
||||
* data may have characters that need more than one <code>char</code>
|
||||
* value. </p>
|
||||
*
|
||||
* @param target the processing instruction target
|
||||
* @param data the processing instruction data, or null if
|
||||
* none was supplied. The data does not include any
|
||||
* whitespace separating it from the target
|
||||
* @throws org.xml.sax.SAXException any SAX exception, possibly
|
||||
* wrapping another exception
|
||||
*/
|
||||
public void processingInstruction (String target, String data)
|
||||
throws SAXException;
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of a skipped entity.
|
||||
* This is not called for entity references within markup constructs
|
||||
* such as element start tags or markup declarations. (The XML
|
||||
* recommendation requires reporting skipped external entities.
|
||||
* SAX also reports internal entity expansion/non-expansion, except
|
||||
* within markup constructs.)
|
||||
*
|
||||
* <p>The Parser will invoke this method each time the entity is
|
||||
* skipped. Non-validating processors may skip entities if they
|
||||
* have not seen the declarations (because, for example, the
|
||||
* entity was declared in an external DTD subset). All processors
|
||||
* may skip external entities, depending on the values of the
|
||||
* <code>http://xml.org/sax/features/external-general-entities</code>
|
||||
* and the
|
||||
* <code>http://xml.org/sax/features/external-parameter-entities</code>
|
||||
* properties.</p>
|
||||
*
|
||||
* @param name the name of the skipped entity. If it is a
|
||||
* parameter entity, the name will begin with '%', and if
|
||||
* it is the external DTD subset, it will be the string
|
||||
* "[dtd]"
|
||||
* @throws org.xml.sax.SAXException any SAX exception, possibly
|
||||
* wrapping another exception
|
||||
*/
|
||||
public void skippedEntity (String name)
|
||||
throws SAXException;
|
||||
}
|
||||
|
||||
// end of ContentHandler.java
|
||||
141
jdkSrc/jdk8/jdk/internal/org/xml/sax/DTDHandler.java
Normal file
141
jdkSrc/jdk8/jdk/internal/org/xml/sax/DTDHandler.java
Normal file
@@ -0,0 +1,141 @@
|
||||
/*
|
||||
* Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
// SAX DTD handler.
|
||||
// http://www.saxproject.org
|
||||
// No warranty; no copyright -- use this as you will.
|
||||
// $Id: DTDHandler.java,v 1.2 2004/11/03 22:44:51 jsuttor Exp $
|
||||
|
||||
package jdk.internal.org.xml.sax;
|
||||
|
||||
/**
|
||||
* Receive notification of basic DTD-related events.
|
||||
*
|
||||
* <blockquote>
|
||||
* <em>This module, both source code and documentation, is in the
|
||||
* Public Domain, and comes with <strong>NO WARRANTY</strong>.</em>
|
||||
* See <a href='http://www.saxproject.org'>http://www.saxproject.org</a>
|
||||
* for further information.
|
||||
* </blockquote>
|
||||
*
|
||||
* <p>If a SAX application needs information about notations and
|
||||
* unparsed entities, then the application implements this
|
||||
* interface and registers an instance with the SAX parser using
|
||||
* the parser's setDTDHandler method. The parser uses the
|
||||
* instance to report notation and unparsed entity declarations to
|
||||
* the application.</p>
|
||||
*
|
||||
* <p>Note that this interface includes only those DTD events that
|
||||
* the XML recommendation <em>requires</em> processors to report:
|
||||
* notation and unparsed entity declarations.</p>
|
||||
*
|
||||
* <p>The SAX parser may report these events in any order, regardless
|
||||
* of the order in which the notations and unparsed entities were
|
||||
* declared; however, all DTD events must be reported after the
|
||||
* document handler's startDocument event, and before the first
|
||||
* startElement event.
|
||||
* (If the {@link org.xml.sax.ext.LexicalHandler LexicalHandler} is
|
||||
* used, these events must also be reported before the endDTD event.)
|
||||
* </p>
|
||||
*
|
||||
* <p>It is up to the application to store the information for
|
||||
* future use (perhaps in a hash table or object tree).
|
||||
* If the application encounters attributes of type "NOTATION",
|
||||
* "ENTITY", or "ENTITIES", it can use the information that it
|
||||
* obtained through this interface to find the entity and/or
|
||||
* notation corresponding with the attribute value.</p>
|
||||
*
|
||||
* @since SAX 1.0
|
||||
* @author David Megginson
|
||||
* @see org.xml.sax.XMLReader#setDTDHandler
|
||||
*/
|
||||
public interface DTDHandler {
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of a notation declaration event.
|
||||
*
|
||||
* <p>It is up to the application to record the notation for later
|
||||
* reference, if necessary;
|
||||
* notations may appear as attribute values and in unparsed entity
|
||||
* declarations, and are sometime used with processing instruction
|
||||
* target names.</p>
|
||||
*
|
||||
* <p>At least one of publicId and systemId must be non-null.
|
||||
* If a system identifier is present, and it is a URL, the SAX
|
||||
* parser must resolve it fully before passing it to the
|
||||
* application through this event.</p>
|
||||
*
|
||||
* <p>There is no guarantee that the notation declaration will be
|
||||
* reported before any unparsed entities that use it.</p>
|
||||
*
|
||||
* @param name The notation name.
|
||||
* @param publicId The notation's public identifier, or null if
|
||||
* none was given.
|
||||
* @param systemId The notation's system identifier, or null if
|
||||
* none was given.
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @see #unparsedEntityDecl
|
||||
* @see org.xml.sax.Attributes
|
||||
*/
|
||||
public abstract void notationDecl (String name,
|
||||
String publicId,
|
||||
String systemId)
|
||||
throws SAXException;
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of an unparsed entity declaration event.
|
||||
*
|
||||
* <p>Note that the notation name corresponds to a notation
|
||||
* reported by the {@link #notationDecl notationDecl} event.
|
||||
* It is up to the application to record the entity for later
|
||||
* reference, if necessary;
|
||||
* unparsed entities may appear as attribute values.
|
||||
* </p>
|
||||
*
|
||||
* <p>If the system identifier is a URL, the parser must resolve it
|
||||
* fully before passing it to the application.</p>
|
||||
*
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @param name The unparsed entity's name.
|
||||
* @param publicId The entity's public identifier, or null if none
|
||||
* was given.
|
||||
* @param systemId The entity's system identifier.
|
||||
* @param notationName The name of the associated notation.
|
||||
* @see #notationDecl
|
||||
* @see org.xml.sax.Attributes
|
||||
*/
|
||||
public abstract void unparsedEntityDecl (String name,
|
||||
String publicId,
|
||||
String systemId,
|
||||
String notationName)
|
||||
throws SAXException;
|
||||
|
||||
}
|
||||
|
||||
// end of DTDHandler.java
|
||||
143
jdkSrc/jdk8/jdk/internal/org/xml/sax/EntityResolver.java
Normal file
143
jdkSrc/jdk8/jdk/internal/org/xml/sax/EntityResolver.java
Normal file
@@ -0,0 +1,143 @@
|
||||
/*
|
||||
* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
// SAX entity resolver.
|
||||
// http://www.saxproject.org
|
||||
// No warranty; no copyright -- use this as you will.
|
||||
// $Id: EntityResolver.java,v 1.2 2004/11/03 22:44:52 jsuttor Exp $
|
||||
|
||||
package jdk.internal.org.xml.sax;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
|
||||
/**
|
||||
* Basic interface for resolving entities.
|
||||
*
|
||||
* <blockquote>
|
||||
* <em>This module, both source code and documentation, is in the
|
||||
* Public Domain, and comes with <strong>NO WARRANTY</strong>.</em>
|
||||
* See <a href='http://www.saxproject.org'>http://www.saxproject.org</a>
|
||||
* for further information.
|
||||
* </blockquote>
|
||||
*
|
||||
* <p>If a SAX application needs to implement customized handling
|
||||
* for external entities, it must implement this interface and
|
||||
* register an instance with the SAX driver using the
|
||||
* {@link org.xml.sax.XMLReader#setEntityResolver setEntityResolver}
|
||||
* method.</p>
|
||||
*
|
||||
* <p>The XML reader will then allow the application to intercept any
|
||||
* external entities (including the external DTD subset and external
|
||||
* parameter entities, if any) before including them.</p>
|
||||
*
|
||||
* <p>Many SAX applications will not need to implement this interface,
|
||||
* but it will be especially useful for applications that build
|
||||
* XML documents from databases or other specialized input sources,
|
||||
* or for applications that use URI types other than URLs.</p>
|
||||
*
|
||||
* <p>The following resolver would provide the application
|
||||
* with a special character stream for the entity with the system
|
||||
* identifier "http://www.myhost.com/today":</p>
|
||||
*
|
||||
* <pre>
|
||||
* import org.xml.sax.EntityResolver;
|
||||
* import org.xml.sax.InputSource;
|
||||
*
|
||||
* public class MyResolver implements EntityResolver {
|
||||
* public InputSource resolveEntity (String publicId, String systemId)
|
||||
* {
|
||||
* if (systemId.equals("http://www.myhost.com/today")) {
|
||||
* // return a special input source
|
||||
* MyReader reader = new MyReader();
|
||||
* return new InputSource(reader);
|
||||
* } else {
|
||||
* // use the default behaviour
|
||||
* return null;
|
||||
* }
|
||||
* }
|
||||
* }
|
||||
* </pre>
|
||||
*
|
||||
* <p>The application can also use this interface to redirect system
|
||||
* identifiers to local URIs or to look up replacements in a catalog
|
||||
* (possibly by using the public identifier).</p>
|
||||
*
|
||||
* @since SAX 1.0
|
||||
* @author David Megginson
|
||||
* @see org.xml.sax.XMLReader#setEntityResolver
|
||||
* @see org.xml.sax.InputSource
|
||||
*/
|
||||
public interface EntityResolver {
|
||||
|
||||
|
||||
/**
|
||||
* Allow the application to resolve external entities.
|
||||
*
|
||||
* <p>The parser will call this method before opening any external
|
||||
* entity except the top-level document entity. Such entities include
|
||||
* the external DTD subset and external parameter entities referenced
|
||||
* within the DTD (in either case, only if the parser reads external
|
||||
* parameter entities), and external general entities referenced
|
||||
* within the document element (if the parser reads external general
|
||||
* entities). The application may request that the parser locate
|
||||
* the entity itself, that it use an alternative URI, or that it
|
||||
* use data provided by the application (as a character or byte
|
||||
* input stream).</p>
|
||||
*
|
||||
* <p>Application writers can use this method to redirect external
|
||||
* system identifiers to secure and/or local URIs, to look up
|
||||
* public identifiers in a catalogue, or to read an entity from a
|
||||
* database or other input source (including, for example, a dialog
|
||||
* box). Neither XML nor SAX specifies a preferred policy for using
|
||||
* public or system IDs to resolve resources. However, SAX specifies
|
||||
* how to interpret any InputSource returned by this method, and that
|
||||
* if none is returned, then the system ID will be dereferenced as
|
||||
* a URL. </p>
|
||||
*
|
||||
* <p>If the system identifier is a URL, the SAX parser must
|
||||
* resolve it fully before reporting it to the application.</p>
|
||||
*
|
||||
* @param publicId The public identifier of the external entity
|
||||
* being referenced, or null if none was supplied.
|
||||
* @param systemId The system identifier of the external entity
|
||||
* being referenced.
|
||||
* @return An InputSource object describing the new input source,
|
||||
* or null to request that the parser open a regular
|
||||
* URI connection to the system identifier.
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @exception java.io.IOException A Java-specific IO exception,
|
||||
* possibly the result of creating a new InputStream
|
||||
* or Reader for the InputSource.
|
||||
* @see org.xml.sax.InputSource
|
||||
*/
|
||||
public abstract InputSource resolveEntity (String publicId,
|
||||
String systemId)
|
||||
throws SAXException, IOException;
|
||||
|
||||
}
|
||||
|
||||
// end of EntityResolver.java
|
||||
163
jdkSrc/jdk8/jdk/internal/org/xml/sax/ErrorHandler.java
Normal file
163
jdkSrc/jdk8/jdk/internal/org/xml/sax/ErrorHandler.java
Normal file
@@ -0,0 +1,163 @@
|
||||
/*
|
||||
* Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
// SAX error handler.
|
||||
// http://www.saxproject.org
|
||||
// No warranty; no copyright -- use this as you will.
|
||||
// $Id: ErrorHandler.java,v 1.2 2004/11/03 22:44:52 jsuttor Exp $
|
||||
|
||||
package jdk.internal.org.xml.sax;
|
||||
|
||||
|
||||
/**
|
||||
* Basic interface for SAX error handlers.
|
||||
*
|
||||
* <blockquote>
|
||||
* <em>This module, both source code and documentation, is in the
|
||||
* Public Domain, and comes with <strong>NO WARRANTY</strong>.</em>
|
||||
* See <a href='http://www.saxproject.org'>http://www.saxproject.org</a>
|
||||
* for further information.
|
||||
* </blockquote>
|
||||
*
|
||||
* <p>If a SAX application needs to implement customized error
|
||||
* handling, it must implement this interface and then register an
|
||||
* instance with the XML reader using the
|
||||
* {@link org.xml.sax.XMLReader#setErrorHandler setErrorHandler}
|
||||
* method. The parser will then report all errors and warnings
|
||||
* through this interface.</p>
|
||||
*
|
||||
* <p><strong>WARNING:</strong> If an application does <em>not</em>
|
||||
* register an ErrorHandler, XML parsing errors will go unreported,
|
||||
* except that <em>SAXParseException</em>s will be thrown for fatal errors.
|
||||
* In order to detect validity errors, an ErrorHandler that does something
|
||||
* with {@link #error error()} calls must be registered.</p>
|
||||
*
|
||||
* <p>For XML processing errors, a SAX driver must use this interface
|
||||
* in preference to throwing an exception: it is up to the application
|
||||
* to decide whether to throw an exception for different types of
|
||||
* errors and warnings. Note, however, that there is no requirement that
|
||||
* the parser continue to report additional errors after a call to
|
||||
* {@link #fatalError fatalError}. In other words, a SAX driver class
|
||||
* may throw an exception after reporting any fatalError.
|
||||
* Also parsers may throw appropriate exceptions for non-XML errors.
|
||||
* For example, {@link XMLReader#parse XMLReader.parse()} would throw
|
||||
* an IOException for errors accessing entities or the document.</p>
|
||||
*
|
||||
* @since SAX 1.0
|
||||
* @author David Megginson
|
||||
* @see org.xml.sax.XMLReader#setErrorHandler
|
||||
* @see org.xml.sax.SAXParseException
|
||||
*/
|
||||
public interface ErrorHandler {
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of a warning.
|
||||
*
|
||||
* <p>SAX parsers will use this method to report conditions that
|
||||
* are not errors or fatal errors as defined by the XML
|
||||
* recommendation. The default behaviour is to take no
|
||||
* action.</p>
|
||||
*
|
||||
* <p>The SAX parser must continue to provide normal parsing events
|
||||
* after invoking this method: it should still be possible for the
|
||||
* application to process the document through to the end.</p>
|
||||
*
|
||||
* <p>Filters may use this method to report other, non-XML warnings
|
||||
* as well.</p>
|
||||
*
|
||||
* @param exception The warning information encapsulated in a
|
||||
* SAX parse exception.
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @see org.xml.sax.SAXParseException
|
||||
*/
|
||||
public abstract void warning (SAXParseException exception)
|
||||
throws SAXException;
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of a recoverable error.
|
||||
*
|
||||
* <p>This corresponds to the definition of "error" in section 1.2
|
||||
* of the W3C XML 1.0 Recommendation. For example, a validating
|
||||
* parser would use this callback to report the violation of a
|
||||
* validity constraint. The default behaviour is to take no
|
||||
* action.</p>
|
||||
*
|
||||
* <p>The SAX parser must continue to provide normal parsing
|
||||
* events after invoking this method: it should still be possible
|
||||
* for the application to process the document through to the end.
|
||||
* If the application cannot do so, then the parser should report
|
||||
* a fatal error even if the XML recommendation does not require
|
||||
* it to do so.</p>
|
||||
*
|
||||
* <p>Filters may use this method to report other, non-XML errors
|
||||
* as well.</p>
|
||||
*
|
||||
* @param exception The error information encapsulated in a
|
||||
* SAX parse exception.
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @see org.xml.sax.SAXParseException
|
||||
*/
|
||||
public abstract void error (SAXParseException exception)
|
||||
throws SAXException;
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of a non-recoverable error.
|
||||
*
|
||||
* <p><strong>There is an apparent contradiction between the
|
||||
* documentation for this method and the documentation for {@link
|
||||
* org.xml.sax.ContentHandler#endDocument}. Until this ambiguity
|
||||
* is resolved in a future major release, clients should make no
|
||||
* assumptions about whether endDocument() will or will not be
|
||||
* invoked when the parser has reported a fatalError() or thrown
|
||||
* an exception.</strong></p>
|
||||
*
|
||||
* <p>This corresponds to the definition of "fatal error" in
|
||||
* section 1.2 of the W3C XML 1.0 Recommendation. For example, a
|
||||
* parser would use this callback to report the violation of a
|
||||
* well-formedness constraint.</p>
|
||||
*
|
||||
* <p>The application must assume that the document is unusable
|
||||
* after the parser has invoked this method, and should continue
|
||||
* (if at all) only for the sake of collecting additional error
|
||||
* messages: in fact, SAX parsers are free to stop reporting any
|
||||
* other events once this method has been invoked.</p>
|
||||
*
|
||||
* @param exception The error information encapsulated in a
|
||||
* SAX parse exception.
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @see org.xml.sax.SAXParseException
|
||||
*/
|
||||
public abstract void fatalError (SAXParseException exception)
|
||||
throws SAXException;
|
||||
|
||||
}
|
||||
|
||||
// end of ErrorHandler.java
|
||||
360
jdkSrc/jdk8/jdk/internal/org/xml/sax/InputSource.java
Normal file
360
jdkSrc/jdk8/jdk/internal/org/xml/sax/InputSource.java
Normal file
@@ -0,0 +1,360 @@
|
||||
/*
|
||||
* Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
// SAX input source.
|
||||
// http://www.saxproject.org
|
||||
// No warranty; no copyright -- use this as you will.
|
||||
// $Id: InputSource.java,v 1.2 2004/11/03 22:55:32 jsuttor Exp $
|
||||
|
||||
package jdk.internal.org.xml.sax;
|
||||
|
||||
import java.io.Reader;
|
||||
import java.io.InputStream;
|
||||
|
||||
/**
|
||||
* A single input source for an XML entity.
|
||||
*
|
||||
* <blockquote>
|
||||
* <em>This module, both source code and documentation, is in the
|
||||
* Public Domain, and comes with <strong>NO WARRANTY</strong>.</em>
|
||||
* See <a href='http://www.saxproject.org'>http://www.saxproject.org</a>
|
||||
* for further information.
|
||||
* </blockquote>
|
||||
*
|
||||
* <p>This class allows a SAX application to encapsulate information
|
||||
* about an input source in a single object, which may include
|
||||
* a public identifier, a system identifier, a byte stream (possibly
|
||||
* with a specified encoding), and/or a character stream.</p>
|
||||
*
|
||||
* <p>There are two places that the application can deliver an
|
||||
* input source to the parser: as the argument to the Parser.parse
|
||||
* method, or as the return value of the EntityResolver.resolveEntity
|
||||
* method.</p>
|
||||
*
|
||||
* <p>The SAX parser will use the InputSource object to determine how
|
||||
* to read XML input. If there is a character stream available, the
|
||||
* parser will read that stream directly, disregarding any text
|
||||
* encoding declaration found in that stream.
|
||||
* If there is no character stream, but there is
|
||||
* a byte stream, the parser will use that byte stream, using the
|
||||
* encoding specified in the InputSource or else (if no encoding is
|
||||
* specified) autodetecting the character encoding using an algorithm
|
||||
* such as the one in the XML specification. If neither a character
|
||||
* stream nor a
|
||||
* byte stream is available, the parser will attempt to open a URI
|
||||
* connection to the resource identified by the system
|
||||
* identifier.</p>
|
||||
*
|
||||
* <p>An InputSource object belongs to the application: the SAX parser
|
||||
* shall never modify it in any way (it may modify a copy if
|
||||
* necessary). However, standard processing of both byte and
|
||||
* character streams is to close them on as part of end-of-parse cleanup,
|
||||
* so applications should not attempt to re-use such streams after they
|
||||
* have been handed to a parser. </p>
|
||||
*
|
||||
* @since SAX 1.0
|
||||
* @author David Megginson
|
||||
* @see org.xml.sax.XMLReader#parse(org.xml.sax.InputSource)
|
||||
* @see org.xml.sax.EntityResolver#resolveEntity
|
||||
* @see java.io.InputStream
|
||||
* @see java.io.Reader
|
||||
*/
|
||||
public class InputSource {
|
||||
|
||||
/**
|
||||
* Zero-argument default constructor.
|
||||
*
|
||||
* @see #setPublicId
|
||||
* @see #setSystemId
|
||||
* @see #setByteStream
|
||||
* @see #setCharacterStream
|
||||
* @see #setEncoding
|
||||
*/
|
||||
public InputSource ()
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Create a new input source with a system identifier.
|
||||
*
|
||||
* <p>Applications may use setPublicId to include a
|
||||
* public identifier as well, or setEncoding to specify
|
||||
* the character encoding, if known.</p>
|
||||
*
|
||||
* <p>If the system identifier is a URL, it must be fully
|
||||
* resolved (it may not be a relative URL).</p>
|
||||
*
|
||||
* @param systemId The system identifier (URI).
|
||||
* @see #setPublicId
|
||||
* @see #setSystemId
|
||||
* @see #setByteStream
|
||||
* @see #setEncoding
|
||||
* @see #setCharacterStream
|
||||
*/
|
||||
public InputSource (String systemId)
|
||||
{
|
||||
setSystemId(systemId);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Create a new input source with a byte stream.
|
||||
*
|
||||
* <p>Application writers should use setSystemId() to provide a base
|
||||
* for resolving relative URIs, may use setPublicId to include a
|
||||
* public identifier, and may use setEncoding to specify the object's
|
||||
* character encoding.</p>
|
||||
*
|
||||
* @param byteStream The raw byte stream containing the document.
|
||||
* @see #setPublicId
|
||||
* @see #setSystemId
|
||||
* @see #setEncoding
|
||||
* @see #setByteStream
|
||||
* @see #setCharacterStream
|
||||
*/
|
||||
public InputSource (InputStream byteStream)
|
||||
{
|
||||
setByteStream(byteStream);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Create a new input source with a character stream.
|
||||
*
|
||||
* <p>Application writers should use setSystemId() to provide a base
|
||||
* for resolving relative URIs, and may use setPublicId to include a
|
||||
* public identifier.</p>
|
||||
*
|
||||
* <p>The character stream shall not include a byte order mark.</p>
|
||||
*
|
||||
* @see #setPublicId
|
||||
* @see #setSystemId
|
||||
* @see #setByteStream
|
||||
* @see #setCharacterStream
|
||||
*/
|
||||
public InputSource (Reader characterStream)
|
||||
{
|
||||
setCharacterStream(characterStream);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Set the public identifier for this input source.
|
||||
*
|
||||
* <p>The public identifier is always optional: if the application
|
||||
* writer includes one, it will be provided as part of the
|
||||
* location information.</p>
|
||||
*
|
||||
* @param publicId The public identifier as a string.
|
||||
* @see #getPublicId
|
||||
* @see org.xml.sax.Locator#getPublicId
|
||||
* @see org.xml.sax.SAXParseException#getPublicId
|
||||
*/
|
||||
public void setPublicId (String publicId)
|
||||
{
|
||||
this.publicId = publicId;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get the public identifier for this input source.
|
||||
*
|
||||
* @return The public identifier, or null if none was supplied.
|
||||
* @see #setPublicId
|
||||
*/
|
||||
public String getPublicId ()
|
||||
{
|
||||
return publicId;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Set the system identifier for this input source.
|
||||
*
|
||||
* <p>The system identifier is optional if there is a byte stream
|
||||
* or a character stream, but it is still useful to provide one,
|
||||
* since the application can use it to resolve relative URIs
|
||||
* and can include it in error messages and warnings (the parser
|
||||
* will attempt to open a connection to the URI only if
|
||||
* there is no byte stream or character stream specified).</p>
|
||||
*
|
||||
* <p>If the application knows the character encoding of the
|
||||
* object pointed to by the system identifier, it can register
|
||||
* the encoding using the setEncoding method.</p>
|
||||
*
|
||||
* <p>If the system identifier is a URL, it must be fully
|
||||
* resolved (it may not be a relative URL).</p>
|
||||
*
|
||||
* @param systemId The system identifier as a string.
|
||||
* @see #setEncoding
|
||||
* @see #getSystemId
|
||||
* @see org.xml.sax.Locator#getSystemId
|
||||
* @see org.xml.sax.SAXParseException#getSystemId
|
||||
*/
|
||||
public void setSystemId (String systemId)
|
||||
{
|
||||
this.systemId = systemId;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get the system identifier for this input source.
|
||||
*
|
||||
* <p>The getEncoding method will return the character encoding
|
||||
* of the object pointed to, or null if unknown.</p>
|
||||
*
|
||||
* <p>If the system ID is a URL, it will be fully resolved.</p>
|
||||
*
|
||||
* @return The system identifier, or null if none was supplied.
|
||||
* @see #setSystemId
|
||||
* @see #getEncoding
|
||||
*/
|
||||
public String getSystemId ()
|
||||
{
|
||||
return systemId;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Set the byte stream for this input source.
|
||||
*
|
||||
* <p>The SAX parser will ignore this if there is also a character
|
||||
* stream specified, but it will use a byte stream in preference
|
||||
* to opening a URI connection itself.</p>
|
||||
*
|
||||
* <p>If the application knows the character encoding of the
|
||||
* byte stream, it should set it with the setEncoding method.</p>
|
||||
*
|
||||
* @param byteStream A byte stream containing an XML document or
|
||||
* other entity.
|
||||
* @see #setEncoding
|
||||
* @see #getByteStream
|
||||
* @see #getEncoding
|
||||
* @see java.io.InputStream
|
||||
*/
|
||||
public void setByteStream (InputStream byteStream)
|
||||
{
|
||||
this.byteStream = byteStream;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get the byte stream for this input source.
|
||||
*
|
||||
* <p>The getEncoding method will return the character
|
||||
* encoding for this byte stream, or null if unknown.</p>
|
||||
*
|
||||
* @return The byte stream, or null if none was supplied.
|
||||
* @see #getEncoding
|
||||
* @see #setByteStream
|
||||
*/
|
||||
public InputStream getByteStream ()
|
||||
{
|
||||
return byteStream;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Set the character encoding, if known.
|
||||
*
|
||||
* <p>The encoding must be a string acceptable for an
|
||||
* XML encoding declaration (see section 4.3.3 of the XML 1.0
|
||||
* recommendation).</p>
|
||||
*
|
||||
* <p>This method has no effect when the application provides a
|
||||
* character stream.</p>
|
||||
*
|
||||
* @param encoding A string describing the character encoding.
|
||||
* @see #setSystemId
|
||||
* @see #setByteStream
|
||||
* @see #getEncoding
|
||||
*/
|
||||
public void setEncoding (String encoding)
|
||||
{
|
||||
this.encoding = encoding;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get the character encoding for a byte stream or URI.
|
||||
* This value will be ignored when the application provides a
|
||||
* character stream.
|
||||
*
|
||||
* @return The encoding, or null if none was supplied.
|
||||
* @see #setByteStream
|
||||
* @see #getSystemId
|
||||
* @see #getByteStream
|
||||
*/
|
||||
public String getEncoding ()
|
||||
{
|
||||
return encoding;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Set the character stream for this input source.
|
||||
*
|
||||
* <p>If there is a character stream specified, the SAX parser
|
||||
* will ignore any byte stream and will not attempt to open
|
||||
* a URI connection to the system identifier.</p>
|
||||
*
|
||||
* @param characterStream The character stream containing the
|
||||
* XML document or other entity.
|
||||
* @see #getCharacterStream
|
||||
* @see java.io.Reader
|
||||
*/
|
||||
public void setCharacterStream (Reader characterStream)
|
||||
{
|
||||
this.characterStream = characterStream;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get the character stream for this input source.
|
||||
*
|
||||
* @return The character stream, or null if none was supplied.
|
||||
* @see #setCharacterStream
|
||||
*/
|
||||
public Reader getCharacterStream ()
|
||||
{
|
||||
return characterStream;
|
||||
}
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Internal state.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
|
||||
private String publicId;
|
||||
private String systemId;
|
||||
private InputStream byteStream;
|
||||
private String encoding;
|
||||
private Reader characterStream;
|
||||
|
||||
}
|
||||
|
||||
// end of InputSource.java
|
||||
160
jdkSrc/jdk8/jdk/internal/org/xml/sax/Locator.java
Normal file
160
jdkSrc/jdk8/jdk/internal/org/xml/sax/Locator.java
Normal file
@@ -0,0 +1,160 @@
|
||||
/*
|
||||
* Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
// SAX locator interface for document events.
|
||||
// http://www.saxproject.org
|
||||
// No warranty; no copyright -- use this as you will.
|
||||
// $Id: Locator.java,v 1.2 2004/11/03 22:55:32 jsuttor Exp $
|
||||
|
||||
package jdk.internal.org.xml.sax;
|
||||
|
||||
|
||||
/**
|
||||
* Interface for associating a SAX event with a document location.
|
||||
*
|
||||
* <blockquote>
|
||||
* <em>This module, both source code and documentation, is in the
|
||||
* Public Domain, and comes with <strong>NO WARRANTY</strong>.</em>
|
||||
* See <a href='http://www.saxproject.org'>http://www.saxproject.org</a>
|
||||
* for further information.
|
||||
* </blockquote>
|
||||
*
|
||||
* <p>If a SAX parser provides location information to the SAX
|
||||
* application, it does so by implementing this interface and then
|
||||
* passing an instance to the application using the content
|
||||
* handler's {@link org.xml.sax.ContentHandler#setDocumentLocator
|
||||
* setDocumentLocator} method. The application can use the
|
||||
* object to obtain the location of any other SAX event
|
||||
* in the XML source document.</p>
|
||||
*
|
||||
* <p>Note that the results returned by the object will be valid only
|
||||
* during the scope of each callback method: the application
|
||||
* will receive unpredictable results if it attempts to use the
|
||||
* locator at any other time, or after parsing completes.</p>
|
||||
*
|
||||
* <p>SAX parsers are not required to supply a locator, but they are
|
||||
* very strongly encouraged to do so. If the parser supplies a
|
||||
* locator, it must do so before reporting any other document events.
|
||||
* If no locator has been set by the time the application receives
|
||||
* the {@link org.xml.sax.ContentHandler#startDocument startDocument}
|
||||
* event, the application should assume that a locator is not
|
||||
* available.</p>
|
||||
*
|
||||
* @since SAX 1.0
|
||||
* @author David Megginson
|
||||
* @see org.xml.sax.ContentHandler#setDocumentLocator
|
||||
*/
|
||||
public interface Locator {
|
||||
|
||||
|
||||
/**
|
||||
* Return the public identifier for the current document event.
|
||||
*
|
||||
* <p>The return value is the public identifier of the document
|
||||
* entity or of the external parsed entity in which the markup
|
||||
* triggering the event appears.</p>
|
||||
*
|
||||
* @return A string containing the public identifier, or
|
||||
* null if none is available.
|
||||
* @see #getSystemId
|
||||
*/
|
||||
public abstract String getPublicId ();
|
||||
|
||||
|
||||
/**
|
||||
* Return the system identifier for the current document event.
|
||||
*
|
||||
* <p>The return value is the system identifier of the document
|
||||
* entity or of the external parsed entity in which the markup
|
||||
* triggering the event appears.</p>
|
||||
*
|
||||
* <p>If the system identifier is a URL, the parser must resolve it
|
||||
* fully before passing it to the application. For example, a file
|
||||
* name must always be provided as a <em>file:...</em> URL, and other
|
||||
* kinds of relative URI are also resolved against their bases.</p>
|
||||
*
|
||||
* @return A string containing the system identifier, or null
|
||||
* if none is available.
|
||||
* @see #getPublicId
|
||||
*/
|
||||
public abstract String getSystemId ();
|
||||
|
||||
|
||||
/**
|
||||
* Return the line number where the current document event ends.
|
||||
* Lines are delimited by line ends, which are defined in
|
||||
* the XML specification.
|
||||
*
|
||||
* <p><strong>Warning:</strong> The return value from the method
|
||||
* is intended only as an approximation for the sake of diagnostics;
|
||||
* it is not intended to provide sufficient information
|
||||
* to edit the character content of the original XML document.
|
||||
* In some cases, these "line" numbers match what would be displayed
|
||||
* as columns, and in others they may not match the source text
|
||||
* due to internal entity expansion. </p>
|
||||
*
|
||||
* <p>The return value is an approximation of the line number
|
||||
* in the document entity or external parsed entity where the
|
||||
* markup triggering the event appears.</p>
|
||||
*
|
||||
* <p>If possible, the SAX driver should provide the line position
|
||||
* of the first character after the text associated with the document
|
||||
* event. The first line is line 1.</p>
|
||||
*
|
||||
* @return The line number, or -1 if none is available.
|
||||
* @see #getColumnNumber
|
||||
*/
|
||||
public abstract int getLineNumber ();
|
||||
|
||||
|
||||
/**
|
||||
* Return the column number where the current document event ends.
|
||||
* This is one-based number of Java <code>char</code> values since
|
||||
* the last line end.
|
||||
*
|
||||
* <p><strong>Warning:</strong> The return value from the method
|
||||
* is intended only as an approximation for the sake of diagnostics;
|
||||
* it is not intended to provide sufficient information
|
||||
* to edit the character content of the original XML document.
|
||||
* For example, when lines contain combining character sequences, wide
|
||||
* characters, surrogate pairs, or bi-directional text, the value may
|
||||
* not correspond to the column in a text editor's display. </p>
|
||||
*
|
||||
* <p>The return value is an approximation of the column number
|
||||
* in the document entity or external parsed entity where the
|
||||
* markup triggering the event appears.</p>
|
||||
*
|
||||
* <p>If possible, the SAX driver should provide the line position
|
||||
* of the first character after the text associated with the document
|
||||
* event. The first column in each line is column 1.</p>
|
||||
*
|
||||
* @return The column number, or -1 if none is available.
|
||||
* @see #getLineNumber
|
||||
*/
|
||||
public abstract int getColumnNumber ();
|
||||
|
||||
}
|
||||
|
||||
// end of Locator.java
|
||||
188
jdkSrc/jdk8/jdk/internal/org/xml/sax/SAXException.java
Normal file
188
jdkSrc/jdk8/jdk/internal/org/xml/sax/SAXException.java
Normal file
@@ -0,0 +1,188 @@
|
||||
/*
|
||||
* Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
// SAX exception class.
|
||||
// http://www.saxproject.org
|
||||
// No warranty; no copyright -- use this as you will.
|
||||
// $Id: SAXException.java,v 1.3 2004/11/03 22:55:32 jsuttor Exp $
|
||||
|
||||
package jdk.internal.org.xml.sax;
|
||||
|
||||
/**
|
||||
* Encapsulate a general SAX error or warning.
|
||||
*
|
||||
* <blockquote>
|
||||
* <em>This module, both source code and documentation, is in the
|
||||
* Public Domain, and comes with <strong>NO WARRANTY</strong>.</em>
|
||||
* See <a href='http://www.saxproject.org'>http://www.saxproject.org</a>
|
||||
* for further information.
|
||||
* </blockquote>
|
||||
*
|
||||
* <p>This class can contain basic error or warning information from
|
||||
* either the XML parser or the application: a parser writer or
|
||||
* application writer can subclass it to provide additional
|
||||
* functionality. SAX handlers may throw this exception or
|
||||
* any exception subclassed from it.</p>
|
||||
*
|
||||
* <p>If the application needs to pass through other types of
|
||||
* exceptions, it must wrap those exceptions in a SAXException
|
||||
* or an exception derived from a SAXException.</p>
|
||||
*
|
||||
* <p>If the parser or application needs to include information about a
|
||||
* specific location in an XML document, it should use the
|
||||
* {@link org.xml.sax.SAXParseException SAXParseException} subclass.</p>
|
||||
*
|
||||
* @since SAX 1.0
|
||||
* @author David Megginson
|
||||
* @version 2.0.1 (sax2r2)
|
||||
* @see org.xml.sax.SAXParseException
|
||||
*/
|
||||
public class SAXException extends Exception {
|
||||
|
||||
|
||||
/**
|
||||
* Create a new SAXException.
|
||||
*/
|
||||
public SAXException ()
|
||||
{
|
||||
super();
|
||||
this.exception = null;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Create a new SAXException.
|
||||
*
|
||||
* @param message The error or warning message.
|
||||
*/
|
||||
public SAXException (String message) {
|
||||
super(message);
|
||||
this.exception = null;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Create a new SAXException wrapping an existing exception.
|
||||
*
|
||||
* <p>The existing exception will be embedded in the new
|
||||
* one, and its message will become the default message for
|
||||
* the SAXException.</p>
|
||||
*
|
||||
* @param e The exception to be wrapped in a SAXException.
|
||||
*/
|
||||
public SAXException (Exception e)
|
||||
{
|
||||
super();
|
||||
this.exception = e;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Create a new SAXException from an existing exception.
|
||||
*
|
||||
* <p>The existing exception will be embedded in the new
|
||||
* one, but the new exception will have its own message.</p>
|
||||
*
|
||||
* @param message The detail message.
|
||||
* @param e The exception to be wrapped in a SAXException.
|
||||
*/
|
||||
public SAXException (String message, Exception e)
|
||||
{
|
||||
super(message);
|
||||
this.exception = e;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Return a detail message for this exception.
|
||||
*
|
||||
* <p>If there is an embedded exception, and if the SAXException
|
||||
* has no detail message of its own, this method will return
|
||||
* the detail message from the embedded exception.</p>
|
||||
*
|
||||
* @return The error or warning message.
|
||||
*/
|
||||
public String getMessage ()
|
||||
{
|
||||
String message = super.getMessage();
|
||||
|
||||
if (message == null && exception != null) {
|
||||
return exception.getMessage();
|
||||
} else {
|
||||
return message;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Return the embedded exception, if any.
|
||||
*
|
||||
* @return The embedded exception, or null if there is none.
|
||||
*/
|
||||
public Exception getException ()
|
||||
{
|
||||
return exception;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the cause of the exception
|
||||
*
|
||||
* @return Return the cause of the exception
|
||||
*/
|
||||
public Throwable getCause() {
|
||||
return exception;
|
||||
}
|
||||
|
||||
/**
|
||||
* Override toString to pick up any embedded exception.
|
||||
*
|
||||
* @return A string representation of this exception.
|
||||
*/
|
||||
public String toString ()
|
||||
{
|
||||
if (exception != null) {
|
||||
return super.toString() + "\n" + exception.toString();
|
||||
} else {
|
||||
return super.toString();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// Internal state.
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* @serial The embedded exception if tunnelling, or null.
|
||||
*/
|
||||
private Exception exception;
|
||||
|
||||
// Added serialVersionUID to preserve binary compatibility
|
||||
static final long serialVersionUID = 583241635256073760L;
|
||||
}
|
||||
|
||||
// end of SAXException.java
|
||||
@@ -0,0 +1,79 @@
|
||||
/*
|
||||
* Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
// SAXNotRecognizedException.java - unrecognized feature or value.
|
||||
// http://www.saxproject.org
|
||||
// Written by David Megginson
|
||||
// NO WARRANTY! This class is in the Public Domain.
|
||||
// $Id: SAXNotRecognizedException.java,v 1.3 2004/11/03 22:55:32 jsuttor Exp $
|
||||
|
||||
package jdk.internal.org.xml.sax;
|
||||
|
||||
|
||||
/**
|
||||
* Exception class for an unrecognized identifier.
|
||||
*
|
||||
* <blockquote>
|
||||
* <em>This module, both source code and documentation, is in the
|
||||
* Public Domain, and comes with <strong>NO WARRANTY</strong>.</em>
|
||||
* See <a href='http://www.saxproject.org'>http://www.saxproject.org</a>
|
||||
* for further information.
|
||||
* </blockquote>
|
||||
*
|
||||
* <p>An XMLReader will throw this exception when it finds an
|
||||
* unrecognized feature or property identifier; SAX applications and
|
||||
* extensions may use this class for other, similar purposes.</p>
|
||||
*
|
||||
* @since SAX 2.0
|
||||
* @author David Megginson
|
||||
* @see org.xml.sax.SAXNotSupportedException
|
||||
*/
|
||||
public class SAXNotRecognizedException extends SAXException
|
||||
{
|
||||
|
||||
/**
|
||||
* Default constructor.
|
||||
*/
|
||||
public SAXNotRecognizedException ()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Construct a new exception with the given message.
|
||||
*
|
||||
* @param message The text message of the exception.
|
||||
*/
|
||||
public SAXNotRecognizedException (String message)
|
||||
{
|
||||
super(message);
|
||||
}
|
||||
|
||||
// Added serialVersionUID to preserve binary compatibility
|
||||
static final long serialVersionUID = 5440506620509557213L;
|
||||
}
|
||||
|
||||
// end of SAXNotRecognizedException.java
|
||||
@@ -0,0 +1,79 @@
|
||||
/*
|
||||
* Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
// SAXNotSupportedException.java - unsupported feature or value.
|
||||
// http://www.saxproject.org
|
||||
// Written by David Megginson
|
||||
// NO WARRANTY! This class is in the Public Domain.
|
||||
// $Id: SAXNotSupportedException.java,v 1.4 2004/11/03 22:55:32 jsuttor Exp $
|
||||
|
||||
package jdk.internal.org.xml.sax;
|
||||
|
||||
/**
|
||||
* Exception class for an unsupported operation.
|
||||
*
|
||||
* <blockquote>
|
||||
* <em>This module, both source code and documentation, is in the
|
||||
* Public Domain, and comes with <strong>NO WARRANTY</strong>.</em>
|
||||
* See <a href='http://www.saxproject.org'>http://www.saxproject.org</a>
|
||||
* for further information.
|
||||
* </blockquote>
|
||||
*
|
||||
* <p>An XMLReader will throw this exception when it recognizes a
|
||||
* feature or property identifier, but cannot perform the requested
|
||||
* operation (setting a state or value). Other SAX2 applications and
|
||||
* extensions may use this class for similar purposes.</p>
|
||||
*
|
||||
* @since SAX 2.0
|
||||
* @author David Megginson
|
||||
* @see org.xml.sax.SAXNotRecognizedException
|
||||
*/
|
||||
public class SAXNotSupportedException extends SAXException
|
||||
{
|
||||
|
||||
/**
|
||||
* Construct a new exception with no message.
|
||||
*/
|
||||
public SAXNotSupportedException ()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Construct a new exception with the given message.
|
||||
*
|
||||
* @param message The text message of the exception.
|
||||
*/
|
||||
public SAXNotSupportedException (String message)
|
||||
{
|
||||
super(message);
|
||||
}
|
||||
|
||||
// Added serialVersionUID to preserve binary compatibility
|
||||
static final long serialVersionUID = -1422818934641823846L;
|
||||
}
|
||||
|
||||
// end of SAXNotSupportedException.java
|
||||
313
jdkSrc/jdk8/jdk/internal/org/xml/sax/SAXParseException.java
Normal file
313
jdkSrc/jdk8/jdk/internal/org/xml/sax/SAXParseException.java
Normal file
@@ -0,0 +1,313 @@
|
||||
/*
|
||||
* Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
// SAX exception class.
|
||||
// http://www.saxproject.org
|
||||
// No warranty; no copyright -- use this as you will.
|
||||
// $Id: SAXParseException.java,v 1.2 2004/11/03 22:55:32 jsuttor Exp $
|
||||
|
||||
package jdk.internal.org.xml.sax;
|
||||
|
||||
/**
|
||||
* Encapsulate an XML parse error or warning.
|
||||
*
|
||||
* <blockquote>
|
||||
* <em>This module, both source code and documentation, is in the
|
||||
* Public Domain, and comes with <strong>NO WARRANTY</strong>.</em>
|
||||
* See <a href='http://www.saxproject.org'>http://www.saxproject.org</a>
|
||||
* for further information.
|
||||
* </blockquote>
|
||||
*
|
||||
* <p>This exception may include information for locating the error
|
||||
* in the original XML document, as if it came from a {@link Locator}
|
||||
* object. Note that although the application
|
||||
* will receive a SAXParseException as the argument to the handlers
|
||||
* in the {@link org.xml.sax.ErrorHandler ErrorHandler} interface,
|
||||
* the application is not actually required to throw the exception;
|
||||
* instead, it can simply read the information in it and take a
|
||||
* different action.</p>
|
||||
*
|
||||
* <p>Since this exception is a subclass of {@link org.xml.sax.SAXException
|
||||
* SAXException}, it inherits the ability to wrap another exception.</p>
|
||||
*
|
||||
* @since SAX 1.0
|
||||
* @author David Megginson
|
||||
* @version 2.0.1 (sax2r2)
|
||||
* @see org.xml.sax.SAXException
|
||||
* @see org.xml.sax.Locator
|
||||
* @see org.xml.sax.ErrorHandler
|
||||
*/
|
||||
public class SAXParseException extends SAXException {
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// Constructors.
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* Create a new SAXParseException from a message and a Locator.
|
||||
*
|
||||
* <p>This constructor is especially useful when an application is
|
||||
* creating its own exception from within a {@link org.xml.sax.ContentHandler
|
||||
* ContentHandler} callback.</p>
|
||||
*
|
||||
* @param message The error or warning message.
|
||||
* @param locator The locator object for the error or warning (may be
|
||||
* null).
|
||||
* @see org.xml.sax.Locator
|
||||
*/
|
||||
public SAXParseException (String message, Locator locator) {
|
||||
super(message);
|
||||
if (locator != null) {
|
||||
init(locator.getPublicId(), locator.getSystemId(),
|
||||
locator.getLineNumber(), locator.getColumnNumber());
|
||||
} else {
|
||||
init(null, null, -1, -1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Wrap an existing exception in a SAXParseException.
|
||||
*
|
||||
* <p>This constructor is especially useful when an application is
|
||||
* creating its own exception from within a {@link org.xml.sax.ContentHandler
|
||||
* ContentHandler} callback, and needs to wrap an existing exception that is not a
|
||||
* subclass of {@link org.xml.sax.SAXException SAXException}.</p>
|
||||
*
|
||||
* @param message The error or warning message, or null to
|
||||
* use the message from the embedded exception.
|
||||
* @param locator The locator object for the error or warning (may be
|
||||
* null).
|
||||
* @param e Any exception.
|
||||
* @see org.xml.sax.Locator
|
||||
*/
|
||||
public SAXParseException (String message, Locator locator,
|
||||
Exception e) {
|
||||
super(message, e);
|
||||
if (locator != null) {
|
||||
init(locator.getPublicId(), locator.getSystemId(),
|
||||
locator.getLineNumber(), locator.getColumnNumber());
|
||||
} else {
|
||||
init(null, null, -1, -1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Create a new SAXParseException.
|
||||
*
|
||||
* <p>This constructor is most useful for parser writers.</p>
|
||||
*
|
||||
* <p>All parameters except the message are as if
|
||||
* they were provided by a {@link Locator}. For example, if the
|
||||
* system identifier is a URL (including relative filename), the
|
||||
* caller must resolve it fully before creating the exception.</p>
|
||||
*
|
||||
*
|
||||
* @param message The error or warning message.
|
||||
* @param publicId The public identifier of the entity that generated
|
||||
* the error or warning.
|
||||
* @param systemId The system identifier of the entity that generated
|
||||
* the error or warning.
|
||||
* @param lineNumber The line number of the end of the text that
|
||||
* caused the error or warning.
|
||||
* @param columnNumber The column number of the end of the text that
|
||||
* cause the error or warning.
|
||||
*/
|
||||
public SAXParseException (String message, String publicId, String systemId,
|
||||
int lineNumber, int columnNumber)
|
||||
{
|
||||
super(message);
|
||||
init(publicId, systemId, lineNumber, columnNumber);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Create a new SAXParseException with an embedded exception.
|
||||
*
|
||||
* <p>This constructor is most useful for parser writers who
|
||||
* need to wrap an exception that is not a subclass of
|
||||
* {@link org.xml.sax.SAXException SAXException}.</p>
|
||||
*
|
||||
* <p>All parameters except the message and exception are as if
|
||||
* they were provided by a {@link Locator}. For example, if the
|
||||
* system identifier is a URL (including relative filename), the
|
||||
* caller must resolve it fully before creating the exception.</p>
|
||||
*
|
||||
* @param message The error or warning message, or null to use
|
||||
* the message from the embedded exception.
|
||||
* @param publicId The public identifier of the entity that generated
|
||||
* the error or warning.
|
||||
* @param systemId The system identifier of the entity that generated
|
||||
* the error or warning.
|
||||
* @param lineNumber The line number of the end of the text that
|
||||
* caused the error or warning.
|
||||
* @param columnNumber The column number of the end of the text that
|
||||
* cause the error or warning.
|
||||
* @param e Another exception to embed in this one.
|
||||
*/
|
||||
public SAXParseException (String message, String publicId, String systemId,
|
||||
int lineNumber, int columnNumber, Exception e)
|
||||
{
|
||||
super(message, e);
|
||||
init(publicId, systemId, lineNumber, columnNumber);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Internal initialization method.
|
||||
*
|
||||
* @param publicId The public identifier of the entity which generated the exception,
|
||||
* or null.
|
||||
* @param systemId The system identifier of the entity which generated the exception,
|
||||
* or null.
|
||||
* @param lineNumber The line number of the error, or -1.
|
||||
* @param columnNumber The column number of the error, or -1.
|
||||
*/
|
||||
private void init (String publicId, String systemId,
|
||||
int lineNumber, int columnNumber)
|
||||
{
|
||||
this.publicId = publicId;
|
||||
this.systemId = systemId;
|
||||
this.lineNumber = lineNumber;
|
||||
this.columnNumber = columnNumber;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get the public identifier of the entity where the exception occurred.
|
||||
*
|
||||
* @return A string containing the public identifier, or null
|
||||
* if none is available.
|
||||
* @see org.xml.sax.Locator#getPublicId
|
||||
*/
|
||||
public String getPublicId ()
|
||||
{
|
||||
return this.publicId;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get the system identifier of the entity where the exception occurred.
|
||||
*
|
||||
* <p>If the system identifier is a URL, it will have been resolved
|
||||
* fully.</p>
|
||||
*
|
||||
* @return A string containing the system identifier, or null
|
||||
* if none is available.
|
||||
* @see org.xml.sax.Locator#getSystemId
|
||||
*/
|
||||
public String getSystemId ()
|
||||
{
|
||||
return this.systemId;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* The line number of the end of the text where the exception occurred.
|
||||
*
|
||||
* <p>The first line is line 1.</p>
|
||||
*
|
||||
* @return An integer representing the line number, or -1
|
||||
* if none is available.
|
||||
* @see org.xml.sax.Locator#getLineNumber
|
||||
*/
|
||||
public int getLineNumber ()
|
||||
{
|
||||
return this.lineNumber;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* The column number of the end of the text where the exception occurred.
|
||||
*
|
||||
* <p>The first column in a line is position 1.</p>
|
||||
*
|
||||
* @return An integer representing the column number, or -1
|
||||
* if none is available.
|
||||
* @see org.xml.sax.Locator#getColumnNumber
|
||||
*/
|
||||
public int getColumnNumber ()
|
||||
{
|
||||
return this.columnNumber;
|
||||
}
|
||||
|
||||
/**
|
||||
* Override toString to provide more detailed error message.
|
||||
*
|
||||
* @return A string representation of this exception.
|
||||
*/
|
||||
public String toString() {
|
||||
StringBuilder buf = new StringBuilder(getClass().getName());
|
||||
String message = getLocalizedMessage();
|
||||
if (publicId!=null) buf.append("publicId: ").append(publicId);
|
||||
if (systemId!=null) buf.append("; systemId: ").append(systemId);
|
||||
if (lineNumber!=-1) buf.append("; lineNumber: ").append(lineNumber);
|
||||
if (columnNumber!=-1) buf.append("; columnNumber: ").append(columnNumber);
|
||||
|
||||
//append the exception message at the end
|
||||
if (message!=null) buf.append("; ").append(message);
|
||||
return buf.toString();
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// Internal state.
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* @serial The public identifier, or null.
|
||||
* @see #getPublicId
|
||||
*/
|
||||
private String publicId;
|
||||
|
||||
|
||||
/**
|
||||
* @serial The system identifier, or null.
|
||||
* @see #getSystemId
|
||||
*/
|
||||
private String systemId;
|
||||
|
||||
|
||||
/**
|
||||
* @serial The line number, or -1.
|
||||
* @see #getLineNumber
|
||||
*/
|
||||
private int lineNumber;
|
||||
|
||||
|
||||
/**
|
||||
* @serial The column number, or -1.
|
||||
* @see #getColumnNumber
|
||||
*/
|
||||
private int columnNumber;
|
||||
|
||||
// Added serialVersionUID to preserve binary compatibility
|
||||
static final long serialVersionUID = -5651165872476709336L;
|
||||
}
|
||||
|
||||
// end of SAXParseException.java
|
||||
428
jdkSrc/jdk8/jdk/internal/org/xml/sax/XMLReader.java
Normal file
428
jdkSrc/jdk8/jdk/internal/org/xml/sax/XMLReader.java
Normal file
@@ -0,0 +1,428 @@
|
||||
/*
|
||||
* Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
// XMLReader.java - read an XML document.
|
||||
// http://www.saxproject.org
|
||||
// Written by David Megginson
|
||||
// NO WARRANTY! This class is in the Public Domain.
|
||||
// $Id: XMLReader.java,v 1.3 2004/11/03 22:55:32 jsuttor Exp $
|
||||
|
||||
package jdk.internal.org.xml.sax;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
|
||||
/**
|
||||
* Interface for reading an XML document using callbacks.
|
||||
*
|
||||
* <blockquote>
|
||||
* <em>This module, both source code and documentation, is in the
|
||||
* Public Domain, and comes with <strong>NO WARRANTY</strong>.</em>
|
||||
* See <a href='http://www.saxproject.org'>http://www.saxproject.org</a>
|
||||
* for further information.
|
||||
* </blockquote>
|
||||
*
|
||||
* <p><strong>Note:</strong> despite its name, this interface does
|
||||
* <em>not</em> extend the standard Java {@link java.io.Reader Reader}
|
||||
* interface, because reading XML is a fundamentally different activity
|
||||
* than reading character data.</p>
|
||||
*
|
||||
* <p>XMLReader is the interface that an XML parser's SAX2 driver must
|
||||
* implement. This interface allows an application to set and
|
||||
* query features and properties in the parser, to register
|
||||
* event handlers for document processing, and to initiate
|
||||
* a document parse.</p>
|
||||
*
|
||||
* <p>All SAX interfaces are assumed to be synchronous: the
|
||||
* {@link #parse parse} methods must not return until parsing
|
||||
* is complete, and readers must wait for an event-handler callback
|
||||
* to return before reporting the next event.</p>
|
||||
*
|
||||
* <p>This interface replaces the (now deprecated) SAX 1.0 {@link
|
||||
* org.xml.sax.Parser Parser} interface. The XMLReader interface
|
||||
* contains two important enhancements over the old Parser
|
||||
* interface (as well as some minor ones):</p>
|
||||
*
|
||||
* <ol>
|
||||
* <li>it adds a standard way to query and set features and
|
||||
* properties; and</li>
|
||||
* <li>it adds Namespace support, which is required for many
|
||||
* higher-level XML standards.</li>
|
||||
* </ol>
|
||||
*
|
||||
* <p>There are adapters available to convert a SAX1 Parser to
|
||||
* a SAX2 XMLReader and vice-versa.</p>
|
||||
*
|
||||
* @since SAX 2.0
|
||||
* @author David Megginson
|
||||
* @see org.xml.sax.XMLFilter
|
||||
* @see org.xml.sax.helpers.ParserAdapter
|
||||
* @see org.xml.sax.helpers.XMLReaderAdapter
|
||||
*/
|
||||
public interface XMLReader
|
||||
{
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Configuration.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* Look up the value of a feature flag.
|
||||
*
|
||||
* <p>The feature name is any fully-qualified URI. It is
|
||||
* possible for an XMLReader to recognize a feature name but
|
||||
* temporarily be unable to return its value.
|
||||
* Some feature values may be available only in specific
|
||||
* contexts, such as before, during, or after a parse.
|
||||
* Also, some feature values may not be programmatically accessible.
|
||||
* (In the case of an adapter for SAX1 {@link Parser}, there is no
|
||||
* implementation-independent way to expose whether the underlying
|
||||
* parser is performing validation, expanding external entities,
|
||||
* and so forth.) </p>
|
||||
*
|
||||
* <p>All XMLReaders are required to recognize the
|
||||
* http://xml.org/sax/features/namespaces and the
|
||||
* http://xml.org/sax/features/namespace-prefixes feature names.</p>
|
||||
*
|
||||
* <p>Typical usage is something like this:</p>
|
||||
*
|
||||
* <pre>
|
||||
* XMLReader r = new MySAXDriver();
|
||||
*
|
||||
* // try to activate validation
|
||||
* try {
|
||||
* r.setFeature("http://xml.org/sax/features/validation", true);
|
||||
* } catch (SAXException e) {
|
||||
* System.err.println("Cannot activate validation.");
|
||||
* }
|
||||
*
|
||||
* // register event handlers
|
||||
* r.setContentHandler(new MyContentHandler());
|
||||
* r.setErrorHandler(new MyErrorHandler());
|
||||
*
|
||||
* // parse the first document
|
||||
* try {
|
||||
* r.parse("http://www.foo.com/mydoc.xml");
|
||||
* } catch (IOException e) {
|
||||
* System.err.println("I/O exception reading XML document");
|
||||
* } catch (SAXException e) {
|
||||
* System.err.println("XML exception reading document.");
|
||||
* }
|
||||
* </pre>
|
||||
*
|
||||
* <p>Implementors are free (and encouraged) to invent their own features,
|
||||
* using names built on their own URIs.</p>
|
||||
*
|
||||
* @param name The feature name, which is a fully-qualified URI.
|
||||
* @return The current value of the feature (true or false).
|
||||
* @exception org.xml.sax.SAXNotRecognizedException If the feature
|
||||
* value can't be assigned or retrieved.
|
||||
* @exception org.xml.sax.SAXNotSupportedException When the
|
||||
* XMLReader recognizes the feature name but
|
||||
* cannot determine its value at this time.
|
||||
* @see #setFeature
|
||||
*/
|
||||
public boolean getFeature (String name)
|
||||
throws SAXNotRecognizedException, SAXNotSupportedException;
|
||||
|
||||
|
||||
/**
|
||||
* Set the value of a feature flag.
|
||||
*
|
||||
* <p>The feature name is any fully-qualified URI. It is
|
||||
* possible for an XMLReader to expose a feature value but
|
||||
* to be unable to change the current value.
|
||||
* Some feature values may be immutable or mutable only
|
||||
* in specific contexts, such as before, during, or after
|
||||
* a parse.</p>
|
||||
*
|
||||
* <p>All XMLReaders are required to support setting
|
||||
* http://xml.org/sax/features/namespaces to true and
|
||||
* http://xml.org/sax/features/namespace-prefixes to false.</p>
|
||||
*
|
||||
* @param name The feature name, which is a fully-qualified URI.
|
||||
* @param value The requested value of the feature (true or false).
|
||||
* @exception org.xml.sax.SAXNotRecognizedException If the feature
|
||||
* value can't be assigned or retrieved.
|
||||
* @exception org.xml.sax.SAXNotSupportedException When the
|
||||
* XMLReader recognizes the feature name but
|
||||
* cannot set the requested value.
|
||||
* @see #getFeature
|
||||
*/
|
||||
public void setFeature (String name, boolean value)
|
||||
throws SAXNotRecognizedException, SAXNotSupportedException;
|
||||
|
||||
|
||||
/**
|
||||
* Look up the value of a property.
|
||||
*
|
||||
* <p>The property name is any fully-qualified URI. It is
|
||||
* possible for an XMLReader to recognize a property name but
|
||||
* temporarily be unable to return its value.
|
||||
* Some property values may be available only in specific
|
||||
* contexts, such as before, during, or after a parse.</p>
|
||||
*
|
||||
* <p>XMLReaders are not required to recognize any specific
|
||||
* property names, though an initial core set is documented for
|
||||
* SAX2.</p>
|
||||
*
|
||||
* <p>Implementors are free (and encouraged) to invent their own properties,
|
||||
* using names built on their own URIs.</p>
|
||||
*
|
||||
* @param name The property name, which is a fully-qualified URI.
|
||||
* @return The current value of the property.
|
||||
* @exception org.xml.sax.SAXNotRecognizedException If the property
|
||||
* value can't be assigned or retrieved.
|
||||
* @exception org.xml.sax.SAXNotSupportedException When the
|
||||
* XMLReader recognizes the property name but
|
||||
* cannot determine its value at this time.
|
||||
* @see #setProperty
|
||||
*/
|
||||
public Object getProperty (String name)
|
||||
throws SAXNotRecognizedException, SAXNotSupportedException;
|
||||
|
||||
|
||||
/**
|
||||
* Set the value of a property.
|
||||
*
|
||||
* <p>The property name is any fully-qualified URI. It is
|
||||
* possible for an XMLReader to recognize a property name but
|
||||
* to be unable to change the current value.
|
||||
* Some property values may be immutable or mutable only
|
||||
* in specific contexts, such as before, during, or after
|
||||
* a parse.</p>
|
||||
*
|
||||
* <p>XMLReaders are not required to recognize setting
|
||||
* any specific property names, though a core set is defined by
|
||||
* SAX2.</p>
|
||||
*
|
||||
* <p>This method is also the standard mechanism for setting
|
||||
* extended handlers.</p>
|
||||
*
|
||||
* @param name The property name, which is a fully-qualified URI.
|
||||
* @param value The requested value for the property.
|
||||
* @exception org.xml.sax.SAXNotRecognizedException If the property
|
||||
* value can't be assigned or retrieved.
|
||||
* @exception org.xml.sax.SAXNotSupportedException When the
|
||||
* XMLReader recognizes the property name but
|
||||
* cannot set the requested value.
|
||||
*/
|
||||
public void setProperty (String name, Object value)
|
||||
throws SAXNotRecognizedException, SAXNotSupportedException;
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Event handlers.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* Allow an application to register an entity resolver.
|
||||
*
|
||||
* <p>If the application does not register an entity resolver,
|
||||
* the XMLReader will perform its own default resolution.</p>
|
||||
*
|
||||
* <p>Applications may register a new or different resolver in the
|
||||
* middle of a parse, and the SAX parser must begin using the new
|
||||
* resolver immediately.</p>
|
||||
*
|
||||
* @param resolver The entity resolver.
|
||||
* @see #getEntityResolver
|
||||
*/
|
||||
public void setEntityResolver (EntityResolver resolver);
|
||||
|
||||
|
||||
/**
|
||||
* Return the current entity resolver.
|
||||
*
|
||||
* @return The current entity resolver, or null if none
|
||||
* has been registered.
|
||||
* @see #setEntityResolver
|
||||
*/
|
||||
public EntityResolver getEntityResolver ();
|
||||
|
||||
|
||||
/**
|
||||
* Allow an application to register a DTD event handler.
|
||||
*
|
||||
* <p>If the application does not register a DTD handler, all DTD
|
||||
* events reported by the SAX parser will be silently ignored.</p>
|
||||
*
|
||||
* <p>Applications may register a new or different handler in the
|
||||
* middle of a parse, and the SAX parser must begin using the new
|
||||
* handler immediately.</p>
|
||||
*
|
||||
* @param handler The DTD handler.
|
||||
* @see #getDTDHandler
|
||||
*/
|
||||
public void setDTDHandler (DTDHandler handler);
|
||||
|
||||
|
||||
/**
|
||||
* Return the current DTD handler.
|
||||
*
|
||||
* @return The current DTD handler, or null if none
|
||||
* has been registered.
|
||||
* @see #setDTDHandler
|
||||
*/
|
||||
public DTDHandler getDTDHandler ();
|
||||
|
||||
|
||||
/**
|
||||
* Allow an application to register a content event handler.
|
||||
*
|
||||
* <p>If the application does not register a content handler, all
|
||||
* content events reported by the SAX parser will be silently
|
||||
* ignored.</p>
|
||||
*
|
||||
* <p>Applications may register a new or different handler in the
|
||||
* middle of a parse, and the SAX parser must begin using the new
|
||||
* handler immediately.</p>
|
||||
*
|
||||
* @param handler The content handler.
|
||||
* @see #getContentHandler
|
||||
*/
|
||||
public void setContentHandler (ContentHandler handler);
|
||||
|
||||
|
||||
/**
|
||||
* Return the current content handler.
|
||||
*
|
||||
* @return The current content handler, or null if none
|
||||
* has been registered.
|
||||
* @see #setContentHandler
|
||||
*/
|
||||
public ContentHandler getContentHandler ();
|
||||
|
||||
|
||||
/**
|
||||
* Allow an application to register an error event handler.
|
||||
*
|
||||
* <p>If the application does not register an error handler, all
|
||||
* error events reported by the SAX parser will be silently
|
||||
* ignored; however, normal processing may not continue. It is
|
||||
* highly recommended that all SAX applications implement an
|
||||
* error handler to avoid unexpected bugs.</p>
|
||||
*
|
||||
* <p>Applications may register a new or different handler in the
|
||||
* middle of a parse, and the SAX parser must begin using the new
|
||||
* handler immediately.</p>
|
||||
*
|
||||
* @param handler The error handler.
|
||||
* @see #getErrorHandler
|
||||
*/
|
||||
public void setErrorHandler (ErrorHandler handler);
|
||||
|
||||
|
||||
/**
|
||||
* Return the current error handler.
|
||||
*
|
||||
* @return The current error handler, or null if none
|
||||
* has been registered.
|
||||
* @see #setErrorHandler
|
||||
*/
|
||||
public ErrorHandler getErrorHandler ();
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Parsing.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
|
||||
/**
|
||||
* Parse an XML document.
|
||||
*
|
||||
* <p>The application can use this method to instruct the XML
|
||||
* reader to begin parsing an XML document from any valid input
|
||||
* source (a character stream, a byte stream, or a URI).</p>
|
||||
*
|
||||
* <p>Applications may not invoke this method while a parse is in
|
||||
* progress (they should create a new XMLReader instead for each
|
||||
* nested XML document). Once a parse is complete, an
|
||||
* application may reuse the same XMLReader object, possibly with a
|
||||
* different input source.
|
||||
* Configuration of the XMLReader object (such as handler bindings and
|
||||
* values established for feature flags and properties) is unchanged
|
||||
* by completion of a parse, unless the definition of that aspect of
|
||||
* the configuration explicitly specifies other behavior.
|
||||
* (For example, feature flags or properties exposing
|
||||
* characteristics of the document being parsed.)
|
||||
* </p>
|
||||
*
|
||||
* <p>During the parse, the XMLReader will provide information
|
||||
* about the XML document through the registered event
|
||||
* handlers.</p>
|
||||
*
|
||||
* <p>This method is synchronous: it will not return until parsing
|
||||
* has ended. If a client application wants to terminate
|
||||
* parsing early, it should throw an exception.</p>
|
||||
*
|
||||
* @param input The input source for the top-level of the
|
||||
* XML document.
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @exception java.io.IOException An IO exception from the parser,
|
||||
* possibly from a byte stream or character stream
|
||||
* supplied by the application.
|
||||
* @see org.xml.sax.InputSource
|
||||
* @see #parse(java.lang.String)
|
||||
* @see #setEntityResolver
|
||||
* @see #setDTDHandler
|
||||
* @see #setContentHandler
|
||||
* @see #setErrorHandler
|
||||
*/
|
||||
public void parse (InputSource input)
|
||||
throws IOException, SAXException;
|
||||
|
||||
|
||||
/**
|
||||
* Parse an XML document from a system identifier (URI).
|
||||
*
|
||||
* <p>This method is a shortcut for the common case of reading a
|
||||
* document from a system identifier. It is the exact
|
||||
* equivalent of the following:</p>
|
||||
*
|
||||
* <pre>
|
||||
* parse(new InputSource(systemId));
|
||||
* </pre>
|
||||
*
|
||||
* <p>If the system identifier is a URL, it must be fully resolved
|
||||
* by the application before it is passed to the parser.</p>
|
||||
*
|
||||
* @param systemId The system identifier (URI).
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @exception java.io.IOException An IO exception from the parser,
|
||||
* possibly from a byte stream or character stream
|
||||
* supplied by the application.
|
||||
* @see #parse(org.xml.sax.InputSource)
|
||||
*/
|
||||
public void parse (String systemId)
|
||||
throws IOException, SAXException;
|
||||
|
||||
}
|
||||
491
jdkSrc/jdk8/jdk/internal/org/xml/sax/helpers/DefaultHandler.java
Normal file
491
jdkSrc/jdk8/jdk/internal/org/xml/sax/helpers/DefaultHandler.java
Normal file
@@ -0,0 +1,491 @@
|
||||
/*
|
||||
* Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Oracle designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Oracle in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
// DefaultHandler.java - default implementation of the core handlers.
|
||||
// http://www.saxproject.org
|
||||
// Written by David Megginson
|
||||
// NO WARRANTY! This class is in the public domain.
|
||||
// $Id: DefaultHandler.java,v 1.3 2006/04/13 02:06:32 jeffsuttor Exp $
|
||||
|
||||
package jdk.internal.org.xml.sax.helpers;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
import jdk.internal.org.xml.sax.InputSource;
|
||||
import jdk.internal.org.xml.sax.Locator;
|
||||
import jdk.internal.org.xml.sax.Attributes;
|
||||
import jdk.internal.org.xml.sax.EntityResolver;
|
||||
import jdk.internal.org.xml.sax.DTDHandler;
|
||||
import jdk.internal.org.xml.sax.ContentHandler;
|
||||
import jdk.internal.org.xml.sax.ErrorHandler;
|
||||
import jdk.internal.org.xml.sax.SAXException;
|
||||
import jdk.internal.org.xml.sax.SAXParseException;
|
||||
|
||||
|
||||
/**
|
||||
* Default base class for SAX2 event handlers.
|
||||
*
|
||||
* <blockquote>
|
||||
* <em>This module, both source code and documentation, is in the
|
||||
* Public Domain, and comes with <strong>NO WARRANTY</strong>.</em>
|
||||
* See <a href='http://www.saxproject.org'>http://www.saxproject.org</a>
|
||||
* for further information.
|
||||
* </blockquote>
|
||||
*
|
||||
* <p>This class is available as a convenience base class for SAX2
|
||||
* applications: it provides default implementations for all of the
|
||||
* callbacks in the four core SAX2 handler classes:</p>
|
||||
*
|
||||
* <ul>
|
||||
* <li>{@link org.xml.sax.EntityResolver EntityResolver}</li>
|
||||
* <li>{@link org.xml.sax.DTDHandler DTDHandler}</li>
|
||||
* <li>{@link org.xml.sax.ContentHandler ContentHandler}</li>
|
||||
* <li>{@link org.xml.sax.ErrorHandler ErrorHandler}</li>
|
||||
* </ul>
|
||||
*
|
||||
* <p>Application writers can extend this class when they need to
|
||||
* implement only part of an interface; parser writers can
|
||||
* instantiate this class to provide default handlers when the
|
||||
* application has not supplied its own.</p>
|
||||
*
|
||||
* <p>This class replaces the deprecated SAX1
|
||||
* {@link org.xml.sax.HandlerBase HandlerBase} class.</p>
|
||||
*
|
||||
* @since SAX 2.0
|
||||
* @author David Megginson,
|
||||
* @see org.xml.sax.EntityResolver
|
||||
* @see org.xml.sax.DTDHandler
|
||||
* @see org.xml.sax.ContentHandler
|
||||
* @see org.xml.sax.ErrorHandler
|
||||
*/
|
||||
public class DefaultHandler
|
||||
implements EntityResolver, DTDHandler, ContentHandler, ErrorHandler
|
||||
{
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Default implementation of the EntityResolver interface.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
|
||||
/**
|
||||
* Resolve an external entity.
|
||||
*
|
||||
* <p>Always return null, so that the parser will use the system
|
||||
* identifier provided in the XML document. This method implements
|
||||
* the SAX default behaviour: application writers can override it
|
||||
* in a subclass to do special translations such as catalog lookups
|
||||
* or URI redirection.</p>
|
||||
*
|
||||
* @param publicId The public identifier, or null if none is
|
||||
* available.
|
||||
* @param systemId The system identifier provided in the XML
|
||||
* document.
|
||||
* @return The new input source, or null to require the
|
||||
* default behaviour.
|
||||
* @exception java.io.IOException If there is an error setting
|
||||
* up the new input source.
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @see org.xml.sax.EntityResolver#resolveEntity
|
||||
*/
|
||||
public InputSource resolveEntity (String publicId, String systemId)
|
||||
throws IOException, SAXException
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Default implementation of DTDHandler interface.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of a notation declaration.
|
||||
*
|
||||
* <p>By default, do nothing. Application writers may override this
|
||||
* method in a subclass if they wish to keep track of the notations
|
||||
* declared in a document.</p>
|
||||
*
|
||||
* @param name The notation name.
|
||||
* @param publicId The notation public identifier, or null if not
|
||||
* available.
|
||||
* @param systemId The notation system identifier.
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @see org.xml.sax.DTDHandler#notationDecl
|
||||
*/
|
||||
public void notationDecl (String name, String publicId, String systemId)
|
||||
throws SAXException
|
||||
{
|
||||
// no op
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of an unparsed entity declaration.
|
||||
*
|
||||
* <p>By default, do nothing. Application writers may override this
|
||||
* method in a subclass to keep track of the unparsed entities
|
||||
* declared in a document.</p>
|
||||
*
|
||||
* @param name The entity name.
|
||||
* @param publicId The entity public identifier, or null if not
|
||||
* available.
|
||||
* @param systemId The entity system identifier.
|
||||
* @param notationName The name of the associated notation.
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @see org.xml.sax.DTDHandler#unparsedEntityDecl
|
||||
*/
|
||||
public void unparsedEntityDecl (String name, String publicId,
|
||||
String systemId, String notationName)
|
||||
throws SAXException
|
||||
{
|
||||
// no op
|
||||
}
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Default implementation of ContentHandler interface.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* Receive a Locator object for document events.
|
||||
*
|
||||
* <p>By default, do nothing. Application writers may override this
|
||||
* method in a subclass if they wish to store the locator for use
|
||||
* with other document events.</p>
|
||||
*
|
||||
* @param locator A locator for all SAX document events.
|
||||
* @see org.xml.sax.ContentHandler#setDocumentLocator
|
||||
* @see org.xml.sax.Locator
|
||||
*/
|
||||
public void setDocumentLocator (Locator locator)
|
||||
{
|
||||
// no op
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of the beginning of the document.
|
||||
*
|
||||
* <p>By default, do nothing. Application writers may override this
|
||||
* method in a subclass to take specific actions at the beginning
|
||||
* of a document (such as allocating the root node of a tree or
|
||||
* creating an output file).</p>
|
||||
*
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @see org.xml.sax.ContentHandler#startDocument
|
||||
*/
|
||||
public void startDocument ()
|
||||
throws SAXException
|
||||
{
|
||||
// no op
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of the end of the document.
|
||||
*
|
||||
* <p>By default, do nothing. Application writers may override this
|
||||
* method in a subclass to take specific actions at the end
|
||||
* of a document (such as finalising a tree or closing an output
|
||||
* file).</p>
|
||||
*
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @see org.xml.sax.ContentHandler#endDocument
|
||||
*/
|
||||
public void endDocument ()
|
||||
throws SAXException
|
||||
{
|
||||
// no op
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of the start of a Namespace mapping.
|
||||
*
|
||||
* <p>By default, do nothing. Application writers may override this
|
||||
* method in a subclass to take specific actions at the start of
|
||||
* each Namespace prefix scope (such as storing the prefix mapping).</p>
|
||||
*
|
||||
* @param prefix The Namespace prefix being declared.
|
||||
* @param uri The Namespace URI mapped to the prefix.
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @see org.xml.sax.ContentHandler#startPrefixMapping
|
||||
*/
|
||||
public void startPrefixMapping (String prefix, String uri)
|
||||
throws SAXException
|
||||
{
|
||||
// no op
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of the end of a Namespace mapping.
|
||||
*
|
||||
* <p>By default, do nothing. Application writers may override this
|
||||
* method in a subclass to take specific actions at the end of
|
||||
* each prefix mapping.</p>
|
||||
*
|
||||
* @param prefix The Namespace prefix being declared.
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @see org.xml.sax.ContentHandler#endPrefixMapping
|
||||
*/
|
||||
public void endPrefixMapping (String prefix)
|
||||
throws SAXException
|
||||
{
|
||||
// no op
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of the start of an element.
|
||||
*
|
||||
* <p>By default, do nothing. Application writers may override this
|
||||
* method in a subclass to take specific actions at the start of
|
||||
* each element (such as allocating a new tree node or writing
|
||||
* output to a file).</p>
|
||||
*
|
||||
* @param uri The Namespace URI, or the empty string if the
|
||||
* element has no Namespace URI or if Namespace
|
||||
* processing is not being performed.
|
||||
* @param localName The local name (without prefix), or the
|
||||
* empty string if Namespace processing is not being
|
||||
* performed.
|
||||
* @param qName The qualified name (with prefix), or the
|
||||
* empty string if qualified names are not available.
|
||||
* @param attributes The attributes attached to the element. If
|
||||
* there are no attributes, it shall be an empty
|
||||
* Attributes object.
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @see org.xml.sax.ContentHandler#startElement
|
||||
*/
|
||||
public void startElement (String uri, String localName,
|
||||
String qName, Attributes attributes)
|
||||
throws SAXException
|
||||
{
|
||||
// no op
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of the end of an element.
|
||||
*
|
||||
* <p>By default, do nothing. Application writers may override this
|
||||
* method in a subclass to take specific actions at the end of
|
||||
* each element (such as finalising a tree node or writing
|
||||
* output to a file).</p>
|
||||
*
|
||||
* @param uri The Namespace URI, or the empty string if the
|
||||
* element has no Namespace URI or if Namespace
|
||||
* processing is not being performed.
|
||||
* @param localName The local name (without prefix), or the
|
||||
* empty string if Namespace processing is not being
|
||||
* performed.
|
||||
* @param qName The qualified name (with prefix), or the
|
||||
* empty string if qualified names are not available.
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @see org.xml.sax.ContentHandler#endElement
|
||||
*/
|
||||
public void endElement (String uri, String localName, String qName)
|
||||
throws SAXException
|
||||
{
|
||||
// no op
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of character data inside an element.
|
||||
*
|
||||
* <p>By default, do nothing. Application writers may override this
|
||||
* method to take specific actions for each chunk of character data
|
||||
* (such as adding the data to a node or buffer, or printing it to
|
||||
* a file).</p>
|
||||
*
|
||||
* @param ch The characters.
|
||||
* @param start The start position in the character array.
|
||||
* @param length The number of characters to use from the
|
||||
* character array.
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @see org.xml.sax.ContentHandler#characters
|
||||
*/
|
||||
public void characters (char ch[], int start, int length)
|
||||
throws SAXException
|
||||
{
|
||||
// no op
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of ignorable whitespace in element content.
|
||||
*
|
||||
* <p>By default, do nothing. Application writers may override this
|
||||
* method to take specific actions for each chunk of ignorable
|
||||
* whitespace (such as adding data to a node or buffer, or printing
|
||||
* it to a file).</p>
|
||||
*
|
||||
* @param ch The whitespace characters.
|
||||
* @param start The start position in the character array.
|
||||
* @param length The number of characters to use from the
|
||||
* character array.
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @see org.xml.sax.ContentHandler#ignorableWhitespace
|
||||
*/
|
||||
public void ignorableWhitespace (char ch[], int start, int length)
|
||||
throws SAXException
|
||||
{
|
||||
// no op
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of a processing instruction.
|
||||
*
|
||||
* <p>By default, do nothing. Application writers may override this
|
||||
* method in a subclass to take specific actions for each
|
||||
* processing instruction, such as setting status variables or
|
||||
* invoking other methods.</p>
|
||||
*
|
||||
* @param target The processing instruction target.
|
||||
* @param data The processing instruction data, or null if
|
||||
* none is supplied.
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @see org.xml.sax.ContentHandler#processingInstruction
|
||||
*/
|
||||
public void processingInstruction (String target, String data)
|
||||
throws SAXException
|
||||
{
|
||||
// no op
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of a skipped entity.
|
||||
*
|
||||
* <p>By default, do nothing. Application writers may override this
|
||||
* method in a subclass to take specific actions for each
|
||||
* processing instruction, such as setting status variables or
|
||||
* invoking other methods.</p>
|
||||
*
|
||||
* @param name The name of the skipped entity.
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @see org.xml.sax.ContentHandler#processingInstruction
|
||||
*/
|
||||
public void skippedEntity (String name)
|
||||
throws SAXException
|
||||
{
|
||||
// no op
|
||||
}
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Default implementation of the ErrorHandler interface.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of a parser warning.
|
||||
*
|
||||
* <p>The default implementation does nothing. Application writers
|
||||
* may override this method in a subclass to take specific actions
|
||||
* for each warning, such as inserting the message in a log file or
|
||||
* printing it to the console.</p>
|
||||
*
|
||||
* @param e The warning information encoded as an exception.
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @see org.xml.sax.ErrorHandler#warning
|
||||
* @see org.xml.sax.SAXParseException
|
||||
*/
|
||||
public void warning (SAXParseException e)
|
||||
throws SAXException
|
||||
{
|
||||
// no op
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Receive notification of a recoverable parser error.
|
||||
*
|
||||
* <p>The default implementation does nothing. Application writers
|
||||
* may override this method in a subclass to take specific actions
|
||||
* for each error, such as inserting the message in a log file or
|
||||
* printing it to the console.</p>
|
||||
*
|
||||
* @param e The error information encoded as an exception.
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @see org.xml.sax.ErrorHandler#warning
|
||||
* @see org.xml.sax.SAXParseException
|
||||
*/
|
||||
public void error (SAXParseException e)
|
||||
throws SAXException
|
||||
{
|
||||
// no op
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Report a fatal XML parsing error.
|
||||
*
|
||||
* <p>The default implementation throws a SAXParseException.
|
||||
* Application writers may override this method in a subclass if
|
||||
* they need to take specific actions for each fatal error (such as
|
||||
* collecting all of the errors into a single report): in any case,
|
||||
* the application must stop all regular processing when this
|
||||
* method is invoked, since the document is no longer reliable, and
|
||||
* the parser may no longer report parsing events.</p>
|
||||
*
|
||||
* @param e The error information encoded as an exception.
|
||||
* @exception org.xml.sax.SAXException Any SAX exception, possibly
|
||||
* wrapping another exception.
|
||||
* @see org.xml.sax.ErrorHandler#fatalError
|
||||
* @see org.xml.sax.SAXParseException
|
||||
*/
|
||||
public void fatalError (SAXParseException e)
|
||||
throws SAXException
|
||||
{
|
||||
throw e;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// end of DefaultHandler.java
|
||||
Reference in New Issue
Block a user