?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 980215
[wine.git] / memory / local.c
blobcb572e8561b10cac4629e1c603fea5cf5ba1ae73
1 /*
2 * Local heap functions
3 *
4 * Copyright 1995 Alexandre Julliard
5 * Copyright 1996 Huw Davies
6 */
7
8 /*
9 * Note:
10 * All local heap functions need the current DS as first parameter
11 * when called from the emulation library, so they take one more
12 * parameter than usual.
13 */
14
15 #include <stdlib.h>
16 #include <string.h>
17 #include "windows.h"
18 #include "ldt.h"
19 #include "task.h"
20 #include "global.h"
21 #include "heap.h"
22 #include "instance.h"
23 #include "local.h"
24 #include "module.h"
25 #include "stackframe.h"
26 #include "toolhelp.h"
27 #include "stddebug.h"
28 #include "debug.h"
29
30 /* needed only for GDI_HeapSel and USER_HeapSel */
31 #include "gdi.h"
32 #include "user.h"
33
34 typedef struct
35 {
36 /* Arena header */
37 WORD prev; /* Previous arena | arena type */
38 WORD next; /* Next arena */
39 /* Start of the memory block or free-list info */
40 WORD size; /* Size of the free block */
41 WORD free_prev; /* Previous free block */
42 WORD free_next; /* Next free block */
43 } LOCALARENA;
44
45 #define ARENA_HEADER_SIZE 4
46 #define ARENA_HEADER( handle) ( ((handle) & ~3) - ARENA_HEADER_SIZE)
47
48 /* Arena types (stored in 'prev' field of the arena) */
49 #define LOCAL_ARENA_FREE 0
50 #define LOCAL_ARENA_FIXED 1
51
52 /* Layout of a handle entry table
53 *
54 * WORD count of entries
55 * LOCALHANDLEENTRY[count] entries
56 * WORD near ptr to next table
57 */
58 typedef struct
59 {
60 WORD addr; /* Address of the MOVEABLE block */
61 BYTE flags; /* Flags for this block */
62 BYTE lock; /* Lock count */
63 } LOCALHANDLEENTRY;
64
65 /*
66 * We make addr = 4n + 2 and set *((WORD *)addr - 1) = &addr like Windows does
67 * in case something actually relies on this.
68 * Note the ARENA_HEADER(addr) still produces the desired result ie. 4n - 4
69 *
70 * An unused handle has lock = flags = 0xff. In windows addr is that of next
71 * free handle, at the moment in wine we set it to 0.
72 *
73 * A discarded block's handle has lock = addr = 0 and flags = 0x40
74 * (LMEM_DISCARDED >> 8)
75 */
76
77 #pragma pack(1)
78
79 typedef struct
80 {
81 WORD check; /* 00 Heap checking flag */
82 WORD freeze; /* 02 Heap frozen flag */
83 WORD items; /* 04 Count of items on the heap */
84 WORD first; /* 06 First item of the heap */
85 WORD pad1; /* 08 Always 0 */
86 WORD last; /* 0a Last item of the heap */
87 WORD pad2; /* 0c Always 0 */
88 BYTE ncompact; /* 0e Compactions counter */
89 BYTE dislevel; /* 0f Discard level */
90 DWORD distotal; /* 10 Total bytes discarded */
91 WORD htable; /* 14 Pointer to handle table */
92 WORD hfree; /* 16 Pointer to free handle table */
93 WORD hdelta; /* 18 Delta to expand the handle table */
94 WORD expand; /* 1a Pointer to expand function (unused) */
95 WORD pstat; /* 1c Pointer to status structure (unused) */
96 FARPROC16 notify WINE_PACKED; /* 1e Pointer to LocalNotify() function */
97 WORD lock; /* 22 Lock count for the heap */
98 WORD extra; /* 24 Extra bytes to allocate when expanding */
99 WORD minsize; /* 26 Minimum size of the heap */
100 WORD magic; /* 28 Magic number */
101 } LOCALHEAPINFO;
102
103 #pragma pack(4)
104
105 #define LOCAL_HEAP_MAGIC 0x484c /* 'LH' */
106
107
108 /* All local heap allocations are aligned on 4-byte boundaries */
109 #define LALIGN(word) (((word) + 3) & ~3)
110
111 #define ARENA_PTR(ptr,arena) ((LOCALARENA *)((char*)(ptr)+(arena)))
112 #define ARENA_PREV(ptr,arena) (ARENA_PTR((ptr),(arena))->prev & ~3)
113 #define ARENA_NEXT(ptr,arena) (ARENA_PTR((ptr),(arena))->next)
114 #define ARENA_FLAGS(ptr,arena) (ARENA_PTR((ptr),(arena))->prev & 3)
115
116 /* determine whether the handle belongs to a fixed or a moveable block */
117 #define HANDLE_FIXED(handle) (((handle) & 3) == 0)
118 #define HANDLE_MOVEABLE(handle) (((handle) & 3) == 2)
119
120 /***********************************************************************
121 * LOCAL_GetHeap
122 *
123 * Return a pointer to the local heap, making sure it exists.
124 */
125 static LOCALHEAPINFO *LOCAL_GetHeap( HANDLE16 ds )
126 {
127 LOCALHEAPINFO *pInfo;
128 INSTANCEDATA *ptr = (INSTANCEDATA *)PTR_SEG_OFF_TO_LIN( ds, 0 );
129 dprintf_local( stddeb, "Heap at %p, %04x\n", ptr, ptr->heap );
130 if (!ptr || !ptr->heap) return NULL;
131 if (IsBadReadPtr16( (SEGPTR)MAKELONG(ptr->heap,ds), sizeof(LOCALHEAPINFO)))
132 return NULL;
133 pInfo = (LOCALHEAPINFO*)((char*)ptr + ptr->heap);
134 if (pInfo->magic != LOCAL_HEAP_MAGIC) return NULL;
135 return pInfo;
136 }
137
138
139 /***********************************************************************
140 * LOCAL_MakeBlockFree
141 *
142 * Make a block free, inserting it in the free-list.
143 * 'block' is the handle of the block arena; 'baseptr' points to
144 * the beginning of the data segment containing the heap.
145 */
146 static void LOCAL_MakeBlockFree( char *baseptr, WORD block )
147 {
148 LOCALARENA *pArena, *pNext;
149 WORD next;
150
151 /* Mark the block as free */
152
153 pArena = ARENA_PTR( baseptr, block );
154 pArena->prev = (pArena->prev & ~3) | LOCAL_ARENA_FREE;
155 pArena->size = pArena->next - block;
156
157 /* Find the next free block (last block is always free) */
158
159 next = pArena->next;
160 for (;;)
161 {
162 pNext = ARENA_PTR( baseptr, next );
163 if ((pNext->prev & 3) == LOCAL_ARENA_FREE) break;
164 next = pNext->next;
165 }
166
167 dprintf_local( stddeb, "Local_MakeBlockFree %04x, next %04x\n", block, next );
168 /* Insert the free block in the free-list */
169
170 pArena->free_prev = pNext->free_prev;
171 pArena->free_next = next;
172 ARENA_PTR(baseptr,pNext->free_prev)->free_next = block;
173 pNext->free_prev = block;
174 }
175
176
177 /***********************************************************************
178 * LOCAL_RemoveFreeBlock
179 *
180 * Remove a block from the free-list.
181 * 'block' is the handle of the block arena; 'baseptr' points to
182 * the beginning of the data segment containing the heap.
183 */
184 static void LOCAL_RemoveFreeBlock( char *baseptr, WORD block )
185 {
186 /* Mark the block as fixed */
187
188 LOCALARENA *pArena = ARENA_PTR( baseptr, block );
189 pArena->prev = (pArena->prev & ~3) | LOCAL_ARENA_FIXED;
190
191 /* Remove it from the list */
192
193 ARENA_PTR(baseptr,pArena->free_prev)->free_next = pArena->free_next;
194 ARENA_PTR(baseptr,pArena->free_next)->free_prev = pArena->free_prev;
195 }
196
197
198 /***********************************************************************
199 * LOCAL_AddBlock
200 *
201 * Insert a new block in the heap.
202 * 'new' is the handle of the new block arena; 'baseptr' points to
203 * the beginning of the data segment containing the heap; 'prev' is
204 * the block before the new one.
205 */
206 static void LOCAL_AddBlock( char *baseptr, WORD prev, WORD new )
207 {
208 LOCALARENA *pPrev = ARENA_PTR( baseptr, prev );
209 LOCALARENA *pNew = ARENA_PTR( baseptr, new );
210
211 pNew->prev = (prev & ~3) | LOCAL_ARENA_FIXED;
212 pNew->next = pPrev->next;
213 ARENA_PTR(baseptr,pPrev->next)->prev &= 3;
214 ARENA_PTR(baseptr,pPrev->next)->prev |= new;
215 pPrev->next = new;
216 }
217
218
219 /***********************************************************************
220 * LOCAL_RemoveBlock
221 *
222 * Remove a block from the heap.
223 * 'block' is the handle of the block arena; 'baseptr' points to
224 * the beginning of the data segment containing the heap.
225 */
226 static void LOCAL_RemoveBlock( char *baseptr, WORD block )
227 {
228 LOCALARENA *pArena, *pTmp;
229
230 /* Remove the block from the free-list */
231
232 dprintf_local( stddeb, "Local_RemoveBlock\n");
233 pArena = ARENA_PTR( baseptr, block );
234 if ((pArena->prev & 3) == LOCAL_ARENA_FREE)
235 LOCAL_RemoveFreeBlock( baseptr, block );
236
237 /* If the previous block is free, expand its size */
238
239 pTmp = ARENA_PTR( baseptr, pArena->prev & ~3 );
240 if ((pTmp->prev & 3) == LOCAL_ARENA_FREE)
241 pTmp->size += pArena->next - block;
242
243 /* Remove the block from the linked list */
244
245 pTmp->next = pArena->next;
246 pTmp = ARENA_PTR( baseptr, pArena->next );
247 pTmp->prev = (pTmp->prev & 3) | (pArena->prev & ~3);
248 }
249
250
251 /***********************************************************************
252 * LOCAL_PrintHeap
253 */
254 static void LOCAL_PrintHeap( HANDLE16 ds )
255 {
256 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
257 LOCALHEAPINFO *pInfo = LOCAL_GetHeap( ds );
258 WORD arena;
259
260 if (!debugging_local) return;
261 if (!pInfo)
262 {
263 printf( "Local Heap corrupted! ds=%04x\n", ds );
264 return;
265 }
266 printf( "Local Heap ds=%04x first=%04x last=%04x items=%d\n",
267 ds, pInfo->first, pInfo->last, pInfo->items );
268
269 arena = pInfo->first;
270 for (;;)
271 {
272 LOCALARENA *pArena = ARENA_PTR(ptr,arena);
273 printf( " %04x: prev=%04x next=%04x type=%d\n", arena,
274 pArena->prev & ~3, pArena->next, pArena->prev & 3 );
275 if (arena == pInfo->first)
276 {
277 printf( " size=%d free_prev=%04x free_next=%04x\n",
278 pArena->size, pArena->free_prev, pArena->free_next );
279 }
280 if ((pArena->prev & 3) == LOCAL_ARENA_FREE)
281 {
282 printf( " size=%d free_prev=%04x free_next=%04x\n",
283 pArena->size, pArena->free_prev, pArena->free_next );
284 if (pArena->next == arena) break; /* last one */
285 if (ARENA_PTR(ptr,pArena->free_next)->free_prev != arena)
286 {
287 printf( "*** arena->free_next->free_prev != arena\n" );
288 break;
289 }
290 }
291 if (pArena->next == arena)
292 {
293 printf( "*** last block is not marked free\n" );
294 break;
295 }
296 if ((ARENA_PTR(ptr,pArena->next)->prev & ~3) != arena)
297 {
298 printf( "*** arena->next->prev != arena (%04x, %04x)\n",
299 pArena->next, ARENA_PTR(ptr,pArena->next)->prev);
300 break;
301 }
302 arena = pArena->next;
303 }
304 }
305
306
307 /***********************************************************************
308 * LocalInit (KERNEL.4)
309 */
310 BOOL16 WINAPI LocalInit( HANDLE16 selector, WORD start, WORD end )
311 {
312 char *ptr;
313 WORD heapInfoArena, freeArena, lastArena;
314 LOCALHEAPINFO *pHeapInfo;
315 LOCALARENA *pArena, *pFirstArena, *pLastArena;
316 NE_MODULE *pModule;
317
318 /* The initial layout of the heap is: */
319 /* - first arena (FIXED) */
320 /* - heap info structure (FIXED) */
321 /* - large free block (FREE) */
322 /* - last arena (FREE) */
323
324 dprintf_local(stddeb, "LocalInit: %04x %04x-%04x\n", selector, start, end);
325 if (!selector) selector = CURRENT_DS;
326
327 if (debugging_heap)
328 {
329 /* If debugging_heap is set, the global heap blocks are cleared */
330 /* before use, so we can test for double initialization. */
331 if (LOCAL_GetHeap(selector))
332 {
333 fprintf( stderr, "LocalInit: Heap %04x initialized twice.\n", selector);
334 LOCAL_PrintHeap(selector);
335 }
336 }
337
338 if (start == 0) {
339 /* Check if the segment is the DGROUP of a module */
340
341 if ((pModule = MODULE_GetPtr( selector )))
342 {
343 SEGTABLEENTRY *pSeg = NE_SEG_TABLE( pModule ) + pModule->dgroup - 1;
344 if (pModule->dgroup && (pSeg->selector == selector)) {
345 /* We can't just use the simple method of using the value
346 * of minsize + stacksize, since there are programs that
347 * resize the data segment before calling InitTask(). So,
348 * we must put it at the end of the segment */
349 start = GlobalSize16( GlobalHandle16( selector ) );
350 start -= end;
351 end += start;
352 dprintf_local( stddeb," new start %04x, minstart: %04x\n", start, pSeg->minsize + pModule->stack_size);
353 }
354 }
355 }
356 ptr = PTR_SEG_OFF_TO_LIN( selector, 0 );
357
358 start = LALIGN( MAX( start, sizeof(INSTANCEDATA) ) );
359 heapInfoArena = LALIGN(start + sizeof(LOCALARENA) );
360 freeArena = LALIGN( heapInfoArena + ARENA_HEADER_SIZE
361 + sizeof(LOCALHEAPINFO) );
362 lastArena = (end - sizeof(LOCALARENA)) & ~3;
363
364 /* Make sure there's enough space. */
365
366 if (freeArena + sizeof(LOCALARENA) >= lastArena) return FALSE;
367
368 /* Initialise the first arena */
369
370 pFirstArena = ARENA_PTR( ptr, start );
371 pFirstArena->prev = start | LOCAL_ARENA_FIXED;
372 pFirstArena->next = heapInfoArena;
373 pFirstArena->size = LALIGN(sizeof(LOCALARENA));
374 pFirstArena->free_prev = start; /* this one */
375 pFirstArena->free_next = freeArena;
376
377 /* Initialise the arena of the heap info structure */
378
379 pArena = ARENA_PTR( ptr, heapInfoArena );
380 pArena->prev = start | LOCAL_ARENA_FIXED;
381 pArena->next = freeArena;
382
383 /* Initialise the heap info structure */
384
385 pHeapInfo = (LOCALHEAPINFO *) (ptr + heapInfoArena + ARENA_HEADER_SIZE );
386 memset( pHeapInfo, 0, sizeof(LOCALHEAPINFO) );
387 pHeapInfo->items = 4;
388 pHeapInfo->first = start;
389 pHeapInfo->last = lastArena;
390 pHeapInfo->htable = 0;
391 pHeapInfo->hdelta = 0x20;
392 pHeapInfo->extra = 0x200;
393 pHeapInfo->minsize = lastArena - freeArena;
394 pHeapInfo->magic = LOCAL_HEAP_MAGIC;
395
396 /* Initialise the large free block */
397
398 pArena = ARENA_PTR( ptr, freeArena );
399 pArena->prev = heapInfoArena | LOCAL_ARENA_FREE;
400 pArena->next = lastArena;
401 pArena->size = lastArena - freeArena;
402 pArena->free_prev = start;
403 pArena->free_next = lastArena;
404
405 /* Initialise the last block */
406
407 pLastArena = ARENA_PTR( ptr, lastArena );
408 pLastArena->prev = freeArena | LOCAL_ARENA_FREE;
409 pLastArena->next = lastArena; /* this one */
410 pLastArena->size = LALIGN(sizeof(LOCALARENA));
411 pLastArena->free_prev = freeArena;
412 pLastArena->free_next = lastArena; /* this one */
413
414 /* Store the local heap address in the instance data */
415
416 ((INSTANCEDATA *)ptr)->heap = heapInfoArena + ARENA_HEADER_SIZE;
417 LOCAL_PrintHeap( selector );
418 return TRUE;
419 }
420
421 /***********************************************************************
422 * LOCAL_GrowHeap
423 */
424 static void LOCAL_GrowHeap( HANDLE16 ds )
425 {
426 HANDLE16 hseg = GlobalHandle16( ds );
427 LONG oldsize = GlobalSize16( hseg );
428 LONG end;
429 LOCALHEAPINFO *pHeapInfo;
430 WORD freeArena, lastArena;
431 LOCALARENA *pArena, *pLastArena;
432 char *ptr;
433
434 /* if nothing can be gained, return */
435 if (oldsize > 0xfff0) return;
436 hseg = GlobalReAlloc16( hseg, 0x10000, GMEM_FIXED );
437 ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
438 pHeapInfo = LOCAL_GetHeap( ds );
439 if (pHeapInfo == NULL) {
440 fprintf( stderr, "Local_GrowHeap: heap not found\n" );
441 return;
442 }
443 end = GlobalSize16( hseg );
444 lastArena = (end - sizeof(LOCALARENA)) & ~3;
445
446 /* Update the HeapInfo */
447 pHeapInfo->items++;
448 freeArena = pHeapInfo->last;
449 pHeapInfo->last = lastArena;
450 pHeapInfo->minsize += end - oldsize;
451
452 /* grow the old last block */
453 pArena = ARENA_PTR( ptr, freeArena );
454 pArena->size = lastArena - freeArena;
455 pArena->next = lastArena;
456 pArena->free_next = lastArena;
457
458 /* Initialise the new last block */
459
460 pLastArena = ARENA_PTR( ptr, lastArena );
461 pLastArena->prev = freeArena | LOCAL_ARENA_FREE;
462 pLastArena->next = lastArena; /* this one */
463 pLastArena->size = LALIGN(sizeof(LOCALARENA));
464 pLastArena->free_prev = freeArena;
465 pLastArena->free_next = lastArena; /* this one */
466
467 /* If block before freeArena is also free then merge them */
468 if((ARENA_PTR(ptr, (pArena->prev & ~3))->prev & 3) == LOCAL_ARENA_FREE)
469 {
470 LOCAL_RemoveBlock(ptr, freeArena);
471 pHeapInfo->items--;
472 }
473
474 dprintf_local( stddeb, "Heap expanded\n" );
475 LOCAL_PrintHeap( ds );
476 }
477
478
479 /***********************************************************************
480 * LOCAL_FreeArena
481 */
482 static HLOCAL16 LOCAL_FreeArena( WORD ds, WORD arena )
483 {
484 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
485 LOCALHEAPINFO *pInfo;
486 LOCALARENA *pArena, *pPrev, *pNext;
487
488 dprintf_local( stddeb, "LocalFreeArena: %04x ds=%04x\n", arena, ds );
489 if (!(pInfo = LOCAL_GetHeap( ds ))) return arena;
490
491 pArena = ARENA_PTR( ptr, arena );
492 if ((pArena->prev & 3) == LOCAL_ARENA_FREE)
493 {
494 /* shouldn't happen */
495 fprintf( stderr, "LocalFreeArena: Trying to free block %04x twice!\n",
496 arena );
497 LOCAL_PrintHeap( ds );
498 return arena;
499 }
500
501 /* Check if we can merge with the previous block */
502
503 pPrev = ARENA_PTR( ptr, pArena->prev & ~3 );
504 pNext = ARENA_PTR( ptr, pArena->next );
505 if ((pPrev->prev & 3) == LOCAL_ARENA_FREE)
506 {
507 arena = pArena->prev & ~3;
508 pArena = pPrev;
509 LOCAL_RemoveBlock( ptr, pPrev->next );
510 pInfo->items--;
511 }
512 else /* Make a new free block */
513 {
514 LOCAL_MakeBlockFree( ptr, arena );
515 }
516
517 /* Check if we can merge with the next block */
518
519 if ((pArena->next == pArena->free_next) &&
520 (pArena->next != pInfo->last))
521 {
522 LOCAL_RemoveBlock( ptr, pArena->next );
523 pInfo->items--;
524 }
525 return 0;
526 }
527
528
529 /***********************************************************************
530 * LOCAL_ShrinkArena
531 *
532 * Shrink an arena by creating a free block at its end if possible.
533 * 'size' includes the arena header, and must be aligned.
534 */
535 static void LOCAL_ShrinkArena( WORD ds, WORD arena, WORD size )
536 {
537 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
538 LOCALARENA *pArena = ARENA_PTR( ptr, arena );
539
540 if (arena + size + LALIGN(sizeof(LOCALARENA)) < pArena->next)
541 {
542 LOCALHEAPINFO *pInfo = LOCAL_GetHeap( ds );
543 if (!pInfo) return;
544 LOCAL_AddBlock( ptr, arena, arena + size );
545 pInfo->items++;
546 LOCAL_FreeArena( ds, arena + size );
547 }
548 }
549
550
551 /***********************************************************************
552 * LOCAL_GrowArenaDownward
553 *
554 * Grow an arena downward by using the previous arena (must be free).
555 */
556 static void LOCAL_GrowArenaDownward( WORD ds, WORD arena, WORD newsize )
557 {
558 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
559 LOCALHEAPINFO *pInfo;
560 LOCALARENA *pArena = ARENA_PTR( ptr, arena );
561 WORD prevArena = pArena->prev & ~3;
562 LOCALARENA *pPrevArena = ARENA_PTR( ptr, prevArena );
563 WORD offset, size;
564 char *p;
565
566 if (!(pInfo = LOCAL_GetHeap( ds ))) return;
567 offset = pPrevArena->size;
568 size = pArena->next - arena - ARENA_HEADER_SIZE;
569 LOCAL_RemoveFreeBlock( ptr, prevArena );
570 LOCAL_RemoveBlock( ptr, arena );
571 pInfo->items--;
572 p = (char *)pPrevArena + ARENA_HEADER_SIZE;
573 while (offset < size)
574 {
575 memcpy( p, p + offset, offset );
576 p += offset;
577 size -= offset;
578 }
579 if (size) memcpy( p, p + offset, size );
580 LOCAL_ShrinkArena( ds, prevArena, newsize );
581 }
582
583
584
585 /***********************************************************************
586 * LOCAL_GrowArenaUpward
587 *
588 * Grow an arena upward by using the next arena (must be free and big
589 * enough). Newsize includes the arena header and must be aligned.
590 */
591 static void LOCAL_GrowArenaUpward( WORD ds, WORD arena, WORD newsize )
592 {
593 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
594 LOCALHEAPINFO *pInfo;
595 LOCALARENA *pArena = ARENA_PTR( ptr, arena );
596 WORD nextArena = pArena->next;
597
598 if (!(pInfo = LOCAL_GetHeap( ds ))) return;
599 LOCAL_RemoveBlock( ptr, nextArena );
600 pInfo->items--;
601 LOCAL_ShrinkArena( ds, arena, newsize );
602 }
603
604
605 /***********************************************************************
606 * LOCAL_GetFreeSpace
607 */
608 static WORD LOCAL_GetFreeSpace(WORD ds, WORD countdiscard)
609 {
610 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
611 LOCALHEAPINFO *pInfo;
612 LOCALARENA *pArena;
613 WORD arena;
614 WORD freespace = 0;
615
616 if (!(pInfo = LOCAL_GetHeap( ds )))
617 {
618 fprintf( stderr, "LOCAL_GetFreeSpace: Local heap not found\n" );
619 LOCAL_PrintHeap(ds);
620 return 0;
621 }
622 arena = pInfo->first;
623 pArena = ARENA_PTR( ptr, arena );
624 while (arena != pArena->free_next)
625 {
626 arena = pArena->free_next;
627 pArena = ARENA_PTR( ptr, arena );
628 if (pArena->size >= freespace) freespace = pArena->size;
629 }
630 /* FIXME doesn't yet calculate space that would become free if everything
631 were discarded when countdiscard == 1 */
632 if (freespace < ARENA_HEADER_SIZE) freespace = 0;
633 else freespace -= ARENA_HEADER_SIZE;
634 return freespace;
635 }
636
637
638 /***********************************************************************
639 * LOCAL_Compact
640 */
641 WORD LOCAL_Compact( HANDLE16 ds, UINT16 minfree, UINT16 flags )
642 {
643 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
644 LOCALHEAPINFO *pInfo;
645 LOCALARENA *pArena, *pMoveArena, *pFinalArena;
646 WORD arena, movearena, finalarena, table;
647 WORD count, movesize, size;
648 WORD freespace;
649 LOCALHANDLEENTRY *pEntry;
650
651 if (!(pInfo = LOCAL_GetHeap( ds )))
652 {
653 fprintf( stderr, "Local_Compact: Local heap not found\n" );
654 LOCAL_PrintHeap(ds);
655 return 0;
656 }
657 dprintf_local(stddeb,
658 "LOCAL_Compact: ds = %04x, minfree = %04x, flags = %04x\n",
659 ds, minfree, flags);
660 freespace = LOCAL_GetFreeSpace(ds, minfree ? 0 : 1);
661 if(freespace >= minfree || (flags & LMEM_NOCOMPACT))
662 {
663 dprintf_local(stddeb, "Returning %04x.\n", freespace);
664 return freespace;
665 }
666 dprintf_local(stddeb, "Local_Compact: Compacting heap %04x.\n", ds);
667 table = pInfo->htable;
668 while(table)
669 {
670 pEntry = (LOCALHANDLEENTRY *)(ptr + table + sizeof(WORD));
671 for(count = *(WORD *)(ptr + table); count > 0; count--, pEntry++)
672 {
673 if((pEntry->lock == 0) && (pEntry->flags != (LMEM_DISCARDED >> 8)))
674 {
675 /* OK we can move this one if we want */
676 dprintf_local(stddeb,
677 "handle %04x (block %04x) can be moved.\n",
678 (WORD)((char *)pEntry - ptr), pEntry->addr);
679 movearena = ARENA_HEADER(pEntry->addr);
680 pMoveArena = ARENA_PTR(ptr, movearena);
681 movesize = pMoveArena->next - movearena;
682 arena = pInfo->first;
683 pArena = ARENA_PTR(ptr, arena);
684 size = 0xffff;
685 finalarena = 0;
686 /* Try to find the smallest arena that will do, */
687 /* which is below us in memory */
688 for(;;)
689 {
690 arena = pArena->free_next;
691 pArena = ARENA_PTR(ptr, arena);
692 if(arena >= movearena)
693 break;
694 if(arena == pArena->free_next)
695 break;
696 if((pArena->size >= movesize) && (pArena->size < size))
697 {
698 size = pArena->size;
699 finalarena = arena;
700 }
701 }
702 if (finalarena) /* Actually got somewhere to move */
703 {
704 dprintf_local(stddeb, "Moving it to %04x.\n", finalarena);
705 pFinalArena = ARENA_PTR(ptr, finalarena);
706 size = pFinalArena->size;
707 LOCAL_RemoveFreeBlock(ptr, finalarena);
708 LOCAL_ShrinkArena( ds, finalarena, movesize );
709 /* Copy the arena to it's new location */
710 memcpy((char *)pFinalArena + ARENA_HEADER_SIZE,
711 (char *)pMoveArena + ARENA_HEADER_SIZE,
712 movesize - ARENA_HEADER_SIZE );
713 /* Free the old location */
714 LOCAL_FreeArena(ds, movearena);
715 /* Update handle table entry */
716 pEntry->addr = finalarena + ARENA_HEADER_SIZE;
717 }
718 else if((ARENA_PTR(ptr, pMoveArena->prev & ~3)->prev & 3)
719 == LOCAL_ARENA_FREE)
720 {
721 /* Previous arena is free (but < movesize) */
722 /* so we can 'slide' movearena down into it */
723 finalarena = pMoveArena->prev & ~3;
724 LOCAL_GrowArenaDownward( ds, movearena, movesize );
725 /* Update handle table entry */
726 pEntry->addr = finalarena + ARENA_HEADER_SIZE;
727 }
728 }
729 }
730 table = *(WORD *)pEntry;
731 }
732 freespace = LOCAL_GetFreeSpace(ds, minfree ? 0 : 1);
733 if(freespace >= minfree || (flags & LMEM_NODISCARD))
734 {
735 dprintf_local(stddeb, "Returning %04x.\n", freespace);
736 return freespace;
737 }
738
739 table = pInfo->htable;
740 while(table)
741 {
742 pEntry = (LOCALHANDLEENTRY *)(ptr + table + sizeof(WORD));
743 for(count = *(WORD *)(ptr + table); count > 0; count--, pEntry++)
744 {
745 if(pEntry->addr && pEntry->lock == 0 &&
746 (pEntry->flags & (LMEM_DISCARDABLE >> 8)))
747 {
748 dprintf_local(stddeb, "Discarding handle %04x (block %04x).\n",
749 (char *)pEntry - ptr, pEntry->addr);
750 LOCAL_FreeArena(ds, ARENA_HEADER(pEntry->addr));
751 pEntry->addr = 0;
752 pEntry->flags = (LMEM_DISCARDED >> 8);
753 /* Call localnotify proc */
754 }
755 }
756 table = *(WORD *)pEntry;
757 }
758 return LOCAL_Compact(ds, 0xffff, LMEM_NODISCARD);
759 }
760
761
762 /***********************************************************************
763 * LOCAL_FindFreeBlock
764 */
765 static HLOCAL16 LOCAL_FindFreeBlock( HANDLE16 ds, WORD size )
766 {
767 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
768 LOCALHEAPINFO *pInfo;
769 LOCALARENA *pArena;
770 WORD arena;
771
772 if (!(pInfo = LOCAL_GetHeap( ds )))
773 {
774 fprintf( stderr, "Local_FindFreeBlock: Local heap not found\n" );
775 LOCAL_PrintHeap(ds);
776 return 0;
777 }
778
779 arena = pInfo->first;
780 pArena = ARENA_PTR( ptr, arena );
781 for (;;) {
782 arena = pArena->free_next;
783 pArena = ARENA_PTR( ptr, arena );
784 if (arena == pArena->free_next) break;
785 if (pArena->size >= size) return arena;
786 }
787 dprintf_local( stddeb, "Local_FindFreeBlock: not enough space\n" );
788 LOCAL_PrintHeap(ds);
789 return 0;
790 }
791
792 /***********************************************************************
793 * LOCAL_GetBlock
794 * The segment may get moved around in this function, so all callers
795 * should reset their pointer variables.
796 */
797 static HLOCAL16 LOCAL_GetBlock( HANDLE16 ds, WORD size, WORD flags )
798 {
799 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
800 LOCALHEAPINFO *pInfo;
801 LOCALARENA *pArena;
802 WORD arena;
803
804 if (!(pInfo = LOCAL_GetHeap( ds )))
805 {
806 fprintf( stderr, "Local_GetBlock: Local heap not found\n");
807 LOCAL_PrintHeap(ds);
808 return 0;
809 }
810
811 size += ARENA_HEADER_SIZE;
812 size = LALIGN( MAX( size, sizeof(LOCALARENA) ) );
813
814 /* Find a suitable free block */
815 arena = LOCAL_FindFreeBlock( ds, size );
816 if (arena == 0) {
817 /* no space: try to make some */
818 LOCAL_Compact( ds, size, flags );
819 arena = LOCAL_FindFreeBlock( ds, size );
820 }
821 if (arena == 0) {
822 /* still no space: try to grow the segment */
823 LOCAL_GrowHeap( ds );
824 ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
825 pInfo = LOCAL_GetHeap( ds );
826 arena = LOCAL_FindFreeBlock( ds, size );
827 }
828 if (arena == 0) {
829 if (ds == GDI_HeapSel) {
830 fprintf( stderr,
831 "Local_GetBlock: not enough space in GDI local heap (%04x) for %d bytes\n",
832 ds, size );
833 } else if (ds == USER_HeapSel) {
834 fprintf( stderr,
835 "Local_GetBlock: not enough space in USER local heap (%04x) for %d bytes\n",
836 ds, size );
837 } else {
838 dprintf_local( stddeb,
839 "Local_GetBlock: not enough space in local heap %04x for %d bytes\n",
840 ds, size );
841 }
842 return 0;
843 }
844
845 /* Make a block out of the free arena */
846 pArena = ARENA_PTR( ptr, arena );
847 dprintf_local(stddeb, "LOCAL_GetBlock size = %04x, arena %04x size %04x\n",
848 size, arena, pArena->size );
849 LOCAL_RemoveFreeBlock( ptr, arena );
850 LOCAL_ShrinkArena( ds, arena, size );
851
852 if (flags & LMEM_ZEROINIT)
853 memset((char *)pArena + ARENA_HEADER_SIZE, 0, size-ARENA_HEADER_SIZE);
854 return arena + ARENA_HEADER_SIZE;
855 }
856
857
858 /***********************************************************************
859 * LOCAL_NewHTable
860 */
861 static BOOL16 LOCAL_NewHTable( HANDLE16 ds )
862 {
863 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
864 LOCALHEAPINFO *pInfo;
865 LOCALHANDLEENTRY *pEntry;
866 HLOCAL16 handle;
867 int i;
868
869 dprintf_local( stddeb, "Local_NewHTable\n" );
870 if (!(pInfo = LOCAL_GetHeap( ds )))
871 {
872 fprintf( stderr, "Local heap not found\n");
873 LOCAL_PrintHeap(ds);
874 return FALSE;
875 }
876
877 if (!(handle = LOCAL_GetBlock( ds, pInfo->hdelta * sizeof(LOCALHANDLEENTRY)
878 + 2 * sizeof(WORD), LMEM_FIXED )))
879 return FALSE;
880 if (!(ptr = PTR_SEG_OFF_TO_LIN( ds, 0 )))
881 fprintf(stderr, "LOCAL_NewHTable: ptr == NULL after GetBlock.\n");
882 if (!(pInfo = LOCAL_GetHeap( ds )))
883 fprintf(stderr,"LOCAL_NewHTable: pInfo == NULL after GetBlock.\n");
884
885 /* Fill the entry table */
886
887 *(WORD *)(ptr + handle) = pInfo->hdelta;
888 pEntry = (LOCALHANDLEENTRY *)(ptr + handle + sizeof(WORD));
889 for (i = pInfo->hdelta; i > 0; i--, pEntry++) {
890 pEntry->lock = pEntry->flags = 0xff;
891 pEntry->addr = 0;
892 }
893 *(WORD *)pEntry = pInfo->htable;
894 pInfo->htable = handle;
895 return TRUE;
896 }
897
898
899 /***********************************************************************
900 * LOCAL_GetNewHandleEntry
901 */
902 static HLOCAL16 LOCAL_GetNewHandleEntry( HANDLE16 ds )
903 {
904 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
905 LOCALHEAPINFO *pInfo;
906 LOCALHANDLEENTRY *pEntry = NULL;
907 WORD table;
908
909 if (!(pInfo = LOCAL_GetHeap( ds )))
910 {
911 fprintf( stderr, "LOCAL_GetNewHandleEntry: Local heap not found\n");
912 LOCAL_PrintHeap(ds);
913 return 0;
914 }
915
916 /* Find a free slot in existing tables */
917
918 table = pInfo->htable;
919 while (table)
920 {
921 WORD count = *(WORD *)(ptr + table);
922 pEntry = (LOCALHANDLEENTRY *)(ptr + table + sizeof(WORD));
923 for (; count > 0; count--, pEntry++)
924 if (pEntry->lock == 0xff) break;
925 if (count) break;
926 table = *(WORD *)pEntry;
927 }
928
929 if (!table) /* We need to create a new table */
930 {
931 if (!LOCAL_NewHTable( ds )) return 0;
932 ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
933 pInfo = LOCAL_GetHeap( ds );
934 pEntry = (LOCALHANDLEENTRY *)(ptr + pInfo->htable + sizeof(WORD));
935 }
936
937 /* Now allocate this entry */
938
939 pEntry->lock = 0;
940 pEntry->flags = 0;
941 dprintf_local( stddeb, "LOCAL_GetNewHandleEntry(%04x): %04x\n",
942 ds, ((char *)pEntry - ptr) );
943 return (HLOCAL16)((char *)pEntry - ptr);
944 }
945
946
947 /***********************************************************************
948 * LOCAL_FreeHandleEntry
949 *
950 * Free a handle table entry.
951 */
952 static void LOCAL_FreeHandleEntry( HANDLE16 ds, HLOCAL16 handle )
953 {
954 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
955 LOCALHANDLEENTRY *pEntry = (LOCALHANDLEENTRY *)(ptr + handle);
956 LOCALHEAPINFO *pInfo;
957 WORD *pTable;
958 WORD table, count, i;
959
960 if (!(pInfo = LOCAL_GetHeap( ds ))) return;
961
962 /* Find the table where this handle comes from */
963
964 pTable = &pInfo->htable;
965 while (*pTable)
966 {
967 WORD size = (*(WORD *)(ptr + *pTable)) * sizeof(LOCALHANDLEENTRY);
968 if ((handle >= *pTable + sizeof(WORD)) &&
969 (handle < *pTable + sizeof(WORD) + size)) break; /* Found it */
970 pTable = (WORD *)(ptr + *pTable + sizeof(WORD) + size);
971 }
972 if (!*pTable)
973 {
974 fprintf(stderr, "LOCAL_FreeHandleEntry: invalid entry %04x\n", handle);
975 LOCAL_PrintHeap( ds );
976 return;
977 }
978
979 /* Make the entry free */
980
981 pEntry->addr = 0; /* just in case */
982 pEntry->lock = 0xff;
983 pEntry->flags = 0xff;
984 /* Now check if all entries in this table are free */
985
986 table = *pTable;
987 pEntry = (LOCALHANDLEENTRY *)(ptr + table + sizeof(WORD));
988 count = *(WORD *)(ptr + table);
989 for (i = count; i > 0; i--, pEntry++) if (pEntry->lock != 0xff) return;
990
991 /* Remove the table from the linked list and free it */
992
993 dprintf_local( stddeb, "LOCAL_FreeHandleEntry(%04x): freeing table %04x\n",
994 ds, table);
995 *pTable = *(WORD *)pEntry;
996 LOCAL_FreeArena( ds, ARENA_HEADER( table ) );
997 }
998
999
1000 /***********************************************************************
1001 * LOCAL_Free
1002 *
1003 * Implementation of LocalFree().
1004 */
1005 HLOCAL16 LOCAL_Free( HANDLE16 ds, HLOCAL16 handle )
1006 {
1007 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
1008
1009 dprintf_local( stddeb, "LocalFree: %04x ds=%04x\n", handle, ds );
1010
1011 if (!handle) { fprintf( stderr, "LOCAL_Free: handle is 0.\n" ); return 0; }
1012 if (HANDLE_FIXED( handle ))
1013 {
1014 if (!LOCAL_FreeArena( ds, ARENA_HEADER( handle ) )) return 0; /* OK */
1015 else return handle; /* couldn't free it */
1016 }
1017 else
1018 {
1019 LOCALHANDLEENTRY *pEntry = (LOCALHANDLEENTRY *)(ptr + handle);
1020 if (pEntry->flags != (LMEM_DISCARDED >> 8))
1021 {
1022 dprintf_local( stddeb, "LocalFree: real block at %04x\n",
1023 pEntry->addr );
1024 if (LOCAL_FreeArena( ds, ARENA_HEADER(pEntry->addr) ))
1025 return handle; /* couldn't free it */
1026 }
1027 LOCAL_FreeHandleEntry( ds, handle );
1028 return 0; /* OK */
1029 }
1030 }
1031
1032
1033 /***********************************************************************
1034 * LOCAL_Alloc
1035 *
1036 * Implementation of LocalAlloc().
1037 *
1038 */
1039 HLOCAL16 LOCAL_Alloc( HANDLE16 ds, WORD flags, WORD size )
1040 {
1041 char *ptr;
1042 HLOCAL16 handle;
1043
1044 dprintf_local( stddeb, "LocalAlloc: %04x %d ds=%04x\n", flags, size, ds );
1045
1046 if(size > 0 && size <= 4) size = 5;
1047 if (flags & LMEM_MOVEABLE)
1048 {
1049 LOCALHANDLEENTRY *plhe;
1050 HLOCAL16 hmem;
1051
1052 if(size)
1053 {
1054 if (!(hmem = LOCAL_GetBlock( ds, size + sizeof(HLOCAL16), flags )))
1055 return 0;
1056 }
1057 else /* We just need to allocate a discarded handle */
1058 hmem = 0;
1059 if (!(handle = LOCAL_GetNewHandleEntry( ds )))
1060 {
1061 fprintf( stderr, "LocalAlloc: couldn't get handle\n");
1062 if(hmem)
1063 LOCAL_FreeArena( ds, ARENA_HEADER(hmem) );
1064 return 0;
1065 }
1066 ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
1067 plhe = (LOCALHANDLEENTRY *)(ptr + handle);
1068 plhe->lock = 0;
1069 if(hmem)
1070 {
1071 plhe->addr = hmem + sizeof(HLOCAL16);
1072 plhe->flags = (BYTE)((flags & 0x0f00) >> 8);
1073 *(HLOCAL16 *)(ptr + hmem) = handle;
1074 }
1075 else
1076 {
1077 plhe->addr = 0;
1078 plhe->flags = LMEM_DISCARDED >> 8;
1079 }
1080 }
1081 else /* FIXED */
1082 {
1083 if(!size)
1084 return 0;
1085 handle = LOCAL_GetBlock( ds, size, flags );
1086 }
1087 return handle;
1088 }
1089
1090
1091 /***********************************************************************
1092 * LOCAL_ReAlloc
1093 *
1094 * Implementation of LocalReAlloc().
1095 */
1096 HLOCAL16 LOCAL_ReAlloc( HANDLE16 ds, HLOCAL16 handle, WORD size, WORD flags )
1097 {
1098 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
1099 LOCALHEAPINFO *pInfo;
1100 LOCALARENA *pArena, *pNext;
1101 LOCALHANDLEENTRY *pEntry;
1102 WORD arena, oldsize;
1103 HLOCAL16 hmem, blockhandle;
1104 LONG nextarena;
1105
1106 if (!handle) return 0;
1107 if(HANDLE_MOVEABLE(handle) &&
1108 ((LOCALHANDLEENTRY *)(ptr + handle))->lock == 0xff) /* An unused handle */
1109 return 0;
1110
1111 dprintf_local( stddeb, "LocalReAlloc: %04x %d %04x ds=%04x\n",
1112 handle, size, flags, ds );
1113 if (!(pInfo = LOCAL_GetHeap( ds ))) return 0;
1114
1115 if (HANDLE_FIXED( handle ))
1116 blockhandle = handle;
1117 else
1118 {
1119 pEntry = (LOCALHANDLEENTRY *) (ptr + handle);
1120 if(pEntry->flags == (LMEM_DISCARDED >> 8))
1121 {
1122 HLOCAL16 hl;
1123 if(pEntry->addr)
1124 fprintf(stderr,
1125 "LOCAL_ReAlloc: Dicarded block has non-zero addr.\n");
1126 dprintf_local(stddeb, "ReAllocating discarded block\n");
1127 if(size <= 4) size = 5;
1128 if (!(hl = LOCAL_GetBlock( ds, size + sizeof(HLOCAL16), flags)))
1129 return 0;
1130 ptr = PTR_SEG_OFF_TO_LIN( ds, 0 ); /* Reload ptr */
1131 pEntry = (LOCALHANDLEENTRY *) (ptr + handle);
1132 pEntry->addr = hl + sizeof(HLOCAL16);
1133 pEntry->flags = 0;
1134 pEntry->lock = 0;
1135 *(HLOCAL16 *)(ptr + hl) = handle;
1136 return handle;
1137 }
1138 if (((blockhandle = pEntry->addr) & 3) != 2)
1139 {
1140 fprintf( stderr, "Local_ReAlloc(%04x,%04x): invalid handle\n",
1141 ds, handle );
1142 return 0;
1143 }
1144 if(*((HLOCAL16 *)(ptr + blockhandle) - 1) != handle) {
1145 fprintf(stderr, "Local_ReAlloc: Back ptr to handle is invalid\n");
1146 return 0;
1147 }
1148 }
1149
1150 if (flags & LMEM_MODIFY)
1151 {
1152 if (HANDLE_MOVEABLE(handle))
1153 {
1154 pEntry = (LOCALHANDLEENTRY *)(ptr + handle);
1155 pEntry->flags = (flags & 0x0f00) >> 8;
1156 dprintf_local(stddeb, "Changing flags to %x.\n", pEntry->flags);
1157 }
1158 return handle;
1159 }
1160
1161 if (!size)
1162 {
1163 if (flags & LMEM_MOVEABLE)
1164 {
1165 if (HANDLE_FIXED(handle))
1166 {
1167 dprintf_local(stddeb, "Freeing fixed block.\n");
1168 return LOCAL_Free( ds, handle );
1169 }
1170 else /* Moveable block */
1171 {
1172 pEntry = (LOCALHANDLEENTRY *)(ptr + handle);
1173 if (pEntry->lock == 0)
1174 {
1175 /* discards moveable blocks */
1176 dprintf_local(stddeb,"Discarding block\n");
1177 LOCAL_FreeArena(ds, ARENA_HEADER(pEntry->addr));
1178 pEntry->addr = 0;
1179 pEntry->flags = (LMEM_DISCARDED >> 8);
1180 return handle;
1181 }
1182 }
1183 return 0;
1184 }
1185 else if(flags == 0)
1186 {
1187 pEntry = (LOCALHANDLEENTRY *)(ptr + handle);
1188 if (pEntry->lock == 0)
1189 {
1190 /* Frees block */
1191 return LOCAL_Free( ds, handle );
1192 }
1193 }
1194 return 0;
1195 }
1196
1197 arena = ARENA_HEADER( blockhandle );
1198 dprintf_local( stddeb, "LocalReAlloc: arena is %04x\n", arena );
1199 pArena = ARENA_PTR( ptr, arena );
1200
1201 if(size <= 4) size = 5;
1202 oldsize = pArena->next - arena - ARENA_HEADER_SIZE;
1203 nextarena = LALIGN(blockhandle + size);
1204
1205 /* Check for size reduction */
1206
1207 if (nextarena <= pArena->next)
1208 {
1209 dprintf_local( stddeb, "size reduction, making new free block\n");
1210 LOCAL_ShrinkArena(ds, arena, nextarena - arena);
1211 dprintf_local( stddeb, "LocalReAlloc: returning %04x\n", handle );
1212 return handle;
1213 }
1214
1215 /* Check if the next block is free and large enough */
1216
1217 pNext = ARENA_PTR( ptr, pArena->next );
1218 if (((pNext->prev & 3) == LOCAL_ARENA_FREE) &&
1219 (nextarena <= pNext->next))
1220 {
1221 dprintf_local( stddeb, "size increase, making new free block\n");
1222 LOCAL_GrowArenaUpward(ds, arena, nextarena - arena);
1223 dprintf_local( stddeb, "LocalReAlloc: returning %04x\n", handle );
1224 return handle;
1225 }
1226
1227 /* Now we have to allocate a new block, but not if (fixed block or locked
1228 block) and no LMEM_MOVEABLE */
1229
1230 if (!(flags & LMEM_MOVEABLE))
1231 {
1232 if (HANDLE_FIXED(handle))
1233 {
1234 dprintf_local(stddeb,
1235 "Needed to move fixed block, but LMEM_MOVEABLE not specified.\n");
1236 return 0;
1237 }
1238 else
1239 {
1240 if(((LOCALHANDLEENTRY *)(ptr + handle))->lock != 0)
1241 {
1242 dprintf_local(stddeb,
1243 "Needed to move locked block, but LMEM_MOVEABLE not specified.\n");
1244 return 0;
1245 }
1246 }
1247 }
1248 if(HANDLE_MOVEABLE(handle)) size += sizeof(HLOCAL16);
1249 hmem = LOCAL_GetBlock( ds, size, flags );
1250 ptr = PTR_SEG_OFF_TO_LIN( ds, 0 ); /* Reload ptr */
1251 if (!hmem)
1252 {
1253 /* Remove the block from the heap and try again */
1254 LPSTR buffer = HeapAlloc( GetProcessHeap(), 0, oldsize );
1255 if (!buffer) return 0;
1256 memcpy( buffer, ptr + arena + ARENA_HEADER_SIZE, oldsize );
1257 LOCAL_FreeArena( ds, arena );
1258 if (!(hmem = LOCAL_GetBlock( ds, size, flags )))
1259 {
1260 if (!(hmem = LOCAL_GetBlock( ds, oldsize, flags )))
1261 {
1262 fprintf( stderr, "LocalRealloc: can't restore saved block\n" );
1263 HeapFree( GetProcessHeap(), 0, buffer );
1264 return 0;
1265 }
1266 size = oldsize;
1267 }
1268 ptr = PTR_SEG_OFF_TO_LIN( ds, 0 ); /* Reload ptr */
1269 memcpy( ptr + hmem, buffer, oldsize );
1270 HeapFree( GetProcessHeap(), 0, buffer );
1271 }
1272 else
1273 {
1274 memcpy( ptr + hmem, ptr + (arena + ARENA_HEADER_SIZE), oldsize );
1275 LOCAL_FreeArena( ds, arena );
1276 }
1277 if (HANDLE_MOVEABLE( handle ))
1278 {
1279 dprintf_local( stddeb, "LocalReAlloc: fixing handle\n");
1280 pEntry = (LOCALHANDLEENTRY *)(ptr + handle);
1281 pEntry->addr = hmem + sizeof(HLOCAL16);
1282 /* Back ptr should still be correct */
1283 if(*(HLOCAL16 *)(ptr + hmem) != handle)
1284 fprintf(stderr, "Local_ReAlloc: back ptr is invalid.\n");
1285 hmem = handle;
1286 }
1287 if (size == oldsize) hmem = 0; /* Realloc failed */
1288 dprintf_local( stddeb, "LocalReAlloc: returning %04x\n", hmem );
1289 return hmem;
1290 }
1291
1292
1293 /***********************************************************************
1294 * LOCAL_InternalLock
1295 */
1296 static HLOCAL16 LOCAL_InternalLock( LPSTR heap, HLOCAL16 handle )
1297 {
1298 dprintf_local( stddeb, "LocalLock: %04x ", handle );
1299 if (HANDLE_MOVEABLE(handle))
1300 {
1301 LOCALHANDLEENTRY *pEntry = (LOCALHANDLEENTRY *)(heap + handle);
1302 if (pEntry->flags == LMEM_DISCARDED) return 0;
1303 if (pEntry->lock < 0xfe) pEntry->lock++;
1304 handle = pEntry->addr;
1305 }
1306 dprintf_local( stddeb, "returning %04x\n", handle );
1307 return handle;
1308 }
1309
1310
1311 /***********************************************************************
1312 * LOCAL_Lock
1313 */
1314 LPSTR LOCAL_Lock( HANDLE16 ds, HLOCAL16 handle )
1315 {
1316 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
1317 return handle ? ptr + LOCAL_InternalLock( ptr, handle ) : NULL;
1318 }
1319
1320
1321 /***********************************************************************
1322 * LOCAL_LockSegptr
1323 */
1324 SEGPTR LOCAL_LockSegptr( HANDLE16 ds, HLOCAL16 handle )
1325 {
1326 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
1327 return PTR_SEG_OFF_TO_SEGPTR( ds, LOCAL_InternalLock( ptr, handle ) );
1328 }
1329
1330
1331 /***********************************************************************
1332 * LOCAL_Unlock
1333 */
1334 BOOL16 LOCAL_Unlock( HANDLE16 ds, HLOCAL16 handle )
1335 {
1336 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
1337
1338 dprintf_local( stddeb, "LocalUnlock: %04x\n", handle );
1339 if (HANDLE_MOVEABLE(handle))
1340 {
1341 LOCALHANDLEENTRY *pEntry = (LOCALHANDLEENTRY *)(ptr + handle);
1342 if (!pEntry->lock || (pEntry->lock == 0xff)) return FALSE;
1343 /* For moveable block, return the new lock count */
1344 /* (see _Windows_Internals_ p. 197) */
1345 return --pEntry->lock;
1346 }
1347 else return FALSE;
1348 }
1349
1350
1351 /***********************************************************************
1352 * LOCAL_Size
1353 *
1354 * Implementation of LocalSize().
1355 */
1356 WORD LOCAL_Size( HANDLE16 ds, HLOCAL16 handle )
1357 {
1358 char *ptr = PTR_SEG_OFF_TO_LIN( CURRENT_DS, 0 );
1359 LOCALARENA *pArena;
1360
1361 dprintf_local( stddeb, "LocalSize: %04x ds=%04x\n", handle, ds );
1362
1363 if (HANDLE_MOVEABLE( handle )) handle = *(WORD *)(ptr + handle);
1364 if (!handle) return 0;
1365 pArena = ARENA_PTR( ptr, ARENA_HEADER(handle) );
1366 return pArena->next - handle;
1367 }
1368
1369
1370 /***********************************************************************
1371 * LOCAL_Flags
1372 *
1373 * Implementation of LocalFlags().
1374 */
1375 WORD LOCAL_Flags( HANDLE16 ds, HLOCAL16 handle )
1376 {
1377 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
1378
1379 if (HANDLE_MOVEABLE(handle))
1380 {
1381 LOCALHANDLEENTRY *pEntry = (LOCALHANDLEENTRY *)(ptr + handle);
1382 dprintf_local( stddeb, "LOCAL_Flags(%04x,%04x): returning %04x\n",
1383 ds, handle, pEntry->lock | (pEntry->flags << 8) );
1384 return pEntry->lock | (pEntry->flags << 8);
1385 }
1386 else
1387 {
1388 dprintf_local( stddeb, "LOCAL_Flags(%04x,%04x): returning 0\n",
1389 ds, handle );
1390 return 0;
1391 }
1392 }
1393
1394
1395 /***********************************************************************
1396 * LOCAL_HeapSize
1397 *
1398 * Implementation of LocalHeapSize().
1399 */
1400 WORD LOCAL_HeapSize( HANDLE16 ds )
1401 {
1402 LOCALHEAPINFO *pInfo = LOCAL_GetHeap( ds );
1403 if (!pInfo) return 0;
1404 return pInfo->last - pInfo->first;
1405 }
1406
1407
1408 /***********************************************************************
1409 * LOCAL_CountFree
1410 *
1411 * Implementation of LocalCountFree().
1412 */
1413 WORD LOCAL_CountFree( HANDLE16 ds )
1414 {
1415 WORD arena, total;
1416 LOCALARENA *pArena;
1417 LOCALHEAPINFO *pInfo;
1418 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
1419
1420 if (!(pInfo = LOCAL_GetHeap( ds )))
1421 {
1422 fprintf( stderr, "LOCAL_Handle(%04x): Local heap not found\n", ds );
1423 LOCAL_PrintHeap( ds );
1424 return 0;
1425 }
1426
1427 total = 0;
1428 arena = pInfo->first;
1429 pArena = ARENA_PTR( ptr, arena );
1430 for (;;)
1431 {
1432 arena = pArena->free_next;
1433 pArena = ARENA_PTR( ptr, arena );
1434 if (arena == pArena->free_next) break;
1435 total += pArena->size;
1436 }
1437 dprintf_local( stddeb, "LOCAL_CountFree(%04x): returning %d\n", ds, total);
1438 return total;
1439 }
1440
1441
1442 /***********************************************************************
1443 * LOCAL_Handle
1444 *
1445 * Implementation of LocalHandle().
1446 */
1447 HLOCAL16 LOCAL_Handle( HANDLE16 ds, WORD addr )
1448 {
1449 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
1450 LOCALHEAPINFO *pInfo;
1451 WORD table;
1452
1453 if (!(pInfo = LOCAL_GetHeap( ds )))
1454 {
1455 fprintf( stderr, "LOCAL_Handle(%04x): Local heap not found\n", ds );
1456 LOCAL_PrintHeap( ds );
1457 return 0;
1458 }
1459
1460 /* Find the address in the entry tables */
1461
1462 table = pInfo->htable;
1463 while (table)
1464 {
1465 WORD count = *(WORD *)(ptr + table);
1466 LOCALHANDLEENTRY *pEntry = (LOCALHANDLEENTRY*)(ptr+table+sizeof(WORD));
1467 for (; count > 0; count--, pEntry++)
1468 if (pEntry->addr == addr) return (HLOCAL16)((char *)pEntry - ptr);
1469 table = *(WORD *)pEntry;
1470 }
1471
1472 return (HLOCAL16)addr; /* Fixed block handle is addr */
1473 }
1474
1475
1476 /***********************************************************************
1477 * LocalAlloc16 (KERNEL.5)
1478 */
1479 HLOCAL16 WINAPI LocalAlloc16( UINT16 flags, WORD size )
1480 {
1481 return LOCAL_Alloc( CURRENT_DS, flags, size );
1482 }
1483
1484
1485 /***********************************************************************
1486 * LocalReAlloc16 (KERNEL.6)
1487 */
1488 HLOCAL16 WINAPI LocalReAlloc16( HLOCAL16 handle, WORD size, UINT16 flags )
1489 {
1490 return LOCAL_ReAlloc( CURRENT_DS, handle, size, flags );
1491 }
1492
1493
1494 /***********************************************************************
1495 * LocalFree16 (KERNEL.7)
1496 */
1497 HLOCAL16 WINAPI LocalFree16( HLOCAL16 handle )
1498 {
1499 return LOCAL_Free( CURRENT_DS, handle );
1500 }
1501
1502
1503 /***********************************************************************
1504 * LocalLock16 (KERNEL.8)
1505 *
1506 * Note: only the offset part of the pointer is returned by the relay code.
1507 */
1508 SEGPTR WINAPI LocalLock16( HLOCAL16 handle )
1509 {
1510 return LOCAL_LockSegptr( CURRENT_DS, handle );
1511 }
1512
1513
1514 /***********************************************************************
1515 * LocalUnlock16 (KERNEL.9)
1516 */
1517 BOOL16 WINAPI LocalUnlock16( HLOCAL16 handle )
1518 {
1519 return LOCAL_Unlock( CURRENT_DS, handle );
1520 }
1521
1522
1523 /***********************************************************************
1524 * LocalSize16 (KERNEL.10)
1525 */
1526 UINT16 WINAPI LocalSize16( HLOCAL16 handle )
1527 {
1528 return LOCAL_Size( CURRENT_DS, handle );
1529 }
1530
1531
1532 /***********************************************************************
1533 * LocalHandle16 (KERNEL.11)
1534 */
1535 HLOCAL16 WINAPI LocalHandle16( WORD addr )
1536 {
1537 return LOCAL_Handle( CURRENT_DS, addr );
1538 }
1539
1540
1541 /***********************************************************************
1542 * LocalFlags16 (KERNEL.12)
1543 */
1544 UINT16 WINAPI LocalFlags16( HLOCAL16 handle )
1545 {
1546 return LOCAL_Flags( CURRENT_DS, handle );
1547 }
1548
1549
1550 /***********************************************************************
1551 * LocalCompact16 (KERNEL.13)
1552 */
1553 UINT16 WINAPI LocalCompact16( UINT16 minfree )
1554 {
1555 dprintf_local( stddeb, "LocalCompact: %04x\n", minfree );
1556 return LOCAL_Compact( CURRENT_DS, minfree, 0 );
1557 }
1558
1559
1560 /***********************************************************************
1561 * LocalNotify (KERNEL.14)
1562 */
1563 FARPROC16 WINAPI LocalNotify( FARPROC16 func )
1564 {
1565 LOCALHEAPINFO *pInfo;
1566 FARPROC16 oldNotify;
1567 HANDLE16 ds = CURRENT_DS;
1568
1569 if (!(pInfo = LOCAL_GetHeap( ds )))
1570 {
1571 fprintf( stderr, "LOCAL_Notify(%04x): Local heap not found\n", ds );
1572 LOCAL_PrintHeap( ds );
1573 return 0;
1574 }
1575 dprintf_local( stddeb, "LocalNotify(%04x): %08lx\n", ds, (DWORD)func );
1576 fprintf(stdnimp, "LocalNotify(): Half implemented\n");
1577 oldNotify = pInfo->notify;
1578 pInfo->notify = func;
1579 return oldNotify;
1580 }
1581
1582
1583 /***********************************************************************
1584 * LocalShrink16 (KERNEL.121)
1585 */
1586 UINT16 WINAPI LocalShrink16( HGLOBAL16 handle, UINT16 newsize )
1587 {
1588 dprintf_local( stddeb, "LocalShrink: %04x %04x\n", handle, newsize );
1589 return 0;
1590 }
1591
1592
1593 /***********************************************************************
1594 * GetHeapSpaces (KERNEL.138)
1595 */
1596 DWORD WINAPI GetHeapSpaces( HMODULE16 module )
1597 {
1598 NE_MODULE *pModule;
1599 WORD ds;
1600
1601 if (!(pModule = MODULE_GetPtr( module ))) return 0;
1602 ds = (NE_SEG_TABLE( pModule ) + pModule->dgroup - 1)->selector;
1603 return MAKELONG( LOCAL_CountFree( ds ), LOCAL_HeapSize( ds ) );
1604 }
1605
1606
1607 /***********************************************************************
1608 * LocalCountFree (KERNEL.161)
1609 */
1610 WORD WINAPI LocalCountFree(void)
1611 {
1612 return LOCAL_CountFree( CURRENT_DS );
1613 }
1614
1615
1616 /***********************************************************************
1617 * LocalHeapSize (KERNEL.162)
1618 */
1619 WORD WINAPI LocalHeapSize(void)
1620 {
1621 dprintf_local( stddeb, "LocalHeapSize:\n" );
1622 return LOCAL_HeapSize( CURRENT_DS );
1623 }
1624
1625
1626 /***********************************************************************
1627 * LocalHandleDelta (KERNEL.310)
1628 */
1629 WORD WINAPI LocalHandleDelta( WORD delta )
1630 {
1631 LOCALHEAPINFO *pInfo;
1632
1633 if (!(pInfo = LOCAL_GetHeap( CURRENT_DS )))
1634 {
1635 fprintf( stderr, "LocalHandleDelta: Local heap not found\n");
1636 LOCAL_PrintHeap( CURRENT_DS );
1637 return 0;
1638 }
1639 if (delta) pInfo->hdelta = delta;
1640 dprintf_local(stddeb, "LocalHandleDelta: returning %04x\n", pInfo->hdelta);
1641 return pInfo->hdelta;
1642 }
1643
1644
1645 /***********************************************************************
1646 * LocalInfo (TOOLHELP.56)
1647 */
1648 BOOL16 WINAPI LocalInfo( LOCALINFO *pLocalInfo, HGLOBAL16 handle )
1649 {
1650 LOCALHEAPINFO *pInfo = LOCAL_GetHeap(SELECTOROF(WIN16_GlobalLock16(handle)));
1651 if (!pInfo) return FALSE;
1652 pLocalInfo->wcItems = pInfo->items;
1653 return TRUE;
1654 }
1655
1656
1657 /***********************************************************************
1658 * LocalFirst (TOOLHELP.57)
1659 */
1660 BOOL16 WINAPI LocalFirst( LOCALENTRY *pLocalEntry, HGLOBAL16 handle )
1661 {
1662 WORD ds = GlobalHandleToSel( handle );
1663 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
1664 LOCALHEAPINFO *pInfo = LOCAL_GetHeap( ds );
1665 if (!pInfo) return FALSE;
1666
1667 pLocalEntry->hHandle = pInfo->first + ARENA_HEADER_SIZE;
1668 pLocalEntry->wAddress = pLocalEntry->hHandle;
1669 pLocalEntry->wFlags = LF_FIXED;
1670 pLocalEntry->wcLock = 0;
1671 pLocalEntry->wType = LT_NORMAL;
1672 pLocalEntry->hHeap = handle;
1673 pLocalEntry->wHeapType = NORMAL_HEAP;
1674 pLocalEntry->wNext = ARENA_PTR(ptr,pInfo->first)->next;
1675 pLocalEntry->wSize = pLocalEntry->wNext - pLocalEntry->hHandle;
1676 return TRUE;
1677 }
1678
1679
1680 /***********************************************************************
1681 * LocalNext (TOOLHELP.58)
1682 */
1683 BOOL16 WINAPI LocalNext( LOCALENTRY *pLocalEntry )
1684 {
1685 WORD ds = GlobalHandleToSel( pLocalEntry->hHeap );
1686 char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
1687 LOCALARENA *pArena;
1688
1689 if (!LOCAL_GetHeap( ds )) return FALSE;
1690 if (!pLocalEntry->wNext) return FALSE;
1691 pArena = ARENA_PTR( ptr, pLocalEntry->wNext );
1692
1693 pLocalEntry->hHandle = pLocalEntry->wNext + ARENA_HEADER_SIZE;
1694 pLocalEntry->wAddress = pLocalEntry->hHandle;
1695 pLocalEntry->wFlags = (pArena->prev & 3) + 1;
1696 pLocalEntry->wcLock = 0;
1697 pLocalEntry->wType = LT_NORMAL;
1698 if (pArena->next != pLocalEntry->wNext) /* last one? */
1699 pLocalEntry->wNext = pArena->next;
1700 else
1701 pLocalEntry->wNext = 0;
1702 pLocalEntry->wSize = pLocalEntry->wNext - pLocalEntry->hHandle;
1703 return TRUE;
1704 }
1705
1706
1707 /***********************************************************************
1708 * LocalAlloc32 (KERNEL32.371)
1709 */
1710 HLOCAL32 WINAPI LocalAlloc32( UINT32 flags, DWORD size )
1711 {
1712 return (HLOCAL32)GlobalAlloc32( flags, size );
1713 }
1714
1715
1716 /***********************************************************************
1717 * LocalCompact32 (KERNEL32.372)
1718 */
1719 UINT32 WINAPI LocalCompact32( UINT32 minfree )
1720 {
1721 return 0; /* LocalCompact does nothing in Win32 */
1722 }
1723
1724
1725 /***********************************************************************
1726 * LocalFlags32 (KERNEL32.374)
1727 */
1728 UINT32 WINAPI LocalFlags32( HLOCAL32 handle )
1729 {
1730 return GlobalFlags32( (HGLOBAL32)handle );
1731 }
1732
1733
1734 /***********************************************************************
1735 * LocalFree32 (KERNEL32.375)
1736 */
1737 HLOCAL32 WINAPI LocalFree32( HLOCAL32 handle )
1738 {
1739 return (HLOCAL32)GlobalFree32( (HGLOBAL32)handle );
1740 }
1741
1742
1743 /***********************************************************************
1744 * LocalHandle32 (KERNEL32.376)
1745 */
1746 HLOCAL32 WINAPI LocalHandle32( LPCVOID ptr )
1747 {
1748 return (HLOCAL32)GlobalHandle32( ptr );
1749 }
1750
1751
1752 /***********************************************************************
1753 * LocalLock32 (KERNEL32.377)
1754 */
1755 LPVOID WINAPI LocalLock32( HLOCAL32 handle )
1756 {
1757 return GlobalLock32( (HGLOBAL32)handle );
1758 }
1759
1760
1761 /***********************************************************************
1762 * LocalReAlloc32 (KERNEL32.378)
1763 */
1764 HLOCAL32 WINAPI LocalReAlloc32( HLOCAL32 handle, DWORD size, UINT32 flags )
1765 {
1766 return (HLOCAL32)GlobalReAlloc32( (HGLOBAL32)handle, size, flags );
1767 }
1768
1769
1770 /***********************************************************************
1771 * LocalShrink32 (KERNEL32.379)
1772 */
1773 UINT32 WINAPI LocalShrink32( HGLOBAL32 handle, UINT32 newsize )
1774 {
1775 return 0; /* LocalShrink does nothing in Win32 */
1776 }
1777
1778
1779 /***********************************************************************
1780 * LocalSize32 (KERNEL32.380)
1781 */
1782 UINT32 WINAPI LocalSize32( HLOCAL32 handle )
1783 {
1784 return GlobalSize32( (HGLOBAL32)handle );
1785 }
1786
1787
1788 /***********************************************************************
1789 * LocalUnlock32 (KERNEL32.381)
1790 */
1791 BOOL32 WINAPI LocalUnlock32( HLOCAL32 handle )
1792 {
1793 return GlobalUnlock32( (HGLOBAL32)handle );
1794 }
Windows API implementation