/*

 * Copyright (c) 2007, 2017, 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.xs.traversers;

import com.sun.org.apache.xerces.internal.impl.Constants;

import com.sun.org.apache.xerces.internal.impl.XMLEntityManager;

import com.sun.org.apache.xerces.internal.impl.XMLErrorReporter;

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

import com.sun.org.apache.xerces.internal.impl.dv.xs.XSSimpleTypeDecl;

import com.sun.org.apache.xerces.internal.impl.xs.SchemaGrammar;

import com.sun.org.apache.xerces.internal.impl.xs.SchemaNamespaceSupport;

import com.sun.org.apache.xerces.internal.impl.xs.SchemaSymbols;

import com.sun.org.apache.xerces.internal.impl.xs.XMLSchemaException;

import com.sun.org.apache.xerces.internal.impl.xs.XMLSchemaLoader;

import com.sun.org.apache.xerces.internal.impl.xs.XSAttributeDecl;

import com.sun.org.apache.xerces.internal.impl.xs.XSAttributeGroupDecl;

import com.sun.org.apache.xerces.internal.impl.xs.XSComplexTypeDecl;

import com.sun.org.apache.xerces.internal.impl.xs.XSDDescription;

import com.sun.org.apache.xerces.internal.impl.xs.XSDeclarationPool;

import com.sun.org.apache.xerces.internal.impl.xs.XSElementDecl;

import com.sun.org.apache.xerces.internal.impl.xs.XSGrammarBucket;

import com.sun.org.apache.xerces.internal.impl.xs.XSGroupDecl;

import com.sun.org.apache.xerces.internal.impl.xs.XSMessageFormatter;

import com.sun.org.apache.xerces.internal.impl.xs.XSModelGroupImpl;

import com.sun.org.apache.xerces.internal.impl.xs.XSNotationDecl;

import com.sun.org.apache.xerces.internal.impl.xs.XSParticleDecl;

import com.sun.org.apache.xerces.internal.impl.xs.identity.IdentityConstraint;

import com.sun.org.apache.xerces.internal.impl.xs.opti.ElementImpl;

import com.sun.org.apache.xerces.internal.impl.xs.opti.SchemaDOMParser;

import com.sun.org.apache.xerces.internal.impl.xs.opti.SchemaParsingConfig;

import com.sun.org.apache.xerces.internal.impl.xs.util.SimpleLocator;

import com.sun.org.apache.xerces.internal.impl.xs.util.XSInputSource;

import com.sun.org.apache.xerces.internal.parsers.SAXParser;

import com.sun.org.apache.xerces.internal.parsers.XML11Configuration;

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

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

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

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

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

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

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

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

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

import com.sun.org.apache.xerces.internal.util.URI.MalformedURIException;

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

import com.sun.org.apache.xerces.internal.utils.XMLSecurityManager;

import com.sun.org.apache.xerces.internal.utils.XMLSecurityPropertyManager;

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

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.grammars.XMLGrammarPool;

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

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

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

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

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

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

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

import com.sun.org.apache.xerces.internal.xs.StringList;

import com.sun.org.apache.xerces.internal.xs.XSAttributeDeclaration;

import com.sun.org.apache.xerces.internal.xs.XSAttributeGroupDefinition;

import com.sun.org.apache.xerces.internal.xs.XSAttributeUse;

import com.sun.org.apache.xerces.internal.xs.XSConstants;

import com.sun.org.apache.xerces.internal.xs.XSElementDeclaration;

import com.sun.org.apache.xerces.internal.xs.XSModelGroup;

import com.sun.org.apache.xerces.internal.xs.XSModelGroupDefinition;

import com.sun.org.apache.xerces.internal.xs.XSNamedMap;

import com.sun.org.apache.xerces.internal.xs.XSObject;

import com.sun.org.apache.xerces.internal.xs.XSObjectList;

import com.sun.org.apache.xerces.internal.xs.XSParticle;

import com.sun.org.apache.xerces.internal.xs.XSSimpleTypeDefinition;

import com.sun.org.apache.xerces.internal.xs.XSTerm;

import com.sun.org.apache.xerces.internal.xs.XSTypeDefinition;

import com.sun.org.apache.xerces.internal.xs.datatypes.ObjectList;

import java.io.IOException;

import java.io.StringReader;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Stack;

import javax.xml.XMLConstants;

import javax.xml.catalog.CatalogFeatures;

import javax.xml.stream.XMLEventReader;

import javax.xml.stream.XMLStreamException;

import javax.xml.stream.XMLStreamReader;

import jdk.xml.internal.JdkXmlUtils;

import jdk.xml.internal.SecuritySupport;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.Node;

import org.xml.sax.InputSource;

import org.xml.sax.SAXException;

import org.xml.sax.SAXNotRecognizedException;

import org.xml.sax.SAXParseException;

import org.xml.sax.XMLReader;

/**

 * The purpose of this class is to co-ordinate the construction of a

 * grammar object corresponding to a schema.  To do this, it must be

 * prepared to parse several schema documents (for instance if the

 * schema document originally referred to contains <include> or

 * <redefined> information items).  If any of the schemas imports a

 * schema, other grammars may be constructed as a side-effect.

 *

 * @xerces.internal

 *

 * @author Neil Graham, IBM

 * @author Pavani Mukthipudi, Sun Microsystems

 *

 * @LastModified: Nov 2017

 */

@SuppressWarnings("deprecation") //org.xml.sax.helpers.XMLReaderFactory

public class XSDHandler {

    /** Feature identifier: validation. */

    protected static final String VALIDATION =

        Constants.SAX_FEATURE_PREFIX + Constants.VALIDATION_FEATURE;

    /** feature identifier: XML Schema validation */

    protected static final String XMLSCHEMA_VALIDATION =

        Constants.XERCES_FEATURE_PREFIX + Constants.SCHEMA_VALIDATION_FEATURE;

    /** Feature identifier:  allow java encodings */

    protected static final String ALLOW_JAVA_ENCODINGS =

        Constants.XERCES_FEATURE_PREFIX + Constants.ALLOW_JAVA_ENCODINGS_FEATURE;

    /** Feature identifier:  continue after fatal error */

    protected static final String CONTINUE_AFTER_FATAL_ERROR =

        Constants.XERCES_FEATURE_PREFIX + Constants.CONTINUE_AFTER_FATAL_ERROR_FEATURE;

    /** Feature identifier:  allow java encodings */

    protected static final String STANDARD_URI_CONFORMANT_FEATURE =

        Constants.XERCES_FEATURE_PREFIX + Constants.STANDARD_URI_CONFORMANT_FEATURE;

    /** Feature: disallow doctype*/

    protected static final String DISALLOW_DOCTYPE =

        Constants.XERCES_FEATURE_PREFIX + Constants.DISALLOW_DOCTYPE_DECL_FEATURE;

    /** Feature: generate synthetic annotations */

    protected static final String GENERATE_SYNTHETIC_ANNOTATIONS =

        Constants.XERCES_FEATURE_PREFIX + Constants.GENERATE_SYNTHETIC_ANNOTATIONS_FEATURE;

    /** Feature identifier: validate annotations. */

    protected static final String VALIDATE_ANNOTATIONS =

