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

词法分析

开发平台:

Visual C++

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2003 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: QNXPlatformUtils.cpp,v 1.5 2003/05/15 18:37:49 knoaman Exp $
  58.  */
  59. // ---------------------------------------------------------------------------
  60. //  Includes
  61. // ---------------------------------------------------------------------------
  62. #include <stdio.h>
  63. #include <stdlib.h>
  64. #include <unistd.h>
  65. #include <sys/types.h>
  66. #include <sys/stat.h>
  67. #include <sys/timeb.h>
  68. #include <atomic.h>
  69. #include <pthread.h>
  70. #include <errno.h>
  71. #include <sys/neutrino.h>
  72. #include <xercesc/util/Janitor.hpp>
  73. #include <xercesc/util/PlatformUtils.hpp>
  74. #include <xercesc/util/RuntimeException.hpp>
  75. #include <xercesc/util/XMLExceptMsgs.hpp>
  76. #include <xercesc/util/XMLString.hpp>
  77. #include <xercesc/util/XMLUniDefs.hpp>
  78. #include <xercesc/util/XMLUni.hpp>
  79. //
  80. //  These control which transcoding service is used by the QNX version.
  81. //
  82. #if defined (XML_USE_ICU_TRANSCODER)
  83.     #include <xercesc/util/Transcoders/ICU/ICUTransService.hpp>
  84. #elif defined (XML_USE_GNU_TRANSCODER)
  85.     #include <xercesc/util/Transcoders/IconvGNU/IconvGNUTransService.hpp>
  86. #else
  87.     #error A transcoding service must be chosen
  88. #endif
  89. //
  90. //  These control which message loading service is used by the QNX version.
  91. //
  92. #if defined(XML_USE_ICU_MESSAGELOADER)
  93.     #include <xercesc/util/MsgLoaders/ICU/ICUMsgLoader.hpp>
  94. #else
  95.     #include <xercesc/util/MsgLoaders/InMemory/InMemMsgLoader.hpp>
  96. #endif
  97. //
  98. //  These control which network access service is used by the QNX version.
  99. //
  100. #if defined (XML_USE_NETACCESSOR_LIBWWW)
  101.     #include <xercesc/util/NetAccessors/libWWW/LibWWWNetAccessor.hpp>
  102. #else
  103.     #include <xercesc/util/NetAccessors/Socket/SocketNetAccessor.hpp>
  104. #endif
  105. XERCES_CPP_NAMESPACE_BEGIN
  106. // ---------------------------------------------------------------------------
  107. //  XMLPlatformUtils: The panic method
  108. // ---------------------------------------------------------------------------
  109. void XMLPlatformUtils::panic(const PanicHandler::PanicReasons reason)
  110. {
  111.     fgUserPanicHandler? fgUserPanicHandler->panic(reason) : fgDefaultPanicHandler->panic(reason);
  112. }
  113. // ---------------------------------------------------------------------------
  114. //  XMLPlatformUtils: File Methods
  115. // ---------------------------------------------------------------------------
  116. unsigned int XMLPlatformUtils::curFilePos(FileHandle theFile)
  117. {
  118.     int curPos = ftell(theFile);
  119.     if (curPos == -1) {
  120.         ThrowXML(XMLPlatformUtilsException, XMLExcepts::File_CouldNotGetSize);
  121.     }
  122.     return (unsigned int)curPos;
  123. }
  124. void XMLPlatformUtils::closeFile(FileHandle theFile)
  125. {
  126.     if (fclose(theFile)) {
  127.         ThrowXML(XMLPlatformUtilsException, XMLExcepts::File_CouldNotCloseFile);
  128.     }
  129. }
  130. unsigned int XMLPlatformUtils::fileSize(FileHandle theFile)
  131. {
  132.     struct stat sbuf;
  133.     if( fstat( fileno(theFile), &sbuf ) ) {
  134.         ThrowXML(XMLPlatformUtilsException, XMLExcepts::File_CouldNotGetSize);
  135.     }
  136.     return sbuf.st_size;
  137. }
  138. FileHandle XMLPlatformUtils::openFile(const char* const fileName)
  139. {
  140.     return fopen( fileName, "rb" );
  141. }
  142. FileHandle XMLPlatformUtils::openFile(const XMLCh* const fileName)
  143. {
  144.     const char* tmpFileName = XMLString::transcode(fileName, fgMemoryManager);
  145.     ArrayJanitor<char> janText((char*)tmpFileName, fgMemoryManager);
  146.     return openFile( tmpFileName );
  147. }
  148. FileHandle XMLPlatformUtils::openFileToWrite(const char* const fileName)
  149. {
  150.     return fopen( fileName, "wb" );
  151. }
  152. FileHandle XMLPlatformUtils::openFileToWrite(const XMLCh* const fileName)
  153. {
  154.     const char* tmpFileName = XMLString::transcode(fileName, fgMemoryManager);
  155.     ArrayJanitor<char> janText((char*)tmpFileName, fgMemoryManager);
  156.     return openFileToWrite(tmpFileName);
  157. }
  158. FileHandle XMLPlatformUtils::openStdInHandle()
  159. {
  160.     return fdopen( dup(STDIN_FILENO), "rb" );
  161. }
  162. unsigned int
  163. XMLPlatformUtils::readFileBuffer(       FileHandle      theFile
  164.                                 , const unsigned int    toRead
  165.                                 ,       XMLByte* const  toFill)
  166. {
  167.     unsigned long bytesRead = 0;
  168.     bytesRead = fread( toFill, 1, toRead, theFile );
  169.     if (ferror(theFile)) {
  170.         ThrowXML(XMLPlatformUtilsException, XMLExcepts::File_CouldNotReadFromFile);
  171.     }
  172.     return (unsigned int)bytesRead;
  173. }
  174. void
  175. XMLPlatformUtils::writeBufferToFile( FileHandle     const  theFile
  176.                                    , long                  toWrite
  177.                                    , const XMLByte* const  toFlush)
  178. {
  179.     unsigned long bytesWritten = 0;
  180.     bytesWritten = fwrite( toFlush, 1, toWrite, theFile );
  181.     if( bytesWritten != toWrite ) {
  182.         ThrowXML(XMLPlatformUtilsException, XMLExcepts::File_CouldNotWriteToFile);
  183.     }
  184.     return;
  185. }
  186. void XMLPlatformUtils::resetFile(FileHandle theFile)
  187. {
  188.     if (fseek(theFile, 0, SEEK_SET)) {
  189.         ThrowXML(XMLPlatformUtilsException, XMLExcepts::File_CouldNotResetFile);
  190.     }
  191. }
  192. // ---------------------------------------------------------------------------
  193. //  XMLPlatformUtils: File system methods
  194. // ---------------------------------------------------------------------------
  195. XMLCh* XMLPlatformUtils::getFullPath(const XMLCh* const srcPath,
  196.                                      MemoryManager* const manager)
  197. {
  198.     //
  199.     //  NOTE: THe path provided has always already been opened successfully,
  200.     //  so we know that its not some pathological freaky path. It comes in
  201.     //  in native format, and goes out as Unicode always
  202.     //
  203.     char* newSrc = XMLString::transcode(srcPath, fgMemoryManager);
  204.     ArrayJanitor<char> janText(newSrc, fgMemoryManager);
  205.     char absPath[PATH_MAX + 1];
  206.     char* retPath = realpath(newSrc, &absPath[0]);
  207.     if (!retPath) {
  208.         ThrowXML(XMLPlatformUtilsException, XMLExcepts::File_CouldNotGetBasePathName);
  209.     }
  210.     return XMLString::transcode(absPath, manager);
  211. }
  212. bool XMLPlatformUtils::isRelative(const XMLCh* const toCheck)
  213. {
  214.     if (!toCheck[0] || toCheck[0] == XMLCh('/'))
  215.         return false;
  216.     return true;
  217. }
  218. XMLCh* XMLPlatformUtils::getCurrentDirectory(MemoryManager* const manager)
  219. {
  220.     char  dirBuf[PATH_MAX + 1];
  221.     char  *curDir = getcwd(&dirBuf[0], PATH_MAX + 1);
  222.     if (!curDir)
  223.     {
  224.         ThrowXML(XMLPlatformUtilsException,
  225.                  XMLExcepts::File_CouldNotGetBasePathName);
  226.     }
  227.     return XMLString::transcode(curDir, manager);
  228. }
  229. inline bool XMLPlatformUtils::isAnySlash(XMLCh c) 
  230. {
  231.     return ( chBackSlash == c || chForwardSlash == c);
  232. }
  233. // ---------------------------------------------------------------------------
  234. //  XMLPlatformUtils: Timing Methods
  235. // ---------------------------------------------------------------------------
  236. unsigned long XMLPlatformUtils::getCurrentMillis()
  237. {
  238.     timeb aTime;
  239.     ftime(&aTime);
  240.     return (unsigned long)(aTime.time*1000 + aTime.millitm);
  241. }
  242. // ---------------------------------------------------------------------------
  243. //  Mutex methods
  244. // ---------------------------------------------------------------------------
  245. void* XMLPlatformUtils::makeMutex()
  246. {
  247.     pthread_mutexattr_t attr;
  248.     pthread_mutexattr_init( &attr );
  249.     pthread_mutexattr_setrecursive( &attr, PTHREAD_RECURSIVE_ENABLE );
  250.     pthread_mutex_t *mutex = new pthread_mutex_t;
  251.     if( pthread_mutex_init( mutex, &attr ) != EOK ) {
  252.         delete mutex;
  253.         ThrowXML(XMLPlatformUtilsException, XMLExcepts::Mutex_CouldNotCreate);
  254.     }
  255.     pthread_mutexattr_destroy( &attr );
  256.     return mutex;
  257. }
  258. void XMLPlatformUtils::closeMutex(void* const mtxHandle)
  259. {
  260.     if( mtxHandle == NULL || pthread_mutex_destroy( (pthread_mutex_t *)mtxHandle ) != EOK ) {
  261.         ThrowXML(XMLPlatformUtilsException, XMLExcepts::Mutex_CouldNotClose);
  262.     }
  263.     delete mtxHandle;
  264. }
  265. void XMLPlatformUtils::lockMutex(void* const mtxHandle)
  266. {
  267.     if( mtxHandle == NULL || pthread_mutex_lock( (pthread_mutex_t *)mtxHandle ) != EOK ) {
  268.         ThrowXML(XMLPlatformUtilsException, XMLExcepts::Mutex_CouldNotLock);
  269.     }
  270. }
  271. void XMLPlatformUtils::unlockMutex(void* const mtxHandle)
  272. {
  273.     if( mtxHandle == NULL || pthread_mutex_unlock( (pthread_mutex_t *)mtxHandle ) != EOK ) {
  274.         ThrowXML(XMLPlatformUtilsException, XMLExcepts::Mutex_CouldNotLock);
  275.     }
  276. }
  277. // ---------------------------------------------------------------------------
  278. //  Miscellaneous synchronization methods
  279. // ---------------------------------------------------------------------------
  280. void*
  281. XMLPlatformUtils::compareAndSwap(       void**      toFill
  282.                                 , const void* const newValue
  283.                                 , const void* const toCompare)
  284. {
  285.     //
  286.     // Undocumented function pulled in by pthread.h.  Uses CPU specific
  287.     // inline assembly routines for doing an atomic compare and exchange
  288.     // operation.
  289.     //
  290.     return (void *)_smp_cmpxchg( (volatile unsigned *)toFill, (unsigned)toCompare, (unsigned)newValue );
  291. }
  292. // ---------------------------------------------------------------------------
  293. //  Atomic increment and decrement methods
  294. // ---------------------------------------------------------------------------
  295. int XMLPlatformUtils::atomicIncrement(int &location)
  296. {
  297.     atomic_add( &(volatile unsigned &)location, 1 );
  298.     return location;
  299. }
  300. int XMLPlatformUtils::atomicDecrement(int &location)
  301. {
  302.     atomic_sub( &(volatile unsigned &)location, 1 );
  303.     return location;
  304. }
  305. // ---------------------------------------------------------------------------
  306. //  XMLPlatformUtils: Private Static Methods
  307. // ---------------------------------------------------------------------------
  308. //
  309. //  This method is called by the platform independent part of this class
  310. //  during initialization. We have to create the type of net accessor that
  311. //  we want to use. If none, then just return zero.
  312. //
  313. XMLNetAccessor* XMLPlatformUtils::makeNetAccessor()
  314. {
  315. #if defined (XML_USE_NETACCESSOR_LIBWWW)
  316.     return new LibWWWNetAccessor();
  317. #else 
  318.     return new SocketNetAccessor();
  319. #endif
  320. }
  321. //
  322. //  This method is called by the platform independent part of this class
  323. //  when client code asks to have one of the supported message sets loaded.
  324. //  In our case, we use the ICU based message loader mechanism.
  325. //
  326. XMLMsgLoader* XMLPlatformUtils::loadAMsgSet(const XMLCh* const msgDomain)
  327. {
  328. #if defined (XML_USE_ICU_MESSAGELOADER)
  329.     return new ICUMsgLoader(msgDomain);
  330. #else
  331.     return new InMemMsgLoader(msgDomain);
  332. #endif
  333. }
  334. //
  335. //  This method is called very early in the bootstrapping process. This guy
  336. //  must create a transcoding service and return it. It cannot use any string
  337. //  methods, any transcoding services, throw any exceptions, etc... It just
  338. //  makes a transcoding service and returns it, or returns zero on failure.
  339. //
  340. XMLTransService* XMLPlatformUtils::makeTransService()
  341. {
  342. #if defined (XML_USE_ICU_TRANSCODER)
  343.     return new ICUTransService;
  344. #elif defined (XML_USE_GNU_TRANSCODER)
  345.     return new IconvGNUTransService;
  346. #else
  347.     #error You must provide a transcoding service implementation
  348. #endif
  349. }
  350. void XMLPlatformUtils::platformInit()
  351. {
  352. }
  353. void XMLPlatformUtils::platformTerm()
  354. {
  355. }
  356. #include <xercesc/util/LogicalPath.c>
  357. XERCES_CPP_NAMESPACE_END