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.
19 #include "wine/winbase16.h"
24 #include "stackframe.h"
26 #include "debugtools.h"
29 DEFAULT_DEBUG_CHANNEL(local
);
30 DECLARE_DEBUG_CHANNEL(heap
);
35 WORD prev
; /* Previous arena | arena type */
36 WORD next
; /* Next arena */
37 /* Start of the memory block or free-list info */
38 WORD size
; /* Size of the free block */
39 WORD free_prev
; /* Previous free block */
40 WORD free_next
; /* Next free block */
43 #define ARENA_HEADER_SIZE 4
44 #define ARENA_HEADER( handle) ((handle) - ARENA_HEADER_SIZE)
46 /* Arena types (stored in 'prev' field of the arena) */
47 #define LOCAL_ARENA_FREE 0
48 #define LOCAL_ARENA_FIXED 1
50 /* LocalNotify() msgs */
56 /* Layout of a handle entry table
58 * WORD count of entries
59 * LOCALHANDLEENTRY[count] entries
60 * WORD near ptr to next table
64 WORD addr
; /* Address of the MOVEABLE block */
65 BYTE flags
; /* Flags for this block */
66 BYTE lock
; /* Lock count */
70 * We make addr = 4n + 2 and set *((WORD *)addr - 1) = &addr like Windows does
71 * in case something actually relies on this.
72 * Note that if the architecture does not allow unaligned accesses, we make
73 * addr = 4n + 4 to avoid returning unaligned pointers from LocalAlloc etc.
75 * An unused handle has lock = flags = 0xff. In windows addr is that of next
76 * free handle, at the moment in wine we set it to 0.
78 * A discarded block's handle has lock = addr = 0 and flags = 0x40
79 * (LMEM_DISCARDED >> 8)
82 #ifdef ALLOW_UNALIGNED_ACCESS
83 #define MOVEABLE_PREFIX sizeof(HLOCAL16)
85 #define MOVEABLE_PREFIX sizeof(int)
93 WORD check
; /* 00 Heap checking flag */
94 WORD freeze
; /* 02 Heap frozen flag */
95 WORD items
; /* 04 Count of items on the heap */
96 WORD first
; /* 06 First item of the heap */
97 WORD pad1
; /* 08 Always 0 */
98 WORD last
; /* 0a Last item of the heap */
99 WORD pad2
; /* 0c Always 0 */
100 BYTE ncompact
; /* 0e Compactions counter */
101 BYTE dislevel
; /* 0f Discard level */
102 DWORD distotal
; /* 10 Total bytes discarded */
103 WORD htable
; /* 14 Pointer to handle table */
104 WORD hfree
; /* 16 Pointer to free handle table */
105 WORD hdelta
; /* 18 Delta to expand the handle table */
106 WORD expand
; /* 1a Pointer to expand function (unused) */
107 WORD pstat
; /* 1c Pointer to status structure (unused) */
108 FARPROC16 notify WINE_PACKED
; /* 1e Pointer to LocalNotify() function */
109 WORD lock
; /* 22 Lock count for the heap */
110 WORD extra
; /* 24 Extra bytes to allocate when expanding */
111 WORD minsize
; /* 26 Minimum size of the heap */
112 WORD magic
; /* 28 Magic number */
117 #define LOCAL_HEAP_MAGIC 0x484c /* 'LH' */
119 WORD USER_HeapSel
= 0; /* USER heap selector */
121 /* All local heap allocations are aligned on 4-byte boundaries */
122 #define LALIGN(word) (((word) + 3) & ~3)
124 #define ARENA_PTR(ptr,arena) ((LOCALARENA *)((char*)(ptr)+(arena)))
125 #define ARENA_PREV(ptr,arena) (ARENA_PTR((ptr),(arena))->prev & ~3)
126 #define ARENA_NEXT(ptr,arena) (ARENA_PTR((ptr),(arena))->next)
127 #define ARENA_FLAGS(ptr,arena) (ARENA_PTR((ptr),(arena))->prev & 3)
129 /* determine whether the handle belongs to a fixed or a moveable block */
130 #define HANDLE_FIXED(handle) (((handle) & 3) == 0)
131 #define HANDLE_MOVEABLE(handle) (((handle) & 3) == 2)
134 /* ### start build ### */
135 extern WORD CALLBACK
LOCAL_CallTo16_word_www(FARPROC16
,WORD
,HLOCAL16
,WORD
);
136 /* ### stop build ### */
138 /***********************************************************************
141 * Return a pointer to the local heap, making sure it exists.
143 static LOCALHEAPINFO
*LOCAL_GetHeap( HANDLE16 ds
)
145 LOCALHEAPINFO
*pInfo
;
146 INSTANCEDATA
*ptr
= MapSL( MAKESEGPTR( ds
, 0 ));
147 TRACE("Heap at %p, %04x\n", ptr
, (ptr
!= NULL
? ptr
->heap
: 0xFFFF));
148 if (!ptr
|| !ptr
->heap
) return NULL
;
149 if (IsBadReadPtr16( (SEGPTR
)MAKELONG(ptr
->heap
,ds
), sizeof(LOCALHEAPINFO
)))
151 WARN("Bad pointer\n");
154 pInfo
= (LOCALHEAPINFO
*)((char*)ptr
+ ptr
->heap
);
155 if (pInfo
->magic
!= LOCAL_HEAP_MAGIC
)
164 /***********************************************************************
165 * LOCAL_MakeBlockFree
167 * Make a block free, inserting it in the free-list.
168 * 'block' is the handle of the block arena; 'baseptr' points to
169 * the beginning of the data segment containing the heap.
171 static void LOCAL_MakeBlockFree( char *baseptr
, WORD block
)
173 LOCALARENA
*pArena
, *pNext
;
176 /* Mark the block as free */
178 pArena
= ARENA_PTR( baseptr
, block
);
179 pArena
->prev
= (pArena
->prev
& ~3) | LOCAL_ARENA_FREE
;
180 pArena
->size
= pArena
->next
- block
;
182 /* Find the next free block (last block is always free) */
187 pNext
= ARENA_PTR( baseptr
, next
);
188 if ((pNext
->prev
& 3) == LOCAL_ARENA_FREE
) break;
192 TRACE("%04x, next %04x\n", block
, next
);
193 /* Insert the free block in the free-list */
195 pArena
->free_prev
= pNext
->free_prev
;
196 pArena
->free_next
= next
;
197 ARENA_PTR(baseptr
,pNext
->free_prev
)->free_next
= block
;
198 pNext
->free_prev
= block
;
202 /***********************************************************************
203 * LOCAL_RemoveFreeBlock
205 * Remove a block from the free-list.
206 * 'block' is the handle of the block arena; 'baseptr' points to
207 * the beginning of the data segment containing the heap.
209 static void LOCAL_RemoveFreeBlock( char *baseptr
, WORD block
)
211 /* Mark the block as fixed */
213 LOCALARENA
*pArena
= ARENA_PTR( baseptr
, block
);
214 pArena
->prev
= (pArena
->prev
& ~3) | LOCAL_ARENA_FIXED
;
216 /* Remove it from the list */
218 ARENA_PTR(baseptr
,pArena
->free_prev
)->free_next
= pArena
->free_next
;
219 ARENA_PTR(baseptr
,pArena
->free_next
)->free_prev
= pArena
->free_prev
;
223 /***********************************************************************
226 * Insert a new block in the heap.
227 * 'new' is the handle of the new block arena; 'baseptr' points to
228 * the beginning of the data segment containing the heap; 'prev' is
229 * the block before the new one.
231 static void LOCAL_AddBlock( char *baseptr
, WORD prev
, WORD
new )
233 LOCALARENA
*pPrev
= ARENA_PTR( baseptr
, prev
);
234 LOCALARENA
*pNew
= ARENA_PTR( baseptr
, new );
236 pNew
->prev
= (prev
& ~3) | LOCAL_ARENA_FIXED
;
237 pNew
->next
= pPrev
->next
;
238 ARENA_PTR(baseptr
,pPrev
->next
)->prev
&= 3;
239 ARENA_PTR(baseptr
,pPrev
->next
)->prev
|= new;
244 /***********************************************************************
247 * Remove a block from the heap.
248 * 'block' is the handle of the block arena; 'baseptr' points to
249 * the beginning of the data segment containing the heap.
251 static void LOCAL_RemoveBlock( char *baseptr
, WORD block
)
253 LOCALARENA
*pArena
, *pTmp
;
255 /* Remove the block from the free-list */
258 pArena
= ARENA_PTR( baseptr
, block
);
259 if ((pArena
->prev
& 3) == LOCAL_ARENA_FREE
)
260 LOCAL_RemoveFreeBlock( baseptr
, block
);
262 /* If the previous block is free, expand its size */
264 pTmp
= ARENA_PTR( baseptr
, pArena
->prev
& ~3 );
265 if ((pTmp
->prev
& 3) == LOCAL_ARENA_FREE
)
266 pTmp
->size
+= pArena
->next
- block
;
268 /* Remove the block from the linked list */
270 pTmp
->next
= pArena
->next
;
271 pTmp
= ARENA_PTR( baseptr
, pArena
->next
);
272 pTmp
->prev
= (pTmp
->prev
& 3) | (pArena
->prev
& ~3);
276 /***********************************************************************
279 static void LOCAL_PrintHeap( HANDLE16 ds
)
282 LOCALHEAPINFO
*pInfo
;
285 /* FIXME - the test should be done when calling the function!
286 plus is not clear that we should print this info
287 only when TRACE_ON is on! */
288 if(!TRACE_ON(local
)) return;
290 ptr
= MapSL( MAKESEGPTR( ds
, 0 ));
291 pInfo
= LOCAL_GetHeap( ds
);
295 DPRINTF( "Local Heap corrupted! ds=%04x\n", ds
);
298 DPRINTF( "Local Heap ds=%04x first=%04x last=%04x items=%d\n",
299 ds
, pInfo
->first
, pInfo
->last
, pInfo
->items
);
301 arena
= pInfo
->first
;
304 LOCALARENA
*pArena
= ARENA_PTR(ptr
,arena
);
305 DPRINTF( " %04x: prev=%04x next=%04x type=%d\n", arena
,
306 pArena
->prev
& ~3, pArena
->next
, pArena
->prev
& 3 );
307 if (arena
== pInfo
->first
)
309 DPRINTF( " size=%d free_prev=%04x free_next=%04x\n",
310 pArena
->size
, pArena
->free_prev
, pArena
->free_next
);
312 if ((pArena
->prev
& 3) == LOCAL_ARENA_FREE
)
314 DPRINTF( " size=%d free_prev=%04x free_next=%04x\n",
315 pArena
->size
, pArena
->free_prev
, pArena
->free_next
);
316 if (pArena
->next
== arena
) break; /* last one */
317 if (ARENA_PTR(ptr
,pArena
->free_next
)->free_prev
!= arena
)
319 DPRINTF( "*** arena->free_next->free_prev != arena\n" );
323 if (pArena
->next
== arena
)
325 DPRINTF( "*** last block is not marked free\n" );
328 if ((ARENA_PTR(ptr
,pArena
->next
)->prev
& ~3) != arena
)
330 DPRINTF( "*** arena->next->prev != arena (%04x, %04x)\n",
331 pArena
->next
, ARENA_PTR(ptr
,pArena
->next
)->prev
);
334 arena
= pArena
->next
;
339 /***********************************************************************
340 * LocalInit (KERNEL.4)
342 BOOL16 WINAPI
LocalInit16( HANDLE16 selector
, WORD start
, WORD end
)
345 WORD heapInfoArena
, freeArena
, lastArena
;
346 LOCALHEAPINFO
*pHeapInfo
;
347 LOCALARENA
*pArena
, *pFirstArena
, *pLastArena
;
351 /* The initial layout of the heap is: */
352 /* - first arena (FIXED) */
353 /* - heap info structure (FIXED) */
354 /* - large free block (FREE) */
355 /* - last arena (FREE) */
357 TRACE("%04x %04x-%04x\n", selector
, start
, end
);
358 if (!selector
) selector
= CURRENT_DS
;
362 /* If TRACE_ON(heap) is set, the global heap blocks are */
363 /* cleared before use, so we can test for double initialization. */
364 if (LOCAL_GetHeap(selector
))
366 ERR("Heap %04x initialized twice.\n", selector
);
367 LOCAL_PrintHeap(selector
);
373 /* start == 0 means: put the local heap at the end of the segment */
375 DWORD size
= GlobalSize16( GlobalHandle16( selector
) );
376 start
= (WORD
)(size
> 0xffff ? 0xffff : size
) - 1;
377 if ( end
> 0xfffe ) end
= 0xfffe;
383 if ((pModule
= NE_GetPtr( GlobalHandle16( selector
) )))
385 SEGTABLEENTRY
*pSeg
= NE_SEG_TABLE( pModule
);
388 for ( segNr
= 0; segNr
< pModule
->seg_count
; segNr
++, pSeg
++ )
389 if ( GlobalHandleToSel16(pSeg
->hSeg
) == selector
)
392 if ( segNr
< pModule
->seg_count
)
394 WORD minsize
= pSeg
->minsize
;
395 if ( pModule
->ss
== segNr
+1 )
396 minsize
+= pModule
->stack_size
;
398 TRACE(" new start %04x, minstart: %04x\n", start
, minsize
);
402 ptr
= MapSL( MAKESEGPTR( selector
, 0 ) );
404 start
= LALIGN( max( start
, sizeof(INSTANCEDATA
) ) );
405 heapInfoArena
= LALIGN(start
+ sizeof(LOCALARENA
) );
406 freeArena
= LALIGN( heapInfoArena
+ ARENA_HEADER_SIZE
407 + sizeof(LOCALHEAPINFO
) );
408 lastArena
= (end
- sizeof(LOCALARENA
)) & ~3;
410 /* Make sure there's enough space. */
412 if (freeArena
+ sizeof(LOCALARENA
) >= lastArena
) goto done
;
414 /* Initialise the first arena */
416 pFirstArena
= ARENA_PTR( ptr
, start
);
417 pFirstArena
->prev
= start
| LOCAL_ARENA_FIXED
;
418 pFirstArena
->next
= heapInfoArena
;
419 pFirstArena
->size
= LALIGN(sizeof(LOCALARENA
));
420 pFirstArena
->free_prev
= start
; /* this one */
421 pFirstArena
->free_next
= freeArena
;
423 /* Initialise the arena of the heap info structure */
425 pArena
= ARENA_PTR( ptr
, heapInfoArena
);
426 pArena
->prev
= start
| LOCAL_ARENA_FIXED
;
427 pArena
->next
= freeArena
;
429 /* Initialise the heap info structure */
431 pHeapInfo
= (LOCALHEAPINFO
*) (ptr
+ heapInfoArena
+ ARENA_HEADER_SIZE
);
432 memset( pHeapInfo
, 0, sizeof(LOCALHEAPINFO
) );
433 pHeapInfo
->items
= 4;
434 pHeapInfo
->first
= start
;
435 pHeapInfo
->last
= lastArena
;
436 pHeapInfo
->htable
= 0;
437 pHeapInfo
->hdelta
= 0x20;
438 pHeapInfo
->extra
= 0x200;
439 pHeapInfo
->minsize
= lastArena
- freeArena
;
440 pHeapInfo
->magic
= LOCAL_HEAP_MAGIC
;
442 /* Initialise the large free block */
444 pArena
= ARENA_PTR( ptr
, freeArena
);
445 pArena
->prev
= heapInfoArena
| LOCAL_ARENA_FREE
;
446 pArena
->next
= lastArena
;
447 pArena
->size
= lastArena
- freeArena
;
448 pArena
->free_prev
= start
;
449 pArena
->free_next
= lastArena
;
451 /* Initialise the last block */
453 pLastArena
= ARENA_PTR( ptr
, lastArena
);
454 pLastArena
->prev
= freeArena
| LOCAL_ARENA_FREE
;
455 pLastArena
->next
= lastArena
; /* this one */
456 pLastArena
->size
= LALIGN(sizeof(LOCALARENA
));
457 pLastArena
->free_prev
= freeArena
;
458 pLastArena
->free_next
= lastArena
; /* this one */
460 /* Store the local heap address in the instance data */
462 ((INSTANCEDATA
*)ptr
)->heap
= heapInfoArena
+ ARENA_HEADER_SIZE
;
463 LOCAL_PrintHeap( selector
);
467 CURRENT_STACK16
->ecx
= ret
; /* must be returned in cx too */
471 /***********************************************************************
474 static BOOL16
LOCAL_GrowHeap( HANDLE16 ds
)
479 LOCALHEAPINFO
*pHeapInfo
;
480 WORD freeArena
, lastArena
;
481 LOCALARENA
*pArena
, *pLastArena
;
484 hseg
= GlobalHandle16( ds
);
485 /* maybe mem allocated by Virtual*() ? */
486 if (!hseg
) return FALSE
;
488 oldsize
= GlobalSize16( hseg
);
489 /* if nothing can be gained, return */
490 if (oldsize
> 0xfff0) return FALSE
;
491 hseg
= GlobalReAlloc16( hseg
, 0x10000, GMEM_FIXED
);
492 ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
493 pHeapInfo
= LOCAL_GetHeap( ds
);
494 if (pHeapInfo
== NULL
) {
495 ERR("Heap not found\n" );
498 end
= GlobalSize16( hseg
);
499 lastArena
= (end
- sizeof(LOCALARENA
)) & ~3;
501 /* Update the HeapInfo */
503 freeArena
= pHeapInfo
->last
;
504 pHeapInfo
->last
= lastArena
;
505 pHeapInfo
->minsize
+= end
- oldsize
;
507 /* grow the old last block */
508 pArena
= ARENA_PTR( ptr
, freeArena
);
509 pArena
->size
= lastArena
- freeArena
;
510 pArena
->next
= lastArena
;
511 pArena
->free_next
= lastArena
;
513 /* Initialise the new last block */
515 pLastArena
= ARENA_PTR( ptr
, lastArena
);
516 pLastArena
->prev
= freeArena
| LOCAL_ARENA_FREE
;
517 pLastArena
->next
= lastArena
; /* this one */
518 pLastArena
->size
= LALIGN(sizeof(LOCALARENA
));
519 pLastArena
->free_prev
= freeArena
;
520 pLastArena
->free_next
= lastArena
; /* this one */
522 /* If block before freeArena is also free then merge them */
523 if((ARENA_PTR(ptr
, (pArena
->prev
& ~3))->prev
& 3) == LOCAL_ARENA_FREE
)
525 LOCAL_RemoveBlock(ptr
, freeArena
);
529 TRACE("Heap expanded\n" );
530 LOCAL_PrintHeap( ds
);
535 /***********************************************************************
538 static HLOCAL16
LOCAL_FreeArena( WORD ds
, WORD arena
)
540 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
541 LOCALHEAPINFO
*pInfo
;
542 LOCALARENA
*pArena
, *pPrev
, *pNext
;
544 TRACE("%04x ds=%04x\n", arena
, ds
);
545 if (!(pInfo
= LOCAL_GetHeap( ds
))) return arena
;
547 pArena
= ARENA_PTR( ptr
, arena
);
548 if ((pArena
->prev
& 3) == LOCAL_ARENA_FREE
)
550 /* shouldn't happen */
551 ERR("Trying to free block %04x twice!\n",
553 LOCAL_PrintHeap( ds
);
557 /* Check if we can merge with the previous block */
559 pPrev
= ARENA_PTR( ptr
, pArena
->prev
& ~3 );
560 pNext
= ARENA_PTR( ptr
, pArena
->next
);
561 if ((pPrev
->prev
& 3) == LOCAL_ARENA_FREE
)
563 arena
= pArena
->prev
& ~3;
565 LOCAL_RemoveBlock( ptr
, pPrev
->next
);
568 else /* Make a new free block */
570 LOCAL_MakeBlockFree( ptr
, arena
);
573 /* Check if we can merge with the next block */
575 if ((pArena
->next
== pArena
->free_next
) &&
576 (pArena
->next
!= pInfo
->last
))
578 LOCAL_RemoveBlock( ptr
, pArena
->next
);
585 /***********************************************************************
588 * Shrink an arena by creating a free block at its end if possible.
589 * 'size' includes the arena header, and must be aligned.
591 static void LOCAL_ShrinkArena( WORD ds
, WORD arena
, WORD size
)
593 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
594 LOCALARENA
*pArena
= ARENA_PTR( ptr
, arena
);
596 if (arena
+ size
+ LALIGN(sizeof(LOCALARENA
)) < pArena
->next
)
598 LOCALHEAPINFO
*pInfo
= LOCAL_GetHeap( ds
);
600 LOCAL_AddBlock( ptr
, arena
, arena
+ size
);
602 LOCAL_FreeArena( ds
, arena
+ size
);
607 /***********************************************************************
608 * LOCAL_GrowArenaDownward
610 * Grow an arena downward by using the previous arena (must be free).
612 static void LOCAL_GrowArenaDownward( WORD ds
, WORD arena
, WORD newsize
)
614 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
615 LOCALHEAPINFO
*pInfo
;
616 LOCALARENA
*pArena
= ARENA_PTR( ptr
, arena
);
617 WORD prevArena
= pArena
->prev
& ~3;
618 LOCALARENA
*pPrevArena
= ARENA_PTR( ptr
, prevArena
);
622 if (!(pInfo
= LOCAL_GetHeap( ds
))) return;
623 offset
= pPrevArena
->size
;
624 size
= pArena
->next
- arena
- ARENA_HEADER_SIZE
;
625 LOCAL_RemoveFreeBlock( ptr
, prevArena
);
626 LOCAL_RemoveBlock( ptr
, arena
);
628 p
= (char *)pPrevArena
+ ARENA_HEADER_SIZE
;
629 while (offset
< size
)
631 memcpy( p
, p
+ offset
, offset
);
635 if (size
) memcpy( p
, p
+ offset
, size
);
636 LOCAL_ShrinkArena( ds
, prevArena
, newsize
);
641 /***********************************************************************
642 * LOCAL_GrowArenaUpward
644 * Grow an arena upward by using the next arena (must be free and big
645 * enough). Newsize includes the arena header and must be aligned.
647 static void LOCAL_GrowArenaUpward( WORD ds
, WORD arena
, WORD newsize
)
649 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
650 LOCALHEAPINFO
*pInfo
;
651 LOCALARENA
*pArena
= ARENA_PTR( ptr
, arena
);
652 WORD nextArena
= pArena
->next
;
654 if (!(pInfo
= LOCAL_GetHeap( ds
))) return;
655 LOCAL_RemoveBlock( ptr
, nextArena
);
657 LOCAL_ShrinkArena( ds
, arena
, newsize
);
661 /***********************************************************************
664 static WORD
LOCAL_GetFreeSpace(WORD ds
, WORD countdiscard
)
666 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
667 LOCALHEAPINFO
*pInfo
;
672 if (!(pInfo
= LOCAL_GetHeap( ds
)))
674 ERR("Local heap not found\n" );
678 arena
= pInfo
->first
;
679 pArena
= ARENA_PTR( ptr
, arena
);
680 while (arena
!= pArena
->free_next
)
682 arena
= pArena
->free_next
;
683 pArena
= ARENA_PTR( ptr
, arena
);
684 if (pArena
->size
>= freespace
) freespace
= pArena
->size
;
686 /* FIXME doesn't yet calculate space that would become free if everything
687 were discarded when countdiscard == 1 */
688 if (freespace
< ARENA_HEADER_SIZE
) freespace
= 0;
689 else freespace
-= ARENA_HEADER_SIZE
;
694 /***********************************************************************
697 WORD
LOCAL_Compact( HANDLE16 ds
, UINT16 minfree
, UINT16 flags
)
699 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
700 LOCALHEAPINFO
*pInfo
;
701 LOCALARENA
*pArena
, *pMoveArena
, *pFinalArena
;
702 WORD arena
, movearena
, finalarena
, table
;
703 WORD count
, movesize
, size
;
705 LOCALHANDLEENTRY
*pEntry
;
707 if (!(pInfo
= LOCAL_GetHeap( ds
)))
709 ERR("Local heap not found\n" );
713 TRACE("ds = %04x, minfree = %04x, flags = %04x\n",
715 freespace
= LOCAL_GetFreeSpace(ds
, minfree
? 0 : 1);
716 if(freespace
>= minfree
|| (flags
& LMEM_NOCOMPACT
))
718 TRACE("Returning %04x.\n", freespace
);
721 TRACE("Compacting heap %04x.\n", ds
);
722 table
= pInfo
->htable
;
725 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ table
+ sizeof(WORD
));
726 for(count
= *(WORD
*)(ptr
+ table
); count
> 0; count
--, pEntry
++)
728 if((pEntry
->lock
== 0) && (pEntry
->flags
!= (LMEM_DISCARDED
>> 8)))
730 /* OK we can move this one if we want */
731 TRACE("handle %04x (block %04x) can be moved.\n",
732 (WORD
)((char *)pEntry
- ptr
), pEntry
->addr
);
733 movearena
= ARENA_HEADER(pEntry
->addr
- MOVEABLE_PREFIX
);
734 pMoveArena
= ARENA_PTR(ptr
, movearena
);
735 movesize
= pMoveArena
->next
- movearena
;
736 arena
= pInfo
->first
;
737 pArena
= ARENA_PTR(ptr
, arena
);
740 /* Try to find the smallest arena that will do, */
741 /* which is below us in memory */
744 arena
= pArena
->free_next
;
745 pArena
= ARENA_PTR(ptr
, arena
);
746 if(arena
>= movearena
)
748 if(arena
== pArena
->free_next
)
750 if((pArena
->size
>= movesize
) && (pArena
->size
< size
))
756 if (finalarena
) /* Actually got somewhere to move */
758 TRACE("Moving it to %04x.\n", finalarena
);
759 pFinalArena
= ARENA_PTR(ptr
, finalarena
);
760 size
= pFinalArena
->size
;
761 LOCAL_RemoveFreeBlock(ptr
, finalarena
);
762 LOCAL_ShrinkArena( ds
, finalarena
, movesize
);
763 /* Copy the arena to it's new location */
764 memcpy((char *)pFinalArena
+ ARENA_HEADER_SIZE
,
765 (char *)pMoveArena
+ ARENA_HEADER_SIZE
,
766 movesize
- ARENA_HEADER_SIZE
);
767 /* Free the old location */
768 LOCAL_FreeArena(ds
, movearena
);
770 LOCAL_CallTo16_word_www(pInfo
->notify
, LN_MOVE
,
771 (WORD
)((char *)pEntry
- ptr
), pEntry
->addr
);
772 /* Update handle table entry */
773 pEntry
->addr
= finalarena
+ ARENA_HEADER_SIZE
+ MOVEABLE_PREFIX
;
775 else if((ARENA_PTR(ptr
, pMoveArena
->prev
& ~3)->prev
& 3)
778 /* Previous arena is free (but < movesize) */
779 /* so we can 'slide' movearena down into it */
780 finalarena
= pMoveArena
->prev
& ~3;
781 LOCAL_GrowArenaDownward( ds
, movearena
, movesize
);
782 /* Update handle table entry */
783 pEntry
->addr
= finalarena
+ ARENA_HEADER_SIZE
+ MOVEABLE_PREFIX
;
787 table
= *(WORD
*)pEntry
;
789 freespace
= LOCAL_GetFreeSpace(ds
, minfree
? 0 : 1);
790 if(freespace
>= minfree
|| (flags
& LMEM_NODISCARD
))
792 TRACE("Returning %04x.\n", freespace
);
796 table
= pInfo
->htable
;
799 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ table
+ sizeof(WORD
));
800 for(count
= *(WORD
*)(ptr
+ table
); count
> 0; count
--, pEntry
++)
802 if(pEntry
->addr
&& pEntry
->lock
== 0 &&
803 (pEntry
->flags
& (LMEM_DISCARDABLE
>> 8)))
805 TRACE("Discarding handle %04x (block %04x).\n",
806 (char *)pEntry
- ptr
, pEntry
->addr
);
807 LOCAL_FreeArena(ds
, ARENA_HEADER(pEntry
->addr
- MOVEABLE_PREFIX
));
809 LOCAL_CallTo16_word_www(pInfo
->notify
, LN_DISCARD
,
810 (char *)pEntry
- ptr
, pEntry
->flags
);
812 pEntry
->flags
= (LMEM_DISCARDED
>> 8);
815 table
= *(WORD
*)pEntry
;
817 return LOCAL_Compact(ds
, 0xffff, LMEM_NODISCARD
);
821 /***********************************************************************
822 * LOCAL_FindFreeBlock
824 static HLOCAL16
LOCAL_FindFreeBlock( HANDLE16 ds
, WORD size
)
826 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
827 LOCALHEAPINFO
*pInfo
;
831 if (!(pInfo
= LOCAL_GetHeap( ds
)))
833 ERR("Local heap not found\n" );
838 arena
= pInfo
->first
;
839 pArena
= ARENA_PTR( ptr
, arena
);
841 arena
= pArena
->free_next
;
842 pArena
= ARENA_PTR( ptr
, arena
);
843 if (arena
== pArena
->free_next
) break;
844 if (pArena
->size
>= size
) return arena
;
846 TRACE("not enough space\n" );
852 /***********************************************************************
855 static const char *get_heap_name( WORD ds
)
857 HINSTANCE16 inst
= LoadLibrary16( "GDI" );
858 if (ds
== GlobalHandleToSel16( inst
))
860 FreeLibrary16( inst
);
863 FreeLibrary16( inst
);
864 inst
= LoadLibrary16( "USER" );
865 if (ds
== GlobalHandleToSel16( inst
))
867 FreeLibrary16( inst
);
870 FreeLibrary16( inst
);
874 /***********************************************************************
876 * The segment may get moved around in this function, so all callers
877 * should reset their pointer variables.
879 static HLOCAL16
LOCAL_GetBlock( HANDLE16 ds
, WORD size
, WORD flags
)
881 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
882 LOCALHEAPINFO
*pInfo
;
886 if (!(pInfo
= LOCAL_GetHeap( ds
)))
888 ERR("Local heap not found\n");
893 size
+= ARENA_HEADER_SIZE
;
894 size
= LALIGN( max( size
, sizeof(LOCALARENA
) ) );
899 /* Find a suitable free block */
900 arena
= LOCAL_FindFreeBlock( ds
, size
);
902 /* no space: try to make some */
903 LOCAL_Compact( ds
, size
, flags
);
904 arena
= LOCAL_FindFreeBlock( ds
, size
);
907 /* still no space: try to grow the segment */
908 if (!(LOCAL_GrowHeap( ds
)))
911 /* FIXME: doesn't work correctly yet */
912 if ((pInfo
->notify
) && (LOCAL_CallTo16_word_www(pInfo
->notify
, LN_OUTOFMEM
, ds
- 20, size
))) /* FIXME: "size" correct ? (should indicate bytes needed) */
917 ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
918 pInfo
= LOCAL_GetHeap( ds
);
919 arena
= LOCAL_FindFreeBlock( ds
, size
);
922 ERR( "not enough space in %s heap %04x for %d bytes\n",
923 get_heap_name(ds
), ds
, size
);
925 if ((pInfo
->notify
) &&
926 /* FIXME: "size" correct ? (should indicate bytes needed) */
927 (LOCAL_CallTo16_word_www(pInfo
->notify
, LN_OUTOFMEM
, ds
, size
)))
933 /* Make a block out of the free arena */
934 pArena
= ARENA_PTR( ptr
, arena
);
935 TRACE("size = %04x, arena %04x size %04x\n",
936 size
, arena
, pArena
->size
);
937 LOCAL_RemoveFreeBlock( ptr
, arena
);
938 LOCAL_ShrinkArena( ds
, arena
, size
);
940 if (flags
& LMEM_ZEROINIT
)
941 memset((char *)pArena
+ ARENA_HEADER_SIZE
, 0, size
-ARENA_HEADER_SIZE
);
942 return arena
+ ARENA_HEADER_SIZE
;
946 /***********************************************************************
949 static BOOL16
LOCAL_NewHTable( HANDLE16 ds
)
951 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
952 LOCALHEAPINFO
*pInfo
;
953 LOCALHANDLEENTRY
*pEntry
;
958 if (!(pInfo
= LOCAL_GetHeap( ds
)))
960 ERR("Local heap not found\n");
965 if (!(handle
= LOCAL_GetBlock( ds
, pInfo
->hdelta
* sizeof(LOCALHANDLEENTRY
)
966 + 2 * sizeof(WORD
), LMEM_FIXED
)))
968 if (!(ptr
= MapSL( MAKESEGPTR( ds
, 0 ) )))
969 ERR("ptr == NULL after GetBlock.\n");
970 if (!(pInfo
= LOCAL_GetHeap( ds
)))
971 ERR("pInfo == NULL after GetBlock.\n");
973 /* Fill the entry table */
975 *(WORD
*)(ptr
+ handle
) = pInfo
->hdelta
;
976 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
+ sizeof(WORD
));
977 for (i
= pInfo
->hdelta
; i
> 0; i
--, pEntry
++) {
978 pEntry
->lock
= pEntry
->flags
= 0xff;
981 *(WORD
*)pEntry
= pInfo
->htable
;
982 pInfo
->htable
= handle
;
987 /***********************************************************************
988 * LOCAL_GetNewHandleEntry
990 static HLOCAL16
LOCAL_GetNewHandleEntry( HANDLE16 ds
)
992 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
993 LOCALHEAPINFO
*pInfo
;
994 LOCALHANDLEENTRY
*pEntry
= NULL
;
997 if (!(pInfo
= LOCAL_GetHeap( ds
)))
999 ERR("Local heap not found\n");
1000 LOCAL_PrintHeap(ds
);
1004 /* Find a free slot in existing tables */
1006 table
= pInfo
->htable
;
1009 WORD count
= *(WORD
*)(ptr
+ table
);
1010 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ table
+ sizeof(WORD
));
1011 for (; count
> 0; count
--, pEntry
++)
1012 if (pEntry
->lock
== 0xff) break;
1014 table
= *(WORD
*)pEntry
;
1017 if (!table
) /* We need to create a new table */
1019 if (!LOCAL_NewHTable( ds
)) return 0;
1020 ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1021 pInfo
= LOCAL_GetHeap( ds
);
1022 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ pInfo
->htable
+ sizeof(WORD
));
1025 /* Now allocate this entry */
1029 TRACE("(%04x): %04x\n",
1030 ds
, ((char *)pEntry
- ptr
) );
1031 return (HLOCAL16
)((char *)pEntry
- ptr
);
1035 /***********************************************************************
1036 * LOCAL_FreeHandleEntry
1038 * Free a handle table entry.
1040 static void LOCAL_FreeHandleEntry( HANDLE16 ds
, HLOCAL16 handle
)
1042 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1043 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1044 LOCALHEAPINFO
*pInfo
;
1046 WORD table
, count
, i
;
1048 if (!(pInfo
= LOCAL_GetHeap( ds
))) return;
1050 /* Find the table where this handle comes from */
1052 pTable
= &pInfo
->htable
;
1055 WORD size
= (*(WORD
*)(ptr
+ *pTable
)) * sizeof(LOCALHANDLEENTRY
);
1056 if ((handle
>= *pTable
+ sizeof(WORD
)) &&
1057 (handle
< *pTable
+ sizeof(WORD
) + size
)) break; /* Found it */
1058 pTable
= (WORD
*)(ptr
+ *pTable
+ sizeof(WORD
) + size
);
1062 ERR("Invalid entry %04x\n", handle
);
1063 LOCAL_PrintHeap( ds
);
1067 /* Make the entry free */
1069 pEntry
->addr
= 0; /* just in case */
1070 pEntry
->lock
= 0xff;
1071 pEntry
->flags
= 0xff;
1072 /* Now check if all entries in this table are free */
1075 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ table
+ sizeof(WORD
));
1076 count
= *(WORD
*)(ptr
+ table
);
1077 for (i
= count
; i
> 0; i
--, pEntry
++) if (pEntry
->lock
!= 0xff) return;
1079 /* Remove the table from the linked list and free it */
1081 TRACE("(%04x): freeing table %04x\n",
1083 *pTable
= *(WORD
*)pEntry
;
1084 LOCAL_FreeArena( ds
, ARENA_HEADER( table
) );
1088 /***********************************************************************
1091 * Implementation of LocalFree().
1093 HLOCAL16
LOCAL_Free( HANDLE16 ds
, HLOCAL16 handle
)
1095 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1097 TRACE("%04x ds=%04x\n", handle
, ds
);
1099 if (!handle
) { WARN("Handle is 0.\n" ); return 0; }
1100 if (HANDLE_FIXED( handle
))
1102 if (!LOCAL_FreeArena( ds
, ARENA_HEADER( handle
) )) return 0; /* OK */
1103 else return handle
; /* couldn't free it */
1107 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1108 if (pEntry
->flags
!= (LMEM_DISCARDED
>> 8))
1110 TRACE("real block at %04x\n",
1112 if (LOCAL_FreeArena( ds
, ARENA_HEADER(pEntry
->addr
- MOVEABLE_PREFIX
) ))
1113 return handle
; /* couldn't free it */
1115 LOCAL_FreeHandleEntry( ds
, handle
);
1121 /***********************************************************************
1124 * Implementation of LocalAlloc().
1127 HLOCAL16
LOCAL_Alloc( HANDLE16 ds
, WORD flags
, WORD size
)
1132 TRACE("%04x %d ds=%04x\n", flags
, size
, ds
);
1134 if(size
> 0 && size
<= 4) size
= 5;
1135 if (flags
& LMEM_MOVEABLE
)
1137 LOCALHANDLEENTRY
*plhe
;
1142 if (!(hmem
= LOCAL_GetBlock( ds
, size
+ MOVEABLE_PREFIX
, flags
)))
1145 else /* We just need to allocate a discarded handle */
1147 if (!(handle
= LOCAL_GetNewHandleEntry( ds
)))
1149 WARN("Couldn't get handle.\n");
1151 LOCAL_FreeArena( ds
, ARENA_HEADER(hmem
) );
1154 ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1155 plhe
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1159 plhe
->addr
= hmem
+ MOVEABLE_PREFIX
;
1160 plhe
->flags
= (BYTE
)((flags
& 0x0f00) >> 8);
1161 *(HLOCAL16
*)(ptr
+ hmem
) = handle
;
1166 plhe
->flags
= LMEM_DISCARDED
>> 8;
1173 handle
= LOCAL_GetBlock( ds
, size
, flags
);
1179 /***********************************************************************
1182 * Implementation of LocalReAlloc().
1184 HLOCAL16
LOCAL_ReAlloc( HANDLE16 ds
, HLOCAL16 handle
, WORD size
, WORD flags
)
1186 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1187 LOCALHEAPINFO
*pInfo
;
1188 LOCALARENA
*pArena
, *pNext
;
1189 LOCALHANDLEENTRY
*pEntry
= NULL
;
1190 WORD arena
, oldsize
;
1191 HLOCAL16 hmem
, blockhandle
;
1194 if (!handle
) return 0;
1195 if(HANDLE_MOVEABLE(handle
) &&
1196 ((LOCALHANDLEENTRY
*)(ptr
+ handle
))->lock
== 0xff) /* An unused handle */
1199 TRACE("%04x %d %04x ds=%04x\n",
1200 handle
, size
, flags
, ds
);
1201 if (!(pInfo
= LOCAL_GetHeap( ds
))) return 0;
1203 if (HANDLE_FIXED( handle
))
1204 blockhandle
= handle
;
1207 pEntry
= (LOCALHANDLEENTRY
*) (ptr
+ handle
);
1208 if(pEntry
->flags
== (LMEM_DISCARDED
>> 8))
1212 WARN("Dicarded block has non-zero addr.\n");
1213 TRACE("ReAllocating discarded block\n");
1214 if(size
<= 4) size
= 5;
1215 if (!(hl
= LOCAL_GetBlock( ds
, size
+ MOVEABLE_PREFIX
, flags
)))
1217 ptr
= MapSL( MAKESEGPTR( ds
, 0 ) ); /* Reload ptr */
1218 pEntry
= (LOCALHANDLEENTRY
*) (ptr
+ handle
);
1219 pEntry
->addr
= hl
+ MOVEABLE_PREFIX
;
1222 *(HLOCAL16
*)(ptr
+ hl
) = handle
;
1225 if (((blockhandle
= pEntry
->addr
- MOVEABLE_PREFIX
) & 3) != 0)
1227 ERR("(%04x,%04x): invalid handle\n",
1231 if (*(HLOCAL16
*)(ptr
+ blockhandle
) != handle
) {
1232 ERR("Back ptr to handle is invalid\n");
1237 if (flags
& LMEM_MODIFY
)
1239 if (HANDLE_MOVEABLE(handle
))
1241 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1242 pEntry
->flags
= (flags
& 0x0f00) >> 8;
1243 TRACE("Changing flags to %x.\n", pEntry
->flags
);
1250 if (flags
& LMEM_MOVEABLE
)
1252 if (HANDLE_FIXED(handle
))
1254 TRACE("Freeing fixed block.\n");
1255 return LOCAL_Free( ds
, handle
);
1257 else /* Moveable block */
1259 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1260 if (pEntry
->lock
== 0)
1262 /* discards moveable blocks */
1263 TRACE("Discarding block\n");
1264 LOCAL_FreeArena(ds
, ARENA_HEADER(pEntry
->addr
- MOVEABLE_PREFIX
));
1266 pEntry
->flags
= (LMEM_DISCARDED
>> 8);
1274 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1275 if (pEntry
->lock
== 0)
1278 return LOCAL_Free( ds
, handle
);
1284 arena
= ARENA_HEADER( blockhandle
);
1285 TRACE("arena is %04x\n", arena
);
1286 pArena
= ARENA_PTR( ptr
, arena
);
1288 if(size
<= 4) size
= 5;
1289 if(HANDLE_MOVEABLE(handle
)) size
+= MOVEABLE_PREFIX
;
1290 oldsize
= pArena
->next
- arena
- ARENA_HEADER_SIZE
;
1291 nextarena
= LALIGN(blockhandle
+ size
);
1293 /* Check for size reduction */
1295 if (nextarena
<= pArena
->next
)
1297 TRACE("size reduction, making new free block\n");
1298 LOCAL_ShrinkArena(ds
, arena
, nextarena
- arena
);
1299 TRACE("returning %04x\n", handle
);
1303 /* Check if the next block is free and large enough */
1305 pNext
= ARENA_PTR( ptr
, pArena
->next
);
1306 if (((pNext
->prev
& 3) == LOCAL_ARENA_FREE
) &&
1307 (nextarena
<= pNext
->next
))
1309 TRACE("size increase, making new free block\n");
1310 LOCAL_GrowArenaUpward(ds
, arena
, nextarena
- arena
);
1311 TRACE("returning %04x\n", handle
);
1315 /* Now we have to allocate a new block, but not if (fixed block or locked
1316 block) and no LMEM_MOVEABLE */
1318 if (!(flags
& LMEM_MOVEABLE
))
1320 if (HANDLE_FIXED(handle
))
1322 ERR("Needed to move fixed block, but LMEM_MOVEABLE not specified.\n");
1327 if(((LOCALHANDLEENTRY
*)(ptr
+ handle
))->lock
!= 0)
1329 ERR("Needed to move locked block, but LMEM_MOVEABLE not specified.\n");
1335 hmem
= LOCAL_GetBlock( ds
, size
, flags
);
1336 ptr
= MapSL( MAKESEGPTR( ds
, 0 )); /* Reload ptr */
1337 if(HANDLE_MOVEABLE(handle
)) /* LOCAL_GetBlock might have triggered */
1338 { /* a compaction, which might in turn have */
1339 blockhandle
= pEntry
->addr
- MOVEABLE_PREFIX
; /* moved the very block we are resizing */
1340 arena
= ARENA_HEADER( blockhandle
); /* thus, we reload arena, too */
1344 /* Remove the block from the heap and try again */
1345 LPSTR buffer
= HeapAlloc( GetProcessHeap(), 0, oldsize
);
1346 if (!buffer
) return 0;
1347 memcpy( buffer
, ptr
+ arena
+ ARENA_HEADER_SIZE
, oldsize
);
1348 LOCAL_FreeArena( ds
, arena
);
1349 if (!(hmem
= LOCAL_GetBlock( ds
, size
, flags
)))
1351 if (!(hmem
= LOCAL_GetBlock( ds
, oldsize
, flags
)))
1353 ERR("Can't restore saved block\n" );
1354 HeapFree( GetProcessHeap(), 0, buffer
);
1359 ptr
= MapSL( MAKESEGPTR( ds
, 0 ) ); /* Reload ptr */
1360 memcpy( ptr
+ hmem
, buffer
, oldsize
);
1361 HeapFree( GetProcessHeap(), 0, buffer
);
1365 memcpy( ptr
+ hmem
, ptr
+ (arena
+ ARENA_HEADER_SIZE
), oldsize
);
1366 LOCAL_FreeArena( ds
, arena
);
1368 if (HANDLE_MOVEABLE( handle
))
1370 TRACE("fixing handle\n");
1371 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1372 pEntry
->addr
= hmem
+ MOVEABLE_PREFIX
;
1373 /* Back ptr should still be correct */
1374 if(*(HLOCAL16
*)(ptr
+ hmem
) != handle
)
1375 ERR("back ptr is invalid.\n");
1378 if (size
== oldsize
) hmem
= 0; /* Realloc failed */
1379 TRACE("returning %04x\n", hmem
);
1384 /***********************************************************************
1385 * LOCAL_InternalLock
1387 static HLOCAL16
LOCAL_InternalLock( LPSTR heap
, HLOCAL16 handle
)
1389 HLOCAL16 old_handle
= handle
;
1391 if (HANDLE_MOVEABLE(handle
))
1393 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(heap
+ handle
);
1394 if (pEntry
->flags
== LMEM_DISCARDED
) return 0;
1395 if (pEntry
->lock
< 0xfe) pEntry
->lock
++;
1396 handle
= pEntry
->addr
;
1398 TRACE("%04x returning %04x\n",
1399 old_handle
, handle
);
1404 /***********************************************************************
1407 void *LOCAL_Lock( HANDLE16 ds
, HLOCAL16 handle
)
1409 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1410 return handle
? ptr
+ LOCAL_InternalLock( ptr
, handle
) : NULL
;
1414 /***********************************************************************
1417 BOOL16
LOCAL_Unlock( HANDLE16 ds
, HLOCAL16 handle
)
1419 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1421 TRACE("%04x\n", handle
);
1422 if (HANDLE_MOVEABLE(handle
))
1424 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1425 if (!pEntry
->lock
|| (pEntry
->lock
== 0xff)) return FALSE
;
1426 /* For moveable block, return the new lock count */
1427 /* (see _Windows_Internals_ p. 197) */
1428 return --pEntry
->lock
;
1434 /***********************************************************************
1437 * Implementation of LocalSize().
1439 WORD
LOCAL_Size( HANDLE16 ds
, HLOCAL16 handle
)
1441 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1444 TRACE("%04x ds=%04x\n", handle
, ds
);
1446 if (!handle
) return 0;
1447 if (HANDLE_MOVEABLE( handle
))
1449 handle
= *(WORD
*)(ptr
+ handle
);
1450 if (!handle
) return 0;
1451 pArena
= ARENA_PTR( ptr
, ARENA_HEADER(handle
- MOVEABLE_PREFIX
) );
1454 pArena
= ARENA_PTR( ptr
, ARENA_HEADER(handle
) );
1456 return pArena
->next
- handle
;
1460 /***********************************************************************
1463 * Implementation of LocalFlags().
1465 WORD
LOCAL_Flags( HANDLE16 ds
, HLOCAL16 handle
)
1467 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1469 if (HANDLE_MOVEABLE(handle
))
1471 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1472 TRACE("(%04x,%04x): returning %04x\n",
1473 ds
, handle
, pEntry
->lock
| (pEntry
->flags
<< 8) );
1474 return pEntry
->lock
| (pEntry
->flags
<< 8);
1478 TRACE("(%04x,%04x): returning 0\n",
1485 /***********************************************************************
1488 * Implementation of LocalHeapSize().
1490 WORD
LOCAL_HeapSize( HANDLE16 ds
)
1492 LOCALHEAPINFO
*pInfo
= LOCAL_GetHeap( ds
);
1493 if (!pInfo
) return 0;
1494 return pInfo
->last
- pInfo
->first
;
1498 /***********************************************************************
1501 * Implementation of LocalCountFree().
1503 WORD
LOCAL_CountFree( HANDLE16 ds
)
1507 LOCALHEAPINFO
*pInfo
;
1508 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1510 if (!(pInfo
= LOCAL_GetHeap( ds
)))
1512 ERR("(%04x): Local heap not found\n", ds
);
1513 LOCAL_PrintHeap( ds
);
1518 arena
= pInfo
->first
;
1519 pArena
= ARENA_PTR( ptr
, arena
);
1522 arena
= pArena
->free_next
;
1523 pArena
= ARENA_PTR( ptr
, arena
);
1524 if (arena
== pArena
->free_next
) break;
1525 total
+= pArena
->size
;
1527 TRACE("(%04x): returning %d\n", ds
, total
);
1532 /***********************************************************************
1535 * Implementation of LocalHandle().
1537 HLOCAL16
LOCAL_Handle( HANDLE16 ds
, WORD addr
)
1539 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1540 LOCALHEAPINFO
*pInfo
;
1543 if (!(pInfo
= LOCAL_GetHeap( ds
)))
1545 ERR("(%04x): Local heap not found\n", ds
);
1546 LOCAL_PrintHeap( ds
);
1550 /* Find the address in the entry tables */
1552 table
= pInfo
->htable
;
1555 WORD count
= *(WORD
*)(ptr
+ table
);
1556 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+table
+sizeof(WORD
));
1557 for (; count
> 0; count
--, pEntry
++)
1558 if (pEntry
->addr
== addr
) return (HLOCAL16
)((char *)pEntry
- ptr
);
1559 table
= *(WORD
*)pEntry
;
1562 return (HLOCAL16
)addr
; /* Fixed block handle is addr */
1566 /***********************************************************************
1567 * LocalAlloc16 (KERNEL.5)
1569 HLOCAL16 WINAPI
LocalAlloc16( UINT16 flags
, WORD size
)
1571 HLOCAL16 ret
= LOCAL_Alloc( CURRENT_DS
, flags
, size
);
1572 CURRENT_STACK16
->ecx
= ret
; /* must be returned in cx too */
1577 /***********************************************************************
1578 * LocalReAlloc16 (KERNEL.6)
1580 HLOCAL16 WINAPI
LocalReAlloc16( HLOCAL16 handle
, WORD size
, UINT16 flags
)
1582 return LOCAL_ReAlloc( CURRENT_DS
, handle
, size
, flags
);
1586 /***********************************************************************
1587 * LocalFree16 (KERNEL.7)
1589 HLOCAL16 WINAPI
LocalFree16( HLOCAL16 handle
)
1591 return LOCAL_Free( CURRENT_DS
, handle
);
1595 /***********************************************************************
1596 * LocalLock16 (KERNEL.8)
1598 * Note: only the offset part of the pointer is returned by the relay code.
1600 SEGPTR WINAPI
LocalLock16( HLOCAL16 handle
)
1602 WORD ds
= CURRENT_DS
;
1603 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1604 return MAKESEGPTR( ds
, LOCAL_InternalLock( ptr
, handle
) );
1608 /***********************************************************************
1609 * LocalUnlock16 (KERNEL.9)
1611 BOOL16 WINAPI
LocalUnlock16( HLOCAL16 handle
)
1613 return LOCAL_Unlock( CURRENT_DS
, handle
);
1617 /***********************************************************************
1618 * LocalSize16 (KERNEL.10)
1620 UINT16 WINAPI
LocalSize16( HLOCAL16 handle
)
1622 return LOCAL_Size( CURRENT_DS
, handle
);
1626 /***********************************************************************
1627 * LocalHandle16 (KERNEL.11)
1629 HLOCAL16 WINAPI
LocalHandle16( WORD addr
)
1631 return LOCAL_Handle( CURRENT_DS
, addr
);
1635 /***********************************************************************
1636 * LocalFlags16 (KERNEL.12)
1638 UINT16 WINAPI
LocalFlags16( HLOCAL16 handle
)
1640 return LOCAL_Flags( CURRENT_DS
, handle
);
1644 /***********************************************************************
1645 * LocalCompact16 (KERNEL.13)
1647 UINT16 WINAPI
LocalCompact16( UINT16 minfree
)
1649 TRACE("%04x\n", minfree
);
1650 return LOCAL_Compact( CURRENT_DS
, minfree
, 0 );
1654 /***********************************************************************
1655 * LocalNotify (KERNEL.14)
1657 * Installs a callback function that is called for local memory events
1658 * Callback function prototype is
1659 * BOOL16 NotifyFunc(WORD wMsg, HLOCAL16 hMem, WORD wArg)
1662 * NotifyFunc seems to be responsible for allocating some memory,
1663 * returns TRUE for success.
1664 * wArg = number of bytes needed additionally
1666 * hMem = handle; wArg = old mem location
1668 * NotifyFunc seems to be strongly encouraged to return TRUE,
1669 * otherwise LogError() gets called.
1670 * hMem = handle; wArg = flags
1672 FARPROC16 WINAPI
LocalNotify16( FARPROC16 func
)
1674 LOCALHEAPINFO
*pInfo
;
1675 FARPROC16 oldNotify
;
1676 HANDLE16 ds
= CURRENT_DS
;
1678 if (!(pInfo
= LOCAL_GetHeap( ds
)))
1680 ERR("(%04x): Local heap not found\n", ds
);
1681 LOCAL_PrintHeap( ds
);
1684 TRACE("(%04x): %08lx\n", ds
, (DWORD
)func
);
1685 FIXME("Half implemented\n");
1686 oldNotify
= pInfo
->notify
;
1687 pInfo
->notify
= func
;
1692 /***********************************************************************
1693 * LocalShrink16 (KERNEL.121)
1695 UINT16 WINAPI
LocalShrink16( HGLOBAL16 handle
, UINT16 newsize
)
1697 TRACE("%04x %04x\n", handle
, newsize
);
1702 /***********************************************************************
1703 * GetHeapSpaces (KERNEL.138)
1705 DWORD WINAPI
GetHeapSpaces16( HMODULE16 module
)
1710 if (!(pModule
= NE_GetPtr( module
))) return 0;
1712 GlobalHandleToSel16((NE_SEG_TABLE( pModule
) + pModule
->dgroup
- 1)->hSeg
);
1713 return MAKELONG( LOCAL_CountFree( ds
), LOCAL_HeapSize( ds
) );
1717 /***********************************************************************
1718 * LocalCountFree (KERNEL.161)
1720 WORD WINAPI
LocalCountFree16(void)
1722 return LOCAL_CountFree( CURRENT_DS
);
1726 /***********************************************************************
1727 * LocalHeapSize (KERNEL.162)
1729 WORD WINAPI
LocalHeapSize16(void)
1732 return LOCAL_HeapSize( CURRENT_DS
);
1736 /***********************************************************************
1737 * LocalHandleDelta (KERNEL.310)
1739 WORD WINAPI
LocalHandleDelta16( WORD delta
)
1741 LOCALHEAPINFO
*pInfo
;
1743 if (!(pInfo
= LOCAL_GetHeap( CURRENT_DS
)))
1745 ERR("Local heap not found\n");
1746 LOCAL_PrintHeap( CURRENT_DS
);
1749 if (delta
) pInfo
->hdelta
= delta
;
1750 TRACE("returning %04x\n", pInfo
->hdelta
);
1751 return pInfo
->hdelta
;
1755 /***********************************************************************
1756 * LocalInfo (TOOLHELP.56)
1758 BOOL16 WINAPI
LocalInfo16( LOCALINFO
*pLocalInfo
, HGLOBAL16 handle
)
1760 LOCALHEAPINFO
*pInfo
= LOCAL_GetHeap(SELECTOROF(K32WOWGlobalLock16(handle
)));
1761 if (!pInfo
) return FALSE
;
1762 pLocalInfo
->wcItems
= pInfo
->items
;
1767 /***********************************************************************
1768 * LocalFirst (TOOLHELP.57)
1770 BOOL16 WINAPI
LocalFirst16( LOCALENTRY
*pLocalEntry
, HGLOBAL16 handle
)
1772 WORD ds
= GlobalHandleToSel16( handle
);
1773 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1774 LOCALHEAPINFO
*pInfo
= LOCAL_GetHeap( ds
);
1775 if (!pInfo
) return FALSE
;
1777 pLocalEntry
->hHandle
= pInfo
->first
+ ARENA_HEADER_SIZE
;
1778 pLocalEntry
->wAddress
= pLocalEntry
->hHandle
;
1779 pLocalEntry
->wFlags
= LF_FIXED
;
1780 pLocalEntry
->wcLock
= 0;
1781 pLocalEntry
->wType
= LT_NORMAL
;
1782 pLocalEntry
->hHeap
= handle
;
1783 pLocalEntry
->wHeapType
= NORMAL_HEAP
;
1784 pLocalEntry
->wNext
= ARENA_PTR(ptr
,pInfo
->first
)->next
;
1785 pLocalEntry
->wSize
= pLocalEntry
->wNext
- pLocalEntry
->hHandle
;
1790 /***********************************************************************
1791 * LocalNext (TOOLHELP.58)
1793 BOOL16 WINAPI
LocalNext16( LOCALENTRY
*pLocalEntry
)
1795 WORD ds
= GlobalHandleToSel16( pLocalEntry
->hHeap
);
1796 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1799 if (!LOCAL_GetHeap( ds
)) return FALSE
;
1800 if (!pLocalEntry
->wNext
) return FALSE
;
1801 pArena
= ARENA_PTR( ptr
, pLocalEntry
->wNext
);
1803 pLocalEntry
->hHandle
= pLocalEntry
->wNext
+ ARENA_HEADER_SIZE
;
1804 pLocalEntry
->wAddress
= pLocalEntry
->hHandle
;
1805 pLocalEntry
->wFlags
= (pArena
->prev
& 3) + 1;
1806 pLocalEntry
->wcLock
= 0;
1807 pLocalEntry
->wType
= LT_NORMAL
;
1808 if (pArena
->next
!= pLocalEntry
->wNext
) /* last one? */
1809 pLocalEntry
->wNext
= pArena
->next
;
1811 pLocalEntry
->wNext
= 0;
1812 pLocalEntry
->wSize
= pLocalEntry
->wNext
- pLocalEntry
->hHandle
;
1817 /***********************************************************************
1818 * LocalAlloc (KERNEL32.371)
1823 HLOCAL WINAPI
LocalAlloc(
1824 UINT flags
, /* [in] Allocation attributes */
1825 DWORD size
/* [in] Number of bytes to allocate */
1827 return (HLOCAL
)GlobalAlloc( flags
, size
);
1831 /***********************************************************************
1832 * LocalCompact (KERNEL32.372)
1834 UINT WINAPI
LocalCompact( UINT minfree
)
1836 return 0; /* LocalCompact does nothing in Win32 */
1840 /***********************************************************************
1841 * LocalFlags (KERNEL32.374)
1843 * Value specifying allocation flags and lock count.
1844 * LMEM_INVALID_HANDLE: Failure
1846 UINT WINAPI
LocalFlags(
1847 HLOCAL handle
/* [in] Handle of memory object */
1849 return GlobalFlags( (HGLOBAL
)handle
);
1853 /***********************************************************************
1854 * LocalFree (KERNEL32.375)
1859 HLOCAL WINAPI
LocalFree(
1860 HLOCAL handle
/* [in] Handle of memory object */
1862 return (HLOCAL
)GlobalFree( (HGLOBAL
)handle
);
1866 /***********************************************************************
1867 * LocalHandle (KERNEL32.376)
1872 HLOCAL WINAPI
LocalHandle(
1873 LPCVOID ptr
/* [in] Address of local memory object */
1875 return (HLOCAL
)GlobalHandle( ptr
);
1879 /***********************************************************************
1880 * LocalLock (KERNEL32.377)
1881 * Locks a local memory object and returns pointer to the first byte
1882 * of the memory block.
1888 LPVOID WINAPI
LocalLock(
1889 HLOCAL handle
/* [in] Address of local memory object */
1891 return GlobalLock( (HGLOBAL
)handle
);
1895 /***********************************************************************
1896 * LocalReAlloc (KERNEL32.378)
1901 HLOCAL WINAPI
LocalReAlloc(
1902 HLOCAL handle
, /* [in] Handle of memory object */
1903 DWORD size
, /* [in] New size of block */
1904 UINT flags
/* [in] How to reallocate object */
1906 return (HLOCAL
)GlobalReAlloc( (HGLOBAL
)handle
, size
, flags
);
1910 /***********************************************************************
1911 * LocalShrink (KERNEL32.379)
1913 UINT WINAPI
LocalShrink( HGLOBAL handle
, UINT newsize
)
1915 return 0; /* LocalShrink does nothing in Win32 */
1919 /***********************************************************************
1920 * LocalSize (KERNEL32.380)
1925 UINT WINAPI
LocalSize(
1926 HLOCAL handle
/* [in] Handle of memory object */
1928 return GlobalSize( (HGLOBAL
)handle
);
1932 /***********************************************************************
1933 * LocalUnlock (KERNEL32.381)
1935 * TRUE: Object is still locked
1936 * FALSE: Object is unlocked
1938 BOOL WINAPI
LocalUnlock(
1939 HLOCAL handle
/* [in] Handle of memory object */
1941 return GlobalUnlock( (HGLOBAL
)handle
);