Changeset 6397 for trunk/src


Ignore:
Timestamp:
Jul 28, 2001, 8:04:35 PM (24 years ago)
Author:
sandervl
Message:

updates

Location:
trunk/src
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/gdi32/initgdi32.cpp

    r6375 r6397  
    8686         ParseLogStatusGDI32();
    8787
     88         InitializeKernel32();
    8889         if(InitRegionSpace() == FALSE) {
    8990                return 0UL;

  • trunk/src/kernel32/KERNEL32.CPP

    r5895 r6397  
    1 /* $Id: KERNEL32.CPP,v 1.68 2001-06-03 08:49:29 sandervl Exp $ */
     1/* $Id: KERNEL32.CPP,v 1.69 2001-07-28 18:03:36 sandervl Exp $ */
    22
    33/*
    … …  
    129129//******************************************************************************
    130130//******************************************************************************
    131 BOOL WIN32API IsBadCodePtr( FARPROC arg1)
    132 {
    133     dprintf(("KERNEL32:  IsBadCodePtr\n"));
    134     return O32_IsBadCodePtr(arg1);
     131BOOL WIN32API IsBadCodePtr(FARPROC pCode)
     132{
     133    dprintf(("KERNEL32: IsBadCodePtr %x", pCode));
     134    return O32_IsBadCodePtr(pCode);
    135135}
    136136//******************************************************************************
    … …  
    226226    dprintf(("dwAvailVirtual  %X\n", arg1->dwAvailVirtual));
    227227}
     228//******************************************************************************
     229//******************************************************************************
    228230BOOL WIN32API Beep( DWORD arg1, DWORD  arg2)
    229231{
    230     dprintf(("KERNEL32:  OS2Beep\n"));
    231     return O32_Beep(arg1, arg2);
    232 }
    233 //******************************************************************************
    234 //******************************************************************************
    235 VOID WIN32API FatalAppExitA( UINT arg1, LPCSTR  arg2)
    236 {
    237     dprintf(("KERNEL32:  OS2FatalAppExitA\n"));
    238     O32_FatalAppExit(arg1, arg2);
    239 }
    240 //******************************************************************************
    241 //******************************************************************************
    242 VOID WIN32API FatalAppExitW(UINT arg1, LPCWSTR arg2)
    243 {
    244  char *astring;
    245 
    246     dprintf(("KERNEL32: OS2FatalAppExitW %x", arg1));
    247     astring = UnicodeToAsciiString((LPWSTR)arg2);
    248     O32_FatalAppExit(arg1, astring);
    249     //probably won't return, but who cares..
    250     FreeAsciiString(astring);
    251 }
    252 //******************************************************************************
    253 //******************************************************************************
    254 VOID WIN32API FatalExit( UINT arg1)
    255 {
    256     dprintf(("KERNEL32: FatalExit %x", arg1));
    257     O32_FatalExit(arg1);
     232    dprintf(("KERNEL32: Beep %d %d", arg1, arg2));
     233    return OSLibDosBeep(arg1, arg2);
     234}
     235//******************************************************************************
     236//******************************************************************************
     237
     238typedef INT (WINAPI *MessageBoxA_funcptr)(HWND,LPCSTR,LPCSTR,UINT);
     239typedef INT (WINAPI *MessageBoxW_funcptr)(HWND,LPCWSTR,LPCWSTR,UINT);
     240
     241//******************************************************************************
     242//******************************************************************************
     243VOID WIN32API FatalAppExitA( UINT exitCode, LPCSTR  str)
     244{
     245    HMODULE mod = GetModuleHandleA( "user32.dll" );
     246    MessageBoxA_funcptr pMessageBoxA = NULL;
     247
     248    dprintf(("KERNEL32: FatalAppExitA %d %s", exitCode, str));
     249
     250    if (mod) pMessageBoxA = (MessageBoxA_funcptr)GetProcAddress( mod, "MessageBoxA" );
     251    if(pMessageBoxA) pMessageBoxA( 0, str, NULL, MB_SYSTEMMODAL | MB_OK );
     252
     253    ExitProcess(exitCode);
     254}
     255//******************************************************************************
     256//******************************************************************************
     257VOID WIN32API FatalAppExitW(UINT exitCode, LPCWSTR str)
     258{
     259    HMODULE mod = GetModuleHandleA( "user32.dll" );
     260    MessageBoxW_funcptr pMessageBoxW = NULL;
     261
     262    dprintf(("KERNEL32: FatalAppExitW %d %ls", exitCode, str));
     263
     264    if (mod) pMessageBoxW = (MessageBoxW_funcptr)GetProcAddress( mod, "MessageBoxW" );
     265    if(pMessageBoxW) pMessageBoxW( 0, str, NULL, MB_SYSTEMMODAL | MB_OK );
     266
     267    ExitProcess(exitCode);
     268}
     269//******************************************************************************
     270//******************************************************************************
     271VOID WIN32API FatalExit( UINT exitCode)
     272{
     273    dprintf(("KERNEL32: FatalExit %x", exitCode));
     274    ExitProcess(exitCode);
    258275}
    259276//******************************************************************************
    … …  
    261278BOOL WIN32API IsBadHugeReadPtr( const void * arg1, UINT  arg2)
    262279{
    263     dprintf(("KERNEL32:  OS2IsBadHugeReadPtr\n"));
    264     return O32_IsBadHugeReadPtr(arg1, arg2);
     280    return IsBadReadPtr(arg1, arg2);
    265281}
    266282//******************************************************************************
    … …  
    268284BOOL WIN32API IsBadHugeWritePtr( PVOID arg1, UINT  arg2)
    269285{
    270     dprintf(("KERNEL32: IsBadHugeWritePtr\n"));
    271     return O32_IsBadHugeWritePtr(arg1, arg2);
     286    return IsBadWritePtr(arg1, arg2);
    272287}
    273288//******************************************************************************

  • trunk/src/kernel32/KERNEL32.DEF

    r6388 r6397  
    1 ; $Id: KERNEL32.DEF,v 1.116 2001-07-22 18:13:08 sandervl Exp $
     1; $Id: KERNEL32.DEF,v 1.117 2001-07-28 18:03:36 sandervl Exp $
    22
    33;Basis is Windows95 KERNEL32
    … …  
    11641164    _Odin32GetBuildNumber@0                                       @1293 NONAME
    11651165
     1166    _AttachThreadInput@12                                         @1300 NONAME
     1167    _WaitForInputIdle@8                                           @1301 NONAME
     1168
     1169    InitializeKernel32                                            @1302 NONAME
     1170
    11661171    IsExeStarted__Fv                                              @2001 NONAME
    11671172    CheckCurFS                                                    @2002 NONAME

  • trunk/src/kernel32/heap.cpp

    r6354 r6397  
    1 /* $Id: heap.cpp,v 1.32 2001-07-17 12:10:21 sandervl Exp $ */
     1/* $Id: heap.cpp,v 1.33 2001-07-28 18:03:37 sandervl Exp $ */
    22
    33/*
    … …  
    8282  //Create Open32 heap for it's handle
    8383  dprintf2(("HeapCreate dwInitialSize %X", dwInitialSize));
    84   HANDLE hHeap = O32_HeapCreate(flOptions, 0, 4096);
    85   if(hHeap == NULL)
    86     return(NULL);
    87 
    88   curheap = new OS2Heap(hHeap, flOptions, dwInitialSize, dwMaximumSize);
     84
     85  curheap = new OS2Heap(flOptions, dwInitialSize, dwMaximumSize);
    8986
    9087  if(curheap == NULL)
    9188  {
    92         O32_HeapDestroy(hHeap);
    9389        return(NULL);
    9490  }
    … …  
    9692  if(curheap->getHeapHandle() == NULL)
    9793  {
    98     O32_HeapDestroy(hHeap);
    9994    delete(curheap);
    10095    return(NULL);
    … …  
    112107        return(FALSE);
    113108
    114   O32_HeapDestroy(curheap->getHeapHandle());
    115109  delete(curheap);
    116110  return(TRUE);
    … …  
    178172    //SvL: Only one process heap per process
    179173    if(processheap == NULL) {
    180       //TODO: I haven't thought real hard about this.  I added it just to make "hdr.exe" happy.
    181       hHeap = O32_HeapCreate(HEAP_GENERATE_EXCEPTIONS, 1, 0x4000);
    182 
    183       OS2ProcessHeap = new OS2Heap(hHeap, HEAP_GENERATE_EXCEPTIONS, 0x4000, 0);
     174      OS2ProcessHeap = new OS2Heap(HEAP_GENERATE_EXCEPTIONS, 0x4000, 0);
    184175
    185176      if(OS2ProcessHeap == NULL) {
    186                 O32_HeapDestroy(hHeap);
    187177                return(NULL);
    188178      }
    189       processheap = hHeap;
     179      processheap = OS2ProcessHeap->getHeapHandle();
    190180    }
    191181    return(processheap);

  • trunk/src/kernel32/initkernel32.cpp

    r6375 r6397  
    8989    APIRET rc;
    9090    ULONG  ulSysinfo, version[2];
     91    static BOOL fInit = FALSE;
    9192   
    9293    /*-------------------------------------------------------------------------*/
    … …  
    9697    /*-------------------------------------------------------------------------*/
    9798
     99    if(fInit == TRUE && ulFlag == 0) {
     100        return 1; //already initialized
     101    }
     102    fInit = TRUE;
    98103    switch (ulFlag)
    99104    {
    … …  
    229234    return ;
    230235}
     236//******************************************************************************
     237ULONG APIENTRY O32__DLL_InitTerm(ULONG handle, ULONG flag);
     238//******************************************************************************
     239ULONG APIENTRY InitializeKernel32()
     240{
     241    HMODULE hModule;
     242
     243    DosQueryModuleHandle("WGSS50", &hModule);
     244    O32__DLL_InitTerm(hModule, 0);
     245    DosQueryModuleHandle("KERNEL32", &hModule);
     246    return inittermKernel32(hModule, 0);
     247}
     248//******************************************************************************
     249//******************************************************************************

  • trunk/src/kernel32/os2heap.cpp

    r6366 r6397  
    1 /* $Id: os2heap.cpp,v 1.21 2001-07-19 20:00:56 sandervl Exp $ */
     1/* $Id: os2heap.cpp,v 1.22 2001-07-28 18:03:38 sandervl Exp $ */
    22
    33/*
    … …  
    4747//******************************************************************************
    4848//******************************************************************************
    49 OS2Heap::OS2Heap(HANDLE hHeap, DWORD flOptions, DWORD dwInitialSize, DWORD dwMaximumSize)
     49OS2Heap::OS2Heap(DWORD flOptions, DWORD dwInitialSize, DWORD dwMaximumSize)
    5050{
    5151 OS2Heap *curheap = OS2Heap::heap;
    5252
    53   hPrimaryHeap = hHeap;
    5453  totalAlloc   = 0;
    5554  fInitialized = 0;
    … …  
    9998        DebugInt3();
    10099  }
     100  hPrimaryHeap = (HANDLE)uheap;
    101101}
    102102//******************************************************************************

  • trunk/src/kernel32/os2heap.h

    r6354 r6397  
    1 /* $Id: os2heap.h,v 1.6 2001-07-17 12:10:22 sandervl Exp $ */
     1/* $Id: os2heap.h,v 1.7 2001-07-28 18:03:38 sandervl Exp $ */
    22
    33/*
    … …  
    3737{
    3838public:
    39     OS2Heap(HANDLE hHeap, DWORD flOptions, DWORD dwInitialSize, DWORD dwMaximumSize);
     39    OS2Heap(DWORD flOptions, DWORD dwInitialSize, DWORD dwMaximumSize);
    4040    ~OS2Heap();
    4141

  • trunk/src/kernel32/oslibdos.cpp

    r6094 r6397  
    1 /* $Id: oslibdos.cpp,v 1.71 2001-06-24 16:40:44 sandervl Exp $ */
     1/* $Id: oslibdos.cpp,v 1.72 2001-07-28 18:03:38 sandervl Exp $ */
    22/*
    33 * Wrappers for OS/2 Dos* API
    … …  
    26032603//******************************************************************************
    26042604//******************************************************************************
     2605BOOL OSLibDosBeep(DWORD ulFreq, DWORD ulDuration)
     2606{
     2607   APIRET   rc;
     2608
     2609   if (ulDuration == -1)
     2610   {
     2611      SetLastError(ERROR_NOT_SUPPORTED_W);
     2612      return FALSE;
     2613   }
     2614   rc = DosBeep(ulFreq, ulDuration);
     2615   SetLastError(error2WinError(rc,ERROR_INVALID_HANDLE));
     2616
     2617   return (rc == 0);
     2618}
     2619//******************************************************************************
     2620//******************************************************************************
     2621ULONG OSLibDosGetModuleFileName(HMODULE hModule, LPTSTR lpszPath, DWORD cchPath)
     2622{
     2623   PTIB pTIB;
     2624   PPIB pPIB;
     2625   APIRET rc;
     2626
     2627   if(hModule == -1 || hModule == 0)
     2628   {
     2629      DosGetInfoBlocks(&pTIB, &pPIB);
     2630      hModule = pPIB->pib_hmte;
     2631   }
     2632   *lpszPath = 0;
     2633   rc = DosQueryModuleName(hModule, cchPath, lpszPath);
     2634
     2635   DWORD len = strlen(lpszPath);
     2636   SetLastError(error2WinError(rc,ERROR_INVALID_HANDLE));
     2637   return len;
     2638}
     2639//******************************************************************************
     2640//******************************************************************************
     2641ULONG OSLibDosGetProcAddress(HMODULE hModule, LPCSTR lpszProc)
     2642{
     2643   APIRET  rc;
     2644   PFN     pfn = NULL;
     2645   ULONG   ordinal = (((ULONG)lpszProc) <= 0xFFFF) ? (ULONG)lpszProc : 0;
     2646   HMODULE hmod = (HMODULE)hModule;
     2647
     2648   rc = DosQueryProcAddr( hmod, ordinal, (PSZ)lpszProc, &pfn );
     2649   if(rc == ERROR_INVALID_HANDLE && pfn == NULL) {
     2650      CHAR pszError[32], pszModule[CCHMAXPATH];
     2651
     2652      if(DosQueryModuleName( hmod, CCHMAXPATH, pszModule ) == 0 &&
     2653         DosLoadModule( pszError, 32, pszModule, &hmod ) == 0)
     2654      {
     2655          rc = DosQueryProcAddr(hmod, ordinal, (PSZ)lpszProc, &pfn);
     2656      }
     2657   }
     2658   SetLastError(error2WinError(rc,ERROR_INVALID_HANDLE));
     2659
     2660   return (ULONG)pfn;
     2661}
     2662//******************************************************************************
     2663//******************************************************************************

  • trunk/src/kernel32/oslibdos.h

    r6094 r6397  
    1 /* $Id: oslibdos.h,v 1.34 2001-06-24 16:40:45 sandervl Exp $ */
     1/* $Id: oslibdos.h,v 1.35 2001-07-28 18:03:38 sandervl Exp $ */
    22
    33/*
    … …  
    311311HINSTANCE OSLibDosLoadModule(LPSTR szModName);
    312312void      OSLibDosFreeModule(HINSTANCE hinst);
     313
     314ULONG OSLibDosGetModuleFileName(HMODULE hModule, LPTSTR lpszPath, DWORD cchPath);
     315BOOL  OSLibDosBeep(DWORD ulFreq, DWORD ulDuration);
     316ULONG OSLibDosGetProcAddress(HMODULE hModule, LPCSTR lpszProc);

  • trunk/src/kernel32/wprocess.cpp

    r6340 r6397  
    1 /* $Id: wprocess.cpp,v 1.130 2001-07-15 15:18:58 sandervl Exp $ */
     1/* $Id: wprocess.cpp,v 1.131 2001-07-28 18:03:38 sandervl Exp $ */
    22
    33/*
    … …  
    14191419        //only needed for call inside kernel32's initterm (profile init)
    14201420        //(console init only it seems...)
    1421         cch = O32_GetModuleFileName(hModule, lpszPath, cchPath);
     1421        cch = OSLibDosGetModuleFileName(hModule, lpszPath, cchPath);
    14221422        if (cch > 0)    cch++;          /* Open32 doesn't count the terminator. */
    14231423    }
    … …  
    18741874    }
    18751875    else {
    1876         rc = O32_WaitForInputIdle(procinfo.hProcess, 15000);
     1876        dprintf(("Calling WaitForInputIdle %x %d", procinfo.hProcess, 15000));
     1877        rc = WaitForInputIdle(procinfo.hProcess, 15000);
     1878#ifdef DEBUG
    18771879        if(rc != 0) {
    18781880            dprintf(("WinExec: WaitForInputIdle %x returned %x", procinfo.hProcess, rc));
    18791881        }
     1882        else dprintf(("WinExec: WaitForInputIdle successfull"));
     1883#endif
    18801884    }
    18811885    CloseHandle(procinfo.hThread);
    18821886    CloseHandle(procinfo.hProcess);
    18831887    return 33;
     1888}
     1889//******************************************************************************
     1890//DWORD idAttach;   /* thread to attach */
     1891//DWORD idAttachTo; /* thread to attach to  */
     1892//BOOL fAttach; /* attach or detach */
     1893//******************************************************************************
     1894BOOL WIN32API AttachThreadInput(DWORD idAttach, DWORD idAttachTo, BOOL fAttach)
     1895{
     1896  dprintf(("USER32: AttachThreadInput, not implemented\n"));
     1897  return(TRUE);
     1898}
     1899//******************************************************************************
     1900//******************************************************************************
     1901DWORD WIN32API WaitForInputIdle(HANDLE hProcess, DWORD dwTimeOut)
     1902{
     1903  dprintf(("USER32: WaitForInputIdle %x %d\n", hProcess, dwTimeOut));
     1904
     1905  if(fVersionWarp3) {
     1906        Sleep(1000);
     1907        return 0;       
     1908  }
     1909  else  return O32_WaitForInputIdle(hProcess, dwTimeOut);
    18841910}
    18851911//******************************************************************************
    … …  
    19511977    {
    19521978        /* Give 15 seconds to the app to come up */
    1953         if ( O32_WaitForInputIdle ( info.hProcess, 15000 ) ==  0xFFFFFFFF )
     1979        if ( WaitForInputIdle ( info.hProcess, 15000 ) ==  0xFFFFFFFF )
    19541980            dprintf(("ERROR: WaitForInputIdle failed: Error %ld\n", GetLastError() ));
    19551981        hInstance = 33;
    … …  
    20002026        return proc;
    20012027  }
    2002   proc = O32_GetProcAddress(hModule, lpszProc);
     2028  proc = (FARPROC)OSLibDosGetProcAddress(hModule, lpszProc);
    20032029  if(HIWORD(lpszProc))
    20042030        dprintf(("KERNEL32:  GetProcAddress %s from %X returned %X\n", lpszProc, hModule, proc));

  • trunk/src/user32/inituser32.cpp

    r6375 r6397  
    8787         ParseLogStatusUSER32();
    8888
     89         InitializeKernel32();
     90
    8991         hInstanceUser32 = RegisterLxDll(hModule, 0, (PVOID)&_Resource_PEResTab,
    9092                                         USER32_MAJORIMAGE_VERSION, USER32_MINORIMAGE_VERSION,

  • trunk/src/user32/user32.cpp

    r6339 r6397  
    1 /* $Id: user32.cpp,v 1.109 2001-07-15 14:58:07 sandervl Exp $ */
     1/* $Id: user32.cpp,v 1.110 2001-07-28 18:02:50 sandervl Exp $ */
    22
    33/*
    … …  
    973973}
    974974
    975 /* Process and Thread Functions */
    976 
    977 //******************************************************************************
    978 //DWORD idAttach;   /* thread to attach */
    979 //DWORD idAttachTo; /* thread to attach to  */
    980 //BOOL fAttach; /* attach or detach */
    981 //******************************************************************************
    982 BOOL WIN32API AttachThreadInput(DWORD idAttach, DWORD idAttachTo, BOOL fAttach)
    983 {
    984   dprintf(("USER32:  AttachThreadInput, not implemented\n"));
    985   return(TRUE);
    986 }
    987 //******************************************************************************
    988 //******************************************************************************
    989 DWORD WIN32API WaitForInputIdle(HANDLE hProcess, DWORD dwTimeOut)
    990 {
    991   dprintf(("USER32: WaitForInputIdle %x %d\n", hProcess, dwTimeOut));
    992 
    993   if(fVersionWarp3) {
    994         Sleep(1000);
    995         return 0;       
    996   }
    997   else  return O32_WaitForInputIdle(hProcess, dwTimeOut);
    998 }
    999 
    1000975/* Help Functions */
    1001976

  • trunk/src/user32/window.cpp

    r6395 r6397  
    1 /* $Id: window.cpp,v 1.102 2001-07-28 13:43:54 sandervl Exp $ */
     1/* $Id: window.cpp,v 1.103 2001-07-28 18:02:50 sandervl Exp $ */
    22/*
    33 * Win32 window apis for OS/2
    … …  
    18721872
    18731873    hwnd = Win32ToOS2Handle(hWnd);
    1874     hwnd = OS2ToWin32Handle(O32_GetLastActivePopup(hwnd));
     1874////    hwnd = OS2ToWin32Handle(O32_GetLastActivePopup(hwnd));
    18751875
    18761876    dprintf(("GetLastActivePopup %x returned %x NOT CORRECTLY IMPLEMENTED", hWnd, hwnd));
    1877     return hwnd;
     1877    return 0;
    18781878}
    18791879//******************************************************************************
Note: See TracChangeset for help on using the changeset viewer.