Changeset 7065 for trunk/src/kernel32/heap.cpp

Timestamp:

Oct 15, 2001, 7:16:37 PM (24 years ago)

Author:

sandervl

Message:

* empty log message *

File:

• trunk/src/kernel32/heap.cpp (modified) (29 diffs)

trunk/src/kernel32/heap.cpp

@@ -1 @@
-/* $Id: heap.cpp,v 1.37 2001-10-15 17:10:54 sandervl Exp $ */
+/* $Id: heap.cpp,v 1.38 2001-10-15 17:16:37 sandervl Exp $ */
 
 /*
@@ -226 +226 @@
  *      NULL: Failure
  */
-HGLOBAL WINAPI GlobalAlloc(
-                 UINT flags, /* [in] Object allocation attributes */
-                 DWORD size    /* [in] Number of bytes to allocate */
-) {
+ODINFUNCTION2(HGLOBAL, GlobalAlloc,
+              UINT, flags,
+              DWORD, size)
+{
    PGLOBAL32_INTERN     pintern;
    DWORD                hpflags;
@@ -280 +280 @@
  *      NULL: Failure
  */
-LPVOID WINAPI GlobalLock(
-              HGLOBAL hmem /* [in] Handle of global memory object */
-) {
+ODINFUNCTION1(LPVOID, GlobalLock,
+              HGLOBAL, hmem)
+{
    PGLOBAL32_INTERN pintern;
    LPVOID           palloc;
@@ -328 +328 @@
  *      FALSE: Object is unlocked
  */
-BOOL WINAPI GlobalUnlock(
-              HGLOBAL hmem /* [in] Handle of global memory object */
-) {
+ODINFUNCTION1(BOOL, GlobalUnlock,
+              HGLOBAL, hmem)
+{
    PGLOBAL32_INTERN       pintern;
    BOOL                 locked;
-
-   dprintf(("KERNEL32: GlobalUnlock %x", hmem));
 
    if(hmem == NULL || ISPOINTER(hmem))
@@ -377 +375 @@
  *      NULL: Failure
  */
-HGLOBAL WINAPI GlobalHandle(
-                 LPCVOID pmem /* [in] Pointer to global memory block */
-) {
+ODINFUNCTION1(HGLOBAL, GlobalHandle,
+              LPCVOID, pmem)
+{
     HGLOBAL handle;
     PGLOBAL32_INTERN  maybe_intern;
     LPCVOID test;
-
-    dprintf(("KERNEL32: GlobalHandle %x", pmem));
 
     if (!pmem)
@@ -470 +466 @@
  *      NULL: Failure
  */
-HGLOBAL WINAPI GlobalReAlloc(
-                 HGLOBAL hmem, /* [in] Handle of global memory object */
-                 DWORD size,     /* [in] New size of block */
-                 UINT flags    /* [in] How to reallocate object */
-) {
+ODINFUNCTION3(HGLOBAL, GlobalReAlloc,
+                 HGLOBAL, hmem,
+                 DWORD, size,
+                 UINT, flags)
+{
    LPVOID               palloc;
    HGLOBAL            hnew;
@@ -580 +576 @@
  *      Handle: Failure
  */
-HGLOBAL WINAPI GlobalFree(
-                 HGLOBAL hmem /* [in] Handle of global memory object */
-) {
+ODINFUNCTION1(HGLOBAL, GlobalFree,
+              HGLOBAL, hmem)
+{
    PGLOBAL32_INTERN pintern;
    HGLOBAL        hreturned = 0;
-
-   dprintf(("KERNEL32: GlobalFree %x", hmem));
 
    /* verify lpMem address */
@@ -631 +625 @@
  *      0: Failure
  */
-DWORD WINAPI GlobalSize(
-             HGLOBAL hmem /* [in] Handle of global memory object */
-) {
+ODINFUNCTION1(DWORD, GlobalSize,
+              HGLOBAL, hmem)
+{
    DWORD                retval;
    PGLOBAL32_INTERN     pintern;
-
-   dprintf(("KERNEL32: GlobalSize %x", hmem));
 
    if(ISPOINTER(hmem)) 
@@ -674 +666 @@
  *           GlobalWire   (KERNEL32.@)
  */
-LPVOID WINAPI GlobalWire(HGLOBAL hmem)
+ODINFUNCTION1(LPVOID, GlobalWire,
+              HGLOBAL, hmem)
 {
    return GlobalLock( hmem );
@@ -683 +676 @@
  *           GlobalUnWire   (KERNEL32.@)
  */
-BOOL WINAPI GlobalUnWire(HGLOBAL hmem)
+ODINFUNCTION1(BOOL, GlobalUnWire,
+              HGLOBAL, hmem)
 {
    return GlobalUnlock( hmem);
@@ -692 +686 @@
  *           GlobalFix   (KERNEL32.@)
  */
-VOID WINAPI GlobalFix(HGLOBAL hmem)
+ODINPROCEDURE1(GlobalFix,
+               HGLOBAL, hmem)
 {
     GlobalLock( hmem );
@@ -701 +696 @@
  *           GlobalUnfix   (KERNEL32.@)
  */
-VOID WINAPI GlobalUnfix(HGLOBAL hmem)
+ODINPROCEDURE1(GlobalUnfix,
+               HGLOBAL, hmem)
 {
    GlobalUnlock( hmem);
@@ -718 +714 @@
  *      GMEM_INVALID_HANDLE: Failure
  */
-UINT WINAPI GlobalFlags(
-              HGLOBAL hmem /* [in] Handle to global memory object */
-) {
+ODINFUNCTION1(UINT, GlobalFlags,
+              HGLOBAL, hmem)
+{
    DWORD                retval;
    PGLOBAL32_INTERN     pintern;
 
-   dprintf(("KERNEL32: GlobalFlags %x", hmem));
-   
    if(ISPOINTER(hmem))
    {
@@ -754 +748 @@
  *           GlobalCompact   (KERNEL32.@)
  */
-DWORD WINAPI GlobalCompact( DWORD minfree )
-{
-    dprintf(("KERNEL32:  GlobalCompact %d OBSOLETE", minfree));
-
+ODINFUNCTION1(DWORD, GlobalCompact,
+              DWORD, minfree )
+{
     return 0;  /* GlobalCompact does nothing in Win32 */
 }
@@ -766 +759 @@
 #endif
 //******************************************************************************
-HGLOBAL WIN32API GlobalAlloc(UINT fuFlags, DWORD dwBytes)
+ODINFUNCTION2(HGLOBAL, GlobalAlloc,
+              UINT, fuFlags, 
+              DWORD, dwBytes)
 {
  HGLOBAL ret;
@@ -774 +769 @@
     totalGlobalAlloc += dwBytes;
 #endif
-    dprintf(("KERNEL32: GlobalAlloc %x %d returned %x (total %x)", fuFlags, dwBytes, ret, totalGlobalAlloc));
     return ret;
 }
 //******************************************************************************
 //******************************************************************************
-HGLOBAL WIN32API GlobalFree( HGLOBAL arg1)
+ODINFUNCTION1(HGLOBAL, GlobalFree,
+              HGLOBAL, arg1)
 {
  HGLOBAL ret;
@@ -787 +782 @@
 #endif
     ret = O32_GlobalFree(arg1);
-    dprintf(("KERNEL32: GlobalFree %x returned %x (lasterr=%x) total %x", arg1, ret, GetLastError(), totalGlobalAlloc));
     return ret;
 }
 //******************************************************************************
 //******************************************************************************
-HGLOBAL WIN32API GlobalHandle( LPCVOID lpMem)
-{
-    dprintf(("KERNEL32: GlobalHandle %x", lpMem));
-
+ODINFUNCTION1(HGLOBAL, GlobalHandle,
+              LPCVOID, lpMem)
+{
     return O32_GlobalHandle((LPVOID)lpMem);
 }
 //******************************************************************************
 //******************************************************************************
-UINT WIN32API GlobalFlags(HGLOBAL hMem)
-{
-    dprintf(("KERNEL32: GlobalFlags %x", hMem));
-
+ODINFUNCTION1(UINT, GlobalFlags,
+              HGLOBAL, hMem)
+{
     return O32_GlobalFlags(hMem);
 }
 //******************************************************************************
 //******************************************************************************
-DWORD WIN32API GlobalCompact(DWORD dwMinFree)
-{
-  dprintf(("KERNEL32:  GlobalCompact, OBSOLETE - stub\n"));
-
+ODINFUNCTION1(DWORD, GlobalCompact,
+              DWORD, dwMinFree)
+{
   return(0);
 }
 //******************************************************************************
 //******************************************************************************
-PVOID WIN32API GlobalLock(HGLOBAL hMem)
-{
- PVOID ret;
-
-    ret = O32_GlobalLock(hMem);
-    dprintf(("KERNEL32: GlobalLock %x returned %x", hMem, ret));
-    return ret;
-}
-//******************************************************************************
-//******************************************************************************
-HGLOBAL WIN32API GlobalReAlloc(HGLOBAL arg1, DWORD arg2, UINT  arg3)
-{
-    dprintf(("KERNEL32: GlobalReAlloc %x %x %d", arg1, arg2, arg3));
-
+ODINFUNCTION1(PVOID, GlobalLock,
+              HGLOBAL, hMem)
+{
+  return O32_GlobalLock(hMem);
+}
+//******************************************************************************
+//******************************************************************************
+ODINFUNCTION3(HGLOBAL, GlobalReAlloc,
+              HGLOBAL, arg1,
+              DWORD, arg2,
+              UINT,  arg3)
+{
     return O32_GlobalReAlloc(arg1, arg2, arg3);
 }
 //******************************************************************************
 //******************************************************************************
-DWORD WIN32API GlobalSize(HGLOBAL arg1)
-{
-    dprintf(("KERNEL32:  GlobalSize\n"));
-
+ODINFUNCTION1(DWORD, GlobalSize,
+              HGLOBAL, arg1)
+{
     return O32_GlobalSize(arg1);
 }
 //******************************************************************************
 //******************************************************************************
-BOOL WIN32API GlobalUnlock(HGLOBAL arg1)
-{
-    dprintf(("KERNEL32:  GlobalUnlock\n"));
-
+ODINFUNCTION1(BOOL, GlobalUnlock,
+              HGLOBAL, arg1)
+{
     return O32_GlobalUnlock(arg1);
 }
@@ -856 +843 @@
  *
  */
-LPVOID WIN32API GlobalWire(HGLOBAL hmem)
+ODINFUNCTION1(LPVOID, GlobalWire,
+              HGLOBAL, hmem)
 {
    return GlobalLock( hmem );
@@ -868 +856 @@
  *
  */
-BOOL WIN32API GlobalUnWire(HGLOBAL hmem)
+ODINFUNCTION1(BOOL, GlobalUnWire,
+              HGLOBAL, hmem)
 {
    return GlobalUnlock( hmem);
@@ -874 +863 @@
 //******************************************************************************
 //******************************************************************************
-HGLOBAL WIN32API GlobalDiscard(HGLOBAL hGlobal)
-{
-    dprintf(("KERNEL32: GlobalDiscard %x", hGlobal));
-
+ODINFUNCTION1(HGLOBAL, GlobalDiscard,
+              HGLOBAL, hGlobal)
+{
     return O32_GlobalDiscard(hGlobal);
 }
@@ -883 +871 @@
  *           GlobalFix   (KERNEL32.@)
  */
-VOID WINAPI GlobalFix(HGLOBAL hmem)
+ODINPROCEDURE1(GlobalFix,
+               HGLOBAL, hmem)
 {
     GlobalLock( hmem );
@@ -890 +879 @@
  *           GlobalUnfix   (KERNEL32.@)
  */
-VOID WINAPI GlobalUnfix(HGLOBAL hmem)
+ODINPROCEDURE1(GlobalUnfix,
+               HGLOBAL, hmem)
 {
    GlobalUnlock( hmem);
@@ -897 +887 @@
 //******************************************************************************
 //******************************************************************************
-HLOCAL WIN32API LocalAlloc(UINT fuFlags, DWORD cbBytes)
+ODINFUNCTION2(HLOCAL, LocalAlloc,
+              UINT, fuFlags, 
+              DWORD, cbBytes)
 {
     HLOCAL hLocal;
@@ -916 +908 @@
 //******************************************************************************
 //******************************************************************************
-UINT WIN32API LocalFlags(HLOCAL hMem)
+ODINFUNCTION1(UINT, LocalFlags,
+              HLOCAL, hMem)
 {
     UINT ret, retG;
-    dprintf(("KERNEL32: LocalFlags %X\n", hMem));
 
     retG = GlobalFlags(hMem);
@@ -937 +929 @@
 //******************************************************************************
 //******************************************************************************
-HLOCAL WIN32API LocalFree(HLOCAL hMem)
-{
-  dprintf(("KERNEL32: LocalFree %X", hMem));
-
+ODINFUNCTION1(HLOCAL, LocalFree,
+              HLOCAL, hMem)
+{
   return GlobalFree(hMem);
 }
 //******************************************************************************
 //******************************************************************************
-HLOCAL WIN32API LocalHandle(PCVOID lpMem)
-{
-    dprintf(("KERNEL32: LocalHandle %x", lpMem));
-
+ODINFUNCTION1(HLOCAL, LocalHandle,
+              PCVOID, lpMem)
+{
     return GlobalHandle(lpMem);
 }
 //******************************************************************************
 //******************************************************************************
-BOOL WIN32API LocalUnlock(HLOCAL hMem)
-{
-    dprintf(("KERNEL32: LocalUnlock %X", hMem));
-
+ODINFUNCTION1(BOOL, LocalUnlock,
+              HLOCAL, hMem)
+{
     return GlobalUnlock(hMem);
 }
@@ -962 +951 @@
 //TODO: cbBytes==0 && fuFlags & LMEM_MOVEABLE not handled!!
 //******************************************************************************
-HLOCAL WIN32API LocalReAlloc(HLOCAL hMem, DWORD cbBytes, UINT fuFlags)
+ODINFUNCTION3(HLOCAL, LocalReAlloc,
+              HLOCAL, hMem,
+              DWORD, cbBytes,
+              UINT, fuFlags)
 {
   HLOCAL hLocalNew, hLocalOld;
   LPVOID lpMem, lpMemOld;
   DWORD  cbOldSize;
-
-    dprintf(("KERNEL32: LocalReAlloc %X %d %X\n", hMem, cbBytes, fuFlags));
 
     // Check flags
@@ -988 +978 @@
 //******************************************************************************
 //******************************************************************************
-UINT WIN32API LocalSize(HLOCAL hMem)
-{
-    dprintf(("KERNEL32: LocalSize %X", hMem));
-
+ODINFUNCTION1(UINT, LocalSize,
+              HLOCAL, hMem)
+{
     return GlobalSize(hMem);
 }
 //******************************************************************************
 //******************************************************************************
-PVOID WIN32API LocalLock(HLOCAL hMem)
-{
-    dprintf(("KERNEL32:  LocalLock %X\n", hMem));
-
+ODINFUNCTION1(PVOID, LocalLock,
+              HLOCAL, hMem)
+{
     return GlobalLock(hMem);
 }
@@ -1005 +993 @@
 //* this function is here for completeness, some stupid software requires it.
 //******************************************************************************
-UINT WIN32API LocalShrink(HLOCAL hMem, UINT cbNewSize)
-{
-    dprintf(("KERNEL32:  LocalShrink %X, %08xh - OBSOLETE", hMem, cbNewSize));
-
+ODINFUNCTION2(UINT, LocalShrink,
+              HLOCAL, hMem,
+              UINT, cbNewSize)
+{
     return cbNewSize;
 }
@@ -1014 +1002 @@
 //* this function is here for completeness, mIRC/32 requires it.
 //******************************************************************************
-UINT WIN32API LocalCompact(UINT cbNewSize)
-{
-    dprintf(("KERNEL32:  LocalCompact %08xh - OBSOLETE", cbNewSize));
-
+ODINFUNCTION1(UINT, LocalCompact,
+              UINT, cbNewSize)
+{
     return cbNewSize;
 }