/*

 */

/*

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import java.lang.ref.SoftReference;

import org.xml.sax.SAXException;

/**

 * This class is to hold all schema component declaration that are declared

 * within one namespace.

 *

 * The Grammar class this class extends contains what little

 * commonality there is between XML Schema and DTD grammars.  It's

 * useful to distinguish grammar objects from other kinds of object

 * when they exist in pools or caches.

 *

 * @xerces.internal

 *

 * @author Sandy Gao, IBM

 * @author Elena Litani, IBM

 *

 */

public class SchemaGrammar implements XSGrammar, XSNamespaceItem {

    // the target namespace of grammar

    String fTargetNamespace;

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

    SymbolHash fGlobalAttrDecls;

    SymbolHash fGlobalAttrGrpDecls;

    SymbolHash fGlobalElemDecls;

    SymbolHash fGlobalGroupDecls;

    SymbolHash fGlobalNotationDecls;

    SymbolHash fGlobalIDConstraintDecls;

    SymbolHash fGlobalTypeDecls;

    // extended global decls: map from schema location + decl name to decl object

    // key is location,name

    SymbolHash fGlobalAttrDeclsExt;

    SymbolHash fGlobalAttrGrpDeclsExt;

    SymbolHash fGlobalElemDeclsExt;

    SymbolHash fGlobalGroupDeclsExt;

    SymbolHash fGlobalNotationDeclsExt;

    SymbolHash fGlobalIDConstraintDeclsExt;

    SymbolHash fGlobalTypeDeclsExt;

    // A global map of all global element declarations - used for substitution group computation

    // (handy when sharing components by reference, since we might end up with duplicate components

    //  that are not added to either of the global element declarations above)

    SymbolHash fAllGlobalElemDecls;

    // the XMLGrammarDescription member

    XSDDescription fGrammarDescription = null;

    // annotations associated with the "root" schema of this targetNamespace

    XSAnnotationImpl [] fAnnotations = null;

    // number of annotations declared

    int fNumAnnotations;

    // symbol table for constructing parsers (annotation support)

    private SymbolTable fSymbolTable = null;

    // parsers for annotation support

    // is this grammar immutable?  (fully constructed and not changeable)

    private boolean fIsImmutable = false;

    //

    // Constructors

    //

    // needed to make BuiltinSchemaGrammar work.

    protected SchemaGrammar() {}

    /**

     * Default constructor.

     *

     * @param targetNamespace

     * @param grammarDesc the XMLGrammarDescription corresponding to this object

     *          at the least a systemId should always be known.

     * @param symbolTable   needed for annotation support

     */

    public SchemaGrammar(String targetNamespace, XSDDescription grammarDesc,

                SymbolTable symbolTable) {

        fTargetNamespace = targetNamespace;

        fGrammarDescription = grammarDesc;

        fSymbolTable = symbolTable;

        // REVISIT: the initial sizes being chosen for each SymbolHash

        // may not be ideal and could still be tuned. They were chosen

        // somewhat arbitrarily to reduce the initial footprint of

        // SymbolHash buckets from 1,515 to 177 (about 12% of the

        // default size).

        fGlobalAttrDecls  = new SymbolHash(12);

        fGlobalAttrGrpDecls = new SymbolHash(5);

        fGlobalElemDecls = new SymbolHash(25);

        fGlobalGroupDecls = new SymbolHash(5);

        fGlobalNotationDecls = new SymbolHash(1);

        fGlobalIDConstraintDecls = new SymbolHash(3);

        // Extended tables

        fGlobalAttrDeclsExt  = new SymbolHash(12);

        fGlobalAttrGrpDeclsExt = new SymbolHash(5);

        fGlobalElemDeclsExt = new SymbolHash(25);

        fGlobalGroupDeclsExt = new SymbolHash(5);

        fGlobalNotationDeclsExt = new SymbolHash(1);

        fGlobalIDConstraintDeclsExt = new SymbolHash(3);

        fGlobalTypeDeclsExt = new SymbolHash(25);

        // All global elements table

        fAllGlobalElemDecls = new SymbolHash(25);

        // if we are parsing S4S, put built-in types in first

        // they might get overwritten by the types from S4S, but that's

        // considered what the application wants to do.

        if (fTargetNamespace == SchemaSymbols.URI_SCHEMAFORSCHEMA) {

            fGlobalTypeDecls = SG_SchemaNS.fGlobalTypeDecls.makeClone();

        }

        else {

            fGlobalTypeDecls = new SymbolHash(25);

        }

    } // <init>(String, XSDDescription)

    // Clone an existing schema grammar

