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 pthread_mutex_t* gAtomicOpMutex =0 ;void XMLPlatformUtils::platformInit(){    //    // The gAtomicOpMutex mutex needs to be created    // because compareAndSwap, atomicIncrement and atomicDecrement    // does not have the atomic system calls for usage    // Normally, mutexes are created on first use, but there is a    // circular dependency between compareAndExchange() and    // mutex creation that must be broken.    gAtomicOpMutex = new pthread_mutex_t;    if (pthread_mutex_init(gAtomicOpMutex, NULL))        panic( PanicHandler::Panic_SystemInit );}class  RecursiveMutex : public XMemory{public:    pthread_mutex_t   mutex;    int               recursionCount;    pthread_t         tid;    RecursiveMutex() {		if (pthread_mutex_init(&mutex, NULL))			ThrowXMLwithMemMgr(XMLPlatformUtilsException, XMLExcepts::Mutex_CouldNotCreate, XMLPlatformUtils::fgMemoryManager);		recursionCount = 0;		tid = 0;	}    ~RecursiveMutex() {		if (pthread_mutex_destroy(&mutex))			ThrowXMLwithMemMgr(XMLPlatformUtilsException, XMLExcepts::Mutex_CouldNotDestroy, XMLPlatformUtils::fgMemoryManager);	}	void lock()      {		if (pthread_equal(tid, pthread_self()))		{			recursionCount++;			return;		}		if (pthread_mutex_lock(&mutex) != 0)			ThrowXMLwithMemMgr(XMLPlatformUtilsException, XMLExcepts::Mutex_CouldNotLock, XMLPlatformUtils::fgMemoryManager);		tid = pthread_self();		recursionCount = 1;	}	void unlock()    {		if (--recursionCount > 0)			return;		if (pthread_mutex_unlock(&mutex) != 0)			ThrowXMLwithMemMgr(XMLPlatformUtilsException, XMLExcepts::Mutex_CouldNotUnlock, XMLPlatformUtils::fgMemoryManager);		tid = 0;	}};void* XMLPlatformUtils::makeMutex(){    return new RecursiveMutex;}void XMLPlatformUtils::closeMutex(void* const mtxHandle){    if (mtxHandle == NULL)        return;    RecursiveMutex *rm = (RecursiveMutex *)mtxHandle;    delete rm;}void XMLPlatformUtils::lockMutex(void* const mtxHandle){    if (mtxHandle == NULL)        return;    RecursiveMutex *rm = (RecursiveMutex *)mtxHandle;    rm->lock();}void XMLPlatformUtils::unlockMutex(void* const mtxHandle){    if (mtxHandle == NULL)        return;    RecursiveMutex *rm = (RecursiveMutex *)mtxHandle;    rm->unlock();}// -----------------------------------------------------------------------//  Miscellaneous synchronization methods// -----------------------------------------------------------------------//atomic system calls in UnixWare is only restricted to kernel libraries//So, to make operations thread safe we implement static mutex and lock//the atomic operations. It makes the process slow but what's the alternative!void* XMLPlatformUtils::compareAndSwap ( void**      toFill ,                    const void* const newValue ,                    const void* const toCompare){    if (pthread_mutex_lock( gAtomicOpMutex))        panic(PanicHandler::Panic_SynchronizationErr);    void *retVal = *toFill;    if (*toFill == toCompare)              *toFill = (void *)newValue;    if (pthread_mutex_unlock( gAtomicOpMutex))        panic(PanicHandler::Panic_SynchronizationErr);    return retVal;}int XMLPlatformUtils::atomicIncrement(int &location){    if (pthread_mutex_lock( gAtomicOpMutex))        panic(PanicHandler::Panic_SynchronizationErr);    int tmp = ++location;    if (pthread_mutex_unlock( gAtomicOpMutex))        panic(PanicHandler::Panic_SynchronizationErr);    return tmp;}int XMLPlatformUtils::atomicDecrement(int &location){    if (pthread_mutex_lock( gAtomicOpMutex))        panic(PanicHandler::Panic_SynchronizationErr);    int tmp = --location;    if (pthread_mutex_unlock( gAtomicOpMutex))        panic(PanicHandler::Panic_SynchronizationErr);    return tmp;}#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	pthread_mutex_destroy(gAtomicOpMutex);    delete gAtomicOpMutex;	gAtomicOpMutex = 0;#endif}#include <xercesc/util/LogicalPath.c>XERCES_CPP_NAMESPACE_END