        Constants.XERCES_FEATURE_PREFIX + Constants.VALIDATE_ANNOTATIONS_FEATURE;

    /** Feature identifier: honour all schemaLocations */

    protected static final String HONOUR_ALL_SCHEMALOCATIONS =

      Constants.XERCES_FEATURE_PREFIX + Constants.HONOUR_ALL_SCHEMALOCATIONS_FEATURE;

    /** Feature identifier: namespace growth */

    protected static final String NAMESPACE_GROWTH =

      Constants.XERCES_FEATURE_PREFIX + Constants.NAMESPACE_GROWTH_FEATURE;

    /** Feature identifier: tolerate duplicates */

    protected static final String TOLERATE_DUPLICATES =

      Constants.XERCES_FEATURE_PREFIX + Constants.TOLERATE_DUPLICATES_FEATURE;

    /** Feature identifier: namespace prefixes. */

    private static final String NAMESPACE_PREFIXES =

        Constants.SAX_FEATURE_PREFIX + Constants.NAMESPACE_PREFIXES_FEATURE;

    /** Feature identifier: string interning. */

    protected static final String STRING_INTERNING =

        Constants.SAX_FEATURE_PREFIX + Constants.STRING_INTERNING_FEATURE;

    /** Property identifier: error handler. */

    protected static final String ERROR_HANDLER =

        Constants.XERCES_PROPERTY_PREFIX + Constants.ERROR_HANDLER_PROPERTY;

    /** Property identifier: JAXP schema source. */

    protected static final String JAXP_SCHEMA_SOURCE =

        Constants.JAXP_PROPERTY_PREFIX + Constants.SCHEMA_SOURCE;

    /** Property identifier: entity resolver. */

    public static final String ENTITY_RESOLVER =

        Constants.XERCES_PROPERTY_PREFIX + Constants.ENTITY_RESOLVER_PROPERTY;

    /** Property identifier: entity manager. */

    protected static final String ENTITY_MANAGER =

        Constants.XERCES_PROPERTY_PREFIX + Constants.ENTITY_MANAGER_PROPERTY;

    /** Property identifier: error reporter. */

    public static final String ERROR_REPORTER =

        Constants.XERCES_PROPERTY_PREFIX + Constants.ERROR_REPORTER_PROPERTY;

    /** Property identifier: grammar pool. */

    public static final String XMLGRAMMAR_POOL =

        Constants.XERCES_PROPERTY_PREFIX + Constants.XMLGRAMMAR_POOL_PROPERTY;

    /** Property identifier: symbol table. */

    public static final String SYMBOL_TABLE =

        Constants.XERCES_PROPERTY_PREFIX + Constants.SYMBOL_TABLE_PROPERTY;

    /** Property identifier: security manager. */

    protected static final String SECURITY_MANAGER =

        Constants.XERCES_PROPERTY_PREFIX + Constants.SECURITY_MANAGER_PROPERTY;

    /** Property identifier: locale. */

    protected static final String LOCALE =

        Constants.XERCES_PROPERTY_PREFIX + Constants.LOCALE_PROPERTY;

    /** Property identifier: Security property manager. */

    private static final String XML_SECURITY_PROPERTY_MANAGER =

        Constants.XML_SECURITY_PROPERTY_MANAGER;

    protected static final boolean DEBUG_NODE_POOL = false;

    // Data

    // different sorts of declarations; should make lookup and

    // traverser calling more efficient/less bulky.

    final static int ATTRIBUTE_TYPE          = 1;

    final static int ATTRIBUTEGROUP_TYPE     = 2;

    final static int ELEMENT_TYPE            = 3;

    final static int GROUP_TYPE              = 4;

    final static int IDENTITYCONSTRAINT_TYPE = 5;

    final static int NOTATION_TYPE           = 6;

    final static int TYPEDECL_TYPE           = 7;

    // this string gets appended to redefined names; it's purpose is to be

    // as unlikely as possible to cause collisions.

    public final static String REDEF_IDENTIFIER = "_fn3dktizrknc9pi";

    //protected data that can be accessible by any traverser

    protected XSDeclarationPool fDeclPool = null;

    // the Security manager in effect.

    protected XMLSecurityManager fSecurityManager = null;

    private String fAccessExternalSchema;

    private String fAccessExternalDTD;

    // These tables correspond to the symbol spaces defined in the

    // spec.

    // They are keyed with a QName (that is, String("URI,localpart) and

    // their values are nodes corresponding to the given name's decl.

    // By asking the node for its ownerDocument and looking in

    // XSDocumentInfoRegistry we can easily get the corresponding

    // XSDocumentInfo object.

    private boolean registryEmpty = true;

    private Map<String, Element> fUnparsedAttributeRegistry = new HashMap<>();

    private Map<String, Element> fUnparsedAttributeGroupRegistry =  new HashMap<>();

    private Map<String, Element> fUnparsedElementRegistry =  new HashMap<>();

    private Map<String, Element> fUnparsedGroupRegistry =  new HashMap<>();

    private Map<String, Element> fUnparsedIdentityConstraintRegistry =  new HashMap<>();

    private Map<String, Element> fUnparsedNotationRegistry =  new HashMap<>();

    private Map<String, Element> fUnparsedTypeRegistry =  new HashMap<>();

    // Compensation for the above maps to locate XSDocumentInfo,

    // Since we may take Schema Element directly, so can not get the

    // corresponding XSDocumentInfo object just using above maps.

    private Map<String, XSDocumentInfo> fUnparsedAttributeRegistrySub =  new HashMap<>();

    private Map<String, XSDocumentInfo> fUnparsedAttributeGroupRegistrySub =  new HashMap<>();

    private Map<String, XSDocumentInfo> fUnparsedElementRegistrySub =  new HashMap<>();

    private Map<String, XSDocumentInfo> fUnparsedGroupRegistrySub =  new HashMap<>();

    private Map<String, XSDocumentInfo> fUnparsedIdentityConstraintRegistrySub =  new HashMap<>();

    private Map<String, XSDocumentInfo> fUnparsedNotationRegistrySub =  new HashMap<>();

    private Map<String, XSDocumentInfo> fUnparsedTypeRegistrySub =  new HashMap<>();

    // Stores XSDocumentInfo (keyed by component name), to check for duplicate

    // components declared within the same xsd document

    @SuppressWarnings({"rawtypes", "unchecked"})

    private Map<String, XSDocumentInfo> fUnparsedRegistriesExt[] = new HashMap[] {

        null,

        null, // ATTRIBUTE_TYPE

        null, // ATTRIBUTEGROUP_TYPE

        null, // ELEMENT_TYPE

        null, // GROUP_TYPE

        null, // IDENTITYCONSTRAINT_TYPE

        null, // NOTATION_TYPE

        null, // TYPEDECL_TYPE

    };

    // this map is keyed on by XSDocumentInfo objects.  Its values

    // are Vectors containing the XSDocumentInfo objects <include>d,

    // <import>ed or <redefine>d by the key XSDocumentInfo.

    private Map<XSDocumentInfo, List<XSDocumentInfo>> fDependencyMap = new HashMap<>();

    // this map is keyed on by a target namespace.  Its values

