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 == chForwardSlash)        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);}void send_message (char * text, char * messageid, char type){           short textsize;           char* buffer;           char* anchor;           char* id;           char message_id[8] = "CPF9897";/* id for raw txt                                             message                */           char message_file_name[21];           char message_type[11] ="*DIAG     ";/* send diagnostic                                                           message   */           char call_stack[11] ="*         " ;/* current callstack*/           int call_stack_counter= 0;/* sent to current call stack */           char message_key[4]; /* return value - not used          */            struct {             int bytes_available;             int bytes_used;             char exception_id[7];             char reserved;             char exception_data[1];                    } error_code;           int msg_size;          char* msg_type;         error_code.bytes_available = sizeof(error_code);/* check input parameters and set up the message information */         if (messageid != 0)  /* was a message id passed   */	 {           if (strncmp(messageid,"CPF",3) &&               strncmp(messageid,"CPE",3))             strcpy(message_file_name,"QXMLMSG   *LIBL     ");           else             strcpy(message_file_name,"QCPFMSG   QSYS      ");           id = messageid; /* yes - use the id, will be                           in QCPFMSG                              */	 }         else  /* just use what we have for immediate text          */	 {           id = &message_id[0];           strcpy(message_file_name,"QCPFMSG   QSYS      ");	 }         if (type == 'e')  /* is this the terminating exception     */              msg_type = "*COMP      ";/* set it as completion      */         else            /* currently all other messages are                             diagnostics                             */              msg_type = "*DIAG      ";         if (text != 0)                  /* was a text field passed           */         {          textsize = strlen(text);          msg_size = textsize + sizeof(short);          buffer = (char*)malloc(msg_size);          anchor = buffer;          memcpy(buffer, (void*)&textsize, sizeof(short));          buffer +=sizeof(short);          memcpy(buffer, text, textsize);         }         else           msg_size = 0;         #pragma exception_handler(jsendprob, 0, _C1_ALL, _C2_ALL,_CTLA_HANDLE)              QMHSNDPM((char *)id,&message_file_name,anchor,                     msg_size,(char*)msg_type,(char*)&call_stack,                     call_stack_counter,&message_key,&error_code);   jsendprob:#pragma disable_handler    return ;}void abnormal_termination(int termcode){   send_message(NULL,"CPF9899",'e'); /* send final exception that we have terminated*/}// ---------------------------------------------------------------------------//  XMLPlatformUtils: Timing Methods// ---------------------------------------------------------------------------unsigned long XMLPlatformUtils::getCurrentMillis(){ _MI_Time mt;         struct timeval tv;         int rc;         mattod(mt);   rc = Qp0zCvtToTimeval(&tv, mt, QP0Z_CVTTIME_TO_TIMESTAMP);   return((tv.tv_sec*1000 )+ (tv.tv_usec/1000));}// -----------------------------------------------------------------------//  Mutex methods// -----------------------------------------------------------------------#if !defined (APP_NO_THREADS)static pthread_mutex_t* gAtomicOpMutex =0 ;void XMLPlatformUtils::platformInit(){    //    // The gAtomicOpMutex mutex needs to be created	// because compareAndSwap and incrementlocation and decrementlocation	// 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)) {		delete gAtomicOpMutex;		gAtomicOpMutex = 0;        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.reservedHiId = 0;		       tid.reservedLoId = 0;                       tid.reservedHandle = 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.reservedHandle= 0;			  tid.reservedHiId = 0;			  tid.reservedLoId = 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 Solaris 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){    //return ((void*)cas32( (uint32_t*)toFill,  (uint32_t)toCompare, (uint32_t)newValue) );    // the below calls are temporarily made till the above functions are part of user library    // Currently its supported only in the kernel mode    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){    int current = location;		    int new_loc = current+1;		    while (_CMPSWP(&current,			                   &location,	                   new_loc) == 0)		        new_loc = current+1;    int tmp = new_loc;    return tmp;}int XMLPlatformUtils::atomicDecrement(int &location){    int current = location;		    int new_loc = current-1;		    while (_CMPSWP(&current,			                   &location,	                   new_loc) == 0)		        new_loc = current-1;    int tmp = new_loc;    return tmp;}#else // #if !defined (APP_NO_THREADS)void XMLPlatformUtils::platformInit(){   // do nothing}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_THREADS/* * convert the errno value to a cpf message identifier by converting the * error to its decimal equivalent and appending "CPE" to the front * note that the caller passes the storage for the message id as a parm */void convert_errno(char* errno_id,int errnum)	      {sprintf(errno_id,"CPE%d04" ,errnum );return;	      }FileHandle XMLPlatformUtils::openStdInHandle(MemoryManager* const manager){    return (FileHandle)fdopen(dup(0), "rb");}void XMLPlatformUtils::platformTerm(){#if !defined (APP_NO_THREADS)	pthread_mutex_destroy(gAtomicOpMutex);    delete gAtomicOpMutex;	gAtomicOpMutex = 0;#endif#if defined (XML_USE_ICONV400_TRANSCODER)	cleanupDefaultConverter();#endif}#include <xercesc/util/LogicalPath.c>XERCES_CPP_NAMESPACE_END