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 /*
  39  * @implemented
  40  */
  41 HANDLE STDCALL HeapCreate(DWORD flags, DWORD dwInitialSize, DWORD dwMaximumSize)
  42 {
  43
  44    DPRINT("HeapCreate( 0x%lX, 0x%lX, 0x%lX )\n", flags, dwInitialSize, dwMaximumSize);
  45    return(RtlCreateHeap(flags, NULL, dwMaximumSize, dwInitialSize, NULL, NULL));
  46 }
  47
  48 /*********************************************************************
  49 *                     HeapDestroy -- KERNEL32                        *
  50 *********************************************************************/
  51 /*
  52  * @implemented
  53  */
  54 BOOL WINAPI HeapDestroy(HANDLE hheap)
  55 {
  56    return(RtlDestroyHeap(hheap));
  57 }
  58
  59 /*********************************************************************
  60 *                   GetProcessHeap  --  KERNEL32                     *
  61 *********************************************************************/
  62 /*
  63  * @implemented
  64  */
  65 HANDLE WINAPI GetProcessHeap(VOID)
  66 {
  67    DPRINT("GetProcessHeap()\n");
  68    return(RtlGetProcessHeap());
  69 }
  70
  71 /********************************************************************
  72 *                   GetProcessHeaps  --  KERNEL32                   *
  73 ********************************************************************/
  74 /*
  75  * @implemented
  76  */
  77 DWORD WINAPI GetProcessHeaps(DWORD maxheaps, PHANDLE phandles)
  78 {
  79    return(RtlGetProcessHeaps(maxheaps, phandles));
  80 }
  81
  82 /*********************************************************************
  83 *                    HeapLock  --  KERNEL32                          *
  84 *********************************************************************/
  85 /*
  86  * @implemented
  87  */
  88 BOOL WINAPI HeapLock(HANDLE hheap)
  89 {
  90    return(RtlLockHeap(hheap));
  91 }
  92
  93 /*********************************************************************
  94 *                    HeapUnlock  --  KERNEL32                        *
  95 *********************************************************************/
  96 /*
  97  * @implemented
  98  */
  99 BOOL WINAPI HeapUnlock(HANDLE hheap)
 100 {
 101    return(RtlUnlockHeap(hheap));
 102 }
 103
 104 /*********************************************************************
 105 *                    HeapCompact  --  KERNEL32                       *
 106 *                                                                    *
 107 * NT uses this function to compact moveable blocks and other things  *
 108 * Here it does not compact, but it finds the largest free region     *
 109 *********************************************************************/
 110 /*
 111  * @implemented
 112  */
 113 UINT WINAPI HeapCompact(HANDLE hheap, DWORD flags)
 114 {
 115    return RtlCompactHeap(hheap, flags);
 116 }
 117
 118 /*********************************************************************
 119 *                    HeapValidate  --  KERNEL32                      *
 120 *********************************************************************/
 121 /*
 122  * @implemented
 123  */
 124 BOOL WINAPI HeapValidate(HANDLE hheap, DWORD flags, LPCVOID pmem)
 125 {
 126    return(RtlValidateHeap(hheap, flags, (PVOID)pmem));
 127 }
 128
 129
 130 /*
 131  * @unimplemented
 132  */
 133 DWORD
 134 STDCALL
 135 HeapCreateTagsW (
 136         DWORD   Unknown0,
 137         DWORD   Unknown1,
 138         DWORD   Unknown2,
 139         DWORD   Unknown3
 140         )
 141 {
 142         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 143         return 0;
 144 }
 145
 146
 147 /*
 148  * @unimplemented
 149  */
 150 DWORD
 151 STDCALL
 152 HeapExtend (
 153         DWORD   Unknown0,
 154         DWORD   Unknown1,
 155         DWORD   Unknown2,
 156         DWORD   Unknown3
 157         )
 158 {
 159 #if 0
 160    NTSTATUS Status;
 161
 162    Status = RtlExtendHeap(Unknown1, Unknown2, Unknown3, Unknown4);
 163    if (!NT_SUCCESS(Status))
 164      {
 165         SetLastErrorByStatus(Status);
 166         return FALSE;
 167      }
 168    return TRUE;
 169 #endif
 170
 171    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 172    return 0;
 173 }
 174
 175
 176 /*
 177  * @unimplemented
 178  */
 179 DWORD
 180 STDCALL
 181 HeapQueryTagW (
 182         DWORD   Unknown0,
 183         DWORD   Unknown1,
 184         DWORD   Unknown2,
 185         DWORD   Unknown3,
 186         DWORD   Unknown4
 187         )
 188 {
 189         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 190         return 0;
 191 }
 192
 193
 194 /*
 195  * @unimplemented
 196  */
 197 DWORD
 198 STDCALL
 199 HeapSummary (
 200         DWORD   Unknown0,
 201         DWORD   Unknown1,
 202         DWORD   Unknown2
 203         )
 204 {
 205         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 206         return 0;
 207 }
 208
 209
 210 /*
 211  * @unimplemented
 212  */
 213 DWORD
 214 STDCALL
 215 HeapUsage (
 216         DWORD   Unknown0,
 217         DWORD   Unknown1,
 218         DWORD   Unknown2,
 219         DWORD   Unknown3,
 220         DWORD   Unknown4
 221         )
 222 {
 223         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 224         return 0;
 225 }
 226
 227
 228 /*
 229  * @unimplemented
 230  */
 231 WINBOOL
 232 STDCALL
 233 HeapWalk (
 234         HANDLE                  hHeap,
 235         LPPROCESS_HEAP_ENTRY    lpEntry
 236         )
 237 {
 238         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 239         return FALSE;
 240 }
 241
 242
 243 /* EOF */