    // are Vectors containing namespaces imported by schema documents

    // with the key target namespace.

    // if an imported schema has absent namespace, the value "null" is stored.

    private Map<String, List<String>> fImportMap = new HashMap<> ();

    // all namespaces that imports other namespaces

    // if the importing schema has absent namespace, empty string is stored.

    // (because the key of a map can't be null.)

    private List<String> fAllTNSs = new ArrayList<>();

    // stores instance document mappings between namespaces and schema hints

    private Map<String, XMLSchemaLoader.LocationArray> fLocationPairs = null;

    // Records which nodes are hidden when the input is a DOMInputSource.

    Map<Node, String> fHiddenNodes = null;

    // convenience methods

    private String null2EmptyString(String ns) {

        return ns == null ? XMLSymbols.EMPTY_STRING : ns;

    }

    private String emptyString2Null(String ns) {

        return ns == XMLSymbols.EMPTY_STRING ? null : ns;

    }

    // use Schema Element to lookup the SystemId.

    private String doc2SystemId(Element ele) {

        String documentURI = null;

        /**

         * REVISIT: Casting until DOM Level 3 interfaces are available. -- mrglavas

         */

        if(ele.getOwnerDocument() instanceof com.sun.org.apache.xerces.internal.impl.xs.opti.SchemaDOM){

            documentURI = ((com.sun.org.apache.xerces.internal.impl.xs.opti.SchemaDOM) ele.getOwnerDocument()).getDocumentURI();

        }

        return documentURI != null ? documentURI : fDoc2SystemId.get(ele);

    }

    // This vector stores strings which are combinations of the

    // publicId and systemId of the inputSource corresponding to a

    // schema document.  This combination is used so that the user's

    // EntityResolver can provide a consistent way of identifying a

    // schema document that is included in multiple other schemas.

    private Map<XSDKey, Element> fTraversed = new HashMap<>();

    // this map contains a mapping from Schema Element to its systemId

    // this is useful to resolve a uri relative to the referring document

    private Map<Element, String> fDoc2SystemId = new HashMap<>();

    // the primary XSDocumentInfo we were called to parse

    private XSDocumentInfo fRoot = null;

    // This map's job is to act as a link between the Schema Element and its

    // XSDocumentInfo object.

    private Map<Element, XSDocumentInfo> fDoc2XSDocumentMap = new HashMap<>();

    // map between <redefine> elements and the XSDocumentInfo

    // objects that correspond to the documents being redefined.

    private Map<Element, XSDocumentInfo> fRedefine2XSDMap = null;

    // map between <redefine> elements and the namespace support

    private Map<Element, SchemaNamespaceSupport> fRedefine2NSSupport = null;

    // these objects store a mapping between the names of redefining

    // groups/attributeGroups and the groups/AttributeGroups which

    // they redefine by restriction (implicitly).  It is up to the

    // Group and AttributeGroup traversers to check these restrictions for

    // validity.

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

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

    // a variable storing whether the last schema document

    // processed (by getSchema) was a duplicate.

    private boolean fLastSchemaWasDuplicate;

    // validate annotations feature

    private boolean fValidateAnnotations = false;

    //handle multiple import feature

    private boolean fHonourAllSchemaLocations = false;

    //handle namespace growth feature

    boolean fNamespaceGrowth = false;

    // handle tolerate duplicates feature

    boolean fTolerateDuplicates = false;

    // the XMLErrorReporter

    private XMLErrorReporter fErrorReporter;

    // the XMLErrorHandler

    private XMLErrorHandler fErrorHandler;

    // the Locale

    private Locale fLocale;

    // the XMLEntityManager

    private XMLEntityManager fEntityManager;

    // the XSAttributeChecker

    private XSAttributeChecker fAttributeChecker;

    // the symbol table

    private SymbolTable fSymbolTable;

    // the GrammarResolver

    private XSGrammarBucket fGrammarBucket;

    // the Grammar description

    private XSDDescription fSchemaGrammarDescription;

    // the Grammar Pool

    private XMLGrammarPool fGrammarPool;

    // the security property manager

    private XMLSecurityPropertyManager fSecurityPropertyMgr = null;

    /** indicate whether Catalog should be used for resolving external resources */

    private boolean fUseCatalog = true;

    private String fCatalogFile;

    private String fDefer;

    private String fPrefer;

    private String fResolve;

    private boolean fOverrideDefaultParser;

    //************ Traversers **********

    XSDAttributeGroupTraverser fAttributeGroupTraverser;

    XSDAttributeTraverser fAttributeTraverser;

    XSDComplexTypeTraverser fComplexTypeTraverser;

    XSDElementTraverser fElementTraverser;

    XSDGroupTraverser fGroupTraverser;

    XSDKeyrefTraverser fKeyrefTraverser;

    XSDNotationTraverser fNotationTraverser;

    XSDSimpleTypeTraverser fSimpleTypeTraverser;

    XSDUniqueOrKeyTraverser fUniqueOrKeyTraverser;

    XSDWildcardTraverser fWildCardTraverser;

    SchemaDVFactory fDVFactory;

    SchemaDOMParser fSchemaParser;

    SchemaContentHandler fXSContentHandler;

    StAXSchemaParser fStAXSchemaParser;

    XML11Configuration fAnnotationValidator;

    XSAnnotationGrammarPool fGrammarBucketAdapter;

    // these data members are needed for the deferred traversal

    // of local elements.

    // the initial size of the array to store deferred local elements

    private static final int INIT_STACK_SIZE = 30;

    // the incremental size of the array to store deferred local elements

    private static final int INC_STACK_SIZE  = 10;

    // current position of the array (# of deferred local elements)

    private int fLocalElemStackPos = 0;

    private XSParticleDecl[] fParticle = new XSParticleDecl[INIT_STACK_SIZE];

    private Element[] fLocalElementDecl = new Element[INIT_STACK_SIZE];

    private XSDocumentInfo[] fLocalElementDecl_schema = new XSDocumentInfo[INIT_STACK_SIZE]; //JACK

    private int[] fAllContext = new int[INIT_STACK_SIZE];

    private XSObject[] fParent = new XSObject[INIT_STACK_SIZE];

    private String [][] fLocalElemNamespaceContext = new String [INIT_STACK_SIZE][1];

    // these data members are needed for the deferred traversal

    // of keyrefs.

    // the initial size of the array to store deferred keyrefs

    private static final int INIT_KEYREF_STACK = 2;

    // the incremental size of the array to store deferred keyrefs

    private static final int INC_KEYREF_STACK_AMOUNT = 2;

    // current position of the array (# of deferred keyrefs)

    private int fKeyrefStackPos = 0;

    private Element [] fKeyrefs = new Element[INIT_KEYREF_STACK];

    private XSDocumentInfo [] fKeyrefsMapXSDocumentInfo = new XSDocumentInfo[INIT_KEYREF_STACK];

    private XSElementDecl [] fKeyrefElems = new XSElementDecl [INIT_KEYREF_STACK];

    private String [][] fKeyrefNamespaceContext = new String[INIT_KEYREF_STACK][1];

    // global decls: map from decl name to decl object

    SymbolHash fGlobalAttrDecls = new SymbolHash(12);

