Ignore:
Timestamp:
Oct 26, 1999, 11:43:00 PM (26 years ago)
Author:
phaller
Message:

Fix: debug info

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/kobjects.cpp

    r765 r1460  
    1 /* $Id: kobjects.cpp,v 1.4 1999-08-31 21:03:26 phaller Exp $ */
     1/* $Id: kobjects.cpp,v 1.5 1999-10-26 21:42:25 phaller Exp $ */
    22
    33/*
    … …  
    1414 * Includes                                                                  *
    1515 *****************************************************************************/
     16
     17#include <odin.h>
     18#include <odinwrap.h>
     19#include <os2sel.h>
     20
    1621#include <os2win.h>
    1722#include "misc.h"
    1823#include "handlemanager.h"
    1924
     25
     26ODINDEBUGCHANNEL(KERNEL32-KOBJECTS)
    2027
    2128
    … …  
    5461
    5562/*****************************************************************************
    56  * Name      : BOOL WIN32API CreateEventA
     63 * Name      : BOOL CreateEventA
    5764 * Purpose   : forward call to Open32
    5865 * Parameters:
    … …  
    6572 *****************************************************************************/
    6673
    67 HANDLE WIN32API CreateEventA(LPSECURITY_ATTRIBUTES lpsa,
    68                              BOOL                  fManualReset,
    69                              BOOL                  fInitialState,
    70                              LPCTSTR               lpszEventName)
    71 {
    72   dprintf(("KERNEL32: CreateEventA(%08xh, %08xh, %08xh, %s)\n",
    73            lpsa,
    74            fManualReset,
    75            fInitialState,
    76            lpszEventName));
    77 
     74ODINFUNCTION4(HANDLE, CreateEventA,
     75              LPSECURITY_ATTRIBUTES, lpsa,
     76              BOOL, fManualReset,
     77              BOOL, fInitialState,
     78              LPCTSTR, lpszEventName)
     79{
    7880  return(HMCreateEvent(lpsa,                         /* create event semaphore */
    7981                       fManualReset,
    … …  
    8486
    8587/*****************************************************************************
    86  * Name      : BOOL WIN32API CreateEventW
     88 * Name      : BOOL CreateEventW
    8789 * Purpose   : forward call to Open32
    8890 * Parameters:
    … …  
    9597 *****************************************************************************/
    9698
    97 HANDLE WIN32API CreateEventW(LPSECURITY_ATTRIBUTES arg1,
    98                              BOOL                  arg2,
    99                              BOOL                  arg3,
    100                              LPCWSTR               arg4)
     99ODINFUNCTION4(HANDLE, CreateEventW,
     100              LPSECURITY_ATTRIBUTES, arg1,
     101              BOOL, arg2,
     102              BOOL, arg3,
     103              LPCWSTR, arg4)
    101104{
    102105  HANDLE rc;
    103106  char  *astring;
    104107
    105   dprintf(("KERNEL32: CreateEventW(%08xh, %08xh, %08xh, %s)\n",
    106            arg1,
    107            arg2,
    108            arg3,
    109            arg4));
     108  dprintf(("KERNEL32: CreateEventW(%s)\n",
     109           astring));
    110110
    111111  astring = UnicodeToAsciiString((LPWSTR)arg4);
    … …  
    123123
    124124/*****************************************************************************
    125  * Name      : BOOL WIN32API CreateMutexA
     125 * Name      : BOOL CreateMutexA
    126126 * Purpose   : forward call to Open32
    127127 * Parameters:
    … …  
    134134 *****************************************************************************/
    135135
    136 HANDLE WIN32API CreateMutexA(LPSECURITY_ATTRIBUTES lpsa,
    137                               BOOL                  fInitialOwner,
    138                               LPCTSTR               lpszMutexName)
    139 {
    140   dprintf(("KERNEL32: CreateMutexA(%08xh,%08xh,%s)\n",
    141            lpsa,
    142            fInitialOwner,
     136ODINFUNCTION3(HANDLE, CreateMutexA,
     137              LPSECURITY_ATTRIBUTES, lpsa,
     138              BOOL, fInitialOwner,
     139              LPCTSTR, lpszMutexName)
     140{
     141  dprintf(("KERNEL32: CreateMutexA(%s)\n",
    143142           lpszMutexName));
    144143
    … …  
    150149
    151150/*****************************************************************************
    152  * Name      : BOOL WIN32API CreateMutexW
     151 * Name      : BOOL CreateMutexW
    153152 * Purpose   : forward call to Open32
    154153 * Parameters:
    … …  
    161160 *****************************************************************************/
    162161
    163 HANDLE WIN32API CreateMutexW(PSECURITY_ATTRIBUTES arg1,
    164                              BOOL                 arg2,
    165                              LPCWSTR              arg3)
     162ODINFUNCTION3(HANDLE, CreateMutexW,
     163              PSECURITY_ATTRIBUTES, arg1,
     164              BOOL, arg2,
     165              LPCWSTR, arg3)
    166166{
    167167  HANDLE rc;
    168168  char  *astring;
    169169
    170   dprintf(("KERNEL32: CreateMutexW(%08xh,%08xh,%08xh)\n",
    171            arg1,
    172            arg2,
    173            arg3));
    174 
    175170  astring = UnicodeToAsciiString((LPWSTR)arg3);
     171
     172  dprintf(("KERNEL32: CreateMutexW(%s)\n",
     173           astring));
     174
    176175  rc = HMCreateMutex(arg1,
    177176                     arg2,
    … …  
    184183
    185184/*****************************************************************************
    186  * Name      : BOOL WIN32API ReleaseMutex
     185 * Name      : BOOL ReleaseMutex
    187186 * Purpose   : forward call to Open32
    188187 * Parameters:
    … …  
    195194 *****************************************************************************/
    196195
    197 BOOL WIN32API ReleaseMutex(HANDLE mutex)
    198 {
    199   dprintf(("KERNEL32: ReleaseMutex%08xh)\n",
    200            mutex));
    201 
     196ODINFUNCTION1(BOOL, ReleaseMutex,
     197              HANDLE, mutex)
     198{
    202199  return(HMReleaseMutex(mutex));
    203200}
    … …  
    205202
    206203/*****************************************************************************
    207  * Name      : BOOL WIN32API SetEvent
     204 * Name      : BOOL SetEvent
    208205 * Purpose   : forward call to Open32
    209206 * Parameters:
    … …  
    216213 *****************************************************************************/
    217214
    218 BOOL WIN32API SetEvent(HANDLE hEvent)
    219 {
    220   dprintf(("KERNEL32: SetEvent(%08xh)\n",
    221            hEvent));
    222 
     215ODINFUNCTION1(BOOL, SetEvent,
     216              HANDLE, hEvent)
     217{
    223218  return(HMSetEvent(hEvent));
    224219}
    … …  
    226221
    227222/*****************************************************************************
    228  * Name      : BOOL WIN32API WaitForSingleObject
     223 * Name      : BOOL WaitForSingleObject
    229224 * Purpose   : forward call to Open32
    230225 * Parameters:
    … …  
    237232 *****************************************************************************/
    238233
    239 DWORD WIN32API WaitForSingleObject(HANDLE hObject,
    240                                    DWORD  timeout)
    241 {
    242   dprintf(("KERNEL32: WaitForSingleObject (%08xh, %08xh)\n",
    243            hObject,
    244            timeout));
    245 
     234ODINFUNCTION2(DWORD, WaitForSingleObject,
     235              HANDLE, hObject,
     236              DWORD, timeout)
     237{
    246238  return(HMWaitForSingleObject(hObject,
    247239                               timeout));
    … …  
    268260 *****************************************************************************/
    269261
    270 DWORD WIN32API WaitForSingleObjectEx(HANDLE hObject,
    271                                         DWORD        dwTimeout,
    272                                         BOOL         fAlertable)
     262ODINFUNCTION3(DWORD, WaitForSingleObjectEx,
     263              HANDLE, hObject,
     264              DWORD, dwTimeout,
     265              BOOL, fAlertable)
    273266{
    274267  dprintf(("Kernel32: WaitForSingleObjectEx(%08xh,%08xh,%08xh) not implemented correctly.\n",
    … …  
    284277
    285278/*****************************************************************************
    286  * Name      : BOOL WIN32API FlushFileBuffers
     279 * Name      : BOOL FlushFileBuffers
    287280 * Purpose   : forward call to Open32
    288281 * Parameters:
    … …  
    295288 *****************************************************************************/
    296289
    297 BOOL WIN32API FlushFileBuffers(HANDLE hFile)
    298 {
    299   dprintf(("KERNEL32: FlushFileBuffers(%08xh)\n",
    300            hFile));
    301 
     290ODINFUNCTION1(BOOL, FlushFileBuffers,
     291              HANDLE, hFile)
     292{
    302293  return(HMFlushFileBuffers(hFile));
    303294}
    … …  
    305296
    306297/*****************************************************************************
    307  * Name      : UINT WIN32API SetHandleCount
     298 * Name      : UINT SetHandleCount
    308299 * Purpose   : forward call to Open32
    309300 * Parameters:
    … …  
    316307 *****************************************************************************/
    317308
    318 UINT WIN32API SetHandleCount(UINT cHandles)
    319 {
    320   dprintf(("KERNEL32: SetHandleCount(%08xh)\n",
    321            cHandles));
    322 
     309ODINFUNCTION1(UINT, SetHandleCount,
     310              UINT, cHandles)
     311{
    323312  return(HMSetHandleCount(cHandles));
    324313}
    … …  
    326315
    327316/*****************************************************************************
    328  * Name      : BOOL WIN32API DuplicateHandle
     317 * Name      : BOOL DuplicateHandle
    329318 * Purpose   : forward call to Open32
    330319 * Parameters:
    … …  
    341330//SvL: 28-6-'97: Fix for timeSetEvent in Red Alert Map Editor
    342331//******************************************************************************
    343 BOOL WIN32API DuplicateHandle(HANDLE  srcprocess,
    344                               HANDLE  srchandle,
    345                               HANDLE  destprocess,
    346                               PHANDLE desthandle,
    347                               DWORD   arg5,
    348                               BOOL    arg6,
    349                               DWORD   arg7)
     332ODINFUNCTION7(BOOL, DuplicateHandle,
     333              HANDLE, srcprocess,
     334              HANDLE, srchandle,
     335              HANDLE, destprocess,
     336              PHANDLE, desthandle,
     337              DWORD, arg5,
     338              BOOL, arg6,
     339              DWORD, arg7)
    350340{
    351341  BOOL rc;
    352 
    353   dprintf(("KERNEL32: DuplicateHandle(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
    354            srcprocess,
    355            srchandle,
    356            destprocess,
    357            desthandle,
    358            arg5,
    359            arg6,
    360            arg7));
    361342
    362343  rc = HMDuplicateHandle(srcprocess,
    … …  
    382363
    383364/*****************************************************************************
    384  * Name      : BOOL WIN32API CreateSemaphoreA
     365 * Name      : BOOL CreateSemaphoreA
    385366 * Purpose   : forward call to Open32
    386367 * Parameters:
    … …  
    393374 *****************************************************************************/
    394375
    395 HANDLE WIN32API CreateSemaphoreA(LPSECURITY_ATTRIBUTES arg1,
    396                                  LONG                  arg2,
    397                                  LONG                  arg3,
    398                                  LPCSTR                arg4)
    399 {
    400   dprintf(("KERNEL32: CreateSemaphoreA(%08xh,%08xh,%08xh,%s)\n",
    401            arg1,
    402            arg2,
    403            arg3,
     376ODINFUNCTION4(HANDLE, CreateSemaphoreA,
     377              LPSECURITY_ATTRIBUTES, arg1,
     378              LONG, arg2,
     379              LONG, arg3,
     380              LPCSTR, arg4)
     381{
     382  dprintf(("KERNEL32: CreateSemaphoreA(%s)\n",
    404383           arg4));
    405384
    … …  
    412391
    413392/*****************************************************************************
    414  * Name      : BOOL WIN32API CreateSemaphoreW
     393 * Name      : BOOL CreateSemaphoreW
    415394 * Purpose   : forward call to Open32
    416395 * Parameters:
    … …  
    423402 *****************************************************************************/
    424403
    425 HANDLE WIN32API CreateSemaphoreW(PSECURITY_ATTRIBUTES arg1,
    426                                  LONG                 arg2,
    427                                  LONG                 arg3,
    428                                  LPCWSTR              arg4)
     404ODINFUNCTION4(HANDLE, CreateSemaphoreW,
     405              PSECURITY_ATTRIBUTES, arg1,
     406              LONG, arg2,
     407              LONG, arg3,
     408              LPCWSTR, arg4)
    429409{
    430410  HANDLE rc;
    431411  char   *astring;
    432412
    433   dprintf(("KERNEL32: CreateSemaphoreW(%08xh,%08xh,%08xh,%08xh)\n",
    434            arg1,
    435            arg2,
    436            arg3,
    437            arg4));
    438 
    439413  astring = UnicodeToAsciiString((LPWSTR)arg4);
     414
     415  dprintf(("KERNEL32: CreateSemaphoreW(%s)\n",
     416           astring));
     417
    440418  rc = HMCreateSemaphore(arg1,
    441419                         arg2,
    … …  
    448426
    449427/*****************************************************************************
    450  * Name      : BOOL WIN32API GetOverlappedResult
     428 * Name      : BOOL GetOverlappedResult
    451429 * Purpose   : forward call to Open32
    452430 * Parameters:
    … …  
    459437 *****************************************************************************/
    460438
    461 BOOL WIN32API GetOverlappedResult(HANDLE       arg1,
    462                                   LPOVERLAPPED arg2,
    463                                   LPDWORD      arg3,
    464                                   BOOL         arg4)
    465 {
    466   dprintf(("KERNEL32: GetOverlappedResult (%08xh,%08xh,%08xh,%08xh)\n",
    467            arg1,
    468            arg2,
    469            arg3,
    470            arg4));
    471 
     439ODINFUNCTION4(BOOL,         GetOverlappedResult,
     440              HANDLE,       arg1,
     441              LPOVERLAPPED, arg2,
     442              LPDWORD,      arg3,
     443              BOOL,         arg4)
     444{
    472445  return HMGetOverlappedResult(arg1,
    473446                               arg2,
    … …  
    478451
    479452/*****************************************************************************
    480  * Name      : BOOL WIN32API OpenEventA
     453 * Name      : BOOL OpenEventA
    481454 * Purpose   : forward call to Open32
    482455 * Parameters:
    … …  
    489462 *****************************************************************************/
    490463
    491 HANDLE WIN32API OpenEventA(DWORD  arg1,
    492                            BOOL   arg2,
    493                            LPCSTR arg3)
    494 {
    495   dprintf(("KERNEL32: OpenEventA(%08xh,%08xh,%s)\n",
    496            arg1,
    497            arg2,
     464ODINFUNCTION3(HANDLE, OpenEventA,
     465              DWORD,  arg1,
     466              BOOL,   arg2,
     467              LPCSTR, arg3)
     468{
     469  dprintf(("KERNEL32: OpenEventA(%s)\n",
    498470           arg3));
    499471
    … …  
    505477
    506478/*****************************************************************************
    507  * Name      : BOOL WIN32API OpenEventW
     479 * Name      : BOOL OpenEventW
    508480 * Purpose   : forward call to Open32
    509481 * Parameters:
    … …  
    516488 *****************************************************************************/
    517489
    518 HANDLE WIN32API OpenEventW(DWORD  dwDesiredAccess,
    519                            BOOL    bInheritHandle,
    520                            LPCWSTR lpName)
     490ODINFUNCTION3(HANDLE,  OpenEventW,
     491              DWORD,   dwDesiredAccess,
     492              BOOL,    bInheritHandle,
     493              LPCWSTR, lpName)
    521494{
    522495  char  *asciiname;
    523496  HANDLE rc;
    524497
    525   dprintf(("KERNEL32: OpenEventW(%08xh,%08xh,%08xh\n",
    526            dwDesiredAccess,
    527            bInheritHandle,
    528            lpName));
    529 
    530498  asciiname = UnicodeToAsciiString((LPWSTR)lpName);
     499
     500  dprintf(("KERNEL32: OpenEventW(%s)\n",
     501           asciiname));
     502
    531503  rc = HMOpenEvent(dwDesiredAccess,
    532504                   bInheritHandle,
    … …  
    538510
    539511/*****************************************************************************
    540  * Name      : BOOL WIN32API OpenMutexA
     512 * Name      : BOOL OpenMutexA
    541513 * Purpose   : forward call to Open32
    542514 * Parameters:
    … …  
    549521 *****************************************************************************/
    550522
    551 HANDLE WIN32API OpenMutexA(DWORD  arg1,
    552                            BOOL   arg2,
    553                            LPCSTR arg3)
    554 {
    555   dprintf(("KERNEL32: OpenMutexA(%08xh,%08xh,%s)\n",
    556            arg1,
    557            arg2,
     523ODINFUNCTION3(HANDLE, OpenMutexA,
     524              DWORD,  arg1,
     525              BOOL,   arg2,
     526              LPCSTR, arg3)
     527{
     528  dprintf(("KERNEL32: OpenMutexA(%s)\n",
    558529           arg3));
    559530
    … …  
    565536
    566537/*****************************************************************************
    567  * Name      : BOOL WIN32API OpenMutexW
     538 * Name      : BOOL OpenMutexW
    568539 * Purpose   : forward call to Open32
    569540 * Parameters:
    … …  
    576547 *****************************************************************************/
    577548
    578 HANDLE WIN32API OpenMutexW(DWORD   dwDesiredAccess,
    579                            BOOL    bInheritHandle,
    580                            LPCWSTR lpName)
     549ODINFUNCTION3(HANDLE,  OpenMutexW,
     550              DWORD,   dwDesiredAccess,
     551              BOOL,    bInheritHandle,
     552              LPCWSTR, lpName)
    581553{
    582554  char  *asciiname;
    583555  HANDLE rc;
    584556
    585   dprintf(("KERNEL32: OpenMutexW(%08xh,%08xh,%08xh)\n",
    586            dwDesiredAccess,
    587            bInheritHandle,
    588            lpName));
    589 
    590557  asciiname = UnicodeToAsciiString((LPWSTR)lpName);
     558
     559  dprintf(("KERNEL32: OpenMutexW(%s)\n",
     560           asciiname));
     561
    591562  rc = HMOpenMutex(dwDesiredAccess,
    592563                   bInheritHandle,
    … …  
    598569
    599570/*****************************************************************************
    600  * Name      : BOOL WIN32API OpenSemaphoreA
     571 * Name      : BOOL OpenSemaphoreA
    601572 * Purpose   : forward call to Open32
    602573 * Parameters:
    … …  
    609580 *****************************************************************************/
    610581
    611 HANDLE WIN32API OpenSemaphoreA(DWORD   arg1,
    612                                BOOL    arg2,
    613                                LPCSTR  arg3)
    614 {
    615   dprintf(("KERNEL32: OpenSemaphoreA(%08xh,%08xh,%s)\n",
    616            arg1,
    617            arg2,
     582ODINFUNCTION3(HANDLE, OpenSemaphoreA,
     583              DWORD,  arg1,
     584              BOOL,   arg2,
     585              LPCSTR, arg3)
     586{
     587  dprintf(("KERNEL32: OpenSemaphoreA(%s)\n",
    618588           arg3));
    619589
    … …  
    625595
    626596/*****************************************************************************
    627  * Name      : BOOL WIN32API OpenSemaphoreW
     597 * Name      : BOOL OpenSemaphoreW
    628598 * Purpose   : forward call to Open32
    629599 * Parameters:
    … …  
    636606 *****************************************************************************/
    637607
    638 HANDLE WIN32API OpenSemaphoreW(DWORD   dwDesiredAccess,
    639                                BOOL    bInheritHandle,
    640                                LPCWSTR lpName)
     608ODINFUNCTION3(HANDLE,  OpenSemaphoreW,
     609              DWORD,   dwDesiredAccess,
     610              BOOL,    bInheritHandle,
     611              LPCWSTR, lpName)
    641612{
    642613  char  *asciiname;
    643614  HANDLE rc;
    644615
    645   dprintf(("KERNEL32: OpenSemaphoreW(%08xh,%08xh,%08xh)\n",
    646            dwDesiredAccess,
    647            bInheritHandle,
    648            lpName));
    649 
    650616  asciiname = UnicodeToAsciiString((LPWSTR)lpName);
     617
     618  dprintf(("KERNEL32: OpenSemaphoreW(%s)\n",
     619           asciiname));
     620
    651621  rc = HMOpenSemaphore(dwDesiredAccess,
    652622                       bInheritHandle,
    … …  
    658628
    659629/*****************************************************************************
    660  * Name      : BOOL WIN32API PulseEvent
     630 * Name      : BOOL PulseEvent
    661631 * Purpose   : forward call to Open32
    662632 * Parameters:
    … …  
    669639 *****************************************************************************/
    670640
    671 BOOL WIN32API PulseEvent(HANDLE arg1)
    672 {
    673   dprintf(("KERNEL32: PulseEvent(%08xh)\n",
    674            arg1));
    675 
     641ODINFUNCTION1(BOOL, PulseEvent,
     642              HANDLE, arg1)
     643{
    676644  return HMPulseEvent(arg1);
    677645}
    … …  
    679647
    680648/*****************************************************************************
    681  * Name      : BOOL WIN32API ReleaseSemaphore
     649 * Name      : BOOL ReleaseSemaphore
    682650 * Purpose   : forward call to Open32
    683651 * Parameters:
    … …  
    690658 *****************************************************************************/
    691659
    692 BOOL WIN32API ReleaseSemaphore(HANDLE arg1,
    693                                LONG   arg2,
    694                                PLONG  arg3)
    695 {
    696   dprintf(("KERNEL32: ReleaseSemaphore(%08xh,%08xh,%08xh)\n",
    697            arg1,
    698            arg2,
    699            arg3));
    700 
     660ODINFUNCTION3(BOOL,   ReleaseSemaphore,
     661              HANDLE, arg1,
     662              LONG,   arg2,
     663              PLONG,  arg3)
     664{
    701665  return HMReleaseSemaphore(arg1,
    702666                            arg2,
    … …  
    706670
    707671/*****************************************************************************
    708  * Name      : BOOL WIN32API ResetEvent
     672 * Name      : BOOL ResetEvent
    709673 * Purpose   : forward call to Open32
    710674 * Parameters:
    … …  
    717681 *****************************************************************************/
    718682
    719 BOOL WIN32API ResetEvent(HANDLE arg1)
    720 {
    721   dprintf(("KERNEL32: ResetEvent(%08xh)\n",
    722            arg1));
    723 
     683ODINFUNCTION1(BOOL,   ResetEvent,
     684              HANDLE, arg1)
     685{
    724686  return HMResetEvent(arg1);
    725687}
    … …  
    727689
    728690/*****************************************************************************
    729  * Name      : BOOL WIN32API WaitForMultipleObjects
     691 * Name      : BOOL WaitForMultipleObjects
    730692 * Purpose   : forward call to Open32
    731693 * Parameters:
    … …  
    738700 *****************************************************************************/
    739701
    740 DWORD WIN32API WaitForMultipleObjects(DWORD        arg1,
    741                                       const HANDLE *arg2,
    742                                       BOOL         arg3,
    743                                       DWORD        arg4)
    744 {
    745   dprintf(("KERNEL32:  OS2WaitForMultipleObjects(%08xh,%08xh,%08xh,%08xh)\n",
    746            arg1,
    747            arg2,
    748            arg3,
    749            arg4));
    750 
     702ODINFUNCTION4(DWORD,          WaitForMultipleObjects,
     703              DWORD,          arg1,
     704              const HANDLE *, arg2,
     705              BOOL,           arg3,
     706              DWORD,          arg4)
     707{
    751708  return HMWaitForMultipleObjects(arg1,
    752709                                  (PHANDLE)arg2,
    … …  
    778735 *****************************************************************************/
    779736
    780 DWORD WIN32API WaitForMultipleObjectsEx(DWORD        cObjects,
    781                                            CONST HANDLE *lphObjects,
    782                                            BOOL         fWaitAll,
    783                                            DWORD        dwTimeout,
    784                                            BOOL         fAlertable)
    785 {
    786   dprintf(("Kernel32: WaitForMultipleObjectsEx(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented correctly.\n",
    787            cObjects,
    788            lphObjects,
    789            fWaitAll,
    790            dwTimeout,
    791            fAlertable));
    792 
     737ODINFUNCTION5(DWORD, WaitForMultipleObjectsEx,
     738              DWORD, cObjects,
     739              CONST HANDLE *, lphObjects,
     740              BOOL, fWaitAll,
     741              DWORD, dwTimeout,
     742              BOOL, fAlertable)
     743{
    793744  return(HMWaitForMultipleObjectsEx(cObjects,
    794745                                    (PHANDLE)lphObjects,
    … …  
    800751
    801752/*****************************************************************************
    802  * Name      : HANDLE WIN32API ConvertToGlobalHandle
     753 * Name      : HANDLE ConvertToGlobalHandle
    803754 * Purpose   : forward call to Open32
    804755 * Parameters:
    … …  
    811762 *****************************************************************************/
    812763
    813 HANDLE WIN32API ConvertToGlobalHandle(HANDLE hHandle)
    814 //HANDLE WIN32API ConvertToGlobalHandle(HANDLE hHandle,
    815 //                                      BOOL   fInherit)
    816 {
    817   dprintf(("KERNEL32: ConvertToGlobalHandle(%08xh)\n",
    818            hHandle));
    819 
     764ODINFUNCTION1(HANDLE, ConvertToGlobalHandle,
     765              HANDLE, hHandle)
     766
     767//ODINFUNCTION2(HANDLE, ConvertToGlobalHandle,
     768//              HANDLE, hHandle,
     769//              BOOL,   fInherit)
     770{
    820771  return (hHandle);
    821772}
    822773
     774
Note: See TracChangeset for help on using the changeset viewer.