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)static XMLMutex *atomicOpsMutex = 0;#ifdef XML_USE_SPROC// ---------------------------------------------------------------------------//  XMLPlatformUtils: Platform init method// ---------------------------------------------------------------------------static char* arenaName = NULL;static usptr_t* arena = NULL;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.    // need a shared memory space    usconfig(CONF_INITUSERS, 128);    usconfig(CONF_INITSIZE, 16000);    usconfig(CONF_AUTOGROW, 1);   // Default, but we set anyway    arenaName = strdup ("/var/tmp/xerces-sharedmemXXXXXX");    arena = usinit (mktemp (arenaName));    if(!atomicOpsMutex)    {        atomicOpsMutex = new (fgMemoryManager) XMLMutex();        if (atomicOpsMutex->fHandle == 0)            atomicOpsMutex->fHandle = XMLPlatformUtils::makeMutex();    }}void XMLPlatformUtils::platformTerm(){    // delete the mutex we created    closeMutex(atomicOpsMutex->fHandle);    atomicOpsMutex->fHandle = 0;    delete atomicOpsMutex;    atomicOpsMutex = 0;    usdetach (arena);    unlink (arenaName);    free (arenaName);    arena = NULL;    // We don't have any termination requirements at this time}void* XMLPlatformUtils::makeMutex(){    if (arena) {        usema_t* sema = usnewsema (arena, 1);        if (sema && (usctlsema (sema, CS_RECURSIVEON) != -1)) {            return (void*)sema;        }        else            ThrowXMLwithMemMgr(XMLPlatformUtilsException,                      XMLExcepts::Mutex_CouldNotCreate, fgMemoryManager);    }    else {        // arena==0; therefore platformInit hasn't been called.        // it's important that we fail quietly here so that we don't        // throw an exception when trying to initizlize the        // atomicOpsMutex, which we re-initizlize in platformInit anyay.        return 0;    }}void XMLPlatformUtils::closeMutex(void* const mtxHandle){    if ((mtxHandle != NULL) && (arena != NULL)) {        usfreesema ((usema_t *)mtxHandle, arena);        // never returns anything testable for failure, so nothing        // to throw an exception about.    }}void XMLPlatformUtils::lockMutex(void* const mtxHandle){    if (mtxHandle != NULL) {        if (uspsema (mtxHandle) != 1)            ThrowXMLwithMemMgr(XMLPlatformUtilsException,                     XMLExcepts::Mutex_CouldNotLock, fgMemoryManager);    }}void XMLPlatformUtils::unlockMutex(void* const mtxHandle){    if (mtxHandle != NULL)    {        if (usvsema(mtxHandle) == -1)        {            ThrowXMLwithMemMgr(XMLPlatformUtilsException,                     XMLExcepts::Mutex_CouldNotUnlock, fgMemoryManager);        }    }}#else// ---------------------------------------------------------------------------//  XMLPlatformUtils: Platform init method// ---------------------------------------------------------------------------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::platformTerm(){    // delete the mutex we created	closeMutex(atomicOpsMutex->fHandle);	atomicOpsMutex->fHandle = 0;    delete atomicOpsMutex;    atomicOpsMutex = 0;}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);    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);        }    }}#endif   // XML_USE_SPROC// -----------------------------------------------------------------------//  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;}void XMLPlatformUtils::platformTerm(){    // We don't have any termination requirements at this time}#endif // APP_NO_THREADS//void XMLPlatformUtils::platformTerm()//{    // We don't have any termination requirements at this time//}#include <xercesc/util/LogicalPath.c>XERCES_CPP_NAMESPACE_END