    SymbolHash fGlobalAttrGrpDecls = new SymbolHash(5);

    SymbolHash fGlobalElemDecls = new SymbolHash(25);

    SymbolHash fGlobalGroupDecls = new SymbolHash(5);

    SymbolHash fGlobalNotationDecls = new SymbolHash(1);

    SymbolHash fGlobalIDConstraintDecls = new SymbolHash(3);

    SymbolHash fGlobalTypeDecls = new SymbolHash(25);

    // Constructors

    public XSDHandler(){

        fHiddenNodes = new HashMap<>();

        fSchemaParser = new SchemaDOMParser(new SchemaParsingConfig());

    }

    // it should be possible to use the same XSDHandler to parse

    // multiple schema documents; this will allow one to be

    // constructed.

    public XSDHandler (XSGrammarBucket gBucket) {

        this();

        fGrammarBucket = gBucket;

        // Note: don't use SchemaConfiguration internally

        //       we will get stack overflaw because

        //       XMLSchemaValidator will be instantiating XSDHandler...

        fSchemaGrammarDescription = new XSDDescription();

    } // end constructor

    /**

     * This method initiates the parse of a schema.  It will likely be

     * called from the Validator and it will make the

     * resulting grammar available; it returns a reference to this object just

     * in case.  A reset(XMLComponentManager) must be called before this methods is called.

     * @param is

     * @param desc

     * @param locationPairs

     * @return the SchemaGrammar

     * @throws IOException

     */

    public SchemaGrammar parseSchema(XMLInputSource is, XSDDescription desc,

            Map<String, XMLSchemaLoader.LocationArray> locationPairs)

    throws IOException {

        fLocationPairs = locationPairs;

        fSchemaParser.resetNodePool();

        SchemaGrammar grammar = null;

        String schemaNamespace  = null;

        short referType = desc.getContextType();

        // if loading using JAXP schemaSource property, or using grammar caching loadGrammar

        // the desc.targetNamespace is always null.

        // Therefore we should not attempt to find out if

        // the schema is already in the bucket, since in the case we have

        // no namespace schema in the bucket, findGrammar will always return the

        // no namespace schema.

        if (referType != XSDDescription.CONTEXT_PREPARSE){

            // first try to find it in the bucket/pool, return if one is found

            if (fHonourAllSchemaLocations && referType == XSDDescription.CONTEXT_IMPORT && isExistingGrammar(desc, fNamespaceGrowth)) {

                grammar = fGrammarBucket.getGrammar(desc.getTargetNamespace());

            }

            else {

                grammar = findGrammar(desc, fNamespaceGrowth);

            }

            if (grammar != null) {

                if (!fNamespaceGrowth) {

                    return grammar;

                }

                else {

                    try {

                        if (grammar.getDocumentLocations().contains(XMLEntityManager.expandSystemId(is.getSystemId(), is.getBaseSystemId(), false))) {

                            return grammar;

                        }

                    }

                    catch (MalformedURIException e) {

                        //REVISIT: return the grammar?

                    }

                }

            }

            schemaNamespace = desc.getTargetNamespace();

            // handle empty string URI as null

            if (schemaNamespace != null) {

                schemaNamespace = fSymbolTable.addSymbol(schemaNamespace);

            }

        }

        // before parsing a schema, need to clear registries associated with

        // parsing schemas

        prepareForParse();

        Element schemaRoot = null;

        // first phase:  construct trees.

        if (is instanceof DOMInputSource) {

            schemaRoot = getSchemaDocument(schemaNamespace, (DOMInputSource) is,

                    referType == XSDDescription.CONTEXT_PREPARSE,

                    referType, null);

        } // DOMInputSource

        else if (is instanceof SAXInputSource) {

                schemaRoot = getSchemaDocument(schemaNamespace, (SAXInputSource) is,

                    referType == XSDDescription.CONTEXT_PREPARSE,

                    referType, null);

        } // SAXInputSource

        else if (is instanceof StAXInputSource) {

            schemaRoot = getSchemaDocument(schemaNamespace, (StAXInputSource) is,

                    referType == XSDDescription.CONTEXT_PREPARSE,

                    referType, null);

        } // StAXInputSource

        else if (is instanceof XSInputSource) {

            schemaRoot = getSchemaDocument((XSInputSource) is, desc);

        } // XSInputSource

        else {

                schemaRoot = getSchemaDocument(schemaNamespace, is,

                  referType == XSDDescription.CONTEXT_PREPARSE,

                  referType, null);

        } //is instanceof XMLInputSource

        if (schemaRoot == null) {

            // something went wrong right off the hop

            if (is instanceof XSInputSource) {

                return fGrammarBucket.getGrammar(desc.getTargetNamespace());

            }

            return grammar;

        }

        if (referType == XSDDescription.CONTEXT_PREPARSE) {

                Element schemaElem = schemaRoot;

            schemaNamespace = DOMUtil.getAttrValue(schemaElem, SchemaSymbols.ATT_TARGETNAMESPACE);

            if(schemaNamespace != null && schemaNamespace.length() > 0) {

                // Since now we've discovered a namespace, we need to update xsd key

                // and store this schema in traversed schemas bucket

                schemaNamespace = fSymbolTable.addSymbol(schemaNamespace);

                desc.setTargetNamespace(schemaNamespace);

            }

            else {

                schemaNamespace = null;

            }

            grammar = findGrammar(desc, fNamespaceGrowth);

            String schemaId = XMLEntityManager.expandSystemId(is.getSystemId(), is.getBaseSystemId(), false);

            if (grammar != null) {

                // When namespace growth is enabled and a null location is provided we cannot tell

                // whether we've loaded this schema document before so we must assume that we haven't.

                if (!fNamespaceGrowth || (schemaId != null && grammar.getDocumentLocations().contains(schemaId))) {

                    return grammar;

                }

            }

            XSDKey key = new XSDKey(schemaId, referType, schemaNamespace);

            fTraversed.put(key, schemaRoot);

            if (schemaId != null) {

                fDoc2SystemId.put(schemaRoot, schemaId);

            }

        }

        // before constructing trees and traversing a schema, need to reset

        // all traversers and clear all registries

        prepareForTraverse();

        fRoot = constructTrees(schemaRoot, is.getSystemId(), desc, grammar != null);

        if (fRoot == null) {

            return null;

        }

        // second phase:  fill global registries.

        buildGlobalNameRegistries();

        // third phase:  call traversers

        List<Object> annotationInfo = fValidateAnnotations ? new ArrayList<>() : null;

        traverseSchemas(annotationInfo);

        // fourth phase: handle local element decls

        traverseLocalElements();

        // fifth phase:  handle Keyrefs

        resolveKeyRefs();

        // sixth phase:  validate attribute of non-schema namespaces

        // REVISIT: skip this for now. we really don't want to do it.

        //fAttributeChecker.checkNonSchemaAttributes(fGrammarBucket);

        // seventh phase:  store imported grammars

        // for all grammars with <import>s

        for (int i = fAllTNSs.size() - 1; i >= 0; i--) {

            // get its target namespace

            String tns = fAllTNSs.get(i);

            // get all namespaces it imports

            List<String> ins = fImportMap.get(tns);

            List<SchemaGrammar> grammars = new ArrayList<>();

            // get the grammar

            SchemaGrammar sg = fGrammarBucket.getGrammar(emptyString2Null(tns));

            if (sg == null)

                continue;

            SchemaGrammar isg;

            // for imported namespace

            int count = 0;

            for (int j = 0; j < ins.size(); j++) {

                // get imported grammar

                isg = fGrammarBucket.getGrammar(ins.get(j));

                // reuse the same vector

                if (isg != null) {

                    grammars.add(isg);

                }

            }

            // set the imported grammars

            sg.setImportedGrammars(grammars);

        }

        /** validate annotations **/

        if (fValidateAnnotations && annotationInfo.size() > 0) {

            validateAnnotations(annotationInfo);

        }

        // and return.

        return fGrammarBucket.getGrammar(fRoot.fTargetNamespace);

    } // end parseSchema

