GrammarResolver.cpp
上传用户:zhuqijet
上传日期:2013-06-25
资源大小:10074k
文件大小:9k
源码类别:

词法分析

开发平台:

Visual C++

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  *
  5.  * Copyright (c) 2001 The Apache Software Foundation.  All rights
  6.  * reserved.
  7.  *
  8.  * Redistribution and use in source and binary forms, with or without
  9.  * modification, are permitted provided that the following conditions
  10.  * are met:
  11.  *
  12.  * 1. Redistributions of source code must retain the above copyright
  13.  *    notice, this list of conditions and the following disclaimer.
  14.  *
  15.  * 2. Redistributions in binary form must reproduce the above copyright
  16.  *    notice, this list of conditions and the following disclaimer in
  17.  *    the documentation and/or other materials provided with the
  18.  *    distribution.
  19.  *
  20.  * 3. The end-user documentation included with the redistribution,
  21.  *    if any, must include the following acknowledgment:
  22.  *       "This product includes software developed by the
  23.  *        Apache Software Foundation (http://www.apache.org/)."
  24.  *    Alternately, this acknowledgment may appear in the software itself,
  25.  *    if and wherever such third-party acknowledgments normally appear.
  26.  *
  27.  * 4. The names "Xerces" and "Apache Software Foundation" must
  28.  *    not be used to endorse or promote products derived from this
  29.  *    software without prior written permission. For written
  30.  *    permission, please contact apache@apache.org.
  31.  *
  32.  * 5. Products derived from this software may not be called "Apache",
  33.  *    nor may "Apache" appear in their name, without prior written
  34.  *    permission of the Apache Software Foundation.
  35.  *
  36.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  37.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  38.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  39.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  40.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  41.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  42.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  43.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  44.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  45.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  46.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  47.  * SUCH DAMAGE.
  48.  * ====================================================================
  49.  *
  50.  * This software consists of voluntary contributions made by many
  51.  * individuals on behalf of the Apache Software Foundation and was
  52.  * originally based on software copyright (c) 2001, International
  53.  * Business Machines, Inc., http://www.apache.org.  For more
  54.  * information on the Apache Software Foundation, please see
  55.  * <http://www.apache.org/>.
  56.  */
  57. /*
  58.  * $Log: GrammarResolver.cpp,v $
  59.  * Revision 1.8  2003/05/18 14:02:06  knoaman
  60.  * Memory manager implementation: pass per instance manager.
  61.  *
  62.  * Revision 1.7  2003/05/16 21:43:20  knoaman
  63.  * Memory manager implementation: Modify constructors to pass in the memory manager.
  64.  *
  65.  * Revision 1.6  2003/05/15 18:48:27  knoaman
  66.  * Partial implementation of the configurable memory manager.
  67.  *
  68.  * Revision 1.5  2002/11/04 14:54:58  tng
  69.  * C++ Namespace Support.
  70.  *
  71.  * Revision 1.4  2002/09/24 19:48:39  tng
  72.  * Performance: use XMLString::equals instead of XMLString::compareString
  73.  *
  74.  * Revision 1.3  2002/07/12 14:35:37  knoaman
  75.  * Add an error message and use it in the scanner.
  76.  *
  77.  * Revision 1.2  2002/07/11 18:17:43  knoaman
  78.  * Grammar caching/preparsing - initial implementation.
  79.  *
  80.  * Revision 1.1.1.1  2002/02/01 22:22:38  peiyongz
  81.  * sane_include
  82.  *
  83.  * Revision 1.5  2001/08/28 19:20:54  tng
  84.  * Schema: xsi:type support
  85.  *
  86.  * Revision 1.4  2001/07/24 18:33:13  knoaman
  87.  * Added support for <group> + extra constraint checking for complexType
  88.  *
  89.  * Revision 1.3  2001/06/07 20:58:39  tng
  90.  * Fix no newline at the end warning.  By Pei Yong Zhang.
  91.  *
  92.  * Revision 1.2  2001/05/11 13:27:19  tng
  93.  * Copyright update.
  94.  *
  95.  * Revision 1.1  2001/03/21 21:56:28  tng
  96.  * Schema: Add Schema Grammar, Schema Validator, and split the DTDValidator into DTDValidator, DTDScanner, and DTDGrammar.
  97.  *
  98.  */
  99. #include <xercesc/validators/common/GrammarResolver.hpp>
  100. #include <xercesc/framework/XMLBuffer.hpp>
  101. #include <xercesc/validators/schema/SchemaSymbols.hpp>
  102. #include <xercesc/validators/schema/SchemaGrammar.hpp>
  103. XERCES_CPP_NAMESPACE_BEGIN
  104. // ---------------------------------------------------------------------------
  105. //  GrammarResolver: Constructor and Destructor
  106. // ---------------------------------------------------------------------------
  107. GrammarResolver::GrammarResolver(MemoryManager* const manager) :
  108.     fCacheGrammar(false)
  109.     , fUseCachedGrammar(false)
  110.     , fStringPool(109, manager)
  111.     , fGrammarRegistry(0)
  112.     , fCachedGrammarRegistry(0)
  113.     , fDataTypeReg(0)
  114.     , fMemoryManager(manager)  
  115. {
  116.     fGrammarRegistry = new (manager) RefHashTableOf<Grammar>(29, true,  manager);
  117. }
  118. GrammarResolver::~GrammarResolver()
  119. {
  120.    delete fGrammarRegistry;
  121.    delete fCachedGrammarRegistry;
  122.    if (fDataTypeReg)
  123.       delete fDataTypeReg;
  124. }
  125. // ---------------------------------------------------------------------------
  126. //  GrammarResolver: Getter methods
  127. // ---------------------------------------------------------------------------
  128. DatatypeValidator*
  129. GrammarResolver::getDatatypeValidator(const XMLCh* const uriStr,
  130.                                       const XMLCh* const localPartStr) {
  131.     DatatypeValidator* dv = 0;
  132.     if (XMLString::equals(uriStr, SchemaSymbols::fgURI_SCHEMAFORSCHEMA)) {
  133.         if (!fDataTypeReg) {
  134.             fDataTypeReg = new (fMemoryManager) DatatypeValidatorFactory(fMemoryManager);
  135.             fDataTypeReg->expandRegistryToFullSchemaSet();
  136.         }
  137.         dv = fDataTypeReg->getDatatypeValidator(localPartStr);
  138.     }
  139.     else {
  140.         Grammar* grammar = getGrammar(uriStr);
  141.         if (grammar && grammar->getGrammarType() == Grammar::SchemaGrammarType) {
  142.             XMLBuffer nameBuf(128, fMemoryManager);
  143.             nameBuf.set(uriStr);
  144.             nameBuf.append(chComma);
  145.             nameBuf.append(localPartStr);
  146.             dv = ((SchemaGrammar*) grammar)->getDatatypeRegistry()->getDatatypeValidator(nameBuf.getRawBuffer());
  147.         }
  148.     }
  149.     return dv;
  150. }
  151. Grammar* GrammarResolver::getGrammar( const XMLCh* const nameSpaceKey )
  152. {
  153.     if (!nameSpaceKey) {
  154.         return 0;
  155.     }
  156.     Grammar* aGrammar = fGrammarRegistry->get(nameSpaceKey);
  157.     if (!aGrammar && fUseCachedGrammar && fCachedGrammarRegistry)
  158.         aGrammar = fCachedGrammarRegistry->get(nameSpaceKey);
  159.     return aGrammar;
  160. }
  161. RefHashTableOfEnumerator<Grammar>
  162. GrammarResolver::getGrammarEnumerator() const
  163. {
  164.     return RefHashTableOfEnumerator<Grammar>(fGrammarRegistry);
  165. }
  166. bool GrammarResolver::containsNameSpace( const XMLCh* const nameSpaceKey )
  167. {
  168.    return fGrammarRegistry->containsKey( nameSpaceKey );
  169. }
  170. void GrammarResolver::putGrammar( const XMLCh* const nameSpaceKey, Grammar* const grammarToAdopt ){
  171.    if (fCacheGrammar)
  172.        fCachedGrammarRegistry->put((void*) nameSpaceKey, grammarToAdopt);
  173.    fGrammarRegistry->put( (void*) nameSpaceKey, grammarToAdopt );
  174. }
  175. // ---------------------------------------------------------------------------
  176. //  GrammarResolver: methods
  177. // ---------------------------------------------------------------------------
  178. void GrammarResolver::reset() {
  179.    fGrammarRegistry->removeAll();
  180. }
  181. void GrammarResolver::resetCachedGrammar()
  182. {
  183.     if (fCachedGrammarRegistry)
  184.         fCachedGrammarRegistry->removeAll();
  185. }
  186. void GrammarResolver::cacheGrammars()
  187. {
  188.     RefHashTableOfEnumerator<Grammar> grammarEnum(fGrammarRegistry);
  189.     ValueVectorOf<XMLCh*> keys(8, fMemoryManager);
  190.     unsigned int keyCount = 0;
  191.     //Check if a grammar has already been cached.
  192.     while (grammarEnum.hasMoreElements()) {
  193.         XMLCh* grammarKey = (XMLCh*) grammarEnum.nextElementKey();
  194.         if (fCachedGrammarRegistry && fCachedGrammarRegistry->containsKey(grammarKey)) {
  195.             ThrowXML(RuntimeException, XMLExcepts::GC_ExistingGrammar);
  196.         }
  197.         keys.addElement(grammarKey);
  198.         keyCount++;
  199.     }
  200.     if (!fCachedGrammarRegistry)
  201.         fCachedGrammarRegistry = new (fMemoryManager) RefHashTableOf<Grammar>(29, true, fMemoryManager);
  202.     // Cache
  203.     for (unsigned int i=0; i<keyCount; i++) {
  204.         XMLCh* grammarKey = keys.elementAt(i);
  205.         Grammar* grammar = fGrammarRegistry->orphanKey(grammarKey);
  206.         fCachedGrammarRegistry->put((void*) grammarKey, grammar);
  207.     }
  208. }
  209. // ---------------------------------------------------------------------------
  210. //  GrammarResolver: Setter methods
  211. // ---------------------------------------------------------------------------
  212. void GrammarResolver::cacheGrammarFromParse(const bool aValue) {
  213.     if (aValue && !fCachedGrammarRegistry) {
  214.         fCachedGrammarRegistry = new (fMemoryManager) RefHashTableOf<Grammar>(29, true, fMemoryManager);
  215.     }
  216.     fCacheGrammar = aValue;
  217.     fGrammarRegistry->removeAll();
  218.     fGrammarRegistry->setAdoptElements(!fCacheGrammar);
  219. }
  220. XERCES_CPP_NAMESPACE_END