4 * Copyright 1995 Alexandre Julliard
5 * Copyright 1996 Huw Davies
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.
25 #include "stackframe.h"
29 /* needed only for GDI_HeapSel and USER_HeapSel */
36 WORD prev
; /* Previous arena | arena type */
37 WORD next
; /* Next arena */
38 /* Start of the memory block or free-list info */
39 WORD size
; /* Size of the free block */
40 WORD free_prev
; /* Previous free block */
41 WORD free_next
; /* Next free block */
44 #define ARENA_HEADER_SIZE 4
45 #define ARENA_HEADER( handle) ( ((handle) & ~3) - ARENA_HEADER_SIZE)
47 /* Arena types (stored in 'prev' field of the arena) */
48 #define LOCAL_ARENA_FREE 0
49 #define LOCAL_ARENA_FIXED 1
51 /* Layout of a handle entry table
53 * WORD count of entries
54 * LOCALHANDLEENTRY[count] entries
55 * WORD near ptr to next table
59 WORD addr
; /* Address of the MOVEABLE block */
60 BYTE flags
; /* Flags for this block */
61 BYTE lock
; /* Lock count */
65 * We make addr = 4n + 2 and set *((WORD *)addr - 1) = &addr like Windows does
66 * in case something actually relies on this.
67 * Note the ARENA_HEADER(addr) still produces the desired result ie. 4n - 4
69 * An unused handle has lock = flags = 0xff. In windows addr is that of next
70 * free handle, at the moment in wine we set it to 0.
72 * A discarded block's handle has lock = addr = 0 and flags = 0x40
73 * (LMEM_DISCARDED >> 8)
80 WORD check
; /* 00 Heap checking flag */
81 WORD freeze
; /* 02 Heap frozen flag */
82 WORD items
; /* 04 Count of items on the heap */
83 WORD first
; /* 06 First item of the heap */
84 WORD pad1
; /* 08 Always 0 */
85 WORD last
; /* 0a Last item of the heap */
86 WORD pad2
; /* 0c Always 0 */
87 BYTE ncompact
; /* 0e Compactions counter */
88 BYTE dislevel
; /* 0f Discard level */
89 DWORD distotal
; /* 10 Total bytes discarded */
90 WORD htable
; /* 14 Pointer to handle table */
91 WORD hfree
; /* 16 Pointer to free handle table */
92 WORD hdelta
; /* 18 Delta to expand the handle table */
93 WORD expand
; /* 1a Pointer to expand function (unused) */
94 WORD pstat
; /* 1c Pointer to status structure (unused) */
95 FARPROC16 notify WINE_PACKED
; /* 1e Pointer to LocalNotify() function */
96 WORD lock
; /* 22 Lock count for the heap */
97 WORD extra
; /* 24 Extra bytes to allocate when expanding */
98 WORD minsize
; /* 26 Minimum size of the heap */
99 WORD magic
; /* 28 Magic number */
104 #define LOCAL_HEAP_MAGIC 0x484c /* 'LH' */
107 /* All local heap allocations are aligned on 4-byte boundaries */
108 #define LALIGN(word) (((word) + 3) & ~3)
110 #define ARENA_PTR(ptr,arena) ((LOCALARENA *)((char*)(ptr)+(arena)))
111 #define ARENA_PREV(ptr,arena) (ARENA_PTR((ptr),(arena))->prev & ~3)
112 #define ARENA_NEXT(ptr,arena) (ARENA_PTR((ptr),(arena))->next)
113 #define ARENA_FLAGS(ptr,arena) (ARENA_PTR((ptr),(arena))->prev & 3)
115 /* determine whether the handle belongs to a fixed or a moveable block */
116 #define HANDLE_FIXED(handle) (((handle) & 3) == 0)
117 #define HANDLE_MOVEABLE(handle) (((handle) & 3) == 2)
119 /***********************************************************************
122 * Return a pointer to the local heap, making sure it exists.
124 static LOCALHEAPINFO
*LOCAL_GetHeap( HANDLE16 ds
)
126 LOCALHEAPINFO
*pInfo
;
127 INSTANCEDATA
*ptr
= (INSTANCEDATA
*)PTR_SEG_OFF_TO_LIN( ds
, 0 );
128 TRACE(local
, "Heap at %p, %04x\n", ptr
, ptr
->heap
);
129 if (!ptr
|| !ptr
->heap
) return NULL
;
130 if (IsBadReadPtr16( (SEGPTR
)MAKELONG(ptr
->heap
,ds
), sizeof(LOCALHEAPINFO
)))
132 pInfo
= (LOCALHEAPINFO
*)((char*)ptr
+ ptr
->heap
);
133 if (pInfo
->magic
!= LOCAL_HEAP_MAGIC
) return NULL
;
138 /***********************************************************************
139 * LOCAL_MakeBlockFree
141 * Make a block free, inserting it in the free-list.
142 * 'block' is the handle of the block arena; 'baseptr' points to
143 * the beginning of the data segment containing the heap.
145 static void LOCAL_MakeBlockFree( char *baseptr
, WORD block
)
147 LOCALARENA
*pArena
, *pNext
;
150 /* Mark the block as free */
152 pArena
= ARENA_PTR( baseptr
, block
);
153 pArena
->prev
= (pArena
->prev
& ~3) | LOCAL_ARENA_FREE
;
154 pArena
->size
= pArena
->next
- block
;
156 /* Find the next free block (last block is always free) */
161 pNext
= ARENA_PTR( baseptr
, next
);
162 if ((pNext
->prev
& 3) == LOCAL_ARENA_FREE
) break;
166 TRACE(local
, "Local_MakeBlockFree %04x, next %04x\n", block
, next
);
167 /* Insert the free block in the free-list */
169 pArena
->free_prev
= pNext
->free_prev
;
170 pArena
->free_next
= next
;
171 ARENA_PTR(baseptr
,pNext
->free_prev
)->free_next
= block
;
172 pNext
->free_prev
= block
;
176 /***********************************************************************
177 * LOCAL_RemoveFreeBlock
179 * Remove a block from the free-list.
180 * 'block' is the handle of the block arena; 'baseptr' points to
181 * the beginning of the data segment containing the heap.
183 static void LOCAL_RemoveFreeBlock( char *baseptr
, WORD block
)
185 /* Mark the block as fixed */
187 LOCALARENA
*pArena
= ARENA_PTR( baseptr
, block
);
188 pArena
->prev
= (pArena
->prev
& ~3) | LOCAL_ARENA_FIXED
;
190 /* Remove it from the list */
192 ARENA_PTR(baseptr
,pArena
->free_prev
)->free_next
= pArena
->free_next
;
193 ARENA_PTR(baseptr
,pArena
->free_next
)->free_prev
= pArena
->free_prev
;
197 /***********************************************************************
200 * Insert a new block in the heap.
201 * 'new' is the handle of the new block arena; 'baseptr' points to
202 * the beginning of the data segment containing the heap; 'prev' is
203 * the block before the new one.
205 static void LOCAL_AddBlock( char *baseptr
, WORD prev
, WORD
new )
207 LOCALARENA
*pPrev
= ARENA_PTR( baseptr
, prev
);
208 LOCALARENA
*pNew
= ARENA_PTR( baseptr
, new );
210 pNew
->prev
= (prev
& ~3) | LOCAL_ARENA_FIXED
;
211 pNew
->next
= pPrev
->next
;
212 ARENA_PTR(baseptr
,pPrev
->next
)->prev
&= 3;
213 ARENA_PTR(baseptr
,pPrev
->next
)->prev
|= new;
218 /***********************************************************************
221 * Remove a block from the heap.
222 * 'block' is the handle of the block arena; 'baseptr' points to
223 * the beginning of the data segment containing the heap.
225 static void LOCAL_RemoveBlock( char *baseptr
, WORD block
)
227 LOCALARENA
*pArena
, *pTmp
;
229 /* Remove the block from the free-list */
231 TRACE(local
, "Local_RemoveBlock\n");
232 pArena
= ARENA_PTR( baseptr
, block
);
233 if ((pArena
->prev
& 3) == LOCAL_ARENA_FREE
)
234 LOCAL_RemoveFreeBlock( baseptr
, block
);
236 /* If the previous block is free, expand its size */
238 pTmp
= ARENA_PTR( baseptr
, pArena
->prev
& ~3 );
239 if ((pTmp
->prev
& 3) == LOCAL_ARENA_FREE
)
240 pTmp
->size
+= pArena
->next
- block
;
242 /* Remove the block from the linked list */
244 pTmp
->next
= pArena
->next
;
245 pTmp
= ARENA_PTR( baseptr
, pArena
->next
);
246 pTmp
->prev
= (pTmp
->prev
& 3) | (pArena
->prev
& ~3);
250 /***********************************************************************
253 static void LOCAL_PrintHeap( HANDLE16 ds
)
256 LOCALHEAPINFO
*pInfo
;
259 /* FIXME - the test should be done when calling the function!
260 plus is not clear that we should print this info
261 only when TRACE_ON is on! */
262 if(!TRACE_ON(local
)) return;
264 ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
265 pInfo
= LOCAL_GetHeap( ds
);
269 DUMP( "Local Heap corrupted! ds=%04x\n", ds
);
272 DUMP( "Local Heap ds=%04x first=%04x last=%04x items=%d\n",
273 ds
, pInfo
->first
, pInfo
->last
, pInfo
->items
);
275 arena
= pInfo
->first
;
278 LOCALARENA
*pArena
= ARENA_PTR(ptr
,arena
);
279 DUMP( " %04x: prev=%04x next=%04x type=%d\n", arena
,
280 pArena
->prev
& ~3, pArena
->next
, pArena
->prev
& 3 );
281 if (arena
== pInfo
->first
)
283 DUMP( " size=%d free_prev=%04x free_next=%04x\n",
284 pArena
->size
, pArena
->free_prev
, pArena
->free_next
);
286 if ((pArena
->prev
& 3) == LOCAL_ARENA_FREE
)
288 DUMP( " size=%d free_prev=%04x free_next=%04x\n",
289 pArena
->size
, pArena
->free_prev
, pArena
->free_next
);
290 if (pArena
->next
== arena
) break; /* last one */
291 if (ARENA_PTR(ptr
,pArena
->free_next
)->free_prev
!= arena
)
293 DUMP( "*** arena->free_next->free_prev != arena\n" );
297 if (pArena
->next
== arena
)
299 DUMP( "*** last block is not marked free\n" );
302 if ((ARENA_PTR(ptr
,pArena
->next
)->prev
& ~3) != arena
)
304 DUMP( "*** arena->next->prev != arena (%04x, %04x)\n",
305 pArena
->next
, ARENA_PTR(ptr
,pArena
->next
)->prev
);
308 arena
= pArena
->next
;
313 /***********************************************************************
314 * LocalInit (KERNEL.4)
316 BOOL16 WINAPI
LocalInit( HANDLE16 selector
, WORD start
, WORD end
)
319 WORD heapInfoArena
, freeArena
, lastArena
;
320 LOCALHEAPINFO
*pHeapInfo
;
321 LOCALARENA
*pArena
, *pFirstArena
, *pLastArena
;
324 /* The initial layout of the heap is: */
325 /* - first arena (FIXED) */
326 /* - heap info structure (FIXED) */
327 /* - large free block (FREE) */
328 /* - last arena (FREE) */
330 TRACE(local
, "%04x %04x-%04x\n", selector
, start
, end
);
331 if (!selector
) selector
= CURRENT_DS
;
335 /* If TRACE_ON(heap) is set, the global heap blocks are */
336 /* cleared before use, so we can test for double initialization. */
337 if (LOCAL_GetHeap(selector
))
339 fprintf( stderr
, "LocalInit: Heap %04x initialized twice.\n", selector
);
340 LOCAL_PrintHeap(selector
);
345 /* Check if the segment is the DGROUP of a module */
347 if ((pModule
= MODULE_GetPtr( selector
)))
349 SEGTABLEENTRY
*pSeg
= NE_SEG_TABLE( pModule
) + pModule
->dgroup
- 1;
350 if (pModule
->dgroup
&& (pSeg
->selector
== selector
)) {
351 /* We can't just use the simple method of using the value
352 * of minsize + stacksize, since there are programs that
353 * resize the data segment before calling InitTask(). So,
354 * we must put it at the end of the segment */
355 start
= GlobalSize16( GlobalHandle16( selector
) );
358 TRACE(local
," new start %04x, minstart: %04x\n", start
, pSeg
->minsize
+ pModule
->stack_size
);
362 ptr
= PTR_SEG_OFF_TO_LIN( selector
, 0 );
364 start
= LALIGN( MAX( start
, sizeof(INSTANCEDATA
) ) );
365 heapInfoArena
= LALIGN(start
+ sizeof(LOCALARENA
) );
366 freeArena
= LALIGN( heapInfoArena
+ ARENA_HEADER_SIZE
367 + sizeof(LOCALHEAPINFO
) );
368 lastArena
= (end
- sizeof(LOCALARENA
)) & ~3;
370 /* Make sure there's enough space. */
372 if (freeArena
+ sizeof(LOCALARENA
) >= lastArena
) return FALSE
;
374 /* Initialise the first arena */
376 pFirstArena
= ARENA_PTR( ptr
, start
);
377 pFirstArena
->prev
= start
| LOCAL_ARENA_FIXED
;
378 pFirstArena
->next
= heapInfoArena
;
379 pFirstArena
->size
= LALIGN(sizeof(LOCALARENA
));
380 pFirstArena
->free_prev
= start
; /* this one */
381 pFirstArena
->free_next
= freeArena
;
383 /* Initialise the arena of the heap info structure */
385 pArena
= ARENA_PTR( ptr
, heapInfoArena
);
386 pArena
->prev
= start
| LOCAL_ARENA_FIXED
;
387 pArena
->next
= freeArena
;
389 /* Initialise the heap info structure */
391 pHeapInfo
= (LOCALHEAPINFO
*) (ptr
+ heapInfoArena
+ ARENA_HEADER_SIZE
);
392 memset( pHeapInfo
, 0, sizeof(LOCALHEAPINFO
) );
393 pHeapInfo
->items
= 4;
394 pHeapInfo
->first
= start
;
395 pHeapInfo
->last
= lastArena
;
396 pHeapInfo
->htable
= 0;
397 pHeapInfo
->hdelta
= 0x20;
398 pHeapInfo
->extra
= 0x200;
399 pHeapInfo
->minsize
= lastArena
- freeArena
;
400 pHeapInfo
->magic
= LOCAL_HEAP_MAGIC
;
402 /* Initialise the large free block */
404 pArena
= ARENA_PTR( ptr
, freeArena
);
405 pArena
->prev
= heapInfoArena
| LOCAL_ARENA_FREE
;
406 pArena
->next
= lastArena
;
407 pArena
->size
= lastArena
- freeArena
;
408 pArena
->free_prev
= start
;
409 pArena
->free_next
= lastArena
;
411 /* Initialise the last block */
413 pLastArena
= ARENA_PTR( ptr
, lastArena
);
414 pLastArena
->prev
= freeArena
| LOCAL_ARENA_FREE
;
415 pLastArena
->next
= lastArena
; /* this one */
416 pLastArena
->size
= LALIGN(sizeof(LOCALARENA
));
417 pLastArena
->free_prev
= freeArena
;
418 pLastArena
->free_next
= lastArena
; /* this one */
420 /* Store the local heap address in the instance data */
422 ((INSTANCEDATA
*)ptr
)->heap
= heapInfoArena
+ ARENA_HEADER_SIZE
;
423 LOCAL_PrintHeap( selector
);
427 /***********************************************************************
430 static void LOCAL_GrowHeap( HANDLE16 ds
)
432 HANDLE16 hseg
= GlobalHandle16( ds
);
433 LONG oldsize
= GlobalSize16( hseg
);
435 LOCALHEAPINFO
*pHeapInfo
;
436 WORD freeArena
, lastArena
;
437 LOCALARENA
*pArena
, *pLastArena
;
440 /* if nothing can be gained, return */
441 if (oldsize
> 0xfff0) return;
442 hseg
= GlobalReAlloc16( hseg
, 0x10000, GMEM_FIXED
);
443 ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
444 pHeapInfo
= LOCAL_GetHeap( ds
);
445 if (pHeapInfo
== NULL
) {
446 fprintf( stderr
, "Local_GrowHeap: heap not found\n" );
449 end
= GlobalSize16( hseg
);
450 lastArena
= (end
- sizeof(LOCALARENA
)) & ~3;
452 /* Update the HeapInfo */
454 freeArena
= pHeapInfo
->last
;
455 pHeapInfo
->last
= lastArena
;
456 pHeapInfo
->minsize
+= end
- oldsize
;
458 /* grow the old last block */
459 pArena
= ARENA_PTR( ptr
, freeArena
);
460 pArena
->size
= lastArena
- freeArena
;
461 pArena
->next
= lastArena
;
462 pArena
->free_next
= lastArena
;
464 /* Initialise the new last block */
466 pLastArena
= ARENA_PTR( ptr
, lastArena
);
467 pLastArena
->prev
= freeArena
| LOCAL_ARENA_FREE
;
468 pLastArena
->next
= lastArena
; /* this one */
469 pLastArena
->size
= LALIGN(sizeof(LOCALARENA
));
470 pLastArena
->free_prev
= freeArena
;
471 pLastArena
->free_next
= lastArena
; /* this one */
473 /* If block before freeArena is also free then merge them */
474 if((ARENA_PTR(ptr
, (pArena
->prev
& ~3))->prev
& 3) == LOCAL_ARENA_FREE
)
476 LOCAL_RemoveBlock(ptr
, freeArena
);
480 TRACE(local
, "Heap expanded\n" );
481 LOCAL_PrintHeap( ds
);
485 /***********************************************************************
488 static HLOCAL16
LOCAL_FreeArena( WORD ds
, WORD arena
)
490 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
491 LOCALHEAPINFO
*pInfo
;
492 LOCALARENA
*pArena
, *pPrev
, *pNext
;
494 TRACE(local
, "%04x ds=%04x\n", arena
, ds
);
495 if (!(pInfo
= LOCAL_GetHeap( ds
))) return arena
;
497 pArena
= ARENA_PTR( ptr
, arena
);
498 if ((pArena
->prev
& 3) == LOCAL_ARENA_FREE
)
500 /* shouldn't happen */
501 fprintf( stderr
, "LocalFreeArena: Trying to free block %04x twice!\n",
503 LOCAL_PrintHeap( ds
);
507 /* Check if we can merge with the previous block */
509 pPrev
= ARENA_PTR( ptr
, pArena
->prev
& ~3 );
510 pNext
= ARENA_PTR( ptr
, pArena
->next
);
511 if ((pPrev
->prev
& 3) == LOCAL_ARENA_FREE
)
513 arena
= pArena
->prev
& ~3;
515 LOCAL_RemoveBlock( ptr
, pPrev
->next
);
518 else /* Make a new free block */
520 LOCAL_MakeBlockFree( ptr
, arena
);
523 /* Check if we can merge with the next block */
525 if ((pArena
->next
== pArena
->free_next
) &&
526 (pArena
->next
!= pInfo
->last
))
528 LOCAL_RemoveBlock( ptr
, pArena
->next
);
535 /***********************************************************************
538 * Shrink an arena by creating a free block at its end if possible.
539 * 'size' includes the arena header, and must be aligned.
541 static void LOCAL_ShrinkArena( WORD ds
, WORD arena
, WORD size
)
543 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
544 LOCALARENA
*pArena
= ARENA_PTR( ptr
, arena
);
546 if (arena
+ size
+ LALIGN(sizeof(LOCALARENA
)) < pArena
->next
)
548 LOCALHEAPINFO
*pInfo
= LOCAL_GetHeap( ds
);
550 LOCAL_AddBlock( ptr
, arena
, arena
+ size
);
552 LOCAL_FreeArena( ds
, arena
+ size
);
557 /***********************************************************************
558 * LOCAL_GrowArenaDownward
560 * Grow an arena downward by using the previous arena (must be free).
562 static void LOCAL_GrowArenaDownward( WORD ds
, WORD arena
, WORD newsize
)
564 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
565 LOCALHEAPINFO
*pInfo
;
566 LOCALARENA
*pArena
= ARENA_PTR( ptr
, arena
);
567 WORD prevArena
= pArena
->prev
& ~3;
568 LOCALARENA
*pPrevArena
= ARENA_PTR( ptr
, prevArena
);
572 if (!(pInfo
= LOCAL_GetHeap( ds
))) return;
573 offset
= pPrevArena
->size
;
574 size
= pArena
->next
- arena
- ARENA_HEADER_SIZE
;
575 LOCAL_RemoveFreeBlock( ptr
, prevArena
);
576 LOCAL_RemoveBlock( ptr
, arena
);
578 p
= (char *)pPrevArena
+ ARENA_HEADER_SIZE
;
579 while (offset
< size
)
581 memcpy( p
, p
+ offset
, offset
);
585 if (size
) memcpy( p
, p
+ offset
, size
);
586 LOCAL_ShrinkArena( ds
, prevArena
, newsize
);
591 /***********************************************************************
592 * LOCAL_GrowArenaUpward
594 * Grow an arena upward by using the next arena (must be free and big
595 * enough). Newsize includes the arena header and must be aligned.
597 static void LOCAL_GrowArenaUpward( WORD ds
, WORD arena
, WORD newsize
)
599 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
600 LOCALHEAPINFO
*pInfo
;
601 LOCALARENA
*pArena
= ARENA_PTR( ptr
, arena
);
602 WORD nextArena
= pArena
->next
;
604 if (!(pInfo
= LOCAL_GetHeap( ds
))) return;
605 LOCAL_RemoveBlock( ptr
, nextArena
);
607 LOCAL_ShrinkArena( ds
, arena
, newsize
);
611 /***********************************************************************
614 static WORD
LOCAL_GetFreeSpace(WORD ds
, WORD countdiscard
)
616 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
617 LOCALHEAPINFO
*pInfo
;
622 if (!(pInfo
= LOCAL_GetHeap( ds
)))
624 fprintf( stderr
, "LOCAL_GetFreeSpace: Local heap not found\n" );
628 arena
= pInfo
->first
;
629 pArena
= ARENA_PTR( ptr
, arena
);
630 while (arena
!= pArena
->free_next
)
632 arena
= pArena
->free_next
;
633 pArena
= ARENA_PTR( ptr
, arena
);
634 if (pArena
->size
>= freespace
) freespace
= pArena
->size
;
636 /* FIXME doesn't yet calculate space that would become free if everything
637 were discarded when countdiscard == 1 */
638 if (freespace
< ARENA_HEADER_SIZE
) freespace
= 0;
639 else freespace
-= ARENA_HEADER_SIZE
;
644 /***********************************************************************
647 WORD
LOCAL_Compact( HANDLE16 ds
, UINT16 minfree
, UINT16 flags
)
649 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
650 LOCALHEAPINFO
*pInfo
;
651 LOCALARENA
*pArena
, *pMoveArena
, *pFinalArena
;
652 WORD arena
, movearena
, finalarena
, table
;
653 WORD count
, movesize
, size
;
655 LOCALHANDLEENTRY
*pEntry
;
657 if (!(pInfo
= LOCAL_GetHeap( ds
)))
659 fprintf( stderr
, "Local_Compact: Local heap not found\n" );
663 TRACE(local
, "ds = %04x, minfree = %04x, flags = %04x\n",
665 freespace
= LOCAL_GetFreeSpace(ds
, minfree
? 0 : 1);
666 if(freespace
>= minfree
|| (flags
& LMEM_NOCOMPACT
))
668 TRACE(local
, "Returning %04x.\n", freespace
);
671 TRACE(local
, "Compacting heap %04x.\n", ds
);
672 table
= pInfo
->htable
;
675 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ table
+ sizeof(WORD
));
676 for(count
= *(WORD
*)(ptr
+ table
); count
> 0; count
--, pEntry
++)
678 if((pEntry
->lock
== 0) && (pEntry
->flags
!= (LMEM_DISCARDED
>> 8)))
680 /* OK we can move this one if we want */
681 TRACE(local
, "handle %04x (block %04x) can be moved.\n",
682 (WORD
)((char *)pEntry
- ptr
), pEntry
->addr
);
683 movearena
= ARENA_HEADER(pEntry
->addr
);
684 pMoveArena
= ARENA_PTR(ptr
, movearena
);
685 movesize
= pMoveArena
->next
- movearena
;
686 arena
= pInfo
->first
;
687 pArena
= ARENA_PTR(ptr
, arena
);
690 /* Try to find the smallest arena that will do, */
691 /* which is below us in memory */
694 arena
= pArena
->free_next
;
695 pArena
= ARENA_PTR(ptr
, arena
);
696 if(arena
>= movearena
)
698 if(arena
== pArena
->free_next
)
700 if((pArena
->size
>= movesize
) && (pArena
->size
< size
))
706 if (finalarena
) /* Actually got somewhere to move */
708 TRACE(local
, "Moving it to %04x.\n", finalarena
);
709 pFinalArena
= ARENA_PTR(ptr
, finalarena
);
710 size
= pFinalArena
->size
;
711 LOCAL_RemoveFreeBlock(ptr
, finalarena
);
712 LOCAL_ShrinkArena( ds
, finalarena
, movesize
);
713 /* Copy the arena to it's new location */
714 memcpy((char *)pFinalArena
+ ARENA_HEADER_SIZE
,
715 (char *)pMoveArena
+ ARENA_HEADER_SIZE
,
716 movesize
- ARENA_HEADER_SIZE
);
717 /* Free the old location */
718 LOCAL_FreeArena(ds
, movearena
);
719 /* Update handle table entry */
720 pEntry
->addr
= finalarena
+ ARENA_HEADER_SIZE
+ sizeof(HLOCAL16
) ;
722 else if((ARENA_PTR(ptr
, pMoveArena
->prev
& ~3)->prev
& 3)
725 /* Previous arena is free (but < movesize) */
726 /* so we can 'slide' movearena down into it */
727 finalarena
= pMoveArena
->prev
& ~3;
728 LOCAL_GrowArenaDownward( ds
, movearena
, movesize
);
729 /* Update handle table entry */
730 pEntry
->addr
= finalarena
+ ARENA_HEADER_SIZE
+ sizeof(HLOCAL16
) ;
734 table
= *(WORD
*)pEntry
;
736 freespace
= LOCAL_GetFreeSpace(ds
, minfree
? 0 : 1);
737 if(freespace
>= minfree
|| (flags
& LMEM_NODISCARD
))
739 TRACE(local
, "Returning %04x.\n", freespace
);
743 table
= pInfo
->htable
;
746 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ table
+ sizeof(WORD
));
747 for(count
= *(WORD
*)(ptr
+ table
); count
> 0; count
--, pEntry
++)
749 if(pEntry
->addr
&& pEntry
->lock
== 0 &&
750 (pEntry
->flags
& (LMEM_DISCARDABLE
>> 8)))
752 TRACE(local
, "Discarding handle %04x (block %04x).\n",
753 (char *)pEntry
- ptr
, pEntry
->addr
);
754 LOCAL_FreeArena(ds
, ARENA_HEADER(pEntry
->addr
));
756 pEntry
->flags
= (LMEM_DISCARDED
>> 8);
757 /* Call localnotify proc */
760 table
= *(WORD
*)pEntry
;
762 return LOCAL_Compact(ds
, 0xffff, LMEM_NODISCARD
);
766 /***********************************************************************
767 * LOCAL_FindFreeBlock
769 static HLOCAL16
LOCAL_FindFreeBlock( HANDLE16 ds
, WORD size
)
771 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
772 LOCALHEAPINFO
*pInfo
;
776 if (!(pInfo
= LOCAL_GetHeap( ds
)))
778 fprintf( stderr
, "Local_FindFreeBlock: Local heap not found\n" );
783 arena
= pInfo
->first
;
784 pArena
= ARENA_PTR( ptr
, arena
);
786 arena
= pArena
->free_next
;
787 pArena
= ARENA_PTR( ptr
, arena
);
788 if (arena
== pArena
->free_next
) break;
789 if (pArena
->size
>= size
) return arena
;
791 WARN(local
, "not enough space\n" );
796 /***********************************************************************
798 * The segment may get moved around in this function, so all callers
799 * should reset their pointer variables.
801 static HLOCAL16
LOCAL_GetBlock( HANDLE16 ds
, WORD size
, WORD flags
)
803 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
804 LOCALHEAPINFO
*pInfo
;
808 if (!(pInfo
= LOCAL_GetHeap( ds
)))
810 fprintf( stderr
, "Local_GetBlock: Local heap not found\n");
815 size
+= ARENA_HEADER_SIZE
;
816 size
= LALIGN( MAX( size
, sizeof(LOCALARENA
) ) );
818 /* Find a suitable free block */
819 arena
= LOCAL_FindFreeBlock( ds
, size
);
821 /* no space: try to make some */
822 LOCAL_Compact( ds
, size
, flags
);
823 arena
= LOCAL_FindFreeBlock( ds
, size
);
826 /* still no space: try to grow the segment */
827 LOCAL_GrowHeap( ds
);
828 ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
829 pInfo
= LOCAL_GetHeap( ds
);
830 arena
= LOCAL_FindFreeBlock( ds
, size
);
833 if (ds
== GDI_HeapSel
) {
834 WARN(local
, "not enough space in GDI local heap "
835 "(%04x) for %d bytes\n", ds
, size
);
836 } else if (ds
== USER_HeapSel
) {
837 WARN(local
, "not enough space in USER local heap "
838 "(%04x) for %d bytes\n", ds
, size
);
840 WARN(local
, "not enough space in local heap "
841 "%04x for %d bytes\n", ds
, size
);
846 /* Make a block out of the free arena */
847 pArena
= ARENA_PTR( ptr
, arena
);
848 TRACE(local
, "LOCAL_GetBlock size = %04x, arena %04x size %04x\n",
849 size
, arena
, pArena
->size
);
850 LOCAL_RemoveFreeBlock( ptr
, arena
);
851 LOCAL_ShrinkArena( ds
, arena
, size
);
853 if (flags
& LMEM_ZEROINIT
)
854 memset((char *)pArena
+ ARENA_HEADER_SIZE
, 0, size
-ARENA_HEADER_SIZE
);
855 return arena
+ ARENA_HEADER_SIZE
;
859 /***********************************************************************
862 static BOOL16
LOCAL_NewHTable( HANDLE16 ds
)
864 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
865 LOCALHEAPINFO
*pInfo
;
866 LOCALHANDLEENTRY
*pEntry
;
870 TRACE(local
, "Local_NewHTable\n" );
871 if (!(pInfo
= LOCAL_GetHeap( ds
)))
873 fprintf( stderr
, "Local heap not found\n");
878 if (!(handle
= LOCAL_GetBlock( ds
, pInfo
->hdelta
* sizeof(LOCALHANDLEENTRY
)
879 + 2 * sizeof(WORD
), LMEM_FIXED
)))
881 if (!(ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 )))
882 fprintf(stderr
, "LOCAL_NewHTable: ptr == NULL after GetBlock.\n");
883 if (!(pInfo
= LOCAL_GetHeap( ds
)))
884 fprintf(stderr
,"LOCAL_NewHTable: pInfo == NULL after GetBlock.\n");
886 /* Fill the entry table */
888 *(WORD
*)(ptr
+ handle
) = pInfo
->hdelta
;
889 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
+ sizeof(WORD
));
890 for (i
= pInfo
->hdelta
; i
> 0; i
--, pEntry
++) {
891 pEntry
->lock
= pEntry
->flags
= 0xff;
894 *(WORD
*)pEntry
= pInfo
->htable
;
895 pInfo
->htable
= handle
;
900 /***********************************************************************
901 * LOCAL_GetNewHandleEntry
903 static HLOCAL16
LOCAL_GetNewHandleEntry( HANDLE16 ds
)
905 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
906 LOCALHEAPINFO
*pInfo
;
907 LOCALHANDLEENTRY
*pEntry
= NULL
;
910 if (!(pInfo
= LOCAL_GetHeap( ds
)))
912 fprintf( stderr
, "LOCAL_GetNewHandleEntry: Local heap not found\n");
917 /* Find a free slot in existing tables */
919 table
= pInfo
->htable
;
922 WORD count
= *(WORD
*)(ptr
+ table
);
923 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ table
+ sizeof(WORD
));
924 for (; count
> 0; count
--, pEntry
++)
925 if (pEntry
->lock
== 0xff) break;
927 table
= *(WORD
*)pEntry
;
930 if (!table
) /* We need to create a new table */
932 if (!LOCAL_NewHTable( ds
)) return 0;
933 ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
934 pInfo
= LOCAL_GetHeap( ds
);
935 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ pInfo
->htable
+ sizeof(WORD
));
938 /* Now allocate this entry */
942 TRACE(local
, "(%04x): %04x\n",
943 ds
, ((char *)pEntry
- ptr
) );
944 return (HLOCAL16
)((char *)pEntry
- ptr
);
948 /***********************************************************************
949 * LOCAL_FreeHandleEntry
951 * Free a handle table entry.
953 static void LOCAL_FreeHandleEntry( HANDLE16 ds
, HLOCAL16 handle
)
955 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
956 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
957 LOCALHEAPINFO
*pInfo
;
959 WORD table
, count
, i
;
961 if (!(pInfo
= LOCAL_GetHeap( ds
))) return;
963 /* Find the table where this handle comes from */
965 pTable
= &pInfo
->htable
;
968 WORD size
= (*(WORD
*)(ptr
+ *pTable
)) * sizeof(LOCALHANDLEENTRY
);
969 if ((handle
>= *pTable
+ sizeof(WORD
)) &&
970 (handle
< *pTable
+ sizeof(WORD
) + size
)) break; /* Found it */
971 pTable
= (WORD
*)(ptr
+ *pTable
+ sizeof(WORD
) + size
);
975 fprintf(stderr
, "LOCAL_FreeHandleEntry: invalid entry %04x\n", handle
);
976 LOCAL_PrintHeap( ds
);
980 /* Make the entry free */
982 pEntry
->addr
= 0; /* just in case */
984 pEntry
->flags
= 0xff;
985 /* Now check if all entries in this table are free */
988 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ table
+ sizeof(WORD
));
989 count
= *(WORD
*)(ptr
+ table
);
990 for (i
= count
; i
> 0; i
--, pEntry
++) if (pEntry
->lock
!= 0xff) return;
992 /* Remove the table from the linked list and free it */
994 TRACE(local
, "(%04x): freeing table %04x\n",
996 *pTable
= *(WORD
*)pEntry
;
997 LOCAL_FreeArena( ds
, ARENA_HEADER( table
) );
1001 /***********************************************************************
1004 * Implementation of LocalFree().
1006 HLOCAL16
LOCAL_Free( HANDLE16 ds
, HLOCAL16 handle
)
1008 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1010 TRACE(local
, "%04x ds=%04x\n", handle
, ds
);
1012 if (!handle
) { fprintf( stderr
, "LOCAL_Free: handle is 0.\n" ); return 0; }
1013 if (HANDLE_FIXED( handle
))
1015 if (!LOCAL_FreeArena( ds
, ARENA_HEADER( handle
) )) return 0; /* OK */
1016 else return handle
; /* couldn't free it */
1020 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1021 if (pEntry
->flags
!= (LMEM_DISCARDED
>> 8))
1023 TRACE(local
, "real block at %04x\n",
1025 if (LOCAL_FreeArena( ds
, ARENA_HEADER(pEntry
->addr
) ))
1026 return handle
; /* couldn't free it */
1028 LOCAL_FreeHandleEntry( ds
, handle
);
1034 /***********************************************************************
1037 * Implementation of LocalAlloc().
1040 HLOCAL16
LOCAL_Alloc( HANDLE16 ds
, WORD flags
, WORD size
)
1045 TRACE(local
, "%04x %d ds=%04x\n", flags
, size
, ds
);
1047 if(size
> 0 && size
<= 4) size
= 5;
1048 if (flags
& LMEM_MOVEABLE
)
1050 LOCALHANDLEENTRY
*plhe
;
1055 if (!(hmem
= LOCAL_GetBlock( ds
, size
+ sizeof(HLOCAL16
), flags
)))
1058 else /* We just need to allocate a discarded handle */
1060 if (!(handle
= LOCAL_GetNewHandleEntry( ds
)))
1062 fprintf( stderr
, "LocalAlloc: couldn't get handle\n");
1064 LOCAL_FreeArena( ds
, ARENA_HEADER(hmem
) );
1067 ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1068 plhe
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1072 plhe
->addr
= hmem
+ sizeof(HLOCAL16
);
1073 plhe
->flags
= (BYTE
)((flags
& 0x0f00) >> 8);
1074 *(HLOCAL16
*)(ptr
+ hmem
) = handle
;
1079 plhe
->flags
= LMEM_DISCARDED
>> 8;
1086 handle
= LOCAL_GetBlock( ds
, size
, flags
);
1092 /***********************************************************************
1095 * Implementation of LocalReAlloc().
1097 HLOCAL16
LOCAL_ReAlloc( HANDLE16 ds
, HLOCAL16 handle
, WORD size
, WORD flags
)
1099 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1100 LOCALHEAPINFO
*pInfo
;
1101 LOCALARENA
*pArena
, *pNext
;
1102 LOCALHANDLEENTRY
*pEntry
;
1103 WORD arena
, oldsize
;
1104 HLOCAL16 hmem
, blockhandle
;
1107 if (!handle
) return 0;
1108 if(HANDLE_MOVEABLE(handle
) &&
1109 ((LOCALHANDLEENTRY
*)(ptr
+ handle
))->lock
== 0xff) /* An unused handle */
1112 TRACE(local
, "%04x %d %04x ds=%04x\n",
1113 handle
, size
, flags
, ds
);
1114 if (!(pInfo
= LOCAL_GetHeap( ds
))) return 0;
1116 if (HANDLE_FIXED( handle
))
1117 blockhandle
= handle
;
1120 pEntry
= (LOCALHANDLEENTRY
*) (ptr
+ handle
);
1121 if(pEntry
->flags
== (LMEM_DISCARDED
>> 8))
1126 "LOCAL_ReAlloc: Dicarded block has non-zero addr.\n");
1127 TRACE(local
, "ReAllocating discarded block\n");
1128 if(size
<= 4) size
= 5;
1129 if (!(hl
= LOCAL_GetBlock( ds
, size
+ sizeof(HLOCAL16
), flags
)))
1131 ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 ); /* Reload ptr */
1132 pEntry
= (LOCALHANDLEENTRY
*) (ptr
+ handle
);
1133 pEntry
->addr
= hl
+ sizeof(HLOCAL16
);
1136 *(HLOCAL16
*)(ptr
+ hl
) = handle
;
1139 if (((blockhandle
= pEntry
->addr
) & 3) != 2)
1141 fprintf( stderr
, "Local_ReAlloc(%04x,%04x): invalid handle\n",
1145 if(*((HLOCAL16
*)(ptr
+ blockhandle
) - 1) != handle
) {
1146 fprintf(stderr
, "Local_ReAlloc: Back ptr to handle is invalid\n");
1151 if (flags
& LMEM_MODIFY
)
1153 if (HANDLE_MOVEABLE(handle
))
1155 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1156 pEntry
->flags
= (flags
& 0x0f00) >> 8;
1157 TRACE(local
, "Changing flags to %x.\n", pEntry
->flags
);
1164 if (flags
& LMEM_MOVEABLE
)
1166 if (HANDLE_FIXED(handle
))
1168 TRACE(local
, "Freeing fixed block.\n");
1169 return LOCAL_Free( ds
, handle
);
1171 else /* Moveable block */
1173 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1174 if (pEntry
->lock
== 0)
1176 /* discards moveable blocks */
1177 TRACE(local
,"Discarding block\n");
1178 LOCAL_FreeArena(ds
, ARENA_HEADER(pEntry
->addr
));
1180 pEntry
->flags
= (LMEM_DISCARDED
>> 8);
1188 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1189 if (pEntry
->lock
== 0)
1192 return LOCAL_Free( ds
, handle
);
1198 arena
= ARENA_HEADER( blockhandle
);
1199 TRACE(local
, "arena is %04x\n", arena
);
1200 pArena
= ARENA_PTR( ptr
, arena
);
1202 if(size
<= 4) size
= 5;
1203 oldsize
= pArena
->next
- arena
- ARENA_HEADER_SIZE
;
1204 nextarena
= LALIGN(blockhandle
+ size
);
1206 /* Check for size reduction */
1208 if (nextarena
<= pArena
->next
)
1210 TRACE(local
, "size reduction, making new free block\n");
1211 LOCAL_ShrinkArena(ds
, arena
, nextarena
- arena
);
1212 TRACE(local
, "returning %04x\n", handle
);
1216 /* Check if the next block is free and large enough */
1218 pNext
= ARENA_PTR( ptr
, pArena
->next
);
1219 if (((pNext
->prev
& 3) == LOCAL_ARENA_FREE
) &&
1220 (nextarena
<= pNext
->next
))
1222 TRACE(local
, "size increase, making new free block\n");
1223 LOCAL_GrowArenaUpward(ds
, arena
, nextarena
- arena
);
1224 TRACE(local
, "returning %04x\n", handle
);
1228 /* Now we have to allocate a new block, but not if (fixed block or locked
1229 block) and no LMEM_MOVEABLE */
1231 if (!(flags
& LMEM_MOVEABLE
))
1233 if (HANDLE_FIXED(handle
))
1235 WARN(local
, "Needed to move fixed block, but LMEM_MOVEABLE not specified.\n");
1240 if(((LOCALHANDLEENTRY
*)(ptr
+ handle
))->lock
!= 0)
1242 WARN(local
, "Needed to move locked block, but LMEM_MOVEABLE not specified.\n");
1247 if(HANDLE_MOVEABLE(handle
)) size
+= sizeof(HLOCAL16
);
1248 hmem
= LOCAL_GetBlock( ds
, size
, flags
);
1249 ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 ); /* Reload ptr */
1250 if(HANDLE_MOVEABLE(handle
)) /* LOCAL_GetBlock might have triggered */
1251 { /* a compaction, which might in turn have */
1252 blockhandle
= pEntry
->addr
; /* moved the very block we are resizing */
1253 arena
= ARENA_HEADER( blockhandle
); /* thus, we reload arena, too */
1257 /* Remove the block from the heap and try again */
1258 LPSTR buffer
= HeapAlloc( GetProcessHeap(), 0, oldsize
);
1259 if (!buffer
) return 0;
1260 memcpy( buffer
, ptr
+ arena
+ ARENA_HEADER_SIZE
, oldsize
);
1261 LOCAL_FreeArena( ds
, arena
);
1262 if (!(hmem
= LOCAL_GetBlock( ds
, size
, flags
)))
1264 if (!(hmem
= LOCAL_GetBlock( ds
, oldsize
, flags
)))
1266 fprintf( stderr
, "LocalRealloc: can't restore saved block\n" );
1267 HeapFree( GetProcessHeap(), 0, buffer
);
1272 ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 ); /* Reload ptr */
1273 memcpy( ptr
+ hmem
, buffer
, oldsize
);
1274 HeapFree( GetProcessHeap(), 0, buffer
);
1278 memcpy( ptr
+ hmem
, ptr
+ (arena
+ ARENA_HEADER_SIZE
), oldsize
);
1279 LOCAL_FreeArena( ds
, arena
);
1281 if (HANDLE_MOVEABLE( handle
))
1283 TRACE(local
, "fixing handle\n");
1284 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1285 pEntry
->addr
= hmem
+ sizeof(HLOCAL16
);
1286 /* Back ptr should still be correct */
1287 if(*(HLOCAL16
*)(ptr
+ hmem
) != handle
)
1288 fprintf(stderr
, "Local_ReAlloc: back ptr is invalid.\n");
1291 if (size
== oldsize
) hmem
= 0; /* Realloc failed */
1292 TRACE(local
, "returning %04x\n", hmem
);
1297 /***********************************************************************
1298 * LOCAL_InternalLock
1300 static HLOCAL16
LOCAL_InternalLock( LPSTR heap
, HLOCAL16 handle
)
1302 HLOCAL16 old_handle
= handle
;
1304 if (HANDLE_MOVEABLE(handle
))
1306 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(heap
+ handle
);
1307 if (pEntry
->flags
== LMEM_DISCARDED
) return 0;
1308 if (pEntry
->lock
< 0xfe) pEntry
->lock
++;
1309 handle
= pEntry
->addr
;
1311 TRACE(local
, "%04x returning %04x\n",
1312 old_handle
, handle
);
1317 /***********************************************************************
1320 LPSTR
LOCAL_Lock( HANDLE16 ds
, HLOCAL16 handle
)
1322 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1323 return handle
? ptr
+ LOCAL_InternalLock( ptr
, handle
) : NULL
;
1327 /***********************************************************************
1330 SEGPTR
LOCAL_LockSegptr( HANDLE16 ds
, HLOCAL16 handle
)
1332 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1333 return PTR_SEG_OFF_TO_SEGPTR( ds
, LOCAL_InternalLock( ptr
, handle
) );
1337 /***********************************************************************
1340 BOOL16
LOCAL_Unlock( HANDLE16 ds
, HLOCAL16 handle
)
1342 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1344 TRACE(local
, "%04x\n", handle
);
1345 if (HANDLE_MOVEABLE(handle
))
1347 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1348 if (!pEntry
->lock
|| (pEntry
->lock
== 0xff)) return FALSE
;
1349 /* For moveable block, return the new lock count */
1350 /* (see _Windows_Internals_ p. 197) */
1351 return --pEntry
->lock
;
1357 /***********************************************************************
1360 * Implementation of LocalSize().
1362 WORD
LOCAL_Size( HANDLE16 ds
, HLOCAL16 handle
)
1364 char *ptr
= PTR_SEG_OFF_TO_LIN( CURRENT_DS
, 0 );
1367 TRACE(local
, "%04x ds=%04x\n", handle
, ds
);
1369 if (HANDLE_MOVEABLE( handle
)) handle
= *(WORD
*)(ptr
+ handle
);
1370 if (!handle
) return 0;
1371 pArena
= ARENA_PTR( ptr
, ARENA_HEADER(handle
) );
1372 return pArena
->next
- handle
;
1376 /***********************************************************************
1379 * Implementation of LocalFlags().
1381 WORD
LOCAL_Flags( HANDLE16 ds
, HLOCAL16 handle
)
1383 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1385 if (HANDLE_MOVEABLE(handle
))
1387 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1388 TRACE(local
, "(%04x,%04x): returning %04x\n",
1389 ds
, handle
, pEntry
->lock
| (pEntry
->flags
<< 8) );
1390 return pEntry
->lock
| (pEntry
->flags
<< 8);
1394 TRACE(local
, "(%04x,%04x): returning 0\n",
1401 /***********************************************************************
1404 * Implementation of LocalHeapSize().
1406 WORD
LOCAL_HeapSize( HANDLE16 ds
)
1408 LOCALHEAPINFO
*pInfo
= LOCAL_GetHeap( ds
);
1409 if (!pInfo
) return 0;
1410 return pInfo
->last
- pInfo
->first
;
1414 /***********************************************************************
1417 * Implementation of LocalCountFree().
1419 WORD
LOCAL_CountFree( HANDLE16 ds
)
1423 LOCALHEAPINFO
*pInfo
;
1424 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1426 if (!(pInfo
= LOCAL_GetHeap( ds
)))
1428 fprintf( stderr
, "LOCAL_Handle(%04x): Local heap not found\n", ds
);
1429 LOCAL_PrintHeap( ds
);
1434 arena
= pInfo
->first
;
1435 pArena
= ARENA_PTR( ptr
, arena
);
1438 arena
= pArena
->free_next
;
1439 pArena
= ARENA_PTR( ptr
, arena
);
1440 if (arena
== pArena
->free_next
) break;
1441 total
+= pArena
->size
;
1443 TRACE(local
, "(%04x): returning %d\n", ds
, total
);
1448 /***********************************************************************
1451 * Implementation of LocalHandle().
1453 HLOCAL16
LOCAL_Handle( HANDLE16 ds
, WORD addr
)
1455 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1456 LOCALHEAPINFO
*pInfo
;
1459 if (!(pInfo
= LOCAL_GetHeap( ds
)))
1461 fprintf( stderr
, "LOCAL_Handle(%04x): Local heap not found\n", ds
);
1462 LOCAL_PrintHeap( ds
);
1466 /* Find the address in the entry tables */
1468 table
= pInfo
->htable
;
1471 WORD count
= *(WORD
*)(ptr
+ table
);
1472 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+table
+sizeof(WORD
));
1473 for (; count
> 0; count
--, pEntry
++)
1474 if (pEntry
->addr
== addr
) return (HLOCAL16
)((char *)pEntry
- ptr
);
1475 table
= *(WORD
*)pEntry
;
1478 return (HLOCAL16
)addr
; /* Fixed block handle is addr */
1482 /***********************************************************************
1483 * LocalAlloc16 (KERNEL.5)
1485 HLOCAL16 WINAPI
LocalAlloc16( UINT16 flags
, WORD size
)
1487 return LOCAL_Alloc( CURRENT_DS
, flags
, size
);
1491 /***********************************************************************
1492 * LocalReAlloc16 (KERNEL.6)
1494 HLOCAL16 WINAPI
LocalReAlloc16( HLOCAL16 handle
, WORD size
, UINT16 flags
)
1496 return LOCAL_ReAlloc( CURRENT_DS
, handle
, size
, flags
);
1500 /***********************************************************************
1501 * LocalFree16 (KERNEL.7)
1503 HLOCAL16 WINAPI
LocalFree16( HLOCAL16 handle
)
1505 return LOCAL_Free( CURRENT_DS
, handle
);
1509 /***********************************************************************
1510 * LocalLock16 (KERNEL.8)
1512 * Note: only the offset part of the pointer is returned by the relay code.
1514 SEGPTR WINAPI
LocalLock16( HLOCAL16 handle
)
1516 return LOCAL_LockSegptr( CURRENT_DS
, handle
);
1520 /***********************************************************************
1521 * LocalUnlock16 (KERNEL.9)
1523 BOOL16 WINAPI
LocalUnlock16( HLOCAL16 handle
)
1525 return LOCAL_Unlock( CURRENT_DS
, handle
);
1529 /***********************************************************************
1530 * LocalSize16 (KERNEL.10)
1532 UINT16 WINAPI
LocalSize16( HLOCAL16 handle
)
1534 return LOCAL_Size( CURRENT_DS
, handle
);
1538 /***********************************************************************
1539 * LocalHandle16 (KERNEL.11)
1541 HLOCAL16 WINAPI
LocalHandle16( WORD addr
)
1543 return LOCAL_Handle( CURRENT_DS
, addr
);
1547 /***********************************************************************
1548 * LocalFlags16 (KERNEL.12)
1550 UINT16 WINAPI
LocalFlags16( HLOCAL16 handle
)
1552 return LOCAL_Flags( CURRENT_DS
, handle
);
1556 /***********************************************************************
1557 * LocalCompact16 (KERNEL.13)
1559 UINT16 WINAPI
LocalCompact16( UINT16 minfree
)
1561 TRACE(local
, "%04x\n", minfree
);
1562 return LOCAL_Compact( CURRENT_DS
, minfree
, 0 );
1566 /***********************************************************************
1567 * LocalNotify (KERNEL.14)
1569 FARPROC16 WINAPI
LocalNotify( FARPROC16 func
)
1571 LOCALHEAPINFO
*pInfo
;
1572 FARPROC16 oldNotify
;
1573 HANDLE16 ds
= CURRENT_DS
;
1575 if (!(pInfo
= LOCAL_GetHeap( ds
)))
1577 ERR(local
, "(%04x): Local heap not found\n", ds
);
1578 LOCAL_PrintHeap( ds
);
1581 TRACE(local
, "(%04x): %08lx\n", ds
, (DWORD
)func
);
1582 FIXME(local
, "Half implemented\n");
1583 oldNotify
= pInfo
->notify
;
1584 pInfo
->notify
= func
;
1589 /***********************************************************************
1590 * LocalShrink16 (KERNEL.121)
1592 UINT16 WINAPI
LocalShrink16( HGLOBAL16 handle
, UINT16 newsize
)
1594 TRACE(local
, "%04x %04x\n", handle
, newsize
);
1599 /***********************************************************************
1600 * GetHeapSpaces (KERNEL.138)
1602 DWORD WINAPI
GetHeapSpaces( HMODULE16 module
)
1607 if (!(pModule
= MODULE_GetPtr( module
))) return 0;
1608 ds
= (NE_SEG_TABLE( pModule
) + pModule
->dgroup
- 1)->selector
;
1609 return MAKELONG( LOCAL_CountFree( ds
), LOCAL_HeapSize( ds
) );
1613 /***********************************************************************
1614 * LocalCountFree (KERNEL.161)
1616 WORD WINAPI
LocalCountFree(void)
1618 return LOCAL_CountFree( CURRENT_DS
);
1622 /***********************************************************************
1623 * LocalHeapSize (KERNEL.162)
1625 WORD WINAPI
LocalHeapSize(void)
1627 TRACE(local
, "(void)\n" );
1628 return LOCAL_HeapSize( CURRENT_DS
);
1632 /***********************************************************************
1633 * LocalHandleDelta (KERNEL.310)
1635 WORD WINAPI
LocalHandleDelta( WORD delta
)
1637 LOCALHEAPINFO
*pInfo
;
1639 if (!(pInfo
= LOCAL_GetHeap( CURRENT_DS
)))
1641 ERR(local
, "Local heap not found\n");
1642 LOCAL_PrintHeap( CURRENT_DS
);
1645 if (delta
) pInfo
->hdelta
= delta
;
1646 TRACE(local
, "returning %04x\n", pInfo
->hdelta
);
1647 return pInfo
->hdelta
;
1651 /***********************************************************************
1652 * LocalInfo (TOOLHELP.56)
1654 BOOL16 WINAPI
LocalInfo( LOCALINFO
*pLocalInfo
, HGLOBAL16 handle
)
1656 LOCALHEAPINFO
*pInfo
= LOCAL_GetHeap(SELECTOROF(WIN16_GlobalLock16(handle
)));
1657 if (!pInfo
) return FALSE
;
1658 pLocalInfo
->wcItems
= pInfo
->items
;
1663 /***********************************************************************
1664 * LocalFirst (TOOLHELP.57)
1666 BOOL16 WINAPI
LocalFirst( LOCALENTRY
*pLocalEntry
, HGLOBAL16 handle
)
1668 WORD ds
= GlobalHandleToSel( handle
);
1669 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1670 LOCALHEAPINFO
*pInfo
= LOCAL_GetHeap( ds
);
1671 if (!pInfo
) return FALSE
;
1673 pLocalEntry
->hHandle
= pInfo
->first
+ ARENA_HEADER_SIZE
;
1674 pLocalEntry
->wAddress
= pLocalEntry
->hHandle
;
1675 pLocalEntry
->wFlags
= LF_FIXED
;
1676 pLocalEntry
->wcLock
= 0;
1677 pLocalEntry
->wType
= LT_NORMAL
;
1678 pLocalEntry
->hHeap
= handle
;
1679 pLocalEntry
->wHeapType
= NORMAL_HEAP
;
1680 pLocalEntry
->wNext
= ARENA_PTR(ptr
,pInfo
->first
)->next
;
1681 pLocalEntry
->wSize
= pLocalEntry
->wNext
- pLocalEntry
->hHandle
;
1686 /***********************************************************************
1687 * LocalNext (TOOLHELP.58)
1689 BOOL16 WINAPI
LocalNext( LOCALENTRY
*pLocalEntry
)
1691 WORD ds
= GlobalHandleToSel( pLocalEntry
->hHeap
);
1692 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1695 if (!LOCAL_GetHeap( ds
)) return FALSE
;
1696 if (!pLocalEntry
->wNext
) return FALSE
;
1697 pArena
= ARENA_PTR( ptr
, pLocalEntry
->wNext
);
1699 pLocalEntry
->hHandle
= pLocalEntry
->wNext
+ ARENA_HEADER_SIZE
;
1700 pLocalEntry
->wAddress
= pLocalEntry
->hHandle
;
1701 pLocalEntry
->wFlags
= (pArena
->prev
& 3) + 1;
1702 pLocalEntry
->wcLock
= 0;
1703 pLocalEntry
->wType
= LT_NORMAL
;
1704 if (pArena
->next
!= pLocalEntry
->wNext
) /* last one? */
1705 pLocalEntry
->wNext
= pArena
->next
;
1707 pLocalEntry
->wNext
= 0;
1708 pLocalEntry
->wSize
= pLocalEntry
->wNext
- pLocalEntry
->hHandle
;
1713 /***********************************************************************
1714 * LocalAlloc32 (KERNEL32.371)
1719 HLOCAL32 WINAPI
LocalAlloc32(
1720 UINT32 flags
, /* [in] Allocation attributes */
1721 DWORD size
/* [in] Number of bytes to allocate */
1723 return (HLOCAL32
)GlobalAlloc32( flags
, size
);
1727 /***********************************************************************
1728 * LocalCompact32 (KERNEL32.372)
1730 UINT32 WINAPI
LocalCompact32( UINT32 minfree
)
1732 return 0; /* LocalCompact does nothing in Win32 */
1736 /***********************************************************************
1737 * LocalFlags32 (KERNEL32.374)
1739 * Value specifying allocation flags and lock count.
1740 * LMEM_INVALID_HANDLE: Failure
1742 UINT32 WINAPI
LocalFlags32(
1743 HLOCAL32 handle
/* [in] Handle of memory object */
1745 return GlobalFlags32( (HGLOBAL32
)handle
);
1749 /***********************************************************************
1750 * LocalFree32 (KERNEL32.375)
1755 HLOCAL32 WINAPI
LocalFree32(
1756 HLOCAL32 handle
/* [in] Handle of memory object */
1758 return (HLOCAL32
)GlobalFree32( (HGLOBAL32
)handle
);
1762 /***********************************************************************
1763 * LocalHandle32 (KERNEL32.376)
1768 HLOCAL32 WINAPI
LocalHandle32(
1769 LPCVOID ptr
/* [in] Address of local memory object */
1771 return (HLOCAL32
)GlobalHandle32( ptr
);
1775 /***********************************************************************
1776 * LocalLock32 (KERNEL32.377)
1777 * Locks a local memory object and returns pointer to the first byte
1778 * of the memory block.
1784 LPVOID WINAPI
LocalLock32(
1785 HLOCAL32 handle
/* [in] Address of local memory object */
1787 return GlobalLock32( (HGLOBAL32
)handle
);
1791 /***********************************************************************
1792 * LocalReAlloc32 (KERNEL32.378)
1797 HLOCAL32 WINAPI
LocalReAlloc32(
1798 HLOCAL32 handle
, /* [in] Handle of memory object */
1799 DWORD size
, /* [in] New size of block */
1800 UINT32 flags
/* [in] How to reallocate object */
1802 return (HLOCAL32
)GlobalReAlloc32( (HGLOBAL32
)handle
, size
, flags
);
1806 /***********************************************************************
1807 * LocalShrink32 (KERNEL32.379)
1809 UINT32 WINAPI
LocalShrink32( HGLOBAL32 handle
, UINT32 newsize
)
1811 return 0; /* LocalShrink does nothing in Win32 */
1815 /***********************************************************************
1816 * LocalSize32 (KERNEL32.380)
1821 UINT32 WINAPI
LocalSize32(
1822 HLOCAL32 handle
/* [in] Handle of memory object */
1824 return GlobalSize32( (HGLOBAL32
)handle
);
1828 /***********************************************************************
1829 * LocalUnlock32 (KERNEL32.381)
1831 * TRUE: Object is still locked
1832 * FALSE: Object is unlocked
1834 BOOL32 WINAPI
LocalUnlock32(
1835 HLOCAL32 handle
/* [in] Handle of memory object */
1837 return GlobalUnlock32( (HGLOBAL32
)handle
);