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

Timestamp:

Oct 15, 2001, 7:10:55 PM (24 years ago)

Author:

sandervl

Message:

custom build update

File:

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

trunk/src/kernel32/heap.cpp

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