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(){    timeb aTime;    ftime(&aTime);    return (unsigned long)(aTime.time*1000 + aTime.millitm);}// -----------------------------------------------------------------------//  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;    pthread_mutexattr_init(attr);    pthread_mutexattr_settype(attr, PTHREAD_MUTEX_RECURSIVE_NP);    if (pthread_mutex_init(mutex, attr))    {        ThrowXMLwithMemMgr(XMLPlatformUtilsException,                 XMLExcepts::Mutex_CouldNotCreate, fgMemoryManager);    }    pthread_mutexattr_destroy(attr);    delete attr;    return (void*)(mutex);}void XMLPlatformUtils::closeMutex(void* const mtxHandle){    if (mtxHandle != NULL)    {        if (pthread_mutex_destroy((pthread_mutex_t*) mtxHandle))        {            ThrowXMLwithMemMgr(XMLPlatformUtilsException,                     XMLExcepts::Mutex_CouldNotDestroy, fgMemoryManager);        }        delete (pthread_mutex_t*) mtxHandle;    }}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 lockMutex(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::makeMutex(){        return 0;}void XMLPlatformUtils::closeMutex(void* const mtxHandle){}void XMLPlatformUtils::lockMutex(void* const mtxHandle){}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