content: /*
   *  This file is part of AndroidIDE.
   *
   *  AndroidIDE is free software: you can redistribute it and/or modify
   *  it under the terms of the GNU General Public License as published by
   *  the Free Software Foundation, either version 3 of the License, or
   *  (at your option) any later version.
   *
   *  AndroidIDE is distributed in the hope that it will be useful,
   *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   *  GNU General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License
   *   along with AndroidIDE.  If not, see <https://www.gnu.org/licenses/>.
   */
  
  /*
   * reserved comment block
   * DO NOT REMOVE OR ALTER!
   */
  /*
   * Copyright 2001-2005 The Apache Software Foundation.
   *
   * Licensed 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 jaxp.sun.org.apache.xerces.internal.parsers;
  
  import java.io.IOException;
  
  import jaxp.sun.org.apache.xerces.internal.impl.Constants;
  import jaxp.sun.org.apache.xerces.internal.impl.dtd.DTDGrammar;
  import jaxp.sun.org.apache.xerces.internal.impl.dtd.XMLDTDLoader;
  import jaxp.sun.org.apache.xerces.internal.impl.xs.SchemaGrammar;
  import jaxp.sun.org.apache.xerces.internal.impl.xs.XMLSchemaLoader;
  import jaxp.sun.org.apache.xerces.internal.impl.xs.XSMessageFormatter;
  import jaxp.sun.org.apache.xerces.internal.util.SymbolTable;
  import jaxp.sun.org.apache.xerces.internal.util.SynchronizedSymbolTable;
  import jaxp.sun.org.apache.xerces.internal.util.XMLGrammarPoolImpl;
  import jaxp.sun.org.apache.xerces.internal.xni.XNIException;
  import jaxp.sun.org.apache.xerces.internal.xni.grammars.Grammar;
  import jaxp.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarDescription;
  import jaxp.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarPool;
  import jaxp.sun.org.apache.xerces.internal.xni.parser.XMLComponentManager;
  import jaxp.sun.org.apache.xerces.internal.xni.parser.XMLEntityResolver;
  import jaxp.sun.org.apache.xerces.internal.xni.parser.XMLInputSource;
  
  /**
   * <p> This configuration provides a generic way of using
   * Xerces's grammar caching facilities.  It extends the
   * XIncludeAwareParserConfiguration and thus may validate documents
   * according to XML schemas or DTD's.  It also allows the user to
   * preparse a grammar, and to lock the grammar pool
   * implementation such that no more grammars will be added.</p>
   * <p> Using the com.sun.org.apache.xerces.internal.xni.parser property, an
   * application may instantiate a Xerces SAX or DOM parser with
   * this configuration.  When invoked in this manner, the default
   * behaviour will be elicited; to use this configuration's
   * specific facilities, the user will need to reference it
   * directly.</p>
   * <p>
   * In addition to the features and properties recognized by the base
   * parser configuration, this class recognizes these additional
   * features and properties:
   * <ul>
   * </ul>
   *
   * @author Neil Graham, IBM
   *
   * @version $Id: XMLGrammarCachingConfiguration.java,v 1.6 2010-11-01 04:40:10 joehw Exp $
   */
  public class XMLGrammarCachingConfiguration
      extends XIncludeAwareParserConfiguration {
  
      //
      // Constants
      //
  
      // a larg(ish) prime to use for a symbol table to be shared
      // among
      // potentially man parsers.  Start one as close to 2K (20
      // times larger than normal) and see what happens...
      public static final int BIG_PRIME = 2039;
  
      // the static symbol table to be shared amongst parsers
      protected static final SynchronizedSymbolTable fStaticSymbolTable =
              new SynchronizedSymbolTable(BIG_PRIME);
  
      // the Grammar Pool to be shared similarly
      protected static final XMLGrammarPoolImpl fStaticGrammarPool =
              new XMLGrammarPoolImpl();
  
      // schema full checking constant
      protected static final String SCHEMA_FULL_CHECKING =
              Constants.XERCES_FEATURE_PREFIX+Constants.SCHEMA_FULL_CHECKING;
  
      // Data
  
      // variables needed for caching schema grammars.
      protected XMLSchemaLoader fSchemaLoader;
  
      // the DTD grammar loader
      protected XMLDTDLoader fDTDLoader;
  
      //
      // Constructors
      //
  
      /** Default constructor. */
      public XMLGrammarCachingConfiguration() {
          this(fStaticSymbolTable, fStaticGrammarPool, null);
      } // <init>()
  
      /**
       * Constructs a parser configuration using the specified symbol table.
       *
       * @param symbolTable The symbol table to use.
       */
      public XMLGrammarCachingConfiguration(SymbolTable symbolTable) {
          this(symbolTable, fStaticGrammarPool, null);
      } // <init>(SymbolTable)
  
      /**
       * Constructs a parser configuration using the specified symbol table and
       * grammar pool.
       * <p>
       * <strong>REVISIT:</strong>
       * Grammar pool will be updated when the new validation engine is
       * implemented.
       *
       * @param symbolTable The symbol table to use.
       * @param grammarPool The grammar pool to use.
       */
      public XMLGrammarCachingConfiguration(SymbolTable symbolTable,
                                         XMLGrammarPool grammarPool) {
          this(symbolTable, grammarPool, null);
      } // <init>(SymbolTable,XMLGrammarPool)
  
      /**
       * Constructs a parser configuration using the specified symbol table,
       * grammar pool, and parent settings.
       * <p>
       * <strong>REVISIT:</strong>
       * Grammar pool will be updated when the new validation engine is
       * implemented.
       *
       * @param symbolTable    The symbol table to use.
       * @param grammarPool    The grammar pool to use.
       * @param parentSettings The parent settings.
       */
      public XMLGrammarCachingConfiguration(SymbolTable symbolTable,
                                         XMLGrammarPool grammarPool,
                                         XMLComponentManager parentSettings) {
          super(symbolTable, grammarPool, parentSettings);
  
          // REVISIT:  may need to add some features/properties
          // specific to this configuration at some point...
  
          // add default recognized features
          // set state for default features
          // add default recognized properties
          // create and register missing components
          fSchemaLoader = new XMLSchemaLoader(fSymbolTable);
          fSchemaLoader.setProperty(XMLGRAMMAR_POOL, fGrammarPool);
  
          // and set up the DTD loader too:
          fDTDLoader = new XMLDTDLoader(fSymbolTable, fGrammarPool);
      } // <init>(SymbolTable,XMLGrammarPool, XMLComponentManager)
  
      //
      // Public methods
      //
  
      /*
       * lock the XMLGrammarPoolImpl object so that it does not
       * accept any more grammars from the validators.
       */
      public void lockGrammarPool() {
          fGrammarPool.lockPool();
      } // lockGrammarPool()
  
      /*
       * clear the XMLGrammarPoolImpl object so that it does not
       * contain any more grammars.
       */
      public void clearGrammarPool() {
          fGrammarPool.clear();
      } // clearGrammarPool()
  
      /*
       * unlock the XMLGrammarPoolImpl object so that it
       * accepts more grammars from the validators.
       */
      public void unlockGrammarPool() {
          fGrammarPool.unlockPool();
      } // unlockGrammarPool()
  
      /**
       * Parse a grammar from a location identified by an URI.
       * This method also adds this grammar to the XMLGrammarPool
       *
       * @param type The type of the grammar to be constructed
       * @param uri The location of the grammar to be constructed.
       * <strong>The parser will not expand this URI or make it
       * available to the EntityResolver</strong>
       * @return The newly created <code>Grammar</code>.
       * @exception XNIException thrown on an error in grammar
       * construction
       * @exception IOException thrown if an error is encountered
       * in reading the file
       */
      public Grammar parseGrammar(String type, String uri)
                                throws XNIException, IOException {
          XMLInputSource source = new XMLInputSource(null, uri, null);
          return parseGrammar(type, source);
  
      }
  
      /**
       * Parse a grammar from a location identified by an
       * XMLInputSource.
       * This method also adds this grammar to the XMLGrammarPool
       *
       * @param type The type of the grammar to be constructed
       * @param is The XMLInputSource containing this grammar's
       * information
       * <strong>If a URI is included in the systemId field, the parser will not expand this URI or make it
       * available to the EntityResolver</strong>
       * @return The newly created <code>Grammar</code>.
       * @exception XNIException thrown on an error in grammar
       * construction
       * @exception IOException thrown if an error is encountered
       * in reading the file
       */
      public Grammar parseGrammar(String type, XMLInputSource
                  is) throws XNIException, IOException {
          if(type.equals(XMLGrammarDescription.XML_SCHEMA)) {
              // by default, make all XMLGrammarPoolImpl's schema grammars available to fSchemaHandler
              return parseXMLSchema(is);
          } else if(type.equals(XMLGrammarDescription.XML_DTD)) {
              return parseDTD(is);
          }
          // don't know this grammar...
          return null;
      } // parseGrammar(String, XMLInputSource):  Grammar
  
      //
      // Protected methods
      //
  
      // package-protected methods
  
      /* This method parses an XML Schema document.
       * It requires a GrammarBucket parameter so that DOMASBuilder can
       * extract the info it needs.
       * Therefore, bucket must not be null!
       */
      SchemaGrammar parseXMLSchema(XMLInputSource is)
                  throws IOException {
          XMLEntityResolver resolver = getEntityResolver();
          if(resolver != null) {
              fSchemaLoader.setEntityResolver(resolver);
          }
          if (fErrorReporter.getMessageFormatter(XSMessageFormatter.SCHEMA_DOMAIN) == null) {
              fErrorReporter.putMessageFormatter(XSMessageFormatter.SCHEMA_DOMAIN, new XSMessageFormatter());
          }
          fSchemaLoader.setProperty(ERROR_REPORTER, fErrorReporter);
  
          String propPrefix = Constants.XERCES_PROPERTY_PREFIX;
          String propName = propPrefix + Constants.SCHEMA_LOCATION;
          fSchemaLoader.setProperty(propName, getProperty(propName));
          propName = propPrefix + Constants.SCHEMA_NONS_LOCATION;
          fSchemaLoader.setProperty(propName, getProperty(propName));
          propName = Constants.JAXP_PROPERTY_PREFIX+Constants.SCHEMA_SOURCE;
          fSchemaLoader.setProperty(propName, getProperty(propName));
          fSchemaLoader.setFeature(SCHEMA_FULL_CHECKING, getFeature(SCHEMA_FULL_CHECKING));
  
          // Should check whether the grammar with this namespace is already in
          // the grammar resolver. But since we don't know the target namespace
          // of the document here, we leave such check to XSDHandler
          SchemaGrammar grammar = (SchemaGrammar)fSchemaLoader.loadGrammar(is);
          // by default, hand it off to the grammar pool
          if (grammar != null) {
              fGrammarPool.cacheGrammars(XMLGrammarDescription.XML_SCHEMA,
                                        new Grammar[]{grammar});
          }
  
          return grammar;
  
      } // parseXMLSchema(XMLInputSource) :  SchemaGrammar
  
      /* This method parses an external DTD entity.
       */
      DTDGrammar parseDTD(XMLInputSource is)
                  throws IOException {
          XMLEntityResolver resolver = getEntityResolver();
          if(resolver != null) {
              fDTDLoader.setEntityResolver(resolver);
          }
          fDTDLoader.setProperty(ERROR_REPORTER, fErrorReporter);
  
          // Should check whether the grammar with this namespace is already in
          // the grammar resolver. But since we don't know the target namespace
          // of the document here, we leave such check to the application...
          DTDGrammar grammar = (DTDGrammar)fDTDLoader.loadGrammar(is);
          // by default, hand it off to the grammar pool
          if (grammar != null) {
              fGrammarPool.cacheGrammars(XMLGrammarDescription.XML_DTD,
                                        new Grammar[]{grammar});
          }
  
          return grammar;
  
      } // parseXMLDTD(XMLInputSource) :  DTDGrammar
  
  
  } // class XMLGrammarCachingConfiguration
  