source: trunk/src/kernel32/old/heap.cpp@ 3274

Last change on this file since 3274 was 955, checked in by sandervl, 26 years ago

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