Changeset 281 for trunk/src/kernel32


Ignore:
Timestamp:
Jul 7, 1999, 10:11:58 AM (26 years ago)
Author:
sandervl
Message:

Major changes in PE2LX/KERNEL32 for TLS support. DLL VERSION INCREASED TO 3 AS THIS CHANGE MAKES IT INCOMPATIBLE WITH APPS CONVERTED WITH PREVIOUS VERSION OF PE2LX (OR WIN32K)

Location:
trunk/src/kernel32
Files:
1 added
1 deleted
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/KERNEL32.DEF

    r263 r281  
    1 ; $Id: KERNEL32.DEF,v 1.15 1999-07-04 11:44:03 sandervl Exp $
     1; $Id: KERNEL32.DEF,v 1.16 1999-07-07 08:11:09 sandervl Exp $
    22
    33;Created by BLAST for IBM's compiler
    … …  
    932932
    933933;Used by tibfix page in exe (change ordinal in lx.cpp too!!)
    934     RegisterResourceUsage         = _RegisterResourceUsage@20      @1203
     934    RegisterExe                   = _RegisterExe@48                @1203
    935935;VMutex
    936936   enter__6VMutexFUl                                               @1204
    … …  
    939939   __dt__6VMutexFv                                                 @1207
    940940;Used by tibfix page in dll (change ordinal in lx.cpp too!!)
    941     DLLExitList                   = _DLLExitList@4                 @1208
    942     RegisterDll                   = _RegisterDll@20                @1209
     941;;;    DLLExitList                   = _DLLExitList@4                 @1208
     942    RegisterDll                   = _RegisterDll@48                @1209
    943943;Unicode
    944944   UnicodeToAsciiString = _UnicodeToAsciiString@4                  @1210

  • trunk/src/kernel32/except.asm

    r223 r281  
    1 ; $Id: except.asm,v 1.5 1999-06-26 18:24:50 sandervl Exp $
     1; $Id: except.asm,v 1.6 1999-07-07 08:11:09 sandervl Exp $
    22
    33;/*
    … …  
    175175SetFS   endp
    176176
     177        PUBLIC SetReturnFS
     178SetReturnFS proc near
     179        push    fs
     180        mov     eax, [esp+8]
     181        mov     fs, eax
     182        pop     eax
     183        ret
     184SetReturnFS endp
     185
    177186        PUBLIC getSS
    178187getSS   proc near

  • trunk/src/kernel32/makefile

    r278 r281  
    1 # $Id: makefile,v 1.11 1999-07-06 15:48:48 phaller Exp $
     1# $Id: makefile,v 1.12 1999-07-07 08:11:10 sandervl Exp $
    22
    33#
    … …  
    6969       pefile.OBJ \
    7070       winimgres.OBJ \
    71        tls.obj \
     71       wintls.obj \
    7272       async.OBJ \
    7373       fileio.obj \
    … …  
    125125    $(PDWIN32_INCLUDE)\unicode.h
    126126
    127 tls.obj: tls.cpp
     127wintls.obj: wintls.cpp $(PDWIN32_INCLUDE)\winimage.h $(PDWIN32_INCLUDE)\winexe.h $(PDWIN32_INCLUDE)\windll.h
    128128
    129129fileio.obj: fileio.cpp \
    … …  
    133133    .\thread.cpp \
    134134    $(PDWIN32_INCLUDE)\wprocess.h \
     135    $(PDWIN32_INCLUDE)\winimage.h $(PDWIN32_INCLUDE)\winexe.h $(PDWIN32_INCLUDE)\windll.h \
    135136    thread.h
    136137

  • trunk/src/kernel32/thread.cpp

    r126 r281  
    1 /* $Id: thread.cpp,v 1.6 1999-06-20 10:55:36 sandervl Exp $ */
     1/* $Id: thread.cpp,v 1.7 1999-07-07 08:11:10 sandervl Exp $ */
    22
    33/*
    … …  
    1414#include "thread.h"
    1515#include "except.h"
    16 #include "misc.h"
     16#include <misc.h>
    1717#include <wprocess.h>
     18#include <windll.h>
     19#include <winexe.h>
    1820
    1921static DWORD OPEN32API Win32ThreadProc(LPVOID lpData);
    … …  
    4648DWORD WIN32API GetCurrentThreadId()
    4749{
    48   dprintf(("GetCurrentThreadId\n"));
    49 
     50////  dprintf(("GetCurrentThreadId\n"));
    5051  return(O32_GetCurrentThreadId());
    5152}
    … …  
    121122           exitcode));
    122123
    123 #ifdef WIN32_TIBSEL
     124  Win32Dll::detachThreadFromAllDlls();  //send DLL_THREAD_DETACH message to all dlls
     125  Win32Dll::tlsDetachThreadFromAllDlls(); //destroy TLS structures of all dlls
     126  WinExe->tlsDetachThread();                    //destroy TLS structure of main exe
    124127  DestroyTIB();
    125 #endif
    126128  O32_ExitThread(exitcode);
    127129}
    … …  
    153155 WIN32THREADPROC  winthread = me->pCallback;
    154156 LPVOID           userdata  = me->lpUserData;
     157 DWORD            rc;
    155158
    156159  delete me;    //only called once
    … …  
    158161  dprintf(("Win32ThreadProc %d\n", GetCurrentThreadId()));
    159162
    160 #ifdef WIN32_TIBSEL
    161163  TEB *winteb = (TEB *)InitializeTIB();
    162164  if(winteb == NULL) {
    … …  
    170172  thdb->entry_point = (void *)winthread;
    171173  thdb->entry_arg   = (void *)userdata;
     174
    172175  SetWin32TIB();
    173 #else
    174   ReplaceExceptionHandler();
    175 #endif
    176   return(winthread(userdata));
     176  WinExe->tlsAttachThread();              //setup TLS structure of main exe
     177  Win32Dll::tlsAttachThreadToAllDlls(); //setup TLS structures of all dlls
     178  Win32Dll::attachThreadToAllDlls();      //send DLL_THREAD_ATTACH message to all dlls
     179
     180  rc = winthread(userdata);
     181
     182  Win32Dll::detachThreadFromAllDlls();  //send DLL_THREAD_DETACH message to all dlls
     183  Win32Dll::tlsDetachThreadFromAllDlls(); //destroy TLS structures of all dlls
     184  WinExe->tlsDetachThread();              //destroy TLS structure of main exe
     185  DestroyTIB();
     186  return rc;
    177187}
    178188//******************************************************************************

  • trunk/src/kernel32/windll.cpp

    r135 r281  
    1 /* $Id: windll.cpp,v 1.6 1999-06-20 17:54:53 sandervl Exp $ */
     1/* $Id: windll.cpp,v 1.7 1999-07-07 08:11:10 sandervl Exp $ */
    22
    33/*
    … …  
    2222#include <iostream.h>
    2323#include <fstream.h>
    24 #include "misc.h"
    25 #include "nameid.h"
    26 #include "win32type.h"
    27 #include "pefile.h"
    28 #include "windll.h"
     24#include <misc.h>
     25#include <nameid.h>
     26#include <win32type.h>
     27#include <pefile.h>
     28#include <windll.h>
     29#include <wprocess.h>
    2930#include "cio.h"
    3031#include "os2util.h"
    … …  
    131132  if(errorState == NO_ERROR && !fUnloaded)
    132133  {
    133         if(!fSystemDll) {
    134                 detachProcess();
    135         }       
     134        detachProcess();
    136135  }
    137136}
    … …  
    304303BOOL Win32Dll::attachProcess()
    305304{
    306   if(fSystemDll || fSkipEntryCalls || !fNativePEImage)
     305 BOOL rc;
     306 USHORT sel;
     307
     308  //Allocate TLS index for this module
     309  tlsAlloc();
     310  tlsAttachThread();    //setup TLS (main thread)
     311
     312  if(fSystemDll || fSkipEntryCalls) {
     313        dprintf(("attachProcess not required for dll %s", szModule));
    307314        return(TRUE);
    308 
    309   if(getenv("WIN32_IOPL2")) {
    310         io_init1();
    311   }
    312   return dllEntryPoint((ULONG)this, DLL_PROCESS_ATTACH, 0);
     315  }
     316
     317  dprintf(("attachProcess to dll %s", szModule));
     318
     319  sel = SetWin32TIB();
     320  rc = dllEntryPoint(hinstance, DLL_PROCESS_ATTACH, 0);
     321  SetFS(sel);
     322  return rc;
    313323}
    314324//******************************************************************************
    315325//******************************************************************************
    316326BOOL Win32Dll::detachProcess()
     327{
     328 BOOL   rc;
     329 USHORT sel;
     330
     331  if(fSystemDll || fSkipEntryCalls) {
     332        tlsDetachThread();      //destroy TLS (main thread)
     333        return(TRUE);
     334  }
     335
     336  dprintf(("detachProcess from dll %s", szModule));
     337
     338  fUnloaded = TRUE;
     339  sel = SetWin32TIB();
     340  rc = dllEntryPoint(hinstance, DLL_PROCESS_DETACH, 0);
     341  SetFS(sel);
     342  tlsDetachThread();    //destroy TLS (main thread)
     343  return rc;
     344}
     345//******************************************************************************
     346//******************************************************************************
     347BOOL Win32Dll::attachThread()
    317348{
    318349  if(fSystemDll || fSkipEntryCalls)
    319350        return(TRUE);
    320351
    321   if(fNativePEImage)
    322         return dllEntryPoint((ULONG)this, DLL_PROCESS_DETACH, 0);
    323   else  return dllEntryPoint((ULONG)this, DLL_PROCESS_ATTACH, 0);  //reversed in converted code
    324 }
    325 //******************************************************************************
    326 //******************************************************************************
    327 BOOL Win32Dll::attachThread()
     352  dprintf(("attachThread to dll %s", szModule));
     353  return dllEntryPoint(hinstance, DLL_THREAD_ATTACH, 0);
     354}
     355//******************************************************************************
     356//******************************************************************************
     357BOOL Win32Dll::detachThread()
    328358{
    329359  if(fSystemDll || fSkipEntryCalls)
    330360        return(TRUE);
    331361
    332   return dllEntryPoint((ULONG)this, DLL_THREAD_ATTACH, 0);
    333 }
    334 //******************************************************************************
    335 //******************************************************************************
    336 BOOL Win32Dll::detachThread()
    337 {
    338   if(fSystemDll || fSkipEntryCalls)
    339         return(TRUE);
    340 
    341   return dllEntryPoint((ULONG)this, DLL_THREAD_DETACH, 0);
     362  dprintf(("attachThread from dll %s", szModule));
     363  return dllEntryPoint(hinstance, DLL_THREAD_DETACH, 0);
     364}
     365//******************************************************************************
     366//Send DLL_THREAD_ATTACH message to all dlls for a new thread
     367//******************************************************************************
     368void Win32Dll::attachThreadToAllDlls()
     369{
     370 Win32Dll *dll = Win32Dll::head;
     371
     372  while(dll) {
     373        dll->attachThread();
     374        dll = dll->getNext();
     375  }
     376}
     377//******************************************************************************
     378//Send DLL_THREAD_DETACH message to all dlls for thread that's about to die
     379//******************************************************************************
     380void Win32Dll::detachThreadFromAllDlls()
     381{
     382 Win32Dll *dll = Win32Dll::head;
     383
     384  while(dll) {
     385        dll->detachThread();
     386        dll = dll->getNext();
     387  }
     388}
     389//******************************************************************************
     390//Setup TLS structure for all dlls for a new thread
     391//******************************************************************************
     392void Win32Dll::tlsAttachThreadToAllDlls()
     393{
     394 Win32Dll *dll = Win32Dll::head;
     395
     396  while(dll) {
     397        dll->tlsAttachThread();
     398        dll = dll->getNext();
     399  }
     400}
     401//******************************************************************************
     402//Destroy TLS structure for all dlls for a thread that's about to die
     403//******************************************************************************
     404void Win32Dll::tlsDetachThreadFromAllDlls()
     405{
     406 Win32Dll *dll = Win32Dll::head;
     407
     408  while(dll) {
     409        dll->tlsDetachThread();
     410        dll = dll->getNext();
     411  }
    342412}
    343413//******************************************************************************

  • trunk/src/kernel32/winexe.cpp

    r126 r281  
    1 /* $Id: winexe.cpp,v 1.7 1999-06-20 10:55:36 sandervl Exp $ */
     1/* $Id: winexe.cpp,v 1.8 1999-07-07 08:11:10 sandervl Exp $ */
    22
    33/*
    … …  
    8787
    8888  fExeStarted  = TRUE;
     89
     90  //Allocate TLS index for this module
     91  tlsAlloc();
     92  tlsAttachThread();    //setup TLS (main thread)
     93
    8994  SetWin32TIB();
    9095  rc = ((WIN32EXEENTRY)entryPoint)();

  • trunk/src/kernel32/winimage.cpp

    r120 r281  
    1 /* $Id: winimage.cpp,v 1.4 1999-06-19 10:54:43 sandervl Exp $ */
     1/* $Id: winimage.cpp,v 1.5 1999-07-07 08:11:10 sandervl Exp $ */
    22
    33/*
    … …  
    6060    nrNameExports(0), nrOrdExports(0), nameexports(NULL), ordexports(NULL),
    6161    szFileName(NULL), NameTable(NULL), Win32Table(NULL), fullpath(NULL),
     62    tlsAddress(0), tlsIndexAddr(0), tlsInitSize(0), tlsTotalSize(0), tlsCallBackAddr(0), tlsIndex(-1),
    6263    pResSection(NULL), pResDir(NULL), winres(NULL), VersionId(-1)
    6364{
    … …  
    8485    nrNameExports(0), nrOrdExports(0), nameexports(NULL), ordexports(NULL),
    8586    szFileName(NULL), NameTable(NULL), Win32Table(NULL), fullpath(NULL),
     87    tlsAddress(0), tlsIndexAddr(0), tlsInitSize(0), tlsTotalSize(0), tlsCallBackAddr(0), tlsIndex(-1),
    8688    pResSection(NULL), pResDir(NULL), winres(NULL)
    8789{

  • trunk/src/kernel32/wprocess.cpp

    r130 r281  
    1 /* $Id: wprocess.cpp,v 1.12 1999-06-20 12:46:09 sandervl Exp $ */
     1/* $Id: wprocess.cpp,v 1.13 1999-07-07 08:11:10 sandervl Exp $ */
    22
    33/*
    … …  
    4545TEB *InitializeTIB(BOOL fMainThread)
    4646{
    47 #ifdef WIN32_TIBSEL
    4847  TEB   *winteb;
    4948  THDB  *thdb;
    … …  
    108107   dprintf(("InitializeTIB: FS(%x):[0] = %x", GetFS(), QueryExceptionChain()));
    109108   return winteb;
    110 #else
    111    return 0;
    112 #endif
    113109}
    114110//******************************************************************************
    … …  
    117113void DestroyTIB()
    118114{
    119 #ifdef WIN32_TIBSEL
    120115 SHORT  orgtibsel;
    121116 TEB   *winteb;
    … …  
    141136   TIBFlatPtr = NULL;
    142137   return;
    143 #endif
    144138}
    145139/******************************************************************************/
    … …  
    147141void WIN32API RestoreOS2TIB()
    148142{
    149 #ifdef WIN32_TIBSEL
    150143 SHORT  orgtibsel;
    151144 TEB   *winteb;
    … …  
    160153        SetFS(orgtibsel);
    161154   }
    162 #endif
    163155}
    164156/******************************************************************************/
    165157/******************************************************************************/
    166 void WIN32API SetWin32TIB()
    167 {
    168 #ifdef WIN32_TIBSEL
     158USHORT WIN32API SetWin32TIB()
     159{
    169160 SHORT  win32tibsel;
    170161 TEB   *winteb;
    … …  
    177168
    178169        //Restore our win32 FS selector
    179         SetFS(win32tibsel);
     170        return SetReturnFS(win32tibsel);
    180171   }
    181172   else DebugInt3();
    182 #endif
     173
     174   return 0;
    183175}
    184176/******************************************************************************/
    185 //SvL: 4-10-'98: Put in separate procedure, as ICC changes FS:0 when there
    186 //               are new or delete calls present.
    187 //******************************************************************************
    188 void RegisterExe(LONG Win32TableId, LONG NameTableId, LONG VersionResId,
    189                  LONG Pe2lxVersion, HINSTANCE hinstance)
     177//******************************************************************************
     178void WIN32API RegisterExe(WIN32EXEENTRY EntryPoint, PIMAGE_TLS_CALLBACK *TlsCallbackAddr,
     179                          LPDWORD TlsIndexAddr, ULONG TlsInitSize,
     180                          ULONG TlsTotalSize, LPVOID TlsAddress,
     181                          LONG Win32TableId, LONG NameTableId, LONG VersionResId,
     182                          LONG Pe2lxVersion, HINSTANCE hinstance, ULONG dwReserved)
    190183{
    191184  if(WinExe != NULL) //should never happen
    192185    delete(WinExe);
    193186
     187  CheckVersion(Pe2lxVersion, OS2GetDllName(hinstance));
     188
     189  if(getenv("WIN32_IOPL2")) {
     190    io_init1();
     191  }
     192
    194193  //SvL: Use 0 instead of the real instance handle (for resource lookup)
    195194  Win32Exe *winexe = new Win32Exe(0, NameTableId, Win32TableId);
     195
    196196  if(winexe) {
    197     winexe->setVersionId(VersionResId);
    198     winexe->setOS2InstanceHandle(hinstance);
     197        dprintf(("RegisterExe Win32TableId = %x", Win32TableId));
     198        dprintf(("RegisterExe NameTableId  = %x", NameTableId));
     199        dprintf(("RegisterExe VersionResId = %x", VersionResId));
     200        dprintf(("RegisterExe Pe2lxVersion = %x", Pe2lxVersion));
     201
     202        winexe->setVersionId(VersionResId);
     203        winexe->setOS2InstanceHandle(hinstance);
     204        winexe->setEntryPoint((ULONG)EntryPoint);
     205        winexe->setTLSAddress(TlsAddress);
     206        winexe->setTLSInitSize(TlsInitSize);
     207        winexe->setTLSTotalSize(TlsTotalSize);
     208        winexe->setTLSIndexAddr(TlsIndexAddr);
     209        winexe->setTLSCallBackAddr(TlsCallbackAddr);
     210
     211        char *modname = getenv("WIN32MODULE");
     212
     213        if(modname != NULL)
     214        {
     215                dprintf(("Set full path for exe to %s", modname));
     216                winexe->setFullPath(modname);
     217        }
     218        winexe->start();
    199219  }
    200220  else {
    201     eprintf(("Win32Exe creation failed!\n"));
    202     DebugInt3();
    203   }
    204 
    205   char *modname = getenv("WIN32MODULE");
    206 
    207   if(modname != NULL)
    208   {
    209     dprintf(("Set full path for exe to %s", modname));
    210     winexe->setFullPath(modname);
    211   }
    212 
    213   fExeStarted  = TRUE;
    214 }
    215 //******************************************************************************
    216 //******************************************************************************
    217 VOID WIN32API RegisterResourceUsage(LONG Win32TableId, LONG NameTableId,
    218                     LONG VersionResId, LONG Pe2lxVersion,
    219                     HINSTANCE hinstance)
    220 {
    221   SetWin32TIB();
    222 
    223   if(getenv("WIN32_IOPL2")) {
    224     io_init1();
    225   }
    226   dprintf(("RegisterResourceUsage %X resid = %d\n", hinstance, VersionResId));
    227 
    228   CheckVersion(Pe2lxVersion, OS2GetDllName(hinstance));
    229 
    230   RegisterExe(Win32TableId, NameTableId, VersionResId, Pe2lxVersion, hinstance);
    231 
    232   dprintf(("RegisterResourceUsage: FS(%x):[0] = %x", GetFS(), QueryExceptionChain()));
    233 }
    234 //******************************************************************************
    235 //******************************************************************************
    236 void CreateDll(LONG Win32TableId, LONG NameTableId, LONG VersionResId,
    237                HINSTANCE hinstance, WIN32DLLENTRY pfnDllEntry)
    238 {
     221        eprintf(("Win32Exe creation failed!\n"));
     222        DebugInt3();
     223        return;
     224  }
     225}
     226//******************************************************************************
     227//******************************************************************************
     228ULONG WIN32API RegisterDll(WIN32DLLENTRY pfnDllEntry, PIMAGE_TLS_CALLBACK *TlsCallbackAddr,
     229                           LPDWORD TlsIndexAddr, ULONG TlsInitSize,
     230                           ULONG TlsTotalSize, LPVOID TlsAddress,
     231                           LONG Win32TableId, LONG NameTableId, LONG VersionResId,
     232                           LONG Pe2lxVersion, HINSTANCE hinstance, ULONG dwAttachType)
     233{
     234 char *name;
     235
    239236  Win32Dll *winmod = Win32Dll::findModule(hinstance);
    240 
    241   if(winmod != NULL) {
    242     //dll manually loaded by PE loader (Win32Dll::init)
    243     winmod->OS2DllInit(hinstance, NameTableId, Win32TableId, pfnDllEntry);
    244     return;
    245   }
    246 
    247   //converted win32 dll loaded by OS/2 loader
    248   winmod = new Win32Dll(hinstance, NameTableId, Win32TableId, pfnDllEntry);
    249   if(winmod == NULL) {
    250     eprintf(("Failed to allocate module object!\n"));
    251     DebugInt3();
    252     return;
    253   }
    254   //SvL: 19-8-'98
    255   winmod->AddRef();
    256   winmod->setVersionId(VersionResId);
    257 }
    258 //******************************************************************************
    259 //******************************************************************************
    260 VOID WIN32API RegisterDll(LONG Win32TableId, LONG NameTableId,
    261                           LONG VersionResId, LONG Pe2lxVersion,
    262                           HINSTANCE hinstance)
    263 {
    264  WIN32DLLENTRY  pfnDllEntry;
    265  char *name;
    266 
    267   pfnDllEntry = (WIN32DLLENTRY)GetDllEntryPoint();  //== return address
    268 
    269   if(getenv("WIN32_IOPL2")) {
    270     io_init1();
    271   }
    272   name = OS2GetDllName(hinstance);
    273   CheckVersion(Pe2lxVersion, name);
    274 
    275   dprintf(("RegisterDll %X %s\n", hinstance, name));
    276 
    277   CreateDll(Win32TableId, NameTableId, VersionResId, hinstance, pfnDllEntry);
    278 
    279   /* @@@PH 1998/03/17 console devices initialization */
    280   iConsoleDevicesRegister();
    281 
    282   SetWin32TIB();
    283   dprintf(("RegisterDll: FS = %x", GetFS()));
     237  if(dwAttachType == 0)
     238  { //Process attach
     239        if(getenv("WIN32_IOPL2")) {
     240                io_init1();
     241        }
     242        name = OS2GetDllName(hinstance);
     243        CheckVersion(Pe2lxVersion, name);
     244
     245        dprintf(("RegisterDll %X %s reason %d\n", hinstance, name, dwAttachType));
     246        dprintf(("RegisterDll Win32TableId = %x", Win32TableId));
     247        dprintf(("RegisterDll NameTableId  = %x", NameTableId));
     248        dprintf(("RegisterDll VersionResId = %x", VersionResId));
     249        dprintf(("RegisterDll Pe2lxVersion = %x", Pe2lxVersion));
     250
     251        if(winmod != NULL) {
     252                //dll manually loaded by PE loader (Win32Dll::init)
     253                winmod->OS2DllInit(hinstance, NameTableId, Win32TableId, pfnDllEntry);
     254        }
     255        else {
     256                //converted win32 dll loaded by OS/2 loader
     257                winmod = new Win32Dll(hinstance, NameTableId, Win32TableId, pfnDllEntry);
     258                if(winmod == NULL) {
     259                        eprintf(("Failed to allocate module object!\n"));
     260                        DebugInt3();
     261                        return 0;       //fail dll load
     262                }
     263        }
     264        winmod->setTLSAddress(TlsAddress);
     265        winmod->setTLSInitSize(TlsInitSize);
     266        winmod->setTLSTotalSize(TlsTotalSize);
     267        winmod->setTLSIndexAddr(TlsIndexAddr);
     268        winmod->setTLSCallBackAddr(TlsCallbackAddr);
     269
     270        /* @@@PH 1998/03/17 console devices initialization */
     271        iConsoleDevicesRegister();
     272
     273        //SvL: 19-8-'98
     274        winmod->AddRef();
     275        winmod->setVersionId(VersionResId);
     276
     277        winmod->attachProcess();
     278   }
     279   else {//process detach
     280        if(winmod != NULL && !fFreeLibrary) {
     281                return 0;       //don't unload (OS/2 dll unload bug)
     282        }
     283//Runtime environment could already be gone, so don't do this
     284//      dprintf(("KERNEL32: Dll Removed by FreeLibrary or ExitProcess\n"));
     285   }
     286   return 1;    //success
    284287}
    285288//******************************************************************************
    … …  
    294297  }
    295298  return;
    296 }
    297 //******************************************************************************
    298 //Called when a dll is detached (either at process exit or when FreeLibrary is called)
    299 //******************************************************************************
    300 BOOL WIN32API DLLExitList(HINSTANCE hInstance)
    301 {
    302 //  dprintf(("DLLExitList"));
    303   Win32Dll *winmod = Win32Dll::findModule(hInstance);
    304 
    305   if(winmod == NULL) {//probably called after we manually unloaded it in ExitProcess
    306     return(1);  //remove it from memory
    307   }
    308   dprintf(("DllExitList for %s (%X)\n", OS2GetDllName(winmod->getInstanceHandle()), winmod->getInstanceHandle()));
    309   delete(winmod);
    310 
    311   if(fFreeLibrary) {
    312     dprintf(("KERNEL32: DLLExitList Ditched by FreeLibrary\n"));
    313     return(1);  //remove it as we no longer need it
    314   }
    315   return(0);    //don't remove it (OS/2 can unload them at process exit in the wrong order!)
    316299}
    317300//******************************************************************************
    … …  
    513496
    514497  dprintf(("KERNEL32:  GetCommandLine %s\n", cmdline));
    515 #ifdef WIN32_TIBSEL
    516498  dprintf(("KERNEL32:  FS = %x\n", GetFS()));
    517 #else
    518   //SvL: Replace original startup code exception handler
    519   ReplaceExceptionHandler();
    520 #endif
    521499  return(cmdline);
    522500}
    … …  
    528506         char *asciicmdline = NULL;
    529507
    530 #ifdef WIN32_TIBSEL
    531508    dprintf(("KERNEL32:  FS = %x\n", GetFS()));
    532 #else
    533     //SvL: Replace original startup code exception handler
    534     ReplaceExceptionHandler();
    535 #endif
    536509
    537510    if(UnicodeCmdLine)
Note: See TracChangeset for help on using the changeset viewer.