Index: trunk/src/kernel32/critsection.cpp
===================================================================
--- trunk/src/kernel32/critsection.cpp	(revision 7850)
+++ trunk/src/kernel32/critsection.cpp	(revision 7854)
@@ -1,3 +1,3 @@
-/* $Id: critsection.cpp,v 1.7 2000-10-02 18:39:33 sandervl Exp $ */
+/* $Id: critsection.cpp,v 1.8 2002-02-09 17:27:30 sandervl Exp $ */
 /*
  * Win32 critical sections
@@ -24,13 +24,4 @@
 
 
-#ifdef DEBUG
-HANDLE ODIN_EXTERN(CreateSemaphoreA) (LPSECURITY_ATTRIBUTES arg1, LONG arg2, LONG arg3,
-                                      LPCSTR arg4);
-
-DWORD ODIN_EXTERN(WaitForSingleObject)(HANDLE hObject, DWORD timeout);
-
-HANDLE ODIN_EXTERN(ConvertToGlobalHandle)(HANDLE hHandle);
-#endif
-
 /***********************************************************************
  *           InitializeCriticalSection   (KERNEL32.472) (NTDLL.406)
@@ -42,5 +33,5 @@
     crit->RecursionCount = 0;
     crit->OwningThread   = 0;
-    crit->LockSemaphore  = CALL_ODINFUNC(CreateSemaphoreA)( NULL, 0, 1, NULL );
+    crit->LockSemaphore  = CreateSemaphoreA( NULL, 0, 1, NULL );
     crit->Reserved       = GetCurrentProcessId();
 }
@@ -93,9 +84,9 @@
         for (;;)
         {
-            res = CALL_ODINFUNC(WaitForSingleObject)( crit->LockSemaphore, 5000L );
+            res = WaitForSingleObject( crit->LockSemaphore, 5000L );
             if ( res == WAIT_TIMEOUT )
             {
                 dprintf(("Critical section %p wait timed out, retrying (60 sec)\n", crit ));
-                res = CALL_ODINFUNC(WaitForSingleObject)( crit->LockSemaphore, 60000L );
+                res = WaitForSingleObject( crit->LockSemaphore, 60000L );
                 if ( res == WAIT_TIMEOUT && TRACE_ON(relay) )
                 {
@@ -177,5 +168,5 @@
 {
     dprintf(("MakeCriticalSectionGlobal %x", crit));
-    crit->LockSemaphore = CALL_ODINFUNC(ConvertToGlobalHandle)( crit->LockSemaphore );
+    crit->LockSemaphore = ConvertToGlobalHandle( crit->LockSemaphore );
     crit->Reserved      = 0L;
 }
Index: trunk/src/kernel32/dbgwrap.cpp
===================================================================
--- trunk/src/kernel32/dbgwrap.cpp	(revision 7850)
+++ trunk/src/kernel32/dbgwrap.cpp	(revision 7854)
@@ -785,7 +785,7 @@
 DEBUGWRAP12(GetSystemTimeAdjustment);
 DEBUGWRAP4(GetSystemTimeAsFileTime);
-DEBUGWRAP4(GetLocalTime);
+DEBUGWRAP4_NORET(GetLocalTime);
 DEBUGWRAP4(SetLocalTime);
-DEBUGWRAP4(SetSystemTime);
+DEBUGWRAP4_NORET(SetSystemTime);
 DEBUGWRAP8(SetSystemTimeAdjustment);
 DEBUGWRAP4(SetTimeZoneInformation);
Index: trunk/src/kernel32/dbgwrap.h
===================================================================
--- trunk/src/kernel32/dbgwrap.h	(revision 7850)
+++ trunk/src/kernel32/dbgwrap.h	(revision 7854)
@@ -6,4 +6,5 @@
 typedef DWORD (* WIN32API DBG_WINPROC0)();
 typedef DWORD (* WIN32API DBG_WINPROC4)(DWORD);
+typedef DWORD (* WIN32API DBG_WINPROC4_NORET)(DWORD);
 typedef DWORD (* WIN32API DBG_WINPROC8)(DWORD, DWORD);
 typedef DWORD (* WIN32API DBG_WINPROC12)(DWORD, DWORD, DWORD);
@@ -52,4 +53,13 @@
 }
 
+#define DEBUGWRAP4_NORET(a) \
+void WIN32API Dbg##a(DWORD arg1)             \
+{                                          \
+    dprintf((DBGWRAP_MODULE": %s %x", #a, arg1));         \
+    dbg_ThreadPushCall(#a); \
+    ((DBG_WINPROC4_NORET)a)(arg1);         \
+    dbg_ThreadPopCall(); \
+}
+
 #define DEBUGWRAP8(a) \
 DWORD WIN32API Dbg##a(DWORD arg1, DWORD arg2) \
Index: trunk/src/kernel32/heap.cpp
===================================================================
--- trunk/src/kernel32/heap.cpp	(revision 7850)
+++ trunk/src/kernel32/heap.cpp	(revision 7854)
@@ -131,6 +131,6 @@
 //******************************************************************************
 //******************************************************************************
-ODINFUNCTIONNODBG3(HANDLE, HeapCreate, DWORD, flOptions, DWORD, dwInitialSize, 
-                   DWORD, dwMaximumSize)
+HANDLE WIN32API HeapCreate(DWORD flOptions, DWORD dwInitialSize, 
+                           DWORD dwMaximumSize)
 {
  OS2Heap *curheap;
@@ -155,5 +155,5 @@
 //******************************************************************************
 //******************************************************************************
-ODINFUNCTIONNODBG1(BOOL, HeapDestroy, HANDLE, hHeap)
+BOOL WIN32API HeapDestroy(HANDLE hHeap)
 {
   OS2Heap *curheap;
@@ -169,5 +169,5 @@
 //******************************************************************************
 //******************************************************************************
-ODINFUNCTIONNODBG3(DWORD, HeapSize, HANDLE, hHeap, DWORD, arg2, PVOID, lpMem)
+DWORD WIN32API HeapSize(HANDLE hHeap, DWORD arg2, PVOID lpMem)
 {
   OS2Heap *curheap;
@@ -182,5 +182,5 @@
 //TODO: Check this!!!
 //******************************************************************************
-ODINFUNCTIONNODBG2(DWORD, HeapCompact, HANDLE, hHeap, DWORD, dwFlags)
+DWORD WIN32API HeapCompact(HANDLE hHeap, DWORD dwFlags)
 {
   dprintf(("KERNEL32:  HeapCompact: Unknown API - stub\n"));
@@ -189,5 +189,5 @@
 //******************************************************************************
 //******************************************************************************
-ODINFUNCTIONNODBG3(BOOL, HeapValidate, HANDLE, hHeap, DWORD, dwFlags, LPCVOID, lpMem)
+BOOL WIN32API HeapValidate(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem)
 {
   OS2Heap *curheap;
@@ -202,5 +202,5 @@
 //******************************************************************************
 //******************************************************************************
-ODINFUNCTIONNODBG1(BOOL, HeapUnlock, HANDLE, hHeap)
+BOOL WIN32API HeapUnlock(HANDLE hHeap)
 {
   dprintf(("KERNEL32:  HeapUnlock - stub (TRUE)\n"));
@@ -209,5 +209,5 @@
 //******************************************************************************
 //******************************************************************************
-ODINFUNCTIONNODBG1(BOOL, HeapLock, HANDLE, hHeap)
+BOOL WIN32API HeapLock(HANDLE hHeap)
 {
   dprintf(("KERNEL32:  HeapLock - stub (TRUE)\n"));
@@ -217,5 +217,5 @@
 //    LPPROCESS_HEAP_ENTRY lpEntry
 //******************************************************************************
-ODINFUNCTIONNODBG2(BOOL, HeapWalk, HANDLE, hHeap, LPVOID, lpEntry)
+BOOL WIN32API HeapWalk(HANDLE hHeap, LPVOID lpEntry)
 {
   dprintf(("KERNEL32:  HeapWalk - stub (TRUE)\n"));
@@ -229,5 +229,4 @@
     return(Heap_ProcessHeap);
 }
-#if 1
 /*
  * Win32 Global heap functions (GlobalXXX).
@@ -271,7 +270,5 @@
  *	NULL: Failure
  */
