tru64platformutils.cpp

来自「IBM的解析xml的工具Xerces的源代码」· C++ 代码 · 共 616 行 · 第 1/2 页

// ---------------------------------------------------------------------------
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()
{
  timespec ts;
  clock_gettime (CLOCK_REALTIME, &ts);
  return (unsigned long) ((ts.tv_sec * 1000) + (ts.tv_nsec / 1000000));
}



#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 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 );
  }
}


// -----------------------------------------------------------------------
//  Mutex methods
// -----------------------------------------------------------------------


class  RecursiveMutex
{
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 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)
{
  //return (int)atomic_add_32_nv( (uint32_t*)&location, 1);

  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)
{
  //return (int)atomic_add_32_nv( (uint32_t*)&location, -1);

  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()
{
   // 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



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
}

#include <xercesc/util/LogicalPath.c>

XERCES_CPP_NAMESPACE_END