/*

 * 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.Locale;

import java.util.Map;

import java.util.Stack;

import java.util.Vector;

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

import org.xml.sax.helpers.XMLReaderFactory;

/**

 * 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

 *

 */

@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("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, Vector<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, Vector> 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 Vector<String> fAllTNSs = new Vector<>();

    // 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 fRedefine2XSDMap = null;

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

    private Map 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 Map fRedefinedRestrictedAttributeGroupRegistry = new HashMap();

    private Map 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;

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