    private void validateAnnotations(List<Object> annotationInfo) {

        if (fAnnotationValidator == null) {

            createAnnotationValidator();

        }

        final int size = annotationInfo.size();

        final XMLInputSource src = new XMLInputSource(null, null, null, false);

        fGrammarBucketAdapter.refreshGrammars(fGrammarBucket);

        for (int i = 0; i < size; i += 2) {

            src.setSystemId((String) annotationInfo.get(i));

            XSAnnotationInfo annotation = (XSAnnotationInfo) annotationInfo.get(i+1);

            while (annotation != null) {

                src.setCharacterStream(new StringReader(annotation.fAnnotation));

                try {

                    fAnnotationValidator.parse(src);

                }

                catch (IOException exc) {}

                annotation = annotation.next;

            }

        }

    }

    private void createAnnotationValidator() {

        fAnnotationValidator = new XML11Configuration();

        fGrammarBucketAdapter = new XSAnnotationGrammarPool();

        fAnnotationValidator.setFeature(VALIDATION, true);

        fAnnotationValidator.setFeature(XMLSCHEMA_VALIDATION, true);

        fAnnotationValidator.setProperty(XMLGRAMMAR_POOL, fGrammarBucketAdapter);

        /** set security manager and XML Security Property Manager **/

        fAnnotationValidator.setProperty(SECURITY_MANAGER, (fSecurityManager != null) ? fSecurityManager : new XMLSecurityManager(true));

        fAnnotationValidator.setProperty(XML_SECURITY_PROPERTY_MANAGER, fSecurityPropertyMgr);

        /** Set error handler. **/

        fAnnotationValidator.setProperty(ERROR_HANDLER, (fErrorHandler != null) ? fErrorHandler : new DefaultErrorHandler());

        /** Set locale. **/

        fAnnotationValidator.setProperty(LOCALE, fLocale);

        // Passing on the Catalog settings

        fAnnotationValidator.setFeature(XMLConstants.USE_CATALOG, fUseCatalog);

        fAnnotationValidator.setProperty(JdkXmlUtils.CATALOG_FILES, fCatalogFile);

        fAnnotationValidator.setProperty(JdkXmlUtils.CATALOG_DEFER, fDefer);

        fAnnotationValidator.setProperty(JdkXmlUtils.CATALOG_PREFER, fPrefer);

        fAnnotationValidator.setProperty(JdkXmlUtils.CATALOG_RESOLVE, fResolve);

    }

    /**

     * Pull the grammar out of the bucket simply using

     * its TNS as a key

     */

    SchemaGrammar getGrammar(String tns) {

        return fGrammarBucket.getGrammar(tns);

    }

    /**

     * First try to find a grammar in the bucket, if failed, consult the

     * grammar pool. If a grammar is found in the pool, then add it (and all

     * imported ones) into the bucket.

     */

    protected SchemaGrammar findGrammar(XSDDescription desc, boolean ignoreConflict) {

        SchemaGrammar sg = fGrammarBucket.getGrammar(desc.getTargetNamespace());

        if (sg == null) {

            if (fGrammarPool != null) {

                sg = (SchemaGrammar)fGrammarPool.retrieveGrammar(desc);

                if (sg != null) {

                    // put this grammar into the bucket, along with grammars

                    // imported by it (directly or indirectly)

                    if (!fGrammarBucket.putGrammar(sg, true, ignoreConflict)) {

                        // REVISIT: a conflict between new grammar(s) and grammars

                        // in the bucket. What to do? A warning? An exception?

                        reportSchemaWarning("GrammarConflict", null, null);

                        sg = null;

                    }

                }

            }

        }

        return sg;

    }

    // may wish to have setter methods for ErrorHandler,

    // EntityResolver...

    private static final String[][] NS_ERROR_CODES = {

            {"src-include.2.1", "src-include.2.1"},

            {"src-redefine.3.1", "src-redefine.3.1"},

            {"src-import.3.1", "src-import.3.2"},

            null,

            {"TargetNamespace.1", "TargetNamespace.2"},

            {"TargetNamespace.1", "TargetNamespace.2"},

            {"TargetNamespace.1", "TargetNamespace.2"},

            {"TargetNamespace.1", "TargetNamespace.2"}

    };

    private static final String[] ELE_ERROR_CODES = {

            "src-include.1", "src-redefine.2", "src-import.2", "schema_reference.4",

            "schema_reference.4", "schema_reference.4", "schema_reference.4", "schema_reference.4"

    };

    // This method does several things:

    // It constructs an instance of an XSDocumentInfo object using the

    // schemaRoot node.  Then, for each <include>,

    // <redefine>, and <import> children, it attempts to resolve the

    // requested schema document, initiates a DOM parse, and calls

    // itself recursively on that document's root.  It also records in

    // the DependencyMap object what XSDocumentInfo objects its XSDocumentInfo

    // depends on.

    // It also makes sure the targetNamespace of the schema it was

    // called to parse is correct.

