Changeset 7854 for trunk/src


Ignore:
Timestamp:
Feb 9, 2002, 6:27:32 PM (24 years ago)
Author:
sandervl
Message:

logging updates

Location:
trunk/src/kernel32
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/critsection.cpp

    r4387 r7854  
    1 /* $Id: critsection.cpp,v 1.7 2000-10-02 18:39:33 sandervl Exp $ */
     1/* $Id: critsection.cpp,v 1.8 2002-02-09 17:27:30 sandervl Exp $ */
    22/*
    33 * Win32 critical sections
    … …  
    2424
    2525
    26 #ifdef DEBUG
    27 HANDLE ODIN_EXTERN(CreateSemaphoreA) (LPSECURITY_ATTRIBUTES arg1, LONG arg2, LONG arg3,
    28                                       LPCSTR arg4);
    29 
    30 DWORD ODIN_EXTERN(WaitForSingleObject)(HANDLE hObject, DWORD timeout);
    31 
    32 HANDLE ODIN_EXTERN(ConvertToGlobalHandle)(HANDLE hHandle);
    33 #endif
    34 
    3526/***********************************************************************
    3627 *           InitializeCriticalSection   (KERNEL32.472) (NTDLL.406)
    … …  
    4233    crit->RecursionCount = 0;
    4334    crit->OwningThread   = 0;
    44     crit->LockSemaphore  = CALL_ODINFUNC(CreateSemaphoreA)( NULL, 0, 1, NULL );
     35    crit->LockSemaphore  = CreateSemaphoreA( NULL, 0, 1, NULL );
    4536    crit->Reserved       = GetCurrentProcessId();
    4637}
    … …  
    9384        for (;;)
    9485        {
    95             res = CALL_ODINFUNC(WaitForSingleObject)( crit->LockSemaphore, 5000L );
     86            res = WaitForSingleObject( crit->LockSemaphore, 5000L );
    9687            if ( res == WAIT_TIMEOUT )
    9788            {
    9889                dprintf(("Critical section %p wait timed out, retrying (60 sec)\n", crit ));
    99                 res = CALL_ODINFUNC(WaitForSingleObject)( crit->LockSemaphore, 60000L );
     90                res = WaitForSingleObject( crit->LockSemaphore, 60000L );
    10091                if ( res == WAIT_TIMEOUT && TRACE_ON(relay) )
    10192                {
    … …  
    177168{
    178169    dprintf(("MakeCriticalSectionGlobal %x", crit));
    179     crit->LockSemaphore = CALL_ODINFUNC(ConvertToGlobalHandle)( crit->LockSemaphore );
     170    crit->LockSemaphore = ConvertToGlobalHandle( crit->LockSemaphore );
    180171    crit->Reserved      = 0L;
    181172}

  • trunk/src/kernel32/dbgwrap.cpp

    r7849 r7854  
    785785DEBUGWRAP12(GetSystemTimeAdjustment);
    786786DEBUGWRAP4(GetSystemTimeAsFileTime);
    787 DEBUGWRAP4(GetLocalTime);
     787DEBUGWRAP4_NORET(GetLocalTime);
    788788DEBUGWRAP4(SetLocalTime);
    789 DEBUGWRAP4(SetSystemTime);
     789DEBUGWRAP4_NORET(SetSystemTime);
    790790DEBUGWRAP8(SetSystemTimeAdjustment);
    791791DEBUGWRAP4(SetTimeZoneInformation);

  • trunk/src/kernel32/dbgwrap.h

    r7849 r7854  
    66typedef DWORD (* WIN32API DBG_WINPROC0)();
    77typedef DWORD (* WIN32API DBG_WINPROC4)(DWORD);
     8typedef DWORD (* WIN32API DBG_WINPROC4_NORET)(DWORD);
    89typedef DWORD (* WIN32API DBG_WINPROC8)(DWORD, DWORD);
    910typedef DWORD (* WIN32API DBG_WINPROC12)(DWORD, DWORD, DWORD);
    … …  
    5253}
    5354
     55#define DEBUGWRAP4_NORET(a) \
     56void WIN32API Dbg##a(DWORD arg1)             \
     57{                                          \
     58    dprintf((DBGWRAP_MODULE": %s %x", #a, arg1));         \
     59    dbg_ThreadPushCall(#a); \
     60    ((DBG_WINPROC4_NORET)a)(arg1);         \
     61    dbg_ThreadPopCall(); \
     62}
     63
    5464#define DEBUGWRAP8(a) \
    5565DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2) \

  • trunk/src/kernel32/heap.cpp

    r7504 r7854  
    131131//******************************************************************************
    132132//******************************************************************************
    133 ODINFUNCTIONNODBG3(HANDLE, HeapCreate, DWORD, flOptions, DWORD, dwInitialSize,
    134                    DWORD, dwMaximumSize)
     133HANDLE WIN32API HeapCreate(DWORD flOptions, DWORD dwInitialSize,
     134                           DWORD dwMaximumSize)
    135135{
    136136 OS2Heap *curheap;
    … …  
    155155//******************************************************************************
    156156//******************************************************************************
    157 ODINFUNCTIONNODBG1(BOOL, HeapDestroy, HANDLE, hHeap)
     157BOOL WIN32API HeapDestroy(HANDLE hHeap)
    158158{
    159159  OS2Heap *curheap;
    … …  
    169169//******************************************************************************
    170170//******************************************************************************
    171 ODINFUNCTIONNODBG3(DWORD, HeapSize, HANDLE, hHeap, DWORD, arg2, PVOID, lpMem)
     171DWORD WIN32API HeapSize(HANDLE hHeap, DWORD arg2, PVOID lpMem)
    172172{
    173173  OS2Heap *curheap;
    … …  
    182182//TODO: Check this!!!
    183183//******************************************************************************
    184 ODINFUNCTIONNODBG2(DWORD, HeapCompact, HANDLE, hHeap, DWORD, dwFlags)
     184DWORD WIN32API HeapCompact(HANDLE hHeap, DWORD dwFlags)
    185185{
    186186  dprintf(("KERNEL32:  HeapCompact: Unknown API - stub\n"));
    … …  
    189189//******************************************************************************
    190190//******************************************************************************
    191 ODINFUNCTIONNODBG3(BOOL, HeapValidate, HANDLE, hHeap, DWORD, dwFlags, LPCVOID, lpMem)
     191BOOL WIN32API HeapValidate(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem)
    192192{
    193193  OS2Heap *curheap;
    … …  
    202202//******************************************************************************
    203203//******************************************************************************
    204 ODINFUNCTIONNODBG1(BOOL, HeapUnlock, HANDLE, hHeap)
     204BOOL WIN32API HeapUnlock(HANDLE hHeap)
    205205{
    206206  dprintf(("KERNEL32:  HeapUnlock - stub (TRUE)\n"));
    … …  
    209209//******************************************************************************
    210210//******************************************************************************
    211 ODINFUNCTIONNODBG1(BOOL, HeapLock, HANDLE, hHeap)
     211BOOL WIN32API HeapLock(HANDLE hHeap)
    212212{
    213213  dprintf(("KERNEL32:  HeapLock - stub (TRUE)\n"));
    … …  
    217217//    LPPROCESS_HEAP_ENTRY lpEntry
    218218//******************************************************************************
    219 ODINFUNCTIONNODBG2(BOOL, HeapWalk, HANDLE, hHeap, LPVOID, lpEntry)
     219BOOL WIN32API HeapWalk(HANDLE hHeap, LPVOID lpEntry)
    220220{
    221221  dprintf(("KERNEL32:  HeapWalk - stub (TRUE)\n"));
    … …  
    229229    return(Heap_ProcessHeap);
    230230}
    231 #if 1
    232231/*
    233232 * Win32 Global heap functions (GlobalXXX).
    … …  
    271270 *      NULL: Failure
    272271 */
    273 ODINFUNCTION2(HGLOBAL, GlobalAlloc,
    274               UINT, flags,
    275               DWORD, size)
     272HGLOBAL WIN32API GlobalAlloc(UINT flags, DWORD size)
    276273{
    277274   PGLOBAL32_INTERN     pintern;
    … …  
    323320 *      NULL: Failure
    324321 */
    325 ODINFUNCTION1(LPVOID, GlobalLock,
    326               HGLOBAL, hmem)
     322LPVOID WIN32API GlobalLock(HGLOBAL hmem)
    327323{
    328324   PGLOBAL32_INTERN pintern;
    … …  
    371367 *      FALSE: Object is unlocked
    372368 */
    373 ODINFUNCTION1(BOOL, GlobalUnlock,
    374               HGLOBAL, hmem)
     369BOOL WIN32API GlobalUnlock(HGLOBAL hmem)
    375370{
    376371   PGLOBAL32_INTERN       pintern;
    … …  
    418413 *      NULL: Failure
    419414 */
    420 ODINFUNCTION1(HGLOBAL, GlobalHandle,
    421               LPCVOID, pmem)
     415HGLOBAL WIN32API GlobalHandle(LPCVOID pmem)
    422416{
    423417    HGLOBAL handle;
    … …  
    509503 *      NULL: Failure
    510504 */
    511 ODINFUNCTION3(HGLOBAL, GlobalReAlloc,
    512                  HGLOBAL, hmem,
    513                  DWORD, size,
    514                  UINT, flags)
     505HGLOBAL WIN32API GlobalReAlloc(HGLOBAL hmem, DWORD size, UINT flags)
    515506{
    516507   LPVOID               palloc;
    … …  
    622613 *      Handle: Failure
    623614 */
    624 ODINFUNCTION1(HGLOBAL, GlobalFree,
    625               HGLOBAL, hmem)
     615HGLOBAL WIN32API GlobalFree(HGLOBAL hmem)
    626616{
    627617   PGLOBAL32_INTERN pintern;
    … …  
    688678 *      0: Failure
    689679 */
    690 ODINFUNCTION1(DWORD, GlobalSize,
    691               HGLOBAL, hmem)
     680DWORD WIN32API GlobalSize(HGLOBAL hmem)
    692681{
    693682   DWORD                retval;
    … …  
    729718 *           GlobalWire   (KERNEL32.@)
    730719 */
    731 ODINFUNCTION1(LPVOID, GlobalWire,
    732               HGLOBAL, hmem)
     720LPVOID WIN32API GlobalWire(HGLOBAL hmem)
    733721{
    734722   return GlobalLock( hmem );
    … …  
    739727 *           GlobalUnWire   (KERNEL32.@)
    740728 */
    741 ODINFUNCTION1(BOOL, GlobalUnWire,
    742               HGLOBAL, hmem)
     729BOOL WIN32API GlobalUnWire(HGLOBAL hmem)
    743730{
    744731   return GlobalUnlock( hmem);
    … …  
    749736 *           GlobalFix   (KERNEL32.@)
    750737 */
    751 ODINPROCEDURE1(GlobalFix,
    752                HGLOBAL, hmem)
     738void WIN32API GlobalFix(HGLOBAL hmem)
    753739{
    754740    GlobalLock( hmem );
    … …  
    759745 *           GlobalUnfix   (KERNEL32.@)
    760746 */
    761 ODINPROCEDURE1(GlobalUnfix,
    762                HGLOBAL, hmem)
     747void WIN32API GlobalUnfix(HGLOBAL hmem)
    763748{
    764749   GlobalUnlock( hmem);
    … …  
    777762 *      GMEM_INVALID_HANDLE: Failure
    778763 */
    779 ODINFUNCTION1(UINT, GlobalFlags,
    780               HGLOBAL, hmem)
     764UINT WIN32API GlobalFlags(HGLOBAL hmem)
    781765{
    782766   DWORD                retval;
    … …  
    811795 *           GlobalCompact   (KERNEL32.@)
    812796 */
    813 ODINFUNCTION1(DWORD, GlobalCompact,
    814               DWORD, minfree )
     797DWORD WIN32API GlobalCompact(DWORD minfree)
    815798{
    816799    return 0;  /* GlobalCompact does nothing in Win32 */
    817800}
    818 #else
    819 //******************************************************************************
    820 #ifdef DEBUG
    821 static ULONG totalGlobalAlloc = 0;
    822 #endif
    823 //******************************************************************************
    824 ODINFUNCTION2(HGLOBAL, GlobalAlloc,
    825               UINT, fuFlags,
    826               DWORD, dwBytes)
    827 {
    828  HGLOBAL ret;
    829 
    830     ret = O32_GlobalAlloc(fuFlags, dwBytes);
    831 #ifdef DEBUG
    832     totalGlobalAlloc += dwBytes;
    833 #endif
    834     return ret;
    835 }
    836 //******************************************************************************
    837 //******************************************************************************
    838 ODINFUNCTION1(HGLOBAL, GlobalFree,
    839               HGLOBAL, arg1)
    840 {
    841  HGLOBAL ret;
    842 
    843 #ifdef DEBUG
    844     totalGlobalAlloc -= O32_GlobalSize(arg1);
    845 #endif
    846     ret = O32_GlobalFree(arg1);
    847     return ret;
    848 }
    849 //******************************************************************************
    850 //******************************************************************************
    851 ODINFUNCTION1(HGLOBAL, GlobalHandle,
    852               LPCVOID, lpMem)
    853 {
    854     return O32_GlobalHandle((LPVOID)lpMem);
    855 }
    856 //******************************************************************************
    857 //******************************************************************************
    858 ODINFUNCTION1(UINT, GlobalFlags,
    859               HGLOBAL, hMem)
    860 {
    861     return O32_GlobalFlags(hMem);
    862 }
    863 //******************************************************************************
    864 //******************************************************************************
    865 ODINFUNCTION1(DWORD, GlobalCompact,
    866               DWORD, dwMinFree)
    867 {
    868   return(0);
    869 }
    870 //******************************************************************************
    871 //******************************************************************************
    872 ODINFUNCTION1(PVOID, GlobalLock,
    873               HGLOBAL, hMem)
    874 {
    875   return O32_GlobalLock(hMem);
    876 }
    877 //******************************************************************************
    878 //******************************************************************************
    879 ODINFUNCTION3(HGLOBAL, GlobalReAlloc,
    880               HGLOBAL, arg1,
    881               DWORD, arg2,
    882               UINT,  arg3)
    883 {
    884     return O32_GlobalReAlloc(arg1, arg2, arg3);
    885 }
    886 //******************************************************************************
    887 //******************************************************************************
    888 ODINFUNCTION1(DWORD, GlobalSize,
    889               HGLOBAL, arg1)
    890 {
    891     return O32_GlobalSize(arg1);
    892 }
    893 //******************************************************************************
    894 //******************************************************************************
    895 ODINFUNCTION1(BOOL, GlobalUnlock,
    896               HGLOBAL, arg1)
    897 {
    898     return O32_GlobalUnlock(arg1);
    899 }
    900 /***********************************************************************
    901  *           GlobalWire
    902  *
    903  * The GlobalWire function is obsolete. It is provided only for compatibility
    904  * with 16-bit versions of Windows. Applications that need to lock a global
    905  * memory object should use the GlobalLock and GlobalUnlock functions.
    906  *
    907  */
    908 ODINFUNCTION1(LPVOID, GlobalWire,
    909               HGLOBAL, hmem)
    910 {
    911    return GlobalLock( hmem );
    912 }
    913 /***********************************************************************
    914  *           GlobalUnWire
    915  *
    916  * The GlobalUnWire function is obsolete. It is provided only for compatibility
    917  * with 16-bit versions of Windows. Applications that need to lock a global
    918  * memory object should use the GlobalLock and GlobalUnlock functions.
    919  *
    920  */
    921 ODINFUNCTION1(BOOL, GlobalUnWire,
    922               HGLOBAL, hmem)
    923 {
    924    return GlobalUnlock( hmem);
    925 }
    926 //******************************************************************************
    927 //******************************************************************************
    928 ODINFUNCTION1(HGLOBAL, GlobalDiscard,
    929               HGLOBAL, hGlobal)
    930 {
    931     return O32_GlobalDiscard(hGlobal);
    932 }
    933 /***********************************************************************
    934  *           GlobalFix   (KERNEL32.@)
    935  */
    936 ODINPROCEDURE1(GlobalFix,
    937                HGLOBAL, hmem)
    938 {
    939     GlobalLock( hmem );
    940 }
    941 /***********************************************************************
    942  *           GlobalUnfix   (KERNEL32.@)
    943  */
    944 ODINPROCEDURE1(GlobalUnfix,
    945                HGLOBAL, hmem)
    946 {
    947    GlobalUnlock( hmem);
    948 }
    949 #endif
    950801//******************************************************************************
    951802//******************************************************************************

  • trunk/src/kernel32/heapstring.cpp

    r7846 r7854  
    1 /* $Id: heapstring.cpp,v 1.50 2002-02-08 15:09:29 sandervl Exp $ */
     1/* $Id: heapstring.cpp,v 1.51 2002-02-09 17:27:31 sandervl Exp $ */
    22/*
    33 * Project Odin Software License can be found in LICENSE.TXT
    … …  
    6565 *****************************************************************************/
    6666
    67 ODINFUNCTIONNODBG1(int, lstrlenA,
    68                    LPCSTR, arg1)
     67int WIN32API lstrlenA(LPCSTR arg1)
    6968{
    7069  dprintf2(("KERNEL32: lstrlenA(%s)\n",
    … …  
    9190 *****************************************************************************/
    9291
    93 ODINFUNCTIONNODBG1(int, lstrlenW,
    94                    LPCWSTR, str)
     92int WIN32API lstrlenW(LPCWSTR str)
    9593{
    9694  if(str == NULL) {
    … …  
    120118 *****************************************************************************/
    121119
    122 ODINFUNCTIONNODBG2(LPSTR, lstrcatA,
    123                    LPSTR, arg1,
    124                    LPCSTR, arg2)
     120LPSTR WIN32API lstrcatA(LPSTR arg1, LPCSTR arg2)
    125121{
    126122  dprintf2(("KERNEL32: lstrcat(%s,%s)\n",
    … …  
    147143 *****************************************************************************/
    148144
    149 ODINFUNCTIONNODBG2(LPWSTR, lstrcatW,
    150                    LPWSTR, dst,
    151                    LPCWSTR, src)
    152 {
    153     dprintf2(("KERNEL32: OS2lstrcatW(%08xh,%08xh)\n",
     145LPWSTR WIN32API lstrcatW(LPWSTR dst, LPCWSTR src)
     146{
     147    dprintf2(("KERNEL32: lstrcatW(%08xh,%08xh)\n",
    154148              dst, src));
    155149
    … …  
    174168 *****************************************************************************/
    175169
    176 ODINFUNCTIONNODBG2(int, lstrcmpA,
    177                    LPCSTR, arg1,
    178                    LPCSTR, arg2)
    179 {
    180   dprintf2(("KERNEL32: OS2lstrcmpA(%s,%s)\n",
     170int WIN32API lstrcmpA(LPCSTR arg1, LPCSTR arg2)
     171{
     172  dprintf2(("KERNEL32: lstrcmpA(%s,%s)\n",
    181173           arg1,
    182174           arg2));
    … …  
    203195 *****************************************************************************/
    204196
    205 ODINFUNCTIONNODBG3(int, lstrncmpA,
    206                    LPCSTR, arg1,
    207                    LPCSTR, arg2,
    208                    int, l)
    209 {
    210   dprintf2(("KERNEL32: OS2lstrncmpA(%s,%s,%d)\n",
     197int WIN32API lstrncmpA(LPCSTR arg1, LPCSTR arg2, int l)
     198{
     199  dprintf2(("KERNEL32: lstrncmpA(%s,%s,%d)\n",
    211200           arg1,
    212201           arg2,
    … …  
    227216 * Author    : Przemyslaw Dobrowolski
    228217 *****************************************************************************/
    229 ODINFUNCTIONNODBG3(INT, lstrncmpiA,
    230                    LPCSTR, str1,
    231                    LPCSTR, str2,
    232                    INT, n )
     218int WIN32API lstrncmpiA(LPCSTR str1, LPCSTR str2, INT n )
    233219{
    234220  INT firstch,lastch;
    … …  
    251237}
    252238//TODO: Don't know if this is completely correct
    253 ODINFUNCTIONNODBG3(int, lstrncmpiW,
    254                    LPCWSTR, str1,
    255                    LPCWSTR, str2,
    256                    int, n)
     239int WIN32API lstrncmpiW(LPCWSTR str1, LPCWSTR str2, int n)
    257240{
    258241  INT firstch,lastch;
    … …  
    287270 *****************************************************************************/
    288271
    289 ODINFUNCTIONNODBG2(int, lstrcmpW,
    290                    LPCWSTR, arg1,
    291                    LPCWSTR, arg2)
     272int WIN32API lstrcmpW(LPCWSTR arg1, LPCWSTR arg2)
    292273{
    293274    dprintf2(("KERNEL32: lstrcmpW (%08xh, %08xh)\n",
    … …  
    316297 *****************************************************************************/
    317298
    318 ODINFUNCTIONNODBG3(int, lstrncmpW,
    319                    LPCWSTR, arg1,
    320                    LPCWSTR, arg2,
    321                    int, l)
    322 {
    323   dprintf2(("KERNEL32: OS2lstrncmpW(%08xh,%08xh,%d)\n",
     299int WIN32API lstrncmpW(LPCWSTR arg1, LPCWSTR arg2, int l)
     300{
     301  dprintf2(("KERNEL32: lstrncmpW(%08xh,%08xh,%d)\n",
    324302           arg1,
    325303           arg2,
    … …  
    343321 *****************************************************************************/
    344322
    345 ODINFUNCTIONNODBG2(LPSTR, lstrcpyA,
    346                    LPSTR, dest,
    347                    LPCSTR, src)
     323LPSTR WIN32API lstrcpyA(LPSTR dest, LPCSTR src)
    348324{
    349325    if ( (src == NULL) || (dest == NULL) ) // stupid parameter checking
    … …  
    366342 *****************************************************************************/
    367343
    368 ODINFUNCTIONNODBG2(LPWSTR, lstrcpyW,
    369                    LPWSTR, dest,
    370                    LPCWSTR, src)
     344LPWSTR WIN32API lstrcpyW(LPWSTR dest, LPCWSTR src)
    371345{
    372346    if ( (src == NULL) || (dest == NULL) ) // stupid parameter checking
    … …  
    392366 *****************************************************************************/
    393367
    394 ODINFUNCTIONNODBG3(LPSTR, lstrcpynA,
    395                    LPSTR, arg1,
    396                    LPCSTR, arg2,
    397                    int, arg3)
     368LPSTR WIN32API lstrcpynA(LPSTR arg1, LPCSTR arg2, int arg3)
    398369{
    399370  register LPSTR p1 = arg1;
    … …  
    430401 *****************************************************************************/
    431402
    432 ODINFUNCTION3(LPWSTR, lstrcpynW,
    433               LPWSTR, dst,
    434               LPCWSTR, src,
    435               int, n)
     403LPWSTR WIN32API lstrcpynW(LPWSTR dst, LPCWSTR src, int n)
    436404{
    437405    LPWSTR p = dst;
    … …  
    463431 *****************************************************************************/
    464432
    465 ODINFUNCTIONNODBG2(int, lstrcmpiA,
    466                    LPCSTR, arg1,
    467                    LPCSTR, arg2)
     433int WIN32API lstrcmpiA(LPCSTR arg1, LPCSTR arg2)
    468434{
    469435  dprintf2(("KERNEL32: lstrcmpiA(%s,%s)\n",
    … …  
    661627 *****************************************************************************/
    662628
    663 ODINFUNCTIONNODBG4(LPVOID, HEAP_xrealloc,
    664                    HANDLE, heap,
    665                    DWORD, flags,
    666                    LPVOID, lpMem,
    667                    DWORD, size )
     629LPVOID WIN32API HEAP_xrealloc(HANDLE heap, DWORD flags, LPVOID lpMem,
     630                              DWORD size )
    668631{
    669632  LPVOID p = HeapReAlloc( heap, flags, lpMem, size );
    … …  
    692655 *****************************************************************************/
    693656
    694 ODINFUNCTIONNODBG1(LPVOID, HEAP_malloc,
    695                    DWORD, size )
     657LPVOID WIN32API HEAP_malloc(DWORD size )
    696658{
    697659  LPVOID p = HeapAlloc( GetProcessHeap(), 0, size );
    … …  
    717679 *****************************************************************************/
    718680
    719 ODINFUNCTIONNODBG1(DWORD, HEAP_size,
    720                    LPVOID, lpMem)
     681DWORD WIN32API HEAP_size(LPVOID lpMem)
    721682{
    722683  return HeapSize( GetProcessHeap(), 0, lpMem );
    … …  
    736697 *****************************************************************************/
    737698
    738 ODINFUNCTIONNODBG2(LPVOID, HEAP_realloc,
    739                    LPVOID, lpMem,
    740                    DWORD, size )
     699LPVOID WIN32API HEAP_realloc(LPVOID lpMem, DWORD size )
    741700{
    742701  LPVOID p = HeapReAlloc( GetProcessHeap(), 0, lpMem, size );
    … …  
    763722 *****************************************************************************/
    764723
    765 ODINFUNCTIONNODBG1(BOOL,   HEAP_free,
    766                    LPVOID, lpMem)
     724BOOL WIN32API HEAP_free(LPVOID lpMem)
    767725{
    768726  return HeapFree( GetProcessHeap(), 0, lpMem);
    … …  
    782740 *****************************************************************************/
    783741
    784 ODINFUNCTIONNODBG3(LPSTR, HEAP_strdupA,
    785                    HANDLE, heap,
    786                    DWORD, flags,
    787                    LPCSTR, str )
     742LPSTR WIN32API HEAP_strdupA(HANDLE heap, DWORD flags, LPCSTR str )
    788743{
    789744  int iLength = lstrlenA(str) + 1;
    … …  
    806761 *****************************************************************************/
    807762
    808 ODINFUNCTIONNODBG3(LPWSTR, HEAP_strdupW,
    809                    HANDLE, heap,
    810                    DWORD, flags,
    811                    LPCWSTR, str )
     763LPWSTR WIN32API HEAP_strdupW(HANDLE heap, DWORD flags, LPCWSTR str )
    812764{
    813765    INT len = lstrlenW(str) + 1;
    … …  
    830782 *****************************************************************************/
    831783
    832 ODINFUNCTIONNODBG3(LPWSTR, HEAP_strdupAtoW,
    833                    HANDLE, heap,
    834                    DWORD, flags,
    835                    LPCSTR, str )
     784LPWSTR WIN32API HEAP_strdupAtoW(HANDLE heap, DWORD flags, LPCSTR str )
    836785{
    837786    LPWSTR ret;
    … …  
    860809 *****************************************************************************/
    861810
    862 ODINFUNCTIONNODBG3(LPSTR, HEAP_strdupWtoA,
    863                    HANDLE, heap,
    864                    DWORD, flags,
    865                    LPCWSTR, str )
     811LPSTR WIN32API HEAP_strdupWtoA(HANDLE heap, DWORD flags, LPCWSTR str )
    866812{
    867813    LPSTR ret;

  • trunk/src/kernel32/kernel32.mak

    r7846 r7854  
    1 # $Id: kernel32.mak,v 1.23 2002-02-08 15:09:30 sandervl Exp $
     1# $Id: kernel32.mak,v 1.24 2002-02-09 17:27:31 sandervl Exp $
    22
    33#
    … …  
    1616#
    1717!if "$(DEBUG)" == "1"
    18 DEFFILE = kernel32dbg.def
     18DEFFILE    = kernel32dbg.def
     19ORGDEFFILE = kernel32.def
    1920!endif
    2021

  • trunk/src/kernel32/kernel32dbg.def

    r7850 r7854  
    1 ; $Id: kernel32dbg.def,v 1.3 2002-02-09 13:36:20 achimha Exp $
     1; $Id: kernel32dbg.def,v 1.4 2002-02-09 17:27:31 sandervl Exp $
    22
    33;Basis is Windows95 KERNEL32
    … …  
    11271127    HEAP_strdupA               = _DbgHEAP_strdupA@12                 @1247 NONAME
    11281128    HEAP_strdupW               = _DbgHEAP_strdupW@12                 @1248 NONAME
    1129 ; AH 2002-02-09 export the debug functions under their mangled non debug name as well
    1130     _HEAP_xalloc@12            = HEAP_xalloc                         @1340 NONAME
    1131     _HEAP_xrealloc@16          = HEAP_xrealloc                       @1341 NONAME
    1132     _HEAP_malloc@4             = HEAP_malloc                         @1342 NONAME
    1133     _HEAP_realloc@8            = HEAP_realloc                        @1343 NONAME
    1134     _HEAP_size@4               = HEAP_size                           @1392 NONAME
    1135     _HEAP_free@4               = HEAP_free                           @1344 NONAME
    1136     _HEAP_strdupWtoA@12        = HEAP_strdupWtoA                     @1345 NONAME
    1137     _HEAP_strdupAtoW@12        = HEAP_strdupAtoW                     @1346 NONAME
    1138     _HEAP_strdupA@12           = HEAP_strdupA                        @1347 NONAME
    1139     _HEAP_strdupW@12           = HEAP_strdupW                        @1348 NONAME
    1140 
    1141 
    11421129
    11431130    _VIRTUAL_MapFileA@12                                          @1251 NONAME

  • trunk/src/kernel32/kobjects.cpp

    r7560 r7854  
    1 /* $Id: kobjects.cpp,v 1.14 2001-12-06 15:57:51 sandervl Exp $ */
     1/* $Id: kobjects.cpp,v 1.15 2002-02-09 17:27:32 sandervl Exp $ */
    22
    33/*
    … …  
    7676 *****************************************************************************/
    7777
    78 ODINFUNCTION4(HANDLE, CreateEventA,
    79               LPSECURITY_ATTRIBUTES, lpsa,
    80               BOOL, fManualReset,
    81               BOOL, fInitialState,
    82               LPCTSTR, lpszEventName)
     78HANDLE WIN32API CreateEventA(LPSECURITY_ATTRIBUTES lpsa, BOOL fManualReset,
     79                             BOOL fInitialState,
     80                             LPCTSTR lpszEventName)
    8381{
    8482  return(HMCreateEvent(lpsa,                         /* create event semaphore */
    … …  
    10199 *****************************************************************************/
    102100
    103 ODINFUNCTION4(HANDLE, CreateEventW,
    104               LPSECURITY_ATTRIBUTES, arg1,
    105               BOOL, arg2,
    106               BOOL, arg3,
    107               LPCWSTR, arg4)
     101HANDLE WIN32API CreateEventW(LPSECURITY_ATTRIBUTES arg1,
     102                             BOOL arg2, BOOL arg3,
     103                             LPCWSTR arg4)
    108104{
    109105  HANDLE rc;
    … …  
    142138 *****************************************************************************/
    143139
    144 ODINFUNCTION3(HANDLE, CreateMutexA,
    145               LPSECURITY_ATTRIBUTES, lpsa,
    146               BOOL, fInitialOwner,
    147               LPCTSTR, lpszMutexName)
     140HANDLE WIN32API CreateMutexA(LPSECURITY_ATTRIBUTES lpsa,
     141                             BOOL fInitialOwner,
     142                             LPCTSTR lpszMutexName)
    148143{
    149144  dprintf(("KERNEL32: CreateMutexA(%s)\n",
    … …  
    168163 *****************************************************************************/
    169164
    170 ODINFUNCTION3(HANDLE, CreateMutexW,
    171               PSECURITY_ATTRIBUTES, arg1,
    172               BOOL, arg2,
    173               LPCWSTR, arg3)
     165HANDLE WIN32API CreateMutexW(LPSECURITY_ATTRIBUTES arg1, BOOL arg2,
     166                             LPCWSTR arg3)
    174167{
    175168  HANDLE rc;
    … …  
    207200 *****************************************************************************/
    208201
    209 ODINFUNCTION1(BOOL, ReleaseMutex,
    210               HANDLE, mutex)
     202BOOL WIN32API ReleaseMutex(HANDLE mutex)
    211203{
    212204  return(HMReleaseMutex(mutex));
    … …  
    226218 *****************************************************************************/
    227219
    228 ODINFUNCTION1(BOOL, SetEvent,
    229               HANDLE, hEvent)
     220BOOL WIN32API SetEvent(HANDLE hEvent)
    230221{
    231222  return(HMSetEvent(hEvent));
    … …  
    245236 *****************************************************************************/
    246237
    247 ODINFUNCTION2(DWORD, WaitForSingleObject,
    248               HANDLE, hObject,
    249               DWORD, timeout)
     238DWORD WIN32API WaitForSingleObject(HANDLE hObject, DWORD timeout)
    250239{
    251240  return(HMWaitForSingleObject(hObject,
    … …  
    273262 *****************************************************************************/
    274263
    275 ODINFUNCTION3(DWORD, WaitForSingleObjectEx,
    276               HANDLE, hObject,
    277               DWORD, dwTimeout,
    278               BOOL, fAlertable)
     264DWORD WIN32API WaitForSingleObjectEx(HANDLE hObject, DWORD dwTimeout, BOOL fAlertable)
    279265{
    280266  dprintf(("Kernel32: WaitForSingleObjectEx(%08xh,%08xh,%08xh) not implemented correctly.\n",
    … …  
    301287 *****************************************************************************/
    302288
    303 ODINFUNCTION1(BOOL, FlushFileBuffers,
    304               HANDLE, hFile)
     289BOOL WIN32API FlushFileBuffers(HANDLE hFile)
    305290{
    306291  return(HMFlushFileBuffers(hFile));
    … …  
    320305 *****************************************************************************/
    321306
    322 ODINFUNCTION1(UINT, SetHandleCount,
    323               UINT, cHandles)
     307UINT WIN32API SetHandleCount(UINT cHandles)
    324308{
    325309  //SvL: Has no effect in NT; also ignore it
    … …  
    340324 *****************************************************************************/
    341325
    342 //******************************************************************************
    343 //SvL: 24-6-'97 - Added
    344 //SvL: 28-6-'97: Fix for timeSetEvent in Red Alert Map Editor
    345 //******************************************************************************
    346 ODINFUNCTION7(BOOL, DuplicateHandle,
    347               HANDLE, srcprocess,
    348               HANDLE, srchandle,
    349               HANDLE, destprocess,
    350               PHANDLE, desthandle,
    351               DWORD, arg5,
    352               BOOL, arg6,
    353               DWORD, arg7)
     326BOOL WIN32API DuplicateHandle(HANDLE srcprocess, HANDLE srchandle,
     327                              HANDLE destprocess, PHANDLE desthandle,
     328                              DWORD arg5, BOOL arg6, DWORD arg7)
    354329{
    355330  BOOL rc;
    … …  
    388363 *****************************************************************************/
    389364
    390 ODINFUNCTION4(HANDLE, CreateSemaphoreA,
    391               LPSECURITY_ATTRIBUTES, arg1,
    392               LONG, arg2,
    393               LONG, arg3,
    394               LPCSTR, arg4)
     365HANDLE WIN32API CreateSemaphoreA(LPSECURITY_ATTRIBUTES arg1,
     366                                 LONG arg2, LONG arg3, LPCSTR arg4)
    395367{
    396368  return HMCreateSemaphore(arg1,
    … …  
    413385 *****************************************************************************/
    414386
    415 ODINFUNCTION4(HANDLE, CreateSemaphoreW,
    416               PSECURITY_ATTRIBUTES, arg1,
    417               LONG, arg2,
    418               LONG, arg3,
    419               LPCWSTR, arg4)
     387HANDLE WIN32API CreateSemaphoreW(LPSECURITY_ATTRIBUTES arg1, LONG arg2,
     388                                 LONG arg3, LPCWSTR arg4)
    420389{
    421390  HANDLE rc;
    … …  
    452421 *****************************************************************************/
    453422
    454 ODINFUNCTION3(HANDLE, OpenEventA,
    455               DWORD,  arg1,
    456               BOOL,   arg2,
    457               LPCSTR, arg3)
     423HANDLE WIN32API OpenEventA(DWORD  arg1, BOOL arg2, LPCSTR arg3)
    458424{
    459425  dprintf(("KERNEL32: OpenEventA(%s)\n",
    … …  
    478444 *****************************************************************************/
    479445
    480 ODINFUNCTION3(HANDLE,  OpenEventW,
    481               DWORD,   dwDesiredAccess,
    482               BOOL,    bInheritHandle,
    483               LPCWSTR, lpName)
     446HANDLE WIN32API  OpenEventW(DWORD dwDesiredAccess, BOOL bInheritHandle,
     447                            LPCWSTR lpName)
    484448{
    485449  char  *asciiname;
    … …  
    511475 *****************************************************************************/
    512476
    513 ODINFUNCTION3(HANDLE, OpenMutexA,
    514               DWORD,  arg1,
    515               BOOL,   arg2,
    516               LPCSTR, arg3)
     477HANDLE WIN32API OpenMutexA(DWORD arg1, BOOL arg2, LPCSTR arg3)
    517478{
    518479  dprintf(("KERNEL32: OpenMutexA(%s)\n",
    … …  
    537498 *****************************************************************************/
    538499
    539 ODINFUNCTION3(HANDLE,  OpenMutexW,
    540               DWORD,   dwDesiredAccess,
    541               BOOL,    bInheritHandle,
    542               LPCWSTR, lpName)
     500HANDLE WIN32API OpenMutexW(DWORD dwDesiredAccess, BOOL bInheritHandle,
     501                           LPCWSTR lpName)
    543502{
    544503  char  *asciiname;
    … …  
    570529 *****************************************************************************/
    571530
    572 ODINFUNCTION3(HANDLE, OpenSemaphoreA,
    573               DWORD,  arg1,
    574               BOOL,   arg2,
    575               LPCSTR, arg3)
     531HANDLE WIN32API OpenSemaphoreA(DWORD arg1, BOOL arg2, LPCSTR arg3)
    576532{
    577533  dprintf(("KERNEL32: OpenSemaphoreA(%s)\n",
    … …  
    596552 *****************************************************************************/
    597553
    598 ODINFUNCTION3(HANDLE,  OpenSemaphoreW,
    599               DWORD,   dwDesiredAccess,
    600               BOOL,    bInheritHandle,
    601               LPCWSTR, lpName)
     554HANDLE WIN32API OpenSemaphoreW(DWORD dwDesiredAccess, BOOL bInheritHandle,
     555                               LPCWSTR lpName)
    602556{
    603557  char  *asciiname;
    … …  
    629583 *****************************************************************************/
    630584
    631 ODINFUNCTION1(BOOL, PulseEvent,
    632               HANDLE, arg1)
     585BOOL WIN32API PulseEvent(HANDLE arg1)
    633586{
    634587  return HMPulseEvent(arg1);
    … …  
    648601 *****************************************************************************/
    649602
    650 ODINFUNCTION3(BOOL,   ReleaseSemaphore,
    651               HANDLE, arg1,
    652               LONG,   arg2,
    653               PLONG,  arg3)
     603BOOL WIN32API ReleaseSemaphore(HANDLE arg1, LONG arg2, PLONG arg3)
    654604{
    655605  return HMReleaseSemaphore(arg1,
    … …  
    671621 *****************************************************************************/
    672622
    673 ODINFUNCTION1(BOOL,   ResetEvent,
    674               HANDLE, arg1)
     623BOOL WIN32API ResetEvent(HANDLE arg1)
    675624{
    676625  return HMResetEvent(arg1);
    … …  
    690639 *****************************************************************************/
    691640
    692 ODINFUNCTION4(DWORD,          WaitForMultipleObjects,
    693               DWORD,          arg1,
    694               const HANDLE *, arg2,
    695               BOOL,           arg3,
    696               DWORD,          arg4)
     641DWORD WIN32API WaitForMultipleObjects(DWORD arg1, const HANDLE * arg2,
     642                                      BOOL arg3, DWORD arg4)
    697643{
    698644  return HMWaitForMultipleObjects(arg1,
    … …  
    725671 *****************************************************************************/
    726672
    727 ODINFUNCTION5(DWORD, WaitForMultipleObjectsEx,
    728               DWORD, cObjects,
    729               CONST HANDLE *, lphObjects,
    730               BOOL, fWaitAll,
    731               DWORD, dwTimeout,
    732               BOOL, fAlertable)
     673DWORD WIN32API WaitForMultipleObjectsEx(DWORD cObjects, CONST HANDLE *lphObjects,
     674                                        BOOL fWaitAll, DWORD dwTimeout,
     675                                        BOOL fAlertable)
    733676{
    734677  return(HMWaitForMultipleObjectsEx(cObjects,
    … …  
    752695 *****************************************************************************/
    753696
    754 ODINFUNCTION1(HANDLE, ConvertToGlobalHandle,
    755               HANDLE, hHandle)
    756 
    757 //ODINFUNCTION2(HANDLE, ConvertToGlobalHandle,
    758 //              HANDLE, hHandle,
    759 //              BOOL,   fInherit)
     697HANDLE WIN32API ConvertToGlobalHandle(HANDLE hHandle)
     698
     699//ODINFUNCTION2(HANDLE ConvertToGlobalHandle,
     700//              HANDLE hHandle,
     701//              BOOL   fInherit)
    760702{
    761703  return (hHandle);
    … …  
    764706//******************************************************************************
    765707//******************************************************************************
    766 ODINFUNCTION6(HANDLE,CreateThread,LPSECURITY_ATTRIBUTES,  lpsa,
    767                                   DWORD,                  cbStack,
    768                                   LPTHREAD_START_ROUTINE, lpStartAddr,
    769                                   LPVOID,                 lpvThreadParm,
    770                                   DWORD,                  fdwCreate,
    771                                   LPDWORD,                lpIDThread)
     708HANDLE WIN32API CreateThread(LPSECURITY_ATTRIBUTES  lpsa,
     709                             DWORD                  cbStack,
     710                             LPTHREAD_START_ROUTINE lpStartAddr,
     711                             LPVOID                 lpvThreadParm,
     712                             DWORD                  fdwCreate,
     713                             LPDWORD                lpIDThread)
    772714{
    773715    return HMCreateThread(lpsa, cbStack, lpStartAddr, lpvThreadParm, fdwCreate, lpIDThread);

  • trunk/src/kernel32/npipe.cpp

    r3819 r7854  
    1 /* $Id: npipe.cpp,v 1.9 2000-07-12 18:21:44 sandervl Exp $ */
     1/* $Id: npipe.cpp,v 1.10 2002-02-09 17:27:32 sandervl Exp $ */
    22/*
    33 * Win32 Named pipes API
    … …  
    2727//******************************************************************************
    2828//******************************************************************************
    29 ODINFUNCTION6(BOOL,PeekNamedPipe,HANDLE ,hPipe,
    30                                  LPVOID ,lpvBuffer,
    31                                  DWORD  ,cbBuffer,
    32                                  LPDWORD,lpcbRead,
    33                                  LPDWORD,lpcbAvail,
    34                                  LPDWORD,lpcbMessage)
     29BOOL WIN32API PeekNamedPipe(HANDLE hPipe, LPVOID lpvBuffer,
     30                            DWORD cbBuffer, LPDWORD lpcbRead,
     31                            LPDWORD lpcbAvail, LPDWORD lpcbMessage)
    3532{
    3633  return (HMPeekNamedPipe(hPipe,lpvBuffer,cbBuffer,lpcbRead,lpcbAvail,lpcbMessage));
    3734}
    3835//******************************************************************************
    39 //LPSECURITY_ATTRIBUTES lpsa;   /* address of security attributes   */
    40 //******************************************************************************
    41 ODINFUNCTION4(BOOL,                 CreatePipe,
    42               PHANDLE,              phRead,
    43               PHANDLE,              phWrite,
    44               LPSECURITY_ATTRIBUTES,lpsa,
    45               DWORD,                cbPipe)
     36//******************************************************************************
     37BOOL WIN32API CreatePipe(PHANDLE phRead, PHANDLE  phWrite,
     38                         LPSECURITY_ATTRIBUTES lpsa, DWORD cbPipe)
    4639{
    4740  return (HMCreatePipe(phRead,phWrite,lpsa,cbPipe));
    4841}
    49 
    50 
    51 //******************************************************************************
    52 //******************************************************************************
    53 ODINFUNCTION8(HANDLE,CreateNamedPipeA,LPCTSTR,lpName, DWORD,dwOpenMode, DWORD,dwPipeMode,
    54                                      DWORD, nMaxInstances, DWORD, nOutBufferSize,
    55                                      DWORD, nInBufferSize, DWORD, nDefaultTimeOut,
    56                                      LPSECURITY_ATTRIBUTES, lpSecurityAttributes)
     42//******************************************************************************
     43//******************************************************************************
     44HANDLE WIN32API CreateNamedPipeA(LPCTSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode,
     45                                 DWORD nMaxInstances, DWORD nOutBufferSize,
     46                                 DWORD nInBufferSize, DWORD nDefaultTimeOut,
     47                                 LPSECURITY_ATTRIBUTES lpSecurityAttributes)
    5748
    5849{
    … …  
    6960//******************************************************************************
    7061//******************************************************************************
    71 ODINFUNCTION8(HANDLE,CreateNamedPipeW,LPCWSTR,lpName, DWORD,dwOpenMode, DWORD,dwPipeMode,
    72                                      DWORD, nMaxInstances, DWORD, nOutBufferSize,
    73                                      DWORD, nInBufferSize, DWORD, nDefaultTimeOut,
    74                                      LPSECURITY_ATTRIBUTES,lpSecurityAttributes)
     62HANDLE WIN32API CreateNamedPipeW(LPCWSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode,
     63                                 DWORD  nMaxInstances, DWORD nOutBufferSize,
     64                                 DWORD  nInBufferSize, DWORD nDefaultTimeOut,
     65                                 LPSECURITY_ATTRIBUTES lpSecurityAttributes)
    7566{
    7667  char *asciiname;
    … …  
    113104 * Author    : Przemyslaw Dobrowolski [Sun, 2000/01/02 12:48]
    114105 *****************************************************************************/
    115 ODINFUNCTION2(BOOL,ConnectNamedPipe,HANDLE,hNamedPipe, LPOVERLAPPED,lpOverlapped)
     106BOOL WIN32API ConnectNamedPipe(HANDLE hNamedPipe, LPOVERLAPPED lpOverlapped)
    116107{
    117108  return (HMConnectNamedPipe(hNamedPipe,lpOverlapped));
    … …  
    152143 *****************************************************************************/
    153144
    154 ODINFUNCTION7(BOOL,CallNamedPipeA,LPCSTR , lpNamedPipeName,
    155                                   LPVOID , lpInBuffer,
    156                                   DWORD  , nInBufferSize,
    157                                   LPVOID , lpOutBuffer,
    158                                   DWORD  , nOutBufferSize,
    159                                   LPDWORD, lpBytesRead,
    160                                   DWORD  , nTimeOut)
     145BOOL WIN32API CallNamedPipeA(LPCSTR lpNamedPipeName,
     146                             LPVOID lpInBuffer,
     147                             DWORD  nInBufferSize,
     148                             LPVOID lpOutBuffer,
     149                             DWORD  nOutBufferSize,
     150                             LPDWORD lpBytesRead,
     151                             DWORD  nTimeOut)
    161152{
    162153  return(OSLibDosCallNamedPipe(lpNamedPipeName,
    … …  
    202193 * Author    : Przemyslaw Dobrowolski [Mon, 2000/01/03 13:33]
    203194 *****************************************************************************/
    204 ODINFUNCTION7(BOOL,CallNamedPipeW,LPCWSTR , lpNamedPipeName,
    205                                   LPVOID , lpInBuffer,
    206                                   DWORD  , nInBufferSize,
    207                                   LPVOID , lpOutBuffer,
    208                                   DWORD  , nOutBufferSize,
    209                                   LPDWORD, lpBytesRead,
    210                                   DWORD  , nTimeOut)
     195BOOL WIN32API CallNamedPipeW(LPCWSTR lpNamedPipeName,
     196                             LPVOID lpInBuffer,
     197                             DWORD  nInBufferSize,
     198                             LPVOID lpOutBuffer,
     199                             DWORD  nOutBufferSize,
     200                             LPDWORD lpBytesRead,
     201                             DWORD  nTimeOut)
    211202{
    212203  char *asciiname;
    … …  
    242233 *****************************************************************************/
    243234
    244 ODINFUNCTION1(BOOL,DisconnectNamedPipe,HANDLE,hNamedPipe)
     235BOOL WIN32API DisconnectNamedPipe(HANDLE hNamedPipe)
    245236{
    246237  return (HMDisconnectNamedPipe(hNamedPipe));
    … …  
    268259
    269260BOOL WIN32API GetNamedPipeHandleStateA(HANDLE  hNamedPipe,
    270                                           LPDWORD lpState,
    271                                           LPDWORD lpCurInstances,
    272                                           LPDWORD lpMaxCollectionCount,
    273                                           LPDWORD lpCollectDataTimeout,
    274                                           LPTSTR  lpUserName,
    275                                           DWORD   nMaxUserNameSize)
     261                                       LPDWORD lpState,
     262                                       LPDWORD lpCurInstances,
     263                                       LPDWORD lpMaxCollectionCount,
     264                                       LPDWORD lpCollectDataTimeout,
     265                                       LPTSTR  lpUserName,
     266                                       DWORD   nMaxUserNameSize)
    276267{
    277268  // Not implemented but waiting to implementation in hmnpipe.cpp
    … …  
    307298
    308299BOOL WIN32API GetNamedPipeHandleStateW(HANDLE  hNamedPipe,
    309                                           LPDWORD lpState,
    310                                           LPDWORD lpCurInstances,
    311                                           LPDWORD lpMaxCollectionCount,
    312                                           LPDWORD lpCollectDataTimeout,
    313                                           LPWSTR  lpUserName,
    314                                           DWORD   nMaxUserNameSize)
     300                                       LPDWORD lpState,
     301                                       LPDWORD lpCurInstances,
     302                                       LPDWORD lpMaxCollectionCount,
     303                                       LPDWORD lpCollectDataTimeout,
     304                                       LPWSTR  lpUserName,
     305                                       DWORD   nMaxUserNameSize)
    315306{
    316307  char *asciiname;
    … …  
    352343
    353344BOOL WIN32API GetNamedPipeInfo(HANDLE  hNamedPipe,
    354                                   LPDWORD lpFlags,
    355                                   LPDWORD lpOutBufferSize,
    356                                   LPDWORD lpInBufferSize,
    357                                   LPDWORD lpMaxInstances)
     345                               LPDWORD lpFlags,
     346                               LPDWORD lpOutBufferSize,
     347                               LPDWORD lpInBufferSize,
     348                               LPDWORD lpMaxInstances)
    358349{
    359350  // Not implemented but waiting to implementation in hmnpipe.cpp
    … …  
    417408 *****************************************************************************/
    418409
    419 ODINFUNCTION7(DWORD,TransactNamedPipe,HANDLE,hNamedPipe,
    420                                       LPVOID,lpvWriteBuf,
    421                                       DWORD,cbWriteBuf,
    422                                       LPVOID,lpvReadBuf,
    423                                       DWORD,cbReadBuf,
    424                                       LPDWORD,lpcbRead,
    425                                       LPOVERLAPPED,lpo)
     410DWORD WIN32API TransactNamedPipe(HANDLE  hNamedPipe,
     411                                 LPVOID  lpvWriteBuf,
     412                                 DWORD   cbWriteBuf,
     413                                 LPVOID  lpvReadBuf,
     414                                 DWORD   cbReadBuf,
     415                                 LPDWORD lpcbRead,
     416                                 LPOVERLAPPED lpo)
    426417{
    427418  return(HMTransactNamedPipe( hNamedPipe,
    … …  
    450441 *****************************************************************************/
    451442
    452 ODINFUNCTION2(BOOL,WaitNamedPipeA,LPCSTR,lpszNamedPipeName, DWORD, dwTimeout)
     443BOOL WIN32API WaitNamedPipeA(LPCSTR lpszNamedPipeName, DWORD dwTimeout)
    453444{
    454445  return(OSLibDosWaitNamedPipe(lpszNamedPipeName, dwTimeout));
    … …  
    472463 *****************************************************************************/
    473464
    474 ODINFUNCTION2(BOOL,WaitNamedPipeW,LPCWSTR,lpszNamedPipeName, DWORD, dwTimeout)
     465BOOL WIN32API WaitNamedPipeW(LPCWSTR lpszNamedPipeName, DWORD dwTimeout)
    475466{
    476467  char  *asciiname;

  • trunk/src/kernel32/time.cpp

    r6375 r7854  
    1 /* $Id: time.cpp,v 1.16 2001-07-20 15:33:30 sandervl Exp $ */
     1/* $Id: time.cpp,v 1.17 2002-02-09 17:27:32 sandervl Exp $ */
    22
    33/*
    … …  
    8787//******************************************************************************
    8888//******************************************************************************
    89 ODINPROCEDURE1(GetLocalTime,
    90                LPSYSTEMTIME, arg1)
     89void WIN32API GetLocalTime(LPSYSTEMTIME arg1)
    9190{
    9291  O32_GetLocalTime(arg1);
    … …  
    9493//******************************************************************************
    9594//******************************************************************************
    96 ODINFUNCTION1(BOOL, SetLocalTime,
    97               const SYSTEMTIME *, arg1)
     95BOOL WIN32API SetLocalTime(const SYSTEMTIME * arg1)
    9896{
    9997  return O32_SetLocalTime(arg1);
    … …  
    10199//******************************************************************************
    102100//******************************************************************************
    103 ODINFUNCTION3(BOOL,FileTimeToDosDateTime,
    104               const FILETIME *, arg1,
    105               LPWORD, arg2,
    106               LPWORD,  arg3)
     101BOOL WIN32API FileTimeToDosDateTime(const FILETIME * arg1,  LPWORD arg2,
     102                                    LPWORD arg3)
    107103{
    108104    return O32_FileTimeToDosDateTime(arg1, arg2, arg3);
    … …  
    124120//******************************************************************************
    125121//******************************************************************************
    126 ODINFUNCTION2(BOOL, FileTimeToSystemTime,
    127               const FILETIME *, arg1,
    128               LPSYSTEMTIME, arg2)
     122BOOL WIN32API FileTimeToSystemTime(const FILETIME * arg1, LPSYSTEMTIME arg2)
    129123{
    130124  return O32_FileTimeToSystemTime(arg1, arg2);
    … …  
    132126//******************************************************************************
    133127//******************************************************************************
    134 ODINFUNCTION3(BOOL,DosDateTimeToFileTime,
    135               WORD, arg1,
    136               WORD, arg2,
    137               LPFILETIME, arg3)
     128BOOL WIN32API DosDateTimeToFileTime(WORD arg1, WORD arg2, LPFILETIME arg3)
    138129{
    139130    return O32_DosDateTimeToFileTime(arg1, arg2, arg3);
    … …  
    141132//******************************************************************************
    142133//******************************************************************************
    143 ODINFUNCTION1(DWORD, GetTimeZoneInformation,
    144               LPTIME_ZONE_INFORMATION, arg1)
     134DWORD WIN32API GetTimeZoneInformation(LPTIME_ZONE_INFORMATION arg1)
    145135{
    146136    return O32_GetTimeZoneInformation(arg1);
    … …  
    155145//******************************************************************************
    156146//******************************************************************************
    157 ODINPROCEDURE1(GetSystemTime,
    158                LPSYSTEMTIME, arg1)
     147void WIN32API GetSystemTime(LPSYSTEMTIME arg1)
    159148{
    160149    O32_GetSystemTime(arg1);
    … …  
    162151//******************************************************************************
    163152//******************************************************************************
    164 ODINFUNCTION2(BOOL, SystemTimeToFileTime,
    165               const SYSTEMTIME *, arg1,
    166               LPFILETIME,  arg2)
     153BOOL WIN32API SystemTimeToFileTime(const SYSTEMTIME * arg1,
     154                                   LPFILETIME arg2)
    167155{
    168156  return O32_SystemTimeToFileTime(arg1, arg2);
    … …  
    170158//******************************************************************************
    171159//******************************************************************************
    172 ODINFUNCTION3(BOOL, SystemTimeToTzSpecificLocalTime,
    173               LPTIME_ZONE_INFORMATION, arg1,
    174               LPSYSTEMTIME, arg2,
    175               LPSYSTEMTIME, arg3)
     160BOOL WIN32API SystemTimeToTzSpecificLocalTime(LPTIME_ZONE_INFORMATION arg1,
     161                                              LPSYSTEMTIME arg2,
     162                                              LPSYSTEMTIME arg3)
    176163{
    177164  return O32_SystemTimeToTzSpecificLocalTime(arg1, arg2, arg3);
    … …  
    179166//******************************************************************************
    180167//******************************************************************************
    181 ODINFUNCTION1(BOOL, SetTimeZoneInformation,
    182               const LPTIME_ZONE_INFORMATION, arg1)
     168BOOL WIN32API SetTimeZoneInformation(const LPTIME_ZONE_INFORMATION arg1)
    183169{
    184170  return O32_SetTimeZoneInformation(arg1);
    … …  
    186172//******************************************************************************
    187173//******************************************************************************
    188 ODINFUNCTION1(BOOL,SetSystemTime,
    189               const SYSTEMTIME *, arg1)
     174BOOL WIN32API SetSystemTime(const SYSTEMTIME * arg1)
    190175{
    191176  return O32_SetSystemTime(arg1);
Note: See TracChangeset for help on using the changeset viewer.