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

词法分析

开发平台:

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: UnixWarePlatformUtils.cpp,v $
  58.  * Revision 1.10  2003/05/15 18:37:49  knoaman
  59.  * Partial implementation of the configurable memory manager.
  60.  *
  61.  * Revision 1.9  2003/04/25 17:21:31  peiyongz
  62.  * throw exception if getcwd() fails
  63.  *
  64.  * Revision 1.8  2003/04/24 02:59:20  peiyongz
  65.  * Logical Path Resolution
  66.  *
  67.  * Revision 1.7  2003/04/21 04:32:10  peiyongz
  68.  * performance tuning
  69.  *
  70.  * Revision 1.6  2003/03/09 17:01:08  peiyongz
  71.  * PanicHandler
  72.  *
  73.  * Revision 1.5  2003/03/07 20:34:16  tng
  74.  * [Bug 17774] Unixware platform utils not implemented .  Patch from Peter Crozier.
  75.  *
  76.  * Revision 1.4  2002/11/04 15:13:01  tng
  77.  * C++ Namespace Support.
  78.  *
  79.  * Revision 1.3  2002/05/21 20:31:48  tng
  80.  * Minor update: Remove obsolete code
  81.  *
  82.  * Revision 1.2  2002/05/01 21:13:32  tng
  83.  * [Bug 7265] UnixWare port broken in platformTerm() since rev 1.10.
  84.  *
  85.  * Revision 1.1.1.1  2002/02/01 22:22:26  peiyongz
  86.  * sane_include
  87.  *
  88.  * Revision 1.11  2001/10/25 15:20:31  tng
  89.  * Need to guard with NO_APP_THREADS when destroying the mutex.
  90.  *
  91.  * Revision 1.10  2001/10/23 23:13:09  peiyongz
  92.  * [Bug#880] patch to PlatformUtils:init()/term() and related. from Mark Weaver
  93.  *
  94.  * Revision 1.9  2001/02/09 14:40:02  tng
  95.  * Update support for SCO UnixWare 7 (gcc).  Tested under UnixWare 7.1.1 with gcc version 2.95.2 19991024 (release) with gmake 3.79.1.  Updated by Martin Kalen.
  96.  *
  97.  * Revision 1.8  2000/07/25 22:30:54  aruna1
  98.  * Char definitions in XMLUni moved to XMLUniDefs
  99.  *
  100.  * Revision 1.7  2000/03/24 00:13:34  aruna1
  101.  * Platform initialization taken care for both threaded and non-threaded environment
  102.  *
  103.  * Revision 1.6  2000/03/02 21:10:39  abagchi
  104.  * Added empty function platformTerm()
  105.  *
  106.  * Revision 1.5  2000/03/02 20:42:42  abagchi
  107.  * Fixed typo in XMLExcepts
  108.  *
  109.  * Revision 1.4  2000/03/02 19:55:33  roddey
  110.  * This checkin includes many changes done while waiting for the
  111.  * 1.1.0 code to be finished. I can't list them all here, but a list is
  112.  * available elsewhere.
  113.  *
  114.  * Revision 1.3  2000/02/06 07:48:31  rahulj
  115.  * Year 2K copyright swat.
  116.  *
  117.  * Revision 1.2  2000/01/25 22:33:13  aruna1
  118.  * Updated panic information
  119.  *
  120.  * Revision 1.1  1999/12/17 22:24:03  rahulj
  121.  * Added missing UnixWare files to the repository.
  122.  *
  123.  * Created by Ron Record (rr@sco.com) based on SolarisPlatformUtils.cpp
  124.  * 13-Nov-1999
  125.  */
  126. // ---------------------------------------------------------------------------
  127. //  Includes
  128. // ---------------------------------------------------------------------------
  129. #if !defined (APP_NO_THREADS)
  130. #include    <pthread.h>
  131. #endif // APP_NO_THREADS
  132. #include    <unistd.h>
  133. #include    <stdio.h>
  134. #include    <stdlib.h>
  135. #include    <errno.h>
  136. #include    <libgen.h>
  137. #include    <sys/timeb.h>
  138. #include    <limits.h>
  139. #include    <xercesc/util/PlatformUtils.hpp>
  140. #include    <xercesc/util/RuntimeException.hpp>
  141. #include    <xercesc/util/Janitor.hpp>
  142. #include    <xercesc/util/Mutexes.hpp>
  143. #include    <xercesc/util/XMLString.hpp>
  144. #include    <xercesc/util/XMLUniDefs.hpp>
  145. #include    <xercesc/util/XMLUni.hpp>
  146. #if defined (XML_USE_ICU_TRANSCODER)
  147.     #include <xercesc/util/Transcoders/ICU/ICUTransService.hpp>
  148. #elif defined (XML_USE_NATIVE_TRANSCODER)
  149.     #include <xercesc/util/Transcoders/Iconv/IconvTransService.hpp>
  150. #else
  151.     #error Transcoding service unknown by UnixWarePlatformUtils.cpp
  152. #endif
  153. #if defined(XML_USE_ICU_MESSAGELOADER)
  154.     #include <xercesc/util/MsgLoaders/ICU/ICUMsgLoader.hpp>
  155. #elif defined (XML_USE_ICONV_MESSAGELOADER)
  156.     #include <xercesc/util/MsgLoaders/MsgCatalog/MsgCatalogLoader.hpp>
  157. #elif defined (XML_USE_INMEM_MESSAGELOADER)
  158.     #include <xercesc/util/MsgLoaders/InMemory/InMemMsgLoader.hpp>
  159. #else
  160.     #error Message loading service unknown by UnixWarePlatformUtils.cpp
  161. #endif
  162. #if defined (XML_USE_NETACCESSOR_LIBWWW)
  163.     #include <xercesc/util/NetAccessors/libWWW/LibWWWNetAccessor.hpp>
  164. #elif defined (XML_USE_NETACCESSOR_SOCKET)
  165.     #include <xercesc/util/NetAccessors/Socket/SocketNetAccessor.hpp>
  166. #endif
  167. XERCES_CPP_NAMESPACE_BEGIN
  168. // ---------------------------------------------------------------------------
  169. //  XMLPlatformUtils: Private Static Methods
  170. // ---------------------------------------------------------------------------
  171. XMLNetAccessor* XMLPlatformUtils::makeNetAccessor()
  172. {
  173. #if defined (XML_USE_NETACCESSOR_LIBWWW)
  174.     return new LibWWWNetAccessor();
  175. #elif defined (XML_USE_NETACCESSOR_SOCKET)
  176.     return new SocketNetAccessor();
  177. #else
  178.     return 0;
  179. #endif
  180. }
  181. //
  182. //  This method is called by the platform independent part of this class
  183. //  when client code asks to have one of the supported message sets loaded.
  184. //
  185. XMLMsgLoader* XMLPlatformUtils::loadAMsgSet(const XMLCh* const msgDomain)
  186. {
  187.     XMLMsgLoader* retVal;
  188.     try
  189.     {
  190. #if defined (XML_USE_ICU_MESSAGELOADER)
  191.         retVal = new ICUMsgLoader(msgDomain);
  192. #elif defined (XML_USE_ICONV_MESSAGELOADER)
  193.         retVal = new MsgCatalogLoader(msgDomain);
  194. #else
  195.         retVal = new InMemMsgLoader(msgDomain);
  196. #endif
  197.     }
  198.     catch(...)
  199.     {
  200.         panic(PanicHandler::Panic_CantLoadMsgDomain);
  201.     }
  202.     return retVal;
  203. }
  204. //
  205. //  This method is called very early in the bootstrapping process. This guy
  206. //  must create a transcoding service and return it. It cannot use any string
  207. //  methods, any transcoding services, throw any exceptions, etc... It just
  208. //  makes a transcoding service and returns it, or returns zero on failure.
  209. //
  210. XMLTransService* XMLPlatformUtils::makeTransService()
  211. {
  212. #if defined (XML_USE_ICU_TRANSCODER)
  213.         return new ICUTransService;
  214. #elif defined (XML_USE_ICONV_TRANSCODER)
  215.     return new IconvTransService;
  216. #else // Use Native transcoding service
  217.     return new IconvTransService;
  218. #endif
  219. }
  220. // ---------------------------------------------------------------------------
  221. //  XMLPlatformUtils: The panic method
  222. // ---------------------------------------------------------------------------
  223. void XMLPlatformUtils::panic(const PanicReasons reason)
  224. {
  225.     fgUserPanicHandler? fgUserPanicHandler->panic(reason) : fgDefaultPanicHandler->panic(reason);
  226. }
  227. // ---------------------------------------------------------------------------
  228. //  XMLPlatformUtils: File Methods
  229. // ---------------------------------------------------------------------------
  230. unsigned int XMLPlatformUtils::curFilePos(FileHandle theFile)
  231. {
  232.     // Get the current position
  233.     int curPos = ftell((FILE*) theFile);
  234.     if (curPos == -1)
  235.         ThrowXML(XMLPlatformUtilsException,
  236.                  XMLExcepts::File_CouldNotGetSize);
  237.     return (unsigned int)curPos;
  238. }
  239. void XMLPlatformUtils::closeFile(FileHandle theFile)
  240. {
  241.     if (fclose((FILE*) theFile))
  242.         ThrowXML(XMLPlatformUtilsException,
  243.                  XMLExcepts::File_CouldNotCloseFile);
  244. }
  245. unsigned int XMLPlatformUtils::fileSize(FileHandle theFile)
  246. {
  247.     // Get the current position
  248.     long  int curPos = ftell((FILE*) theFile);
  249.     if (curPos == -1)
  250.         ThrowXML(XMLPlatformUtilsException,
  251.                  XMLExcepts::File_CouldNotGetCurPos);
  252.     // Seek to the end and save that value for return
  253. if (fseek((FILE*) theFile, 0, SEEK_END))
  254.         ThrowXML(XMLPlatformUtilsException,
  255.                  XMLExcepts::File_CouldNotSeekToEnd);
  256.     long int retVal = ftell((FILE*) theFile);
  257.     if (retVal == -1)
  258.         ThrowXML(XMLPlatformUtilsException,
  259.                  XMLExcepts::File_CouldNotSeekToEnd);
  260.     // And put the pointer back
  261.     if (fseek((FILE*) theFile, curPos, SEEK_SET))
  262.         ThrowXML(XMLPlatformUtilsException,
  263.                  XMLExcepts::File_CouldNotSeekToPos);
  264.     return (unsigned int)retVal;
  265. }
  266. FileHandle XMLPlatformUtils::openFile(const XMLCh* const fileName)
  267. {
  268.     const char* tmpFileName = XMLString::transcode(fileName, fgMemoryManager);
  269.     ArrayJanitor<char> janText((char*)tmpFileName, fgMemoryManager);
  270.     FileHandle retVal = (FILE*)fopen( tmpFileName , "rb" );
  271.     if (retVal == NULL)
  272.         return 0;
  273.     return retVal;
  274. }
  275. FileHandle XMLPlatformUtils::openFile(const char* const fileName)
  276. {
  277.     FileHandle retVal = (FILE*)fopen( fileName , "rb" );
  278.     if (retVal == NULL)
  279.         return 0;
  280.     return retVal;
  281. }
  282. FileHandle XMLPlatformUtils::openFileToWrite(const XMLCh* const fileName)
  283. {
  284.     const char* tmpFileName = XMLString::transcode(fileName, fgMemoryManager);
  285.     ArrayJanitor<char> janText((char*)tmpFileName, fgMemoryManager);
  286.     return fopen( tmpFileName , "wb" );
  287. }
  288. FileHandle XMLPlatformUtils::openFileToWrite(const char* const fileName)
  289. {
  290.     return fopen( fileName , "wb" );
  291. }
  292. FileHandle XMLPlatformUtils::openStdInHandle()
  293. {
  294. return (FileHandle)fdopen(dup(0), "rb");
  295. }
  296. unsigned int
  297. XMLPlatformUtils::readFileBuffer( FileHandle          theFile
  298.                                , const unsigned int      toRead
  299.                                , XMLByte* const          toFill)
  300. {
  301.     size_t noOfItemsRead = fread((void*) toFill, 1, toRead, (FILE*) theFile);
  302.     if(ferror((FILE*) theFile))
  303.     {
  304.         ThrowXML(XMLPlatformUtilsException,
  305.                  XMLExcepts::File_CouldNotReadFromFile);
  306.     }
  307.     return (unsigned int) noOfItemsRead;
  308. }
  309. void
  310. XMLPlatformUtils::writeBufferToFile( FileHandle     const  theFile
  311.                                    , long                  toWrite
  312.                                    , const XMLByte* const  toFlush)
  313. {
  314.     if (!theFile        ||
  315.         (toWrite <= 0 ) ||
  316.         !toFlush         )
  317.         return;
  318.     const XMLByte* tmpFlush = (const XMLByte*) toFlush;
  319.     size_t bytesWritten = 0;
  320.     while (true)
  321.     {
  322.         bytesWritten=fwrite(tmpFlush, sizeof(XMLByte), toWrite, (FILE*)theFile);
  323.         if(ferror((FILE*)theFile))
  324.         {
  325.             ThrowXML(XMLPlatformUtilsException, XMLExcepts::File_CouldNotWriteToFile);
  326.         }
  327.         if (bytesWritten < toWrite) //incomplete write
  328.         {
  329.             tmpFlush+=bytesWritten;
  330.             toWrite-=bytesWritten;
  331.             bytesWritten=0;
  332.         }
  333.         else
  334.             return;
  335.     }
  336.     return;
  337. }
  338. void XMLPlatformUtils::resetFile(FileHandle theFile)
  339. {
  340.     // Seek to the start of the file
  341.     if (fseek((FILE*) theFile, 0, SEEK_SET))
  342.         ThrowXML(XMLPlatformUtilsException,
  343.                  XMLExcepts::File_CouldNotResetFile);
  344. }
  345. // ---------------------------------------------------------------------------
  346. //  XMLPlatformUtils: File system methods
  347. // ---------------------------------------------------------------------------
  348. XMLCh* XMLPlatformUtils::getFullPath(const XMLCh* const srcPath,
  349.                                      MemoryManager* const manager)
  350. {
  351.     //
  352.     //  NOTE: The path provided has always already been opened successfully,
  353.     //  so we know that its not some pathological freaky path. It comes in
  354.     //  in native format, and goes out as Unicode always
  355.     //
  356.     char* newSrc = XMLString::transcode(srcPath, fgMemoryManager);
  357.     ArrayJanitor<char> janText(newSrc, fgMemoryManager);
  358.     // Use a local buffer that is big enough for the largest legal path
  359.     char absPath[PATH_MAX + 1];
  360.     //get the absolute path
  361.     char* retPath = realpath(newSrc, &absPath[0]);
  362.     if (!retPath)
  363.     {
  364.         ThrowXML(XMLPlatformUtilsException,
  365.                  XMLExcepts::File_CouldNotGetBasePathName);
  366.     }
  367.     return XMLString::transcode(absPath, manager);
  368. }
  369. bool XMLPlatformUtils::isRelative(const XMLCh* const toCheck)
  370. {
  371.     // Check for pathological case of empty path
  372.     if (!toCheck[0])
  373.         return false;
  374.     //
  375.     //  If it starts with a slash, then it cannot be relative. This covers
  376.     //  both something like "TestFile.xml" and an NT Lan type remote path
  377.     //  that starts with a node like "\MyNodeTestFile.xml".
  378.     //
  379.     if (toCheck[0] == XMLCh('/'))
  380.         return false;
  381.     // Else assume its a relative path
  382.     return true;
  383. }
  384. XMLCh* XMLPlatformUtils::getCurrentDirectory(MemoryManager* const manager)
  385. {
  386.     char  dirBuf[PATH_MAX + 1];
  387.     char  *curDir = getcwd(&dirBuf[0], PATH_MAX + 1);
  388.     if (!curDir)
  389.     {
  390.         ThrowXML(XMLPlatformUtilsException,
  391.                  XMLExcepts::File_CouldNotGetBasePathName);
  392.     }
  393.     return XMLString::transcode(curDir, manager);
  394. }
  395. inline bool XMLPlatformUtils::isAnySlash(XMLCh c) 
  396. {
  397.     return ( chBackSlash == c || chForwardSlash == c);
  398. }
  399. // ---------------------------------------------------------------------------
  400. //  XMLPlatformUtils: Timing Methods
  401. // ---------------------------------------------------------------------------
  402. unsigned long XMLPlatformUtils::getCurrentMillis()
  403. {
  404.     timeb aTime;
  405.     ftime(&aTime);
  406.     return (unsigned long)(aTime.time*1000 + aTime.millitm);
  407. }
  408. // -----------------------------------------------------------------------
  409. //  Mutex methods
  410. // -----------------------------------------------------------------------
  411. #if !defined (APP_NO_THREADS)
  412. // ---------------------------------------------------------------------------
  413. //  XMLPlatformUtils: Platform init method
  414. // ---------------------------------------------------------------------------
  415. static pthread_mutex_t* gAtomicOpMutex =0 ;
  416. void XMLPlatformUtils::platformInit()
  417. {
  418.     //
  419.     // The gAtomicOpMutex mutex needs to be created
  420.     // because compareAndSwap, atomicIncrement and atomicDecrement
  421.     // does not have the atomic system calls for usage
  422.     // Normally, mutexes are created on first use, but there is a
  423.     // circular dependency between compareAndExchange() and
  424.     // mutex creation that must be broken.
  425.     gAtomicOpMutex = new pthread_mutex_t;
  426.     if (pthread_mutex_init(gAtomicOpMutex, NULL))
  427.         panic( PanicHandler::Panic_SystemInit );
  428. }
  429. class  RecursiveMutex : public XMemory
  430. {
  431. public:
  432.     pthread_mutex_t   mutex;
  433.     int               recursionCount;
  434.     pthread_t         tid;
  435.     RecursiveMutex() {
  436. if (pthread_mutex_init(&mutex, NULL))
  437. ThrowXML(XMLPlatformUtilsException, XMLExcepts::Mutex_CouldNotCreate);
  438. recursionCount = 0;
  439. tid = 0;
  440. };
  441.     ~RecursiveMutex() {
  442. if (pthread_mutex_destroy(&mutex))
  443. ThrowXML(XMLPlatformUtilsException, XMLExcepts::Mutex_CouldNotDestroy);
  444. };
  445. void lock()      {
  446. if (pthread_equal(tid, pthread_self()))
  447. {
  448. recursionCount++;
  449. return;
  450. }
  451. if (pthread_mutex_lock(&mutex) != 0)
  452. ThrowXML(XMLPlatformUtilsException, XMLExcepts::Mutex_CouldNotLock);
  453. tid = pthread_self();
  454. recursionCount = 1;
  455. };
  456. void unlock()    {
  457. if (--recursionCount > 0)
  458. return;
  459. if (pthread_mutex_unlock(&mutex) != 0)
  460. ThrowXML(XMLPlatformUtilsException, XMLExcepts::Mutex_CouldNotUnlock);
  461. tid = 0;
  462. };
  463. };
  464. void* XMLPlatformUtils::makeMutex()
  465. {
  466.     return new RecursiveMutex;
  467. };
  468. void XMLPlatformUtils::closeMutex(void* const mtxHandle)
  469. {
  470.     if (mtxHandle == NULL)
  471.         return;
  472.     RecursiveMutex *rm = (RecursiveMutex *)mtxHandle;
  473.     delete rm;
  474. };
  475. void XMLPlatformUtils::lockMutex(void* const mtxHandle)
  476. {
  477.     if (mtxHandle == NULL)
  478.         return;
  479.     RecursiveMutex *rm = (RecursiveMutex *)mtxHandle;
  480.     rm->lock();
  481. }
  482. void XMLPlatformUtils::unlockMutex(void* const mtxHandle)
  483. {
  484.     if (mtxHandle == NULL)
  485.         return;
  486.     RecursiveMutex *rm = (RecursiveMutex *)mtxHandle;
  487.     rm->unlock();
  488. }
  489. // -----------------------------------------------------------------------
  490. //  Miscellaneous synchronization methods
  491. // -----------------------------------------------------------------------
  492. //atomic system calls in UnixWare is only restricted to kernel libraries
  493. //So, to make operations thread safe we implement static mutex and lock
  494. //the atomic operations. It makes the process slow but what's the alternative!
  495. void* XMLPlatformUtils::compareAndSwap ( void**      toFill ,
  496.                     const void* const newValue ,
  497.                     const void* const toCompare)
  498. {
  499.     if (pthread_mutex_lock( gAtomicOpMutex))
  500.         panic(PanicHandler::Panic_SynchronizationErr);
  501.     void *retVal = *toFill;
  502.     if (*toFill == toCompare)
  503.               *toFill = (void *)newValue;
  504.     if (pthread_mutex_unlock( gAtomicOpMutex))
  505.         panic(PanicHandler::Panic_SynchronizationErr);
  506.     return retVal;
  507. }
  508. int XMLPlatformUtils::atomicIncrement(int &location)
  509. {
  510.     if (pthread_mutex_lock( gAtomicOpMutex))
  511.         panic(PanicHandler::Panic_SynchronizationErr);
  512.     int tmp = ++location;
  513.     if (pthread_mutex_unlock( gAtomicOpMutex))
  514.         panic(PanicHandler::Panic_SynchronizationErr);
  515.     return tmp;
  516. }
  517. int XMLPlatformUtils::atomicDecrement(int &location)
  518. {
  519.     if (pthread_mutex_lock( gAtomicOpMutex))
  520.         panic(PanicHandler::Panic_SynchronizationErr);
  521.     int tmp = --location;
  522.     if (pthread_mutex_unlock( gAtomicOpMutex))
  523.         panic(PanicHandler::Panic_SynchronizationErr);
  524.     return tmp;
  525. }
  526. #else // #if !defined (APP_NO_THREADS)
  527. void XMLPlatformUtils::platformInit()
  528. {
  529. }
  530. void* XMLPlatformUtils::makeMutex()
  531. {
  532. return 0;
  533. }
  534. void XMLPlatformUtils::closeMutex(void* const mtxHandle)
  535. {
  536. }
  537. void XMLPlatformUtils::lockMutex(void* const mtxHandle)
  538. {
  539. }
  540. void XMLPlatformUtils::unlockMutex(void* const mtxHandle)
  541. {
  542. }
  543. void* XMLPlatformUtils::compareAndSwap ( void**      toFill,
  544.                                    const void* const newValue,
  545.                                    const void* const toCompare)
  546. {
  547.     void *retVal = *toFill;
  548.     if (*toFill == toCompare)
  549.        *toFill = (void *)newValue;
  550.     return retVal;
  551. }
  552. int XMLPlatformUtils::atomicIncrement(int &location)
  553. {
  554.     return ++location;
  555. }
  556. int XMLPlatformUtils::atomicDecrement(int &location)
  557. {
  558.     return --location;
  559. }
  560. #endif // APP_NO_THREADS
  561. void XMLPlatformUtils::platformTerm()
  562. {
  563. #if !defined (APP_NO_THREADS)
  564.     // delete the mutex we created
  565. pthread_mutex_destroy(gAtomicOpMutex);
  566.     delete gAtomicOpMutex;
  567. gAtomicOpMutex = 0;
  568. #endif
  569. }
  570. #include <xercesc/util/LogicalPath.c>
  571. XERCES_CPP_NAMESPACE_END