Changeset 1670 for trunk/src


Ignore:
Timestamp:
Nov 9, 1999, 8:22:33 PM (26 years ago)
Author:
sandervl
Message:

thread fixes + heap wrappers

Location:
trunk/src/kernel32
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/KERNEL32.CPP

    r1641 r1670  
    1 /* $Id: KERNEL32.CPP,v 1.28 1999-11-08 20:53:24 sandervl Exp $ */
     1/* $Id: KERNEL32.CPP,v 1.29 1999-11-09 19:22:31 sandervl Exp $ */
    22
    33/*
    … …  
    161161VOID WIN32API SetLastError( DWORD arg1)
    162162{
    163 //    dprintf(("KERNEL32:  SetLastError to %d\n", arg1));
     163    dprintf2(("KERNEL32:  SetLastError to %d\n", arg1));
    164164    O32_SetLastError(arg1);
    165165}
    … …  
    386386HANDLE WIN32API GetCurrentProcess(void)
    387387{
    388 ////    dprintf(("KERNEL32:  GetCurrentProcess\n"));
     388    dprintf2(("KERNEL32:  GetCurrentProcess\n"));
    389389    return O32_GetCurrentProcess();
    390390}
    … …  
    393393DWORD WIN32API GetCurrentProcessId(void)
    394394{
    395 //    dprintf(("KERNEL32:  GetCurrentProcessId\n"));
     395    dprintf2(("KERNEL32:  GetCurrentProcessId\n"));
    396396    return O32_GetCurrentProcessId();
    397397}
    … …  
    407407VOID WIN32API Sleep(DWORD arg1)
    408408{
    409 //    dprintf(("KERNEL32:  Sleep %d\n", arg1));
     409    dprintf2(("KERNEL32:  Sleep %d\n", arg1));
    410410    O32_Sleep(arg1);
    411411}
    … …  
    599599         fEqual = 3;
    600600   }
    601 //   dprintf(("KERNEL32:  OS2CompareStringA '%s' - '%s' returned %d\n", lpString1, lpString2, fEqual));
     601   dprintf2(("KERNEL32:  OS2CompareStringA '%s' - '%s' returned %d\n", lpString1, lpString2, fEqual));
    602602   return(fEqual);
    603603}
    … …  
    614614 char *string2 = UnicodeToAsciiString((LPWSTR)lpString2);
    615615
    616 //  dprintf(("KERNEL32:  OS2CompareStringW '%s' - '%s'\n", string1, string2));
     616  dprintf2(("KERNEL32:  OS2CompareStringW '%s' - '%s'\n", string1, string2));
    617617
    618618  fEqual = CompareStringA(lcid, fdwStyle, string1, cch1, string2, cch2);
    … …  
    912912                            UINT  len )
    913913{
    914 #ifdef DEBUG_LOCAL
    915   dprintf(("KERNEL32: RtlMoveMemory(%08x,%08x,%08x)\n",
     914  dprintf2(("KERNEL32: RtlMoveMemory(%08x,%08x,%08x)\n",
    916915           dst,
    917916           src,
    918917           len));
    919 #endif
    920918
    921919  memmove(dst,
    … …  
    931929                            UINT len)
    932930{
    933 #ifdef DEBUG_LOCAL
    934   dprintf(("KERNEL32: RtlZeroMemory(%08x,%08x)\n",
     931  dprintf2(("KERNEL32: RtlZeroMemory(%08x,%08x)\n",
    935932           ptr,
    936933           len));
    937 #endif
    938934
    939935  memset(ptr,

  • trunk/src/kernel32/KERNEL32.DEF

    r1663 r1670  
    1 ; $Id: KERNEL32.DEF,v 1.49 1999-11-09 14:19:45 sandervl Exp $
     1; $Id: KERNEL32.DEF,v 1.50 1999-11-09 19:22:32 sandervl Exp $
    22
    33;Created by BLAST for IBM's compiler
    … …  
    10461046;Export for MSACM32
    10471047    _wsnprintfA                                                   @2000
     1048
     1049    IsExeStarted__Fv     @2001

  • trunk/src/kernel32/heap.cpp

    r607 r1670  
    1 /* $Id: heap.cpp,v 1.14 1999-08-21 16:29:26 sandervl Exp $ */
     1/* $Id: heap.cpp,v 1.15 1999-11-09 19:22:32 sandervl Exp $ */
    22
    33/*
    … …  
    1717#include "os2heap.h"
    1818#include <heap.h>
     19#include <odinwrap.h>
    1920
    2021static HANDLE processheap = NULL;
    … …  
    2324//******************************************************************************
    2425//******************************************************************************
    25 LPVOID WIN32API HeapAlloc(HANDLE hHeap, DWORD dwFlags, DWORD dwBytes)
    26 {
    27  OS2Heap *curheap = OS2Heap::find(hHeap);
    28 
    29 //  dprintf(("HeapAlloc %X bytes", dwBytes));
     26ODINFUNCTIONNODBG3(LPVOID, HeapAlloc, HANDLE, hHeap, DWORD, dwFlags,
     27                   DWORD, dwBytes)
     28{
     29 OS2Heap *curheap = OS2Heap::find(hHeap);
     30
     31  dprintf2(("HeapAlloc %X bytes", dwBytes));
    3032  if(curheap == NULL)
    3133        return(NULL);
    … …  
    3537//******************************************************************************
    3638//******************************************************************************
    37 LPVOID WIN32API HeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, DWORD dwBytes)
    38 {
    39  OS2Heap *curheap = OS2Heap::find(hHeap);
    40 
     39ODINFUNCTIONNODBG4(LPVOID, HeapReAlloc, HANDLE, hHeap, DWORD, dwFlags, LPVOID,
     40                   lpMem, DWORD, dwBytes)
     41{
     42 OS2Heap *curheap = OS2Heap::find(hHeap);
     43
     44  dprintf2(("HeapReAlloc %X bytes", dwBytes));
    4145  if(curheap == NULL)
    4246        return(NULL);
    … …  
    4650//******************************************************************************
    4751//******************************************************************************
    48 BOOL WIN32API HeapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem)
    49 {
    50  OS2Heap *curheap = OS2Heap::find(hHeap);
    51 
     52ODINFUNCTIONNODBG3(BOOL, HeapFree, HANDLE, hHeap, DWORD, dwFlags, LPVOID, lpMem)
     53{
     54 OS2Heap *curheap = OS2Heap::find(hHeap);
     55
     56  dprintf2(("HeapFree %X", lpMem));
    5257  if(curheap == NULL)
    5358        return(FALSE);
    … …  
    5762//******************************************************************************
    5863//******************************************************************************
    59 HANDLE WIN32API HeapCreate(DWORD flOptions, DWORD dwInitialSize, DWORD dwMaximumSize)
     64ODINFUNCTIONNODBG3(HANDLE, HeapCreate, DWORD, flOptions, DWORD, dwInitialSize,
     65                   DWORD, dwMaximumSize)
    6066{
    6167 OS2Heap *curheap;
    6268
    6369  //Create Open32 heap for it's handle
     70  dprintf2(("HeapCreate dwInitialSize %X", dwInitialSize));
    6471  HANDLE hHeap = O32_HeapCreate(flOptions, 0, 4096);
    6572  if(hHeap == NULL)
    … …  
    8491//******************************************************************************
    8592//******************************************************************************
    86 BOOL WIN32API HeapDestroy(HANDLE hHeap)
    87 {
    88  OS2Heap *curheap = OS2Heap::find(hHeap);
    89 
     93ODINFUNCTIONNODBG1(BOOL, HeapDestroy, HANDLE, hHeap)
     94{
     95 OS2Heap *curheap = OS2Heap::find(hHeap);
     96
     97  dprintf2(("HeapDestroy %X", hHeap));
    9098  if(curheap == NULL)
    9199        return(FALSE);
    … …  
    97105//******************************************************************************
    98106//******************************************************************************
    99 DWORD WIN32API HeapSize(HANDLE hHeap, DWORD arg2, PVOID  arg3)
    100 {
    101  OS2Heap *curheap = OS2Heap::find(hHeap);
    102 
     107ODINFUNCTIONNODBG3(DWORD, HeapSize, HANDLE, hHeap, DWORD, arg2, PVOID, arg3)
     108{
     109 OS2Heap *curheap = OS2Heap::find(hHeap);
     110
     111  dprintf2(("HeapSize %X %x", hHeap, arg2));
    103112  if(curheap == NULL)
    104113        return(0);
    … …  
    108117//TODO: Check this!!!
    109118//******************************************************************************
    110 DWORD WIN32API HeapCompact(HANDLE hHeap, DWORD dwFlags)
     119ODINFUNCTIONNODBG2(DWORD, HeapCompact, HANDLE, hHeap, DWORD, dwFlags)
    111120{
    112121  dprintf(("KERNEL32:  HeapCompact: Unknown API - stub\n"));
    … …  
    115124//******************************************************************************
    116125//******************************************************************************
    117 BOOL WIN32API HeapValidate(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem)
     126ODINFUNCTIONNODBG3(BOOL, HeapValidate, HANDLE, hHeap, DWORD, dwFlags, LPCVOID, lpMem)
    118127{
    119128  dprintf(("KERNEL32:  HeapValidate - stub\n"));
    … …  
    122131//******************************************************************************
    123132//******************************************************************************
    124 BOOL WIN32API HeapUnlock(HANDLE hHeap)
     133ODINFUNCTIONNODBG1(BOOL, HeapUnlock, HANDLE, hHeap)
    125134{
    126135  dprintf(("KERNEL32:  HeapUnlock - stub (TRUE)\n"));
    … …  
    129138//******************************************************************************
    130139//******************************************************************************
    131 BOOL WIN32API HeapLock(HANDLE hHeap)
     140ODINFUNCTIONNODBG1(BOOL, HeapLock, HANDLE, hHeap)
    132141{
    133142  dprintf(("KERNEL32:  HeapLock - stub (TRUE)\n"));
    … …  
    137146//    LPPROCESS_HEAP_ENTRY lpEntry
    138147//******************************************************************************
    139 BOOL WIN32API HeapWalk(HANDLE hHeap, void *lpEntry)
     148ODINFUNCTIONNODBG2(BOOL, HeapWalk, HANDLE, hHeap, LPVOID, lpEntry)
    140149{
    141150  dprintf(("KERNEL32:  HeapWalk - stub (TRUE)\n"));
    … …  
    144153//******************************************************************************
    145154//******************************************************************************
    146 HANDLE WIN32API GetProcessHeap(VOID)
     155ODINFUNCTIONNODBG0(HANDLE, GetProcessHeap)
    147156{
    148157 HANDLE hHeap;
    149158
    150 //    dprintf(("KERNEL32:  OS2GetProcessHeap\n"));
     159    dprintf2(("KERNEL32: GetProcessHeap\n"));
    151160    //SvL: Only one process heap per process
    152161    if(processheap == NULL) {

  • trunk/src/kernel32/heapstring.cpp

    r1663 r1670  
    1 /* $Id: heapstring.cpp,v 1.18 1999-11-09 14:19:46 sandervl Exp $ */
     1/* $Id: heapstring.cpp,v 1.19 1999-11-09 19:22:32 sandervl Exp $ */
    22
    33/*
    … …  
    1212 * Includes                                                                  *
    1313 *****************************************************************************/
    14 #undef DEBUG
    1514
    1615#include <odin.h>
    … …  
    6968      return FALSE;
    7069    }
    71     dprintf(("KERNEL32: HeapString: UniCreateUconvObject(%d)\n",
     70    dprintf2(("KERNEL32: HeapString: UniCreateUconvObject(%d)\n",
    7271             rc));
    7372  }
    … …  
    9089int WIN32API lstrlenA(LPCSTR arg1)
    9190{
    92   dprintf(("KERNEL32: lstrlenA(%s)\n",
     91  dprintf2(("KERNEL32: lstrlenA(%s)\n",
    9392           arg1));
    9493
    … …  
    114113
    115114  rc = UniStrlen( (UniChar*)arg1);
    116   dprintf(("KERNEL32: lstrlenW(%08xh) returns %d\n",
     115  dprintf2(("KERNEL32: lstrlenW(%08xh) returns %d\n",
    117116           arg1,
    118117           rc));
    … …  
    135134LPSTR WIN32API lstrcatA(LPSTR arg1, LPCSTR arg2)
    136135{
    137   dprintf(("KERNEL32: lstrcat(%s,%s)\n",
     136  dprintf2(("KERNEL32: lstrcat(%s,%s)\n",
    138137           arg1,
    139138           arg2));
    … …  
    157156LPWSTR WIN32API lstrcatW(LPWSTR arg1, LPCWSTR arg2)
    158157{
    159   dprintf(("KERNEL32: OS2lstrcatW(%08xh,%08xh)\n",
     158  dprintf2(("KERNEL32: OS2lstrcatW(%08xh,%08xh)\n",
    160159           arg1,
    161160           arg2));
    … …  
    180179int WIN32API lstrcmpA(LPCSTR arg1, LPCSTR  arg2)
    181180{
    182   dprintf(("KERNEL32: OS2lstrcmpA(%s,%s)\n",
     181  dprintf2(("KERNEL32: OS2lstrcmpA(%s,%s)\n",
    183182           arg1,
    184183           arg2));
    … …  
    202201int WIN32API lstrncmpA(LPCSTR arg1, LPCSTR  arg2, int l)
    203202{
    204   dprintf(("KERNEL32: OS2lstrncmpA(%s,%s,%d)\n",
     203  dprintf2(("KERNEL32: OS2lstrncmpA(%s,%s,%d)\n",
    205204           arg1,
    206205           arg2,
    … …  
    277276int WIN32API lstrcmpW(LPCWSTR arg1, LPCWSTR arg2)
    278277{
    279     dprintf(("KERNEL32: lstrcmpW (%08xh-%ls, %08xh-%ls)\n",
     278    dprintf2(("KERNEL32: lstrcmpW (%08xh-%ls, %08xh-%ls)\n",
    280279             arg1,
    281280             arg1,
    … …  
    307306int WIN32API lstrncmpW(LPCWSTR arg1, LPCWSTR  arg2, int l)
    308307{
    309   dprintf(("KERNEL32: OS2lstrncmpW(%08xh,%08xh,%d)\n",
     308  dprintf2(("KERNEL32: OS2lstrncmpW(%08xh,%08xh,%d)\n",
    310309           arg1,
    311310           arg2,
    … …  
    380379  register LPSTR p2 = (LPSTR)arg2;
    381380
    382   dprintf(("KERNEL32: OS2lstrcpyA(%08xh, %08xh, %08xh)\n",
     381  dprintf2(("KERNEL32: OS2lstrcpyA(%08xh, %08xh, %08xh)\n",
    383382           arg1,
    384383           arg2,
    … …  
    413412LPWSTR WIN32API lstrcpynW(LPWSTR dest, LPCWSTR src, int arg3)
    414413{
    415   dprintf(("KERNEL32: lstrcpynW(%08xh,%08xh,%08xh)",
     414  dprintf2(("KERNEL32: lstrcpynW(%08xh,%08xh,%08xh)",
    416415           dest,
    417416           src,
    … …  
    443442int WIN32API lstrcmpiA(LPCSTR arg1, LPCSTR  arg2)
    444443{
    445   dprintf(("KERNEL32: lstrcmpiA(%s,%s)\n",
     444  dprintf2(("KERNEL32: lstrcmpiA(%s,%s)\n",
    446445           arg1,
    447446           arg2));
    … …  
    474473  int   rc;
    475474
    476   dprintf(("KERNEL32: lstrcmpiW(%08xh,%08xh)\n",
     475  dprintf2(("KERNEL32: lstrcmpiW(%08xh,%08xh)\n",
    477476           arg1,
    478477           arg2));
    … …  
    600599  char*    in_buf;
    601600
    602   dprintf(("KERNEL32: HeapString: lstrcpynAtoW(%s,%08xh,%d)\n",
     601  dprintf2(("KERNEL32: HeapString: lstrcpynAtoW(%s,%08xh,%d)\n",
    603602           ascii,
    604603           unicode,
    … …  
    751750  if (!p)
    752751  {
    753     dprintf(("KERNEL32: HEAP_xalloc(%08xh,%08xh,%08xh) out of memory.\n",
     752    dprintf2(("KERNEL32: HEAP_xalloc(%08xh,%08xh,%08xh) out of memory.\n",
    754753             heap,
    755754             flags,
    … …  
    777776  if (!p)
    778777  {
    779     dprintf(("KERNEL32: HEAP_xrealloc(%08xh,%08xh,%08xh,%08xh) out of memory.\n",
     778    dprintf2(("KERNEL32: HEAP_xrealloc(%08xh,%08xh,%08xh,%08xh) out of memory.\n",
    780779             heap,
    781780             flags,
    … …  
    804803  if (!p)
    805804  {
    806     dprintf(("KERNEL32: HEAP_malloc(%08xh) out of memory.\n",
     805    dprintf2(("KERNEL32: HEAP_malloc(%08xh) out of memory.\n",
    807806             size));
    808807  }
    … …  
    828827  if (!p)
    829828  {
    830     dprintf(("KERNEL32: HEAP_realloc(%08xh,%08xh) out of memory.\n",
     829    dprintf2(("KERNEL32: HEAP_realloc(%08xh,%08xh) out of memory.\n",
    831830             lpMem,
    832831             size));
    … …  
    850849VOID WIN32API HEAP_free(LPVOID lpMem)
    851850{
    852   dprintf(("KERNEL32: HEAP_free(%08xh)\n",
     851  dprintf2(("KERNEL32: HEAP_free(%08xh)\n",
    853852           lpMem));
    854853
    … …  
    958957INT WIN32API WideCharToLocal(LPSTR pLocal, LPWSTR pWide, INT dwChars)
    959958{
    960   dprintf(("KERNEL32: WideCharToLocal(%08xh,%08xh,%08xh)\n",
     959  dprintf2(("KERNEL32: WideCharToLocal(%08xh,%08xh,%08xh)\n",
    961960           pLocal,
    962961           pWide,
    … …  
    993992  *pWide = 0;
    994993
    995   dprintf(("KERNEL32: LocalToWideChar(%08xh,%08xh,%08xh)\n",
     994  dprintf2(("KERNEL32: LocalToWideChar(%08xh,%08xh,%08xh)\n",
    996995           pLocal,
    997996           pWide,

  • trunk/src/kernel32/makefile

    r1663 r1670  
    1 # $Id: makefile,v 1.54 1999-11-09 14:19:46 sandervl Exp $
     1# $Id: makefile,v 1.55 1999-11-09 19:22:32 sandervl Exp $
    22
    33#
    … …  
    1919CXXFLAGS = $(CXXFLAGS) -I$(PDWIN32_INCLUDE) /Tm+
    2020
     21!ifdef DEBUGALL
     22CFLAGS = $(CFLAGS) -DDEBUG_ENABLELOG_LEVEL2
     23CXXFLAGS = $(CXXFLAGS) -DDEBUG_ENABLELOG_LEVEL2
     24!endif
    2125
    2226OBJS = KERNEL32.OBJ KOBJECTS.OBJ CONSOLE.OBJ CONIN.OBJ \

  • trunk/src/kernel32/windllbase.cpp

    r1663 r1670  
    1 /* $Id: windllbase.cpp,v 1.3 1999-11-09 14:19:47 sandervl Exp $ */
     1/* $Id: windllbase.cpp,v 1.4 1999-11-09 19:22:32 sandervl Exp $ */
    22
    33/*
    … …  
    102102 WINEXCEPTION_FRAME exceptFrame;
    103103 USHORT sel;
    104  BOOL rc;
     104 THDB *thdb;
     105 BOOL rc, fSetExceptionHandler;
    105106
    106107  if(fAttachedToProcess)
    … …  
    108109
    109110  fAttachedToProcess = TRUE;
     111
     112  thdb = GetThreadTHDB();
     113  fSetExceptionHandler = (!thdb || thdb->teb_sel != GetFS());
     114
     115  //Note: The Win32 exception structure references by FS:[0] is the same
     116  //      in OS/2
     117  if(fSetExceptionHandler) {
     118        OS2SetExceptionHandler((void *)&exceptFrame);
     119        sel = SetWin32TIB();
     120  }
    110121
    111122  //Allocate TLS index for this module
    … …  
    115126  if(fSkipEntryCalls || dllEntryPoint == NULL) {
    116127        dprintf(("attachProcess not required for dll %s", szModule));
     128        if(fSetExceptionHandler) {
     129                SetFS(sel);
     130                OS2UnsetExceptionHandler((void *)&exceptFrame);
     131        }
    117132        return(TRUE);
    118133  }
    … …  
    120135  dprintf(("attachProcess to dll %s", szModule));
    121136
    122   //Note: The Win32 exception structure references by FS:[0] is the same
    123   //      in OS/2
    124   OS2SetExceptionHandler((void *)&exceptFrame);
    125 
    126   sel = SetWin32TIB();
    127137  rc = dllEntryPoint(hinstance, DLL_PROCESS_ATTACH, 0);
    128   SetFS(sel);
    129 
    130   OS2UnsetExceptionHandler((void *)&exceptFrame);
    131 
     138
     139  dprintf(("attachProcess to dll %s DONE", szModule));
     140
     141  if(fSetExceptionHandler) {
     142        SetFS(sel);
     143        OS2UnsetExceptionHandler((void *)&exceptFrame);
     144  }
    132145  return rc;
    133146}
    … …  
    174187
    175188  dprintf(("attachThread to dll %s", szModule));
    176   //Note: The Win32 exception structure references by FS:[0] is the same
    177   //      in OS/2
    178   OS2SetExceptionHandler((void *)&exceptFrame);
    179189
    180190  rc = dllEntryPoint(hinstance, DLL_THREAD_ATTACH, 0);
    181191
    182   OS2UnsetExceptionHandler((void *)&exceptFrame);
     192  dprintf(("attachThread to dll %s DONE", szModule));
     193
    183194  return rc;
    184195}
    … …  
    195206  dprintf(("attachThread from dll %s", szModule));
    196207
    197   //Note: The Win32 exception structure references by FS:[0] is the same
    198   //      in OS/2
    199   OS2SetExceptionHandler((void *)&exceptFrame);
    200 
    201208  rc =  dllEntryPoint(hinstance, DLL_THREAD_DETACH, 0);
    202 
    203   OS2UnsetExceptionHandler((void *)&exceptFrame);
    204209  return rc;
    205210}

  • trunk/src/kernel32/winexebase.cpp

    r956 r1670  
    1 /* $Id: winexebase.cpp,v 1.1 1999-09-15 23:39:07 sandervl Exp $ */
     1/* $Id: winexebase.cpp,v 1.2 1999-11-09 19:22:32 sandervl Exp $ */
    22
    33/*
    … …  
    3939//******************************************************************************
    4040//******************************************************************************
     41BOOL IsExeStarted()
     42{
     43    return fExeStarted;
     44}
     45//******************************************************************************
     46//******************************************************************************
    4147Win32ExeBase::Win32ExeBase(HINSTANCE hInstance)
    4248                 : Win32ImageBase(hInstance),
    … …  
    6773  fExeStarted  = TRUE;
    6874
     75  //Note: The Win32 exception structure references by FS:[0] is the same
     76  //      in OS/2
     77  OS2SetExceptionHandler((void *)&exceptFrame);
     78  SetWin32TIB();
     79
    6980  //Allocate TLS index for this module
    7081  tlsAlloc();
    7182  tlsAttachThread();    //setup TLS (main thread)
    7283
    73   //Note: The Win32 exception structure references by FS:[0] is the same
    74   //      in OS/2
    75   OS2SetExceptionHandler((void *)&exceptFrame);
    76 
    77   SetWin32TIB();
    7884  rc = ((WIN32EXEENTRY)entryPoint)();
    7985  RestoreOS2TIB();

  • trunk/src/kernel32/wintls.cpp

    r956 r1670  
    1 /* $Id: wintls.cpp,v 1.5 1999-09-15 23:38:02 sandervl Exp $ */
     1/* $Id: wintls.cpp,v 1.6 1999-11-09 19:22:33 sandervl Exp $ */
    22/*
    33 * Win32 TLS API functions
    … …  
    5454 EXCEPTION_FRAME exceptFrame;
    5555 PIMAGE_TLS_CALLBACK *pCallback;
    56  USHORT sel;
    5756 TEB   *winteb;
    5857 char  *tibmem;
    … …  
    9291                dprintf(("tlsAttachThread: calling TLS Callback %x", *pCallback));
    9392
    94                 OS2SetExceptionHandler((void *)&exceptFrame);   
    95                 sel = SetWin32TIB();
    9693                (*pCallback)((LPVOID)hinstance, DLL_THREAD_ATTACH, 0);
    97                 SetFS(sel);
    98                 OS2UnsetExceptionHandler((void *)&exceptFrame);
    9994
    10095                dprintf(("tlsAttachThread: finished calling TLS Callback %x", *pCallback));
    … …  
    110105 EXCEPTION_FRAME exceptFrame;
    111106 PIMAGE_TLS_CALLBACK *pCallback;
    112  USHORT sel;
    113107 TEB   *winteb;
    114108
    … …  
    123117                dprintf(("tlsDetachThread: calling TLS Callback %x", *pCallback));
    124118
    125                 OS2SetExceptionHandler((void *)&exceptFrame);   
    126                 sel = SetWin32TIB();
    127119                (*pCallback)((LPVOID)hinstance, DLL_THREAD_DETACH, 0);
    128                 SetFS(sel);
    129                 OS2UnsetExceptionHandler((void *)&exceptFrame);
    130120
    131121                dprintf(("tlsDetachThread: finished calling TLS Callback %x", *pCallback));

  • trunk/src/kernel32/wprocess.cpp

    r1663 r1670  
    1 /* $Id: wprocess.cpp,v 1.45 1999-11-09 14:19:47 sandervl Exp $ */
     1/* $Id: wprocess.cpp,v 1.46 1999-11-09 19:22:33 sandervl Exp $ */
    22
    33/*
    … …  
    5757TEB *WIN32API GetThreadTEB()
    5858{
     59  if(TIBFlatPtr == NULL)
     60        return 0;
     61
    5962  return (TEB *)*TIBFlatPtr;
    6063}
    … …  
    6669 THDB *thdb;
    6770
     71  if(TIBFlatPtr == NULL)
     72        return 0;
     73
    6874  winteb = (TEB *)*TIBFlatPtr;
    6975  if(winteb == NULL) {
    70    return NULL;
     76        return NULL;
    7177  }
    7278  thdb = (THDB *)(winteb+1);
    … …  
    370376  dprintf(("KERNEL32:  LoadLibraryA(%s)\n",
    371377           lpszLibFile));
    372   dprintf(("KERNEL32: LoadLibrary FS = %x\n", GetFS()));
     378  dprintf(("KERNEL32: LoadLibrary %x FS = %x\n", GetCurrentThreadId(), GetFS()));
    373379
    374380  hDll = iLoadLibraryA(lpszLibFile, 0);
Note: See TracChangeset for help on using the changeset viewer.