Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
Java Source Code for Xerces Java 2.11.2
Where Can I see Java Source Code files for Xerces Java 2.11.2?
✍: FYIcenter
Here are Java Source Code files for Xerces Java 2.11.2:
⏎ org/apache/xerces/impl/dtd/DTDGrammar.java
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.xerces.impl.dtd; import java.util.ArrayList; import java.util.Hashtable; import java.util.Random; import org.apache.xerces.impl.dtd.models.CMAny; import org.apache.xerces.impl.dtd.models.CMBinOp; import org.apache.xerces.impl.dtd.models.CMLeaf; import org.apache.xerces.impl.dtd.models.CMNode; import org.apache.xerces.impl.dtd.models.CMUniOp; import org.apache.xerces.impl.dtd.models.ContentModelValidator; import org.apache.xerces.impl.dtd.models.DFAContentModel; import org.apache.xerces.impl.dtd.models.MixedContentModel; import org.apache.xerces.impl.dtd.models.SimpleContentModel; import org.apache.xerces.impl.dv.DatatypeValidator; import org.apache.xerces.impl.validation.EntityState; import org.apache.xerces.util.SymbolTable; import org.apache.xerces.xni.Augmentations; import org.apache.xerces.xni.QName; import org.apache.xerces.xni.XMLDTDContentModelHandler; import org.apache.xerces.xni.XMLDTDHandler; import org.apache.xerces.xni.XMLLocator; import org.apache.xerces.xni.XMLResourceIdentifier; import org.apache.xerces.xni.XMLString; import org.apache.xerces.xni.XNIException; import org.apache.xerces.xni.grammars.Grammar; import org.apache.xerces.xni.grammars.XMLGrammarDescription; import org.apache.xerces.xni.parser.XMLDTDContentModelSource; import org.apache.xerces.xni.parser.XMLDTDSource; /** * A DTD grammar. This class implements the XNI handler interfaces * for DTD information so that it can build the appropriate validation * structures automatically from the callbacks. * * @xerces.internal * * @author Eric Ye, IBM * @author Jeffrey Rodriguez, IBM * @author Andy Clark, IBM * @author Neil Graham, IBM * * @version $Id: DTDGrammar.java 1357390 2012-07-04 20:20:20Z mrglavas $ */ public class DTDGrammar implements XMLDTDHandler, XMLDTDContentModelHandler, EntityState, Grammar { // // Constants // /** Top level scope (-1). */ public static final int TOP_LEVEL_SCOPE = -1; // private /** Chunk shift (8). */ private static final int CHUNK_SHIFT = 8; // 2^8 = 256 /** Chunk size (1 << CHUNK_SHIFT). */ private static final int CHUNK_SIZE = (1 << CHUNK_SHIFT); /** Chunk mask (CHUNK_SIZE - 1). */ private static final int CHUNK_MASK = CHUNK_SIZE - 1; /** Initial chunk count (1 << (10 - CHUNK_SHIFT)). */ private static final int INITIAL_CHUNK_COUNT = (1 << (10 - CHUNK_SHIFT)); // 2^10 = 1k /** List flag (0x80). */ private static final short LIST_FLAG = 0x80; /** List mask (~LIST_FLAG). */ private static final short LIST_MASK = ~LIST_FLAG; // debugging /** Debug DTDGrammar. */ private static final boolean DEBUG = false; // // Data // protected XMLDTDSource fDTDSource = null; protected XMLDTDContentModelSource fDTDContentModelSource = null; /** Current element index. */ protected int fCurrentElementIndex; /** Current attribute index. */ protected int fCurrentAttributeIndex; /** fReadingExternalDTD */ protected boolean fReadingExternalDTD = false; /** Symbol table. */ private SymbolTable fSymbolTable; // The XMLDTDDescription with which this Grammar is associated protected XMLDTDDescription fGrammarDescription = null; // element declarations /** Number of element declarations. */ private int fElementDeclCount = 0; /** Element declaration name. */ private QName fElementDeclName[][] = new QName[INITIAL_CHUNK_COUNT][]; /** * Element declaration type. * @see XMLElementDecl */ private short fElementDeclType[][] = new short[INITIAL_CHUNK_COUNT][]; /** * Element declaration content spec index. This index value is used * to refer to the content spec information tables. */ private int fElementDeclContentSpecIndex[][] = new int[INITIAL_CHUNK_COUNT][]; /** * Element declaration content model validator. This validator is * constructed from the content spec nodes. */ private ContentModelValidator fElementDeclContentModelValidator[][] = new ContentModelValidator[INITIAL_CHUNK_COUNT][]; /** First attribute declaration of an element declaration. */ private int fElementDeclFirstAttributeDeclIndex[][] = new int[INITIAL_CHUNK_COUNT][]; /** Last attribute declaration of an element declaration. */ private int fElementDeclLastAttributeDeclIndex[][] = new int[INITIAL_CHUNK_COUNT][]; // attribute declarations /** Number of attribute declarations. */ private int fAttributeDeclCount = 0 ; /** Attribute declaration name. */ private QName fAttributeDeclName[][] = new QName[INITIAL_CHUNK_COUNT][]; // is this grammar immutable? (fully constructed and not changeable) private boolean fIsImmutable = false; /** * Attribute declaration type. * @see XMLAttributeDecl */ private short fAttributeDeclType[][] = new short[INITIAL_CHUNK_COUNT][]; /** Attribute declaration enumeration values. */ private String[] fAttributeDeclEnumeration[][] = new String[INITIAL_CHUNK_COUNT][][]; private short fAttributeDeclDefaultType[][] = new short[INITIAL_CHUNK_COUNT][]; private DatatypeValidator fAttributeDeclDatatypeValidator[][] = new DatatypeValidator[INITIAL_CHUNK_COUNT][]; private String fAttributeDeclDefaultValue[][] = new String[INITIAL_CHUNK_COUNT][]; private String fAttributeDeclNonNormalizedDefaultValue[][] = new String[INITIAL_CHUNK_COUNT][]; private int fAttributeDeclNextAttributeDeclIndex[][] = new int[INITIAL_CHUNK_COUNT][]; // content specs // here saves the content spec binary trees for element decls, // each element with a content model will hold a pointer which is // the index of the head node of the content spec tree. private int fContentSpecCount = 0; private short fContentSpecType[][] = new short[INITIAL_CHUNK_COUNT][]; private Object fContentSpecValue[][] = new Object[INITIAL_CHUNK_COUNT][]; private Object fContentSpecOtherValue[][] = new Object[INITIAL_CHUNK_COUNT][]; // entities private int fEntityCount = 0; private String fEntityName[][] = new String[INITIAL_CHUNK_COUNT][]; private String[][] fEntityValue = new String[INITIAL_CHUNK_COUNT][]; private String[][] fEntityPublicId = new String[INITIAL_CHUNK_COUNT][]; private String[][] fEntitySystemId = new String[INITIAL_CHUNK_COUNT][]; private String[][] fEntityBaseSystemId = new String[INITIAL_CHUNK_COUNT][]; private String[][] fEntityNotation = new String[INITIAL_CHUNK_COUNT][]; private byte[][] fEntityIsPE = new byte[INITIAL_CHUNK_COUNT][]; private byte[][] fEntityInExternal = new byte[INITIAL_CHUNK_COUNT][]; // notations private int fNotationCount = 0; private String fNotationName[][] = new String[INITIAL_CHUNK_COUNT][]; private String[][] fNotationPublicId = new String[INITIAL_CHUNK_COUNT][]; private String[][] fNotationSystemId = new String[INITIAL_CHUNK_COUNT][]; private String[][] fNotationBaseSystemId = new String[INITIAL_CHUNK_COUNT][]; // other information /** Element index mapping table. */ private QNameHashtable fElementIndexMap = new QNameHashtable(); /** Entity index mapping table. */ private QNameHashtable fEntityIndexMap = new QNameHashtable(); /** Notation index mapping table. */ private QNameHashtable fNotationIndexMap = new QNameHashtable(); // temp variables /** Mixed. */ private boolean fMixed; /** Temporary qualified name. */ private final QName fQName = new QName(); /** Temporary qualified name. */ private final QName fQName2 = new QName(); /** Temporary Attribute decl. */ protected final XMLAttributeDecl fAttributeDecl = new XMLAttributeDecl(); // for buildSyntaxTree method private int fLeafCount = 0; private int fEpsilonIndex = -1; /** Element declaration. */ private XMLElementDecl fElementDecl = new XMLElementDecl(); /** Entity declaration. */ private XMLEntityDecl fEntityDecl = new XMLEntityDecl(); /** Simple type. */ private XMLSimpleType fSimpleType = new XMLSimpleType(); /** Content spec node. */ private XMLContentSpec fContentSpec = new XMLContentSpec(); /** table of XMLElementDecl */ Hashtable fElementDeclTab = new Hashtable(); /** Children content model operation stack. */ private short[] fOpStack = null; /** Children content model index stack. */ private int[] fNodeIndexStack = null; /** Children content model previous node index stack. */ private int[] fPrevNodeIndexStack = null; /** Stack depth */ private int fDepth = 0; /** Entity stack. */ private boolean[] fPEntityStack = new boolean[4]; private int fPEDepth = 0; // additional fields(columns) for the element Decl pool in the Grammar /** flag if the elementDecl is External. */ private int fElementDeclIsExternal[][] = new int[INITIAL_CHUNK_COUNT][]; // additional fields(columns) for the attribute Decl pool in the Grammar /** flag if the AttributeDecl is External. */ private int fAttributeDeclIsExternal[][] = new int[INITIAL_CHUNK_COUNT][]; // for mixedElement method int valueIndex = -1; int prevNodeIndex = -1; int nodeIndex = -1; // // Constructors // /** Default constructor. */ public DTDGrammar(SymbolTable symbolTable, XMLDTDDescription desc) { fSymbolTable = symbolTable; fGrammarDescription = desc; } // <init>(SymbolTable) // Grammar methods // return the XMLDTDDescription object with which this is associated public XMLGrammarDescription getGrammarDescription() { return fGrammarDescription; } // getGrammarDescription(): XMLGrammarDescription // // Public methods // /** * Returns true if the specified element declaration is external. * * @param elementDeclIndex The element declaration index. */ public boolean getElementDeclIsExternal(int elementDeclIndex) { if (elementDeclIndex < 0) { return false; } int chunk = elementDeclIndex >> CHUNK_SHIFT; int index = elementDeclIndex & CHUNK_MASK; return (fElementDeclIsExternal[chunk][index] != 0); } // getElementDeclIsExternal(int):boolean /** * Returns true if the specified attribute declaration is external. * * @param attributeDeclIndex Attribute declaration index. */ public boolean getAttributeDeclIsExternal(int attributeDeclIndex) { if (attributeDeclIndex < 0) { return false; } int chunk = attributeDeclIndex >> CHUNK_SHIFT; int index = attributeDeclIndex & CHUNK_MASK; return (fAttributeDeclIsExternal[chunk][index] != 0); } public int getAttributeDeclIndex(int elementDeclIndex, String attributeDeclName) { if (elementDeclIndex == -1) { return -1; } int attDefIndex = getFirstAttributeDeclIndex(elementDeclIndex); while (attDefIndex != -1) { getAttributeDecl(attDefIndex, fAttributeDecl); if (fAttributeDecl.name.rawname == attributeDeclName || attributeDeclName.equals(fAttributeDecl.name.rawname) ) { return attDefIndex; } attDefIndex = getNextAttributeDeclIndex(attDefIndex); } return -1; } // getAttributeDeclIndex (int,QName) // // XMLDTDHandler methods // /** * The start of the DTD. * * @param locator The document locator, or null if the document * location cannot be reported during the parsing of * the document DTD. However, it is <em>strongly</em> * recommended that a locator be supplied that can * at least report the base system identifier of the * DTD. * * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. */ public void startDTD(XMLLocator locator, Augmentations augs) throws XNIException { //Initialize stack fOpStack = null; fNodeIndexStack = null; fPrevNodeIndexStack = null; } // startDTD(XMLLocator) /** * This method notifies of the start of an entity. The DTD has the * pseudo-name of "[dtd]" and parameter entity names start with '%'. * <p> * <strong>Note:</strong> Since the DTD is an entity, the handler * will be notified of the start of the DTD entity by calling the * startParameterEntity method with the entity name "[dtd]" <em>before</em> calling * the startDTD method. * * @param name The name of the parameter entity. * @param identifier The resource identifier. * @param encoding The auto-detected IANA encoding name of the entity * stream. This value will be null in those situations * where the entity encoding is not auto-detected (e.g. * internal parameter entities). * @param augs Additional information that may include infoset * augmentations. * * @throws XNIException Thrown by handler to signal an error. */ public void startParameterEntity(String name, XMLResourceIdentifier identifier, String encoding, Augmentations augs) throws XNIException { // keep track of this entity before fEntityDepth is increased if (fPEDepth == fPEntityStack.length) { boolean[] entityarray = new boolean[fPEntityStack.length * 2]; System.arraycopy(fPEntityStack, 0, entityarray, 0, fPEntityStack.length); fPEntityStack = entityarray; } fPEntityStack[fPEDepth] = fReadingExternalDTD; fPEDepth++; } // startParameterEntity(String,XMLResourceIdentifier,String,Augmentations) /** * The start of the DTD external subset. * * @param augs Additional information that may include infoset * augmentations. * * @throws XNIException Thrown by handler to signal an error. */ public void startExternalSubset(XMLResourceIdentifier identifier, Augmentations augs) throws XNIException { fReadingExternalDTD = true; } // startExternalSubset(Augmentations) /** * This method notifies the end of an entity. The DTD has the pseudo-name * of "[dtd]" and parameter entity names start with '%'. * <p> * <strong>Note:</strong> Since the DTD is an entity, the handler * will be notified of the end of the DTD entity by calling the * endEntity method with the entity name "[dtd]" <em>after</em> calling * the endDTD method. * * @param name The name of the entity. * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. */ public void endParameterEntity(String name, Augmentations augs) throws XNIException { fPEDepth--; fReadingExternalDTD = fPEntityStack[fPEDepth]; } // endParameterEntity(String,Augmentations) /** * The end of the DTD external subset. * * @param augs Additional information that may include infoset * augmentations. * * @throws XNIException Thrown by handler to signal an error. */ public void endExternalSubset(Augmentations augs) throws XNIException { fReadingExternalDTD = false; } // endExternalSubset(Augmentations) /** * An element declaration. * * @param name The name of the element. * @param contentModel The element content model. * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. */ public void elementDecl(String name, String contentModel, Augmentations augs) throws XNIException { XMLElementDecl tmpElementDecl = (XMLElementDecl) fElementDeclTab.get(name) ; // check if it is already defined if ( tmpElementDecl != null ) { if (tmpElementDecl.type == -1) { fCurrentElementIndex = getElementDeclIndex(name); } else { // duplicate element, ignored. return; } } else { fCurrentElementIndex = createElementDecl();//create element decl } XMLElementDecl elementDecl = new XMLElementDecl(); fQName.setValues(null, name, name, null); elementDecl.name.setValues(fQName); elementDecl.contentModelValidator = null; elementDecl.scope= -1; if (contentModel.equals("EMPTY")) { elementDecl.type = XMLElementDecl.TYPE_EMPTY; } else if (contentModel.equals("ANY")) { elementDecl.type = XMLElementDecl.TYPE_ANY; } else if (contentModel.startsWith("(") ) { if (contentModel.indexOf("#PCDATA") > 0 ) { elementDecl.type = XMLElementDecl.TYPE_MIXED; } else { elementDecl.type = XMLElementDecl.TYPE_CHILDREN; } } //add(or set) this elementDecl to the local cache this.fElementDeclTab.put(name, elementDecl ); fElementDecl = elementDecl; addContentSpecToElement(elementDecl); if ( DEBUG ) { System.out.println( "name = " + fElementDecl.name.localpart ); System.out.println( "Type = " + fElementDecl.type ); } setElementDecl(fCurrentElementIndex, fElementDecl );//set internal structure int chunk = fCurrentElementIndex >> CHUNK_SHIFT; int index = fCurrentElementIndex & CHUNK_MASK; ensureElementDeclCapacity(chunk); fElementDeclIsExternal[chunk][index] = (fReadingExternalDTD || fPEDepth > 0) ? 1 : 0; } // elementDecl(String,String) /** * An attribute declaration. * * @param elementName The name of the element that this attribute * is associated with. * @param attributeName The name of the attribute. * @param type The attribute type. This value will be one of * the following: "CDATA", "ENTITY", "ENTITIES", * "ENUMERATION", "ID", "IDREF", "IDREFS", * "NMTOKEN", "NMTOKENS", or "NOTATION". * @param enumeration If the type has the value "ENUMERATION", this * array holds the allowed attribute values; * otherwise, this array is null. * @param defaultType The attribute default type. This value will be * one of the following: "#FIXED", "#IMPLIED", * "#REQUIRED", or null. * @param defaultValue The attribute default value, or null if no * default value is specified. * @param nonNormalizedDefaultValue The attribute default value with no normalization * performed, or null if no default value is specified. * * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. */ public void attributeDecl(String elementName, String attributeName, String type, String[] enumeration, String defaultType, XMLString defaultValue, XMLString nonNormalizedDefaultValue, Augmentations augs) throws XNIException { if ( this.fElementDeclTab.containsKey( (String) elementName) ) { //if ElementDecl has already being created in the Grammar then remove from table, //this.fElementDeclTab.remove( (String) elementName ); } // then it is forward reference to a element decl, create the elementDecl first. else { fCurrentElementIndex = createElementDecl();//create element decl XMLElementDecl elementDecl = new XMLElementDecl(); elementDecl.name.setValues(null, elementName, elementName, null); elementDecl.scope= -1; //add(or set) this elementDecl to the local cache this.fElementDeclTab.put(elementName, elementDecl ); //set internal structure setElementDecl(fCurrentElementIndex, elementDecl ); } //Get Grammar index to grammar array int elementIndex = getElementDeclIndex(elementName); //return, when more than one definition is provided for the same attribute of given element type //only the first declaration is binding and later declarations are ignored if (getAttributeDeclIndex(elementIndex, attributeName) != -1) { return; } fCurrentAttributeIndex = createAttributeDecl();// Create current Attribute Decl fSimpleType.clear(); if ( defaultType != null ) { if ( defaultType.equals( "#FIXED") ) { fSimpleType.defaultType = XMLSimpleType.DEFAULT_TYPE_FIXED; } else if ( defaultType.equals( "#IMPLIED") ) { fSimpleType.defaultType = XMLSimpleType.DEFAULT_TYPE_IMPLIED; } else if ( defaultType.equals( "#REQUIRED") ) { fSimpleType.defaultType = XMLSimpleType.DEFAULT_TYPE_REQUIRED; } } if ( DEBUG ) { System.out.println("defaultvalue = " + defaultValue.toString() ); } fSimpleType.defaultValue = defaultValue!=null ? defaultValue.toString() : null; fSimpleType.nonNormalizedDefaultValue = nonNormalizedDefaultValue!=null ? nonNormalizedDefaultValue.toString() : null; fSimpleType.enumeration = enumeration; if (type.equals("CDATA")) { fSimpleType.type = XMLSimpleType.TYPE_CDATA; } else if ( type.equals("ID") ) { fSimpleType.type = XMLSimpleType.TYPE_ID; } else if ( type.startsWith("IDREF") ) { fSimpleType.type = XMLSimpleType.TYPE_IDREF; if (type.indexOf("S") > 0) { fSimpleType.list = true; } } else if (type.equals("ENTITIES")) { fSimpleType.type = XMLSimpleType.TYPE_ENTITY; fSimpleType.list = true; } else if (type.equals("ENTITY")) { fSimpleType.type = XMLSimpleType.TYPE_ENTITY; } else if (type.equals("NMTOKENS")) { fSimpleType.type = XMLSimpleType.TYPE_NMTOKEN; fSimpleType.list = true; } else if (type.equals("NMTOKEN")) { fSimpleType.type = XMLSimpleType.TYPE_NMTOKEN; } else if (type.startsWith("NOTATION") ) { fSimpleType.type = XMLSimpleType.TYPE_NOTATION; } else if (type.startsWith("ENUMERATION") ) { fSimpleType.type = XMLSimpleType.TYPE_ENUMERATION; } else { // REVISIT: Report error message. -Ac System.err.println("!!! unknown attribute type "+type); } // REVISIT: The datatype should be stored with the attribute value // and not special-cased in the XMLValidator. -Ac //fSimpleType.datatypeValidator = fDatatypeValidatorFactory.createDatatypeValidator(type, null, facets, fSimpleType.list); fQName.setValues(null, attributeName, attributeName, null); fAttributeDecl.setValues( fQName, fSimpleType, false ); setAttributeDecl(elementIndex, fCurrentAttributeIndex, fAttributeDecl); int chunk = fCurrentAttributeIndex >> CHUNK_SHIFT; int index = fCurrentAttributeIndex & CHUNK_MASK; ensureAttributeDeclCapacity(chunk); fAttributeDeclIsExternal[chunk][index] = (fReadingExternalDTD || fPEDepth > 0) ? 1 : 0; } // attributeDecl(String,String,String,String[],String,XMLString,XMLString, Augmentations) /** * An internal entity declaration. * * @param name The name of the entity. Parameter entity names start with * '%', whereas the name of a general entity is just the * entity name. * @param text The value of the entity. * @param nonNormalizedText The non-normalized value of the entity. This * value contains the same sequence of characters that was in * the internal entity declaration, without any entity * references expanded. * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. */ public void internalEntityDecl(String name, XMLString text, XMLString nonNormalizedText, Augmentations augs) throws XNIException { int entityIndex = getEntityDeclIndex(name); if( entityIndex == -1){ entityIndex = createEntityDecl(); boolean isPE = name.startsWith("%"); boolean inExternal = (fReadingExternalDTD || fPEDepth > 0); XMLEntityDecl entityDecl = new XMLEntityDecl(); entityDecl.setValues(name,null,null, null, null, text.toString(), isPE, inExternal); setEntityDecl(entityIndex, entityDecl); } } // internalEntityDecl(String,XMLString,XMLString) /** * An external entity declaration. * * @param name The name of the entity. Parameter entity names start * with '%', whereas the name of a general entity is just * the entity name. * @param identifier An object containing all location information * pertinent to this external entity declaration. * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. */ public void externalEntityDecl(String name, XMLResourceIdentifier identifier, Augmentations augs) throws XNIException { int entityIndex = getEntityDeclIndex(name); if( entityIndex == -1){ entityIndex = createEntityDecl(); boolean isPE = name.startsWith("%"); boolean inExternal = (fReadingExternalDTD || fPEDepth > 0); XMLEntityDecl entityDecl = new XMLEntityDecl(); entityDecl.setValues(name, identifier.getPublicId(), identifier.getLiteralSystemId(), identifier.getBaseSystemId(), null, null, isPE, inExternal); setEntityDecl(entityIndex, entityDecl); } } // externalEntityDecl(String, XMLResourceIdentifier, Augmentations) /** * An unparsed entity declaration. * * @param name The name of the entity. * @param identifier An object containing all location information * pertinent to this entity. * @param notation The name of the notation. * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. */ public void unparsedEntityDecl(String name, XMLResourceIdentifier identifier, String notation, Augmentations augs) throws XNIException { XMLEntityDecl entityDecl = new XMLEntityDecl(); boolean isPE = name.startsWith("%"); boolean inExternal = (fReadingExternalDTD || fPEDepth > 0); entityDecl.setValues(name,identifier.getPublicId(),identifier.getLiteralSystemId(), identifier.getBaseSystemId(), notation, null, isPE, inExternal); int entityIndex = getEntityDeclIndex(name); if (entityIndex == -1) { entityIndex = createEntityDecl(); setEntityDecl(entityIndex, entityDecl); } } // unparsedEntityDecl(String,StringXMLResourceIdentifier,Augmentations) /** * A notation declaration * * @param name The name of the notation. * @param identifier An object containing all location information * pertinent to this notation. * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. */ public void notationDecl(String name, XMLResourceIdentifier identifier, Augmentations augs) throws XNIException { XMLNotationDecl notationDecl = new XMLNotationDecl(); notationDecl.setValues(name,identifier.getPublicId(),identifier.getLiteralSystemId(), identifier.getBaseSystemId()); int notationIndex = getNotationDeclIndex(name); if (notationIndex == -1) { notationIndex = createNotationDecl(); setNotationDecl(notationIndex, notationDecl); } } // notationDecl(String,XMLResourceIdentifier,Augmentations) /** * The end of the DTD. * * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. */ public void endDTD(Augmentations augs) throws XNIException { fIsImmutable = true; // make sure our description contains useful stuff... if (fGrammarDescription.getRootName() == null) { // we don't know what the root is; so use possibleRoots... int chunk, index = 0; String currName = null; final int size = fElementDeclCount; ArrayList elements = new ArrayList(size); for (int i = 0; i < size; ++i) { chunk = i >> CHUNK_SHIFT; index = i & CHUNK_MASK; currName = fElementDeclName[chunk][index].rawname; elements.add(currName); } fGrammarDescription.setPossibleRoots(elements); } } // endDTD() // sets the source of this handler public void setDTDSource(XMLDTDSource source) { fDTDSource = source; } // setDTDSource(XMLDTDSource) // returns the source of this handler public XMLDTDSource getDTDSource() { return fDTDSource; } // getDTDSource(): XMLDTDSource // no-op methods /** * Notifies of the presence of a TextDecl line in an entity. If present, * this method will be called immediately following the startEntity call. * <p> * <strong>Note:</strong> This method is only called for external * parameter entities referenced in the DTD. * * @param version The XML version, or null if not specified. * @param encoding The IANA encoding name of the entity. * * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. */ public void textDecl(String version, String encoding, Augmentations augs) throws XNIException {} /** * A comment. * * @param text The text in the comment. * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by application to signal an error. */ public void comment(XMLString text, Augmentations augs) throws XNIException {} /** * A processing instruction. Processing instructions consist of a * target name and, optionally, text data. The data is only meaningful * to the application. * <p> * Typically, a processing instruction's data will contain a series * of pseudo-attributes. These pseudo-attributes follow the form of * element attributes but are <strong>not</strong> parsed or presented * to the application as anything other than text. The application is * responsible for parsing the data. * * @param target The target. * @param data The data or null if none specified. * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. */ public void processingInstruction(String target, XMLString data, Augmentations augs) throws XNIException {} /** * The start of an attribute list. * * @param elementName The name of the element that this attribute * list is associated with. * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. */ public void startAttlist(String elementName, Augmentations augs) throws XNIException {} /** * The end of an attribute list. * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. */ public void endAttlist(Augmentations augs) throws XNIException {} /** * The start of a conditional section. * * @param type The type of the conditional section. This value will * either be CONDITIONAL_INCLUDE or CONDITIONAL_IGNORE. * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. * * @see XMLDTDHandler#CONDITIONAL_INCLUDE * @see XMLDTDHandler#CONDITIONAL_IGNORE */ public void startConditional(short type, Augmentations augs) throws XNIException {} /** * Characters within an IGNORE conditional section. * * @param text The ignored text. * @param augs Additional information that may include infoset * augmentations. */ public void ignoredCharacters(XMLString text, Augmentations augs) throws XNIException {} /** * The end of a conditional section. * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. */ public void endConditional(Augmentations augs) throws XNIException {} // // XMLDTDContentModelHandler methods // // set content model source public void setDTDContentModelSource(XMLDTDContentModelSource source) { fDTDContentModelSource = source; } // get content model source public XMLDTDContentModelSource getDTDContentModelSource() { return fDTDContentModelSource; } /** * The start of a content model. Depending on the type of the content * model, specific methods may be called between the call to the * startContentModel method and the call to the endContentModel method. * * @param elementName The name of the element. * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. */ public void startContentModel(String elementName, Augmentations augs) throws XNIException { XMLElementDecl elementDecl = (XMLElementDecl) this.fElementDeclTab.get( elementName); if ( elementDecl != null ) { fElementDecl = elementDecl; } fDepth = 0; initializeContentModelStack(); } // startContentModel(String) /** * A start of either a mixed or children content model. A mixed * content model will immediately be followed by a call to the * <code>pcdata()</code> method. A children content model will * contain additional groups and/or elements. * * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. * * @see #any * @see #empty */ public void startGroup(Augmentations augs) throws XNIException { fDepth++; initializeContentModelStack(); fMixed = false; } // startGroup() /** * The appearance of "#PCDATA" within a group signifying a * mixed content model. This method will be the first called * following the content model's <code>startGroup()</code>. * *@param augs Additional information that may include infoset * augmentations. * * @throws XNIException Thrown by handler to signal an error. * * @see #startGroup */ public void pcdata(Augmentations augs) throws XNIException { fMixed = true; } // pcdata() /** * A referenced element in a mixed or children content model. * * @param elementName The name of the referenced element. * @param augs Additional information that may include infoset * augmentations. * * @throws XNIException Thrown by handler to signal an error. */ public void element(String elementName, Augmentations augs) throws XNIException { if (fMixed) { if (fNodeIndexStack[fDepth] == -1 ) { fNodeIndexStack[fDepth] = addUniqueLeafNode(elementName); } else { fNodeIndexStack[fDepth] = addContentSpecNode(XMLContentSpec.CONTENTSPECNODE_CHOICE, fNodeIndexStack[fDepth], addUniqueLeafNode(elementName)); } } else { fNodeIndexStack[fDepth] = addContentSpecNode(XMLContentSpec.CONTENTSPECNODE_LEAF, elementName); } } // element(String) /** * The separator between choices or sequences of a mixed or children * content model. * * @param separator The type of children separator. * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. * * @see org.apache.xerces.xni.XMLDTDContentModelHandler#SEPARATOR_CHOICE * @see org.apache.xerces.xni.XMLDTDContentModelHandler#SEPARATOR_SEQUENCE */ public void separator(short separator, Augmentations augs) throws XNIException { if (!fMixed) { if (fOpStack[fDepth] != XMLContentSpec.CONTENTSPECNODE_SEQ && separator == XMLDTDContentModelHandler.SEPARATOR_CHOICE ) { if (fPrevNodeIndexStack[fDepth] != -1) { fNodeIndexStack[fDepth] = addContentSpecNode(fOpStack[fDepth], fPrevNodeIndexStack[fDepth], fNodeIndexStack[fDepth]); } fPrevNodeIndexStack[fDepth] = fNodeIndexStack[fDepth]; fOpStack[fDepth] = XMLContentSpec.CONTENTSPECNODE_CHOICE; } else if (fOpStack[fDepth] != XMLContentSpec.CONTENTSPECNODE_CHOICE && separator == XMLDTDContentModelHandler.SEPARATOR_SEQUENCE) { if (fPrevNodeIndexStack[fDepth] != -1) { fNodeIndexStack[fDepth] = addContentSpecNode(fOpStack[fDepth], fPrevNodeIndexStack[fDepth], fNodeIndexStack[fDepth]); } fPrevNodeIndexStack[fDepth] = fNodeIndexStack[fDepth]; fOpStack[fDepth] = XMLContentSpec.CONTENTSPECNODE_SEQ; } } } // separator(short) /** * The occurrence count for a child in a children content model or * for the mixed content model group. * * @param occurrence The occurrence count for the last element * or group. * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. * * @see org.apache.xerces.xni.XMLDTDContentModelHandler#OCCURS_ZERO_OR_ONE * @see org.apache.xerces.xni.XMLDTDContentModelHandler#OCCURS_ZERO_OR_MORE * @see org.apache.xerces.xni.XMLDTDContentModelHandler#OCCURS_ONE_OR_MORE */ public void occurrence(short occurrence, Augmentations augs) throws XNIException { if (!fMixed) { if (occurrence == XMLDTDContentModelHandler.OCCURS_ZERO_OR_ONE ) { fNodeIndexStack[fDepth] = addContentSpecNode(XMLContentSpec.CONTENTSPECNODE_ZERO_OR_ONE, fNodeIndexStack[fDepth], -1); } else if ( occurrence == XMLDTDContentModelHandler.OCCURS_ZERO_OR_MORE ) { fNodeIndexStack[fDepth] = addContentSpecNode(XMLContentSpec.CONTENTSPECNODE_ZERO_OR_MORE, fNodeIndexStack[fDepth], -1 ); } else if ( occurrence == XMLDTDContentModelHandler.OCCURS_ONE_OR_MORE) { fNodeIndexStack[fDepth] = addContentSpecNode(XMLContentSpec.CONTENTSPECNODE_ONE_OR_MORE, fNodeIndexStack[fDepth], -1 ); } } } // occurrence(short) /** * The end of a group for mixed or children content models. * * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. */ public void endGroup(Augmentations augs) throws XNIException { if (!fMixed) { if (fPrevNodeIndexStack[fDepth] != -1) { fNodeIndexStack[fDepth] = addContentSpecNode(fOpStack[fDepth], fPrevNodeIndexStack[fDepth], fNodeIndexStack[fDepth]); } int nodeIndex = fNodeIndexStack[fDepth--]; fNodeIndexStack[fDepth] = nodeIndex; } } // endGroup() // no-op methods /** * A content model of ANY. * * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. * * @see #empty * @see #startGroup */ public void any(Augmentations augs) throws XNIException {} /** * A content model of EMPTY. * * @param augs Additional information that may include infoset * augmentations. * @throws XNIException Thrown by handler to signal an error. * * @see #any * @see #startGroup */ public void empty(Augmentations augs) throws XNIException {} /** * The end of a content model. * @param augs Additional information that may include infoset * augmentations. * * @throws XNIException Thrown by handler to signal an error. */ public void endContentModel(Augmentations augs) throws XNIException {} // // Grammar methods // /** Returns true if this grammar is namespace aware. */ public boolean isNamespaceAware() { return false; } // isNamespaceAware():boolean /** Returns the symbol table. */ public SymbolTable getSymbolTable() { return fSymbolTable; } // getSymbolTable():SymbolTable /** * Returns the index of the first element declaration. This index * is then used to query more information about the element declaration. * * @see #getNextElementDeclIndex * @see #getElementDecl */ public int getFirstElementDeclIndex() { return fElementDeclCount >= 0 ? 0 : -1; } // getFirstElementDeclIndex():int /** * Returns the next index of the element declaration following the * specified element declaration. * * @param elementDeclIndex The element declaration index. */ public int getNextElementDeclIndex(int elementDeclIndex) { return elementDeclIndex < fElementDeclCount - 1 ? elementDeclIndex + 1 : -1; } // getNextElementDeclIndex(int):int /** * getElementDeclIndex * * @param elementDeclName * * @return index of the elementDeclName in scope */ public int getElementDeclIndex(String elementDeclName) { int mapping = fElementIndexMap.get(elementDeclName); //System.out.println("getElementDeclIndex("+elementDeclName+") -> "+mapping); return mapping; } // getElementDeclIndex(String):int /** Returns the element decl index. * @param elementDeclQName qualilfied name of the element */ public int getElementDeclIndex(QName elementDeclQName) { return getElementDeclIndex(elementDeclQName.rawname); } // getElementDeclIndex(QName):int /** make separate function for getting contentSpecType of element. * we can avoid setting of the element values. */ public short getContentSpecType(int elementIndex){ if (elementIndex < 0 || elementIndex >= fElementDeclCount) { return -1 ; } int chunk = elementIndex >> CHUNK_SHIFT; int index = elementIndex & CHUNK_MASK; if(fElementDeclType[chunk][index] == -1){ return -1 ; } else{ return (short) (fElementDeclType[chunk][index] & LIST_MASK); } }//getContentSpecType /** * getElementDecl * * @param elementDeclIndex * @param elementDecl The values of this structure are set by this call. * * @return True if find the element, False otherwise. */ public boolean getElementDecl(int elementDeclIndex, XMLElementDecl elementDecl) { if (elementDeclIndex < 0 || elementDeclIndex >= fElementDeclCount) { return false; } int chunk = elementDeclIndex >> CHUNK_SHIFT; int index = elementDeclIndex & CHUNK_MASK; elementDecl.name.setValues(fElementDeclName[chunk][index]); if (fElementDeclType[chunk][index] == -1) { elementDecl.type = -1; elementDecl.simpleType.list = false; } else { elementDecl.type = (short) (fElementDeclType[chunk][index] & LIST_MASK); elementDecl.simpleType.list = (fElementDeclType[chunk][index] & LIST_FLAG) != 0; } /* Validators are null until we add that code */ if (elementDecl.type == XMLElementDecl.TYPE_CHILDREN || elementDecl.type == XMLElementDecl.TYPE_MIXED) { elementDecl.contentModelValidator = getElementContentModelValidator(elementDeclIndex); } elementDecl.simpleType.datatypeValidator = null; elementDecl.simpleType.defaultType = -1; elementDecl.simpleType.defaultValue = null; return true; } // getElementDecl(int,XMLElementDecl):boolean QName getElementDeclName(int elementDeclIndex) { if (elementDeclIndex < 0 || elementDeclIndex >= fElementDeclCount) { return null; } int chunk = elementDeclIndex >> CHUNK_SHIFT; int index = elementDeclIndex & CHUNK_MASK; return fElementDeclName[chunk][index]; } // REVISIT: Make this getAttributeDeclCount/getAttributeDeclAt. -Ac /** * getFirstAttributeDeclIndex * * @param elementDeclIndex * * @return index of the first attribute for element declaration elementDeclIndex */ public int getFirstAttributeDeclIndex(int elementDeclIndex) { int chunk = elementDeclIndex >> CHUNK_SHIFT; int index = elementDeclIndex & CHUNK_MASK; return fElementDeclFirstAttributeDeclIndex[chunk][index]; } // getFirstAttributeDeclIndex /** * getNextAttributeDeclIndex * * @param attributeDeclIndex * * @return index of the next attribute of the attribute at attributeDeclIndex */ public int getNextAttributeDeclIndex(int attributeDeclIndex) { int chunk = attributeDeclIndex >> CHUNK_SHIFT; int index = attributeDeclIndex & CHUNK_MASK; return fAttributeDeclNextAttributeDeclIndex[chunk][index]; } // getNextAttributeDeclIndex /** * getAttributeDecl * * @param attributeDeclIndex * @param attributeDecl The values of this structure are set by this call. * * @return true if getAttributeDecl was able to fill in the value of attributeDecl */ public boolean getAttributeDecl(int attributeDeclIndex, XMLAttributeDecl attributeDecl) { if (attributeDeclIndex < 0 || attributeDeclIndex >= fAttributeDeclCount) { return false; } int chunk = attributeDeclIndex >> CHUNK_SHIFT; int index = attributeDeclIndex & CHUNK_MASK; attributeDecl.name.setValues(fAttributeDeclName[chunk][index]); short attributeType; boolean isList; if (fAttributeDeclType[chunk][index] == -1) { attributeType = -1; isList = false; } else { attributeType = (short) (fAttributeDeclType[chunk][index] & LIST_MASK); isList = (fAttributeDeclType[chunk][index] & LIST_FLAG) != 0; } attributeDecl.simpleType.setValues(attributeType,fAttributeDeclName[chunk][index].localpart, fAttributeDeclEnumeration[chunk][index], isList, fAttributeDeclDefaultType[chunk][index], fAttributeDeclDefaultValue[chunk][index], fAttributeDeclNonNormalizedDefaultValue[chunk][index], fAttributeDeclDatatypeValidator[chunk][index]); return true; } // getAttributeDecl /** * Returns whether the given attribute is of type CDATA or not * * @param elName The element name. * @param atName The attribute name. * * @return true if the attribute is of type CDATA */ public boolean isCDATAAttribute(QName elName, QName atName) { int elDeclIdx = getElementDeclIndex(elName); if (getAttributeDecl(elDeclIdx, fAttributeDecl) && fAttributeDecl.simpleType.type != XMLSimpleType.TYPE_CDATA){ return false; } return true; } /** * getEntityDeclIndex * * @param entityDeclName * * @return the index of the EntityDecl */ public int getEntityDeclIndex(String entityDeclName) { if (entityDeclName == null) { return -1; } return fEntityIndexMap.get(entityDeclName); } // getEntityDeclIndex /** * getEntityDecl * * @param entityDeclIndex * @param entityDecl * * @return true if getEntityDecl was able to fill entityDecl with the contents of the entity * with index entityDeclIndex */ public boolean getEntityDecl(int entityDeclIndex, XMLEntityDecl entityDecl) { if (entityDeclIndex < 0 || entityDeclIndex >= fEntityCount) { return false; } int chunk = entityDeclIndex >> CHUNK_SHIFT; int index = entityDeclIndex & CHUNK_MASK; entityDecl.setValues(fEntityName[chunk][index], fEntityPublicId[chunk][index], fEntitySystemId[chunk][index], fEntityBaseSystemId[chunk][index], fEntityNotation[chunk][index], fEntityValue[chunk][index], fEntityIsPE[chunk][index] == 0 ? false : true , fEntityInExternal[chunk][index] == 0 ? false : true ); return true; } // getEntityDecl /** * getNotationDeclIndex * * @param notationDeclName * * @return the index if found a notation with the name, otherwise -1. */ public int getNotationDeclIndex(String notationDeclName) { if (notationDeclName == null) { return -1; } return fNotationIndexMap.get(notationDeclName); } // getNotationDeclIndex /** * getNotationDecl * * @param notationDeclIndex * @param notationDecl * * @return return true of getNotationDecl can fill notationDecl with information about * the notation at notationDeclIndex. */ public boolean getNotationDecl(int notationDeclIndex, XMLNotationDecl notationDecl) { if (notationDeclIndex < 0 || notationDeclIndex >= fNotationCount) { return false; } int chunk = notationDeclIndex >> CHUNK_SHIFT; int index = notationDeclIndex & CHUNK_MASK; notationDecl.setValues(fNotationName[chunk][index], fNotationPublicId[chunk][index], fNotationSystemId[chunk][index], fNotationBaseSystemId[chunk][index]); return true; } // getNotationDecl /** * getContentSpec * * @param contentSpecIndex * @param contentSpec * * @return true if find the requested contentSpec node, false otherwise */ public boolean getContentSpec(int contentSpecIndex, XMLContentSpec contentSpec) { if (contentSpecIndex < 0 || contentSpecIndex >= fContentSpecCount ) return false; int chunk = contentSpecIndex >> CHUNK_SHIFT; int index = contentSpecIndex & CHUNK_MASK; contentSpec.type = fContentSpecType[chunk][index]; contentSpec.value = fContentSpecValue[chunk][index]; contentSpec.otherValue = fContentSpecOtherValue[chunk][index]; return true; } /** * Returns the index to the content spec for the given element * declaration, or <code>-1</code> if the element declaration * index was invalid. */ public int getContentSpecIndex(int elementDeclIndex) { if (elementDeclIndex < 0 || elementDeclIndex >= fElementDeclCount) { return -1; } final int chunk = elementDeclIndex >> CHUNK_SHIFT; final int index = elementDeclIndex & CHUNK_MASK; return fElementDeclContentSpecIndex[chunk][index]; } /** * getContentSpecAsString * * @param elementDeclIndex * * @return String */ public String getContentSpecAsString(int elementDeclIndex){ if (elementDeclIndex < 0 || elementDeclIndex >= fElementDeclCount) { return null; } int chunk = elementDeclIndex >> CHUNK_SHIFT; int index = elementDeclIndex & CHUNK_MASK; int contentSpecIndex = fElementDeclContentSpecIndex[chunk][index]; // lookup content spec node XMLContentSpec contentSpec = new XMLContentSpec(); if (getContentSpec(contentSpecIndex, contentSpec)) { // build string StringBuffer str = new StringBuffer(); int parentContentSpecType = contentSpec.type & 0x0f; int nextContentSpec; switch (parentContentSpecType) { case XMLContentSpec.CONTENTSPECNODE_LEAF: { str.append('('); if (contentSpec.value == null && contentSpec.otherValue == null) { str.append("#PCDATA"); } else { str.append(contentSpec.value); } str.append(')'); break; } case XMLContentSpec.CONTENTSPECNODE_ZERO_OR_ONE: { getContentSpec(((int[])contentSpec.value)[0], contentSpec); nextContentSpec = contentSpec.type; if (nextContentSpec == XMLContentSpec.CONTENTSPECNODE_LEAF) { str.append('('); str.append(contentSpec.value); str.append(')'); } else if( nextContentSpec == XMLContentSpec.CONTENTSPECNODE_ONE_OR_MORE || nextContentSpec == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_MORE || nextContentSpec == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_ONE ) { str.append('(' ); appendContentSpec(contentSpec, str, true, parentContentSpecType ); str.append(')'); } else { appendContentSpec(contentSpec, str, true, parentContentSpecType ); } str.append('?'); break; } case XMLContentSpec.CONTENTSPECNODE_ZERO_OR_MORE: { getContentSpec(((int[])contentSpec.value)[0], contentSpec); nextContentSpec = contentSpec.type; if ( nextContentSpec == XMLContentSpec.CONTENTSPECNODE_LEAF) { str.append('('); if (contentSpec.value == null && contentSpec.otherValue == null) { str.append("#PCDATA"); } else if (contentSpec.otherValue != null) { str.append("##any:uri=").append(contentSpec.otherValue); } else if (contentSpec.value == null) { str.append("##any"); } else { appendContentSpec(contentSpec, str, true, parentContentSpecType ); } str.append(')'); } else if( nextContentSpec == XMLContentSpec.CONTENTSPECNODE_ONE_OR_MORE || nextContentSpec == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_MORE || nextContentSpec == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_ONE ) { str.append('(' ); appendContentSpec(contentSpec, str, true, parentContentSpecType ); str.append(')'); } else { appendContentSpec(contentSpec, str, true, parentContentSpecType ); } str.append('*'); break; } case XMLContentSpec.CONTENTSPECNODE_ONE_OR_MORE: { getContentSpec(((int[])contentSpec.value)[0], contentSpec); nextContentSpec = contentSpec.type; if ( nextContentSpec == XMLContentSpec.CONTENTSPECNODE_LEAF) { str.append('('); if (contentSpec.value == null && contentSpec.otherValue == null) { str.append("#PCDATA"); } else if (contentSpec.otherValue != null) { str.append("##any:uri=").append(contentSpec.otherValue); } else if (contentSpec.value == null) { str.append("##any"); } else { str.append(contentSpec.value); } str.append(')'); } else if( nextContentSpec == XMLContentSpec.CONTENTSPECNODE_ONE_OR_MORE || nextContentSpec == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_MORE || nextContentSpec == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_ONE ) { str.append('(' ); appendContentSpec(contentSpec, str, true, parentContentSpecType ); str.append(')'); } else { appendContentSpec(contentSpec, str, true, parentContentSpecType); } str.append('+'); break; } case XMLContentSpec.CONTENTSPECNODE_CHOICE: case XMLContentSpec.CONTENTSPECNODE_SEQ: { appendContentSpec(contentSpec, str, true, parentContentSpecType ); break; } case XMLContentSpec.CONTENTSPECNODE_ANY: { str.append("##any"); if (contentSpec.otherValue != null) { str.append(":uri="); str.append(contentSpec.otherValue); } break; } case XMLContentSpec.CONTENTSPECNODE_ANY_OTHER: { str.append("##other:uri="); str.append(contentSpec.otherValue); break; } case XMLContentSpec.CONTENTSPECNODE_ANY_LOCAL: { str.append("##local"); break; } default: { str.append("???"); } } // switch type // return string return str.toString(); } // not found return null; } // getContentSpecAsString(int):String // debugging public void printElements( ) { int elementDeclIndex = 0; XMLElementDecl elementDecl = new XMLElementDecl(); while (getElementDecl(elementDeclIndex++, elementDecl)) { System.out.println("element decl: "+elementDecl.name+ ", "+ elementDecl.name.rawname ); // ", "+ elementDecl.contentModelValidator.toString()); } } public void printAttributes(int elementDeclIndex) { int attributeDeclIndex = getFirstAttributeDeclIndex(elementDeclIndex); System.out.print(elementDeclIndex); System.out.print(" ["); while (attributeDeclIndex != -1) { System.out.print(' '); System.out.print(attributeDeclIndex); printAttribute(attributeDeclIndex); attributeDeclIndex = getNextAttributeDeclIndex(attributeDeclIndex); if (attributeDeclIndex != -1) { System.out.print(","); } } System.out.println(" ]"); } // // Protected methods // /** * Adds the content spec to the given element declaration. */ protected void addContentSpecToElement(XMLElementDecl elementDecl) { if ((fDepth == 0 || (fDepth == 1 && elementDecl.type == XMLElementDecl.TYPE_MIXED)) && fNodeIndexStack != null) { if (elementDecl.type == XMLElementDecl.TYPE_MIXED) { int pcdata = addUniqueLeafNode(null); if (fNodeIndexStack[0] == -1) { fNodeIndexStack[0] = pcdata; } else { fNodeIndexStack[0] = addContentSpecNode(XMLContentSpec.CONTENTSPECNODE_CHOICE, pcdata, fNodeIndexStack[0]); } } setContentSpecIndex(fCurrentElementIndex, fNodeIndexStack[fDepth]); } } /** * getElementContentModelValidator * * @param elementDeclIndex * * @return its ContentModelValidator if any. */ protected ContentModelValidator getElementContentModelValidator(int elementDeclIndex) { int chunk = elementDeclIndex >> CHUNK_SHIFT; int index = elementDeclIndex & CHUNK_MASK; ContentModelValidator contentModel = fElementDeclContentModelValidator[chunk][index]; // If we have one, just return that. Otherwise, gotta create one if (contentModel != null) { return contentModel; } int contentType = fElementDeclType[chunk][index]; if (contentType == XMLElementDecl.TYPE_SIMPLE) { return null; } // Get the type of content this element has int contentSpecIndex = fElementDeclContentSpecIndex[chunk][index]; /*** if ( contentSpecIndex == -1 ) return null; /***/ XMLContentSpec contentSpec = new XMLContentSpec(); getContentSpec( contentSpecIndex, contentSpec ); // And create the content model according to the spec type if ( contentType == XMLElementDecl.TYPE_MIXED ) { // // Just create a mixel content model object. This type of // content model is optimized for mixed content validation. // ChildrenList children = new ChildrenList(); contentSpecTree(contentSpecIndex, contentSpec, children); contentModel = new MixedContentModel(children.qname, children.type, 0, children.length, false); } else if (contentType == XMLElementDecl.TYPE_CHILDREN) { // This method will create an optimal model for the complexity // of the element's defined model. If its simple, it will create // a SimpleContentModel object. If its a simple list, it will // create a SimpleListContentModel object. If its complex, it // will create a DFAContentModel object. // contentModel = createChildModel(contentSpecIndex); } else { throw new RuntimeException("Unknown content type for a element decl " + "in getElementContentModelValidator() in AbstractDTDGrammar class"); } // Add the new model to the content model for this element fElementDeclContentModelValidator[chunk][index] = contentModel; return contentModel; } // getElementContentModelValidator(int):ContentModelValidator protected int createElementDecl() { int chunk = fElementDeclCount >> CHUNK_SHIFT; int index = fElementDeclCount & CHUNK_MASK; ensureElementDeclCapacity(chunk); fElementDeclName[chunk][index] = new QName(); fElementDeclType[chunk][index] = -1; fElementDeclContentModelValidator[chunk][index] = null; fElementDeclFirstAttributeDeclIndex[chunk][index] = -1; fElementDeclLastAttributeDeclIndex[chunk][index] = -1; return fElementDeclCount++; } protected void setElementDecl(int elementDeclIndex, XMLElementDecl elementDecl) { if (elementDeclIndex < 0 || elementDeclIndex >= fElementDeclCount) { return; } int chunk = elementDeclIndex >> CHUNK_SHIFT; int index = elementDeclIndex & CHUNK_MASK; fElementDeclName[chunk][index].setValues(elementDecl.name); fElementDeclType[chunk][index] = elementDecl.type; fElementDeclContentModelValidator[chunk][index] = elementDecl.contentModelValidator; if (elementDecl.simpleType.list == true ) { fElementDeclType[chunk][index] |= LIST_FLAG; } fElementIndexMap.put(elementDecl.name.rawname, elementDeclIndex); } protected void putElementNameMapping(QName name, int scope, int elementDeclIndex) { } protected void setFirstAttributeDeclIndex(int elementDeclIndex, int newFirstAttrIndex){ if (elementDeclIndex < 0 || elementDeclIndex >= fElementDeclCount) { return; } int chunk = elementDeclIndex >> CHUNK_SHIFT; int index = elementDeclIndex & CHUNK_MASK; fElementDeclFirstAttributeDeclIndex[chunk][index] = newFirstAttrIndex; } protected void setContentSpecIndex(int elementDeclIndex, int contentSpecIndex){ if (elementDeclIndex < 0 || elementDeclIndex >= fElementDeclCount) { return; } int chunk = elementDeclIndex >> CHUNK_SHIFT; int index = elementDeclIndex & CHUNK_MASK; fElementDeclContentSpecIndex[chunk][index] = contentSpecIndex; } protected int createAttributeDecl() { int chunk = fAttributeDeclCount >> CHUNK_SHIFT; int index = fAttributeDeclCount & CHUNK_MASK; ensureAttributeDeclCapacity(chunk); fAttributeDeclName[chunk][index] = new QName(); fAttributeDeclType[chunk][index] = -1; fAttributeDeclDatatypeValidator[chunk][index] = null; fAttributeDeclEnumeration[chunk][index] = null; fAttributeDeclDefaultType[chunk][index] = XMLSimpleType.DEFAULT_TYPE_IMPLIED; fAttributeDeclDefaultValue[chunk][index] = null; fAttributeDeclNonNormalizedDefaultValue[chunk][index] = null; fAttributeDeclNextAttributeDeclIndex[chunk][index] = -1; return fAttributeDeclCount++; } protected void setAttributeDecl(int elementDeclIndex, int attributeDeclIndex, XMLAttributeDecl attributeDecl) { int attrChunk = attributeDeclIndex >> CHUNK_SHIFT; int attrIndex = attributeDeclIndex & CHUNK_MASK; fAttributeDeclName[attrChunk][attrIndex].setValues(attributeDecl.name); fAttributeDeclType[attrChunk][attrIndex] = attributeDecl.simpleType.type; if (attributeDecl.simpleType.list) { fAttributeDeclType[attrChunk][attrIndex] |= LIST_FLAG; } fAttributeDeclEnumeration[attrChunk][attrIndex] = attributeDecl.simpleType.enumeration; fAttributeDeclDefaultType[attrChunk][attrIndex] = attributeDecl.simpleType.defaultType; fAttributeDeclDatatypeValidator[attrChunk][attrIndex] = attributeDecl.simpleType.datatypeValidator; fAttributeDeclDefaultValue[attrChunk][attrIndex] = attributeDecl.simpleType.defaultValue; fAttributeDeclNonNormalizedDefaultValue[attrChunk][attrIndex] = attributeDecl.simpleType.nonNormalizedDefaultValue; int elemChunk = elementDeclIndex >> CHUNK_SHIFT; int elemIndex = elementDeclIndex & CHUNK_MASK; int index = fElementDeclFirstAttributeDeclIndex[elemChunk][elemIndex]; while (index != -1) { if (index == attributeDeclIndex) { break; } attrChunk = index >> CHUNK_SHIFT; attrIndex = index & CHUNK_MASK; index = fAttributeDeclNextAttributeDeclIndex[attrChunk][attrIndex]; } if (index == -1) { if (fElementDeclFirstAttributeDeclIndex[elemChunk][elemIndex] == -1) { fElementDeclFirstAttributeDeclIndex[elemChunk][elemIndex] = attributeDeclIndex; } else { index = fElementDeclLastAttributeDeclIndex[elemChunk][elemIndex]; attrChunk = index >> CHUNK_SHIFT; attrIndex = index & CHUNK_MASK; fAttributeDeclNextAttributeDeclIndex[attrChunk][attrIndex] = attributeDeclIndex; } fElementDeclLastAttributeDeclIndex[elemChunk][elemIndex] = attributeDeclIndex; } } protected int createContentSpec() { int chunk = fContentSpecCount >> CHUNK_SHIFT; int index = fContentSpecCount & CHUNK_MASK; ensureContentSpecCapacity(chunk); fContentSpecType[chunk][index] = -1; fContentSpecValue[chunk][index] = null; fContentSpecOtherValue[chunk][index] = null; return fContentSpecCount++; } protected void setContentSpec(int contentSpecIndex, XMLContentSpec contentSpec) { int chunk = contentSpecIndex >> CHUNK_SHIFT; int index = contentSpecIndex & CHUNK_MASK; fContentSpecType[chunk][index] = contentSpec.type; fContentSpecValue[chunk][index] = contentSpec.value; fContentSpecOtherValue[chunk][index] = contentSpec.otherValue; } protected int createEntityDecl() { int chunk = fEntityCount >> CHUNK_SHIFT; int index = fEntityCount & CHUNK_MASK; ensureEntityDeclCapacity(chunk); fEntityIsPE[chunk][index] = 0; fEntityInExternal[chunk][index] = 0; return fEntityCount++; } protected void setEntityDecl(int entityDeclIndex, XMLEntityDecl entityDecl) { int chunk = entityDeclIndex >> CHUNK_SHIFT; int index = entityDeclIndex & CHUNK_MASK; fEntityName[chunk][index] = entityDecl.name; fEntityValue[chunk][index] = entityDecl.value; fEntityPublicId[chunk][index] = entityDecl.publicId; fEntitySystemId[chunk][index] = entityDecl.systemId; fEntityBaseSystemId[chunk][index] = entityDecl.baseSystemId; fEntityNotation[chunk][index] = entityDecl.notation; fEntityIsPE[chunk][index] = entityDecl.isPE ? (byte)1 : (byte)0; fEntityInExternal[chunk][index] = entityDecl.inExternal ? (byte)1 : (byte)0; fEntityIndexMap.put(entityDecl.name, entityDeclIndex); } protected int createNotationDecl() { int chunk = fNotationCount >> CHUNK_SHIFT; ensureNotationDeclCapacity(chunk); return fNotationCount++; } protected void setNotationDecl(int notationDeclIndex, XMLNotationDecl notationDecl) { int chunk = notationDeclIndex >> CHUNK_SHIFT; int index = notationDeclIndex & CHUNK_MASK; fNotationName[chunk][index] = notationDecl.name; fNotationPublicId[chunk][index] = notationDecl.publicId; fNotationSystemId[chunk][index] = notationDecl.systemId; fNotationBaseSystemId[chunk][index] = notationDecl.baseSystemId; fNotationIndexMap.put(notationDecl.name, notationDeclIndex); } /** * Create an XMLContentSpec for a single non-leaf * * @param nodeType the type of XMLContentSpec to create - from XMLContentSpec.CONTENTSPECNODE_* * @param nodeValue handle to an XMLContentSpec * @return handle to the newly create XMLContentSpec */ protected int addContentSpecNode(short nodeType, String nodeValue) { // create content spec node int contentSpecIndex = createContentSpec(); // set content spec node values fContentSpec.setValues(nodeType, nodeValue, null); setContentSpec(contentSpecIndex, fContentSpec); // return index return contentSpecIndex; } // addContentSpecNode(short,String):int /** * create an XMLContentSpec for a leaf * * @param elementName the name (Element) for the node * @return handle to the newly create XMLContentSpec */ protected int addUniqueLeafNode(String elementName) { // create content spec node int contentSpecIndex = createContentSpec(); // set content spec node values fContentSpec.setValues( XMLContentSpec.CONTENTSPECNODE_LEAF, elementName, null); setContentSpec(contentSpecIndex, fContentSpec); // return index return contentSpecIndex; } // addUniqueLeafNode(String):int /** * Create an XMLContentSpec for a two child leaf * * @param nodeType the type of XMLContentSpec to create - from XMLContentSpec.CONTENTSPECNODE_* * @param leftNodeIndex handle to an XMLContentSpec * @param rightNodeIndex handle to an XMLContentSpec * @return handle to the newly create XMLContentSpec */ protected int addContentSpecNode(short nodeType, int leftNodeIndex, int rightNodeIndex) { // create content spec node int contentSpecIndex = createContentSpec(); // set content spec node values int[] leftIntArray = new int[1]; int[] rightIntArray = new int[1]; leftIntArray[0] = leftNodeIndex; rightIntArray[0] = rightNodeIndex; fContentSpec.setValues(nodeType, leftIntArray, rightIntArray); setContentSpec(contentSpecIndex, fContentSpec); // return index return contentSpecIndex; } // addContentSpecNode(short,int,int):int /** Initialize content model stack. */ protected void initializeContentModelStack() { if (fOpStack == null) { fOpStack = new short[8]; fNodeIndexStack = new int[8]; fPrevNodeIndexStack = new int[8]; } else if (fDepth == fOpStack.length) { short[] newStack = new short[fDepth * 2]; System.arraycopy(fOpStack, 0, newStack, 0, fDepth); fOpStack = newStack; int[] newIntStack = new int[fDepth * 2]; System.arraycopy(fNodeIndexStack, 0, newIntStack, 0, fDepth); fNodeIndexStack = newIntStack; newIntStack = new int[fDepth * 2]; System.arraycopy(fPrevNodeIndexStack, 0, newIntStack, 0, fDepth); fPrevNodeIndexStack = newIntStack; } fOpStack[fDepth] = -1; fNodeIndexStack[fDepth] = -1; fPrevNodeIndexStack[fDepth] = -1; } // initializeContentModelStack() boolean isImmutable() { return fIsImmutable; } // // Private methods // private void appendContentSpec(XMLContentSpec contentSpec, StringBuffer str, boolean parens, int parentContentSpecType ) { int thisContentSpec = contentSpec.type & 0x0f; switch (thisContentSpec) { case XMLContentSpec.CONTENTSPECNODE_LEAF: { if (contentSpec.value == null && contentSpec.otherValue == null) { str.append("#PCDATA"); } else if (contentSpec.value == null && contentSpec.otherValue != null) { str.append("##any:uri=").append(contentSpec.otherValue); } else if (contentSpec.value == null) { str.append("##any"); } else { str.append(contentSpec.value); } break; } case XMLContentSpec.CONTENTSPECNODE_ZERO_OR_ONE: { if (parentContentSpecType == XMLContentSpec.CONTENTSPECNODE_ONE_OR_MORE || parentContentSpecType == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_MORE || parentContentSpecType == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_ONE ) { getContentSpec(((int[])contentSpec.value)[0], contentSpec); str.append('('); appendContentSpec(contentSpec, str, true, thisContentSpec ); str.append(')'); } else { getContentSpec(((int[])contentSpec.value)[0], contentSpec); appendContentSpec( contentSpec, str, true, thisContentSpec ); } str.append('?'); break; } case XMLContentSpec.CONTENTSPECNODE_ZERO_OR_MORE: { if (parentContentSpecType == XMLContentSpec.CONTENTSPECNODE_ONE_OR_MORE || parentContentSpecType == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_MORE || parentContentSpecType == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_ONE ) { getContentSpec(((int[])contentSpec.value)[0], contentSpec); str.append('('); appendContentSpec(contentSpec, str, true, thisContentSpec); str.append(')' ); } else { getContentSpec(((int[])contentSpec.value)[0], contentSpec); appendContentSpec(contentSpec, str, true, thisContentSpec); } str.append('*'); break; } case XMLContentSpec.CONTENTSPECNODE_ONE_OR_MORE: { if (parentContentSpecType == XMLContentSpec.CONTENTSPECNODE_ONE_OR_MORE || parentContentSpecType == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_MORE || parentContentSpecType == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_ONE ) { str.append('('); getContentSpec(((int[])contentSpec.value)[0], contentSpec); appendContentSpec(contentSpec, str, true, thisContentSpec); str.append(')' ); } else { getContentSpec(((int[])contentSpec.value)[0], contentSpec); appendContentSpec(contentSpec, str, true, thisContentSpec); } str.append('+'); break; } case XMLContentSpec.CONTENTSPECNODE_CHOICE: case XMLContentSpec.CONTENTSPECNODE_SEQ: { if (parens) { str.append('('); } int type = contentSpec.type; int otherValue = ((int[])contentSpec.otherValue)[0]; getContentSpec(((int[])contentSpec.value)[0], contentSpec); appendContentSpec(contentSpec, str, contentSpec.type != type, thisContentSpec); if (type == XMLContentSpec.CONTENTSPECNODE_CHOICE) { str.append('|'); } else { str.append(','); } getContentSpec(otherValue, contentSpec); appendContentSpec(contentSpec, str, true, thisContentSpec); if (parens) { str.append(')'); } break; } case XMLContentSpec.CONTENTSPECNODE_ANY: { str.append("##any"); if (contentSpec.otherValue != null) { str.append(":uri="); str.append(contentSpec.otherValue); } break; } case XMLContentSpec.CONTENTSPECNODE_ANY_OTHER: { str.append("##other:uri="); str.append(contentSpec.otherValue); break; } case XMLContentSpec.CONTENTSPECNODE_ANY_LOCAL: { str.append("##local"); break; } default: { str.append("???"); break; } } // switch type } // appendContentSpec(XMLContentSpec.Provider,StringPool,XMLContentSpec,StringBuffer,boolean) // debugging private void printAttribute(int attributeDeclIndex) { XMLAttributeDecl attributeDecl = new XMLAttributeDecl(); if (getAttributeDecl(attributeDeclIndex, attributeDecl)) { System.out.print(" { "); System.out.print(attributeDecl.name.localpart); System.out.print(" }"); } } // printAttribute(int) // content models /** * When the element has a 'CHILDREN' model, this method is called to * create the content model object. It looks for some special case simple * models and creates SimpleContentModel objects for those. For the rest * it creates the standard DFA style model. */ private synchronized ContentModelValidator createChildModel(int contentSpecIndex) { // // Get the content spec node for the element we are working on. // This will tell us what kind of node it is, which tells us what // kind of model we will try to create. // XMLContentSpec contentSpec = new XMLContentSpec(); getContentSpec(contentSpecIndex, contentSpec); if ((contentSpec.type & 0x0f ) == XMLContentSpec.CONTENTSPECNODE_ANY || (contentSpec.type & 0x0f ) == XMLContentSpec.CONTENTSPECNODE_ANY_OTHER || (contentSpec.type & 0x0f ) == XMLContentSpec.CONTENTSPECNODE_ANY_LOCAL) { // let fall through to build a DFAContentModel } else if (contentSpec.type == XMLContentSpec.CONTENTSPECNODE_LEAF) { // // Check that the left value is not -1, since any content model // with PCDATA should be MIXED, so we should not have gotten here. // if (contentSpec.value == null && contentSpec.otherValue == null) throw new RuntimeException("ImplementationMessages.VAL_NPCD"); // // Its a single leaf, so its an 'a' type of content model, i.e. // just one instance of one element. That one is definitely a // simple content model. // fQName.setValues(null, (String)contentSpec.value, (String)contentSpec.value, (String)contentSpec.otherValue); return new SimpleContentModel(contentSpec.type, fQName, null); } else if ((contentSpec.type == XMLContentSpec.CONTENTSPECNODE_CHOICE) || (contentSpec.type == XMLContentSpec.CONTENTSPECNODE_SEQ)) { // // Lets see if both of the children are leafs. If so, then it // it has to be a simple content model // XMLContentSpec contentSpecLeft = new XMLContentSpec(); XMLContentSpec contentSpecRight = new XMLContentSpec(); getContentSpec( ((int[])contentSpec.value)[0], contentSpecLeft); getContentSpec( ((int[])contentSpec.otherValue)[0], contentSpecRight); if ((contentSpecLeft.type == XMLContentSpec.CONTENTSPECNODE_LEAF) && (contentSpecRight.type == XMLContentSpec.CONTENTSPECNODE_LEAF)) { // // Its a simple choice or sequence, so we can do a simple // content model for it. // fQName.setValues(null, (String)contentSpecLeft.value, (String)contentSpecLeft.value, (String)contentSpecLeft.otherValue); fQName2.setValues(null, (String)contentSpecRight.value, (String)contentSpecRight.value, (String)contentSpecRight.otherValue); return new SimpleContentModel(contentSpec.type, fQName, fQName2); } } else if ((contentSpec.type == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_ONE) || (contentSpec.type == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_MORE) || (contentSpec.type == XMLContentSpec.CONTENTSPECNODE_ONE_OR_MORE)) { // // Its a repetition, so see if its one child is a leaf. If so // its a repetition of a single element, so we can do a simple // content model for that. // XMLContentSpec contentSpecLeft = new XMLContentSpec(); getContentSpec(((int[])contentSpec.value)[0], contentSpecLeft); if (contentSpecLeft.type == XMLContentSpec.CONTENTSPECNODE_LEAF) { // // It is, so we can create a simple content model here that // will check for this repetition. We pass -1 for the unused // right node. // fQName.setValues(null, (String)contentSpecLeft.value, (String)contentSpecLeft.value, (String)contentSpecLeft.otherValue); return new SimpleContentModel(contentSpec.type, fQName, null); } } else { throw new RuntimeException("ImplementationMessages.VAL_CST"); } // // Its not a simple content model, so here we have to create a DFA // for this element. So we create a DFAContentModel object. He // encapsulates all of the work to create the DFA. // fLeafCount = 0; //int leafCount = countLeaves(contentSpecIndex); fLeafCount = 0; CMNode cmn = buildSyntaxTree(contentSpecIndex, contentSpec); // REVISIT: has to be fLeafCount because we convert x+ to x,x*, one more leaf return new DFAContentModel( cmn, fLeafCount, false); } // createChildModel(int):ContentModelValidator private final CMNode buildSyntaxTree(int startNode, XMLContentSpec contentSpec) { // We will build a node at this level for the new tree CMNode nodeRet = null; getContentSpec(startNode, contentSpec); if ((contentSpec.type & 0x0f) == XMLContentSpec.CONTENTSPECNODE_ANY) { //nodeRet = new CMAny(contentSpec.type, -1, fLeafCount++); nodeRet = new CMAny(contentSpec.type, (String)contentSpec.otherValue, fLeafCount++); } else if ((contentSpec.type & 0x0f) == XMLContentSpec.CONTENTSPECNODE_ANY_OTHER) { nodeRet = new CMAny(contentSpec.type, (String)contentSpec.otherValue, fLeafCount++); } else if ((contentSpec.type & 0x0f) == XMLContentSpec.CONTENTSPECNODE_ANY_LOCAL) { nodeRet = new CMAny(contentSpec.type, null, fLeafCount++); } // // If this node is a leaf, then its an easy one. We just add it // to the tree. // else if (contentSpec.type == XMLContentSpec.CONTENTSPECNODE_LEAF) { // // Create a new leaf node, and pass it the current leaf count, // which is its DFA state position. Bump the leaf count after // storing it. This makes the positions zero based since we // store first and then increment. // fQName.setValues(null, (String)contentSpec.value, (String)contentSpec.value, (String)contentSpec.otherValue); nodeRet = new CMLeaf(fQName, fLeafCount++); } else { // // Its not a leaf, so we have to recurse its left and maybe right // nodes. Save both values before we recurse and trash the node. final int leftNode = ((int[])contentSpec.value)[0]; final int rightNode = ((int[])contentSpec.otherValue)[0]; if ((contentSpec.type == XMLContentSpec.CONTENTSPECNODE_CHOICE) || (contentSpec.type == XMLContentSpec.CONTENTSPECNODE_SEQ)) { // // Recurse on both children, and return a binary op node // with the two created sub nodes as its children. The node // type is the same type as the source. // nodeRet = new CMBinOp( contentSpec.type, buildSyntaxTree(leftNode, contentSpec) , buildSyntaxTree(rightNode, contentSpec)); } else if (contentSpec.type == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_MORE) { nodeRet = new CMUniOp( contentSpec.type, buildSyntaxTree(leftNode, contentSpec)); } else if (contentSpec.type == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_MORE || contentSpec.type == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_ONE || contentSpec.type == XMLContentSpec.CONTENTSPECNODE_ONE_OR_MORE) { nodeRet = new CMUniOp(contentSpec.type, buildSyntaxTree(leftNode, contentSpec)); } else { throw new RuntimeException("ImplementationMessages.VAL_CST"); } } // And return our new node for this level return nodeRet; } /** * Build a vector of valid QNames from Content Spec * table. * * @param contentSpecIndex * Content Spec index * @param vectorQName * Array of QName * @exception RuntimeException */ private void contentSpecTree(int contentSpecIndex, XMLContentSpec contentSpec, ChildrenList children) { // Handle any and leaf nodes getContentSpec( contentSpecIndex, contentSpec); if ( contentSpec.type == XMLContentSpec.CONTENTSPECNODE_LEAF || (contentSpec.type & 0x0f) == XMLContentSpec.CONTENTSPECNODE_ANY || (contentSpec.type & 0x0f) == XMLContentSpec.CONTENTSPECNODE_ANY_LOCAL || (contentSpec.type & 0x0f) == XMLContentSpec.CONTENTSPECNODE_ANY_OTHER) { // resize arrays, if needed if (children.length == children.qname.length) { QName[] newQName = new QName[children.length * 2]; System.arraycopy(children.qname, 0, newQName, 0, children.length); children.qname = newQName; int[] newType = new int[children.length * 2]; System.arraycopy(children.type, 0, newType, 0, children.length); children.type = newType; } // save values and return length children.qname[children.length] = new QName(null, (String)contentSpec.value, (String) contentSpec.value, (String) contentSpec.otherValue); children.type[children.length] = contentSpec.type; children.length++; return; } // // Its not a leaf, so we have to recurse its left and maybe right // nodes. Save both values before we recurse and trash the node. // final int leftNode = contentSpec.value != null ? ((int[])(contentSpec.value))[0] : -1; int rightNode = -1 ; if (contentSpec.otherValue != null ) rightNode = ((int[])(contentSpec.otherValue))[0]; else return; if (contentSpec.type == XMLContentSpec.CONTENTSPECNODE_CHOICE || contentSpec.type == XMLContentSpec.CONTENTSPECNODE_SEQ) { contentSpecTree(leftNode, contentSpec, children); contentSpecTree(rightNode, contentSpec, children); return; } if (contentSpec.type == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_ONE || contentSpec.type == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_MORE || contentSpec.type == XMLContentSpec.CONTENTSPECNODE_ONE_OR_MORE) { contentSpecTree(leftNode, contentSpec, children); return; } // error throw new RuntimeException("Invalid content spec type seen in contentSpecTree() method of AbstractDTDGrammar class : "+contentSpec.type); } // contentSpecTree(int,XMLContentSpec,ChildrenList) // ensure capacity private void ensureElementDeclCapacity(int chunk) { if (chunk >= fElementDeclName.length) { fElementDeclIsExternal = resize(fElementDeclIsExternal, fElementDeclIsExternal.length * 2); fElementDeclName = resize(fElementDeclName, fElementDeclName.length * 2); fElementDeclType = resize(fElementDeclType, fElementDeclType.length * 2); fElementDeclContentModelValidator = resize(fElementDeclContentModelValidator, fElementDeclContentModelValidator.length * 2); fElementDeclContentSpecIndex = resize(fElementDeclContentSpecIndex,fElementDeclContentSpecIndex.length * 2); fElementDeclFirstAttributeDeclIndex = resize(fElementDeclFirstAttributeDeclIndex, fElementDeclFirstAttributeDeclIndex.length * 2); fElementDeclLastAttributeDeclIndex = resize(fElementDeclLastAttributeDeclIndex, fElementDeclLastAttributeDeclIndex.length * 2); } else if (fElementDeclName[chunk] != null) { return; } fElementDeclIsExternal[chunk] = new int[CHUNK_SIZE]; fElementDeclName[chunk] = new QName[CHUNK_SIZE]; fElementDeclType[chunk] = new short[CHUNK_SIZE]; fElementDeclContentModelValidator[chunk] = new ContentModelValidator[CHUNK_SIZE]; fElementDeclContentSpecIndex[chunk] = new int[CHUNK_SIZE]; fElementDeclFirstAttributeDeclIndex[chunk] = new int[CHUNK_SIZE]; fElementDeclLastAttributeDeclIndex[chunk] = new int[CHUNK_SIZE]; return; } private void ensureAttributeDeclCapacity(int chunk) { if (chunk >= fAttributeDeclName.length) { fAttributeDeclIsExternal = resize(fAttributeDeclIsExternal, fAttributeDeclIsExternal.length * 2); fAttributeDeclName = resize(fAttributeDeclName, fAttributeDeclName.length * 2); fAttributeDeclType = resize(fAttributeDeclType, fAttributeDeclType.length * 2); fAttributeDeclEnumeration = resize(fAttributeDeclEnumeration, fAttributeDeclEnumeration.length * 2); fAttributeDeclDefaultType = resize(fAttributeDeclDefaultType, fAttributeDeclDefaultType.length * 2); fAttributeDeclDatatypeValidator = resize(fAttributeDeclDatatypeValidator, fAttributeDeclDatatypeValidator.length * 2); fAttributeDeclDefaultValue = resize(fAttributeDeclDefaultValue, fAttributeDeclDefaultValue.length * 2); fAttributeDeclNonNormalizedDefaultValue = resize(fAttributeDeclNonNormalizedDefaultValue, fAttributeDeclNonNormalizedDefaultValue.length * 2); fAttributeDeclNextAttributeDeclIndex = resize(fAttributeDeclNextAttributeDeclIndex, fAttributeDeclNextAttributeDeclIndex.length * 2); } else if (fAttributeDeclName[chunk] != null) { return; } fAttributeDeclIsExternal[chunk] = new int[CHUNK_SIZE]; fAttributeDeclName[chunk] = new QName[CHUNK_SIZE]; fAttributeDeclType[chunk] = new short[CHUNK_SIZE]; fAttributeDeclEnumeration[chunk] = new String[CHUNK_SIZE][]; fAttributeDeclDefaultType[chunk] = new short[CHUNK_SIZE]; fAttributeDeclDatatypeValidator[chunk] = new DatatypeValidator[CHUNK_SIZE]; fAttributeDeclDefaultValue[chunk] = new String[CHUNK_SIZE]; fAttributeDeclNonNormalizedDefaultValue[chunk] = new String[CHUNK_SIZE]; fAttributeDeclNextAttributeDeclIndex[chunk] = new int[CHUNK_SIZE]; return; } private void ensureEntityDeclCapacity(int chunk) { if (chunk >= fEntityName.length) { fEntityName = resize(fEntityName, fEntityName.length * 2); fEntityValue = resize(fEntityValue, fEntityValue.length * 2); fEntityPublicId = resize(fEntityPublicId, fEntityPublicId.length * 2); fEntitySystemId = resize(fEntitySystemId, fEntitySystemId.length * 2); fEntityBaseSystemId = resize(fEntityBaseSystemId, fEntityBaseSystemId.length * 2); fEntityNotation = resize(fEntityNotation, fEntityNotation.length * 2); fEntityIsPE = resize(fEntityIsPE, fEntityIsPE.length * 2); fEntityInExternal = resize(fEntityInExternal, fEntityInExternal.length * 2); } else if (fEntityName[chunk] != null) { return; } fEntityName[chunk] = new String[CHUNK_SIZE]; fEntityValue[chunk] = new String[CHUNK_SIZE]; fEntityPublicId[chunk] = new String[CHUNK_SIZE]; fEntitySystemId[chunk] = new String[CHUNK_SIZE]; fEntityBaseSystemId[chunk] = new String[CHUNK_SIZE]; fEntityNotation[chunk] = new String[CHUNK_SIZE]; fEntityIsPE[chunk] = new byte[CHUNK_SIZE]; fEntityInExternal[chunk] = new byte[CHUNK_SIZE]; return; } private void ensureNotationDeclCapacity(int chunk) { if (chunk >= fNotationName.length) { fNotationName = resize(fNotationName, fNotationName.length * 2); fNotationPublicId = resize(fNotationPublicId, fNotationPublicId.length * 2); fNotationSystemId = resize(fNotationSystemId, fNotationSystemId.length * 2); fNotationBaseSystemId = resize(fNotationBaseSystemId, fNotationBaseSystemId.length * 2); } else if (fNotationName[chunk] != null) { return; } fNotationName[chunk] = new String[CHUNK_SIZE]; fNotationPublicId[chunk] = new String[CHUNK_SIZE]; fNotationSystemId[chunk] = new String[CHUNK_SIZE]; fNotationBaseSystemId[chunk] = new String[CHUNK_SIZE]; return; } private void ensureContentSpecCapacity(int chunk) { if (chunk >= fContentSpecType.length) { fContentSpecType = resize(fContentSpecType, fContentSpecType.length * 2); fContentSpecValue = resize(fContentSpecValue, fContentSpecValue.length * 2); fContentSpecOtherValue = resize(fContentSpecOtherValue, fContentSpecOtherValue.length * 2); } else if (fContentSpecType[chunk] != null) { return; } fContentSpecType[chunk] = new short[CHUNK_SIZE]; fContentSpecValue[chunk] = new Object[CHUNK_SIZE]; fContentSpecOtherValue[chunk] = new Object[CHUNK_SIZE]; return; } // // Private static methods // // resize chunks private static byte[][] resize(byte array[][], int newsize) { byte newarray[][] = new byte[newsize][]; System.arraycopy(array, 0, newarray, 0, array.length); return newarray; } private static short[][] resize(short array[][], int newsize) { short newarray[][] = new short[newsize][]; System.arraycopy(array, 0, newarray, 0, array.length); return newarray; } private static int[][] resize(int array[][], int newsize) { int newarray[][] = new int[newsize][]; System.arraycopy(array, 0, newarray, 0, array.length); return newarray; } private static DatatypeValidator[][] resize(DatatypeValidator array[][], int newsize) { DatatypeValidator newarray[][] = new DatatypeValidator[newsize][]; System.arraycopy(array, 0, newarray, 0, array.length); return newarray; } private static ContentModelValidator[][] resize(ContentModelValidator array[][], int newsize) { ContentModelValidator newarray[][] = new ContentModelValidator[newsize][]; System.arraycopy(array, 0, newarray, 0, array.length); return newarray; } private static Object[][] resize(Object array[][], int newsize) { Object newarray[][] = new Object[newsize][]; System.arraycopy(array, 0, newarray, 0, array.length); return newarray; } private static QName[][] resize(QName array[][], int newsize) { QName newarray[][] = new QName[newsize][]; System.arraycopy(array, 0, newarray, 0, array.length); return newarray; } private static String[][] resize(String array[][], int newsize) { String newarray[][] = new String[newsize][]; System.arraycopy(array, 0, newarray, 0, array.length); return newarray; } private static String[][][] resize(String array[][][], int newsize) { String newarray[][][] = new String[newsize] [][]; System.arraycopy(array, 0, newarray, 0, array.length); return newarray; } // // Classes // /** * Children list for <code>contentSpecTree</code> method. * * @xerces.internal * * @author Eric Ye, IBM */ private static class ChildrenList { // // Data // /** Length. */ public int length = 0; // NOTE: The following set of data is mutually exclusive. It is // written this way because Java doesn't have a native // union data structure. -Ac /** Left and right children names. */ public QName[] qname = new QName[2]; /** Left and right children types. */ public int[] type = new int[2]; // // Constructors // public ChildrenList () {} } // class ChildrenList // // Classes // /** * A simple Hashtable implementation that takes a tuple (String, String) * as the key and a int as value. * * @xerces.internal * * @author Eric Ye, IBM * @author Andy Clark, IBM */ protected static final class QNameHashtable { /** * Fills an array with a random sequence of prime numbers. * * @xerces.internal */ private static final class PrimeNumberSequenceGenerator { private static int [] PRIMES = { 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727}; static void generateSequence(int[] arrayToFill) { Random r = new Random(); for (int i = 0; i < arrayToFill.length; ++i) { arrayToFill[i] = PRIMES[r.nextInt(PRIMES.length)]; } } } // // Constants // /** Initial bucket size (4). */ private static final int INITIAL_BUCKET_SIZE = 4; // NOTE: Changed previous hashtable size from 512 to 101 so // that we get a better distribution for hashing. -Ac /** Hashtable size (101). */ private static final int HASHTABLE_SIZE = 101; /** Maximum hash collisions per bucket for a table with load factor == 1. */ private static final int MAX_HASH_COLLISIONS = 40; private static final int MULTIPLIERS_SIZE = 1 << 5; private static final int MULTIPLIERS_MASK = MULTIPLIERS_SIZE - 1; // // Data // private Object[][] fHashTable = new Object[HASHTABLE_SIZE][]; /** actual table size **/ private int fTableSize = HASHTABLE_SIZE; /** The total number of entries in the hash table. */ private int fCount = 0; /** * Array of randomly selected hash function multipliers or <code>null</code> * if the default String.hashCode() function should be used. */ private int[] fHashMultipliers; // // Public methods // /** Associates the given value with the specified key tuple. */ public void put(String key, int value) { int hash = (hash(key) & 0x7FFFFFFF) % fTableSize; Object[] bucket = fHashTable[hash]; if (bucket == null) { bucket = new Object[1 + 2*INITIAL_BUCKET_SIZE]; bucket[0] = new int[]{1}; bucket[1] = key; bucket[2] = new int[]{value}; fHashTable[hash] = bucket; if (++fCount > fTableSize) { // Rehash the table if the number of entries // would exceed the number of buckets. rehash(); } } else { int count = ((int[])bucket[0])[0]; int offset = 1 + 2*count; if (offset == bucket.length) { int newSize = count + INITIAL_BUCKET_SIZE; Object[] newBucket = new Object[1 + 2*newSize]; System.arraycopy(bucket, 0, newBucket, 0, offset); bucket = newBucket; fHashTable[hash] = bucket; } boolean found = false; int j=1; for (int i=0; i<count; i++){ if ((String)bucket[j] == key) { ((int[])bucket[j+1])[0] = value; found = true; break; } j += 2; } if (!found) { bucket[offset++] = key; bucket[offset]= new int[]{value}; ((int[])bucket[0])[0] = ++count; if (++fCount > fTableSize) { // Rehash the table if the number of entries // would exceed the number of buckets. rehash(); } else if (count > MAX_HASH_COLLISIONS) { // Select a new hash function and rehash the table if // MAX_HASH_COLLISIONS is exceeded. rebalance(); } } } //System.out.println("put("+key+" -> "+value+')'); //System.out.println("get("+key+") -> "+get(key)); } // put(int,String,String,int) /** Returns the value associated with the specified key tuple. */ public int get(String key) { int hash = (hash(key) & 0x7FFFFFFF) % fTableSize; Object[] bucket = fHashTable[hash]; if (bucket == null) { return -1; } int count = ((int[])bucket[0])[0]; int j=1; for (int i=0; i<count; i++){ if ((String)bucket[j] == key) { return ((int[])bucket[j+1])[0]; } j += 2; } return -1; } // get(int,String,String) public int hash(String symbol) { if (fHashMultipliers == null) { return symbol.hashCode(); } return hash0(symbol); } // hash(String):int private int hash0(String symbol) { int code = 0; final int length = symbol.length(); final int[] multipliers = fHashMultipliers; for (int i = 0; i < length; ++i) { code = code * multipliers[i & MULTIPLIERS_MASK] + symbol.charAt(i); } return code; } // hash0(String):int private void rehash() { rehashCommon(fHashTable.length * 2 + 1); } // rehash() private void rebalance() { if (fHashMultipliers == null) { fHashMultipliers = new int[MULTIPLIERS_SIZE]; } PrimeNumberSequenceGenerator.generateSequence(fHashMultipliers); rehashCommon(fHashTable.length); } // rebalance() private void rehashCommon(final int newCapacity) { final int oldCapacity = fHashTable.length; final Object[][] oldTable = fHashTable; final Object[][] newTable = new Object[newCapacity][]; fHashTable = newTable; fTableSize = fHashTable.length; for (int i = 0; i < oldCapacity; ++i) { final Object[] oldBucket = oldTable[i]; if (oldBucket != null) { final int oldCount = ((int[]) oldBucket[0])[0]; boolean oldBucketReused = false; int k = 1; for (int j = 0; j < oldCount; ++j) { final String key = (String) oldBucket[k]; final Object value = oldBucket[k+1]; final int hash = (hash(key) & 0x7FFFFFFF) % fTableSize; Object[] bucket = fHashTable[hash]; if (bucket == null) { if (oldBucketReused) { bucket = new Object[1 + 2*INITIAL_BUCKET_SIZE]; bucket[0] = new int[]{1}; } else { bucket = oldBucket; ((int[])bucket[0])[0] = 1; oldBucketReused = true; } bucket[1] = key; bucket[2] = value; fHashTable[hash] = bucket; } else { int count = ((int[])bucket[0])[0]; int offset = 1 + 2*count; if (offset == bucket.length) { int newSize = count + INITIAL_BUCKET_SIZE; Object[] newBucket = new Object[1 + 2*newSize]; System.arraycopy(bucket, 0, newBucket, 0, offset); bucket = newBucket; fHashTable[hash] = bucket; } bucket[offset++] = key; bucket[offset]= value; ((int[])bucket[0])[0] = ++count; } k += 2; } } } } // rehashCommon(int) } // class QNameHashtable // // EntityState methods // public boolean isEntityDeclared (String name){ return (getEntityDeclIndex(name)!=-1)?true:false; } public boolean isEntityUnparsed (String name){ int entityIndex = getEntityDeclIndex(name); if (entityIndex >-1) { int chunk = entityIndex >> CHUNK_SHIFT; int index = entityIndex & CHUNK_MASK; //for unparsed entity notation!=null return (fEntityNotation[chunk][index]!=null)?true:false; } return false; } } // class DTDGrammar
⏎ org/apache/xerces/impl/dtd/DTDGrammar.java
Or download all of them as a single archive file:
File name: Xerces-J.2.12.2-src.zip File size: 2128351 bytes Release date: 2022-01-21 Download
⇒ Donwload Xerces-J-bin.2.11.0.zip
⇐ What Is in Xerces-J-bin.2.12.2.zip
2016-09-15, 57640👍, 1💬
Popular Posts:
How to download and install JDK (Java Development Kit) 7? If you want to write Java applications, yo...
How to download and install JDK (Java Development Kit) 1.3? If you want to write Java applications, ...
Where to find answers to frequently asked questions on Download and Installing of Older Versions? He...
What Is javaws.jar in JRE (Java Runtime Environment) 8? javaws.jar in JRE (Java Runtime Environment)...
How to download and install ojdbc5.jar for Oracle 11g R1? ojdbc5.jar for Oracle 11g R1 is a Java 5 J...