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

词法分析

开发平台:

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.  * $Log: TandemPlatformUtils.cpp,v $
  58.  * Revision 1.9  2003/05/15 18:37:49  knoaman
  59.  * Partial implementation of the configurable memory manager.
  60.  *
  61.  * Revision 1.8  2003/04/24 02:58:31  peiyongz
  62.  * Logical Path Resolution
  63.  *
  64.  * Revision 1.7  2003/03/09 17:00:11  peiyongz
  65.  * PanicHandler
  66.  *
  67.  * Revision 1.6  2003/02/05 18:29:27  tng
  68.  * [Bug 13437] Incorrect memory management in XXXPlatformUtils.cpp.
  69.  *
  70.  * Revision 1.5  2003/01/09 15:30:39  tng
  71.  * Missing panic function in Tandem
  72.  *
  73.  * Revision 1.4  2002/12/12 16:29:30  peiyongz
  74.  * loadAMsgSet() added
  75.  *
  76.  * Revision 1.3  2002/11/04 15:13:01  tng
  77.  * C++ Namespace Support.
  78.  *
  79.  * Revision 1.2  2002/05/21 20:31:48  tng
  80.  * Minor update: Remove obsolete code
  81.  *
  82.  * Revision 1.1.1.1  2002/02/01 22:22:26  peiyongz
  83.  * sane_include
  84.  *
  85.  * Revision 1.4  2000/03/02 21:10:38  abagchi
  86.  * Added empty function platformTerm()
  87.  *
  88.  * Revision 1.3  2000/03/02 19:55:32  roddey
  89.  * This checkin includes many changes done while waiting for the
  90.  * 1.1.0 code to be finished. I can't list them all here, but a list is
  91.  * available elsewhere.
  92.  *
  93.  * Revision 1.2  2000/02/06 07:48:30  rahulj
  94.  * Year 2K copyright swat.
  95.  *
  96.  * Revision 1.1.1.1  1999/11/09 01:06:24  twl
  97.  * Initial checkin
  98.  *
  99.  * Revision 1.2  1999/11/08 20:45:32  rahul
  100.  * Swat for adding in Product name and CVS comment log variable.
  101.  *
  102.  */
  103. // ---------------------------------------------------------------------------
  104. //  Includes
  105. // ---------------------------------------------------------------------------
  106. // XXX #include    <pthread.h>
  107. // XXX #include    <sys/atomic_op.h>
  108. #include    <xercesc/util/PlatformUtils.hpp>
  109. #include    <xercesc/util/RuntimeException.hpp>
  110. #include    <xercesc/util/Janitor.hpp>
  111. #include    <xercesc/util/PanicHandler.hpp>
  112. #include    <stdio.h>
  113. #include    <stdlib.h>
  114. #include    <errno.h>
  115. #include    <libgen.h>
  116. #include    <sys/timeb.h>
  117. #include    <string.h>
  118. #if defined (XML_USE_ICU_MESSAGELOADER)
  119.     #include <xercesc/util/MsgLoaders/ICU/ICUMsgLoader.hpp>
  120. #elif defined (XML_USE_ICONV_MESSAGELOADER)
  121.     #include <xercesc/util/MsgLoaders/MsgCatalog/MsgCatalogLoader.hpp>
  122. #else   // use In-memory message loader
  123.     #include <xercesc/util/MsgLoaders/InMemory/InMemMsgLoader.hpp>
  124. #endif
  125. XERCES_CPP_NAMESPACE_BEGIN
  126. // ---------------------------------------------------------------------------
  127. //  XMLPlatformUtils: Platform init method
  128. // ---------------------------------------------------------------------------
  129. void XMLPlatformUtils::platformInit()
  130. {
  131. }
  132. //
  133. //  This method is called by the platform independent part of this class
  134. //  when client code asks to have one of the supported message sets loaded.
  135. //  In our case, we use the ICU based message loader mechanism.
  136. //
  137. XMLMsgLoader* XMLPlatformUtils::loadAMsgSet(const XMLCh* const msgDomain)
  138. {
  139.     XMLMsgLoader* retVal;
  140.     try
  141.     {
  142. #if defined (XML_USE_ICU_MESSAGELOADER)
  143.         retVal = new ICUMsgLoader(msgDomain);
  144. #elif defined (XML_USE_ICONV_MESSAGELOADER)
  145.         retVal = new MsgCatalogLoader(msgDomain);
  146. #else
  147.         retVal = new InMemMsgLoader(msgDomain);
  148. #endif
  149.     }
  150.     catch(...)
  151.     {
  152.         panic(PanicHandler::Panic_CantLoadMsgDomain);
  153.     }
  154.     return retVal;
  155. }
  156. void XMLPlatformUtils::panic(const PanicHandler::PanicReasons reason)
  157. {
  158.     fgUserPanicHandler? fgUserPanicHandler->panic(reason) : fgDefaultPanicHandler->panic(reason);
  159. }
  160. // ---------------------------------------------------------------------------
  161. //  XMLPlatformUtils: File Methods
  162. // ---------------------------------------------------------------------------
  163. unsigned int XMLPlatformUtils::curFilePos(FileHandle theFile)
  164. {
  165.     // Get the current position
  166.     int curPos = ftell( (FILE*)theFile);
  167.     if (curPos == -1)
  168.         throw XMLPlatformUtilsException("XMLPlatformUtils::curFilePos - Could not get current pos");
  169.     return (unsigned int)curPos;
  170. }
  171. void XMLPlatformUtils::closeFile(FileHandle theFile)
  172. {
  173.     if (fclose((FILE*)theFile))
  174.         throw XMLPlatformUtilsException("XMLPlatformUtils::closeFile - Could not close the file handle");
  175. }
  176. unsigned int XMLPlatformUtils::fileSize(FileHandle theFile)
  177. {
  178.     // Get the current position
  179.     long  int curPos = ftell((FILE*)theFile);
  180.     if (curPos == -1)
  181.         throw XMLPlatformUtilsException("XMLPlatformUtils::fileSize - Could not get current pos");
  182.     // Seek to the end and save that value for return
  183.      if (fseek( (FILE*)theFile, 0, SEEK_END) )
  184.         throw XMLPlatformUtilsException("XMLPlatformUtils::fileSize - Could not seek to end");
  185.     long int retVal = ftell( (FILE*)theFile);
  186.     if (retVal == -1)
  187.         throw XMLPlatformUtilsException("XMLPlatformUtils::fileSize - Could not get the file size");
  188.     // And put the pointer back
  189.     if (fseek( (FILE*)theFile, curPos, SEEK_SET) )
  190.         throw XMLPlatformUtilsException("XMLPlatformUtils::fileSize - Could not seek back to original pos");
  191.     return (unsigned int)retVal;
  192. }
  193. FileHandle XMLPlatformUtils::openFile(const unsigned short* const fileName)
  194. {
  195.     const char* tmpFileName = XMLString::transcode(fileName, fgMemoryManager);
  196.     ArrayJanitor<char> tmpFileNameJan((char*)tmpFileName , fgMemoryManager);
  197.     FileHandle retVal = (FILE*)fopen( tmpFileName , "rb" );
  198.     if (retVal == NULL)
  199.         return 0;
  200.     return retVal;
  201. }
  202. unsigned int
  203. XMLPlatformUtils::readFileBuffer(  FileHandle      theFile
  204.                                 , const unsigned int    toRead
  205.                                 , XMLByte* const  toFill)
  206. {
  207.     size_t noOfItemsRead = fread( (void*) toFill, 1, toRead, (FILE*)theFile);
  208.     if(ferror((FILE*)theFile))
  209.     {
  210.         throw XMLPlatformUtilsException("XMLPlatformUtils::readFileBuffer - Read failed");
  211.     }
  212.     return (unsigned int)noOfItemsRead;
  213. }
  214. void XMLPlatformUtils::resetFile(FileHandle theFile)
  215. {
  216.     // Seek to the start of the file
  217.     if (fseek((FILE*)theFile, 0, SEEK_SET) )
  218.         throw XMLPlatformUtilsException("XMLPlatformUtils::resetFile - Could not seek to beginning");
  219. }
  220. // ---------------------------------------------------------------------------
  221. //  XMLPlatformUtils: File system methods
  222. // ---------------------------------------------------------------------------
  223. XMLCh* XMLPlatformUtils::getFullPath(const XMLCh* const srcPath,
  224.                                      MemoryManager* const manager)
  225. {
  226.     //
  227.     //  NOTE: THe path provided has always already been opened successfully,
  228.     //  so we know that its not some pathological freaky path. It comes in
  229.     //  in native format, and goes out as Unicode always
  230.     //
  231.     char* newSrc = XMLString::transcode(srcPath, fgMemoryManager);
  232.     // Use a local buffer that is big enough for the largest legal path
  233.      char* tmpPath = dirname((char*)newSrc);
  234.     if (!tmpPath)
  235.     {
  236.         throw XMLPlatformUtilsException("XMLPlatformUtils::resetFile - Could not get the base path name");
  237.     }
  238.     char* newXMLString = (char*) fgMemoryManager->allocate
  239.     (
  240.         (strlen(tmpPath) +1) * sizeof(char)
  241.     );//new char [strlen(tmpPath) +1];
  242.     ArrayJanitor<char> newJanitor(newXMLString, fgMemoryManager);
  243.     strcpy(newXMLString, tmpPath);
  244.         strcat(newXMLString , "/");
  245.     // Return a copy of the path, in Unicode format
  246.     return XMLString::transcode(newXMLString, manager);
  247. }
  248. bool XMLPlatformUtils::isRelative(const XMLCh* const toCheck)
  249. {
  250.     // Check for pathological case of empty path
  251.     if (!toCheck[0])
  252.         return false;
  253.     //
  254.     //  If it starts with a slash, then it cannot be relative. This covers
  255.     //  both something like "TestFile.xml" and an NT Lan type remote path
  256.     //  that starts with a node like "\MyNodeTestFile.xml".
  257.     //
  258.     if (toCheck[0] == XMLCh('/'))
  259.         return false;
  260.     // Else assume its a relative path
  261.     return true;
  262. }
  263. XMLCh* XMLPlatformUtils::getCurrentDirectory()
  264. {
  265.     /*** 
  266.      *  REVISIT:
  267.      * 
  268.      *   To be implemented later
  269.     ***/
  270.     XMLCh curDir[]={ chPeriod, chForwardSlash, chNull};
  271.     return getFullPath(curDir);
  272. }
  273. inline bool XMLPlatformUtils::isAnySlash(XMLCh c) 
  274. {
  275.     return ( chBackSlash == c || chForwardSlash == c);
  276. }
  277. // ---------------------------------------------------------------------------
  278. //  XMLPlatformUtils: Timing Methods
  279. // ---------------------------------------------------------------------------
  280. unsigned long XMLPlatformUtils::getCurrentMillis()
  281. {
  282.     timeb aTime;
  283.     ftime(&aTime);
  284.     return (unsigned long)(aTime.time*1000 + aTime.millitm);
  285. }
  286. #ifndef __TANDEM
  287. // -----------------------------------------------------------------------
  288. //  Mutex methods
  289. // -----------------------------------------------------------------------
  290. void XMLPlatformUtils::closeMutex(void* const mtxHandle)
  291. {
  292.     if (mtxHandle == NULL)
  293.         return;
  294.     if (pthread_mutex_destroy( (pthread_mutex_t*)mtxHandle))
  295.     {
  296.         throw XMLPlatformUtilsException("Could not destroy a mutex");
  297.     }
  298.     if ( (pthread_mutex_t*)mtxHandle)
  299.         delete (pthread_mutex_t*) mtxHandle;
  300. }
  301. void XMLPlatformUtils::lockMutex(void* const mtxHandle)
  302. {
  303.     if (mtxHandle == NULL)
  304.         return;
  305.     if (pthread_mutex_lock( (pthread_mutex_t*)mtxHandle))
  306.     {
  307.         throw XMLPlatformUtilsException("Could not lock a mutex");
  308.     }
  309. }
  310. void* XMLPlatformUtils::makeMutex()
  311. {
  312.     pthread_mutex_t* mutex = new pthread_mutex_t;
  313.     if (mutex == NULL)
  314.     {
  315.         throw XMLPlatformUtilsException("Could not initialize a mutex");
  316.     }
  317.     if (pthread_mutex_init(mutex, NULL))
  318.     {
  319.         throw XMLPlatformUtilsException("Could not create a mutex");
  320.     }
  321.     return (void*)(mutex);
  322. }
  323. void XMLPlatformUtils::unlockMutex(void* const mtxHandle)
  324. {
  325.     if (mtxHandle == NULL)
  326.         return;
  327.     if (pthread_mutex_unlock( (pthread_mutex_t*)mtxHandle))
  328.     {
  329.         throw XMLPlatformUtilsException("Could not unlock a mutex");
  330.     }
  331. }
  332. // -----------------------------------------------------------------------
  333. //  Miscellaneous synchronization methods
  334. // -----------------------------------------------------------------------
  335. void* XMLPlatformUtils::compareAndSwap ( void**      toFill ,
  336.                     const void* const newValue ,
  337.                     const void* const toCompare)
  338. {
  339.     boolean_t boolVar = compare_and_swap((atomic_p)toFill, (int *)&toCompare, (int)newValue );
  340.     return (void *)toCompare;
  341. }
  342. int XMLPlatformUtils::atomicIncrement(int &location)
  343. {
  344.     int retVal = fetch_and_add( (atomic_p)&location, 1);
  345.     return retVal+1;
  346. }
  347. int XMLPlatformUtils::atomicDecrement(int &location)
  348. {
  349.     int retVal = fetch_and_add( (atomic_p)&location, -1);
  350.     return retVal-1;
  351. }
  352. FileHandle XMLPlatformUtils::openStdInHandle()
  353. {
  354.     return (FileHandle)fdopen(dup(0), "rb");
  355. }
  356. #endif
  357. void XMLPlatformUtils::platformTerm()
  358. {
  359.     // We don't have any termination requirements at this time
  360. }
  361. #include <xercesc/util/LogicalPath.c>
  362. XERCES_CPP_NAMESPACE_END