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

Last change on this file since 4310 was 4224, checked in by sandervl, 25 years ago

exception changes, implemented enumresourcelanguages + put back some old code
File size: 14.3 KB
Line 
1/* $Id: heap.cpp,v 1.22 2000-09-08 18:07:50 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#ifdef DEBUG
321static ULONG totalGlobalAlloc = 0;
322#endif
323//******************************************************************************
324HGLOBAL WIN32API GlobalAlloc(UINT fuFlags, DWORD dwBytes)
325{
326 HGLOBAL ret;
327
328 ret = O32_GlobalAlloc(fuFlags, dwBytes);
329#ifdef DEBUG
330 totalGlobalAlloc += dwBytes;
331#endif
332 dprintf(("KERNEL32: GlobalAlloc %x %d returned %x (total %x)", fuFlags, dwBytes, ret, totalGlobalAlloc));
333 return ret;
334}
335//******************************************************************************
336//******************************************************************************
337HGLOBAL WIN32API GlobalFree( HGLOBAL arg1)
338{
339 HGLOBAL ret;
340
341#ifdef DEBUG
342 totalGlobalAlloc -= O32_GlobalSize(arg1);
343#endif
344 ret = O32_GlobalFree(arg1);
345 dprintf(("KERNEL32: GlobalFree %x returned %x (lasterr=%x) total %x", arg1, ret, GetLastError(), totalGlobalAlloc));
346 return ret;
347}
348//******************************************************************************
349//******************************************************************************
350HGLOBAL WIN32API GlobalHandle( LPCVOID arg1)
351{
352 dprintf(("KERNEL32: OS2GlobalHandle\n"));
353
354 return O32_GlobalHandle((LPVOID)arg1);
355}
356//******************************************************************************
357//******************************************************************************
358UINT WIN32API GlobalFlags(HGLOBAL arg1)
359{
360 dprintf(("KERNEL32: OS2GlobalFlags\n"));
361
362 return O32_GlobalFlags(arg1);
363}
364//******************************************************************************
365//******************************************************************************
366DWORD WIN32API GlobalCompact(DWORD dwMinFree)
367{
368 dprintf(("KERNEL32: GlobalCompact, OBSOLETE - stub\n"));
369
370 return(0);
371}
372//******************************************************************************
373//******************************************************************************
374PVOID WIN32API GlobalLock(HGLOBAL arg1)
375{
376 PVOID ret;
377
378 ret = O32_GlobalLock(arg1);
379 dprintf(("KERNEL32: GlobalLock %x returned %x", arg1, ret));
380 return ret;
381}
382//******************************************************************************
383//******************************************************************************
384HGLOBAL WIN32API GlobalReAlloc(HGLOBAL arg1, DWORD arg2, UINT arg3)
385{
386 dprintf(("KERNEL32: GlobalReAlloc\n"));
387
388 return O32_GlobalReAlloc(arg1, arg2, arg3);
389}
390//******************************************************************************
391//******************************************************************************
392DWORD WIN32API GlobalSize(HGLOBAL arg1)
393{
394 dprintf(("KERNEL32: GlobalSize\n"));
395
396 return O32_GlobalSize(arg1);
397}
398//******************************************************************************
399//******************************************************************************
400BOOL WIN32API GlobalUnlock(HGLOBAL arg1)
401{
402 dprintf(("KERNEL32: GlobalUnlock\n"));
403
404 return O32_GlobalUnlock(arg1);
405}
406/***********************************************************************
407 * GlobalWire
408 *
409 * The GlobalWire function is obsolete. It is provided only for compatibility
410 * with 16-bit versions of Windows. Applications that need to lock a global
411 * memory object should use the GlobalLock and GlobalUnlock functions.
412 *
413 */
414LPVOID WIN32API GlobalWire(HGLOBAL hmem)
415{
416 return GlobalLock( hmem );
417}
418
419
420/***********************************************************************
421 * GlobalUnWire
422 *
423 * The GlobalUnWire function is obsolete. It is provided only for compatibility
424 * with 16-bit versions of Windows. Applications that need to lock a global
425 * memory object should use the GlobalLock and GlobalUnlock functions.
426 *
427 */
428BOOL WIN32API GlobalUnWire(HGLOBAL hmem)
429{
430 return GlobalUnlock( hmem);
431}
432//******************************************************************************
433//******************************************************************************
Note: See TracBrowser for help on using the repository browser.