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

词法分析

开发平台:

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: IRIXPlatformUtils.cpp,v $
  58.  * Revision 1.12  2003/05/15 18:37:48  knoaman
  59.  * Partial implementation of the configurable memory manager.
  60.  *
  61.  * Revision 1.11  2003/04/25 17:19:40  peiyongz
  62.  * throw exception if getcwd() fails
  63.  *
  64.  * Revision 1.10  2003/04/24 02:54:24  peiyongz
  65.  * Logical Path Resolution
  66.  *
  67.  * Revision 1.9  2003/04/21 04:28:04  peiyongz
  68.  * performance tuning
  69.  *
  70.  * Revision 1.8  2003/03/09 16:54:25  peiyongz
  71.  * PanicHandler
  72.  *
  73.  * Revision 1.7  2003/02/05 18:28:21  tng
  74.  * [Bug 13437] Incorrect memory management in XXXPlatformUtils.cpp.
  75.  *
  76.  * Revision 1.6  2002/12/12 16:28:55  peiyongz
  77.  * MsgCatalogLoader added.
  78.  *
  79.  * Revision 1.5  2002/12/02 19:16:38  tng
  80.  * [Bug 14723] Memory leak in atomicOpsMutex.  Patch from Adam Zell.
  81.  *
  82.  * Revision 1.4  2002/11/15 21:05:45  tng
  83.  * [Bug 14598] IRIX 6.5 / g++ 3.0.4 compilation bugs.  Patch from Richard Balint
  84.  * .
  85.  *
  86.  * Revision 1.3  2002/11/04 15:13:00  tng
  87.  * C++ Namespace Support.
  88.  *
  89.  * Revision 1.2  2002/05/21 20:31:47  tng
  90.  * Minor update: Remove obsolete code
  91.  *
  92.  * Revision 1.1.1.1  2002/02/01 22:22:24  peiyongz
  93.  * sane_include
  94.  *
  95.  * Revision 1.14  2001/12/11 14:46:39  tng
  96.  * [Bug 5320] 1.5.2 Build fails on IRIX.  The variable "atomicOpsMutex" has been defined twice.  Fixed by Christopher Just.
  97.  *
  98.  * Revision 1.13  2001/10/23 23:10:20  peiyongz
  99.  * [Bug#880] patch to PlatformUtils:init()/term() and related. from Mark Weaver
  100.  *
  101.  * Revision 1.12  2001/09/04 19:05:44  peiyongz
  102.  * Patch to support IRIX's sproc(), from Christopher Just
  103.  *
  104.  * Revision 1.11  2001/01/26 15:42:00  tng
  105.  * Undefined symbol error when building a single threaded version of the xerces lib on irix.  Fixed by Walker.
  106.  *
  107.  * Revision 1.10  2000/07/25 22:29:45  aruna1
  108.  * Char definitions in XMLUni moved to XMLUniDefs
  109.  *
  110.  * Revision 1.9  2000/04/03 19:27:19  abagchi
  111.  * Included changes for SGI IRIX 6.5
  112.  *
  113.  * Revision 1.8  2000/03/02 21:10:36  abagchi
  114.  * Added empty function platformTerm()
  115.  *
  116.  * Revision 1.7  2000/03/02 20:42:40  abagchi
  117.  * Fixed typo in XMLExcepts
  118.  *
  119.  * Revision 1.6  2000/03/02 19:55:22  roddey
  120.  * This checkin includes many changes done while waiting for the
  121.  * 1.1.0 code to be finished. I can't list them all here, but a list is
  122.  * available elsewhere.
  123.  *
  124.  * Revision 1.5  2000/02/06 07:48:27  rahulj
  125.  * Year 2K copyright swat.
  126.  *
  127.  * Revision 1.4  2000/01/25 22:32:35  aruna1
  128.  * Updated panic information
  129.  *
  130.  * Revision 1.3  1999/12/18 00:54:43  rahulj
  131.  * Merged in changes for IRIX submitted by Marc Stuessel
  132.  *
  133.  * Revision 1.2  1999/12/14 23:53:32  rahulj
  134.  * Removed the offending Ctrl-M's from the commit message
  135.  * logs which was giving packaging problems.
  136.  *
  137.  * PR:
  138.  * Obtained from:
  139.  * Submitted by:
  140.  * Reviewed by:
  141.  *
  142.  * Revision 1.1  1999/12/01 17:16:18  rahulj
  143.  * Added support for IRIX 6.5.5 using SGI MIPSpro C++ 7.3 and 7.21 generating 32 bit objects. Changes submitted by Marc Stuessel
  144.  *
  145.  */
  146. // ---------------------------------------------------------------------------
  147. //  Includes
  148. // ---------------------------------------------------------------------------
  149. #if !defined(APP_NO_THREADS)
  150. #ifdef XML_USE_SPROC
  151. #include    <ulocks.h>
  152. #else
  153. #include    <pthread.h>
  154. #endif
  155. #endif
  156. #include    <unistd.h>
  157. #include    <stdio.h>
  158. #include    <stdlib.h>
  159. #include    <errno.h>
  160. #include    <sys/param.h>
  161. #include    <sys/timeb.h>
  162. #include    <string.h>
  163. #include    <xercesc/util/PlatformUtils.hpp>
  164. #include    <xercesc/util/RuntimeException.hpp>
  165. #include    <xercesc/util/Janitor.hpp>
  166. #include    <xercesc/util/Mutexes.hpp>
  167. #include    <xercesc/util/XMLString.hpp>
  168. #include    <xercesc/util/XMLUniDefs.hpp>
  169. #include    <xercesc/util/XMLUni.hpp>
  170. #include    <xercesc/util/PanicHandler.hpp>
  171. #if defined(XML_USE_ICU_TRANSCODER)
  172.     #include <xercesc/util/Transcoders/ICU/ICUTransService.hpp>
  173. #else
  174.     // Use native transcoder. Same as -DXML_USE_NATIVE_TRANSCODER
  175.     #include <xercesc/util/Transcoders/Iconv/IconvTransService.hpp>
  176. #endif
  177. #if defined(XML_USE_ICU_MESSAGELOADER)
  178.     #include <xercesc/util/MsgLoaders/ICU/ICUMsgLoader.hpp>
  179. #elif defined (XML_USE_ICONV_MESSAGELOADER)
  180.     #include <xercesc/util/MsgLoaders/MsgCatalog/MsgCatalogLoader.hpp>
  181. #else
  182.     // Same as -DXML_USE_INMEM_MESSAGELOADER
  183.     #include <xercesc/util/MsgLoaders/InMemory/InMemMsgLoader.hpp>
  184. #endif
  185. #if defined (XML_USE_NETACCESSOR_SOCKET)
  186.     #include <xercesc/util/NetAccessors/Socket/SocketNetAccessor.hpp>
  187. #endif
  188. XERCES_CPP_NAMESPACE_BEGIN
  189. // ---------------------------------------------------------------------------
  190. //  XMLPlatformUtils: Private Static Methods
  191. // ---------------------------------------------------------------------------
  192. XMLNetAccessor* XMLPlatformUtils::makeNetAccessor()
  193. {
  194. #if defined (XML_USE_NETACCESSOR_SOCKET)
  195.     return new SocketNetAccessor();
  196. #else
  197.     return 0;
  198. #endif
  199. }
  200. //
  201. //  This method is called by the platform independent part of this class
  202. //  when client code asks to have one of the supported message sets loaded.
  203. //
  204. XMLMsgLoader* XMLPlatformUtils::loadAMsgSet(const XMLCh* const msgDomain)
  205. {
  206.     XMLMsgLoader* retVal;
  207.     try
  208.     {
  209. #if defined (XML_USE_ICU_MESSAGELOADER)
  210.         retVal = new ICUMsgLoader(msgDomain);
  211. #elif defined (XML_USE_ICONV_MESSAGELOADER)
  212.         retVal = new MsgCatalogLoader(msgDomain);
  213. #else
  214.         // same as -DXML_USE_INMEM_MESSAGELOADER
  215.         retVal = new InMemMsgLoader(msgDomain);
  216. #endif
  217.     }
  218.     catch(...)
  219.     {
  220.         panic(PanicHandler::Panic_CantLoadMsgDomain);
  221.     }
  222.     return retVal;
  223. }
  224. //
  225. //  This method is called very early in the bootstrapping process. This guy
  226. //  must create a transcoding service and return it. It cannot use any string
  227. //  methods, any transcoding services, throw any exceptions, etc... It just
  228. //  makes a transcoding service and returns it, or returns zero on failure.
  229. //
  230. XMLTransService* XMLPlatformUtils::makeTransService()
  231. {
  232. #if defined (XML_USE_ICU_TRANSCODER)
  233.     // Use ICU transcoding services.
  234.     // same as -DXML_USE_ICU_MESSAGELOADER
  235.     return new ICUTransService;
  236. #else
  237.     // Use native transcoding services.
  238.     // same as -DXML_USE_INMEM_MESSAGELOADER
  239.     return new IconvTransService;
  240. #endif
  241. }
  242. // ---------------------------------------------------------------------------
  243. //  XMLPlatformUtils: The panic method
  244. // ---------------------------------------------------------------------------
  245. void XMLPlatformUtils::panic(const PanicHandler::PanicReasons reason)
  246. {
  247.     fgUserPanicHandler? fgUserPanicHandler->panic(reason) : fgDefaultPanicHandler->panic(reason);
  248. }
  249. // ---------------------------------------------------------------------------
  250. //  XMLPlatformUtils: File Methods
  251. // ---------------------------------------------------------------------------
  252. unsigned int XMLPlatformUtils::curFilePos(FileHandle theFile)
  253. {
  254.     int curPos = ftell( (FILE*)theFile);
  255.     if (curPos == -1)
  256.         ThrowXML(XMLPlatformUtilsException,
  257.                  XMLExcepts::File_CouldNotGetSize);
  258.     return (unsigned int)curPos;
  259. }
  260. void XMLPlatformUtils::closeFile(FileHandle theFile)
  261. {
  262.     if (fclose((FILE*)theFile))
  263.         ThrowXML(XMLPlatformUtilsException,
  264.                  XMLExcepts::File_CouldNotCloseFile);
  265. }
  266. unsigned int XMLPlatformUtils::fileSize(FileHandle theFile)
  267. {
  268.     // Get the current position
  269.     long  int curPos = ftell((FILE*) theFile);
  270.     if (curPos == -1)
  271.         ThrowXML(XMLPlatformUtilsException,
  272.                  XMLExcepts::File_CouldNotGetCurPos);
  273.     // Seek to the end and save that value for return
  274.      if (fseek((FILE*) theFile, 0, SEEK_END))
  275.         ThrowXML(XMLPlatformUtilsException,
  276.                  XMLExcepts::File_CouldNotSeekToEnd);
  277.     long int retVal = ftell((FILE*)theFile);
  278.     if (retVal == -1)
  279.         ThrowXML(XMLPlatformUtilsException,
  280.                  XMLExcepts::File_CouldNotSeekToEnd);
  281.     // And put the pointer back
  282.     if (fseek( (FILE*)theFile, curPos, SEEK_SET) )
  283.         ThrowXML(XMLPlatformUtilsException,
  284.                  XMLExcepts::File_CouldNotSeekToPos);
  285.     return (unsigned int)retVal;
  286. }
  287. FileHandle XMLPlatformUtils::openFile(const XMLCh* const fileName)
  288. {
  289.     const char* tmpFileName = XMLString::transcode(fileName, fgMemoryManager);
  290.     ArrayJanitor<char> janText((char*)tmpFileName, fgMemoryManager);
  291.     FileHandle retVal = (FILE*)fopen( tmpFileName , "rb" );
  292.     if (retVal == NULL)
  293.         return 0;
  294.     return retVal;
  295. }
  296. FileHandle XMLPlatformUtils::openFile(const char* const fileName)
  297. {
  298.     FileHandle retVal = (FILE*)fopen( fileName , "rb" );
  299.     if (retVal == NULL)
  300.         return 0;
  301.     return retVal;
  302. }
  303. FileHandle XMLPlatformUtils::openFileToWrite(const XMLCh* const fileName)
  304. {
  305.     const char* tmpFileName = XMLString::transcode(fileName, fgMemoryManager);
  306.     ArrayJanitor<char> janText((char*)tmpFileName, fgMemoryManager);
  307.     return fopen( tmpFileName , "wb" );
  308. }
  309. FileHandle XMLPlatformUtils::openFileToWrite(const char* const fileName)
  310. {
  311.     return fopen( fileName , "wb" );
  312. }
  313. FileHandle XMLPlatformUtils::openStdInHandle()
  314. {
  315.         return (FileHandle)fdopen(dup(0), "rb");
  316. }
  317. unsigned int
  318. XMLPlatformUtils::readFileBuffer( FileHandle          theFile
  319.                                 , const unsigned int  toRead
  320.                                 , XMLByte* const      toFill)
  321. {
  322.     size_t noOfItemsRead = fread((void*) toFill, 1, toRead, (FILE*)theFile);
  323.     if(ferror((FILE*)theFile))
  324.     {
  325.         ThrowXML(XMLPlatformUtilsException,
  326.                  XMLExcepts::File_CouldNotReadFromFile);
  327.     }
  328.     return (unsigned int)noOfItemsRead;
  329. }
  330. void
  331. XMLPlatformUtils::writeBufferToFile( FileHandle     const  theFile
  332.                                    , long                  toWrite
  333.                                    , const XMLByte* const  toFlush)
  334. {
  335.     if (!theFile        ||
  336.         (toWrite <= 0 ) ||
  337.         !toFlush         )
  338.         return;
  339.     const XMLByte* tmpFlush = (const XMLByte*) toFlush;
  340.     size_t bytesWritten = 0;
  341.     while (true)
  342.     {
  343.         bytesWritten=fwrite(tmpFlush, sizeof(XMLByte), toWrite, (FILE*)theFile);
  344.         if(ferror((FILE*)theFile))
  345.         {
  346.             ThrowXML(XMLPlatformUtilsException,XMLExcepts::File_CouldNotWriteToFile);
  347.         }
  348.         if (bytesWritten < toWrite) //incomplete write
  349.         {
  350.             tmpFlush+=bytesWritten;
  351.             toWrite-=bytesWritten;
  352.             bytesWritten=0;
  353.         }
  354.         else
  355.             return;
  356.     }
  357.     return;
  358. }
  359. void XMLPlatformUtils::resetFile(FileHandle theFile)
  360. {
  361.     // Seek to the start of the file
  362.     if (fseek((FILE*)theFile, 0, SEEK_SET))
  363.         ThrowXML(XMLPlatformUtilsException,
  364.                  XMLExcepts::File_CouldNotResetFile);
  365. }
  366. // ---------------------------------------------------------------------------
  367. //  XMLPlatformUtils: File system methods
  368. // ---------------------------------------------------------------------------
  369. XMLCh* XMLPlatformUtils::getFullPath(const XMLCh* const srcPath,
  370.                                      MemoryManager* const manager)
  371. {
  372.     //
  373.     //  NOTE: THe path provided has always already been opened successfully,
  374.     //  so we know that its not some pathological freaky path. It comes in
  375.     //  in native format, and goes out as Unicode always
  376.     //
  377.     char* newSrc = XMLString::transcode(srcPath, fgMemoryManager);
  378.     ArrayJanitor<char> janText(newSrc, fgMemoryManager);
  379.     // Use a local buffer that is big enough for the largest legal path
  380.     char absPath[PATH_MAX + 1];
  381.     // get the absolute path
  382.     char* retPath = realpath(newSrc, &absPath[0]);
  383.     if (!retPath)
  384.     {
  385.         ThrowXML(XMLPlatformUtilsException, XMLExcepts::File_CouldNotGetBasePathName);
  386.     }
  387.     return XMLString::transcode(absPath, manager);
  388. }
  389. bool XMLPlatformUtils::isRelative(const XMLCh* const toCheck)
  390. {
  391.     // Check for pathological case of empty path
  392.     if (!toCheck[0])
  393.         return false;
  394.     //
  395.     //  If it starts with a slash, then it cannot be relative. This covers
  396.     //  both something like "TestFile.xml" and an NT Lan type remote path
  397.     //  that starts with a node like "\MyNodeTestFile.xml".
  398.     //
  399.     if (toCheck[0] == XMLCh('/'))
  400.         return false;
  401.     // Else assume its a relative path
  402.     return true;
  403. }
  404. XMLCh* XMLPlatformUtils::getCurrentDirectory(MemoryManager* const manager)
  405. {
  406.     char  dirBuf[PATH_MAX + 1];
  407.     char  *curDir = getcwd(&dirBuf[0], PATH_MAX + 1);
  408.     if (!curDir)
  409.     {
  410.         ThrowXML(XMLPlatformUtilsException,
  411.                  XMLExcepts::File_CouldNotGetBasePathName);
  412.     }
  413.     return XMLString::transcode(curDir, manager);
  414. }
  415. inline bool XMLPlatformUtils::isAnySlash(XMLCh c) 
  416. {
  417.     return ( chBackSlash == c || chForwardSlash == c);
  418. }
  419. // ---------------------------------------------------------------------------
  420. //  XMLPlatformUtils: Timing Methods
  421. // ---------------------------------------------------------------------------
  422. unsigned long XMLPlatformUtils::getCurrentMillis()
  423. {
  424.     timeb aTime;
  425.     ftime(&aTime);
  426.     return (unsigned long)(aTime.time*1000 + aTime.millitm);
  427. }
  428. // -----------------------------------------------------------------------
  429. //  Mutex methods
  430. // -----------------------------------------------------------------------
  431. #if !defined(APP_NO_THREADS)
  432. static XMLMutex atomicOpsMutex;
  433. #ifdef XML_USE_SPROC
  434. // ---------------------------------------------------------------------------
  435. //  XMLPlatformUtils: Platform init method
  436. // ---------------------------------------------------------------------------
  437. static char* arenaName = NULL;
  438. static usptr_t* arena = NULL;
  439. void XMLPlatformUtils::platformInit()
  440. {
  441.     //
  442.     // The atomicOps mutex needs to be created early.
  443.     // Normally, mutexes are created on first use, but there is a
  444.     // circular dependency between compareAndExchange() and
  445.     // mutex creation that must be broken.
  446.     // need a shared memory space
  447.     usconfig(CONF_INITUSERS, 128);
  448.     usconfig(CONF_INITSIZE, 16000);
  449.     usconfig(CONF_AUTOGROW, 1);   // Default, but we set anyway
  450.     arenaName = strdup ("/var/tmp/xerces-sharedmemXXXXXX");
  451.     arena = usinit (mktemp (arenaName));
  452.     if (atomicOpsMutex.fHandle == 0)
  453.         atomicOpsMutex.fHandle = XMLPlatformUtils::makeMutex();
  454. }
  455. void XMLPlatformUtils::platformTerm()
  456. {
  457.     // delete the mutex we created
  458.     closeMutex(atomicOpsMutex.fHandle);
  459.     atomicOpsMutex.fHandle = 0;
  460.     usdetach (arena);
  461.     unlink (arenaName);
  462.     free (arenaName);
  463.     arena = NULL;
  464.     // We don't have any termination requirements at this time
  465. }
  466. void* XMLPlatformUtils::makeMutex()
  467. {
  468.     if (arena) {
  469.         usema_t* sema = usnewsema (arena, 1);
  470.         if (sema && (usctlsema (sema, CS_RECURSIVEON) != -1)) {
  471.             return (void*)sema;
  472.         }
  473.         else
  474.             ThrowXML (XMLPlatformUtilsException,
  475.                       XMLExcepts::Mutex_CouldNotCreate);
  476.     }
  477.     else {
  478.         // arena==0; therefore platformInit hasn't been called.
  479.         // it's important that we fail quietly here so that we don't
  480.         // throw an exception when trying to initizlize the
  481.         // atomicOpsMutex, which we re-initizlize in platformInit anyay.
  482.         return 0;
  483.     }
  484. }
  485. void XMLPlatformUtils::closeMutex(void* const mtxHandle)
  486. {
  487.     if ((mtxHandle != NULL) && (arena != NULL)) {
  488.         usfreesema ((usema_t *)mtxHandle, arena);
  489.         // never returns anything testable for failure, so nothing
  490.         // to throw an exception about.
  491.     }
  492. }
  493. void XMLPlatformUtils::lockMutex(void* const mtxHandle)
  494. {
  495.     if (mtxHandle != NULL) {
  496.         if (uspsema (mtxHandle) != 1)
  497.             ThrowXML(XMLPlatformUtilsException,
  498.                      XMLExcepts::Mutex_CouldNotLock);
  499.     }
  500. }
  501. void XMLPlatformUtils::unlockMutex(void* const mtxHandle)
  502. {
  503.     if (mtxHandle != NULL)
  504.     {
  505.         if (usvsema(mtxHandle) == -1)
  506.         {
  507.             ThrowXML(XMLPlatformUtilsException,
  508.                      XMLExcepts::Mutex_CouldNotUnlock);
  509.         }
  510.     }
  511. }
  512. #else
  513. // ---------------------------------------------------------------------------
  514. //  XMLPlatformUtils: Platform init method
  515. // ---------------------------------------------------------------------------
  516. void XMLPlatformUtils::platformInit()
  517. {
  518.     //
  519.     // The atomicOps mutex needs to be created early.
  520.     // Normally, mutexes are created on first use, but there is a
  521.     // circular dependency between compareAndExchange() and
  522.     // mutex creation that must be broken.
  523.     if (atomicOpsMutex.fHandle == 0)
  524.         atomicOpsMutex.fHandle = XMLPlatformUtils::makeMutex();
  525. }
  526. void XMLPlatformUtils::platformTerm()
  527. {
  528.     // delete the mutex we created
  529. closeMutex(atomicOpsMutex.fHandle);
  530. atomicOpsMutex.fHandle = 0;
  531. }
  532. void* XMLPlatformUtils::makeMutex()
  533. {
  534.     pthread_mutex_t* mutex = new pthread_mutex_t;
  535.     pthread_mutexattr_t*  attr = new pthread_mutexattr_t;
  536.     pthread_mutexattr_init(attr);
  537.     pthread_mutexattr_settype(attr, PTHREAD_MUTEX_RECURSIVE);
  538.     if (pthread_mutex_init(mutex, attr))
  539.     {
  540.         ThrowXML(XMLPlatformUtilsException,
  541.                  XMLExcepts::Mutex_CouldNotCreate);
  542.     }
  543.     pthread_mutexattr_destroy(attr);
  544.     delete attr;
  545.     return (void*)(mutex);
  546. }
  547. void XMLPlatformUtils::closeMutex(void* const mtxHandle)
  548. {
  549.     if (mtxHandle != NULL)
  550.     {
  551.         if (pthread_mutex_destroy((pthread_mutex_t*) mtxHandle))
  552.         {
  553.             ThrowXML(XMLPlatformUtilsException,
  554.                      XMLExcepts::Mutex_CouldNotDestroy);
  555.         }
  556.         delete (pthread_mutex_t*) mtxHandle;
  557.     }
  558. }
  559. void XMLPlatformUtils::lockMutex(void* const mtxHandle)
  560. {
  561.     if (mtxHandle != NULL)
  562.     {
  563.         if (pthread_mutex_lock((pthread_mutex_t*) mtxHandle))
  564.         {
  565.             ThrowXML(XMLPlatformUtilsException,
  566.                      XMLExcepts::Mutex_CouldNotLock);
  567.         }
  568.     }
  569. }
  570. void XMLPlatformUtils::unlockMutex(void* const mtxHandle)
  571. {
  572.     if (mtxHandle != NULL)
  573.     {
  574.         if (pthread_mutex_unlock((pthread_mutex_t*) mtxHandle))
  575.         {
  576.             ThrowXML(XMLPlatformUtilsException,
  577.                      XMLExcepts::Mutex_CouldNotUnlock);
  578.         }
  579.     }
  580. }
  581. #endif   // XML_USE_SPROC
  582. // -----------------------------------------------------------------------
  583. //  Miscellaneous synchronization methods
  584. // -----------------------------------------------------------------------
  585. void* XMLPlatformUtils::compareAndSwap(void**            toFill
  586.                                      , const void* const newValue
  587.                                      , const void* const toCompare)
  588. {
  589.     XMLMutexLock lockMutex(&atomicOpsMutex);
  590.     void *retVal = *toFill;
  591.     if (*toFill == toCompare)
  592.         *toFill = (void *)newValue;
  593.     return retVal;
  594. }
  595. int XMLPlatformUtils::atomicIncrement(int &location)
  596. {
  597.     XMLMutexLock localLock(&atomicOpsMutex);
  598.     return ++location;
  599. }
  600. int XMLPlatformUtils::atomicDecrement(int &location)
  601. {
  602.     XMLMutexLock localLock(&atomicOpsMutex);
  603.     return --location;
  604. }
  605. #else // #if !defined (APP_NO_THREADS)
  606. void XMLPlatformUtils::platformInit()
  607. {
  608. }
  609. void* XMLPlatformUtils::makeMutex()
  610. {
  611.         return 0;
  612. }
  613. void XMLPlatformUtils::closeMutex(void* const mtxHandle)
  614. {
  615. }
  616. void XMLPlatformUtils::lockMutex(void* const mtxHandle)
  617. {
  618. }
  619. void XMLPlatformUtils::unlockMutex(void* const mtxHandle)
  620. {
  621. }
  622. void* XMLPlatformUtils::compareAndSwap (void**             toFill,
  623.                                         const void* const  newValue,
  624.                                         const void* const  toCompare)
  625. {
  626.     void *retVal = *toFill;
  627.     if (*toFill == toCompare)
  628.        *toFill = (void *)newValue;
  629.     return retVal;
  630. }
  631. int XMLPlatformUtils::atomicIncrement(int &location)
  632. {
  633.     return ++location;
  634. }
  635. int XMLPlatformUtils::atomicDecrement(int &location)
  636. {
  637.     return --location;
  638. }
  639. void XMLPlatformUtils::platformTerm()
  640. {
  641.     // We don't have any termination requirements at this time
  642. }
  643. #endif // APP_NO_THREADS
  644. //void XMLPlatformUtils::platformTerm()
  645. //{
  646.     // We don't have any termination requirements at this time
  647. //}
  648. #include <xercesc/util/LogicalPath.c>
  649. XERCES_CPP_NAMESPACE_END