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

词法分析

开发平台:

Visual C++

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2001-2002 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 2001, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  56. /*
  57.  * $Id: DOMImplementationImpl.cpp,v 1.17 2003/05/18 14:02:03 knoaman Exp $
  58.  */
  59. #include "DOMImplementationImpl.hpp"
  60. #include "DOMDocumentImpl.hpp"
  61. #include "DOMDocumentTypeImpl.hpp"
  62. #include "DOMWriterImpl.hpp"
  63. #include <xercesc/dom/DOMDocument.hpp>
  64. #include <xercesc/dom/DOMDocumentType.hpp>
  65. #include <xercesc/dom/DOMException.hpp>
  66. #include <xercesc/util/PlatformUtils.hpp>
  67. #include <xercesc/util/XMLUniDefs.hpp>
  68. #include <xercesc/util/XMLChar.hpp>
  69. #include <xercesc/util/XMLRegisterCleanup.hpp>
  70. #include <xercesc/util/XMLStringTokenizer.hpp>
  71. #include <xercesc/util/XMLDOMMsg.hpp>
  72. #include <xercesc/util/XMLMsgLoader.hpp>
  73. #include <xercesc/parsers/DOMBuilderImpl.hpp>
  74. XERCES_CPP_NAMESPACE_BEGIN
  75. // ------------------------------------------------------------
  76. //
  77. //  Static constants.  These are lazily initialized on first usage.
  78. //                     (Static constructors can not be safely used because
  79. //                      of order of initialization dependencies.)
  80. // ------------------------------------------------------------
  81. static const XMLCh  gXML[] =      // Points to "XML"
  82.         {chLatin_X, chLatin_M, chLatin_L, chNull};
  83. static const XMLCh  g1_0[] =     // Points to "1.0"
  84.         {chDigit_1, chPeriod, chDigit_0, chNull};
  85. static const XMLCh  g2_0[] =      // Points to "2.0"
  86.         {chDigit_2, chPeriod, chDigit_0, chNull};
  87. static const XMLCh  g3_0[] =      // Points to "3.0"
  88.         {chDigit_3, chPeriod, chDigit_0, chNull};
  89. static const XMLCh  gTrav[] =     // Points to "Traversal"
  90.         {chLatin_T, chLatin_r, chLatin_a, chLatin_v, chLatin_e, chLatin_r,
  91.             chLatin_s, chLatin_a, chLatin_l, chNull};
  92. static const XMLCh  gCore[] =     // Points to "Core"
  93.         {chLatin_C, chLatin_o, chLatin_r, chLatin_e, chNull};
  94. static const XMLCh  gRange[] =     // Points to "Range"
  95.         {chLatin_R, chLatin_a, chLatin_n, chLatin_g, chLatin_e, 0};
  96. static const XMLCh  gLS[] =     // Points to "LS"
  97.         {chLatin_L, chLatin_S, chNull};
  98. // -----------------------------------------------------------------------
  99. //  Message Loader for DOM
  100. // -----------------------------------------------------------------------
  101. static XMLMsgLoader             *gMsgLoader4DOM;   // Points to the singleton instance
  102. static void reinitMsgLoader4DOM()
  103. {
  104. delete gMsgLoader4DOM;
  105. gMsgLoader4DOM = 0;
  106. }
  107. XMLMsgLoader* DOMImplementationImpl::getMsgLoader4DOM() {
  108. static XMLRegisterCleanup msgLoader4DOMCleanup;
  109.     if (gMsgLoader4DOM == 0)
  110.     {
  111.         XMLMsgLoader* t = XMLPlatformUtils::loadMsgSet(XMLUni::fgXMLDOMMsgDomain);
  112.         if (!t)
  113.             XMLPlatformUtils::panic(PanicHandler::Panic_CantLoadMsgDomain);
  114.         else {
  115.             if (XMLPlatformUtils::compareAndSwap((void **)&gMsgLoader4DOM, t, 0) != 0)
  116.             {
  117.                 delete t;
  118.             }
  119.             else
  120.             {
  121.                 msgLoader4DOMCleanup.registerCleanup(reinitMsgLoader4DOM);
  122.             }
  123.         }
  124.     }
  125.     return gMsgLoader4DOM;
  126. };
  127. // -----------------------------------------------------------------------
  128. //  Singleton DOMImplementationImpl
  129. // -----------------------------------------------------------------------
  130. static DOMImplementationImpl    *gDomimp;   // Points to the singleton instance
  131.                                             //  of DOMImplementation that is returnedreturned
  132.                                             //  by any call to getImplementation().
  133. static void reinitImplementation()
  134. {
  135. delete gDomimp;
  136. gDomimp = 0;
  137. }
  138. //  getImplementation()  - Always returns the same singleton instance, which
  139. //                         is lazily created on the first call.  Note that
  140. //                         DOM_Implementation must be thread-safe because
  141. //                         it is common to all DOM documents, and while a single
  142. //                         document is not thread-safe within itself, we do
  143. //                         promise that different documents can safely be
  144. //                         used concurrently by different threads.
  145. //
  146. DOMImplementationImpl *DOMImplementationImpl::getDOMImplementationImpl() {
  147. static XMLRegisterCleanup implementationCleanup;
  148.     if (gDomimp == 0)
  149.     {
  150.         DOMImplementationImpl *t = new DOMImplementationImpl;
  151.         if (XMLPlatformUtils::compareAndSwap((void **)&gDomimp, t, 0) != 0)
  152.         {
  153.             delete t;
  154.         }
  155.         else
  156.         {
  157. implementationCleanup.registerCleanup(reinitImplementation);
  158.         }
  159.     }
  160.     return gDomimp;
  161. };
  162. // ------------------------------------------------------------
  163. // DOMImplementation Virtual interface
  164. // ------------------------------------------------------------
  165. bool  DOMImplementationImpl::hasFeature(const  XMLCh * feature,  const  XMLCh * version) const
  166. {
  167.     if (!feature)
  168.         return false;
  169.     bool anyVersion = (version == 0 || !*version);
  170.     bool version1_0 = XMLString::equals(version, g1_0);
  171.     bool version2_0 = XMLString::equals(version, g2_0);
  172.     bool version3_0 = XMLString::equals(version, g3_0);
  173.     // Currently, we support only XML Level 1 version 1.0
  174.     if (XMLString::compareIString(feature, gXML) == 0
  175.         && (anyVersion || version1_0 || version2_0))
  176.         return true;
  177.     if (XMLString::compareIString(feature, gCore) == 0
  178.         && (anyVersion || version1_0 || version2_0 || version3_0))
  179.         return true;
  180.     if (XMLString::compareIString(feature, gTrav) == 0
  181.         && (anyVersion || version2_0))
  182.         return true;
  183.     if (XMLString::compareIString(feature, gRange) == 0
  184.         && (anyVersion || version2_0))
  185.         return true;
  186.     if (XMLString::compareIString(feature, gLS) == 0
  187.         && (anyVersion || version3_0))
  188.         return true;
  189.     return false;
  190. }
  191. //Introduced in DOM Level 2
  192. DOMDocumentType *DOMImplementationImpl::createDocumentType(const XMLCh *qualifiedName,
  193. const XMLCh * publicId, const XMLCh *systemId)
  194. {
  195.     // assume XML 1.0 since we do not know its version yet.
  196.     if(!XMLChar1_0::isValidName(qualifiedName, XMLString::stringLen(qualifiedName)))
  197.         throw DOMException(DOMException::INVALID_CHARACTER_ERR,0);
  198.     DOMDocumentTypeImpl* docType = new DOMDocumentTypeImpl(0, qualifiedName, publicId, systemId, true);
  199.     return docType;
  200. }
  201. DOMDocument *DOMImplementationImpl::createDocument(const XMLCh *namespaceURI,
  202. const XMLCh *qualifiedName, DOMDocumentType *doctype,
  203.     MemoryManager* const manager)
  204. {
  205.     return new (manager) DOMDocumentImpl(namespaceURI, qualifiedName, doctype, manager);
  206. }
  207. //Introduced in DOM Level 3
  208. DOMImplementation* DOMImplementationImpl::getInterface(const XMLCh* feature){
  209.     throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0);
  210.     return 0;
  211. }
  212. // Non-standard extension
  213. DOMDocument *DOMImplementationImpl::createDocument(MemoryManager* const manager)
  214. {
  215.         return new (manager) DOMDocumentImpl(manager);
  216. }
  217. //
  218. //  DOMImplementation::getImplementation.  DOMImplementation is supposed to
  219. //                                              be a pure interface class.  This one static
  220. //                                              function is the hook that lets things get started.
  221. DOMImplementation *DOMImplementation::getImplementation()
  222. {
  223.     return (DOMImplementation*) DOMImplementationImpl::getDOMImplementationImpl();
  224. }
  225. bool DOMImplementation::loadDOMExceptionMsg
  226. (
  227.     const   DOMException::ExceptionCode  msgToLoad
  228.     ,       XMLCh* const                 toFill
  229.     , const unsigned int                 maxChars
  230. )
  231. {
  232.     // load the text, the msgToLoad+XMLDOMMsgs::DOMEXCEPTION_ERRX+msgToLoad is the corresponding XMLDOMMsg Code
  233.     return DOMImplementationImpl::getMsgLoader4DOM()->loadMsg(XMLDOMMsg::DOMEXCEPTION_ERRX+msgToLoad, toFill, maxChars);
  234. }
  235. bool DOMImplementation::loadDOMExceptionMsg
  236. (
  237.     const   DOMRangeException::RangeExceptionCode  msgToLoad
  238.     ,       XMLCh* const                           toFill
  239.     , const unsigned int                           maxChars
  240. )
  241. {
  242.     // load the text, the XMLDOMMsgs::DOMRANGEEXCEPTION_ERRX+msgToLoad is the corresponding XMLDOMMsg Code
  243.     return DOMImplementationImpl::getMsgLoader4DOM()->loadMsg(XMLDOMMsg::DOMRANGEEXCEPTION_ERRX+msgToLoad, toFill, maxChars);
  244. }
  245. // ------------------------------------------------------------
  246. // DOMImplementationLS Virtual interface
  247. // ------------------------------------------------------------
  248. //Introduced in DOM Level 3
  249. DOMBuilder* DOMImplementationImpl::createDOMBuilder(const short mode,
  250.                                                     const XMLCh* const schemaType,
  251.                                                     MemoryManager* const manager)
  252. {
  253.     if (mode == DOMImplementationLS::MODE_ASYNCHRONOUS)
  254.         throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0);
  255.     return new DOMBuilderImpl(0, manager);
  256. }
  257. DOMWriter* DOMImplementationImpl::createDOMWriter(MemoryManager* const manager)
  258. {
  259.     return new DOMWriterImpl(manager);
  260. }
  261. DOMInputSource* DOMImplementationImpl::createDOMInputSource()
  262. {
  263.     throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0);
  264.     return 0;
  265. }
  266. // ------------------------------------------------------------
  267. // DOMImplementationSource Virtual interface
  268. // ------------------------------------------------------------
  269. DOMImplementation* DOMImplementationImpl::getDOMImplementation(const XMLCh* features) const
  270. {
  271.     DOMImplementation* impl = DOMImplementation::getImplementation();
  272.     XMLStringTokenizer tokenizer(features, XMLPlatformUtils::fgMemoryManager);
  273.     const XMLCh* feature = 0;
  274.     while (feature || tokenizer.hasMoreTokens()) {
  275.         if (!feature)
  276.             feature = tokenizer.nextToken();
  277.         const XMLCh* version = 0;
  278.         const XMLCh* token = tokenizer.nextToken();
  279.         if (token && XMLString::isDigit(token[0]))
  280.             version = token;
  281.         if (!impl->hasFeature(feature, version))
  282.             return 0;
  283.         if (!version)
  284.             feature = token;
  285.     }
  286.     return impl;
  287. }
  288. XERCES_CPP_NAMESPACE_END