FileHandle XMLPlatformUtils::openFile(const XMLCh* const fileName                                      , MemoryManager* const manager){    const char* tmpFileName = XMLString::transcode(fileName, manager);    ArrayJanitor<char> janText((char*)tmpFileName, manager);    return fopen(tmpFileName , "rb");}FileHandle XMLPlatformUtils::openFileToWrite(const XMLCh* const fileName                                             , MemoryManager* const manager){    const char* tmpFileName = XMLString::transcode(fileName, manager);    ArrayJanitor<char> janText((char*)tmpFileName, manager);    return fopen( tmpFileName , "wb" );}FileHandle XMLPlatformUtils::openFileToWrite(const char* const fileName                                             , MemoryManager* const manager){    return fopen( fileName , "wb" );}FileHandle XMLPlatformUtils::openStdInHandle(MemoryManager* const manager){    return (FileHandle) fdopen(dup(0), "rb");}unsigned intXMLPlatformUtils::readFileBuffer(       FileHandle      theFile                                , const unsigned int    toRead                                ,       XMLByte* const  toFill                                , MemoryManager* const  manager){    size_t noOfItemsRead = fread((void*) toFill, 1, toRead, (FILE*)theFile);    if (ferror((FILE*)theFile))    {        ThrowXMLwithMemMgr(XMLPlatformUtilsException,                 XMLExcepts::File_CouldNotReadFromFile, manager);    }    return (unsigned int) noOfItemsRead;}voidXMLPlatformUtils::writeBufferToFile( FileHandle     const  theFile                                   , long                  toWrite                                   , const XMLByte* const  toFlush                                   , MemoryManager* const  manager){    if (!theFile        ||        (toWrite <= 0 ) ||        !toFlush         )        return;    const XMLByte* tmpFlush = (const XMLByte*) toFlush;    size_t bytesWritten = 0;    while (true)    {        bytesWritten=fwrite(tmpFlush, sizeof(XMLByte), toWrite, (FILE*)theFile);        if(ferror((FILE*)theFile))        {            ThrowXMLwithMemMgr(XMLPlatformUtilsException, XMLExcepts::File_CouldNotWriteToFile, manager);        }        if (bytesWritten < toWrite) //incomplete write        {            tmpFlush+=bytesWritten;            toWrite-=bytesWritten;            bytesWritten=0;        }        else            return;    }    return;}void XMLPlatformUtils::resetFile(FileHandle theFile                                 , MemoryManager* const manager){    // Seek to the start of the file    if (fseek((FILE*) theFile, 0, SEEK_SET))        ThrowXMLwithMemMgr(XMLPlatformUtilsException,                 XMLExcepts::File_CouldNotResetFile, manager);}// ---------------------------------------------------------------------------//  XMLPlatformUtils: File system methods// ---------------------------------------------------------------------------XMLCh* XMLPlatformUtils::getFullPath(const XMLCh* const srcPath,                                     MemoryManager* const manager){    //    //  NOTE: The path provided has always already been opened successfully,    //  so we know that its not some pathological freaky path. It comes in    //  in native format, and goes out as Unicode always    //    char* newSrc = XMLString::transcode(srcPath, manager);    ArrayJanitor<char> janText(newSrc, manager);    // Use a local buffer that is big enough for the largest legal path    char absPath[PATH_MAX + 1];    //get the absolute path    char* retPath = realpath(newSrc, &absPath[0]);    if (!retPath)    {        ThrowXMLwithMemMgr(XMLPlatformUtilsException, XMLExcepts::File_CouldNotGetBasePathName, manager);    }    return XMLString::transcode(absPath, manager);}bool XMLPlatformUtils::isRelative(const XMLCh* const toCheck                                  , MemoryManager* const manager){    // Check for pathological case of empty path    if (!toCheck[0])        return false;    //    //  If it starts with a slash, then it cannot be relative. This covers    //  both something like "\Test\File.xml" and an NT Lan type remote path    //  that starts with a node like "\\MyNode\Test\File.xml".    //    if (toCheck[0] == XMLCh('/'))        return false;    // Else assume its a relative path    return true;}XMLCh* XMLPlatformUtils::getCurrentDirectory(MemoryManager* const manager){    char  dirBuf[PATH_MAX + 2];    char  *curDir = getcwd(&dirBuf[0], PATH_MAX + 1);    if (!curDir)    {        ThrowXMLwithMemMgr(XMLPlatformUtilsException,                 XMLExcepts::File_CouldNotGetBasePathName, manager);    }    return XMLString::transcode(curDir, manager);}inline bool XMLPlatformUtils::isAnySlash(XMLCh c) {    return ( chBackSlash == c || chForwardSlash == c);}// ---------------------------------------------------------------------------//  XMLPlatformUtils: Timing Methods// ---------------------------------------------------------------------------unsigned long XMLPlatformUtils::getCurrentMillis(){#if defined(XML_HPUX_KAICC)         // should be reimplemented by someone with                                    // HP/UX and KAI knowledge.    return (unsigned long) 0;#else    timeb aTime;    ftime(&aTime);    return (unsigned long)(aTime.time*1000 + aTime.millitm);#endif}// -----------------------------------------------------------------------//  Mutex methods// -----------------------------------------------------------------------#if !defined(APP_NO_THREADS)// ---------------------------------------------------------------------------//  XMLPlatformUtils: Platform init method// ---------------------------------------------------------------------------static XMLMutex *atomicOpsMutex = 0;void XMLPlatformUtils::platformInit(){    //    // The atomicOps mutex needs to be created early.    // Normally, mutexes are created on first use, but there is a    // circular dependency between compareAndExchange() and    // mutex creation that must be broken.    if(!atomicOpsMutex)    {        atomicOpsMutex = new (fgMemoryManager) XMLMutex();        if (atomicOpsMutex->fHandle == 0)            atomicOpsMutex->fHandle = XMLPlatformUtils::makeMutex();    }}void* XMLPlatformUtils::makeMutex(){    pthread_mutex_t* mutex = new pthread_mutex_t;    pthread_mutexattr_t*  attr = new pthread_mutexattr_t;#if defined(XML_USE_DCE)    pthread_mutexattr_create(attr);    pthread_mutexattr_setkind_np(attr, MUTEX_RECURSIVE_NP);    if (pthread_mutex_init(mutex, *attr))    {        ThrowXMLwithMemMgr(XMLPlatformUtilsException,                 XMLExcepts::Mutex_CouldNotCreate, fgMemoryManager);    }    pthread_mutexattr_delete(attr);#else    pthread_mutexattr_init(attr);    pthread_mutexattr_settype(attr, PTHREAD_MUTEX_RECURSIVE);    if (pthread_mutex_init(mutex, attr))    {        ThrowXMLwithMemMgr(XMLPlatformUtilsException,                 XMLExcepts::Mutex_CouldNotCreate, fgMemoryManager);    }    pthread_mutexattr_destroy(attr);#endif    delete attr;    return (void*) mutex;}void XMLPlatformUtils::closeMutex(void* const mtxHandle){    pthread_mutex_t* mutex = (pthread_mutex_t *) mtxHandle;    if (mutex != NULL)    {        if (pthread_mutex_destroy(mutex))            ThrowXMLwithMemMgr(XMLPlatformUtilsException,                  XMLExcepts::Mutex_CouldNotDestroy, fgMemoryManager);        delete mutex;    }}void XMLPlatformUtils::lockMutex(void* const mtxHandle){    if (mtxHandle != NULL)    {        if (pthread_mutex_lock((pthread_mutex_t *) mtxHandle))        {            ThrowXMLwithMemMgr(XMLPlatformUtilsException,                     XMLExcepts::Mutex_CouldNotLock, fgMemoryManager);        }    }}void XMLPlatformUtils::unlockMutex(void* const mtxHandle){    if (mtxHandle != NULL)    {        if (pthread_mutex_unlock((pthread_mutex_t *) mtxHandle))        {            ThrowXMLwithMemMgr(XMLPlatformUtilsException,                     XMLExcepts::Mutex_CouldNotUnlock, fgMemoryManager);        }    }}// -----------------------------------------------------------------------//  Miscellaneous synchronization methods// -----------------------------------------------------------------------void* XMLPlatformUtils::compareAndSwap ( void**      toFill,                                   const void* const newValue,                                   const void* const toCompare){    XMLMutexLock  localLock(atomicOpsMutex);    void *retVal = *toFill;    if (*toFill == toCompare)    {       *toFill = (void *)newValue;    }    return retVal;}int XMLPlatformUtils::atomicIncrement(int &location){    XMLMutexLock localLock(atomicOpsMutex);    return ++location;}int XMLPlatformUtils::atomicDecrement(int &location){    XMLMutexLock localLock(atomicOpsMutex);    return --location;}#else // #if !defined (APP_NO_THREADS)void XMLPlatformUtils::platformInit(){}void XMLPlatformUtils::closeMutex(void* const mtxHandle){}void XMLPlatformUtils::lockMutex(void* const mtxHandle){}void* XMLPlatformUtils::makeMutex(){    return 0;}void XMLPlatformUtils::unlockMutex(void* const mtxHandle){}void* XMLPlatformUtils::compareAndSwap (void**             toFill,                                        const void* const  newValue,                                        const void* const  toCompare){    void *retVal = *toFill;    if (*toFill == toCompare)       *toFill = (void *)newValue;    return retVal;}int XMLPlatformUtils::atomicIncrement(int &location){    return ++location;}int XMLPlatformUtils::atomicDecrement(int &location){    return --location;}#endif // APP_NO_THREADSvoid XMLPlatformUtils::platformTerm(){#if !defined(APP_NO_THREADS)    // delete the mutex we created	closeMutex(atomicOpsMutex->fHandle);	atomicOpsMutex->fHandle = 0;    delete atomicOpsMutex;    atomicOpsMutex = 0;#endif}#include <xercesc/util/LogicalPath.c>XERCES_CPP_NAMESPACE_END