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

词法分析

开发平台:

Visual C++

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999-2000 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) 1999, 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: XMLException.cpp,v 1.6 2003/05/15 19:07:46 knoaman Exp $
  58.  */
  59. // ---------------------------------------------------------------------------
  60. //  Includes
  61. // ---------------------------------------------------------------------------
  62. #include <xercesc/util/XMLException.hpp>
  63. #include <xercesc/util/Mutexes.hpp>
  64. #include <xercesc/util/PlatformUtils.hpp>
  65. #include <xercesc/util/XMLMsgLoader.hpp>
  66. #include <xercesc/util/XMLRegisterCleanup.hpp>
  67. #include <xercesc/util/XMLString.hpp>
  68. #include <xercesc/util/XMLUniDefs.hpp>
  69. XERCES_CPP_NAMESPACE_BEGIN
  70. // ---------------------------------------------------------------------------
  71. //  Local data
  72. //
  73. //  gDefErrMsg
  74. //      For now, if we cannot load an exception message, we load up the
  75. //      default.
  76. // ---------------------------------------------------------------------------
  77. static const XMLCh  gDefErrMsg[] =
  78. {
  79.         chLatin_C, chLatin_o, chLatin_u, chLatin_l, chLatin_d
  80.     ,   chSpace, chLatin_n, chLatin_o, chLatin_t, chSpace
  81.     ,   chLatin_l, chLatin_o, chLatin_a, chLatin_d, chSpace
  82.     ,   chLatin_m, chLatin_e, chLatin_s, chLatin_s, chLatin_a
  83.     ,   chLatin_g, chLatin_e, chNull
  84. };
  85. // ---------------------------------------------------------------------------
  86. //  Local, static data
  87. // ---------------------------------------------------------------------------
  88. static XMLMsgLoader* sMsgLoader = 0;
  89. static XMLRegisterCleanup msgLoaderCleanup;
  90. static XMLMutex* sMsgMutex = 0;
  91. static XMLRegisterCleanup msgMutexCleanup;
  92. // ---------------------------------------------------------------------------
  93. //  Local, static functions
  94. // ---------------------------------------------------------------------------
  95. //
  96. //  We need to fault in this mutex. But, since its used for synchronization
  97. //  itself, we have to do this the low level way using a compare and swap.
  98. //
  99. static XMLMutex& gMsgMutex()
  100. {
  101.     if (!sMsgMutex)
  102.     {
  103.         XMLMutex* tmpMutex = new XMLMutex;
  104.         if (XMLPlatformUtils::compareAndSwap((void**)&sMsgMutex, tmpMutex, 0))
  105.         {
  106.             // Some other thread beat us to it, so let's clean up ours.
  107.             delete tmpMutex;
  108.         }
  109.         else
  110.         {
  111.             // This is the real mutex.  Register it for cleanup at Termination.
  112. msgMutexCleanup.registerCleanup(XMLException::reinitMsgMutex);
  113.         }
  114.     }
  115.     return *sMsgMutex;
  116. }
  117. //
  118. //  This method is a lazy evaluator for the message loader for exception
  119. //  messages.
  120. //
  121. static XMLMsgLoader& gGetMsgLoader()
  122. {
  123.     // Lock the message loader mutex and load the text
  124. XMLMutexLock lockInit(&gMsgMutex());
  125.     // Fault it in on first request
  126.     if (!sMsgLoader)
  127.     {
  128.         sMsgLoader = XMLPlatformUtils::loadMsgSet(XMLUni::fgExceptDomain);
  129.         if (!sMsgLoader)
  130.             XMLPlatformUtils::panic(PanicHandler::Panic_CantLoadMsgDomain);
  131.         //
  132.         // Register this XMLMsgLoader for cleanup at Termination.
  133.         //
  134.         msgLoaderCleanup.registerCleanup(XMLException::reinitMsgLoader);
  135.     }
  136.     // We got it, so return it
  137.     return *sMsgLoader;
  138. }
  139. // ---------------------------------------------------------------------------
  140. //  XMLException: Virtual destructor
  141. // ---------------------------------------------------------------------------
  142. XMLException::~XMLException()
  143. {
  144.     XMLPlatformUtils::fgMemoryManager->deallocate(fMsg);
  145.     XMLPlatformUtils::fgMemoryManager->deallocate(fSrcFile);
  146. }
  147. // ---------------------------------------------------------------------------
  148. //  XMLException: Setter methods
  149. // ---------------------------------------------------------------------------
  150. void XMLException::setPosition(const char* const file, const unsigned int line)
  151. {
  152.     fSrcLine = line;
  153. XMLPlatformUtils::fgMemoryManager->deallocate(fSrcFile);
  154.     fSrcFile = XMLString::replicate(file, XMLPlatformUtils::fgMemoryManager);
  155. }
  156. // ---------------------------------------------------------------------------
  157. //  XMLException: Hidden constructors and operators
  158. // ---------------------------------------------------------------------------
  159. XMLException::XMLException() :
  160.     fCode(XMLExcepts::NoError)
  161.     , fSrcFile(0)
  162.     , fSrcLine(0)
  163.     , fMsg(0)
  164. {
  165. }
  166. XMLException::XMLException( const   char* const     srcFile
  167.                             , const unsigned int    srcLine) :
  168.     fCode(XMLExcepts::NoError)
  169.     , fSrcFile(0)
  170.     , fSrcLine(srcLine)
  171.     , fMsg(0)
  172. {
  173.     fSrcFile = XMLString::replicate(srcFile, XMLPlatformUtils::fgMemoryManager);
  174. }
  175. XMLException::XMLException(const XMLException& toCopy) :
  176.     fCode(toCopy.fCode)
  177.     , fSrcFile(0)
  178.     , fSrcLine(toCopy.fSrcLine)
  179.     , fMsg(XMLString::replicate(toCopy.fMsg, XMLPlatformUtils::fgMemoryManager))
  180. {
  181.     if (toCopy.fSrcFile) {
  182.         fSrcFile = XMLString::replicate
  183.         (
  184.             toCopy.fSrcFile
  185.             , XMLPlatformUtils::fgMemoryManager
  186.         );
  187.     }
  188. }
  189. XMLException& XMLException::operator=(const XMLException& toAssign)
  190. {
  191.     if (this != &toAssign)
  192.     {
  193.         XMLPlatformUtils::fgMemoryManager->deallocate(fSrcFile);
  194.         fSrcFile = 0;
  195.         XMLPlatformUtils::fgMemoryManager->deallocate(fMsg);
  196.         fMsg = 0;
  197.         fSrcLine = toAssign.fSrcLine;
  198.         fCode = toAssign.fCode;
  199.         if (toAssign.fMsg) {
  200.             fMsg = XMLString::replicate
  201.             (
  202.                 toAssign.fMsg
  203.                 , XMLPlatformUtils::fgMemoryManager
  204.             );
  205.         }
  206.         if (toAssign.fSrcFile) {
  207.             fSrcFile = XMLString::replicate
  208.             (
  209.                 toAssign.fSrcFile
  210.                 , XMLPlatformUtils::fgMemoryManager
  211.             );
  212.         }
  213.     }
  214.     return *this;
  215. }
  216. // ---------------------------------------------------------------------------
  217. //  XMLException: Protected methods
  218. // ---------------------------------------------------------------------------
  219. void XMLException::loadExceptText(const XMLExcepts::Codes toLoad)
  220. {
  221.     // Store the error code
  222.     fCode = toLoad;
  223.     // Load up the text into a local buffer
  224.     const unsigned int msgSize = 2047;
  225.     XMLCh errText[msgSize + 1];
  226.     // load the text
  227. if (!gGetMsgLoader().loadMsg(toLoad, errText, msgSize))
  228. {
  229. fMsg = XMLString::replicate
  230.         (
  231.             gDefErrMsg
  232.             , XMLPlatformUtils::fgMemoryManager
  233.         );
  234. return;
  235. }
  236.     // We got the text so replicate it into the message member
  237.     fMsg = XMLString::replicate(errText, XMLPlatformUtils::fgMemoryManager);
  238. }
  239. void
  240. XMLException::loadExceptText(const  XMLExcepts::Codes toLoad
  241.                             , const XMLCh* const        text1
  242.                             , const XMLCh* const        text2
  243.                             , const XMLCh* const        text3
  244.                             , const XMLCh* const        text4)
  245. {
  246.     // Store the error code
  247.     fCode = toLoad;
  248.     // Load up the text into a local buffer
  249.     const unsigned int msgSize = 4095;
  250.     XMLCh errText[msgSize + 1];
  251.     // load the text
  252. if (!gGetMsgLoader().loadMsg(toLoad, errText, msgSize, text1, text2, text3, text4))
  253. {
  254. fMsg = XMLString::replicate
  255.         (
  256.             gDefErrMsg
  257.             , XMLPlatformUtils::fgMemoryManager
  258.         );
  259. return;
  260. }
  261.     // We got the text so replicate it into the message member
  262.     fMsg = XMLString::replicate(errText, XMLPlatformUtils::fgMemoryManager);
  263. }
  264. void
  265. XMLException::loadExceptText(const  XMLExcepts::Codes toLoad
  266.                             , const char* const         text1
  267.                             , const char* const         text2
  268.                             , const char* const         text3
  269.                             , const char* const         text4)
  270. {
  271.     // Store the error code
  272.     fCode = toLoad;
  273.     // Load up the text into a local buffer
  274.     const unsigned int msgSize = 4095;
  275.     XMLCh errText[msgSize + 1];
  276.     // load the text
  277. if (!gGetMsgLoader().loadMsg(toLoad, errText, msgSize, text1, text2, text3, text4))
  278. {
  279. fMsg = XMLString::replicate
  280.         (
  281.             gDefErrMsg
  282.             , XMLPlatformUtils::fgMemoryManager
  283.         );
  284. return;
  285. }
  286.     // We got the text so replicate it into the message member
  287.     fMsg = XMLString::replicate(errText, XMLPlatformUtils::fgMemoryManager);
  288. }
  289. // -----------------------------------------------------------------------
  290. //  Reinitialise the message mutex
  291. // -----------------------------------------------------------------------
  292. void XMLException::reinitMsgMutex()
  293. {
  294. delete sMsgMutex;
  295. sMsgMutex = 0;
  296. }
  297. // -----------------------------------------------------------------------
  298. //  Reinitialise the message loader
  299. // -----------------------------------------------------------------------
  300. void XMLException::reinitMsgLoader()
  301. {
  302. delete sMsgLoader;
  303. sMsgLoader = 0;
  304. }
  305. XERCES_CPP_NAMESPACE_END