    protected XSDocumentInfo constructTrees(Element schemaRoot, String locationHint, XSDDescription desc, boolean nsCollision) {

        if (schemaRoot == null) return null;

        String callerTNS = desc.getTargetNamespace();

        short referType = desc.getContextType();

        XSDocumentInfo currSchemaInfo = null;

        try {

            // note that attributes are freed at end of traverseSchemas()

            currSchemaInfo = new XSDocumentInfo(schemaRoot, fAttributeChecker, fSymbolTable);

        } catch (XMLSchemaException se) {

            reportSchemaError(ELE_ERROR_CODES[referType],

                    new Object[]{locationHint},

                                          schemaRoot);

            return null;

        }

        // targetNamespace="" is not valid, issue a warning, and ignore it

        if (currSchemaInfo.fTargetNamespace != null &&

                currSchemaInfo.fTargetNamespace.length() == 0) {

            reportSchemaWarning("EmptyTargetNamespace",

                    new Object[]{locationHint},

                                        schemaRoot);

            currSchemaInfo.fTargetNamespace = null;

        }

        if (callerTNS != null) {

            // the second index to the NS_ERROR_CODES array

            // if the caller/expected NS is not absent, we use the first column

            int secondIdx = 0;

            // for include and redefine

            if (referType == XSDDescription.CONTEXT_INCLUDE ||

                    referType == XSDDescription.CONTEXT_REDEFINE) {

                // if the referred document has no targetNamespace,

                // it's a chameleon schema

                if (currSchemaInfo.fTargetNamespace == null) {

                    currSchemaInfo.fTargetNamespace = callerTNS;

                    currSchemaInfo.fIsChameleonSchema = true;

                }

                // if the referred document has a target namespace differing

                // from the caller, it's an error

                else if (callerTNS != currSchemaInfo.fTargetNamespace) {

                    reportSchemaError(NS_ERROR_CODES[referType][secondIdx],

                            new Object [] {callerTNS, currSchemaInfo.fTargetNamespace},

                                                        schemaRoot);

                    return null;

                }

            }

            // for instance and import, the two NS's must be the same

            else if (referType != XSDDescription.CONTEXT_PREPARSE && callerTNS != currSchemaInfo.fTargetNamespace) {

                reportSchemaError(NS_ERROR_CODES[referType][secondIdx],

                        new Object [] {callerTNS, currSchemaInfo.fTargetNamespace},

                                                schemaRoot);

                return null;

            }

        }

        // now there is no caller/expected NS, it's an error for the referred

        // document to have a target namespace, unless we are preparsing a schema

        else if (currSchemaInfo.fTargetNamespace != null) {

            // set the target namespace of the description

            if (referType == XSDDescription.CONTEXT_PREPARSE) {

                desc.setTargetNamespace(currSchemaInfo.fTargetNamespace);

                callerTNS = currSchemaInfo.fTargetNamespace;

            }

            else {

                // the second index to the NS_ERROR_CODES array

                // if the caller/expected NS is absent, we use the second column

                int secondIdx = 1;

                reportSchemaError(NS_ERROR_CODES[referType][secondIdx],

                        new Object [] {callerTNS, currSchemaInfo.fTargetNamespace},

                                                schemaRoot);

                return null;

            }

        }

        // the other cases (callerTNS == currSchemaInfo.fTargetNamespce == null)

        // are valid

        // a schema document can always access it's own target namespace

        currSchemaInfo.addAllowedNS(currSchemaInfo.fTargetNamespace);

        SchemaGrammar sg = null;

        // we have a namespace collision

        if (nsCollision) {

            SchemaGrammar sg2 = fGrammarBucket.getGrammar(currSchemaInfo.fTargetNamespace);

            if (sg2.isImmutable()) {

                sg = new SchemaGrammar(sg2);

                fGrammarBucket.putGrammar(sg);

                // update all the grammars in the bucket to point to the new grammar.

                updateImportListWith(sg);

            }

            else {

                sg = sg2;

            }

            // update import list of the new grammar

            updateImportListFor(sg);

        }

        else if (referType == XSDDescription.CONTEXT_INCLUDE ||

                referType == XSDDescription.CONTEXT_REDEFINE) {

            sg = fGrammarBucket.getGrammar(currSchemaInfo.fTargetNamespace);

        }

        else if(fHonourAllSchemaLocations && referType == XSDDescription.CONTEXT_IMPORT) {

            sg = findGrammar(desc, false);

            if(sg == null) {

                sg = new SchemaGrammar(currSchemaInfo.fTargetNamespace, desc.makeClone(), fSymbolTable);

                fGrammarBucket.putGrammar(sg);

            }

        }

        else {

            sg = new SchemaGrammar(currSchemaInfo.fTargetNamespace, desc.makeClone(), fSymbolTable);

            fGrammarBucket.putGrammar(sg);

        }

        // store the document and its location

        // REVISIT: don't expose the DOM tree

        sg.addDocument(null, fDoc2SystemId.get(currSchemaInfo.fSchemaElement));

        fDoc2XSDocumentMap.put(schemaRoot, currSchemaInfo);

        List<XSDocumentInfo> dependencies = new ArrayList<>();

        Element rootNode = schemaRoot;

        Element newSchemaRoot = null;

        for (Element child = DOMUtil.getFirstChildElement(rootNode);

        child != null;

        child = DOMUtil.getNextSiblingElement(child)) {

            String schemaNamespace=null;

            String schemaHint=null;

            String localName = DOMUtil.getLocalName(child);

            short refType = -1;

            boolean importCollision = false;

            if (localName.equals(SchemaSymbols.ELT_ANNOTATION))

                continue;

            else if (localName.equals(SchemaSymbols.ELT_IMPORT)) {

                refType = XSDDescription.CONTEXT_IMPORT;

                // have to handle some validation here too!

                // call XSAttributeChecker to fill in attrs

                Object[] importAttrs = fAttributeChecker.checkAttributes(child, true, currSchemaInfo);

                schemaHint = (String)importAttrs[XSAttributeChecker.ATTIDX_SCHEMALOCATION];

                schemaNamespace = (String)importAttrs[XSAttributeChecker.ATTIDX_NAMESPACE];

                if (schemaNamespace != null)

                    schemaNamespace = fSymbolTable.addSymbol(schemaNamespace);

                // check contents and process optional annotations

                Element importChild = DOMUtil.getFirstChildElement(child);

                if(importChild != null ) {

                    String importComponentType = DOMUtil.getLocalName(importChild);

                    if (importComponentType.equals(SchemaSymbols.ELT_ANNOTATION)) {

                        // promoting annotations to parent component

                        sg.addAnnotation(

                                fElementTraverser.traverseAnnotationDecl(importChild, importAttrs, true, currSchemaInfo));

                    } else {

                        reportSchemaError("s4s-elt-must-match.1", new Object [] {localName, "annotation?", importComponentType}, child);

                    }

                    if(DOMUtil.getNextSiblingElement(importChild) != null) {

                        reportSchemaError("s4s-elt-must-match.1", new Object [] {localName, "annotation?", DOMUtil.getLocalName(DOMUtil.getNextSiblingElement(importChild))}, child);

                    }

                }

                else {

                    String text = DOMUtil.getSyntheticAnnotation(child);

                    if (text != null) {

                        sg.addAnnotation(fElementTraverser.traverseSyntheticAnnotation(child, text, importAttrs, true, currSchemaInfo));

                    }

                }

                fAttributeChecker.returnAttrArray(importAttrs, currSchemaInfo);

                // a document can't import another document with the same namespace

                if (schemaNamespace == currSchemaInfo.fTargetNamespace) {

                    reportSchemaError(schemaNamespace != null ?

                            "src-import.1.1" : "src-import.1.2", new Object [] {schemaNamespace}, child);

                    continue;

                }

                // if this namespace has not been imported by this document,

                //  then import if multiple imports support is enabled.

                if(currSchemaInfo.isAllowedNS(schemaNamespace)) {

                    if(!fHonourAllSchemaLocations && !fNamespaceGrowth)

                        continue;

                }

                else  {

                    currSchemaInfo.addAllowedNS(schemaNamespace);

                }

                // also record the fact that one namespace imports another one

                // convert null to ""

                String tns = null2EmptyString(currSchemaInfo.fTargetNamespace);

                // get all namespaces imported by this one

               List<String> ins = fImportMap.get(tns);

                // if no namespace was imported, create new ArrayList<>

                if (ins == null) {

                    // record that this one imports other(s)

                    fAllTNSs.add(tns);

                    ins = new ArrayList<>();

                    fImportMap.put(tns, ins);

                    ins.add(schemaNamespace);

                }

                else if (!ins.contains(schemaNamespace)){

                    ins.add(schemaNamespace);

                }

                fSchemaGrammarDescription.reset();

                fSchemaGrammarDescription.setContextType(XSDDescription.CONTEXT_IMPORT);

                fSchemaGrammarDescription.setBaseSystemId(doc2SystemId(schemaRoot));

                fSchemaGrammarDescription.setLiteralSystemId(schemaHint);

                fSchemaGrammarDescription.setLocationHints(new String[]{schemaHint});

                fSchemaGrammarDescription.setTargetNamespace(schemaNamespace);

                // if a grammar with the same namespace and location exists (or being

                // built), ignore this one (don't traverse it).

                SchemaGrammar isg = findGrammar(fSchemaGrammarDescription, fNamespaceGrowth);

                if (isg != null) {

                    if (fNamespaceGrowth) {

                        try {

                            if (isg.getDocumentLocations().contains(XMLEntityManager.expandSystemId(schemaHint, fSchemaGrammarDescription.getBaseSystemId(), false))) {

                                continue;

                            }

                            else {

                                importCollision = true;

                            }

                        }

                        catch (MalformedURIException e) {

                        }

                    }

                    else if (!fHonourAllSchemaLocations || isExistingGrammar(fSchemaGrammarDescription, false)) {

                        continue;

                    }

                }

                //if ((!fHonourAllSchemaLocations && findGrammar(fSchemaGrammarDescription) != null) || isExistingGrammar(fSchemaGrammarDescription))

                //    continue;

                // If "findGrammar" returns a grammar, then this is not the

                // the first time we see a location for a given namespace.

                // Don't consult the location pair map in this case,

                // otherwise the location will be ignored because it'll get

                // resolved to the same location as the first hint.

                newSchemaRoot = resolveSchema(fSchemaGrammarDescription, false, child, isg == null);

            }

            else if ((localName.equals(SchemaSymbols.ELT_INCLUDE)) ||

                    (localName.equals(SchemaSymbols.ELT_REDEFINE))) {

                // validation for redefine/include will be the same here; just

                // make sure TNS is right (don't care about redef contents

                // yet).

                Object[] includeAttrs = fAttributeChecker.checkAttributes(child, true, currSchemaInfo);

                schemaHint = (String)includeAttrs[XSAttributeChecker.ATTIDX_SCHEMALOCATION];

                // store the namespace decls of the redefine element

                if (localName.equals(SchemaSymbols.ELT_REDEFINE)) {

                    if (fRedefine2NSSupport == null) fRedefine2NSSupport = new HashMap<>();

                    fRedefine2NSSupport.put(child, new SchemaNamespaceSupport(currSchemaInfo.fNamespaceSupport));

                }

                // check annotations.  Must do this here to avoid having to

                // re-parse attributes later

                if(localName.equals(SchemaSymbols.ELT_INCLUDE)) {

                    Element includeChild = DOMUtil.getFirstChildElement(child);

                    if(includeChild != null ) {

                        String includeComponentType = DOMUtil.getLocalName(includeChild);

                        if (includeComponentType.equals(SchemaSymbols.ELT_ANNOTATION)) {

                            // promoting annotations to parent component

                            sg.addAnnotation(

                                    fElementTraverser.traverseAnnotationDecl(includeChild, includeAttrs, true, currSchemaInfo));

                        } else {

                            reportSchemaError("s4s-elt-must-match.1",

                                    new Object [] {localName, "annotation?", includeComponentType}, child);

                        }

                        if(DOMUtil.getNextSiblingElement(includeChild) != null) {

                            reportSchemaError("s4s-elt-must-match.1",

                                    new Object [] {localName, "annotation?",

                                        DOMUtil.getLocalName(DOMUtil.getNextSiblingElement(includeChild))}, child);

                        }

                    }

                    else {

                        String text = DOMUtil.getSyntheticAnnotation(child);

                        if (text != null) {

                            sg.addAnnotation(fElementTraverser.traverseSyntheticAnnotation(child, text, includeAttrs, true, currSchemaInfo));

                        }

                    }

                }

                else {

                    for (Element redefinedChild = DOMUtil.getFirstChildElement(child);

                    redefinedChild != null;

                    redefinedChild = DOMUtil.getNextSiblingElement(redefinedChild)) {

                        String redefinedComponentType = DOMUtil.getLocalName(redefinedChild);

                        if (redefinedComponentType.equals(SchemaSymbols.ELT_ANNOTATION)) {

                            // promoting annotations to parent component

                            sg.addAnnotation(

                                    fElementTraverser.traverseAnnotationDecl(redefinedChild, includeAttrs, true, currSchemaInfo));

                            DOMUtil.setHidden(redefinedChild, fHiddenNodes);

                        }

                        else {

                            String text = DOMUtil.getSyntheticAnnotation(child);

                            if (text != null) {

                                sg.addAnnotation(fElementTraverser.traverseSyntheticAnnotation(child, text, includeAttrs, true, currSchemaInfo));

                            }

                        }

                        // catch all other content errors later

                    }

                }

                fAttributeChecker.returnAttrArray(includeAttrs, currSchemaInfo);

                // schemaLocation is required on <include> and <redefine>

                if (schemaHint == null) {

                    reportSchemaError("s4s-att-must-appear", new Object [] {

                            "<include> or <redefine>", "schemaLocation"},

                            child);

                }

                // pass the systemId of the current document as the base systemId

                boolean mustResolve = false;

                refType = XSDDescription.CONTEXT_INCLUDE;

                if(localName.equals(SchemaSymbols.ELT_REDEFINE)) {

                    mustResolve = nonAnnotationContent(child);

                    refType = XSDDescription.CONTEXT_REDEFINE;

                }

                fSchemaGrammarDescription.reset();

                fSchemaGrammarDescription.setContextType(refType);

                fSchemaGrammarDescription.setBaseSystemId(doc2SystemId(schemaRoot));

                fSchemaGrammarDescription.setLocationHints(new String[]{schemaHint});

                fSchemaGrammarDescription.setTargetNamespace(callerTNS);

                boolean alreadyTraversed = false;

                XMLInputSource schemaSource =

                        resolveSchemaSource(fSchemaGrammarDescription, mustResolve, child, true);

                if (fNamespaceGrowth && refType == XSDDescription.CONTEXT_INCLUDE) {

                    try {

                        final String schemaId = XMLEntityManager.expandSystemId(

                                schemaSource.getSystemId(), schemaSource.getBaseSystemId(), false);

                        alreadyTraversed = sg.getDocumentLocations().contains(schemaId);

                    }

                    catch(MalformedURIException e) {

                    }

                }

                if (!alreadyTraversed) {

                    newSchemaRoot = resolveSchema(schemaSource, fSchemaGrammarDescription, mustResolve, child);

                    schemaNamespace = currSchemaInfo.fTargetNamespace;

                }

                else {

                    fLastSchemaWasDuplicate = true;

                }

            }

            else {

                // no more possibility of schema references in well-formed

                // schema...

                break;

            }

            // If the schema is duplicate, we needn't call constructTrees() again.

            // To handle mutual <include>s

            XSDocumentInfo newSchemaInfo = null;

            if (fLastSchemaWasDuplicate) {

                newSchemaInfo = newSchemaRoot == null ? null : fDoc2XSDocumentMap.get(newSchemaRoot);

            }

            else {

                newSchemaInfo = constructTrees(newSchemaRoot, schemaHint,

                        fSchemaGrammarDescription, importCollision);

            }

            if (localName.equals(SchemaSymbols.ELT_REDEFINE) &&

                    newSchemaInfo != null) {

                // must record which schema we're redefining so that we can

                // rename the right things later!

                if (fRedefine2XSDMap == null) fRedefine2XSDMap = new HashMap<>();

                fRedefine2XSDMap.put(child, newSchemaInfo);

            }

            if (newSchemaRoot != null) {

                if (newSchemaInfo != null)

                    dependencies.add(newSchemaInfo);

                newSchemaRoot = null;

            }

        }

        fDependencyMap.put(currSchemaInfo, dependencies);

        return currSchemaInfo;

    } // end constructTrees

