DTDGrammarpublic class DTDGrammar extends Object implements XMLDTDHandler, XMLDTDContentModelHandler, EntityState, Grammar| A DTD grammar. This class implements the XNI handler interfaces
for DTD information so that it can build the approprate validation
structures automatically from the callbacks. |
| Fields Summary |
|---|
| public static final int | TOP_LEVEL_SCOPETop level scope (-1). | | private static final int | CHUNK_SHIFTChunk shift (8). | | private static final int | CHUNK_SIZEChunk size (1 << CHUNK_SHIFT). | | private static final int | CHUNK_MASKChunk mask (CHUNK_SIZE - 1). | | private static final int | INITIAL_CHUNK_COUNTInitial chunk count (1 << (10 - CHUNK_SHIFT)). | | private static final short | LIST_FLAGList flag (0x80). | | private static final short | LIST_MASKList mask (~LIST_FLAG). | | private static final boolean | DEBUGDebug DTDGrammar. | | protected XMLDTDSource | fDTDSource | | protected XMLDTDContentModelSource | fDTDContentModelSource | | protected int | fCurrentElementIndexCurrent element index. | | protected int | fCurrentAttributeIndexCurrent attribute index. | | protected boolean | fReadingExternalDTDfReadingExternalDTD | | private SymbolTable | fSymbolTableSymbol table. | | protected XMLDTDDescription | fGrammarDescription | | private int | fElementDeclCountNumber of element declarations. | | private QName[] | fElementDeclNameElement declaration name. | | private short[] | fElementDeclTypeElement declaration type. | | private int[] | fElementDeclContentSpecIndexElement declaration content spec index. This index value is used
to refer to the content spec information tables. | | private ContentModelValidator[] | fElementDeclContentModelValidatorElement declaration content model validator. This validator is
constructed from the content spec nodes. | | private int[] | fElementDeclFirstAttributeDeclIndexFirst attribute declaration of an element declaration. | | private int[] | fElementDeclLastAttributeDeclIndexLast attribute declaration of an element declaration. | | private int | fAttributeDeclCountNumber of attribute declarations. | | private QName[] | fAttributeDeclNameAttribute declaration name. | | private boolean | fIsImmutable | | private short[] | fAttributeDeclTypeAttribute declaration type. | | private String[] | fAttributeDeclEnumerationAttribute declaration enumeration values. | | private short[] | fAttributeDeclDefaultType | | private DatatypeValidator[] | fAttributeDeclDatatypeValidator | | private String[] | fAttributeDeclDefaultValue | | private String[] | fAttributeDeclNonNormalizedDefaultValue | | private int[] | fAttributeDeclNextAttributeDeclIndex | | private int | fContentSpecCount | | private short[] | fContentSpecType | | private Object[] | fContentSpecValue | | private Object[] | fContentSpecOtherValue | | private int | fEntityCount | | private String[] | fEntityName | | private String[] | fEntityValue | | private String[] | fEntityPublicId | | private String[] | fEntitySystemId | | private String[] | fEntityBaseSystemId | | private String[] | fEntityNotation | | private byte[] | fEntityIsPE | | private byte[] | fEntityInExternal | | private int | fNotationCount | | private String[] | fNotationName | | private String[] | fNotationPublicId | | private String[] | fNotationSystemId | | private String[] | fNotationBaseSystemId | | private QNameHashtable | fElementIndexMapElement index mapping table. | | private QNameHashtable | fEntityIndexMapEntity index mapping table. | | private QNameHashtable | fNotationIndexMapNotation index mapping table. | | private boolean | fMixedMixed. | | private QName | fQNameTemporary qualified name. | | private QName | fQName2Temporary qualified name. | | protected XMLAttributeDecl | fAttributeDeclTemporary Attribute decl. | | private int | fLeafCount | | private int | fEpsilonIndex | | private XMLElementDecl | fElementDeclElement declaration. | | private XMLEntityDecl | fEntityDeclEntity declaration. | | private XMLSimpleType | fSimpleTypeSimple type. | | private XMLContentSpec | fContentSpecContent spec node. | | Hashtable | fElementDeclTabtable of XMLElementDecl | | private short[] | fOpStackChildren content model operation stack. | | private int[] | fNodeIndexStackChildren content model index stack. | | private int[] | fPrevNodeIndexStackChildren content model previous node index stack. | | private int | fDepthStack depth | | private boolean[] | fPEntityStackEntity stack. | | private int | fPEDepth | | private int[] | fElementDeclIsExternalflag if the elementDecl is External. | | private int[] | fAttributeDeclIsExternalflag if the AttributeDecl is External. | | int | valueIndex | | int | prevNodeIndex | | int | nodeIndex |
| Constructors Summary |
|---|
public DTDGrammar(SymbolTable symbolTable, XMLDTDDescription desc)Default constructor.
//
// Constructors
//
fSymbolTable = symbolTable;
fGrammarDescription = desc;
|
| Methods Summary |
|---|
| protected int | addContentSpecNode(short nodeType, java.lang.String nodeValue)Create an XMLContentSpec for a single non-leaf
// create content spec node
int contentSpecIndex = createContentSpec();
// set content spec node values
fContentSpec.setValues(nodeType, nodeValue, null);
setContentSpec(contentSpecIndex, fContentSpec);
// return index
return contentSpecIndex;
| | protected int | addContentSpecNode(short nodeType, int leftNodeIndex, int rightNodeIndex)Create an XMLContentSpec for a two child leaf
// 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;
| | protected int | addUniqueLeafNode(java.lang.String elementName)create an XMLContentSpec for a leaf
// 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;
| | public void | any(com.sun.org.apache.xerces.internal.xni.Augmentations augs)A content model of ANY.
| | private void | appendContentSpec(com.sun.org.apache.xerces.internal.impl.dtd.XMLContentSpec contentSpec, java.lang.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="+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
| | public void | attributeDecl(java.lang.String elementName, java.lang.String attributeName, java.lang.String type, java.lang.String[] enumeration, java.lang.String defaultType, com.sun.org.apache.xerces.internal.xni.XMLString defaultValue, com.sun.org.apache.xerces.internal.xni.XMLString nonNormalizedDefaultValue, com.sun.org.apache.xerces.internal.xni.Augmentations augs)An attribute declaration.
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 ? 1 : 0;
| | private final com.sun.org.apache.xerces.internal.impl.dtd.models.CMNode | buildSyntaxTree(int startNode, com.sun.org.apache.xerces.internal.impl.dtd.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;
| | public void | comment(com.sun.org.apache.xerces.internal.xni.XMLString text, com.sun.org.apache.xerces.internal.xni.Augmentations augs)A comment.
| | private void | contentSpecTree(int contentSpecIndex, com.sun.org.apache.xerces.internal.impl.dtd.XMLContentSpec contentSpec, com.sun.org.apache.xerces.internal.impl.dtd.DTDGrammar$ChildrenList children)Build a vector of valid QNames from Content Spec
table.
// 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);
| | 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++;
| | private com.sun.org.apache.xerces.internal.impl.dtd.models.ContentModelValidator | createChildModel(int contentSpecIndex)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.
//
// 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);
| | 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 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 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 int | createNotationDecl()
int chunk = fNotationCount >> CHUNK_SHIFT;
int index = fNotationCount & CHUNK_MASK;
ensureNotationDeclCapacity(chunk);
return fNotationCount++;
| | public void | element(java.lang.String elementName, com.sun.org.apache.xerces.internal.xni.Augmentations augs)A referenced element in a mixed or children content model.
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);
}
| | public void | elementDecl(java.lang.String name, java.lang.String contentModel, com.sun.org.apache.xerces.internal.xni.Augmentations augs)An element declaration.
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;
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]);
}
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? 1 : 0;
| | public void | empty(com.sun.org.apache.xerces.internal.xni.Augmentations augs)A content model of EMPTY.
| | public void | endAttlist(com.sun.org.apache.xerces.internal.xni.Augmentations augs)The end of an attribute list.
| | public void | endConditional(com.sun.org.apache.xerces.internal.xni.Augmentations augs)The end of a conditional section.
| | public void | endContentModel(com.sun.org.apache.xerces.internal.xni.Augmentations augs)The end of a content model.
| | public void | endDTD(com.sun.org.apache.xerces.internal.xni.Augmentations augs)The end of the DTD.
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;
Vector elements = new Vector();
for (int i=0; i < fElementDeclCount; i++) {
chunk = i >> CHUNK_SHIFT;
index = i & CHUNK_MASK;
currName = fElementDeclName[chunk][index].rawname;
elements.addElement(currName);
}
fGrammarDescription.setPossibleRoots(elements);
}
| | public void | endExternalSubset(com.sun.org.apache.xerces.internal.xni.Augmentations augs)The end of the DTD external subset.
fReadingExternalDTD = false;
| | public void | endGroup(com.sun.org.apache.xerces.internal.xni.Augmentations augs)The end of a group for mixed or children content models.
if (!fMixed) {
if (fPrevNodeIndexStack[fDepth] != -1) {
fNodeIndexStack[fDepth] = addContentSpecNode(fOpStack[fDepth], fPrevNodeIndexStack[fDepth], fNodeIndexStack[fDepth]);
}
int nodeIndex = fNodeIndexStack[fDepth--];
fNodeIndexStack[fDepth] = nodeIndex;
}
| | public void | endParameterEntity(java.lang.String name, com.sun.org.apache.xerces.internal.xni.Augmentations augs)This method notifies the end of an entity. The DTD has the pseudo-name
of "[dtd]" and parameter entity names start with '%'.
Note: 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]" after calling
the endDTD method.
fPEDepth--;
fReadingExternalDTD = fPEntityStack[fPEDepth];
| | 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 | 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 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 | 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;
| | public void | externalEntityDecl(java.lang.String name, com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier identifier, com.sun.org.apache.xerces.internal.xni.Augmentations augs)An external entity declaration.
int entityIndex = getEntityDeclIndex(name);
if( entityIndex == -1){
entityIndex = createEntityDecl();
boolean isPE = name.startsWith("%");
boolean inExternal = fReadingExternalDTD;
XMLEntityDecl entityDecl = new XMLEntityDecl();
entityDecl.setValues(name, identifier.getPublicId(), identifier.getLiteralSystemId(),
identifier.getBaseSystemId(),
null, null, isPE, inExternal);
setEntityDecl(entityIndex, entityDecl);
}
| | public boolean | getAttributeDecl(int attributeDeclIndex, com.sun.org.apache.xerces.internal.impl.dtd.XMLAttributeDecl attributeDecl)getAttributeDecl
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;
| | public int | getAttributeDeclIndex(int elementDeclIndex, java.lang.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;
| | public boolean | getAttributeDeclIsExternal(int attributeDeclIndex)Returns true if the specified attribute declaration is external.
if (attributeDeclIndex < 0) {
return false;
}
int chunk = attributeDeclIndex >> CHUNK_SHIFT;
int index = attributeDeclIndex & CHUNK_MASK;
return (fAttributeDeclIsExternal[chunk][index] != 0);
| | public boolean | getContentSpec(int contentSpecIndex, com.sun.org.apache.xerces.internal.impl.dtd.XMLContentSpec contentSpec)getContentSpec
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;
| | public java.lang.String | getContentSpecAsString(int elementDeclIndex)getContentSpecAsString
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="+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="+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;
| | public short | getContentSpecType(int elementIndex)make separate function for getting contentSpecType of element.
we can avoid setting of the element values.
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);
}
| | public com.sun.org.apache.xerces.internal.xni.parser.XMLDTDContentModelSource | getDTDContentModelSource()
return fDTDContentModelSource;
| | public com.sun.org.apache.xerces.internal.xni.parser.XMLDTDSource | getDTDSource()
return fDTDSource;
| | protected com.sun.org.apache.xerces.internal.impl.dtd.models.ContentModelValidator | getElementContentModelValidator(int elementDeclIndex)getElementContentModelValidator
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;
| | public boolean | getElementDecl(int elementDeclIndex, com.sun.org.apache.xerces.internal.impl.dtd.XMLElementDecl elementDecl)getElementDecl
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;
| | public int | getElementDeclIndex(java.lang.String elementDeclName)getElementDeclIndex
int mapping = fElementIndexMap.get(elementDeclName);
//System.out.println("getElementDeclIndex("+elementDeclName+") -> "+mapping);
return mapping;
| | public int | getElementDeclIndex(com.sun.org.apache.xerces.internal.xni.QName elementDeclQName)Returns the element decl index.
return getElementDeclIndex(elementDeclQName.rawname);
| | public boolean | getElementDeclIsExternal(int elementDeclIndex)Returns true if the specified element declaration is external.
if (elementDeclIndex < 0) {
return false;
}
int chunk = elementDeclIndex >> CHUNK_SHIFT;
int index = elementDeclIndex & CHUNK_MASK;
return (fElementDeclIsExternal[chunk][index] != 0);
| | public boolean | getEntityDecl(int entityDeclIndex, com.sun.org.apache.xerces.internal.impl.dtd.XMLEntityDecl entityDecl)getEntityDecl
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;
| | public int | getEntityDeclIndex(java.lang.String entityDeclName)getEntityDeclIndex
if (entityDeclName == null) {
return -1;
}
return fEntityIndexMap.get(entityDeclName);
| | public int | getFirstAttributeDeclIndex(int elementDeclIndex)getFirstAttributeDeclIndex
int chunk = elementDeclIndex >> CHUNK_SHIFT;
int index = elementDeclIndex & CHUNK_MASK;
return fElementDeclFirstAttributeDeclIndex[chunk][index];
| | public int | getFirstElementDeclIndex()Returns the index of the first element declaration. This index
is then used to query more information about the element declaration.
return fElementDeclCount >= 0 ? 0 : -1;
| | public com.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarDescription | getGrammarDescription()
return fGrammarDescription;
| | public int | getNextAttributeDeclIndex(int attributeDeclIndex)getNextAttributeDeclIndex
int chunk = attributeDeclIndex >> CHUNK_SHIFT;
int index = attributeDeclIndex & CHUNK_MASK;
return fAttributeDeclNextAttributeDeclIndex[chunk][index];
| | public int | getNextElementDeclIndex(int elementDeclIndex)Returns the next index of the element declaration following the
specified element declaration.
return elementDeclIndex < fElementDeclCount - 1
? elementDeclIndex + 1 : -1;
| | public boolean | getNotationDecl(int notationDeclIndex, com.sun.org.apache.xerces.internal.impl.dtd.XMLNotationDecl notationDecl)getNotationDecl
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;
| | public int | getNotationDeclIndex(java.lang.String notationDeclName)getNotationDeclIndex
if (notationDeclName == null) {
return -1;
}
return fNotationIndexMap.get(notationDeclName);
| | public com.sun.org.apache.xerces.internal.util.SymbolTable | getSymbolTable()Returns the symbol table.
return fSymbolTable;
| | public void | ignoredCharacters(com.sun.org.apache.xerces.internal.xni.XMLString text, com.sun.org.apache.xerces.internal.xni.Augmentations augs)Characters within an IGNORE conditional section.
| | protected void | initializeContentModelStack()Initialize content model stack.
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;
| | public void | internalEntityDecl(java.lang.String name, com.sun.org.apache.xerces.internal.xni.XMLString text, com.sun.org.apache.xerces.internal.xni.XMLString nonNormalizedText, com.sun.org.apache.xerces.internal.xni.Augmentations augs)An internal entity declaration.
int entityIndex = getEntityDeclIndex(name);
if( entityIndex == -1){
entityIndex = createEntityDecl();
boolean isPE = name.startsWith("%");
boolean inExternal = fReadingExternalDTD;
XMLEntityDecl entityDecl = new XMLEntityDecl();
entityDecl.setValues(name,null,null, null, null,
text.toString(), isPE, inExternal);
setEntityDecl(entityIndex, entityDecl);
}
| | public boolean | isCDATAAttribute(com.sun.org.apache.xerces.internal.xni.QName elName, com.sun.org.apache.xerces.internal.xni.QName atName)Returns whether the given attribute is of type CDATA or not
int elDeclIdx = getElementDeclIndex(elName);
int atDeclIdx = getAttributeDeclIndex(elDeclIdx, atName.rawname);
if (getAttributeDecl(elDeclIdx, fAttributeDecl)
&& fAttributeDecl.simpleType.type != XMLSimpleType.TYPE_CDATA){
return false;
}
return true;
| | public boolean | isEntityDeclared(java.lang.String name)
return (getEntityDeclIndex(name)!=-1)?true:false;
| | public boolean | isEntityUnparsed(java.lang.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;
| | boolean | isImmutable()
return fIsImmutable;
| | public boolean | isNamespaceAware()Returns true if this grammar is namespace aware.
return false;
| | public void | notationDecl(java.lang.String name, com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier identifier, com.sun.org.apache.xerces.internal.xni.Augmentations augs)A notation declaration
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);
}
| | public void | occurrence(short occurrence, com.sun.org.apache.xerces.internal.xni.Augmentations augs)The occurrence count for a child in a children content model or
for the mixed content model group.
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 );
}
}
| | public void | pcdata(com.sun.org.apache.xerces.internal.xni.Augmentations augs)The appearance of "#PCDATA" within a group signifying a
mixed content model. This method will be the first called
following the content model's startGroup().
fMixed = true;
| | 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(" }");
}
| | 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(" ]");
| | 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 | processingInstruction(java.lang.String target, com.sun.org.apache.xerces.internal.xni.XMLString data, com.sun.org.apache.xerces.internal.xni.Augmentations augs)A processing instruction. Processing instructions consist of a
target name and, optionally, text data. The data is only meaningful
to the application.
Typically, a processing instruction's data will contain a series
of pseudo-attributes. These pseudo-attributes follow the form of
element attributes but are not parsed or presented
to the application as anything other than text. The application is
responsible for parsing the data.
| | protected void | putElementNameMapping(com.sun.org.apache.xerces.internal.xni.QName name, int scope, int elementDeclIndex)
| | 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 com.sun.org.apache.xerces.internal.impl.dv.DatatypeValidator[][] | resize(com.sun.org.apache.xerces.internal.impl.dv.DatatypeValidator[][] array, int newsize)
DatatypeValidator newarray[][] = new DatatypeValidator[newsize][];
System.arraycopy(array, 0, newarray, 0, array.length);
return newarray;
| | private static com.sun.org.apache.xerces.internal.impl.dtd.models.ContentModelValidator[][] | resize(com.sun.org.apache.xerces.internal.impl.dtd.models.ContentModelValidator[][] array, int newsize)
ContentModelValidator newarray[][] = new ContentModelValidator[newsize][];
System.arraycopy(array, 0, newarray, 0, array.length);
return newarray;
| | private static java.lang.Object[][] | resize(java.lang.Object[][] array, int newsize)
Object newarray[][] = new Object[newsize][];
System.arraycopy(array, 0, newarray, 0, array.length);
return newarray;
| | private static com.sun.org.apache.xerces.internal.xni.QName[][] | resize(com.sun.org.apache.xerces.internal.xni.QName[][] array, int newsize)
QName newarray[][] = new QName[newsize][];
System.arraycopy(array, 0, newarray, 0, array.length);
return newarray;
| | private static java.lang.String[][] | resize(java.lang.String[][] array, int newsize)
String newarray[][] = new String[newsize][];
System.arraycopy(array, 0, newarray, 0, array.length);
return newarray;
| | private static java.lang.String[][][] | resize(java.lang.String[][][] array, int newsize)
String newarray[][][] = new String[newsize] [][];
System.arraycopy(array, 0, newarray, 0, array.length);
return newarray;
| | public void | separator(short separator, com.sun.org.apache.xerces.internal.xni.Augmentations augs)The separator between choices or sequences of a mixed or children
content model.
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;
}
}
| | protected void | setAttributeDecl(int elementDeclIndex, int attributeDeclIndex, com.sun.org.apache.xerces.internal.impl.dtd.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 void | setContentSpec(int contentSpecIndex, com.sun.org.apache.xerces.internal.impl.dtd.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 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;
| | public void | setDTDContentModelSource(com.sun.org.apache.xerces.internal.xni.parser.XMLDTDContentModelSource source)
fDTDContentModelSource = source;
| | public void | setDTDSource(com.sun.org.apache.xerces.internal.xni.parser.XMLDTDSource source)
fDTDSource = source;
| | protected void | setElementDecl(int elementDeclIndex, com.sun.org.apache.xerces.internal.impl.dtd.XMLElementDecl elementDecl)
if (elementDeclIndex < 0 || elementDeclIndex >= fElementDeclCount) {
return;
}
int chunk = elementDeclIndex >> CHUNK_SHIFT;
int index = elementDeclIndex & CHUNK_MASK;
int scope = elementDecl.scope;
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 | setEntityDecl(int entityDeclIndex, com.sun.org.apache.xerces.internal.impl.dtd.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 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 | setNotationDecl(int notationDeclIndex, com.sun.org.apache.xerces.internal.impl.dtd.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);
| | public void | startAttlist(java.lang.String elementName, com.sun.org.apache.xerces.internal.xni.Augmentations augs)The start of an attribute list.
| | public void | startConditional(short type, com.sun.org.apache.xerces.internal.xni.Augmentations augs)The start of a conditional section.
| | public void | startContentModel(java.lang.String elementName, com.sun.org.apache.xerces.internal.xni.Augmentations augs)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.
XMLElementDecl elementDecl = (XMLElementDecl) this.fElementDeclTab.get( elementName);
if ( elementDecl != null ) {
fElementDecl = elementDecl;
}
fDepth = 0;
initializeContentModelStack();
| | public void | startDTD(com.sun.org.apache.xerces.internal.xni.XMLLocator locator, com.sun.org.apache.xerces.internal.xni.Augmentations augs)The start of the DTD.
//Initialize stack
fOpStack = null;
fNodeIndexStack = null;
fPrevNodeIndexStack = null;
| | public void | startExternalSubset(com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier identifier, com.sun.org.apache.xerces.internal.xni.Augmentations augs)The start of the DTD external subset.
fReadingExternalDTD = true;
| | public void | startGroup(com.sun.org.apache.xerces.internal.xni.Augmentations augs)A start of either a mixed or children content model. A mixed
content model will immediately be followed by a call to the
pcdata() method. A children content model will
contain additional groups and/or elements.
fDepth++;
initializeContentModelStack();
fMixed = false;
| | public void | startParameterEntity(java.lang.String name, com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier identifier, java.lang.String encoding, com.sun.org.apache.xerces.internal.xni.Augmentations augs)This method notifies of the start of an entity. The DTD has the
pseudo-name of "[dtd]" and parameter entity names start with '%'.
Note: 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]" before calling
the startDTD method.
// 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++;
| | public void | textDecl(java.lang.String version, java.lang.String encoding, com.sun.org.apache.xerces.internal.xni.Augmentations augs)Notifies of the presence of a TextDecl line in an entity. If present,
this method will be called immediately following the startEntity call.
Note: This method is only called for external
parameter entities referenced in the DTD.
| | public void | unparsedEntityDecl(java.lang.String name, com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier identifier, java.lang.String notation, com.sun.org.apache.xerces.internal.xni.Augmentations augs)An unparsed entity declaration.
XMLEntityDecl entityDecl = new XMLEntityDecl();
boolean isPE = name.startsWith("%");
boolean inExternal = fReadingExternalDTD;
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);
}
|
|
