// ---------------------------------------------------------------------------
// XMLPlatformUtils: Init/term methods
// ---------------------------------------------------------------------------
void XMLPlatformUtils::Initialize(const char* const locale
, const char* const nlsHome
, PanicHandler* const panicHandler
, MemoryManager* const memoryManager
, bool toInitStatics)
{
//
// Effects of overflow:
// . resouce re-allocations
// . consequently resource leaks
// . potentially terminate() may never get executed
//
// We got to prevent overflow from happening.
// no error or exception
//
if (gInitFlag == LONG_MAX)
return;
//
// Make sure we haven't already been initialized. Note that this is not
// thread safe and is not intended for that. Its more for those COM
// like processes that cannot keep up with whether they have initialized
// us yet or not.
//
gInitFlag++;
if (gInitFlag > 1)
return;
// Set pluggable memory manager
if (!fgMemoryManager)
{
if (memoryManager)
{
fgMemoryManager = memoryManager;
fgMemMgrAdopted = false;
}
else
{
fgMemoryManager = new MemoryManagerImpl();
}
}
/***
* Panic Handler:
*
***/
if (!panicHandler)
{
fgDefaultPanicHandler = new DefaultPanicHandler();
}
else
{
fgUserPanicHandler = panicHandler;
}
//
// Call the platform init method, which is implemented in each of the
// per-platform implementation cpp files. This one does the very low
// level per-platform setup. It cannot use any XML util services at all,
// i.e. only native services.
//
platformInit();
// Create the local sync mutex
gSyncMutex = new XMLMutex(fgMemoryManager);
// Create the mutex for the static data cleanup list
gXMLCleanupListMutex = new XMLMutex(fgMemoryManager);
fgAtomicMutex = new XMLMutex(fgMemoryManager);
//
// Ask the per-platform code to make the desired transcoding service for
// us to use. This call cannot throw any exceptions or do anything that
// cause any transcoding to happen. It should create the service and
// return it or zero if it cannot.
//
// This one also cannot use any utility services. It can only create a
// transcoding service object and return it.
//
// If we cannot make one, then we call panic to end the process.
//
fgTransService = makeTransService();
if (!fgTransService)
panic(PanicHandler::Panic_NoTransService);
// Initialize the transcoder service
fgTransService->initTransService();
//
// Try to create a default local code page transcoder. This is the one
// that will be used internally by the XMLString class. If we cannot
// create one, then call the panic method.
//
XMLLCPTranscoder* defXCode = XMLPlatformUtils::fgTransService->makeNewLCPTranscoder();
if (!defXCode)
panic(PanicHandler::Panic_NoDefTranscoder);
XMLString::initString(defXCode, fgMemoryManager);
//
// Now lets ask the per-platform code to give us an instance of the type
// of network access implementation he wants to use. This can return
// a zero pointer if this platform doesn't want to support this.
//
fgNetAccessor = makeNetAccessor();
/***
* Message Loader:
*
* Locale setting
* nlsHome setting
***/
XMLMsgLoader::setLocale(locale);
XMLMsgLoader::setNLSHome(nlsHome);
if (toInitStatics) {
XMLInitializer::InitializeAllStaticData();
}
}
// ---------------------------------------------------------------------------
// XMLPlatformUtils: Init/term methods
// ---------------------------------------------------------------------------
void XMLPlatformUtils::Initialize(const char* const locale
, const char* const nlsHome
, PanicHandler* const panicHandler
, MemoryManager* const memoryManager)
{
//
// Effects of overflow:
// . resouce re-allocations
// . consequently resource leaks
// . potentially terminate() may never get executed
//
// We got to prevent overflow from happening.
// no error or exception
//
if (gInitFlag == LONG_MAX)
return;
//
// Make sure we haven't already been initialized. Note that this is not
// thread safe and is not intended for that. Its more for those COM
// like processes that cannot keep up with whether they have initialized
// us yet or not.
//
gInitFlag++;
if (gInitFlag > 1)
return;
// Set pluggable memory manager
if (!fgMemoryManager)
{
if (memoryManager)
{
fgMemoryManager = memoryManager;
fgMemMgrAdopted = false;
}
else
{
fgMemoryManager = new MemoryManagerImpl();
}
}
/***
* Panic Handler:
*
***/
if (!panicHandler)
{
fgDefaultPanicHandler = new DefaultPanicHandler();
}
else
{
fgUserPanicHandler = panicHandler;
}
// Determine our endianness (with regard to a XMLCh 16-bit word)
union {
XMLCh ch;
unsigned char ar[sizeof(XMLCh)];
} endianTest;
endianTest.ch = 1;
fgXMLChBigEndian = (endianTest.ar[sizeof(XMLCh)-1] == 1);
// Determine if we can use SSE2 functions
#if defined(MATCH_HAVE_CPUID_INTRINSIC)
int CPUInfo[4]={0};
__cpuid(CPUInfo, 1);
if(CPUInfo[3] & (1UL << 26))
fgSSE2ok = true;
else
fgSSE2ok = false;
#elif defined(MATCH_HAVE_GETCPUID)
unsigned int eax, ebx, ecx, edx;
if(!__get_cpuid (1, &eax, &ebx, &ecx, &edx) || (edx & (1UL << 26))==0)
fgSSE2ok = false;
else
fgSSE2ok = true;
#elif defined(MATCH_HAVE_SSE2_INTRINSIC)
// if we cannot find out at runtime, assume the define has it right
fgSSE2ok = true;
#else
fgSSE2ok = false;
#endif
// Initialize the platform-specific mutex and file mgrs
fgMutexMgr = makeMutexMgr(fgMemoryManager);
fgFileMgr = makeFileMgr(fgMemoryManager);
// Create the local sync mutex
gSyncMutex = new XMLMutex(fgMemoryManager);
// Create the global "atomic operations" mutex.
fgAtomicMutex = new XMLMutex(fgMemoryManager);
//
// Ask the per-platform code to make the desired transcoding service for
// us to use. This call cannot throw any exceptions or do anything that
// cause any transcoding to happen. It should create the service and
// return it or zero if it cannot.
//
// This one also cannot use any utility services. It can only create a
// transcoding service object and return it.
//
// If we cannot make one, then we call panic to end the process.
//
XMLInitializer::initializeTransService(); // TransService static data.
fgTransService = makeTransService();
if (!fgTransService)
panic(PanicHandler::Panic_NoTransService);
// Initialize the transcoder service
fgTransService->initTransService();
//
// Try to create a default local code page transcoder. This is the one
// that will be used internally by the XMLString class. If we cannot
// create one, then call the panic method.
//
XMLLCPTranscoder* defXCode = XMLPlatformUtils::fgTransService->makeNewLCPTranscoder(fgMemoryManager);
if (!defXCode)
panic(PanicHandler::Panic_NoDefTranscoder);
XMLString::initString(defXCode, fgMemoryManager);
//
// Now lets ask the per-platform code to give us an instance of the type
// of network access implementation he wants to use. This can return
// a zero pointer if this platform doesn't want to support this.
//
fgNetAccessor = makeNetAccessor();
/***
* Message Loader:
*
* Locale setting
* nlsHome setting
***/
XMLMsgLoader::setLocale(locale);
XMLMsgLoader::setNLSHome(nlsHome);
// Initialize static data.
//
XMLInitializer::initializeStaticData();
}
