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

Last change on this file since 4 was 4, checked in by ktk, 26 years ago

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