    public SchemaGrammar(SchemaGrammar grammar) {

        fTargetNamespace = grammar.fTargetNamespace;

        fGrammarDescription = grammar.fGrammarDescription.makeClone();

        //fGrammarDescription.fContextType |= XSDDescription.CONTEXT_COLLISION; // REVISIT

        fSymbolTable = grammar.fSymbolTable; // REVISIT

        fGlobalAttrDecls  = grammar.fGlobalAttrDecls.makeClone();

        fGlobalAttrGrpDecls = grammar.fGlobalAttrGrpDecls.makeClone();

        fGlobalElemDecls = grammar.fGlobalElemDecls.makeClone();

        fGlobalGroupDecls = grammar.fGlobalGroupDecls.makeClone();

        fGlobalNotationDecls = grammar.fGlobalNotationDecls.makeClone();

        fGlobalIDConstraintDecls = grammar.fGlobalIDConstraintDecls.makeClone();

        fGlobalTypeDecls = grammar.fGlobalTypeDecls.makeClone();

        // Extended tables

        fGlobalAttrDeclsExt  = grammar.fGlobalAttrDeclsExt.makeClone();

        fGlobalAttrGrpDeclsExt = grammar.fGlobalAttrGrpDeclsExt.makeClone();

        fGlobalElemDeclsExt = grammar.fGlobalElemDeclsExt.makeClone();

        fGlobalGroupDeclsExt = grammar.fGlobalGroupDeclsExt.makeClone();

        fGlobalNotationDeclsExt = grammar.fGlobalNotationDeclsExt.makeClone();

        fGlobalIDConstraintDeclsExt = grammar.fGlobalIDConstraintDeclsExt.makeClone();

        fGlobalTypeDeclsExt = grammar.fGlobalTypeDeclsExt.makeClone();

        // All global elements table

        fAllGlobalElemDecls = grammar.fAllGlobalElemDecls.makeClone();

        // Annotations associated with the "root" schema of this targetNamespace

        fNumAnnotations = grammar.fNumAnnotations;

        if (fNumAnnotations > 0) {

            fAnnotations = new XSAnnotationImpl[grammar.fAnnotations.length];

            System.arraycopy(grammar.fAnnotations, 0, fAnnotations, 0, fNumAnnotations);

        }

        // All substitution group information declared in this namespace

        fSubGroupCount = grammar.fSubGroupCount;

        if (fSubGroupCount > 0) {

            fSubGroups = new XSElementDecl[grammar.fSubGroups.length];

            System.arraycopy(grammar.fSubGroups, 0, fSubGroups, 0, fSubGroupCount);

        }

        // Array to store complex type decls for constraint checking

        fCTCount = grammar.fCTCount;

        if (fCTCount > 0) {

            fComplexTypeDecls = new XSComplexTypeDecl[grammar.fComplexTypeDecls.length];

            fCTLocators = new SimpleLocator[grammar.fCTLocators.length];

            System.arraycopy(grammar.fComplexTypeDecls, 0, fComplexTypeDecls, 0, fCTCount);

            System.arraycopy(grammar.fCTLocators, 0, fCTLocators, 0, fCTCount);

        }

        // Groups being redefined by restriction

        fRGCount = grammar.fRGCount;

        if (fRGCount > 0) {

            fRedefinedGroupDecls = new XSGroupDecl[grammar.fRedefinedGroupDecls.length];

            fRGLocators = new SimpleLocator[grammar.fRGLocators.length];

            System.arraycopy(grammar.fRedefinedGroupDecls, 0, fRedefinedGroupDecls, 0, fRGCount);

            System.arraycopy(grammar.fRGLocators, 0, fRGLocators, 0, fRGCount/2);

        }

        // List of imported grammars

        if (grammar.fImported != null) {

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

            }

        }

        // Locations