    private boolean isExistingGrammar(XSDDescription desc, boolean ignoreConflict) {

        SchemaGrammar sg = fGrammarBucket.getGrammar(desc.getTargetNamespace());

        if (sg == null) {

            return findGrammar(desc, ignoreConflict) != null;

        }

        else if (sg.isImmutable()) {

            return true;

        }

        else {

            try {

                return sg.getDocumentLocations().contains(XMLEntityManager.expandSystemId(desc.getLiteralSystemId(), desc.getBaseSystemId(), false));

            }

            catch (MalformedURIException e) {

                return false;

            }

        }

    }

    /**

     * Namespace growth

     *

     * Go through the import list of a given grammar and for each imported

     * grammar, check to see if the grammar bucket has a newer version.

     * If a new instance is found, we update the import list with the

     * newer version.

     */

    private void updateImportListFor(SchemaGrammar grammar) {

       List<SchemaGrammar> importedGrammars = grammar.getImportedGrammars();

        if (importedGrammars != null) {

            for (int i=0; i<importedGrammars.size(); i++) {

                SchemaGrammar isg1 = importedGrammars.get(i);

                SchemaGrammar isg2 = fGrammarBucket.getGrammar(isg1.getTargetNamespace());

                if (isg2 != null && isg1 != isg2) {

                    importedGrammars.set(i, isg2);

                }

            }

        }

    }

