source: trunk/src/kernel32/heap.cpp@ 4145

Last change on this file since 4145 was 3464, checked in by sandervl, 26 years ago

LocalGetFlags bugfix + some extra checks for invalid pointers
File size: 13.9 KB
Line 
1/* $Id: heap.cpp,v 1.20 2000-04-30 16:31:47 sandervl Exp $ */
2
3/*
4 * Win32 heap API functions for OS/2
5 *
6 * Copyright 1999 Sander van Leeuwen
7 *
8 * Project Odin Software License can be found in LICENSE.TXT
9 *
10 */
11
12#include <os2win.h>
13#include <stdlib.h>
14#include <string.h>
15#include <misc.h>
16#define _WIN32
17#include "os2heap.h"
18#include <heap.h>
19#include <odinwrap.h>
20
21#define DBG_LOCALLOG DBG_heap
22#include "dbglocal.h"
23
24static HANDLE processheap = NULL;
25OS2Heap *OS2ProcessHeap = NULL;
26
27//******************************************************************************
28//******************************************************************************
29ODINFUNCTIONNODBG3(LPVOID, HeapAlloc, HANDLE, hHeap, DWORD, dwFlags,
30 DWORD, dwBytes)
31{
32 OS2Heap *curheap = OS2Heap::find(hHeap);
33 LPVOID rc;
34
35 if(curheap == NULL)
36 return(NULL);
37
38 rc = curheap->Alloc(dwFlags, dwBytes);
39 dprintf2(("HeapAlloc %X bytes -> %x", dwBytes, rc));
40 return rc;
41}
42//******************************************************************************
43//******************************************************************************
44ODINFUNCTIONNODBG4(LPVOID, HeapReAlloc, HANDLE, hHeap, DWORD, dwFlags, LPVOID,
45 lpMem, DWORD, dwBytes)
46{
47 OS2Heap *curheap = OS2Heap::find(hHeap);
48
49 dprintf2(("HeapReAlloc %X bytes", dwBytes));
50 if(curheap == NULL)
51 return(NULL);
52
53 return(curheap->ReAlloc(dwFlags, lpMem, dwBytes));
54}
55//******************************************************************************
56//******************************************************************************
57ODINFUNCTIONNODBG3(BOOL, HeapFree, HANDLE, hHeap, DWORD, dwFlags, LPVOID, lpMem)
58{
59 OS2Heap *curheap = OS2Heap::find(hHeap);
60
61 dprintf2(("HeapFree %X", lpMem));
62 if(curheap == NULL)
63 return(FALSE);
64
65 return(curheap->Free(dwFlags, lpMem));
66}
67//******************************************************************************
68//******************************************************************************
69ODINFUNCTIONNODBG3(HANDLE, HeapCreate, DWORD, flOptions, DWORD, dwInitialSize,
70 DWORD, dwMaximumSize)
71{
72 OS2Heap *curheap;
73
74 //Create Open32 heap for it's handle
75 dprintf2(("HeapCreate dwInitialSize %X", dwInitialSize));
76 HANDLE hHeap = O32_HeapCreate(flOptions, 0, 4096);
77 if(hHeap == NULL)
78 return(NULL);
79
80 curheap = new OS2Heap(hHeap, flOptions, dwInitialSize, dwMaximumSize);
81
82 if(curheap == NULL)
83 {
84 O32_HeapDestroy(hHeap);
85 return(NULL);
86 }
87
88 if(curheap->getHeapHandle() == NULL)
89 {
90 O32_HeapDestroy(hHeap);
91 delete(curheap);
92 return(NULL);
93 }
94 return(curheap->getHeapHandle());
95}
96//******************************************************************************
97//******************************************************************************
98ODINFUNCTIONNODBG1(BOOL, HeapDestroy, HANDLE, hHeap)
99{
100 OS2Heap *curheap = OS2Heap::find(hHeap);
101
102 dprintf2(("HeapDestroy %X", hHeap));
103 if(curheap == NULL)
104 return(FALSE);
105
106 O32_HeapDestroy(curheap->getHeapHandle());
107 delete(curheap);
108 return(TRUE);
109}
110//******************************************************************************
111//******************************************************************************
112ODINFUNCTIONNODBG3(DWORD, HeapSize, HANDLE, hHeap, DWORD, arg2, PVOID, arg3)
113{
114 OS2Heap *curheap = OS2Heap::find(hHeap);
115
116 dprintf2(("HeapSize %X %x", hHeap, arg2));
117 if(curheap == NULL)
118 return(0);
119 return curheap->Size(arg2, arg3);
120}
121//******************************************************************************
122//TODO: Check this!!!
123//******************************************************************************
124ODINFUNCTIONNODBG2(DWORD, HeapCompact, HANDLE, hHeap, DWORD, dwFlags)
125{
126 dprintf(("KERNEL32: HeapCompact: Unknown API - stub\n"));
127 return(0);
128}
129//******************************************************************************
130//******************************************************************************
131ODINFUNCTIONNODBG3(BOOL, HeapValidate, HANDLE, hHeap, DWORD, dwFlags, LPCVOID, lpMem)
132{
133 dprintf(("KERNEL32: HeapValidate - stub\n"));
134 return(TRUE);
135}
136//******************************************************************************
137//******************************************************************************
138ODINFUNCTIONNODBG1(BOOL, HeapUnlock, HANDLE, hHeap)
139{
140 dprintf(("KERNEL32: HeapUnlock - stub (TRUE)\n"));
141 return(TRUE);
142}
143//******************************************************************************
144//******************************************************************************
145ODINFUNCTIONNODBG1(BOOL, HeapLock, HANDLE, hHeap)
146{
147 dprintf(("KERNEL32: HeapLock - stub (TRUE)\n"));
148 return(TRUE);
149}
150//******************************************************************************
151// LPPROCESS_HEAP_ENTRY lpEntry
152//******************************************************************************
153ODINFUNCTIONNODBG2(BOOL, HeapWalk, HANDLE, hHeap, LPVOID, lpEntry)
154{
155 dprintf(("KERNEL32: HeapWalk - stub (TRUE)\n"));
156 return(TRUE);
157}
158//******************************************************************************
159//******************************************************************************
160ODINFUNCTIONNODBG0(HANDLE, GetProcessHeap)
161{
162 HANDLE hHeap;
163
164// dprintf2(("KERNEL32: GetProcessHeap\n"));
165 //SvL: Only one process heap per process
166 if(processheap == NULL) {
167 //TODO: I haven't thought real hard about this. I added it just to make "hdr.exe" happy.
168 hHeap = O32_HeapCreate(HEAP_GENERATE_EXCEPTIONS, 1, 0x4000);
169
170 OS2ProcessHeap = new OS2Heap(hHeap, HEAP_GENERATE_EXCEPTIONS, 0x4000, 0);
171
172 if(OS2ProcessHeap == NULL) {
173 O32_HeapDestroy(hHeap);
174 return(NULL);
175 }
176 processheap = hHeap;
177 }
178 return(processheap);
179}
180//******************************************************************************
181//******************************************************************************
182HLOCAL WIN32API LocalAlloc(UINT fuFlags, DWORD cbBytes)
183{
184 HLOCAL lmem;
185 DWORD dwFlags = 0;
186
187 if(processheap == NULL) {
188 if(GetProcessHeap() == NULL)
189 return(NULL);
190 }
191 if(fuFlags & LMEM_ZEROINIT)
192 dwFlags = HEAP_ZERO_MEMORY;
193
194 lmem = (HLOCAL)OS2ProcessHeap->Alloc(dwFlags, cbBytes, fuFlags);
195
196 dprintf(("KERNEL32: LocalAlloc flags %X, size %d returned %X\n", dwFlags, cbBytes, lmem));
197
198 return(lmem);
199}
200//******************************************************************************
201//******************************************************************************
202HLOCAL WIN32API LocalDiscard(HLOCAL hMem)
203{
204 dprintf(("KERNEL32: LocalDiscard NOT IMPLEMENTED\n"));
205
206// return O32_LocalDiscard(arg1);
207 return(hMem); //TODO: Possible memory leak
208}
209//******************************************************************************
210//******************************************************************************
211UINT WIN32API LocalFlags(HLOCAL hMem)
212{
213 dprintf(("KERNEL32: LocalFlags %X\n", hMem));
214
215 return OS2ProcessHeap->GetFlags((LPVOID)hMem);
216}
217//******************************************************************************
218//******************************************************************************
219HLOCAL WIN32API LocalFree(HLOCAL hMem)
220{
221 dprintf(("KERNEL32: LocalFree %X\n", hMem));
222
223 if(OS2ProcessHeap->GetLockCnt((LPVOID)hMem) != 0) {
224 dprintf(("LocalFree, lock count != 0\n"));
225 return(hMem); //TODO: SetLastError
226 }
227 if(OS2ProcessHeap->Free(0, (LPVOID)hMem) == FALSE) {
228 return(hMem); //TODO: SetLastError
229 }
230 return NULL; //success
231}
232//******************************************************************************
233//******************************************************************************
234HLOCAL WIN32API LocalHandle(PCVOID lpMem)
235{
236 dprintf(("KERNEL32: LocalHandle\n"));
237
238 return (HLOCAL)lpMem;
239}
240//******************************************************************************
241//******************************************************************************
242BOOL WIN32API LocalUnlock(HLOCAL hMem)
243{
244 dprintf(("KERNEL32: LocalUnlock %X\n", hMem));
245
246 return OS2ProcessHeap->Unlock((LPVOID)hMem);
247}
248//******************************************************************************
249//TODO: cbBytes==0 && fuFlags & LMEM_MOVEABLE not handled!!
250//******************************************************************************
251HLOCAL WIN32API LocalReAlloc(HLOCAL hMem, DWORD cbBytes, UINT fuFlags)
252{
253 HLOCAL hLocalNew;
254 LPVOID lpMem;
255
256 dprintf(("KERNEL32: LocalReAlloc %X %d %X\n", hMem, cbBytes, fuFlags));
257
258 //SvL: 8-8-'98: Notepad bugfix (assumes address is identical when new size < old size)
259 if(OS2ProcessHeap->Size(0, (LPVOID)hMem) > cbBytes)
260 return hMem;
261
262 hLocalNew = LocalAlloc(fuFlags, cbBytes);
263 if (hLocalNew != 0)
264 {
265 lpMem = LocalLock(hLocalNew);
266
267 if (lpMem != NULL) /* copy memory if successful */
268 memcpy(lpMem,
269 (LPVOID)hMem,
270 min(cbBytes, OS2ProcessHeap->Size(0, (LPVOID)hMem))
271 );
272
273 LocalUnlock(hLocalNew);
274 OS2ProcessHeap->Free(0, (LPVOID)hMem);
275 }
276 return(hLocalNew);
277}
278//******************************************************************************
279//******************************************************************************
280UINT WIN32API LocalSize(HLOCAL hMem)
281{
282 dprintf(("KERNEL32: LocalSize %X\n", hMem));
283
284 return OS2ProcessHeap->Size(0, (PVOID)hMem);
285}
286//******************************************************************************
287//******************************************************************************
288PVOID WIN32API LocalLock(HLOCAL hMem)
289{
290 dprintf(("KERNEL32: LocalLock %X\n", hMem));
291
292 OS2ProcessHeap->Lock((LPVOID)hMem);
293 return (PVOID)hMem;
294}
295//******************************************************************************
296
297//******************************************************************************
298//* this function is here for completeness, some stupid software requires it.
299UINT WIN32API LocalShrink(HLOCAL hMem,
300 UINT cbNewSize)
301{
302 dprintf(("KERNEL32: LocalShrink %X, %08xh - stub (cbNewSize)\n",
303 hMem,
304 cbNewSize));
305
306 return cbNewSize;
307}
308//******************************************************************************
309
310//******************************************************************************
311//* this function is here for completeness, mIRC/32 requires it.
312UINT WIN32API LocalCompact(UINT cbNewSize)
313{
314 dprintf(("KERNEL32: LocalCompact %08xh - stub (cbNewSize)\n",
315 cbNewSize));
316
317 return cbNewSize;
318}
319//******************************************************************************
320//******************************************************************************
321HGLOBAL WIN32API GlobalAlloc(UINT fuFlags, DWORD dwBytes)
322{
323 dprintf(("KERNEL32: GlobalAlloc %d\n", dwBytes));
324
325 return O32_GlobalAlloc(fuFlags, dwBytes);
326}
327//******************************************************************************
328//******************************************************************************
329HGLOBAL WIN32API GlobalFree( HGLOBAL arg1)
330{
331 dprintf(("KERNEL32: GlobalFree\n"));
332
333 return O32_GlobalFree(arg1);
334}
335//******************************************************************************
336//******************************************************************************
337HGLOBAL WIN32API GlobalHandle( LPCVOID arg1)
338{
339 dprintf(("KERNEL32: OS2GlobalHandle\n"));
340
341 return O32_GlobalHandle((LPVOID)arg1);
342}
343//******************************************************************************
344//******************************************************************************
345UINT WIN32API GlobalFlags(HGLOBAL arg1)
346{
347 dprintf(("KERNEL32: OS2GlobalFlags\n"));
348
349 return O32_GlobalFlags(arg1);
350}
351//******************************************************************************
352//******************************************************************************
353DWORD WIN32API GlobalCompact(DWORD dwMinFree)
354{
355 dprintf(("KERNEL32: GlobalCompact, OBSOLETE - stub\n"));
356
357 return(0);
358}
359//******************************************************************************
360//******************************************************************************
361PVOID WIN32API GlobalLock(HGLOBAL arg1)
362{
363 dprintf(("KERNEL32: GlobalLock\n"));
364
365 return O32_GlobalLock(arg1);
366}
367//******************************************************************************
368//******************************************************************************
369HGLOBAL WIN32API GlobalReAlloc(HGLOBAL arg1, DWORD arg2, UINT arg3)
370{
371 dprintf(("KERNEL32: GlobalReAlloc\n"));
372
373 return O32_GlobalReAlloc(arg1, arg2, arg3);
374}
375//******************************************************************************
376//******************************************************************************
377DWORD WIN32API GlobalSize(HGLOBAL arg1)
378{
379 dprintf(("KERNEL32: GlobalSize\n"));
380
381 return O32_GlobalSize(arg1);
382}
383//******************************************************************************
384//******************************************************************************
385BOOL WIN32API GlobalUnlock(HGLOBAL arg1)
386{
387 dprintf(("KERNEL32: GlobalUnlock\n"));
388
389 return O32_GlobalUnlock(arg1);
390}
391/***********************************************************************
392 * GlobalWire
393 *
394 * The GlobalWire function is obsolete. It is provided only for compatibility
395 * with 16-bit versions of Windows. Applications that need to lock a global
396 * memory object should use the GlobalLock and GlobalUnlock functions.
397 *
398 */
399LPVOID WIN32API GlobalWire(HGLOBAL hmem)
400{
401 return GlobalLock( hmem );
402}
403
404
405/***********************************************************************
406 * GlobalUnWire
407 *
408 * The GlobalUnWire function is obsolete. It is provided only for compatibility
409 * with 16-bit versions of Windows. Applications that need to lock a global
410 * memory object should use the GlobalLock and GlobalUnlock functions.
411 *
412 */
413BOOL WIN32API GlobalUnWire(HGLOBAL hmem)
414{
415 return GlobalUnlock( hmem);
416}
417//******************************************************************************
418//******************************************************************************
Note: See TracBrowser for help on using the repository browser.