        if (grammar.fLocations != null) {

            for (int k=0; k<grammar.fLocations.size(); k++) {

            }

        }

    } // <init>(String, XSDDescription)

    // number of built-in XSTypes we need to create for base and full

    // datatype set

    private static final int BASICSET_COUNT = 29;

    private static final int FULLSET_COUNT  = 46;

    private static final int GRAMMAR_XS  = 1;

    private static final int GRAMMAR_XSI = 2;

    // this class makes sure the static, built-in schema grammars

    // are immutable.

    public static class BuiltinSchemaGrammar extends SchemaGrammar {

        private static final String EXTENDED_SCHEMA_FACTORY_CLASS = "com.sun.org.apache.xerces.internal.impl.dv.xs.ExtendedSchemaDVFactoryImpl";

        /**

         * Special constructor to create the grammars for the schema namespaces

         *

         * @param grammar

         */

        public BuiltinSchemaGrammar(int grammar, short schemaVersion) {

            SchemaDVFactory schemaFactory;

            if (schemaVersion == Constants.SCHEMA_VERSION_1_0) {

                schemaFactory = SchemaDVFactory.getInstance();

            }

            else {

                schemaFactory = SchemaDVFactory.getInstance(EXTENDED_SCHEMA_FACTORY_CLASS);

            }

            if (grammar == GRAMMAR_XS) {

                // target namespace

                fTargetNamespace = SchemaSymbols.URI_SCHEMAFORSCHEMA;

                // grammar description

                fGrammarDescription = new XSDDescription();

                fGrammarDescription.fContextType = XSDDescription.CONTEXT_PREPARSE;

                fGrammarDescription.setNamespace(SchemaSymbols.URI_SCHEMAFORSCHEMA);

                // no global decls other than types

                fGlobalAttrDecls  = new SymbolHash(1);

                fGlobalAttrGrpDecls = new SymbolHash(1);

                fGlobalElemDecls = new SymbolHash(1);

                fGlobalGroupDecls = new SymbolHash(1);

                fGlobalNotationDecls = new SymbolHash(1);

                fGlobalIDConstraintDecls = new SymbolHash(1);

                // no extended global decls

                fGlobalAttrDeclsExt  = new SymbolHash(1);

                fGlobalAttrGrpDeclsExt = new SymbolHash(1);

                fGlobalElemDeclsExt = new SymbolHash(1);

                fGlobalGroupDeclsExt = new SymbolHash(1);

                fGlobalNotationDeclsExt = new SymbolHash(1);

                fGlobalIDConstraintDeclsExt = new SymbolHash(1);

                fGlobalTypeDeclsExt = new SymbolHash(1);

                // all global element decls table

                fAllGlobalElemDecls = new SymbolHash(1);

                // get all built-in types

                fGlobalTypeDecls = schemaFactory.getBuiltInTypes();

                // assign the built-in schema grammar as the XSNamespaceItem

                // for each of the built-in simple type definitions.

                int length = fGlobalTypeDecls.getLength();

                XSTypeDefinition [] typeDefinitions = new XSTypeDefinition[length];

                fGlobalTypeDecls.getValues(typeDefinitions, 0);

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

                    XSTypeDefinition xtd = typeDefinitions[i];

                    if (xtd instanceof XSSimpleTypeDecl) {

                        ((XSSimpleTypeDecl) xtd).setNamespaceItem(this);

                    }

                }

                // add anyType

                fGlobalTypeDecls.put(fAnyType.getName(), fAnyType);

            }

            else if (grammar == GRAMMAR_XSI) {

                // target namespace

                fTargetNamespace = SchemaSymbols.URI_XSI;

                // grammar description

                fGrammarDescription = new XSDDescription();

                fGrammarDescription.fContextType = XSDDescription.CONTEXT_PREPARSE;

                fGrammarDescription.setNamespace(SchemaSymbols.URI_XSI);

                // no global decls other than attributes

                fGlobalAttrGrpDecls = new SymbolHash(1);

                fGlobalElemDecls = new SymbolHash(1);

                fGlobalGroupDecls = new SymbolHash(1);

                fGlobalNotationDecls = new SymbolHash(1);

                fGlobalIDConstraintDecls = new SymbolHash(1);

                fGlobalTypeDecls = new SymbolHash(1);

                // no extended global decls

                fGlobalAttrDeclsExt  = new SymbolHash(1);

                fGlobalAttrGrpDeclsExt = new SymbolHash(1);

                fGlobalElemDeclsExt = new SymbolHash(1);

                fGlobalGroupDeclsExt = new SymbolHash(1);

                fGlobalNotationDeclsExt = new SymbolHash(1);

                fGlobalIDConstraintDeclsExt = new SymbolHash(1);

                fGlobalTypeDeclsExt = new SymbolHash(1);

                // no all global element decls

                fAllGlobalElemDecls = new SymbolHash(1);

                // 4 attributes, so initialize the size as 4*2 = 8

                fGlobalAttrDecls  = new SymbolHash(8);

                String name = null;

                String tns = null;

                XSSimpleType type = null;

                short scope = XSConstants.SCOPE_GLOBAL;

                // xsi:type

                name = SchemaSymbols.XSI_TYPE;

                tns = SchemaSymbols.URI_XSI;

                type = schemaFactory.getBuiltInType(SchemaSymbols.ATTVAL_QNAME);

                fGlobalAttrDecls.put(name, new BuiltinAttrDecl(name, tns, type, scope));

                // xsi:nil

                name = SchemaSymbols.XSI_NIL;

                tns = SchemaSymbols.URI_XSI;

                type = schemaFactory.getBuiltInType(SchemaSymbols.ATTVAL_BOOLEAN);

                fGlobalAttrDecls.put(name, new BuiltinAttrDecl(name, tns, type, scope));

                XSSimpleType anyURI = schemaFactory.getBuiltInType(SchemaSymbols.ATTVAL_ANYURI);

                // xsi:schemaLocation

                name = SchemaSymbols.XSI_SCHEMALOCATION;

                tns = SchemaSymbols.URI_XSI;

                type = schemaFactory.createTypeList("#AnonType_schemaLocation", SchemaSymbols.URI_XSI, (short)0, anyURI, null);

                if (type instanceof XSSimpleTypeDecl) {

                    ((XSSimpleTypeDecl)type).setAnonymous(true);

                }

                fGlobalAttrDecls.put(name, new BuiltinAttrDecl(name, tns, type, scope));

                // xsi:noNamespaceSchemaLocation

                name = SchemaSymbols.XSI_NONAMESPACESCHEMALOCATION;

                tns = SchemaSymbols.URI_XSI;

                type = anyURI;

                fGlobalAttrDecls.put(name, new BuiltinAttrDecl(name, tns, type, scope));

            }

        } // <init>(int)

        // return the XMLGrammarDescription corresponding to this

        // object

        public XMLGrammarDescription getGrammarDescription() {

            return fGrammarDescription.makeClone();

        } // getGrammarDescription():  XMLGrammarDescription

        // override these methods solely so that these

        // objects cannot be modified once they're created.

            // ignore

        }

        public void addGlobalAttributeDecl(XSAttributeDecl decl) {

            // ignore

        }

        public void addGlobalAttributeDecl(XSAttributeDecl decl, String location) {

            // ignore

        }

        public void addGlobalAttributeGroupDecl(XSAttributeGroupDecl decl) {

            // ignore

        }

        public void addGlobalAttributeGroupDecl(XSAttributeGroupDecl decl, String location) {

            // ignore

        }

        public void addGlobalElementDecl(XSElementDecl decl) {

            // ignore

        }

        public void addGlobalElementDecl(XSElementDecl decl, String location) {

            // ignore

        }

        public void addGlobalElementDeclAll(XSElementDecl decl) {

            // ignore

        }

        public void addGlobalGroupDecl(XSGroupDecl decl) {

            // ignore

        }

        public void addGlobalGroupDecl(XSGroupDecl decl, String location) {

            // ignore

        }

        public void addGlobalNotationDecl(XSNotationDecl decl) {

            // ignore

        }

        public void addGlobalNotationDecl(XSNotationDecl decl, String location) {

            // ignore

        }

        public void addGlobalTypeDecl(XSTypeDefinition decl) {

            // ignore

        }

        public void addGlobalTypeDecl(XSTypeDefinition decl, String location) {

            // ignore

        }

        public void addGlobalComplexTypeDecl(XSComplexTypeDecl decl) {

            // ignore

        }

        public void addGlobalComplexTypeDecl(XSComplexTypeDecl decl, String location) {

            // ignore

        }

        public void addGlobalSimpleTypeDecl(XSSimpleType decl) {

            // ignore

        }

        public void addGlobalSimpleTypeDecl(XSSimpleType decl, String location) {

            // ignore

        }

        public void addComplexTypeDecl(XSComplexTypeDecl decl, SimpleLocator locator) {

            // ignore

        }

        public void addRedefinedGroupDecl(XSGroupDecl derived, XSGroupDecl base, SimpleLocator locator) {

            // ignore

        }

        public synchronized void addDocument(Object document, String location) {

            // ignore

        }

        // annotation support

        synchronized DOMParser getDOMParser() {

            return null;

        }

        synchronized SAXParser getSAXParser() {

            return null;

        }

    }

    /**

     * <p>A partial schema for schemas for validating annotations.</p>

     *

     * @xerces.internal

     *

     * @author Michael Glavassevich, IBM

     */

    public static final class Schema4Annotations extends SchemaGrammar {

        /**

         * Singleton instance.

         */

        public static final Schema4Annotations INSTANCE = new Schema4Annotations();

        /**

         * Special constructor to create a schema

         * capable of validating annotations.

         */

        private Schema4Annotations() {

            // target namespace

            fTargetNamespace = SchemaSymbols.URI_SCHEMAFORSCHEMA;

            // grammar description

            fGrammarDescription = new XSDDescription();

            fGrammarDescription.fContextType = XSDDescription.CONTEXT_PREPARSE;

            fGrammarDescription.setNamespace(SchemaSymbols.URI_SCHEMAFORSCHEMA);

            // no global decls other than types and

            // element declarations for <annotation>, <documentation> and <appinfo>.

            fGlobalAttrDecls  = new SymbolHash(1);

            fGlobalAttrGrpDecls = new SymbolHash(1);

            fGlobalElemDecls = new SymbolHash(6);

            fGlobalGroupDecls = new SymbolHash(1);

            fGlobalNotationDecls = new SymbolHash(1);

            fGlobalIDConstraintDecls = new SymbolHash(1);

            // no extended global decls

            fGlobalAttrDeclsExt  = new SymbolHash(1);

            fGlobalAttrGrpDeclsExt = new SymbolHash(1);