int __LibCAddThread( thread_data *tdata )
/***************************************/
{
if( __NXSlotID == NO_INDEX )
{
return( FALSE );
}
tdata = __AllocInitThreadData( tdata );
if( tdata == NULL )
{
return( FALSE );
}
if( !__AddThreadData( tdata->thread_id, tdata ) )
{
lib_free( tdata );
return( FALSE );
}
if(0 != NXKeySetValue(__NXSlotID, tdata ))
{
lib_free( tdata );
return( FALSE );
}
return( TRUE );
}
thread_data *__QNXAddThread( thread_data *tdata )
/***********************************************/
{
void *tmp;
tdata = __AllocInitThreadData( tdata );
// if tdata is NULL it doesn't matter what we do with it
tmp = (void *)tdata;
__setmagicvar( &tmp, _m_thread_data );
return( tdata );
}
int __RdosAddThread( thread_data *tdata )
/***************************************/
{
if( __TlsIndex == NO_INDEX ) {
return( 0 );
}
tdata = __AllocInitThreadData( tdata );
if( tdata == NULL ) {
return( 0 );
}
if( !__AddThreadData( tdata->thread_id, tdata ) ) {
__FreeInitThreadData( tdata );
return( 0 );
}
__tls_set_value( __TlsIndex, tdata );
return( 1 );
}
int __NTAddThread( thread_data *tdata )
/*************************************/
{
if( __TlsIndex == NO_INDEX ) {
return( FALSE );
}
tdata = __AllocInitThreadData( tdata );
if( tdata == NULL ) {
return( FALSE );
}
if( !__AddThreadData( tdata->thread_id, tdata ) ) {
__FreeInitThreadData( tdata );
return( FALSE );
}
TlsSetValue( __TlsIndex, tdata );
return( TRUE );
}
int __OS2AddThread( TID tid, thread_data *tdata )
/***********************************************/
{
tdata = __AllocInitThreadData( tdata );
if( tdata == NULL ) return( 0 );
if( tid <= __MaxThreads ) {
if( __initthread( tdata ) ) {
__FreeInitThreadData( tdata );
return( 0 );
} else {
__ThreadData[tid].data = tdata;
__ThreadData[tid].allocated_entry = tdata->__allocated;
}
} else {
if( !__AddThreadData( tid, tdata ) ) {
// unable to setup storage
__FreeInitThreadData( tdata );
return( 0 );
}
}
return( 1 );
}
unsigned _LibMain( unsigned hmod, unsigned termination )
/******************************************************/
{
static int processes;
unsigned rc;
if( termination != 0 ) {
// If we're running with single DGROUP and tried to load
// twice, do not run any termination code! Also reset the
// process counter so that the already loaded DLL can
// terminate properly
if( processes > 1 ) {
--processes;
return( 0 );
}
rc = LibMain( hmod, termination );
--processes;
#ifdef __SW_BR
__FiniRtns( 0, 255 );
#else
if( _LpwCmdLine ) {
lib_free( _LpwCmdLine );
_LpwCmdLine = NULL;
}
if( _LpwPgmName ) {
lib_free( _LpwPgmName );
_LpwPgmName = NULL;
}
__FiniRtns( FINI_PRIORITY_EXIT, 255 );
// calls to free memory have to be done before semaphores closed
__FreeInitThreadData( __FirstThreadData );
__OS2Fini(); // must be done before following finalizers get called
__FiniRtns( 0, FINI_PRIORITY_EXIT - 1 );
__shutdown_stack_checking();
#endif
return( rc );
}
++processes;
if( processes > 1 ) {
if( __disallow_single_dgroup(hmod) ) {
return( 0 );
}
}
__hmodule = hmod;
#ifdef __SW_BR
{
static char fname[_MAX_PATH];
static wchar_t wfname[_MAX_PATH];
__Is_DLL = 1;
__InitRtns( 255 );
DosQueryModuleName( hmod, sizeof( fname ), fname );
_LpDllName = fname;
_LpwDllName = wfname;
_atouni( _LpwDllName, _LpDllName );
}
#else
{
PTIB pptib;
PPIB pppib;
unsigned i;
DosGetInfoBlocks( &pptib, &pppib );
_RWD_Envptr = pppib->pib_pchenv;
_LpCmdLine = pppib->pib_pchcmd;
while( *_LpCmdLine ) { // skip over program name
_LpCmdLine++;
}
_LpCmdLine++;
_LpwCmdLine = lib_malloc( (strlen( _LpCmdLine ) + 1) * sizeof( wchar_t ) );
_atouni( _LpwCmdLine, _LpCmdLine );
{
// ugly stuff to deal with two copies of .exe name in the
// environment space. apparently the OS fullpath name is
// just before this one in the environment space
char *cmd_path;
cmd_path = pppib->pib_pchcmd;
for( cmd_path -= 2; *cmd_path != '\0'; --cmd_path );
++cmd_path;
_LpPgmName = cmd_path;
_LpwPgmName = lib_malloc( (strlen( _LpPgmName ) + 1) * sizeof( wchar_t ) );
_atouni( _LpwPgmName, _LpPgmName );
}
__InitRtns( INIT_PRIORITY_THREAD );
if( __InitThreadProcessing() == NULL )
return( 0 );
__OS2Init( TRUE, __AllocInitThreadData( NULL ) );
for( i = 2; i <= __MaxThreads; i++ ) {
if( !__OS2AddThread( i, NULL ) ) {
return( 0 );
}
}
__InitRtns( INIT_PRIORITY_EXIT - 1 );
__InitMultipleThread();
{
static char fname[_MAX_PATH];
static wchar_t wfname[_MAX_PATH];
DosQueryModuleName( hmod, sizeof( fname ), fname );
_LpDllName = fname;
_LpwDllName = wfname;
_atouni( _LpwDllName, _LpDllName );
}
__InitRtns( 255 );
}
#endif
__CommonInit();
#ifndef __SW_BR
/* allocate alternate stack for F77 */
__ASTACKPTR = (char *)_STACKLOW + __ASTACKSIZ;
#endif
return( LibMain( hmod, termination ) );
}
// lookup thread data
thread_data *__GetThreadData( void )
{
thread_data *tdata = NULL;
#ifdef __OS2__
TID tid;
tid = GetCurrentThreadId();
if( tid <= __MaxThreads ) {
tdata = __AllocInitThreadData( tdata );
if( tdata != NULL ) {
if( __initthread( tdata ) ) {
__FreeInitThreadData( tdata );
tdata = NULL;
} else {
__ThreadData[tid].data = tdata;
__ThreadData[tid].allocated_entry = tdata->__allocated;
}
}
} else {
thread_data_list *tdl;
thread_data_list **pprev;
_AccessTDList();
tdata = NULL;
pprev = &__thread_data_list;
for( tdl = *pprev; tdl != NULL ; tdl = tdl->next ) {
if( tdl->tid == tid ) {
tdata = tdl->data;
break;
}
pprev = &(tdl->next);
}
if( tdata == NULL ) {
tdata = __AllocInitThreadData( tdata );
if( tdata != NULL ) {
if( !__AddThreadData( tid, tdata ) ) {
__FreeInitThreadData( tdata );
tdata = NULL;
}
}
} else if( *pprev ) {
// promote to front
*pprev = tdl->next;
tdl->next = __thread_data_list;
__thread_data_list = tdl;
// check for need to resize thread data
if( tdata->__resize ) {
tdata = __ReallocThreadData();
}
}
_ReleaseTDList();
}
#elif defined(__NT__)
if( __NTAddThread( tdata ) )
{
tdata = (thread_data *)TlsGetValue( __TlsIndex );
}
#elif defined(_NETWARE_LIBC)
if( __LibCAddThread( tdata ) )
{
if(0 != NXKeyGetValue(__NXSlotID, (void **) &tdata))
tdata = NULL;
}
#elif defined(__RDOS__)
if( __RdosAddThread( tdata ) )
{
tdata = (thread_data *)__tls_get_value( __TlsIndex );
}
#endif
if( tdata == NULL ) {
__fatal_runtime_error( "Thread has no thread-specific data", 1 );
}
return( tdata );
}
int APIENTRY _LibMain( HANDLE hdll, DWORD reason, LPVOID reserved )
{
int rc;
static int processes;
switch( reason ) {
case DLL_THREAD_ATTACH:
#ifndef __SW_BR
if( !__NTAddThread( NULL ) ) {
return( FALSE );
}
#endif
rc = LibMain( hdll, reason, reserved );
break;
case DLL_PROCESS_ATTACH:
++processes;
if( processes > 1 ) {
if( __disallow_single_dgroup( hdll ) ) {
rc = FALSE;
break;
}
}
#ifdef __SW_BR
__Is_DLL = 1;
__InitRtns( INIT_PRIORITY_EXIT - 1 );
#else
// The following initializers are called: (in the CLIB run-time DLL):
// nothing is called
__InitRtns( INIT_PRIORITY_THREAD );
// allocate some thread data storage and initialize run-time variables
{
thread_data *tdata = __AllocInitThreadData( NULL );
if( !tdata || !__NTInit( TRUE, tdata, hdll ) ) {
rc = FALSE;
break;
}
}
// set up TLSIndex thingee
if( !__NTThreadInit() ) { // safe to call multiple times
rc = FALSE;
break;
}
// The following initializers are called: (in the CLIB run-time DLL):
// __chk8087
// __verify_pentium_fdiv_bug
// __Init_Argv
// __imthread_fn (which calls _NTThreadInit and __InitMultipleThread)
__InitRtns( INIT_PRIORITY_EXIT - 1 );
// sets up semaphores and starts linked list of thread data storage
__InitMultipleThread(); // now safe to call multiple times
#endif
if( _pRawDllMain != NULL ) {
if( !_pRawDllMain( hdll, reason, reserved ) ) {
__FiniRtns( 0, FINI_PRIORITY_EXIT - 1 );
rc = FALSE;
break;
}
}
// The following initializers are called: (in the CLIB run-time DLL):
// profilog_init
// __InitWinLinesSem
// dbgdata@do_it
// __setenvp
// __mbInitOnStartup
// __sig_init
// (??) in STK
// __InitFiles
// __clock_init
__InitRtns( 255 );
#ifdef __SW_BR
{
static char fn[_MAX_PATH];
__lib_GetModuleFileNameA( hdll, fn, sizeof( fn ) );
_LpDllName = fn;
}
{
static wchar_t wfn[_MAX_PATH];
__lib_GetModuleFileNameW( hdll, wfn, sizeof( wfn ) );
_LpwDllName = wfn;
}
#endif
__CommonInit();
__sig_init_rtn();
rc = LibMain( hdll, reason, reserved );
if( !rc ) {
__FiniRtns( 0, 255 );
}
break;
case DLL_THREAD_DETACH:
rc = LibMain( hdll, reason, reserved );
#ifndef __SW_BR
__NTRemoveThread( TRUE );
#endif
break;
case DLL_PROCESS_DETACH:
rc = LibMain( hdll, reason, reserved );
__FiniRtns( FINI_PRIORITY_EXIT, 255 );
if( _pRawDllMain != NULL ) {
_pRawDllMain( hdll, reason, reserved );
}
#ifndef __SW_BR
__NTFini(); // must be done before following finalizers get called
#endif
__FiniRtns( 0, FINI_PRIORITY_EXIT - 1 );
#ifndef __SW_BR
__NTRemoveThread( TRUE );
__FreeInitThreadData( __FirstThreadData );
__FirstThreadData = NULL;
#endif
--processes;
}
return( rc );
}