    /**

     * Namespace growth

     *

     * Go throuth the grammar bucket, and for each grammar in the bucket

     * check the import list. If there exists a grammar in import list

     * that has the same namespace as newGrammar, but a different instance,

     * then update the import list and replace the old grammar instance with

     * the new one

     */

    private void updateImportListWith(SchemaGrammar newGrammar) {

        SchemaGrammar[] schemaGrammars = fGrammarBucket.getGrammars();

        for (int i = 0; i < schemaGrammars.length; ++i) {

            SchemaGrammar sg = schemaGrammars[i];

            if (sg != newGrammar) {

                List<SchemaGrammar> importedGrammars = sg.getImportedGrammars();

                if (importedGrammars != null) {

                    for (int j=0; j<importedGrammars.size(); j++) {

                        SchemaGrammar isg = importedGrammars.get(j);

                        if (null2EmptyString(isg.getTargetNamespace()).equals(

                                null2EmptyString(newGrammar.getTargetNamespace()))) {

                            if (isg != newGrammar) {

                                importedGrammars.set(j, newGrammar);

                            }

                            break;

                        }

                    }

                }

            }

        }

    }

    // This method builds registries for all globally-referenceable

    // names.  A registry will be built for each symbol space defined

    // by the spec.  It is also this method's job to rename redefined

    // components, and to record which components redefine others (so

    // that implicit redefinitions of groups and attributeGroups can be handled).

    protected void buildGlobalNameRegistries() {

        registryEmpty = false;

        // Starting with fRoot, we examine each child of the schema

        // element.  Skipping all imports and includes, we record the names

        // of all other global components (and children of <redefine>).  We

        // also put <redefine> names in a registry that we look through in

        // case something needs renaming.  Once we're done with a schema we

        // set its Document node to hidden so that we don't try to traverse

        // it again; then we look to its Dependency map entry.  We keep a

        // stack of schemas that we haven't yet finished processing; this

        // is a depth-first traversal.

        Stack<XSDocumentInfo> schemasToProcess = new Stack<>();

        schemasToProcess.push(fRoot);

        while (!schemasToProcess.empty()) {

            XSDocumentInfo currSchemaDoc = schemasToProcess.pop();

            Element currDoc = currSchemaDoc.fSchemaElement;

            if(DOMUtil.isHidden(currDoc, fHiddenNodes)){

                // must have processed this already!

                continue;

            }

            Element currRoot = currDoc;

            // process this schema's global decls

            boolean dependenciesCanOccur = true;

            for (Element globalComp =

                DOMUtil.getFirstChildElement(currRoot);

            globalComp != null;

            globalComp = DOMUtil.getNextSiblingElement(globalComp)) {

                // this loop makes sure the <schema> element ordering is

                // also valid.

                if (DOMUtil.getLocalName(globalComp).equals(SchemaSymbols.ELT_ANNOTATION)) {

                    //skip it; traverse it later

                    continue;

                }

                else if (DOMUtil.getLocalName(globalComp).equals(SchemaSymbols.ELT_INCLUDE) ||

                        DOMUtil.getLocalName(globalComp).equals(SchemaSymbols.ELT_IMPORT)) {

                    if (!dependenciesCanOccur) {

                        reportSchemaError("s4s-elt-invalid-content.3", new Object [] {DOMUtil.getLocalName(globalComp)}, globalComp);

                    }

                    DOMUtil.setHidden(globalComp, fHiddenNodes);

                }

                else if (DOMUtil.getLocalName(globalComp).equals(SchemaSymbols.ELT_REDEFINE)) {

                    if (!dependenciesCanOccur) {

                        reportSchemaError("s4s-elt-invalid-content.3", new Object [] {DOMUtil.getLocalName(globalComp)}, globalComp);

                    }

                    for (Element redefineComp = DOMUtil.getFirstChildElement(globalComp);

                    redefineComp != null;

                    redefineComp = DOMUtil.getNextSiblingElement(redefineComp)) {

                        String lName = DOMUtil.getAttrValue(redefineComp, SchemaSymbols.ATT_NAME);

                        if (lName.length() == 0) // an error we'll catch later

                            continue;

                        String qName = currSchemaDoc.fTargetNamespace == null ?

                                ","+lName:

                                    currSchemaDoc.fTargetNamespace +","+lName;

                        String componentType = DOMUtil.getLocalName(redefineComp);

                        if (componentType.equals(SchemaSymbols.ELT_ATTRIBUTEGROUP)) {

                            checkForDuplicateNames(qName, ATTRIBUTEGROUP_TYPE, fUnparsedAttributeGroupRegistry, fUnparsedAttributeGroupRegistrySub, redefineComp, currSchemaDoc);

                            // the check will have changed our name;