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

Last change on this file since 43 was 37, checked in by cbratschi, 26 years ago

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