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