/*

 * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved.

 */

/*

 * 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 com.sun.org.apache.xerces.internal.impl.dtd;

import com.sun.org.apache.xerces.internal.impl.dtd.models.CMAny;

import com.sun.org.apache.xerces.internal.impl.dtd.models.CMBinOp;

import com.sun.org.apache.xerces.internal.impl.dtd.models.CMLeaf;

import com.sun.org.apache.xerces.internal.impl.dtd.models.CMNode;

import com.sun.org.apache.xerces.internal.impl.dtd.models.CMUniOp;

import com.sun.org.apache.xerces.internal.impl.dtd.models.ContentModelValidator;

import com.sun.org.apache.xerces.internal.impl.dtd.models.DFAContentModel;

import com.sun.org.apache.xerces.internal.impl.dtd.models.MixedContentModel;

import com.sun.org.apache.xerces.internal.impl.dtd.models.SimpleContentModel;

import com.sun.org.apache.xerces.internal.impl.dv.DatatypeValidator;

import com.sun.org.apache.xerces.internal.impl.validation.EntityState;

import com.sun.org.apache.xerces.internal.util.SymbolTable;

import com.sun.org.apache.xerces.internal.xni.Augmentations;

import com.sun.org.apache.xerces.internal.xni.QName;

import com.sun.org.apache.xerces.internal.xni.XMLDTDContentModelHandler;

import com.sun.org.apache.xerces.internal.xni.XMLDTDHandler;

import com.sun.org.apache.xerces.internal.xni.XMLLocator;

import com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier;

import com.sun.org.apache.xerces.internal.xni.XMLString;

import com.sun.org.apache.xerces.internal.xni.XNIException;

import com.sun.org.apache.xerces.internal.xni.grammars.Grammar;

import com.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarDescription;

import com.sun.org.apache.xerces.internal.xni.parser.XMLDTDContentModelSource;

import com.sun.org.apache.xerces.internal.xni.parser.XMLDTDSource;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Random;

/**

 * 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

 *

 * @LastModified: Feb 2020

 */

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 final Map<String, Integer> fElementIndexMap = new HashMap<>();

    /** Entity index mapping table. */

    private final Map<String, Integer> fEntityIndexMap = new HashMap<>();

    /** Notation index mapping table. */

    private final Map<String, Integer> fNotationIndexMap = new HashMap<>();

    // 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   */

    Map<String, XMLElementDecl> fElementDeclTab = new HashMap<>();

    /** 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 {

        // redundant check as this method can only be called after parsing a PE

        // incomplete or truncated DTD get caught before reaching this method

        if (fPEDepth > 0) {

            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 = 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(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;

            List<String> 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 = 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) {

        Integer mapping = fElementIndexMap.get(elementDeclName);

        if (mapping == null) {

            mapping = -1;

        }

        //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