mirror of git://gcc.gnu.org/git/gcc.git
1929 lines
69 KiB
Java
1929 lines
69 KiB
Java
/* ValidationConsumer.java --
|
|
Copyright (C) 1999,2000,2001 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU Classpath 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 for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301 USA.
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
making a combined work based on this library. Thus, the terms and
|
|
conditions of the GNU General Public License cover the whole
|
|
combination.
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
permission to link this library with independent modules to produce an
|
|
executable, regardless of the license terms of these independent
|
|
modules, and to copy and distribute the resulting executable under
|
|
terms of your choice, provided that you also meet, for each linked
|
|
independent module, the terms and conditions of the license of that
|
|
module. An independent module is a module which is not derived from
|
|
or based on this library. If you modify this library, you may extend
|
|
this exception to your version of the library, but you are not
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
exception statement from your version. */
|
|
|
|
package gnu.xml.pipeline;
|
|
|
|
import java.io.IOException;
|
|
import java.io.StringReader;
|
|
import java.io.StringWriter;
|
|
import java.util.EmptyStackException;
|
|
import java.util.Enumeration;
|
|
import java.util.Hashtable;
|
|
import java.util.Stack;
|
|
import java.util.StringTokenizer;
|
|
import java.util.Vector;
|
|
|
|
import org.xml.sax.Attributes;
|
|
import org.xml.sax.EntityResolver;
|
|
import org.xml.sax.ErrorHandler;
|
|
import org.xml.sax.InputSource;
|
|
import org.xml.sax.Locator;
|
|
import org.xml.sax.SAXException;
|
|
import org.xml.sax.SAXParseException;
|
|
import org.xml.sax.XMLReader;
|
|
import org.xml.sax.helpers.XMLReaderFactory;
|
|
|
|
/**
|
|
* This class checks SAX2 events to report validity errors; it works as
|
|
* both a filter and a terminus on an event pipeline. It relies on the
|
|
* producer of SAX events to: </p> <ol>
|
|
*
|
|
* <li> Conform to the specification of a non-validating XML parser that
|
|
* reads all external entities, reported using SAX2 events. </li>
|
|
*
|
|
* <li> Report ignorable whitespace as such (through the ContentHandler
|
|
* interface). This is, strictly speaking, optional for nonvalidating
|
|
* XML processors. </li>
|
|
*
|
|
* <li> Make SAX2 DeclHandler callbacks, with default
|
|
* attribute values already normalized (and without "<").</li>
|
|
*
|
|
* <li> Make SAX2 LexicalHandler startDTD() and endDTD ()
|
|
* callbacks. </li>
|
|
*
|
|
* <li> Act as if the <em>(URI)/namespace-prefixes</em> property were
|
|
* set to true, by providing XML 1.0 names and all <code>xmlns*</code>
|
|
* attributes (rather than omitting either or both). </li>
|
|
*
|
|
* </ol>
|
|
*
|
|
* <p> At this writing, the major SAX2 parsers (such as Ælfred2,
|
|
* Crimson, and Xerces) meet these requirements, and this validation
|
|
* module is used by the optional Ælfred2 validation support.
|
|
* </p>
|
|
*
|
|
* <p> Note that because this is a layered validator, it has to duplicate some
|
|
* work that the parser is doing; there are also other cost to layering.
|
|
* However, <em>because of layering it doesn't need a parser</em> in order
|
|
* to work! You can use it with anything that generates SAX events, such
|
|
* as an application component that wants to detect invalid content in
|
|
* a changed area without validating an entire document, or which wants to
|
|
* ensure that it doesn't write invalid data to a communications partner.</p>
|
|
*
|
|
* <p> Also, note that because this is a layered validator, the line numbers
|
|
* reported for some errors may seem strange. For example, if an element does
|
|
* not permit character content, the validator
|
|
* will use the locator provided to it.
|
|
* That might reflect the last character of a <em>characters</em> event
|
|
* callback, rather than the first non-whitespace character. </p>
|
|
*
|
|
* <hr />
|
|
*
|
|
* <!--
|
|
* <p> Of interest is the fact that unlike most currently known XML validators,
|
|
* this one can report some cases of non-determinism in element content models.
|
|
* It is a compile-time option, enabled by default. This will only report
|
|
* such XML errors if they relate to content actually appearing in a document;
|
|
* content models aren't aggressively scanned for non-deterministic structure.
|
|
* Documents which trigger such non-deterministic transitions may be handled
|
|
* differently by different validating parsers, without losing conformance
|
|
* to the XML specification. </p>
|
|
* -->
|
|
*
|
|
* <p> Current limitations of the validation performed are in roughly three
|
|
* categories. </p>
|
|
*
|
|
* <p> The first category represents constraints which demand violations
|
|
* of software layering: exposing lexical details, one of the first things
|
|
* that <em>application</em> programming interfaces (APIs) hide. These
|
|
* invariably relate to XML entity handling, and to historical oddities
|
|
* of the XML validation semantics. Curiously,
|
|
* recent (Autumn 1999) conformance testing showed that these constraints are
|
|
* among those handled worst by existing XML validating parsers. Arguments
|
|
* have been made that each of these VCs should be turned into WFCs (most
|
|
* of them) or discarded (popular for the standalone declaration); in short,
|
|
* that these are bugs in the XML specification (not all via SGML): </p><ul>
|
|
*
|
|
* <li> The <em>Proper Declaration/PE Nesting</em> and
|
|
* <em>Proper Group/PE Nesting</em> VCs can't be tested because they
|
|
* require access to particularly low level lexical level information.
|
|
* In essence, the reason XML isn't a simple thing to parse is that
|
|
* it's not a context free grammar, and these constraints elevate that
|
|
* SGML-derived context sensitivity to the level of a semantic rule.
|
|
*
|
|
* <li> The <em>Standalone Document Declaration</em> VC can't be
|
|
* tested. This is for two reasons. First, this flag isn't made
|
|
* available through SAX2. Second, it also requires breaking that
|
|
* lexical layering boundary. (If you ever wondered why classes
|
|
* in compiler construction or language design barely mention the
|
|
* existence of context-sensitive grammars, it's because of messy
|
|
* issues like these.)
|
|
*
|
|
* <li> The <em>Entity Declared</em> VC can't be tested, because it
|
|
* also requires breaking that lexical layering boundary! There's also
|
|
* another issue: the VC wording (and seemingly intent) is ambiguous.
|
|
* (This is still true in the "Second edition" XML spec.)
|
|
* Since there is a WFC of the same name, everyone's life would be
|
|
* easier if references to undeclared parsed entities were always well
|
|
* formedness errors, regardless of whether they're parameter entities
|
|
* or not. (Note that nonvalidating parsers are not required
|
|
* to report all such well formedness errors if they don't read external
|
|
* parameter entities, although currently most XML parsers read them
|
|
* in an attempt to avoid problems from inconsistent parser behavior.)
|
|
*
|
|
* </ul>
|
|
*
|
|
* <p> The second category of limitations on this validation represent
|
|
* constraints associated with information that is not guaranteed to be
|
|
* available (or in one case, <em>is guaranteed not to be available</em>,
|
|
* through the SAX2 API: </p><ul>
|
|
*
|
|
* <li> The <em>Unique Element Type Declaration</em> VC may not be
|
|
* reportable, if the underlying parser happens not to expose
|
|
* multiple declarations. (Ælfred2 reports these validity
|
|
* errors directly.)</li>
|
|
*
|
|
* <li> Similarly, the <em>Unique Notation Name</em> VC, added in the
|
|
* 14-January-2000 XML spec errata to restrict typing models used by
|
|
* elements, may not be reportable. (Ælfred reports these
|
|
* validity errors directly.) </li>
|
|
*
|
|
* </ul>
|
|
*
|
|
* <p> A third category relates to ease of implementation. (Think of this
|
|
* as "bugs".) The most notable issue here is character handling. Rather
|
|
* than attempting to implement the voluminous character tables in the XML
|
|
* specification (Appendix B), Unicode rules are used directly from
|
|
* the java.lang.Character class. Recent JVMs have begun to diverge from
|
|
* the original specification for that class (Unicode 2.0), meaning that
|
|
* different JVMs may handle that aspect of conformance differently.
|
|
* </p>
|
|
*
|
|
* <p> Note that for some of the validity errors that SAX2 does not
|
|
* expose, a nonvalidating parser is permitted (by the XML specification)
|
|
* to report validity errors. When used with a parser that does so for
|
|
* the validity constraints mentioned above (or any other SAX2 event
|
|
* stream producer that does the same thing), overall conformance is
|
|
* substantially improved.
|
|
*
|
|
* @see gnu.xml.aelfred2.SAXDriver
|
|
* @see gnu.xml.aelfred2.XmlReader
|
|
*
|
|
* @author David Brownell
|
|
*/
|
|
public final class ValidationConsumer extends EventFilter
|
|
{
|
|
// report error if we happen to notice a non-deterministic choice?
|
|
// we won't report buggy content models; just buggy instances
|
|
private static final boolean warnNonDeterministic = false;
|
|
|
|
// for tracking active content models
|
|
private String rootName;
|
|
private Stack contentStack = new Stack ();
|
|
|
|
// flags for "saved DTD" processing
|
|
private boolean disableDeclarations;
|
|
private boolean disableReset;
|
|
|
|
//
|
|
// most VCs get tested when we see element start tags. the per-element
|
|
// info (including attributes) recorded here duplicates that found inside
|
|
// many nonvalidating parsers, hence dual lookups etc ... that's why a
|
|
// layered validator isn't going to be as fast as a non-layered one.
|
|
//
|
|
|
|
// key = element name; value = ElementInfo
|
|
private Hashtable elements = new Hashtable ();
|
|
|
|
// some VCs relate to ID/IDREF/IDREFS attributes
|
|
// key = id; value = boolean true (defd) or false (refd)
|
|
private Hashtable ids = new Hashtable ();
|
|
|
|
// we just record declared notation and unparsed entity names.
|
|
// the implementation here is simple/slow; these features
|
|
// are seldom used, one hopes they'll wither away soon
|
|
private Vector notations = new Vector (5, 5);
|
|
private Vector nDeferred = new Vector (5, 5);
|
|
private Vector unparsed = new Vector (5, 5);
|
|
private Vector uDeferred = new Vector (5, 5);
|
|
|
|
// note: DocBk 3.1.7 XML defines over 2 dozen notations,
|
|
// used when defining unparsed entities for graphics
|
|
// (and maybe in other places)
|
|
|
|
|
|
|
|
/**
|
|
* Creates a pipeline terminus which consumes all events passed to
|
|
* it; this will report validity errors as if they were fatal errors,
|
|
* unless an error handler is assigned.
|
|
*
|
|
* @see #setErrorHandler
|
|
*/
|
|
// constructor used by PipelineFactory
|
|
// ... and want one taking system ID of an external subset
|
|
public ValidationConsumer ()
|
|
{
|
|
this (null);
|
|
}
|
|
|
|
/**
|
|
* Creates a pipeline filter which reports validity errors and then
|
|
* passes events on to the next consumer if they were not fatal.
|
|
*
|
|
* @see #setErrorHandler
|
|
*/
|
|
// constructor used by PipelineFactory
|
|
// ... and want one taking system ID of an external subset
|
|
// (which won't send declaration events)
|
|
public ValidationConsumer (EventConsumer next)
|
|
{
|
|
super (next);
|
|
|
|
setContentHandler (this);
|
|
setDTDHandler (this);
|
|
try { setProperty (DECL_HANDLER, this); }
|
|
catch (Exception e) { /* "can't happen" */ }
|
|
try { setProperty (LEXICAL_HANDLER, this); }
|
|
catch (Exception e) { /* "can't happen" */ }
|
|
}
|
|
|
|
|
|
private static final String fakeRootName
|
|
= ":Nobody:in:their_Right.Mind_would:use:this-name:1x:";
|
|
|
|
/**
|
|
* Creates a validation consumer which is preloaded with the DTD provided.
|
|
* It does this by constructing a document with that DTD, then parsing
|
|
* that document and recording its DTD declarations. Then it arranges
|
|
* not to modify that information.
|
|
*
|
|
* <p> The resulting validation consumer will only validate against
|
|
* the specified DTD, regardless of whether some other DTD is found
|
|
* in a document being parsed.
|
|
*
|
|
* @param rootName The name of the required root element; if this is
|
|
* null, any root element name will be accepted.
|
|
* @param publicId If non-null and there is a non-null systemId, this
|
|
* identifier provides an alternate access identifier for the DTD's
|
|
* external subset.
|
|
* @param systemId If non-null, this is a URI (normally URL) that
|
|
* may be used to access the DTD's external subset.
|
|
* @param internalSubset If non-null, holds literal markup declarations
|
|
* comprising the DTD's internal subset.
|
|
* @param resolver If non-null, this will be provided to the parser for
|
|
* use when resolving parameter entities (including any external subset).
|
|
* @param resolver If non-null, this will be provided to the parser for
|
|
* use when resolving parameter entities (including any external subset).
|
|
* @param minimalElement If non-null, a minimal valid document.
|
|
*
|
|
* @exception SAXNotSupportedException If the default SAX parser does
|
|
* not support the standard lexical or declaration handlers.
|
|
* @exception SAXParseException If the specified DTD has either
|
|
* well-formedness or validity errors
|
|
* @exception IOException If the specified DTD can't be read for
|
|
* some reason
|
|
*/
|
|
public ValidationConsumer (
|
|
String rootName,
|
|
String publicId,
|
|
String systemId,
|
|
String internalSubset,
|
|
EntityResolver resolver,
|
|
String minimalDocument
|
|
) throws SAXException, IOException
|
|
{
|
|
this (null);
|
|
|
|
disableReset = true;
|
|
if (rootName == null)
|
|
rootName = fakeRootName;
|
|
|
|
//
|
|
// Synthesize document with that DTD; is it possible to do
|
|
// better for the declaration of the root element?
|
|
//
|
|
// NOTE: can't use SAX2 to write internal subsets.
|
|
//
|
|
StringWriter writer = new StringWriter ();
|
|
|
|
writer.write ("<!DOCTYPE ");
|
|
writer.write (rootName);
|
|
if (systemId != null) {
|
|
writer.write ("\n ");
|
|
if (publicId != null) {
|
|
writer.write ("PUBLIC '");
|
|
writer.write (publicId);
|
|
writer.write ("'\n\t'");
|
|
} else
|
|
writer.write ("SYSTEM '");
|
|
writer.write (systemId);
|
|
writer.write ("'");
|
|
}
|
|
writer.write (" [ ");
|
|
if (rootName == fakeRootName) {
|
|
writer.write ("\n<!ELEMENT ");
|
|
writer.write (rootName);
|
|
writer.write (" EMPTY>");
|
|
}
|
|
if (internalSubset != null)
|
|
writer.write (internalSubset);
|
|
writer.write ("\n ]>");
|
|
|
|
if (minimalDocument != null) {
|
|
writer.write ("\n");
|
|
writer.write (minimalDocument);
|
|
writer.write ("\n");
|
|
} else {
|
|
writer.write (" <");
|
|
writer.write (rootName);
|
|
writer.write ("/>\n");
|
|
}
|
|
minimalDocument = writer.toString ();
|
|
|
|
//
|
|
// OK, load it
|
|
//
|
|
XMLReader producer;
|
|
|
|
producer = XMLReaderFactory.createXMLReader ();
|
|
bind (producer, this);
|
|
|
|
if (resolver != null)
|
|
producer.setEntityResolver (resolver);
|
|
|
|
InputSource in;
|
|
|
|
in = new InputSource (new StringReader (minimalDocument));
|
|
producer.parse (in);
|
|
|
|
disableDeclarations = true;
|
|
if (rootName == fakeRootName)
|
|
this.rootName = null;
|
|
}
|
|
|
|
private void resetState ()
|
|
{
|
|
if (!disableReset) {
|
|
rootName = null;
|
|
contentStack.removeAllElements ();
|
|
elements.clear ();
|
|
ids.clear ();
|
|
|
|
notations.removeAllElements ();
|
|
nDeferred.removeAllElements ();
|
|
unparsed.removeAllElements ();
|
|
uDeferred.removeAllElements ();
|
|
}
|
|
}
|
|
|
|
|
|
private void warning (String description)
|
|
throws SAXException
|
|
{
|
|
ErrorHandler errHandler = getErrorHandler ();
|
|
Locator locator = getDocumentLocator ();
|
|
SAXParseException err;
|
|
|
|
if (errHandler == null)
|
|
return;
|
|
|
|
if (locator == null)
|
|
err = new SAXParseException (description, null, null, -1, -1);
|
|
else
|
|
err = new SAXParseException (description, locator);
|
|
errHandler.warning (err);
|
|
}
|
|
|
|
// package private (for ChildrenRecognizer)
|
|
private void error (String description)
|
|
throws SAXException
|
|
{
|
|
ErrorHandler errHandler = getErrorHandler ();
|
|
Locator locator = getDocumentLocator ();
|
|
SAXParseException err;
|
|
|
|
if (locator == null)
|
|
err = new SAXParseException (description, null, null, -1, -1);
|
|
else
|
|
err = new SAXParseException (description, locator);
|
|
if (errHandler != null)
|
|
errHandler.error (err);
|
|
else // else we always treat it as fatal!
|
|
throw err;
|
|
}
|
|
|
|
private void fatalError (String description)
|
|
throws SAXException
|
|
{
|
|
ErrorHandler errHandler = getErrorHandler ();
|
|
Locator locator = getDocumentLocator ();
|
|
SAXParseException err;
|
|
|
|
if (locator != null)
|
|
err = new SAXParseException (description, locator);
|
|
else
|
|
err = new SAXParseException (description, null, null, -1, -1);
|
|
if (errHandler != null)
|
|
errHandler.fatalError (err);
|
|
// we always treat this as fatal, regardless of the handler
|
|
throw err;
|
|
}
|
|
|
|
|
|
private static boolean isExtender (char c)
|
|
{
|
|
// [88] Extender ::= ...
|
|
return c == 0x00b7 || c == 0x02d0 || c == 0x02d1 || c == 0x0387
|
|
|| c == 0x0640 || c == 0x0e46 || c == 0x0ec6 || c == 0x3005
|
|
|| (c >= 0x3031 && c <= 0x3035)
|
|
|| (c >= 0x309d && c <= 0x309e)
|
|
|| (c >= 0x30fc && c <= 0x30fe);
|
|
}
|
|
|
|
|
|
// use augmented Unicode rules, not full XML rules
|
|
private boolean isName (String name, String context, String id)
|
|
throws SAXException
|
|
{
|
|
char buf [] = name.toCharArray ();
|
|
boolean pass = true;
|
|
|
|
if (!Character.isUnicodeIdentifierStart (buf [0])
|
|
&& ":_".indexOf (buf [0]) == -1)
|
|
pass = false;
|
|
else {
|
|
int max = buf.length;
|
|
for (int i = 1; pass && i < max; i++) {
|
|
char c = buf [i];
|
|
if (!Character.isUnicodeIdentifierPart (c)
|
|
&& ":-_.".indexOf (c) == -1
|
|
&& !isExtender (c))
|
|
pass = false;
|
|
}
|
|
}
|
|
|
|
if (!pass)
|
|
error ("In " + context + " for " + id
|
|
+ ", '" + name + "' is not a name");
|
|
return pass; // true == OK
|
|
}
|
|
|
|
// use augmented Unicode rules, not full XML rules
|
|
private boolean isNmtoken (String nmtoken, String context, String id)
|
|
throws SAXException
|
|
{
|
|
char buf [] = nmtoken.toCharArray ();
|
|
boolean pass = true;
|
|
int max = buf.length;
|
|
|
|
// XXX make this share code with isName
|
|
|
|
for (int i = 0; pass && i < max; i++) {
|
|
char c = buf [i];
|
|
if (!Character.isUnicodeIdentifierPart (c)
|
|
&& ":-_.".indexOf (c) == -1
|
|
&& !isExtender (c))
|
|
pass = false;
|
|
}
|
|
|
|
if (!pass)
|
|
error ("In " + context + " for " + id
|
|
+ ", '" + nmtoken + "' is not a name token");
|
|
return pass; // true == OK
|
|
}
|
|
|
|
private void checkEnumeration (String value, String type, String name)
|
|
throws SAXException
|
|
{
|
|
if (!hasMatch (value, type))
|
|
// VC: Enumeration
|
|
error ("Value '" + value
|
|
+ "' for attribute '" + name
|
|
+ "' is not permitted: " + type);
|
|
}
|
|
|
|
// used to test enumerated attributes and mixed content models
|
|
// package private
|
|
static boolean hasMatch (String value, String orList)
|
|
{
|
|
int len = value.length ();
|
|
int max = orList.length () - len;
|
|
|
|
for (int start = 0;
|
|
(start = orList.indexOf (value, start)) != -1;
|
|
start++) {
|
|
char c;
|
|
|
|
if (start > max)
|
|
break;
|
|
c = orList.charAt (start - 1);
|
|
if (c != '|' && c != '('/*)*/)
|
|
continue;
|
|
c = orList.charAt (start + len);
|
|
if (c != '|' && /*(*/ c != ')')
|
|
continue;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* <b>LexicalHandler</b> Records the declaration of the root
|
|
* element, so it can be verified later.
|
|
* Passed to the next consumer, unless this one was
|
|
* preloaded with a particular DTD.
|
|
*/
|
|
public void startDTD (String name, String publicId, String systemId)
|
|
throws SAXException
|
|
{
|
|
if (disableDeclarations)
|
|
return;
|
|
|
|
rootName = name;
|
|
super.startDTD (name, publicId, systemId);
|
|
}
|
|
|
|
/**
|
|
* <b>LexicalHandler</b> Verifies that all referenced notations
|
|
* and unparsed entities have been declared.
|
|
* Passed to the next consumer, unless this one was
|
|
* preloaded with a particular DTD.
|
|
*/
|
|
public void endDTD ()
|
|
throws SAXException
|
|
{
|
|
if (disableDeclarations)
|
|
return;
|
|
|
|
// this is a convenient hook for end-of-dtd checks, but we
|
|
// could also trigger it in the first startElement call.
|
|
// locator info is more appropriate here though.
|
|
|
|
// VC: Notation Declared (NDATA can refer to them before decls,
|
|
// as can NOTATION attribute enumerations and defaults)
|
|
int length = nDeferred.size ();
|
|
for (int i = 0; i < length; i++) {
|
|
String notation = (String) nDeferred.elementAt (i);
|
|
if (!notations.contains (notation)) {
|
|
error ("A declaration referred to notation '" + notation
|
|
+ "' which was never declared");
|
|
}
|
|
}
|
|
nDeferred.removeAllElements ();
|
|
|
|
// VC: Entity Name (attribute values can refer to them
|
|
// before they're declared); VC Attribute Default Legal
|
|
length = uDeferred.size ();
|
|
for (int i = 0; i < length; i++) {
|
|
String entity = (String) uDeferred.elementAt (i);
|
|
if (!unparsed.contains (entity)) {
|
|
error ("An attribute default referred to entity '" + entity
|
|
+ "' which was never declared");
|
|
}
|
|
}
|
|
uDeferred.removeAllElements ();
|
|
super.endDTD ();
|
|
}
|
|
|
|
|
|
// These are interned, so we can rely on "==" to find the type of
|
|
// all attributes except enumerations ...
|
|
// "(this|or|that|...)" and "NOTATION (this|or|that|...)"
|
|
static final String types [] = {
|
|
"CDATA",
|
|
"ID", "IDREF", "IDREFS",
|
|
"NMTOKEN", "NMTOKENS",
|
|
"ENTITY", "ENTITIES"
|
|
};
|
|
|
|
|
|
/**
|
|
* <b>DecllHandler</b> Records attribute declaration for later use
|
|
* in validating document content, and checks validity constraints
|
|
* that are applicable to attribute declarations.
|
|
* Passed to the next consumer, unless this one was
|
|
* preloaded with a particular DTD.
|
|
*/
|
|
public void attributeDecl (
|
|
String eName,
|
|
String aName,
|
|
String type,
|
|
String mode,
|
|
String value
|
|
) throws SAXException
|
|
{
|
|
if (disableDeclarations)
|
|
return;
|
|
|
|
ElementInfo info = (ElementInfo) elements.get (eName);
|
|
AttributeInfo ainfo = new AttributeInfo ();
|
|
boolean checkOne = false;
|
|
boolean interned = false;
|
|
|
|
// cheap interning of type names and #FIXED, #REQUIRED
|
|
// for faster startElement (we can use "==")
|
|
for (int i = 0; i < types.length; i++) {
|
|
if (types [i].equals (type)) {
|
|
type = types [i];
|
|
interned = true;
|
|
break;
|
|
}
|
|
}
|
|
if ("#FIXED".equals (mode))
|
|
mode = "#FIXED";
|
|
else if ("#REQUIRED".equals (mode))
|
|
mode = "#REQUIRED";
|
|
|
|
ainfo.type = type;
|
|
ainfo.mode = mode;
|
|
ainfo.value = value;
|
|
|
|
// we might not have seen the content model yet
|
|
if (info == null) {
|
|
info = new ElementInfo (eName);
|
|
elements.put (eName, info);
|
|
}
|
|
if ("ID" == type) {
|
|
checkOne = true;
|
|
if (!("#REQUIRED" == mode || "#IMPLIED".equals (mode))) {
|
|
// VC: ID Attribute Default
|
|
error ("ID attribute '" + aName
|
|
+ "' must be #IMPLIED or #REQUIRED");
|
|
}
|
|
|
|
} else if (!interned && type.startsWith ("NOTATION ")) {
|
|
checkOne = true;
|
|
|
|
// VC: Notation Attributes (notations must be declared)
|
|
StringTokenizer tokens = new StringTokenizer (
|
|
type.substring (10, type.lastIndexOf (')')),
|
|
"|");
|
|
while (tokens.hasMoreTokens ()) {
|
|
String token = tokens.nextToken ();
|
|
if (!notations.contains (token))
|
|
nDeferred.addElement (token);
|
|
}
|
|
}
|
|
if (checkOne) {
|
|
for (Enumeration e = info.attributes.keys ();
|
|
e.hasMoreElements ();
|
|
/* NOP */) {
|
|
String name;
|
|
AttributeInfo ainfo2;
|
|
|
|
name = (String) e.nextElement ();
|
|
ainfo2 = (AttributeInfo) info.attributes.get (name);
|
|
if (type == ainfo2.type || !interned /* NOTATION */) {
|
|
// VC: One ID per Element Type
|
|
// VC: One Notation per Element TYpe
|
|
error ("Element '" + eName
|
|
+ "' already has an attribute of type "
|
|
+ (interned ? "NOTATION" : type)
|
|
+ " ('" + name
|
|
+ "') so '" + aName
|
|
+ "' is a validity error");
|
|
}
|
|
}
|
|
}
|
|
|
|
// VC: Attribute Default Legal
|
|
if (value != null) {
|
|
|
|
if ("CDATA" == type) {
|
|
// event source rejected '<'
|
|
|
|
} else if ("NMTOKEN" == type) {
|
|
// VC: Name Token (is a nmtoken)
|
|
isNmtoken (value, "attribute default", aName);
|
|
|
|
} else if ("NMTOKENS" == type) {
|
|
// VC: Name Token (is a nmtoken; at least one value)
|
|
StringTokenizer tokens = new StringTokenizer (value);
|
|
if (!tokens.hasMoreTokens ())
|
|
error ("Default for attribute '" + aName
|
|
+ "' must have at least one name token.");
|
|
else do {
|
|
String token = tokens.nextToken ();
|
|
isNmtoken (token, "attribute default", aName);
|
|
} while (tokens.hasMoreTokens ());
|
|
|
|
} else if ("IDREF" == type || "ENTITY" == type) {
|
|
// VC: Entity Name (is a name)
|
|
// VC: IDREF (is a name) (is declared)
|
|
isName (value, "attribute default", aName);
|
|
if ("ENTITY" == type && !unparsed.contains (value))
|
|
uDeferred.addElement (value);
|
|
|
|
} else if ("IDREFS" == type || "ENTITIES" == type) {
|
|
// VC: Entity Name (is a name; at least one value)
|
|
// VC: IDREF (is a name; at least one value)
|
|
StringTokenizer names = new StringTokenizer (value);
|
|
if (!names.hasMoreTokens ())
|
|
error ("Default for attribute '" + aName
|
|
+ "' must have at least one name.");
|
|
else do {
|
|
String name = names.nextToken ();
|
|
isName (name, "attribute default", aName);
|
|
if ("ENTITIES" == type && !unparsed.contains (name))
|
|
uDeferred.addElement (value);
|
|
} while (names.hasMoreTokens ());
|
|
|
|
} else if (type.charAt (0) == '(' /*)*/ ) {
|
|
// VC: Enumeration (must match)
|
|
checkEnumeration (value, type, aName);
|
|
|
|
} else if (!interned && checkOne) { /* NOTATION */
|
|
// VC: Notation attributes (must be names)
|
|
isName (value, "attribute default", aName);
|
|
|
|
// VC: Notation attributes (must be declared)
|
|
if (!notations.contains (value))
|
|
nDeferred.addElement (value);
|
|
|
|
// VC: Enumeration (must match)
|
|
checkEnumeration (value, type, aName);
|
|
|
|
} else if ("ID" != type)
|
|
throw new RuntimeException ("illegal attribute type: " + type);
|
|
}
|
|
|
|
if (info.attributes.get (aName) == null)
|
|
info.attributes.put (aName, ainfo);
|
|
/*
|
|
else
|
|
warning ("Element '" + eName
|
|
+ "' already has an attribute named '" + aName + "'");
|
|
*/
|
|
|
|
if ("xml:space".equals (aName)) {
|
|
if (!("(default|preserve)".equals (type)
|
|
|| "(preserve|default)".equals (type)
|
|
// these next two are arguable; XHTML's DTD doesn't
|
|
// deserve errors. After all, it's not like any
|
|
// illegal _value_ could pass ...
|
|
|| "(preserve)".equals (type)
|
|
|| "(default)".equals (type)
|
|
))
|
|
error (
|
|
"xml:space attribute type must be like '(default|preserve)'"
|
|
+ " not '" + type + "'"
|
|
);
|
|
|
|
}
|
|
super.attributeDecl (eName, aName, type, mode, value);
|
|
}
|
|
|
|
/**
|
|
* <b>DecllHandler</b> Records the element declaration for later use
|
|
* when checking document content, and checks validity constraints that
|
|
* apply to element declarations. Passed to the next consumer, unless
|
|
* this one was preloaded with a particular DTD.
|
|
*/
|
|
public void elementDecl (String name, String model)
|
|
throws SAXException
|
|
{
|
|
if (disableDeclarations)
|
|
return;
|
|
|
|
ElementInfo info = (ElementInfo) elements.get (name);
|
|
|
|
// we might have seen an attribute decl already
|
|
if (info == null) {
|
|
info = new ElementInfo (name);
|
|
elements.put (name, info);
|
|
}
|
|
if (info.model != null) {
|
|
// NOTE: not all parsers can report such duplicates.
|
|
// VC: Unique Element Type Declaration
|
|
error ("Element type '" + name
|
|
+ "' was already declared.");
|
|
} else {
|
|
info.model = model;
|
|
|
|
// VC: No Duplicate Types (in mixed content models)
|
|
if (model.charAt (1) == '#') // (#PCDATA...
|
|
info.getRecognizer (this);
|
|
}
|
|
super.elementDecl (name, model);
|
|
}
|
|
|
|
/**
|
|
* <b>DecllHandler</b> passed to the next consumer, unless this
|
|
* one was preloaded with a particular DTD
|
|
*/
|
|
public void internalEntityDecl (String name, String value)
|
|
throws SAXException
|
|
{
|
|
if (!disableDeclarations)
|
|
super.internalEntityDecl (name, value);
|
|
}
|
|
|
|
/**
|
|
* <b>DecllHandler</b> passed to the next consumer, unless this
|
|
* one was preloaded with a particular DTD
|
|
*/
|
|
public void externalEntityDecl (String name,
|
|
String publicId, String systemId)
|
|
throws SAXException
|
|
{
|
|
if (!disableDeclarations)
|
|
super.externalEntityDecl (name, publicId, systemId);
|
|
}
|
|
|
|
|
|
/**
|
|
* <b>DTDHandler</b> Records the notation name, for checking
|
|
* NOTATIONS attribute values and declararations of unparsed
|
|
* entities. Passed to the next consumer, unless this one was
|
|
* preloaded with a particular DTD.
|
|
*/
|
|
public void notationDecl (String name, String publicId, String systemId)
|
|
throws SAXException
|
|
{
|
|
if (disableDeclarations)
|
|
return;
|
|
|
|
notations.addElement (name);
|
|
super.notationDecl (name, publicId, systemId);
|
|
}
|
|
|
|
/**
|
|
* <b>DTDHandler</b> Records the entity name, for checking
|
|
* ENTITY and ENTITIES attribute values; records the notation
|
|
* name if it hasn't yet been declared. Passed to the next consumer,
|
|
* unless this one was preloaded with a particular DTD.
|
|
*/
|
|
public void unparsedEntityDecl (
|
|
String name,
|
|
String publicId,
|
|
String systemId,
|
|
String notationName
|
|
) throws SAXException
|
|
{
|
|
if (disableDeclarations)
|
|
return;
|
|
|
|
unparsed.addElement (name);
|
|
if (!notations.contains (notationName))
|
|
nDeferred.addElement (notationName);
|
|
super.unparsedEntityDecl (name, publicId, systemId, notationName);
|
|
}
|
|
|
|
|
|
/**
|
|
* <b>ContentHandler</b> Ensures that state from any previous parse
|
|
* has been deleted.
|
|
* Passed to the next consumer.
|
|
*/
|
|
public void startDocument ()
|
|
throws SAXException
|
|
{
|
|
resetState ();
|
|
super.startDocument ();
|
|
}
|
|
|
|
|
|
private static boolean isAsciiLetter (char c)
|
|
{
|
|
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
|
|
}
|
|
|
|
|
|
/**
|
|
* <b>ContentHandler</b> Reports a fatal exception. Validating
|
|
* XML processors may not skip any entities.
|
|
*/
|
|
public void skippedEntity (String name)
|
|
throws SAXException
|
|
{
|
|
fatalError ("may not skip entities");
|
|
}
|
|
|
|
/*
|
|
* SAX2 doesn't expand non-PE refs in attribute defaults...
|
|
*/
|
|
private String expandDefaultRefs (String s)
|
|
throws SAXException
|
|
{
|
|
if (s.indexOf ('&') < 0)
|
|
return s;
|
|
|
|
// FIXME: handle &#nn; &#xnn; &name;
|
|
String message = "Can't expand refs in attribute default: " + s;
|
|
warning (message);
|
|
|
|
return s;
|
|
}
|
|
|
|
/**
|
|
* <b>ContentHandler</b> Performs validity checks against element
|
|
* (and document) content models, and attribute values.
|
|
* Passed to the next consumer.
|
|
*/
|
|
public void startElement (
|
|
String uri,
|
|
String localName,
|
|
String qName,
|
|
Attributes atts
|
|
) throws SAXException
|
|
{
|
|
//
|
|
// First check content model for the enclosing scope.
|
|
//
|
|
if (contentStack.isEmpty ()) {
|
|
// VC: Root Element Type
|
|
if (!qName.equals (rootName)) {
|
|
if (rootName == null)
|
|
warning ("This document has no DTD, can't be valid");
|
|
else
|
|
error ("Root element type '" + qName
|
|
+ "' was declared to be '" + rootName + "'");
|
|
}
|
|
} else {
|
|
Recognizer state = (Recognizer) contentStack.peek ();
|
|
|
|
if (state != null) {
|
|
Recognizer newstate = state.acceptElement (qName);
|
|
|
|
if (newstate == null)
|
|
error ("Element type '" + qName
|
|
+ "' in element '" + state.type.name
|
|
+ "' violates content model " + state.type.model
|
|
);
|
|
if (newstate != state) {
|
|
contentStack.pop ();
|
|
contentStack.push (newstate);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Then check that this element was declared, and push the
|
|
// object used to validate its content model onto our stack.
|
|
//
|
|
// This is where the recognizer gets created, if needed; if
|
|
// it's a "children" (elements) content model, an NDFA is
|
|
// created. (One recognizer is used per content type, no
|
|
// matter how complex that recognizer is.)
|
|
//
|
|
ElementInfo info;
|
|
|
|
info = (ElementInfo) elements.get (qName);
|
|
if (info == null || info.model == null) {
|
|
// VC: Element Valid (base clause)
|
|
error ("Element type '" + qName + "' was not declared");
|
|
contentStack.push (null);
|
|
|
|
// for less diagnostic noise, fake a declaration.
|
|
elementDecl (qName, "ANY");
|
|
} else
|
|
contentStack.push (info.getRecognizer (this));
|
|
|
|
//
|
|
// Then check each attribute present
|
|
//
|
|
int len;
|
|
String aname;
|
|
AttributeInfo ainfo;
|
|
|
|
if (atts != null)
|
|
len = atts.getLength ();
|
|
else
|
|
len = 0;
|
|
|
|
for (int i = 0; i < len; i++) {
|
|
aname = atts.getQName (i);
|
|
|
|
if (info == null
|
|
|| (ainfo = (AttributeInfo) info.attributes.get (aname))
|
|
== null) {
|
|
// VC: Attribute Value Type
|
|
error ("Attribute '" + aname
|
|
+ "' was not declared for element type " + qName);
|
|
continue;
|
|
}
|
|
|
|
String value = atts.getValue (i);
|
|
|
|
// note that "==" for type names and "#FIXED" is correct
|
|
// (and fast) since we've interned those literals.
|
|
|
|
if ("#FIXED" == ainfo.mode) {
|
|
String expanded = expandDefaultRefs (ainfo.value);
|
|
|
|
// VC: Fixed Attribute Default
|
|
if (!value.equals (expanded)) {
|
|
error ("Attribute '" + aname
|
|
+ "' must match " + expanded
|
|
);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ("CDATA" == ainfo.type)
|
|
continue;
|
|
|
|
//
|
|
// For all other attribute types, there are various
|
|
// rules to follow.
|
|
//
|
|
|
|
if ("ID" == ainfo.type) {
|
|
// VC: ID (must be a name)
|
|
if (isName (value, "ID attribute", aname)) {
|
|
if (Boolean.TRUE == ids.get (value))
|
|
// VC: ID (appears once)
|
|
error ("ID attribute " + aname
|
|
+ " uses an ID value '" + value
|
|
+ "' which was already declared.");
|
|
else
|
|
// any forward refs are no longer problems
|
|
ids.put (value, Boolean.TRUE);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if ("IDREF" == ainfo.type) {
|
|
// VC: IDREF (value must be a name)
|
|
if (isName (value, "IDREF attribute", aname)) {
|
|
// VC: IDREF (must match some ID attribute)
|
|
if (ids.get (value) == null)
|
|
// new -- assume it's a forward ref
|
|
ids.put (value, Boolean.FALSE);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if ("IDREFS" == ainfo.type) {
|
|
StringTokenizer tokens = new StringTokenizer (value, " ");
|
|
|
|
if (!tokens.hasMoreTokens ()) {
|
|
// VC: IDREF (one or more values)
|
|
error ("IDREFS attribute " + aname
|
|
+ " must have at least one ID ref");
|
|
} else do {
|
|
String id = tokens.nextToken ();
|
|
|
|
// VC: IDREF (value must be a name)
|
|
if (isName (id, "IDREFS attribute", aname)) {
|
|
// VC: IDREF (must match some ID attribute)
|
|
if (ids.get (id) == null)
|
|
// new -- assume it's a forward ref
|
|
ids.put (id, Boolean.FALSE);
|
|
}
|
|
} while (tokens.hasMoreTokens ());
|
|
continue;
|
|
}
|
|
|
|
if ("NMTOKEN" == ainfo.type) {
|
|
// VC: Name Token (is a name token)
|
|
isNmtoken (value, "NMTOKEN attribute", aname);
|
|
continue;
|
|
}
|
|
|
|
if ("NMTOKENS" == ainfo.type) {
|
|
StringTokenizer tokens = new StringTokenizer (value, " ");
|
|
|
|
if (!tokens.hasMoreTokens ()) {
|
|
// VC: Name Token (one or more values)
|
|
error ("NMTOKENS attribute " + aname
|
|
+ " must have at least one name token");
|
|
} else do {
|
|
String token = tokens.nextToken ();
|
|
|
|
// VC: Name Token (is a name token)
|
|
isNmtoken (token, "NMTOKENS attribute", aname);
|
|
} while (tokens.hasMoreTokens ());
|
|
continue;
|
|
}
|
|
|
|
if ("ENTITY" == ainfo.type) {
|
|
if (!unparsed.contains (value))
|
|
// VC: Entity Name
|
|
error ("Value of attribute '" + aname
|
|
+ "' refers to unparsed entity '" + value
|
|
+ "' which was not declared.");
|
|
continue;
|
|
}
|
|
|
|
if ("ENTITIES" == ainfo.type) {
|
|
StringTokenizer tokens = new StringTokenizer (value, " ");
|
|
|
|
if (!tokens.hasMoreTokens ()) {
|
|
// VC: Entity Name (one or more values)
|
|
error ("ENTITIES attribute " + aname
|
|
+ " must have at least one name token");
|
|
} else do {
|
|
String entity = tokens.nextToken ();
|
|
|
|
if (!unparsed.contains (entity))
|
|
// VC: Entity Name
|
|
error ("Value of attribute '" + aname
|
|
+ "' refers to unparsed entity '" + entity
|
|
+ "' which was not declared.");
|
|
} while (tokens.hasMoreTokens ());
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// check for enumerations last; more expensive
|
|
//
|
|
if (ainfo.type.charAt (0) == '(' /*)*/
|
|
|| ainfo.type.startsWith ("NOTATION ")
|
|
) {
|
|
// VC: Enumeration (value must be defined)
|
|
checkEnumeration (value, ainfo.type, aname);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Last, check that all #REQUIRED attributes were provided
|
|
//
|
|
if (info != null) {
|
|
Hashtable table = info.attributes;
|
|
|
|
if (table.size () != 0) {
|
|
Enumeration e = table.keys ();
|
|
|
|
// XXX table.keys uses the heap, bleech -- slows things
|
|
|
|
while (e.hasMoreElements ()) {
|
|
aname = (String) e.nextElement ();
|
|
ainfo = (AttributeInfo) table.get (aname);
|
|
|
|
// "#REQUIRED" mode was interned in attributeDecl
|
|
if ("#REQUIRED" == ainfo.mode
|
|
&& atts.getValue (aname) == null) {
|
|
// VC: Required Attribute
|
|
error ("Attribute '" + aname + "' must be specified "
|
|
+ "for element type " + qName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
super.startElement (uri, localName, qName, atts);
|
|
}
|
|
|
|
/**
|
|
* <b>ContentHandler</b> Reports a validity error if the element's content
|
|
* model does not permit character data.
|
|
* Passed to the next consumer.
|
|
*/
|
|
public void characters (char ch [], int start, int length)
|
|
throws SAXException
|
|
{
|
|
Recognizer state;
|
|
|
|
if (contentStack.empty ())
|
|
state = null;
|
|
else
|
|
state = (Recognizer) contentStack.peek ();
|
|
|
|
// NOTE: if this ever supports with SAX parsers that don't
|
|
// report ignorable whitespace as such (only XP?), this class
|
|
// needs to morph it into ignorableWhitespace() as needed ...
|
|
|
|
if (state != null && !state.acceptCharacters ())
|
|
// VC: Element Valid (clauses three, four -- see recognizer)
|
|
error ("Character content not allowed in element "
|
|
+ state.type.name);
|
|
|
|
super.characters (ch, start, length);
|
|
}
|
|
|
|
|
|
/**
|
|
* <b>ContentHandler</b> Reports a validity error if the element's content
|
|
* model does not permit end-of-element yet, or a well formedness error
|
|
* if there was no matching startElement call.
|
|
* Passed to the next consumer.
|
|
*/
|
|
public void endElement (String uri, String localName, String qName)
|
|
throws SAXException
|
|
{
|
|
try {
|
|
Recognizer state = (Recognizer) contentStack.pop ();
|
|
|
|
if (state != null && !state.completed ())
|
|
// VC: Element valid (clauses two, three, four; see Recognizer)
|
|
error ("Premature end for element '"
|
|
+ state.type.name
|
|
+ "', content model "
|
|
+ state.type.model);
|
|
|
|
// could insist on match of start element, but that's
|
|
// something the input stream must to guarantee.
|
|
|
|
} catch (EmptyStackException e) {
|
|
fatalError ("endElement without startElement: " + qName
|
|
+ ((uri == null)
|
|
? ""
|
|
: ( " { '" + uri + "', " + localName + " }")));
|
|
}
|
|
super.endElement (uri, localName, qName);
|
|
}
|
|
|
|
/**
|
|
* <b>ContentHandler</b> Checks whether all ID values that were
|
|
* referenced have been declared, and releases all resources.
|
|
* Passed to the next consumer.
|
|
*
|
|
* @see #setDocumentLocator
|
|
*/
|
|
public void endDocument ()
|
|
throws SAXException
|
|
{
|
|
for (Enumeration idNames = ids.keys ();
|
|
idNames.hasMoreElements ();
|
|
/* NOP */) {
|
|
String id = (String) idNames.nextElement ();
|
|
|
|
if (Boolean.FALSE == ids.get (id)) {
|
|
// VC: IDREF (must match ID)
|
|
error ("Undeclared ID value '" + id
|
|
+ "' was referred to by an IDREF/IDREFS attribute");
|
|
}
|
|
}
|
|
|
|
resetState ();
|
|
super.endDocument ();
|
|
}
|
|
|
|
|
|
/** Holds per-element declarations */
|
|
static private final class ElementInfo
|
|
{
|
|
String name;
|
|
String model;
|
|
|
|
// key = attribute name; value = AttributeInfo
|
|
Hashtable attributes = new Hashtable (11);
|
|
|
|
ElementInfo (String n) { name = n; }
|
|
|
|
private Recognizer recognizer;
|
|
|
|
// for validating content models: one per type, shared,
|
|
// and constructed only on demand ... so unused elements do
|
|
// not need to consume resources.
|
|
Recognizer getRecognizer (ValidationConsumer consumer)
|
|
throws SAXException
|
|
{
|
|
if (recognizer == null) {
|
|
if ("ANY".equals (model))
|
|
recognizer = ANY;
|
|
else if ("EMPTY".equals (model))
|
|
recognizer = new EmptyRecognizer (this);
|
|
else if ('#' == model.charAt (1))
|
|
// n.b. this constructor does a validity check
|
|
recognizer = new MixedRecognizer (this, consumer);
|
|
else
|
|
recognizer = new ChildrenRecognizer (this, consumer);
|
|
}
|
|
return recognizer;
|
|
}
|
|
}
|
|
|
|
/** Holds per-attribute declarations */
|
|
static private final class AttributeInfo
|
|
{
|
|
String type;
|
|
String mode; // #REQUIRED, etc (or null)
|
|
String value; // or null
|
|
}
|
|
|
|
|
|
//
|
|
// Content model validation
|
|
//
|
|
|
|
static private final Recognizer ANY = new Recognizer (null);
|
|
|
|
|
|
// Base class defines the calls used to validate content,
|
|
// and supports the "ANY" content model
|
|
static private class Recognizer
|
|
{
|
|
final ElementInfo type;
|
|
|
|
Recognizer (ElementInfo t) { type = t; }
|
|
|
|
// return true iff character data is legal here
|
|
boolean acceptCharacters ()
|
|
throws SAXException
|
|
// VC: Element Valid (third and fourth clauses)
|
|
{ return true; }
|
|
|
|
// null return = failure
|
|
// otherwise, next state (like an FSM)
|
|
// prerequisite: tested that name was declared
|
|
Recognizer acceptElement (String name)
|
|
throws SAXException
|
|
// VC: Element Valid (fourth clause)
|
|
{ return this; }
|
|
|
|
// return true iff model is completed, can finish
|
|
boolean completed ()
|
|
throws SAXException
|
|
// VC: Element Valid (fourth clause)
|
|
{ return true; }
|
|
|
|
public String toString ()
|
|
// n.b. "children" is the interesting case!
|
|
{ return (type == null) ? "ANY" : type.model; }
|
|
}
|
|
|
|
// "EMPTY" content model -- no characters or elements
|
|
private static final class EmptyRecognizer extends Recognizer
|
|
{
|
|
public EmptyRecognizer (ElementInfo type)
|
|
{ super (type); }
|
|
|
|
// VC: Element Valid (first clause)
|
|
boolean acceptCharacters ()
|
|
{ return false; }
|
|
|
|
// VC: Element Valid (first clause)
|
|
Recognizer acceptElement (String name)
|
|
{ return null; }
|
|
}
|
|
|
|
// "Mixed" content model -- ANY, but restricts elements
|
|
private static final class MixedRecognizer extends Recognizer
|
|
{
|
|
private String permitted [];
|
|
|
|
// N.B. constructor tests for duplicated element names (VC)
|
|
public MixedRecognizer (ElementInfo t, ValidationConsumer v)
|
|
throws SAXException
|
|
{
|
|
super (t);
|
|
|
|
// (#PCDATA...)* or (#PCDATA) ==> ... or empty
|
|
// with the "..." being "|elname|..."
|
|
StringTokenizer tokens = new StringTokenizer (
|
|
t.model.substring (8, t.model.lastIndexOf (')')),
|
|
"|");
|
|
Vector vec = new Vector ();
|
|
|
|
while (tokens.hasMoreTokens ()) {
|
|
String token = tokens.nextToken ();
|
|
|
|
if (vec.contains (token))
|
|
v.error ("element " + token
|
|
+ " is repeated in mixed content model: "
|
|
+ t.model);
|
|
else
|
|
vec.addElement (token.intern ());
|
|
}
|
|
permitted = new String [vec.size ()];
|
|
for (int i = 0; i < permitted.length; i++)
|
|
permitted [i] = (String) vec.elementAt (i);
|
|
|
|
// in one large machine-derived DTD sample, most of about
|
|
// 250 mixed content models were empty, and 25 had ten or
|
|
// more entries. 2 had over a hundred elements. Linear
|
|
// search isn't obviously wrong.
|
|
}
|
|
|
|
// VC: Element Valid (third clause)
|
|
Recognizer acceptElement (String name)
|
|
{
|
|
int length = permitted.length;
|
|
|
|
// first pass -- optimistic w.r.t. event source interning
|
|
// (and document validity)
|
|
for (int i = 0; i < length; i++)
|
|
if (permitted [i] == name)
|
|
return this;
|
|
// second pass -- pessimistic w.r.t. event source interning
|
|
for (int i = 0; i < length; i++)
|
|
if (permitted [i].equals (name))
|
|
return this;
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
// recognizer loop flags, see later
|
|
private static final int F_LOOPHEAD = 0x01;
|
|
private static final int F_LOOPNEXT = 0x02;
|
|
|
|
// for debugging -- used to label/count nodes in toString()
|
|
private static int nodeCount;
|
|
|
|
/**
|
|
* "Children" content model -- these are nodes in NDFA state graphs.
|
|
* They work in fixed space. Note that these graphs commonly have
|
|
* cycles, handling features such as zero-or-more and one-or-more.
|
|
*
|
|
* <p>It's readonly, so only one copy is ever needed. The content model
|
|
* stack may have any number of pointers into each graph, when a model
|
|
* happens to be needed more than once due to element nesting. Since
|
|
* traversing the graph just moves to another node, and never changes
|
|
* it, traversals never interfere with each other.
|
|
*
|
|
* <p>There is an option to report non-deterministic models. These are
|
|
* always XML errors, but ones which are not often reported despite the
|
|
* fact that they can lead to different validating parsers giving
|
|
* different results for the same input. (The XML spec doesn't require
|
|
* them to be reported.)
|
|
*
|
|
* <p><b>FIXME</b> There's currently at least one known bug here, in that
|
|
* it's not actually detecting the non-determinism it tries to detect.
|
|
* (Of the "optional.xml" test, the once-or-twice-2* tests are all non-D;
|
|
* maybe some others.) This may relate to the issue flagged below as
|
|
* "should not" happen (but it was), which showed up when patching the
|
|
* graph to have one exit node (or more EMPTY nodes).
|
|
*/
|
|
private static final class ChildrenRecognizer extends Recognizer
|
|
implements Cloneable
|
|
{
|
|
// for reporting non-deterministic content models
|
|
// ... a waste of space if we're not reporting those!
|
|
// ... along with the 'model' member (in base class)
|
|
private ValidationConsumer consumer;
|
|
|
|
// for CHOICE nodes -- each component is an arc that
|
|
// accepts a different NAME (or is EMPTY indicating
|
|
// NDFA termination).
|
|
private Recognizer components [];
|
|
|
|
// for NAME/SEQUENCE nodes -- accepts that NAME and
|
|
// then goes to the next node (CHOICE, NAME, EMPTY).
|
|
private String name;
|
|
private Recognizer next;
|
|
|
|
// loops always point back to a CHOICE node. we mark such choice
|
|
// nodes (F_LOOPHEAD) for diagnostics and faster deep cloning.
|
|
// We also mark nodes before back pointers (F_LOOPNEXT), to ensure
|
|
// termination when we patch sequences and loops.
|
|
private int flags;
|
|
|
|
|
|
// prevent a needless indirection between 'this' and 'node'
|
|
private void copyIn (ChildrenRecognizer node)
|
|
{
|
|
// model & consumer are already set
|
|
components = node.components;
|
|
name = node.name;
|
|
next = node.next;
|
|
flags = node.flags;
|
|
}
|
|
|
|
// used to construct top level "children" content models,
|
|
public ChildrenRecognizer (ElementInfo type, ValidationConsumer vc)
|
|
{
|
|
this (vc, type);
|
|
populate (type.model.toCharArray (), 0);
|
|
patchNext (new EmptyRecognizer (type), null);
|
|
}
|
|
|
|
// used internally; populating is separate
|
|
private ChildrenRecognizer (ValidationConsumer vc, ElementInfo type)
|
|
{
|
|
super (type);
|
|
consumer = vc;
|
|
}
|
|
|
|
|
|
//
|
|
// When rewriting some graph nodes we need deep clones in one case;
|
|
// mostly shallow clones (what the JVM handles for us) are fine.
|
|
//
|
|
private ChildrenRecognizer shallowClone ()
|
|
{
|
|
try {
|
|
return (ChildrenRecognizer) clone ();
|
|
} catch (CloneNotSupportedException e) {
|
|
throw new Error ("clone");
|
|
}
|
|
}
|
|
|
|
private ChildrenRecognizer deepClone ()
|
|
{
|
|
return deepClone (new Hashtable (37));
|
|
}
|
|
|
|
private ChildrenRecognizer deepClone (Hashtable table)
|
|
{
|
|
ChildrenRecognizer retval;
|
|
|
|
if ((flags & F_LOOPHEAD) != 0) {
|
|
retval = (ChildrenRecognizer) table.get (this);
|
|
if (retval != null)
|
|
return this;
|
|
|
|
retval = shallowClone ();
|
|
table.put (this, retval);
|
|
} else
|
|
retval = shallowClone ();
|
|
|
|
if (next != null) {
|
|
if (next instanceof ChildrenRecognizer)
|
|
retval.next = ((ChildrenRecognizer)next)
|
|
.deepClone (table);
|
|
else if (!(next instanceof EmptyRecognizer))
|
|
throw new RuntimeException ("deepClone");
|
|
}
|
|
|
|
if (components != null) {
|
|
retval.components = new Recognizer [components.length];
|
|
for (int i = 0; i < components.length; i++) {
|
|
Recognizer temp = components [i];
|
|
|
|
if (temp == null)
|
|
retval.components [i] = null;
|
|
else if (temp instanceof ChildrenRecognizer)
|
|
retval.components [i] = ((ChildrenRecognizer)temp)
|
|
.deepClone (table);
|
|
else if (!(temp instanceof EmptyRecognizer))
|
|
throw new RuntimeException ("deepClone");
|
|
}
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
// connect subgraphs, first to next (sequencing)
|
|
private void patchNext (Recognizer theNext, Hashtable table)
|
|
{
|
|
// backpointers must not be repatched or followed
|
|
if ((flags & F_LOOPNEXT) != 0)
|
|
return;
|
|
|
|
// XXX this table "shouldn't" be needed, right?
|
|
// but some choice nodes looped if it isn't there.
|
|
if (table != null && table.get (this) != null)
|
|
return;
|
|
if (table == null)
|
|
table = new Hashtable ();
|
|
|
|
// NAME/SEQUENCE
|
|
if (name != null) {
|
|
if (next == null)
|
|
next = theNext;
|
|
else if (next instanceof ChildrenRecognizer) {
|
|
((ChildrenRecognizer)next).patchNext (theNext, table);
|
|
} else if (!(next instanceof EmptyRecognizer))
|
|
throw new RuntimeException ("patchNext");
|
|
return;
|
|
}
|
|
|
|
// CHOICE
|
|
for (int i = 0; i < components.length; i++) {
|
|
if (components [i] == null)
|
|
components [i] = theNext;
|
|
else if (components [i] instanceof ChildrenRecognizer) {
|
|
((ChildrenRecognizer)components [i])
|
|
.patchNext (theNext, table);
|
|
} else if (!(components [i] instanceof EmptyRecognizer))
|
|
throw new RuntimeException ("patchNext");
|
|
}
|
|
|
|
if (table != null && (flags & F_LOOPHEAD) != 0)
|
|
table.put (this, this);
|
|
}
|
|
|
|
/**
|
|
* Parses a 'children' spec (or recursively 'cp') and makes this
|
|
* become a regular graph node.
|
|
*
|
|
* @return index after this particle
|
|
*/
|
|
private int populate (char parseBuf [], int startPos)
|
|
{
|
|
int nextPos = startPos + 1;
|
|
char c;
|
|
|
|
if (nextPos < 0 || nextPos >= parseBuf.length)
|
|
throw new IndexOutOfBoundsException ();
|
|
|
|
// Grammar of the string is from the XML spec, but
|
|
// with whitespace removed by the SAX parser.
|
|
|
|
// children ::= (choice | seq) ('?' | '*' | '+')?
|
|
// cp ::= (Name | choice | seq) ('?' | '*' | '+')?
|
|
// choice ::= '(' cp ('|' choice)* ')'
|
|
// seq ::= '(' cp (',' choice)* ')'
|
|
|
|
// interior nodes only
|
|
// cp ::= name ...
|
|
if (parseBuf [startPos] != '('/*)*/) {
|
|
boolean done = false;
|
|
do {
|
|
switch (c = parseBuf [nextPos]) {
|
|
case '?': case '*': case '+':
|
|
case '|': case ',':
|
|
case /*(*/ ')':
|
|
done = true;
|
|
continue;
|
|
default:
|
|
nextPos++;
|
|
continue;
|
|
}
|
|
} while (!done);
|
|
name = new String (parseBuf, startPos, nextPos - startPos);
|
|
|
|
// interior OR toplevel nodes
|
|
// cp ::= choice ..
|
|
// cp ::= seq ..
|
|
} else {
|
|
// collect everything as a separate list, and merge it
|
|
// into "this" later if we can (SEQUENCE or singleton)
|
|
ChildrenRecognizer first;
|
|
|
|
first = new ChildrenRecognizer (consumer, type);
|
|
nextPos = first.populate (parseBuf, nextPos);
|
|
c = parseBuf [nextPos++];
|
|
|
|
if (c == ',' || c == '|') {
|
|
ChildrenRecognizer current = first;
|
|
char separator = c;
|
|
Vector v = null;
|
|
|
|
if (separator == '|') {
|
|
v = new Vector ();
|
|
v.addElement (first);
|
|
}
|
|
|
|
do {
|
|
ChildrenRecognizer link;
|
|
|
|
link = new ChildrenRecognizer (consumer, type);
|
|
nextPos = link.populate (parseBuf, nextPos);
|
|
|
|
if (separator == ',') {
|
|
current.patchNext (link, null);
|
|
current = link;
|
|
} else
|
|
v.addElement (link);
|
|
|
|
c = parseBuf [nextPos++];
|
|
} while (c == separator);
|
|
|
|
// choice ... collect everything into one array.
|
|
if (separator == '|') {
|
|
// assert v.size() > 1
|
|
components = new Recognizer [v.size ()];
|
|
for (int i = 0; i < components.length; i++) {
|
|
components [i] = (Recognizer)
|
|
v.elementAt (i);
|
|
}
|
|
// assert flags == 0
|
|
|
|
// sequence ... merge into "this" to be smaller.
|
|
} else
|
|
copyIn (first);
|
|
|
|
// treat singletons like one-node sequences.
|
|
} else
|
|
copyIn (first);
|
|
|
|
if (c != /*(*/ ')')
|
|
throw new RuntimeException ("corrupt content model");
|
|
}
|
|
|
|
//
|
|
// Arity is optional, and the root of all fun. We keep the
|
|
// FSM state graph simple by only having NAME/SEQUENCE and
|
|
// CHOICE nodes (or EMPTY to terminate a model), easily
|
|
// evaluated. So we rewrite each node that has arity, using
|
|
// those primitives. We create loops here, if needed.
|
|
//
|
|
if (nextPos < parseBuf.length) {
|
|
c = parseBuf [nextPos];
|
|
if (c == '?' || c == '*' || c == '+') {
|
|
nextPos++;
|
|
|
|
// Rewrite 'zero-or-one' "?" arity to a CHOICE:
|
|
// - SEQUENCE (clone, what's next)
|
|
// - or, what's next
|
|
// Size cost: N --> N + 1
|
|
if (c == '?') {
|
|
Recognizer once = shallowClone ();
|
|
|
|
components = new Recognizer [2];
|
|
components [0] = once;
|
|
// components [1] initted to null
|
|
name = null;
|
|
next = null;
|
|
flags = 0;
|
|
|
|
|
|
// Rewrite 'zero-or-more' "*" arity to a CHOICE.
|
|
// - LOOP (clone, back to this CHOICE)
|
|
// - or, what's next
|
|
// Size cost: N --> N + 1
|
|
} else if (c == '*') {
|
|
ChildrenRecognizer loop = shallowClone ();
|
|
|
|
loop.patchNext (this, null);
|
|
loop.flags |= F_LOOPNEXT;
|
|
flags = F_LOOPHEAD;
|
|
|
|
components = new Recognizer [2];
|
|
components [0] = loop;
|
|
// components [1] initted to null
|
|
name = null;
|
|
next = null;
|
|
|
|
|
|
// Rewrite 'one-or-more' "+" arity to a SEQUENCE.
|
|
// Basically (a)+ --> ((a),(a)*).
|
|
// - this
|
|
// - CHOICE
|
|
// * LOOP (clone, back to the CHOICE)
|
|
// * or, whatever's next
|
|
// Size cost: N --> 2N + 1
|
|
} else if (c == '+') {
|
|
ChildrenRecognizer loop = deepClone ();
|
|
ChildrenRecognizer choice;
|
|
|
|
choice = new ChildrenRecognizer (consumer, type);
|
|
loop.patchNext (choice, null);
|
|
loop.flags |= F_LOOPNEXT;
|
|
choice.flags = F_LOOPHEAD;
|
|
|
|
choice.components = new Recognizer [2];
|
|
choice.components [0] = loop;
|
|
// choice.components [1] initted to null
|
|
// choice.name, choice.next initted to null
|
|
|
|
patchNext (choice, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
return nextPos;
|
|
}
|
|
|
|
// VC: Element Valid (second clause)
|
|
boolean acceptCharacters ()
|
|
{ return false; }
|
|
|
|
// VC: Element Valid (second clause)
|
|
Recognizer acceptElement (String type)
|
|
throws SAXException
|
|
{
|
|
// NAME/SEQUENCE
|
|
if (name != null) {
|
|
if (name.equals (type))
|
|
return next;
|
|
return null;
|
|
}
|
|
|
|
// CHOICE ... optionally reporting nondeterminism we
|
|
// run across. we won't check out every transition
|
|
// for nondeterminism; only the ones we follow.
|
|
Recognizer retval = null;
|
|
|
|
for (int i = 0; i < components.length; i++) {
|
|
Recognizer temp = components [i].acceptElement (type);
|
|
|
|
if (temp == null)
|
|
continue;
|
|
else if (!warnNonDeterministic)
|
|
return temp;
|
|
else if (retval == null)
|
|
retval = temp;
|
|
else if (retval != temp)
|
|
consumer.error ("Content model " + this.type.model
|
|
+ " is non-deterministic for " + type);
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
// VC: Element Valid (second clause)
|
|
boolean completed ()
|
|
throws SAXException
|
|
{
|
|
// expecting a specific element
|
|
if (name != null)
|
|
return false;
|
|
|
|
// choice, some sequences
|
|
for (int i = 0; i < components.length; i++) {
|
|
if (components [i].completed ())
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/** /
|
|
// FOR DEBUGGING ... flattens the graph for printing.
|
|
|
|
public String toString ()
|
|
{
|
|
StringBuffer buf = new StringBuffer ();
|
|
|
|
// only one set of loop labels can be generated
|
|
// at a time...
|
|
synchronized (ANY) {
|
|
nodeCount = 0;
|
|
|
|
toString (buf, new Hashtable ());
|
|
return buf.toString ();
|
|
}
|
|
}
|
|
|
|
private void toString (StringBuffer buf, Hashtable table)
|
|
{
|
|
// When we visit a node, label and count it.
|
|
// Nodes are never visited/counted more than once.
|
|
// For small models labels waste space, but if arity
|
|
// mappings were used the savings are substantial.
|
|
// (Plus, the output can be more readily understood.)
|
|
String temp = (String) table.get (this);
|
|
|
|
if (temp != null) {
|
|
buf.append ('{');
|
|
buf.append (temp);
|
|
buf.append ('}');
|
|
return;
|
|
} else {
|
|
StringBuffer scratch = new StringBuffer (15);
|
|
|
|
if ((flags & F_LOOPHEAD) != 0)
|
|
scratch.append ("loop");
|
|
else
|
|
scratch.append ("node");
|
|
scratch.append ('-');
|
|
scratch.append (++nodeCount);
|
|
temp = scratch.toString ();
|
|
|
|
table.put (this, temp);
|
|
buf.append ('[');
|
|
buf.append (temp);
|
|
buf.append (']');
|
|
buf.append (':');
|
|
}
|
|
|
|
// NAME/SEQUENCE
|
|
if (name != null) {
|
|
// n.b. some output encodings turn some name chars into '?'
|
|
// e.g. with Japanese names and ASCII output
|
|
buf.append (name);
|
|
if (components != null) // bug!
|
|
buf.append ('$');
|
|
if (next == null)
|
|
buf.append (",*");
|
|
else if (next instanceof EmptyRecognizer) // patch-to-next
|
|
buf.append (",{}");
|
|
else if (next instanceof ChildrenRecognizer) {
|
|
buf.append (',');
|
|
((ChildrenRecognizer)next).toString (buf, table);
|
|
} else // bug!
|
|
buf.append (",+");
|
|
return;
|
|
}
|
|
|
|
// CHOICE
|
|
buf.append ("<");
|
|
for (int i = 0; i < components.length; i++) {
|
|
if (i != 0)
|
|
buf.append ("|");
|
|
if (components [i] instanceof EmptyRecognizer) {
|
|
buf.append ("{}");
|
|
} else if (components [i] == null) { // patch-to-next
|
|
buf.append ('*');
|
|
} else {
|
|
ChildrenRecognizer r;
|
|
|
|
r = (ChildrenRecognizer) components [i];
|
|
r.toString (buf, table);
|
|
}
|
|
}
|
|
buf.append (">");
|
|
}
|
|
/**/
|
|
}
|
|
}
|