Changeset 114 for trunk/src


Ignore:
Timestamp:
Jun 17, 1999, 11:52:01 PM (26 years ago)
Author:
phaller
Message:

Fix: preparing support for HandleManager on kernel objects

Location:
trunk/src/kernel32
Files:
1 added
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/HandleManager.cpp

    r111 r114  
    1 /* $Id: HandleManager.cpp,v 1.3 1999-06-17 18:21:35 phaller Exp $ */
     1/* $Id: HandleManager.cpp,v 1.4 1999-06-17 21:52:00 phaller Exp $ */
    22
    33/*
    … …  
    894894  if (-1 == iIndex)                                               /* error ? */
    895895  {
    896     SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
    897     return (FALSE);                                        /* signal failure */
     896    //@@@PH it may occur someone closes e.g. a semaphore handle
     897    // which is not registered through the HandleManager yet.
     898    // so we try to pass on to Open32 instead.
     899    dprintf(("KERNEL32: HandleManager:HMCloseHandle(%08xh) passed on to Open32.\n",
     900             hObject));
     901
     902    fResult = O32_CloseHandle(hObject);
     903    return (fResult);
     904
     905    //SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     906    //return (FALSE);                                        /* signal failure */
    898907  }
    899908

  • trunk/src/kernel32/KERNEL32.CPP

    r111 r114  
    1 /* $Id: KERNEL32.CPP,v 1.5 1999-06-17 18:21:36 phaller Exp $ */
     1/* $Id: KERNEL32.CPP,v 1.6 1999-06-17 21:52:00 phaller Exp $ */
    22
    33/*
    … …  
    4646
    4747/*****************************************************************************
    48  * Name      : BOOL WIN32API CreateEventA
    49  * Purpose   : forward call to Open32
    50  * Parameters:
    51  * Variables :
    52  * Result    :
    53  * Remark    :
    54  * Status    :
    55  *
    56  * Author    : Patrick Haller [Fri, 1998/06/12 03:44]
    57  *****************************************************************************/
    58 
    59 HANDLE WIN32API CreateEventA(LPSECURITY_ATTRIBUTES lpsa,
    60                                 BOOL                  fManualReset,
    61                                 BOOL                  fInitialState,
    62                                 LPCTSTR               lpszEventName)
    63 {
    64   ULONG  rc;                                               /* API returncode */
    65   HANDLE hOS2;                                         /* 32-bit OS/2 handle */
    66   HANDLE hWindows;                                  /* 16-bit Windows handle */
    67 
    68   dprintf(("KERNEL32::CreateEventA(%08xh, %08xh, %08xh, %s)\n",
    69            lpsa,
    70            fManualReset,
    71            fInitialState,
    72            lpszEventName));
    73 
    74   hOS2 = O32_CreateEvent(lpsa,                         /* create event semaphore */
    75                      fManualReset,
    76                      fInitialState,
    77                      lpszEventName);
    78   if (hOS2 != 0)                                             /* check handle */
    79   {
    80     rc = HMHandleAllocate(&hWindows,                      /* allocate handle */
    81                           hOS2);
    82     if (rc == NO_ERROR)                                  /* check for errors */
    83       return (hWindows);                         /* return translated handle */
    84     else
    85       return (0);                                   /* raise error condition */
    86   }
    87 
    88   return (hOS2);                 /* should have the correct error value here */
    89 }
    90 
    91 /*****************************************************************************
    9248 * Name      : BOOL WIN32API CloseHandle
    9349 * Purpose   : forward call to Open32
    … …  
    10965
    11066
    111 /*****************************************************************************
    112  * Name      : BOOL WIN32API CreateEventW
    113  * Purpose   : forward call to Open32
    114  * Parameters:
    115  * Variables :
    116  * Result    :
    117  * Remark    : handle translation is done in CreateEventA
    118  * Status    :
    119  *
    120  * Author    : Patrick Haller [Fri, 1998/06/12 03:44]
    121  *****************************************************************************/
    122 
    123 HANDLE WIN32API CreateEventW(PSECURITY_ATTRIBUTES arg1,
    124                              BOOL                 arg2,
    125                              BOOL                 arg3,
    126                              LPCWSTR               arg4)
    127 {
    128   HANDLE rc;
    129   char  *astring;
    130 
    131   dprintf(("KERNEL32::CreateEventW>(%08xh, %08xh, %08xh, %s)\n",
    132            arg1,
    133            arg2,
    134            arg3,
    135            arg4));
    136 
    137   astring = UnicodeToAsciiString((LPWSTR)arg4);
    138 
    139   rc = O32_CreateEvent(arg1,
    140                    arg2,
    141                    arg3,
    142                    astring);
    143 
    144   FreeAsciiString(astring);
    145 
    146   return(rc);
    147 }
    148 ///@@@PH handlemanager
    149 //******************************************************************************
    150 //******************************************************************************
    151 HANDLE WIN32API CreateMutexA(LPSECURITY_ATTRIBUTES lpsa,
    152                                 BOOL                  fInitialOwner,
    153                                 LPCTSTR               lpszMutexName)
    154 {
    155   dprintf(("KERNEL32:  CreateMutex\n"));
    156 
    157   return(O32_CreateMutex(lpsa,
    158                      fInitialOwner,
    159                      lpszMutexName));
    160 }
    161 //******************************************************************************
    162 //******************************************************************************
    163 HANDLE WIN32API CreateMutexW(PSECURITY_ATTRIBUTES arg1,
    164                              BOOL                 arg2,
    165                              LPCWSTR              arg3)
    166 {
    167  HANDLE rc;
    168  char  *astring;
    169 
    170   dprintf(("KERNEL32:  OS2CreateMutexW\n"));
    171 
    172   astring = UnicodeToAsciiString((LPWSTR)arg3);
    173   rc = O32_CreateMutex(arg1,
    174                    arg2,
    175                    astring);
    176   FreeAsciiString(astring);
    177 
    178   return(rc);
    179 }
    180 //******************************************************************************
    18167//******************************************************************************
    18268HANDLE WIN32API GetModuleHandleA(LPCTSTR lpszModule)
    … …  
    218104//******************************************************************************
    219105//******************************************************************************
    220 BOOL WIN32API ReleaseMutex(HANDLE mutex)
    221 {
    222   dprintf(("KERNEL32:  ReleaseMutex\n"));
    223   return(O32_ReleaseMutex(mutex));
    224 }
    225 //******************************************************************************
    226 //******************************************************************************
    227 BOOL WIN32API SetEvent(HANDLE hEvent)
    228 {
    229   dprintf(("KERNEL32:  SetEvent\n"));
    230   return(O32_SetEvent(hEvent));
    231 }
    232 //******************************************************************************
    233 //******************************************************************************
    234106BOOL WIN32API SetStdHandle(DWORD  IDStdHandle,
    235107                              HANDLE hHandle)
    … …  
    273145  return(O32_TlsSetValue(index, val));
    274146}
    275 //******************************************************************************
    276 //******************************************************************************
    277 DWORD WIN32API WaitForSingleObject(HANDLE hObject,
    278                                       DWORD  timeout)
    279 {
    280   dprintf(("KERNEL32:  WaitForSingleObject (%08xh, %08xh)\n",
    281            hObject,
    282            timeout));
    283 
    284   return(O32_WaitForSingleObject(hObject,
    285                              timeout));
    286 }
    287 //******************************************************************************
    288 
    289 
    290 /*****************************************************************************
    291  * Name      : DWORD OS2WaitForSingleObjectEx
    292  * Purpose   : The WaitForSingleObjectEx function is an extended wait function
    293  *             that can be used to perform an alertable wait. This enables the
    294  *             function to return when the system queues an I/O completion
    295  *             routine to be executed by the calling thread. The function also
    296  *             returns when the specified object is in the signaled state or
    297  *             when the time-out interval elapses.
    298  * Parameters: HANDLE hObject     handle of object to wait for
    299  *             DWORD  dwTimeout   time-out interval in milliseconds
    300  *             BOOL   fAlertable  alertable wait flag
    301  * Variables :
    302  * Result    : 0xFFFFFFFF in case of error
    303  * Remark    : only really required for async I/O
    304  * Status    : UNTESTED STUB
    305  *
    306  * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
    307  *****************************************************************************/
    308 
    309 DWORD WIN32API WaitForSingleObjectEx(HANDLE hObject,
    310                                         DWORD        dwTimeout,
    311                                         BOOL         fAlertable)
    312 {
    313   dprintf(("Kernel32: WaitForSingleObjectEx(%08xh,%08xh,%08xh) not implemented correctly.\n",
    314            hObject,
    315            dwTimeout,
    316            fAlertable));
    317 
    318   return(O32_WaitForSingleObject(hObject,
    319                              dwTimeout));
    320 }
    321 
    322147//******************************************************************************
    323148//******************************************************************************
    … …  
    404229//******************************************************************************
    405230//******************************************************************************
    406 BOOL WIN32API FlushFileBuffers(HANDLE hFile)
    407 {
    408   dprintf(("KERNEL32:  FlushFileBuffers\n"));
    409   return(O32_FlushFileBuffers(hFile));
    410 }
    411 //******************************************************************************
    412 //******************************************************************************
    413231LONG WIN32API InterlockedDecrement(LPLONG lplVal)
    414232{
    … …  
    429247    dprintf(("KERNEL32:  InterlockedExchange\n"));
    430248    return O32_InterlockedExchange(arg1, arg2);
    431 }
    432 //******************************************************************************
    433 //******************************************************************************
    434 UINT WIN32API SetHandleCount(UINT cHandles)
    435 {
    436   dprintf(("KERNEL32:  GetHandleCount\n"));
    437   return(O32_SetHandleCount(cHandles));
    438249}
    439250//******************************************************************************
    … …  
    762573}
    763574//******************************************************************************
    764 //SvL: 24-6-'97 - Added
    765 //SvL: 28-6-'97: Fix for timeSetEvent in Red Alert Map Editor
    766 //******************************************************************************
    767 BOOL WIN32API DuplicateHandle(HANDLE srcprocess, HANDLE srchandle, HANDLE destprocess,
    768                                  PHANDLE desthandle, DWORD arg5, BOOL arg6, DWORD  arg7)
    769 {
    770  BOOL rc;
    771 
    772 #if 0
    773     //SvL:
    774     //If source & destination process are identical, just copy handle
    775     //(if target pointer != NULL)
    776     //timeSetEvent's timer handler expects to be called from another process,
    777     //but we just create a separate timer thread inside the client process
    778     if(srcprocess == destprocess) {
    779         if(desthandle != NULL)
    780                 *desthandle = srchandle;
    781         return(TRUE);
    782     }
    783 #endif
    784     rc = O32_DuplicateHandle(srcprocess, srchandle, destprocess, desthandle, arg5, arg6, arg7);
    785 ////    dprintf(("KERNEL32:  OS2DuplicateHandle returned %d\n", rc));
    786     return(rc);
    787 }
    788 //******************************************************************************
    789575//******************************************************************************
    790576BOOL WIN32API Beep( DWORD arg1, DWORD  arg2)
    … …  
    792578    dprintf(("KERNEL32:  OS2Beep\n"));
    793579    return O32_Beep(arg1, arg2);
    794 }
    795 //******************************************************************************
    796 //******************************************************************************
    797 HANDLE WIN32API CreateSemaphoreA(PSECURITY_ATTRIBUTES arg1, LONG arg2, LONG arg3, LPCSTR arg4)
    798 {
    799     dprintf(("KERNEL32:  OS2CreateSemaphoreA\n"));
    800     return O32_CreateSemaphore(arg1, arg2, arg3, (LPSTR)arg4);
    801 }
    802 //******************************************************************************
    803 //******************************************************************************
    804 HANDLE WIN32API CreateSemaphoreW(PSECURITY_ATTRIBUTES arg1,
    805                                  LONG arg2, LONG arg3,
    806                                  LPCWSTR arg4)
    807 {
    808  HANDLE rc;
    809  char   *astring;
    810 
    811     dprintf(("KERNEL32:  OS2CreateSemaphoreW"));
    812     astring = UnicodeToAsciiString((LPWSTR)arg4);
    813     rc = O32_CreateSemaphore(arg1, arg2, arg3, astring);
    814     FreeAsciiString(astring);
    815     return(rc);
    816580}
    817581//******************************************************************************
    … …  
    867631//******************************************************************************
    868632//******************************************************************************
    869 BOOL WIN32API GetOverlappedResult(HANDLE arg1, LPOVERLAPPED arg2, LPDWORD arg3, BOOL  arg4)
    870 {
    871     dprintf(("KERNEL32:  OS2GetOverlappedResult\n"));
    872     return O32_GetOverlappedResult(arg1, arg2, arg3, arg4);
    873 }
    874 //******************************************************************************
    875 //******************************************************************************
    876633BOOL WIN32API IsBadHugeReadPtr( const void * arg1, UINT  arg2)
    877634{
    … …  
    909666//******************************************************************************
    910667//******************************************************************************
    911 HANDLE WIN32API OpenEventA( DWORD arg1, BOOL arg2, LPCSTR  arg3)
    912 {
    913     dprintf(("KERNEL32:  OS2OpenEventA\n"));
    914     return O32_OpenEvent(arg1, arg2, arg3);
    915 }
    916 //******************************************************************************
    917 //******************************************************************************
    918 HANDLE WIN32API OpenEventW(DWORD dwDesiredAccess, BOOL bInheritHandle,
    919                            LPCWSTR lpName)
    920 {
    921  char  *asciiname;
    922  HANDLE rc;
    923 
    924     dprintf(("KERNEL32:  OS2OpenEventW\n"));
    925     asciiname = UnicodeToAsciiString((LPWSTR)lpName);
    926     rc = O32_OpenEvent(dwDesiredAccess, bInheritHandle, asciiname);
    927     FreeAsciiString(asciiname);
    928     return(rc);
    929 }
    930 //******************************************************************************
    931 //******************************************************************************
    932 HANDLE WIN32API OpenMutexA( DWORD arg1, BOOL arg2, LPCSTR  arg3)
    933 {
    934     dprintf(("KERNEL32:  OS2OpenMutexA\n"));
    935     return O32_OpenMutex(arg1, arg2, arg3);
    936 }
    937 //******************************************************************************
    938 //******************************************************************************
    939 HANDLE WIN32API OpenMutexW(DWORD dwDesiredAccess, BOOL bInheritHandle,
    940                            LPCWSTR lpName)
    941 {
    942  char  *asciiname;
    943  HANDLE rc;
    944 
    945     dprintf(("KERNEL32:  OS2OpenMutexW\n"));
    946     asciiname = UnicodeToAsciiString((LPWSTR)lpName);
    947     rc = O32_OpenMutex(dwDesiredAccess, bInheritHandle, asciiname);
    948     FreeAsciiString(asciiname);
    949     return(rc);
    950 }
    951 //******************************************************************************
    952 //******************************************************************************
    953668HANDLE WIN32API OpenProcess(DWORD arg1, BOOL arg2, DWORD arg3)
    954669{
    955670    dprintf(("KERNEL32:  OS2OpenProcess\n"));
    956671    return O32_OpenProcess(arg1, arg2, arg3);
    957 }
    958 //******************************************************************************
    959 //******************************************************************************
    960 HANDLE WIN32API OpenSemaphoreA( DWORD arg1, BOOL arg2, LPCSTR  arg3)
    961 {
    962     dprintf(("KERNEL32:  OS2OpenSemaphoreA"));
    963     return O32_OpenSemaphore(arg1, arg2, arg3);
    964 }
    965 //******************************************************************************
    966 //******************************************************************************
    967 HANDLE WIN32API OpenSemaphoreW(DWORD dwDesiredAccess, BOOL bInheritHandle,
    968                                LPCWSTR lpName)
    969 {
    970  char  *asciiname;
    971  HANDLE rc;
    972 
    973     dprintf(("KERNEL32:  OS2OpenSemaphoreW"));
    974     asciiname = UnicodeToAsciiString((LPWSTR)lpName);
    975     rc = O32_OpenSemaphore(dwDesiredAccess, bInheritHandle, asciiname);
    976     FreeAsciiString(asciiname);
    977     return(rc);
    978 }
    979 //******************************************************************************
    980 //******************************************************************************
    981 BOOL WIN32API PulseEvent( HANDLE arg1)
    982 {
    983     dprintf(("KERNEL32:  OS2PulseEvent\n"));
    984     return O32_PulseEvent(arg1);
    985 }
    986 //******************************************************************************
    987 //******************************************************************************
    988 BOOL WIN32API ReleaseSemaphore( HANDLE arg1, LONG arg2, PLONG  arg3)
    989 {
    990     dprintf(("KERNEL32:  OS2ReleaseSemaphore"));
    991     return O32_ReleaseSemaphore(arg1, arg2, arg3);
    992 }
    993 //******************************************************************************
    994 //******************************************************************************
    995 BOOL WIN32API ResetEvent(HANDLE arg1)
    996 {
    997   dprintf(("KERNEL32: ResetEvent(%08xh)\n",
    998            arg1));
    999 
    1000   return O32_ResetEvent(arg1);
    1001 }
    1002 //******************************************************************************
    1003 //******************************************************************************
    1004 DWORD WIN32API WaitForMultipleObjects( DWORD arg1, const HANDLE * arg2, BOOL arg3, DWORD  arg4)
    1005 {
    1006     dprintf(("KERNEL32:  OS2WaitForMultipleObjects"));
    1007     return O32_WaitForMultipleObjects(arg1, arg2, arg3, arg4);
    1008 }
    1009 
    1010 
    1011 /*****************************************************************************
    1012  * Name      : DWORD OS2WaitForMultipleObjectsEx
    1013  * Purpose   : The WaitForMultipleObjectsEx function is an extended wait
    1014  *             function that can be used to perform an alertable wait. This
    1015  *             enables the function to return when the system queues an I/O
    1016  *             completion routine to be executed by the calling thread. The
    1017  *             function also returns either when any one or when all of the
    1018  *             specified objects are in the signaled state, or when the
    1019  *             time-out interval elapses.
    1020  * Parameters: DWORD  cObjects    number of handles in handle array
    1021  *             HANDLE *lphObjects address of object-handle array
    1022  *             BOOL   fWaitAll    wait flag
    1023  *             DWORD  dwTimeout   time-out interval in milliseconds
    1024  *             BOOL   fAlertable  alertable wait flag
    1025  * Variables :
    1026  * Result    : 0xFFFFFFFF in case of error
    1027  * Remark    : only really required for async I/O
    1028  * Status    : UNTESTED STUB
    1029  *
    1030  * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
    1031  *****************************************************************************/
    1032 
    1033 DWORD WIN32API WaitForMultipleObjectsEx(DWORD        cObjects,
    1034                                            CONST HANDLE *lphObjects,
    1035                                            BOOL         fWaitAll,
    1036                                            DWORD        dwTimeout,
    1037                                            BOOL         fAlertable)
    1038 {
    1039   dprintf(("Kernel32: WaitForMultipleObjectsEx(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented correctly.\n",
    1040            cObjects,
    1041            lphObjects,
    1042            fWaitAll,
    1043            dwTimeout,
    1044            fAlertable));
    1045 
    1046   return(O32_WaitForMultipleObjects(cObjects,
    1047                                    lphObjects,
    1048                                    fWaitAll,
    1049                                    dwTimeout));
    1050672}
    1051673//******************************************************************************
    … …  
    14581080}
    14591081
    1460 HANDLE WIN32API ConvertToGlobalHandle(HANDLE hHandle)
    1461 //HANDLE WIN32API ConvertToGlobalHandle(HANDLE hHandle,
    1462 //                                      BOOL   fInherit)
    1463 {
    1464   return (hHandle);
    1465 }
    1466 
    14671082BOOL WIN32API FindCloseChangeNotification(HANDLE hChange)
    14681083{

  • trunk/src/kernel32/exceptions.cpp

    r100 r114  
    1 /* $Id: exceptions.cpp,v 1.3 1999-06-10 20:47:51 phaller Exp $ */
     1/* $Id: exceptions.cpp,v 1.4 1999-06-17 21:51:59 phaller Exp $ */
    22
    33/*
    … …  
    2323 *  __try{...}__finally{...}
    2424 *  statements is simply not documented by Microsoft. There could be different
    25  *  reasons for this: 
    26  *  One reason could be that they try to hide the fact that exception 
    27  *  handling in Win32 looks almost the same as in OS/2 2.x. 
     25 *  reasons for this:
     26 *  One reason could be that they try to hide the fact that exception
     27 *  handling in Win32 looks almost the same as in OS/2 2.x.
    2828 *  Another reason could be that Microsoft does not want others to write
    29  *  binary compatible implementations of the Win32 API (like us). 
    30  *
    31  *  Whatever the reason, THIS SUCKS!! Ensuring portabilty or future 
    32  *  compatability may be valid reasons to keep some things undocumented. 
    33  *  But exception handling is so basic to Win32 that it should be 
     29 *  binary compatible implementations of the Win32 API (like us).
     30 *
     31 *  Whatever the reason, THIS SUCKS!! Ensuring portabilty or future
     32 *  compatability may be valid reasons to keep some things undocumented.
     33 *  But exception handling is so basic to Win32 that it should be
    3434 *  documented!
    3535 *
    … …  
    3737 *  -Most functions need better parameter checking.
    3838 *  -I do not know how to handle exceptions within an exception handler.
    39  *   or what is done when ExceptionNestedException is returned from an 
     39 *   or what is done when ExceptionNestedException is returned from an
    4040 *   exception handler
    4141 *  -Real exceptions are not yet implemented. only the exception functions
    … …  
    310310      pszExceptionName = "Guard Page Violation";
    311311      sprintf(szData,
    312               "R/W %08x at %08x.",
     312              "R/W %08xh at %08xh.",
    313313              pERepRec->ExceptionInfo[0],
    314314              pERepRec->ExceptionInfo[1]);
    … …  
    334334        case XCPT_READ_ACCESS:
    335335           sprintf (szData,
    336                     "Read Access at address %08x",
     336                    "Read Access at address %08xh",
    337337                    pERepRec->ExceptionInfo[1]);
    338338           break;
    … …  
    567567
    568568  if (rc == NO_ERROR)
    569     dprintf(("%s (#%u), Obj #%u, Offset %08x\n",
     569    dprintf(("%s (#%u), obj #%u:%08x\n",
    570570             szModule,
    571571             ulModule,
    … …  
    602602
    603603  if (pCtxRec->ContextFlags & CONTEXT_INTEGER)         /* check flags */
    604     dprintf(("   EAX=%08x ESI=%08x\n"
    605              "   EBX=%08x EDI=%08x\n"
    606              "   ECX=%08x\n"
    607              "   EDX=%08x\n",
     604    dprintf(("   EAX=%08x EBX=%08x ESI=%08x\n"
     605             "   ECX=%08x EDX=%08x EDI=%08x\n",
    608606             pCtxRec->ctx_RegEax,
     607             pCtxRec->ctx_RegEbx,
    609608             pCtxRec->ctx_RegEsi,
    610              pCtxRec->ctx_RegEbx,
    611              pCtxRec->ctx_RegEdi,
    612609             pCtxRec->ctx_RegEcx,
    613              pCtxRec->ctx_RegEdx));
     610             pCtxRec->ctx_RegEdx,
     611             pCtxRec->ctx_RegEdi));
    614612
    615613  if (pCtxRec->ContextFlags & CONTEXT_SEGMENTS)        /* check flags */
    616     dprintf(("   DS=%08x\n"
    617              "   ES=%08x\n"
    618              "   FS=%08x\n"
    619              "   GS=%08x\n",
     614    dprintf(("   DS=%04x     ES=%08x"
     615             "   FS=%04x     GS=%04x\n",
    620616              pCtxRec->ctx_SegDs,
    621617              pCtxRec->ctx_SegEs,

  • trunk/src/kernel32/hmopen32.cpp

    r113 r114  
    1 /* $Id: hmopen32.cpp,v 1.2 1999-06-17 18:44:06 phaller Exp $ */
     1/* $Id: hmopen32.cpp,v 1.3 1999-06-17 21:52:01 phaller Exp $ */
    22
    33/*
    … …  
    1010 * Remark                                                                    *
    1111 *****************************************************************************
    12 
    13  - do CreateFile + OpenFile allocate handles
    14  - does CloseHandle remove the handle ?
    1512 */
    1613
     14//#define DEBUG_LOCAL
     15
     16#ifdef DEBUG_LOCAL
     17#  define dprintfl(a) dprintf(a)
     18#else
     19inline void ignore_dprintf(...){}
     20#  define dprintfl(a) ignore_dprintf(a)
     21#endif
    1722
    1823/*****************************************************************************
    … …  
    5560                                        ULONG         arg4)
    5661{
    57   dprintf(("KERNEL32: HandleManager::Open32::_DeviceRequest %s(%08x,%08x) - stub?\n",
     62  dprintfl(("KERNEL32: HandleManager::Open32::_DeviceRequest %s(%08x,%08x) - stub?\n",
    5863           lpHMDeviceName,
    5964           pHMHandleData,
    … …  
    8994  HFILE hTemplate;
    9095
    91   dprintf(("KERNEL32: HandleManager::Open32::CreateFile %s(%s,%08x,%08x,%08x) - stub?\n",
     96  dprintfl(("KERNEL32: HandleManager::Open32::CreateFile %s(%s,%08x,%08x,%08x) - stub?\n",
    9297           lpHMDeviceName,
    9398           lpFileName,
    … …  
    141146  BOOL bRC;
    142147
    143   dprintf(("KERNEL32: HandleManager::Open32::CloseHandle(%08x)\n",
     148  dprintfl(("KERNEL32: HandleManager::Open32::CloseHandle(%08x)\n",
    144149           pHMHandleData->hWinHandle));
    145150
    146151  bRC = O32_CloseHandle(pHMHandleData->hWinHandle);
    147152
    148   dprintf(("KERNEL32: HandleManager::Open32::CloseHandle returned %08xh\n",
     153  dprintfl(("KERNEL32: HandleManager::Open32::CloseHandle returned %08xh\n",
    149154           bRC));
    150155
    … …  
    177182  BOOL bRC;
    178183
    179   dprintf(("KERNEL32: HandleManager::Open32::ReadFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
     184  dprintfl(("KERNEL32: HandleManager::Open32::ReadFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
    180185           lpHMDeviceName,
    181186           pHMHandleData,
    … …  
    191196                     lpOverlapped);
    192197
    193   dprintf(("KERNEL32: HandleManager::Open32::ReadFile returned %08xh\n",
     198  dprintfl(("KERNEL32: HandleManager::Open32::ReadFile returned %08xh\n",
    194199           bRC));
    195200
    … …  
    222227  BOOL bRC;
    223228
    224   dprintf(("KERNEL32: HandleManager::Open32::WriteFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
     229  dprintfl(("KERNEL32: HandleManager::Open32::WriteFile %s(%08x,%08x,%08x,%08x,%08x) - stub?\n",
    225230           lpHMDeviceName,
    226231           pHMHandleData,
    … …  
    236241                      lpOverlapped);
    237242
    238   dprintf(("KERNEL32: HandleManager::Open32::WriteFile returned %08xh\n",
     243  dprintfl(("KERNEL32: HandleManager::Open32::WriteFile returned %08xh\n",
    239244           bRC));
    240245
    … …  
    257262DWORD HMDeviceOpen32Class::GetFileType(PHMHANDLEDATA pHMHandleData)
    258263{
    259   dprintf(("KERNEL32: HandleManager::Open32::GetFileType %s(%08x)\n",
     264  dprintfl(("KERNEL32: HandleManager::Open32::GetFileType %s(%08x)\n",
    260265           lpHMDeviceName,
    261266           pHMHandleData));
    … …  
    281286                                                      BY_HANDLE_FILE_INFORMATION* pHFI)
    282287{
    283   dprintf(("KERNEL32: HandleManager::Open32::GetFileInformationByHandle %s(%08xh,%08xh)\n",
     288  dprintfl(("KERNEL32: HandleManager::Open32::GetFileInformationByHandle %s(%08xh,%08xh)\n",
    284289           lpHMDeviceName,
    285290           pHMHandleData,
    … …  
    305310BOOL HMDeviceOpen32Class::SetEndOfFile(PHMHANDLEDATA pHMHandleData)
    306311{
    307   dprintf(("KERNEL32: HandleManager::Open32::SetEndOfFile %s(%08xh)\n",
     312  dprintfl(("KERNEL32: HandleManager::Open32::SetEndOfFile %s(%08xh)\n",
    308313           lpHMDeviceName,
    309314           pHMHandleData));
    … …  
    333338                                      LPFILETIME pFT3)
    334339{
    335   dprintf(("KERNEL32: HandleManager::Open32::SetFileTime %s(%08xh,%08xh,%08xh,%08xh)\n",
     340  dprintfl(("KERNEL32: HandleManager::Open32::SetFileTime %s(%08xh,%08xh,%08xh,%08xh)\n",
    336341           lpHMDeviceName,
    337342           pHMHandleData,
    … …  
    363368                                       PDWORD        pSize)
    364369{
    365   dprintf(("KERNEL32: HandleManager::Open32::GetFileSize %s(%08xh,%08xh)\n",
     370  dprintfl(("KERNEL32: HandleManager::Open32::GetFileSize %s(%08xh,%08xh)\n",
    366371           lpHMDeviceName,
    367372           pHMHandleData,
    … …  
    393398                                          DWORD         dwMoveMethod)
    394399{
    395   dprintf(("KERNEL32: HandleManager::Open32::SetFilePointer %s(%08xh,%08xh,%08xh,%08xh)\n",
     400  dprintfl(("KERNEL32: HandleManager::Open32::SetFilePointer %s(%08xh,%08xh,%08xh,%08xh)\n",
    396401           lpHMDeviceName,
    397402           pHMHandleData,
    … …  
    429434                                    DWORD         arg5)
    430435{
    431   dprintf(("KERNEL32: HandleManager::Open32::LockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
     436  dprintfl(("KERNEL32: HandleManager::Open32::LockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
    432437           lpHMDeviceName,
    433438           pHMHandleData,
    … …  
    471476{
    472477
    473   dprintf(("KERNEL32: HandleManager::Open32::LockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
     478  dprintfl(("KERNEL32: HandleManager::Open32::LockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
    474479           lpHMDeviceName,
    475480           pHMHandleData,
    … …  
    513518  HFILE hFile;
    514519
    515   dprintf(("KERNEL32: HandleManager::Open32::OpenFile %s(%s,%08x,%08x,%08x) - stub?\n",
     520  dprintfl(("KERNEL32: HandleManager::Open32::OpenFile %s(%s,%08x,%08x,%08x) - stub?\n",
    516521           lpHMDeviceName,
    517522           lpFileName,
    … …  
    556561                                      DWORD         arg5)
    557562{
    558   dprintf(("KERNEL32: HandleManager::Open32::UnlockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
     563  dprintfl(("KERNEL32: HandleManager::Open32::UnlockFile %s(%08xh,%08xh,%08xh,%08xh,%08xh)\n",
    559564           lpHMDeviceName,
    560565           pHMHandleData,
    … …  
    598603{
    599604
    600   dprintf(("KERNEL32: HandleManager::Open32::UnlockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
     605  dprintfl(("KERNEL32: HandleManager::Open32::UnlockFileEx %s(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
    601606           lpHMDeviceName,
    602607           pHMHandleData,

  • trunk/src/kernel32/makefile

    r111 r114  
    1 # $Id: makefile,v 1.5 1999-06-17 18:21:43 phaller Exp $
     1# $Id: makefile,v 1.6 1999-06-17 21:52:01 phaller Exp $
    22
    33#
    … …  
    2020
    2121OBJS = KERNEL32.OBJ \
     22       KOBJECTS.OBJ \
    2223       CONSOLE.OBJ \
    2324       CONIN.OBJ \
    … …  
    9899    $(PDWIN32_INCLUDE)\nameid.h
    99100
     101kobjects.obj: kobjects.cpp
     102
    100103comm.OBJ: \
    101104    .\comm.cpp \
Note: See TracChangeset for help on using the changeset viewer.