-ODINFUNCTION2(HGLOBAL, GlobalAlloc,
-              UINT, flags,
-              DWORD, size)
+HGLOBAL WIN32API GlobalAlloc(UINT flags, DWORD size)
 {
    PGLOBAL32_INTERN     pintern;
@@ -323,6 +320,5 @@
  *	NULL: Failure
  */
-ODINFUNCTION1(LPVOID, GlobalLock,
-              HGLOBAL, hmem)
+LPVOID WIN32API GlobalLock(HGLOBAL hmem)
 {
    PGLOBAL32_INTERN pintern;
@@ -371,6 +367,5 @@
  *	FALSE: Object is unlocked
  */
-ODINFUNCTION1(BOOL, GlobalUnlock,
-              HGLOBAL, hmem)
+BOOL WIN32API GlobalUnlock(HGLOBAL hmem)
 {
    PGLOBAL32_INTERN       pintern;
@@ -418,6 +413,5 @@
  *	NULL: Failure
  */
-ODINFUNCTION1(HGLOBAL, GlobalHandle,
-              LPCVOID, pmem)
+HGLOBAL WIN32API GlobalHandle(LPCVOID pmem)
 {
     HGLOBAL handle;
@@ -509,8 +503,5 @@
  *	NULL: Failure
  */
-ODINFUNCTION3(HGLOBAL, GlobalReAlloc,
-                 HGLOBAL, hmem,
-                 DWORD, size,
-                 UINT, flags)
+HGLOBAL WIN32API GlobalReAlloc(HGLOBAL hmem, DWORD size, UINT flags)
 {
    LPVOID               palloc;
@@ -622,6 +613,5 @@
  *	Handle: Failure
  */
-ODINFUNCTION1(HGLOBAL, GlobalFree,
-              HGLOBAL, hmem)
+HGLOBAL WIN32API GlobalFree(HGLOBAL hmem)
 {
    PGLOBAL32_INTERN pintern;
@@ -688,6 +678,5 @@
  *	0: Failure
  */
-ODINFUNCTION1(DWORD, GlobalSize,
-              HGLOBAL, hmem)
+DWORD WIN32API GlobalSize(HGLOBAL hmem)
 {
    DWORD                retval;
@@ -729,6 +718,5 @@
  *           GlobalWire   (KERNEL32.@)
  */
-ODINFUNCTION1(LPVOID, GlobalWire,
-              HGLOBAL, hmem)
+LPVOID WIN32API GlobalWire(HGLOBAL hmem)
 {
    return GlobalLock( hmem );
@@ -739,6 +727,5 @@
  *           GlobalUnWire   (KERNEL32.@)
  */
-ODINFUNCTION1(BOOL, GlobalUnWire,
-              HGLOBAL, hmem)
+BOOL WIN32API GlobalUnWire(HGLOBAL hmem)
 {
    return GlobalUnlock( hmem);
@@ -749,6 +736,5 @@
  *           GlobalFix   (KERNEL32.@)
  */
-ODINPROCEDURE1(GlobalFix,
-               HGLOBAL, hmem)
+void WIN32API GlobalFix(HGLOBAL hmem)
 {
     GlobalLock( hmem );
@@ -759,6 +745,5 @@
  *           GlobalUnfix   (KERNEL32.@)
  */
-ODINPROCEDURE1(GlobalUnfix,
-               HGLOBAL, hmem)
+void WIN32API GlobalUnfix(HGLOBAL hmem)
 {
    GlobalUnlock( hmem);
@@ -777,6 +762,5 @@
  *	GMEM_INVALID_HANDLE: Failure
  */
-ODINFUNCTION1(UINT, GlobalFlags,
-              HGLOBAL, hmem)
+UINT WIN32API GlobalFlags(HGLOBAL hmem)
 {
    DWORD                retval;
@@ -811,141 +795,8 @@
  *           GlobalCompact   (KERNEL32.@)
  */
-ODINFUNCTION1(DWORD, GlobalCompact,
-              DWORD, minfree )
+DWORD WIN32API GlobalCompact(DWORD minfree)
 {
     return 0;  /* GlobalCompact does nothing in Win32 */
 }
-#else
-//******************************************************************************
-#ifdef DEBUG
-static ULONG totalGlobalAlloc = 0;
-#endif
-//******************************************************************************
-ODINFUNCTION2(HGLOBAL, GlobalAlloc,
-              UINT, fuFlags, 
-              DWORD, dwBytes)
-{
- HGLOBAL ret;
-
-    ret = O32_GlobalAlloc(fuFlags, dwBytes);
-#ifdef DEBUG
-    totalGlobalAlloc += dwBytes;
-#endif
-    return ret;
-}
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION1(HGLOBAL, GlobalFree,
-              HGLOBAL, arg1)
-{
- HGLOBAL ret;
-
-#ifdef DEBUG
-    totalGlobalAlloc -= O32_GlobalSize(arg1);
-#endif
-    ret = O32_GlobalFree(arg1);
-    return ret;
-}
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION1(HGLOBAL, GlobalHandle,
-              LPCVOID, lpMem)
-{
-    return O32_GlobalHandle((LPVOID)lpMem);
-}
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION1(UINT, GlobalFlags,
-              HGLOBAL, hMem)
-{
-    return O32_GlobalFlags(hMem);
-}
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION1(DWORD, GlobalCompact,
-              DWORD, dwMinFree)
-{
-  return(0);
-}
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION1(PVOID, GlobalLock,
-              HGLOBAL, hMem)
-{
-  return O32_GlobalLock(hMem);
-}
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION3(HGLOBAL, GlobalReAlloc,
-              HGLOBAL, arg1,
-              DWORD, arg2,
-              UINT,  arg3)
-{
-    return O32_GlobalReAlloc(arg1, arg2, arg3);
-}
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION1(DWORD, GlobalSize,
-              HGLOBAL, arg1)
-{
-    return O32_GlobalSize(arg1);
-}
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION1(BOOL, GlobalUnlock,
-              HGLOBAL, arg1)
-{
-    return O32_GlobalUnlock(arg1);
-}
-/***********************************************************************
- *           GlobalWire
- *
- * The GlobalWire function is obsolete. It is provided only for compatibility 
- * with 16-bit versions of Windows. Applications that need to lock a global 
- * memory object should use the GlobalLock and GlobalUnlock functions. 
- *
- */
-ODINFUNCTION1(LPVOID, GlobalWire,
-              HGLOBAL, hmem)
-{
-   return GlobalLock( hmem );
-}
-/***********************************************************************
- *           GlobalUnWire
- *
- * The GlobalUnWire function is obsolete. It is provided only for compatibility 
- * with 16-bit versions of Windows. Applications that need to lock a global 
- * memory object should use the GlobalLock and GlobalUnlock functions. 
- *
- */
-ODINFUNCTION1(BOOL, GlobalUnWire,
-              HGLOBAL, hmem)
-{
-   return GlobalUnlock( hmem);
-}
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION1(HGLOBAL, GlobalDiscard,
-              HGLOBAL, hGlobal)
-{
-    return O32_GlobalDiscard(hGlobal);
-}
-/***********************************************************************
- *           GlobalFix   (KERNEL32.@)
- */
-ODINPROCEDURE1(GlobalFix,
-               HGLOBAL, hmem)
-{
-    GlobalLock( hmem );
-}
-/***********************************************************************
- *           GlobalUnfix   (KERNEL32.@)
- */
-ODINPROCEDURE1(GlobalUnfix,
-               HGLOBAL, hmem)
-{
-   GlobalUnlock( hmem);
-}
-#endif
 //******************************************************************************
 //******************************************************************************
Index: trunk/src/kernel32/heapstring.cpp
===================================================================
--- trunk/src/kernel32/heapstring.cpp	(revision 7850)
+++ trunk/src/kernel32/heapstring.cpp	(revision 7854)
@@ -1,3 +1,3 @@
-/* $Id: heapstring.cpp,v 1.50 2002-02-08 15:09:29 sandervl Exp $ */
+/* $Id: heapstring.cpp,v 1.51 2002-02-09 17:27:31 sandervl Exp $ */
 /*
  * Project Odin Software License can be found in LICENSE.TXT
@@ -65,6 +65,5 @@
  *****************************************************************************/
 
-ODINFUNCTIONNODBG1(int, lstrlenA,
-                   LPCSTR, arg1)
+int WIN32API lstrlenA(LPCSTR arg1)
 {
   dprintf2(("KERNEL32: lstrlenA(%s)\n",
@@ -91,6 +90,5 @@
  *****************************************************************************/
 
-ODINFUNCTIONNODBG1(int, lstrlenW,
-                   LPCWSTR, str)
+int WIN32API lstrlenW(LPCWSTR str)
 {
   if(str == NULL) {
@@ -120,7 +118,5 @@
  *****************************************************************************/
 
-ODINFUNCTIONNODBG2(LPSTR, lstrcatA,
-                   LPSTR, arg1, 
-                   LPCSTR, arg2)
+LPSTR WIN32API lstrcatA(LPSTR arg1, LPCSTR arg2)
 {
   dprintf2(("KERNEL32: lstrcat(%s,%s)\n",
@@ -147,9 +143,7 @@
  *****************************************************************************/
 
-ODINFUNCTIONNODBG2(LPWSTR, lstrcatW,
-                   LPWSTR, dst,
-                   LPCWSTR, src)
-{
-    dprintf2(("KERNEL32: OS2lstrcatW(%08xh,%08xh)\n",
+LPWSTR WIN32API lstrcatW(LPWSTR dst, LPCWSTR src)
+{
+    dprintf2(("KERNEL32: lstrcatW(%08xh,%08xh)\n",
               dst, src));
 
@@ -174,9 +168,7 @@
  *****************************************************************************/
 
-ODINFUNCTIONNODBG2(int, lstrcmpA,
-                   LPCSTR, arg1,
-                   LPCSTR, arg2)
-{
-  dprintf2(("KERNEL32: OS2lstrcmpA(%s,%s)\n",
+int WIN32API lstrcmpA(LPCSTR arg1, LPCSTR arg2)
+{
+  dprintf2(("KERNEL32: lstrcmpA(%s,%s)\n",
            arg1,
            arg2));
@@ -203,10 +195,7 @@
  *****************************************************************************/
 
-ODINFUNCTIONNODBG3(int, lstrncmpA,
-                   LPCSTR, arg1, 
-                   LPCSTR, arg2,
-                   int, l)
-{
-  dprintf2(("KERNEL32: OS2lstrncmpA(%s,%s,%d)\n",
+int WIN32API lstrncmpA(LPCSTR arg1, LPCSTR arg2, int l)
+{
+  dprintf2(("KERNEL32: lstrncmpA(%s,%s,%d)\n",
            arg1,
            arg2,
@@ -227,8 +216,5 @@
  * Author    : Przemyslaw Dobrowolski
  *****************************************************************************/
-ODINFUNCTIONNODBG3(INT, lstrncmpiA,
-                   LPCSTR, str1,
-                   LPCSTR, str2,
-                   INT, n )
+int WIN32API lstrncmpiA(LPCSTR str1, LPCSTR str2, INT n )
 {
   INT firstch,lastch;
@@ -251,8 +237,5 @@
 }
 //TODO: Don't know if this is completely correct
-ODINFUNCTIONNODBG3(int, lstrncmpiW,
-                   LPCWSTR, str1, 
-                   LPCWSTR, str2,
-                   int, n)
+int WIN32API lstrncmpiW(LPCWSTR str1, LPCWSTR str2, int n)
 {
   INT firstch,lastch;
@@ -287,7 +270,5 @@
  *****************************************************************************/
 
-ODINFUNCTIONNODBG2(int, lstrcmpW,
-                   LPCWSTR, arg1,
-                   LPCWSTR, arg2)
+int WIN32API lstrcmpW(LPCWSTR arg1, LPCWSTR arg2)
 {
     dprintf2(("KERNEL32: lstrcmpW (%08xh, %08xh)\n",
@@ -316,10 +297,7 @@
  *****************************************************************************/
 
-ODINFUNCTIONNODBG3(int, lstrncmpW,
-                   LPCWSTR, arg1,
-                   LPCWSTR, arg2,
-                   int, l)
-{
-  dprintf2(("KERNEL32: OS2lstrncmpW(%08xh,%08xh,%d)\n",
+int WIN32API lstrncmpW(LPCWSTR arg1, LPCWSTR arg2, int l)
+{
+  dprintf2(("KERNEL32: lstrncmpW(%08xh,%08xh,%d)\n",
            arg1,
            arg2,
@@ -343,7 +321,5 @@
  *****************************************************************************/
 
-ODINFUNCTIONNODBG2(LPSTR, lstrcpyA,
-                   LPSTR, dest,
-                   LPCSTR, src)
+LPSTR WIN32API lstrcpyA(LPSTR dest, LPCSTR src)
 {
     if ( (src == NULL) || (dest == NULL) ) // stupid parameter checking
@@ -366,7 +342,5 @@
  *****************************************************************************/
 
-ODINFUNCTIONNODBG2(LPWSTR, lstrcpyW,
-                   LPWSTR, dest,
-                   LPCWSTR, src)
+LPWSTR WIN32API lstrcpyW(LPWSTR dest, LPCWSTR src)
 {
     if ( (src == NULL) || (dest == NULL) ) // stupid parameter checking
@@ -392,8 +366,5 @@
  *****************************************************************************/
 
-ODINFUNCTIONNODBG3(LPSTR, lstrcpynA,
-                   LPSTR, arg1,
-                   LPCSTR, arg2,
-                   int, arg3)
+LPSTR WIN32API lstrcpynA(LPSTR arg1, LPCSTR arg2, int arg3)
 {
   register LPSTR p1 = arg1;
@@ -430,8 +401,5 @@
  *****************************************************************************/
 
-ODINFUNCTION3(LPWSTR, lstrcpynW,
-              LPWSTR, dst,
-              LPCWSTR, src,
-              int, n)
+LPWSTR WIN32API lstrcpynW(LPWSTR dst, LPCWSTR src, int n)
 {
     LPWSTR p = dst;
@@ -463,7 +431,5 @@
  *****************************************************************************/
 
-ODINFUNCTIONNODBG2(int, lstrcmpiA,
-                   LPCSTR, arg1,
-                   LPCSTR, arg2)
+int WIN32API lstrcmpiA(LPCSTR arg1, LPCSTR arg2)
 {
   dprintf2(("KERNEL32: lstrcmpiA(%s,%s)\n",
@@ -661,9 +627,6 @@
  *****************************************************************************/
 
-ODINFUNCTIONNODBG4(LPVOID, HEAP_xrealloc,
-                   HANDLE, heap,
-                   DWORD, flags,
-                   LPVOID, lpMem,
-                   DWORD, size )
+LPVOID WIN32API HEAP_xrealloc(HANDLE heap, DWORD flags, LPVOID lpMem,
+                              DWORD size )
 {
   LPVOID p = HeapReAlloc( heap, flags, lpMem, size );
@@ -692,6 +655,5 @@
  *****************************************************************************/
 
-ODINFUNCTIONNODBG1(LPVOID, HEAP_malloc,
-                   DWORD, size )
+LPVOID WIN32API HEAP_malloc(DWORD size )
 {
   LPVOID p = HeapAlloc( GetProcessHeap(), 0, size );
@@ -717,6 +679,5 @@
  *****************************************************************************/
 
-ODINFUNCTIONNODBG1(DWORD, HEAP_size,
-                   LPVOID, lpMem)
+DWORD WIN32API HEAP_size(LPVOID lpMem)
 {
   return HeapSize( GetProcessHeap(), 0, lpMem );
@@ -736,7 +697,5 @@
  *****************************************************************************/
 
-ODINFUNCTIONNODBG2(LPVOID, HEAP_realloc,
-                   LPVOID, lpMem,
-                   DWORD, size )
+LPVOID WIN32API HEAP_realloc(LPVOID lpMem, DWORD size )
 {
   LPVOID p = HeapReAlloc( GetProcessHeap(), 0, lpMem, size );
@@ -763,6 +722,5 @@
  *****************************************************************************/
 
-ODINFUNCTIONNODBG1(BOOL,   HEAP_free,
-                   LPVOID, lpMem)
+BOOL WIN32API HEAP_free(LPVOID lpMem)
 {
   return HeapFree( GetProcessHeap(), 0, lpMem);
@@ -782,8 +740,5 @@
  *****************************************************************************/
 
-ODINFUNCTIONNODBG3(LPSTR, HEAP_strdupA,
-                   HANDLE, heap,
-                   DWORD, flags,
-                   LPCSTR, str )
+LPSTR WIN32API HEAP_strdupA(HANDLE heap, DWORD flags, LPCSTR str )
 {
   int iLength = lstrlenA(str) + 1;
@@ -806,8 +761,5 @@
  *****************************************************************************/
 
-ODINFUNCTIONNODBG3(LPWSTR, HEAP_strdupW,
-                   HANDLE, heap,
-                   DWORD, flags,
-                   LPCWSTR, str )
+LPWSTR WIN32API HEAP_strdupW(HANDLE heap, DWORD flags, LPCWSTR str )
 {
     INT len = lstrlenW(str) + 1;
@@ -830,8 +782,5 @@
  *****************************************************************************/
 
-ODINFUNCTIONNODBG3(LPWSTR, HEAP_strdupAtoW,
-                   HANDLE, heap,
-                   DWORD, flags,
-                   LPCSTR, str )
+LPWSTR WIN32API HEAP_strdupAtoW(HANDLE heap, DWORD flags, LPCSTR str )
 {
     LPWSTR ret;
@@ -860,8 +809,5 @@
  *****************************************************************************/
 
-ODINFUNCTIONNODBG3(LPSTR, HEAP_strdupWtoA,
-                   HANDLE, heap,
-                   DWORD, flags,
-                   LPCWSTR, str )
+LPSTR WIN32API HEAP_strdupWtoA(HANDLE heap, DWORD flags, LPCWSTR str )
 {
     LPSTR ret;
Index: trunk/src/kernel32/kernel32.mak
===================================================================
--- trunk/src/kernel32/kernel32.mak	(revision 7850)
+++ trunk/src/kernel32/kernel32.mak	(revision 7854)
@@ -1,3 +1,3 @@
-# $Id: kernel32.mak,v 1.23 2002-02-08 15:09:30 sandervl Exp $
+# $Id: kernel32.mak,v 1.24 2002-02-09 17:27:31 sandervl Exp $
 
 #
@@ -16,5 +16,6 @@
 #
 !if "$(DEBUG)" == "1"
-DEFFILE = kernel32dbg.def
+DEFFILE    = kernel32dbg.def
+ORGDEFFILE = kernel32.def
 !endif
 
Index: trunk/src/kernel32/kernel32dbg.def
===================================================================
--- trunk/src/kernel32/kernel32dbg.def	(revision 7850)
+++ trunk/src/kernel32/kernel32dbg.def	(revision 7854)
@@ -1,3 +1,3 @@
-; $Id: kernel32dbg.def,v 1.3 2002-02-09 13:36:20 achimha Exp $
+; $Id: kernel32dbg.def,v 1.4 2002-02-09 17:27:31 sandervl Exp $
 
 ;Basis is Windows95 KERNEL32
@@ -1127,17 +1127,4 @@
     HEAP_strdupA               = _DbgHEAP_strdupA@12                 @1247 NONAME
     HEAP_strdupW               = _DbgHEAP_strdupW@12                 @1248 NONAME
-; AH 2002-02-09 export the debug functions under their mangled non debug name as well
-    _HEAP_xalloc@12            = HEAP_xalloc                         @1340 NONAME
-    _HEAP_xrealloc@16          = HEAP_xrealloc                       @1341 NONAME
-    _HEAP_malloc@4             = HEAP_malloc                         @1342 NONAME
-    _HEAP_realloc@8            = HEAP_realloc                        @1343 NONAME
-    _HEAP_size@4               = HEAP_size                           @1392 NONAME
-    _HEAP_free@4               = HEAP_free                           @1344 NONAME
-    _HEAP_strdupWtoA@12        = HEAP_strdupWtoA                     @1345 NONAME
-    _HEAP_strdupAtoW@12        = HEAP_strdupAtoW                     @1346 NONAME
-    _HEAP_strdupA@12           = HEAP_strdupA                        @1347 NONAME
-    _HEAP_strdupW@12           = HEAP_strdupW                        @1348 NONAME
-
-
 
     _VIRTUAL_MapFileA@12                                          @1251 NONAME
Index: trunk/src/kernel32/kobjects.cpp
===================================================================
--- trunk/src/kernel32/kobjects.cpp	(revision 7850)
+++ trunk/src/kernel32/kobjects.cpp	(revision 7854)
@@ -1,3 +1,3 @@
-/* $Id: kobjects.cpp,v 1.14 2001-12-06 15:57:51 sandervl Exp $ */
+/* $Id: kobjects.cpp,v 1.15 2002-02-09 17:27:32 sandervl Exp $ */
 
 /*
@@ -76,9 +76,7 @@
  *****************************************************************************/
 
-ODINFUNCTION4(HANDLE, CreateEventA,
-              LPSECURITY_ATTRIBUTES, lpsa,
-              BOOL, fManualReset,
-              BOOL, fInitialState,
-              LPCTSTR, lpszEventName)
+HANDLE WIN32API CreateEventA(LPSECURITY_ATTRIBUTES lpsa, BOOL fManualReset,
+                             BOOL fInitialState,
+                             LPCTSTR lpszEventName)
 {
   return(HMCreateEvent(lpsa,                         /* create event semaphore */
@@ -101,9 +99,7 @@
  *****************************************************************************/
 
-ODINFUNCTION4(HANDLE, CreateEventW,
-              LPSECURITY_ATTRIBUTES, arg1,
-              BOOL, arg2,
-              BOOL, arg3,
-              LPCWSTR, arg4)
+HANDLE WIN32API CreateEventW(LPSECURITY_ATTRIBUTES arg1,
+                             BOOL arg2, BOOL arg3,
+                             LPCWSTR arg4)
 {
   HANDLE rc;
@@ -142,8 +138,7 @@
  *****************************************************************************/
 
-ODINFUNCTION3(HANDLE, CreateMutexA,
-              LPSECURITY_ATTRIBUTES, lpsa,
-              BOOL, fInitialOwner,
-              LPCTSTR, lpszMutexName)
+HANDLE WIN32API CreateMutexA(LPSECURITY_ATTRIBUTES lpsa,
+                             BOOL fInitialOwner,
+                             LPCTSTR lpszMutexName)
 {
   dprintf(("KERNEL32: CreateMutexA(%s)\n",
@@ -168,8 +163,6 @@
  *****************************************************************************/
 
-ODINFUNCTION3(HANDLE, CreateMutexW,
-              PSECURITY_ATTRIBUTES, arg1,
-              BOOL, arg2,
-              LPCWSTR, arg3)
+HANDLE WIN32API CreateMutexW(LPSECURITY_ATTRIBUTES arg1, BOOL arg2,
+                             LPCWSTR arg3)
 {
   HANDLE rc;
@@ -207,6 +200,5 @@
  *****************************************************************************/
 
-ODINFUNCTION1(BOOL, ReleaseMutex,
-              HANDLE, mutex)
+BOOL WIN32API ReleaseMutex(HANDLE mutex)
 {
   return(HMReleaseMutex(mutex));
@@ -226,6 +218,5 @@
  *****************************************************************************/
 
-ODINFUNCTION1(BOOL, SetEvent,
-              HANDLE, hEvent)
+BOOL WIN32API SetEvent(HANDLE hEvent)
 {
   return(HMSetEvent(hEvent));
@@ -245,7 +236,5 @@
  *****************************************************************************/
 
-ODINFUNCTION2(DWORD, WaitForSingleObject,
-              HANDLE, hObject,
-              DWORD, timeout)
+DWORD WIN32API WaitForSingleObject(HANDLE hObject, DWORD timeout)
 {
   return(HMWaitForSingleObject(hObject,
@@ -273,8 +262,5 @@
  *****************************************************************************/
 
-ODINFUNCTION3(DWORD, WaitForSingleObjectEx,
-              HANDLE, hObject,
-              DWORD, dwTimeout,
-              BOOL, fAlertable)
+DWORD WIN32API WaitForSingleObjectEx(HANDLE hObject, DWORD dwTimeout, BOOL fAlertable)
 {
   dprintf(("Kernel32: WaitForSingleObjectEx(%08xh,%08xh,%08xh) not implemented correctly.\n",
@@ -301,6 +287,5 @@
  *****************************************************************************/
 
-ODINFUNCTION1(BOOL, FlushFileBuffers,
-              HANDLE, hFile)
+BOOL WIN32API FlushFileBuffers(HANDLE hFile)
 {
   return(HMFlushFileBuffers(hFile));
@@ -320,6 +305,5 @@
  *****************************************************************************/
 
-ODINFUNCTION1(UINT, SetHandleCount,
-              UINT, cHandles)
+UINT WIN32API SetHandleCount(UINT cHandles)
 {
   //SvL: Has no effect in NT; also ignore it
@@ -340,16 +324,7 @@
  *****************************************************************************/
 
-//******************************************************************************
-//SvL: 24-6-'97 - Added
-//SvL: 28-6-'97: Fix for timeSetEvent in Red Alert Map Editor
-//******************************************************************************
-ODINFUNCTION7(BOOL, DuplicateHandle,
-              HANDLE, srcprocess,
-              HANDLE, srchandle,
-              HANDLE, destprocess,
-              PHANDLE, desthandle,
-              DWORD, arg5,
-              BOOL, arg6,
-              DWORD, arg7)
+BOOL WIN32API DuplicateHandle(HANDLE srcprocess, HANDLE srchandle,
+                              HANDLE destprocess, PHANDLE desthandle,
+                              DWORD arg5, BOOL arg6, DWORD arg7)
 {
   BOOL rc;
@@ -388,9 +363,6 @@
  *****************************************************************************/
 
-ODINFUNCTION4(HANDLE, CreateSemaphoreA,
-              LPSECURITY_ATTRIBUTES, arg1,
-              LONG, arg2,
-              LONG, arg3,
-              LPCSTR, arg4)
+HANDLE WIN32API CreateSemaphoreA(LPSECURITY_ATTRIBUTES arg1,
+                                 LONG arg2, LONG arg3, LPCSTR arg4)
 {
   return HMCreateSemaphore(arg1,
@@ -413,9 +385,6 @@
  *****************************************************************************/
 
-ODINFUNCTION4(HANDLE, CreateSemaphoreW,
-              PSECURITY_ATTRIBUTES, arg1,
-              LONG, arg2,
-              LONG, arg3,
-              LPCWSTR, arg4)
+HANDLE WIN32API CreateSemaphoreW(LPSECURITY_ATTRIBUTES arg1, LONG arg2,
+                                 LONG arg3, LPCWSTR arg4)
 {
   HANDLE rc;
@@ -452,8 +421,5 @@
  *****************************************************************************/
 
-ODINFUNCTION3(HANDLE, OpenEventA,
-              DWORD,  arg1,
-              BOOL,   arg2,
-              LPCSTR, arg3)
+HANDLE WIN32API OpenEventA(DWORD  arg1, BOOL arg2, LPCSTR arg3)
 {
   dprintf(("KERNEL32: OpenEventA(%s)\n",
@@ -478,8 +444,6 @@
  *****************************************************************************/
 
-ODINFUNCTION3(HANDLE,  OpenEventW,
-              DWORD,   dwDesiredAccess,
-              BOOL,    bInheritHandle,
-              LPCWSTR, lpName)
+HANDLE WIN32API  OpenEventW(DWORD dwDesiredAccess, BOOL bInheritHandle,
+                            LPCWSTR lpName)
 {
   char  *asciiname;
@@ -511,8 +475,5 @@
  *****************************************************************************/
 
-ODINFUNCTION3(HANDLE, OpenMutexA,
-              DWORD,  arg1,
-              BOOL,   arg2,
-              LPCSTR, arg3)
+HANDLE WIN32API OpenMutexA(DWORD arg1, BOOL arg2, LPCSTR arg3)
 {
   dprintf(("KERNEL32: OpenMutexA(%s)\n",
@@ -537,8 +498,6 @@
  *****************************************************************************/
 
-ODINFUNCTION3(HANDLE,  OpenMutexW,
-              DWORD,   dwDesiredAccess,
-              BOOL,    bInheritHandle,
-              LPCWSTR, lpName)
+HANDLE WIN32API OpenMutexW(DWORD dwDesiredAccess, BOOL bInheritHandle,
+                           LPCWSTR lpName)
 {
   char  *asciiname;
@@ -570,8 +529,5 @@
  *****************************************************************************/
 
-ODINFUNCTION3(HANDLE, OpenSemaphoreA,
-              DWORD,  arg1,
-              BOOL,   arg2,
-              LPCSTR, arg3)
+HANDLE WIN32API OpenSemaphoreA(DWORD arg1, BOOL arg2, LPCSTR arg3)
 {
   dprintf(("KERNEL32: OpenSemaphoreA(%s)\n",
@@ -596,8 +552,6 @@
  *****************************************************************************/
 
-ODINFUNCTION3(HANDLE,  OpenSemaphoreW,
-              DWORD,   dwDesiredAccess,
-              BOOL,    bInheritHandle,
-              LPCWSTR, lpName)
+HANDLE WIN32API OpenSemaphoreW(DWORD dwDesiredAccess, BOOL bInheritHandle,
+                               LPCWSTR lpName)
 {
   char  *asciiname;
@@ -629,6 +583,5 @@
  *****************************************************************************/
 
-ODINFUNCTION1(BOOL, PulseEvent,
-              HANDLE, arg1)
+BOOL WIN32API PulseEvent(HANDLE arg1)
 {
   return HMPulseEvent(arg1);
@@ -648,8 +601,5 @@
  *****************************************************************************/
 
-ODINFUNCTION3(BOOL,   ReleaseSemaphore,
-              HANDLE, arg1,
-              LONG,   arg2,
-              PLONG,  arg3)
+BOOL WIN32API ReleaseSemaphore(HANDLE arg1, LONG arg2, PLONG arg3)
 {
   return HMReleaseSemaphore(arg1,
@@ -671,6 +621,5 @@
  *****************************************************************************/
 
-ODINFUNCTION1(BOOL,   ResetEvent,
-              HANDLE, arg1)
+BOOL WIN32API ResetEvent(HANDLE arg1)
 {
   return HMResetEvent(arg1);
@@ -690,9 +639,6 @@
  *****************************************************************************/
 
-ODINFUNCTION4(DWORD,          WaitForMultipleObjects,
-              DWORD,          arg1,
-              const HANDLE *, arg2,
-              BOOL,           arg3,
-              DWORD,          arg4)
+DWORD WIN32API WaitForMultipleObjects(DWORD arg1, const HANDLE * arg2,
+                                      BOOL arg3, DWORD arg4)
 {
   return HMWaitForMultipleObjects(arg1,
@@ -725,10 +671,7 @@
  *****************************************************************************/
 
-ODINFUNCTION5(DWORD, WaitForMultipleObjectsEx,
-              DWORD, cObjects,
-              CONST HANDLE *, lphObjects,
-              BOOL, fWaitAll,
-              DWORD, dwTimeout,
-              BOOL, fAlertable)
+DWORD WIN32API WaitForMultipleObjectsEx(DWORD cObjects, CONST HANDLE *lphObjects,
+                                        BOOL fWaitAll, DWORD dwTimeout,
+                                        BOOL fAlertable)
 {
   return(HMWaitForMultipleObjectsEx(cObjects,
@@ -752,10 +695,9 @@
  *****************************************************************************/
 
-ODINFUNCTION1(HANDLE, ConvertToGlobalHandle,
-              HANDLE, hHandle)
-
-//ODINFUNCTION2(HANDLE, ConvertToGlobalHandle,
-//              HANDLE, hHandle,
-//              BOOL,   fInherit)
+HANDLE WIN32API ConvertToGlobalHandle(HANDLE hHandle)
+
+//ODINFUNCTION2(HANDLE ConvertToGlobalHandle,
+//              HANDLE hHandle,
+//              BOOL   fInherit)
 {
   return (hHandle);
@@ -764,10 +706,10 @@
 //******************************************************************************
 //******************************************************************************
-ODINFUNCTION6(HANDLE,CreateThread,LPSECURITY_ATTRIBUTES,  lpsa,
-                                  DWORD,                  cbStack,
-                                  LPTHREAD_START_ROUTINE, lpStartAddr,
-                                  LPVOID,                 lpvThreadParm,
-                                  DWORD,                  fdwCreate,
-                                  LPDWORD,                lpIDThread)
+HANDLE WIN32API CreateThread(LPSECURITY_ATTRIBUTES  lpsa,
+                             DWORD                  cbStack,
+                             LPTHREAD_START_ROUTINE lpStartAddr,
+                             LPVOID                 lpvThreadParm,
+                             DWORD                  fdwCreate,
+                             LPDWORD                lpIDThread)
 {
     return HMCreateThread(lpsa, cbStack, lpStartAddr, lpvThreadParm, fdwCreate, lpIDThread);
Index: trunk/src/kernel32/npipe.cpp
===================================================================
--- trunk/src/kernel32/npipe.cpp	(revision 7850)
+++ trunk/src/kernel32/npipe.cpp	(revision 7854)
@@ -1,3 +1,3 @@
-/* $Id: npipe.cpp,v 1.9 2000-07-12 18:21:44 sandervl Exp $ */
+/* $Id: npipe.cpp,v 1.10 2002-02-09 17:27:32 sandervl Exp $ */
 /*
  * Win32 Named pipes API
@@ -27,32 +27,23 @@
 //******************************************************************************
 //******************************************************************************
-ODINFUNCTION6(BOOL,PeekNamedPipe,HANDLE ,hPipe,
-                                 LPVOID ,lpvBuffer,
-                                 DWORD  ,cbBuffer,
-                                 LPDWORD,lpcbRead,
-                                 LPDWORD,lpcbAvail,
-                                 LPDWORD,lpcbMessage)
+BOOL WIN32API PeekNamedPipe(HANDLE hPipe, LPVOID lpvBuffer,
+                            DWORD cbBuffer, LPDWORD lpcbRead,
+                            LPDWORD lpcbAvail, LPDWORD lpcbMessage)
 {
   return (HMPeekNamedPipe(hPipe,lpvBuffer,cbBuffer,lpcbRead,lpcbAvail,lpcbMessage));
 }
 //******************************************************************************
-//LPSECURITY_ATTRIBUTES lpsa;   /* address of security attributes   */
-//******************************************************************************
-ODINFUNCTION4(BOOL,                 CreatePipe,
-              PHANDLE,              phRead,
-              PHANDLE,              phWrite,
-              LPSECURITY_ATTRIBUTES,lpsa, 
-              DWORD,                cbPipe)
+//******************************************************************************
+BOOL WIN32API CreatePipe(PHANDLE phRead, PHANDLE  phWrite,
+                         LPSECURITY_ATTRIBUTES lpsa, DWORD cbPipe)
 {
   return (HMCreatePipe(phRead,phWrite,lpsa,cbPipe));
 }
-
-
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION8(HANDLE,CreateNamedPipeA,LPCTSTR,lpName, DWORD,dwOpenMode, DWORD,dwPipeMode,
-                                     DWORD, nMaxInstances, DWORD, nOutBufferSize,
-                                     DWORD, nInBufferSize, DWORD, nDefaultTimeOut,
-                                     LPSECURITY_ATTRIBUTES, lpSecurityAttributes)
+//******************************************************************************
+//******************************************************************************
+HANDLE WIN32API CreateNamedPipeA(LPCTSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode,
+                                 DWORD nMaxInstances, DWORD nOutBufferSize,
+                                 DWORD nInBufferSize, DWORD nDefaultTimeOut,
+                                 LPSECURITY_ATTRIBUTES lpSecurityAttributes)
 
 {
@@ -69,8 +60,8 @@
 //******************************************************************************
 //******************************************************************************
-ODINFUNCTION8(HANDLE,CreateNamedPipeW,LPCWSTR,lpName, DWORD,dwOpenMode, DWORD,dwPipeMode,
-                                     DWORD, nMaxInstances, DWORD, nOutBufferSize,
-                                     DWORD, nInBufferSize, DWORD, nDefaultTimeOut,
-                                     LPSECURITY_ATTRIBUTES,lpSecurityAttributes)
+HANDLE WIN32API CreateNamedPipeW(LPCWSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode,
+                                 DWORD  nMaxInstances, DWORD  nOutBufferSize,
+                                 DWORD  nInBufferSize, DWORD  nDefaultTimeOut,
+                                 LPSECURITY_ATTRIBUTES lpSecurityAttributes)
 {
   char *asciiname;
@@ -113,5 +104,5 @@
  * Author    : Przemyslaw Dobrowolski [Sun, 2000/01/02 12:48]
  *****************************************************************************/
-ODINFUNCTION2(BOOL,ConnectNamedPipe,HANDLE,hNamedPipe, LPOVERLAPPED,lpOverlapped)
+BOOL WIN32API ConnectNamedPipe(HANDLE hNamedPipe, LPOVERLAPPED lpOverlapped)
 {
   return (HMConnectNamedPipe(hNamedPipe,lpOverlapped));
@@ -152,11 +143,11 @@
  *****************************************************************************/
 
-ODINFUNCTION7(BOOL,CallNamedPipeA,LPCSTR , lpNamedPipeName,
-                                  LPVOID , lpInBuffer,
-                                  DWORD  , nInBufferSize,
-                                  LPVOID , lpOutBuffer,
-                                  DWORD  , nOutBufferSize,
-                                  LPDWORD, lpBytesRead,
-                                  DWORD  , nTimeOut)
+BOOL WIN32API CallNamedPipeA(LPCSTR  lpNamedPipeName,
+                             LPVOID  lpInBuffer,
+                             DWORD   nInBufferSize,
+                             LPVOID  lpOutBuffer,
+                             DWORD   nOutBufferSize,
+                             LPDWORD lpBytesRead,
+                             DWORD   nTimeOut)
 {
   return(OSLibDosCallNamedPipe(lpNamedPipeName,
@@ -202,11 +193,11 @@
  * Author    : Przemyslaw Dobrowolski [Mon, 2000/01/03 13:33]
  *****************************************************************************/
-ODINFUNCTION7(BOOL,CallNamedPipeW,LPCWSTR , lpNamedPipeName,
-                                  LPVOID , lpInBuffer,
-                                  DWORD  , nInBufferSize,
-                                  LPVOID , lpOutBuffer,
-                                  DWORD  , nOutBufferSize,
-                                  LPDWORD, lpBytesRead,
-                                  DWORD  , nTimeOut)
+BOOL WIN32API CallNamedPipeW(LPCWSTR lpNamedPipeName,
+                             LPVOID  lpInBuffer,
+                             DWORD   nInBufferSize,
+                             LPVOID  lpOutBuffer,
+                             DWORD   nOutBufferSize,
+                             LPDWORD lpBytesRead,
+                             DWORD   nTimeOut)
 {
   char *asciiname;
@@ -242,5 +233,5 @@
  *****************************************************************************/
 
-ODINFUNCTION1(BOOL,DisconnectNamedPipe,HANDLE,hNamedPipe)
+BOOL WIN32API DisconnectNamedPipe(HANDLE hNamedPipe)
 {
   return (HMDisconnectNamedPipe(hNamedPipe));
@@ -268,10 +259,10 @@
 
 BOOL WIN32API GetNamedPipeHandleStateA(HANDLE  hNamedPipe,
-                                          LPDWORD lpState,
-                                          LPDWORD lpCurInstances,
-                                          LPDWORD lpMaxCollectionCount,
-                                          LPDWORD lpCollectDataTimeout,
-                                          LPTSTR  lpUserName,
-                                          DWORD   nMaxUserNameSize)
+                                       LPDWORD lpState,
+                                       LPDWORD lpCurInstances,
+                                       LPDWORD lpMaxCollectionCount,
+                                       LPDWORD lpCollectDataTimeout,
+                                       LPTSTR  lpUserName,
+                                       DWORD   nMaxUserNameSize)
 {
   // Not implemented but waiting to implementation in hmnpipe.cpp
@@ -307,10 +298,10 @@
 
 BOOL WIN32API GetNamedPipeHandleStateW(HANDLE  hNamedPipe,
-                                          LPDWORD lpState,
-                                          LPDWORD lpCurInstances,
-                                          LPDWORD lpMaxCollectionCount,
-                                          LPDWORD lpCollectDataTimeout,
-                                          LPWSTR  lpUserName,
-                                          DWORD   nMaxUserNameSize)
+                                       LPDWORD lpState,
+                                       LPDWORD lpCurInstances,
+                                       LPDWORD lpMaxCollectionCount,
+                                       LPDWORD lpCollectDataTimeout,
+                                       LPWSTR  lpUserName,
+                                       DWORD   nMaxUserNameSize)
 {
   char *asciiname;
@@ -352,8 +343,8 @@
 
 BOOL WIN32API GetNamedPipeInfo(HANDLE  hNamedPipe,
-                                  LPDWORD lpFlags,
-                                  LPDWORD lpOutBufferSize,
-                                  LPDWORD lpInBufferSize,
-                                  LPDWORD lpMaxInstances)
+                               LPDWORD lpFlags,
+                               LPDWORD lpOutBufferSize,
+                               LPDWORD lpInBufferSize,
+                               LPDWORD lpMaxInstances)
 {
   // Not implemented but waiting to implementation in hmnpipe.cpp
@@ -417,11 +408,11 @@
  *****************************************************************************/
 
-ODINFUNCTION7(DWORD,TransactNamedPipe,HANDLE,hNamedPipe,
-                                      LPVOID,lpvWriteBuf,
-                                      DWORD,cbWriteBuf,
-                                      LPVOID,lpvReadBuf,
-                                      DWORD,cbReadBuf,
-                                      LPDWORD,lpcbRead,
-                                      LPOVERLAPPED,lpo)
+DWORD WIN32API TransactNamedPipe(HANDLE  hNamedPipe,
+                                 LPVOID  lpvWriteBuf,
+                                 DWORD   cbWriteBuf,
+                                 LPVOID  lpvReadBuf,
+                                 DWORD   cbReadBuf,
+                                 LPDWORD lpcbRead,
+                                 LPOVERLAPPED lpo)
 {
   return(HMTransactNamedPipe( hNamedPipe,
@@ -450,5 +441,5 @@
  *****************************************************************************/
 
-ODINFUNCTION2(BOOL,WaitNamedPipeA,LPCSTR,lpszNamedPipeName, DWORD, dwTimeout)
+BOOL WIN32API WaitNamedPipeA(LPCSTR lpszNamedPipeName, DWORD dwTimeout)
 {
   return(OSLibDosWaitNamedPipe(lpszNamedPipeName, dwTimeout));
@@ -472,5 +463,5 @@
  *****************************************************************************/
 
-ODINFUNCTION2(BOOL,WaitNamedPipeW,LPCWSTR,lpszNamedPipeName, DWORD, dwTimeout)
+BOOL WIN32API WaitNamedPipeW(LPCWSTR lpszNamedPipeName, DWORD dwTimeout)
 {
   char  *asciiname;
Index: trunk/src/kernel32/time.cpp
===================================================================
--- trunk/src/kernel32/time.cpp	(revision 7850)
+++ trunk/src/kernel32/time.cpp	(revision 7854)
@@ -1,3 +1,3 @@
-/* $Id: time.cpp,v 1.16 2001-07-20 15:33:30 sandervl Exp $ */
+/* $Id: time.cpp,v 1.17 2002-02-09 17:27:32 sandervl Exp $ */
 
 /*
@@ -87,6 +87,5 @@
 //******************************************************************************
 //******************************************************************************
-ODINPROCEDURE1(GetLocalTime,
-               LPSYSTEMTIME, arg1)
+void WIN32API GetLocalTime(LPSYSTEMTIME arg1)
 {
   O32_GetLocalTime(arg1);
@@ -94,6 +93,5 @@
 //******************************************************************************
 //******************************************************************************
-ODINFUNCTION1(BOOL, SetLocalTime,
-              const SYSTEMTIME *, arg1)
+BOOL WIN32API SetLocalTime(const SYSTEMTIME * arg1)
 {
   return O32_SetLocalTime(arg1);
@@ -101,8 +99,6 @@
 //******************************************************************************
 //******************************************************************************
-ODINFUNCTION3(BOOL,FileTimeToDosDateTime,
-              const FILETIME *, arg1, 
-              LPWORD, arg2, 
-              LPWORD,  arg3)
+BOOL WIN32API FileTimeToDosDateTime(const FILETIME * arg1,  LPWORD arg2, 
+                                    LPWORD arg3)
 {
     return O32_FileTimeToDosDateTime(arg1, arg2, arg3);
@@ -124,7 +120,5 @@
 //******************************************************************************
 //******************************************************************************
-ODINFUNCTION2(BOOL, FileTimeToSystemTime,
-              const FILETIME *, arg1, 
-              LPSYSTEMTIME, arg2)
+BOOL WIN32API FileTimeToSystemTime(const FILETIME * arg1, LPSYSTEMTIME arg2)
 {
   return O32_FileTimeToSystemTime(arg1, arg2);
@@ -132,8 +126,5 @@
 //******************************************************************************
 //******************************************************************************
-ODINFUNCTION3(BOOL,DosDateTimeToFileTime,
-              WORD, arg1, 
-              WORD, arg2, 
-              LPFILETIME, arg3)
+BOOL WIN32API DosDateTimeToFileTime(WORD arg1, WORD arg2, LPFILETIME arg3)
 {
     return O32_DosDateTimeToFileTime(arg1, arg2, arg3);
@@ -141,6 +132,5 @@
 //******************************************************************************
 //******************************************************************************
-ODINFUNCTION1(DWORD, GetTimeZoneInformation,
-              LPTIME_ZONE_INFORMATION, arg1)
+DWORD WIN32API GetTimeZoneInformation(LPTIME_ZONE_INFORMATION arg1)
 {
     return O32_GetTimeZoneInformation(arg1);
@@ -155,6 +145,5 @@
 //******************************************************************************
 //******************************************************************************
-ODINPROCEDURE1(GetSystemTime,
-               LPSYSTEMTIME, arg1)
+void WIN32API GetSystemTime(LPSYSTEMTIME arg1)
 {
     O32_GetSystemTime(arg1);
@@ -162,7 +151,6 @@
 //******************************************************************************
 //******************************************************************************
-ODINFUNCTION2(BOOL, SystemTimeToFileTime,
-              const SYSTEMTIME *, arg1, 
-              LPFILETIME,  arg2)
+BOOL WIN32API SystemTimeToFileTime(const SYSTEMTIME * arg1, 
+                                   LPFILETIME arg2)
 {
   return O32_SystemTimeToFileTime(arg1, arg2);
@@ -170,8 +158,7 @@
 //******************************************************************************
 //******************************************************************************
-ODINFUNCTION3(BOOL, SystemTimeToTzSpecificLocalTime,
-              LPTIME_ZONE_INFORMATION, arg1,
-              LPSYSTEMTIME, arg2,
-              LPSYSTEMTIME, arg3)
+BOOL WIN32API SystemTimeToTzSpecificLocalTime(LPTIME_ZONE_INFORMATION arg1,
+                                              LPSYSTEMTIME arg2,
+                                              LPSYSTEMTIME arg3)
 {
   return O32_SystemTimeToTzSpecificLocalTime(arg1, arg2, arg3);
@@ -179,6 +166,5 @@
 //******************************************************************************
 //******************************************************************************
-ODINFUNCTION1(BOOL, SetTimeZoneInformation,
-              const LPTIME_ZONE_INFORMATION, arg1)
+BOOL WIN32API SetTimeZoneInformation(const LPTIME_ZONE_INFORMATION arg1)
 {
   return O32_SetTimeZoneInformation(arg1);
@@ -186,6 +172,5 @@
 //******************************************************************************
 //******************************************************************************
-ODINFUNCTION1(BOOL,SetSystemTime,
-              const SYSTEMTIME *, arg1)
+BOOL WIN32API SetSystemTime(const SYSTEMTIME * arg1)
 {
   return O32_SetSystemTime(arg1);
