lib/kernel32/mem/heap.c

   1 /* $Id$
   2  *
   3  * kernel/heap.c
   4  * Copyright (C) 1996, Onno Hovers, All rights reserved
   5  *
   6  * This software is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This software is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this software; see the file COPYING.LIB. If
  18  * not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  19  * Cambridge, MA 02139, USA.
  20  *
  21  * Win32 heap functions (HeapXXX).
  22  *
  23  */
  24
  25 /*
  26  * Adapted for the ReactOS system libraries by David Welch (welch@mcmail.com)
  27  * Put the type definitions of the heap in a seperate header. Boudewijn Dekker
  28  */
  29
  30 #include <k32.h>
  31
  32 #define NDEBUG
  33 #include <kernel32/kernel32.h>
  34
  35 /*********************************************************************
  36 *                     HeapCreate -- KERNEL32                         *
  37 *********************************************************************/
  38 HANDLE STDCALL HeapCreate(DWORD flags, DWORD dwInitialSize, DWORD dwMaximumSize)
  39 {
  40
  41    DPRINT("HeapCreate( 0x%lX, 0x%lX, 0x%lX )\n", flags, dwInitialSize, dwMaximumSize);
  42    return(RtlCreateHeap(flags, NULL, dwMaximumSize, dwInitialSize, NULL, NULL));
  43 }
  44
  45 /*********************************************************************
  46 *                     HeapDestroy -- KERNEL32                        *
  47 *********************************************************************/
  48 BOOL WINAPI HeapDestroy(HANDLE hheap)
  49 {
  50    return(RtlDestroyHeap(hheap));
  51 }
  52
  53 /*********************************************************************
  54 *                   GetProcessHeap  --  KERNEL32                     *
  55 *********************************************************************/
  56 HANDLE WINAPI GetProcessHeap(VOID)
  57 {
  58    DPRINT("GetProcessHeap()\n");
  59    return(RtlGetProcessHeap());
  60 }
  61
  62 /********************************************************************
  63 *                   GetProcessHeaps  --  KERNEL32                   *
  64 ********************************************************************/
  65 DWORD WINAPI GetProcessHeaps(DWORD maxheaps, PHANDLE phandles)
  66 {
  67    return(RtlGetProcessHeaps(maxheaps, phandles));
  68 }
  69
  70 /*********************************************************************
  71 *                    HeapLock  --  KERNEL32                          *
  72 *********************************************************************/
  73 BOOL WINAPI HeapLock(HANDLE hheap)
  74 {
  75    return(RtlLockHeap(hheap));
  76 }
  77
  78 /*********************************************************************
  79 *                    HeapUnlock  --  KERNEL32                        *
  80 *********************************************************************/
  81 BOOL WINAPI HeapUnlock(HANDLE hheap)
  82 {
  83    return(RtlUnlockHeap(hheap));
  84 }
  85
  86 /*********************************************************************
  87 *                    HeapCompact  --  KERNEL32                       *
  88 *                                                                    *
  89 * NT uses this function to compact moveable blocks and other things  *
  90 * Here it does not compact, but it finds the largest free region     *
  91 *********************************************************************/
  92 UINT WINAPI HeapCompact(HANDLE hheap, DWORD flags)
  93 {
  94    return RtlCompactHeap(hheap, flags);
  95 }
  96
  97 /*********************************************************************
  98 *                    HeapValidate  --  KERNEL32                      *
  99 *********************************************************************/
 100 BOOL WINAPI HeapValidate(HANDLE hheap, DWORD flags, LPCVOID pmem)
 101 {
 102    return(RtlValidateHeap(hheap, flags, (PVOID)pmem));
 103 }
 104
 105
 106 DWORD
 107 STDCALL
 108 HeapCreateTagsW (
 109         DWORD   Unknown0,
 110         DWORD   Unknown1,
 111         DWORD   Unknown2,
 112         DWORD   Unknown3
 113         )
 114 {
 115         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 116         return 0;
 117 }
 118
 119
 120 DWORD
 121 STDCALL
 122 HeapExtend (
 123         DWORD   Unknown0,
 124         DWORD   Unknown1,
 125         DWORD   Unknown2,
 126         DWORD   Unknown3
 127         )
 128 {
 129 #if 0
 130    NTSTATUS Status;
 131
 132    Status = RtlExtendHeap(Unknown1, Unknown2, Unknown3, Unknown4);
 133    if (!NT_SUCCESS(Status))
 134      {
 135         SetLastErrorByStatus(Status);
 136         return FALSE;
 137      }
 138    return TRUE;
 139 #endif
 140
 141    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 142    return 0;
 143 }
 144
 145
 146 DWORD
 147 STDCALL
 148 HeapQueryTagW (
 149         DWORD   Unknown0,
 150         DWORD   Unknown1,
 151         DWORD   Unknown2,
 152         DWORD   Unknown3,
 153         DWORD   Unknown4
 154         )
 155 {
 156         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 157         return 0;
 158 }
 159
 160
 161 DWORD
 162 STDCALL
 163 HeapSummary (
 164         DWORD   Unknown0,
 165         DWORD   Unknown1,
 166         DWORD   Unknown2
 167         )
 168 {
 169         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 170         return 0;
 171 }
 172
 173
 174 DWORD
 175 STDCALL
 176 HeapUsage (
 177         DWORD   Unknown0,
 178         DWORD   Unknown1,
 179         DWORD   Unknown2,
 180         DWORD   Unknown3,
 181         DWORD   Unknown4
 182         )
 183 {
 184         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 185         return 0;
 186 }
 187
 188
 189 WINBOOL
 190 STDCALL
 191 HeapWalk (
 192         HANDLE                  hHeap,
 193         LPPROCESS_HEAP_ENTRY    lpEntry
 194         )
 195 {
 196         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 197         return FALSE;
 198 }
 199
 200
 201 /* EOF */