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.
17 #include "wine/winbase16.h"
25 #include "stackframe.h"
27 #include "debugtools.h"
30 DECLARE_DEBUG_CHANNEL(heap
)
31 DECLARE_DEBUG_CHANNEL(local
)
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 /* LocalNotify() msgs */
57 /* Layout of a handle entry table
59 * WORD count of entries
60 * LOCALHANDLEENTRY[count] entries
61 * WORD near ptr to next table
65 WORD addr
; /* Address of the MOVEABLE block */
66 BYTE flags
; /* Flags for this block */
67 BYTE lock
; /* Lock count */
71 * We make addr = 4n + 2 and set *((WORD *)addr - 1) = &addr like Windows does
72 * in case something actually relies on this.
73 * Note the ARENA_HEADER(addr) still produces the desired result ie. 4n - 4
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)
86 WORD check
; /* 00 Heap checking flag */
87 WORD freeze
; /* 02 Heap frozen flag */
88 WORD items
; /* 04 Count of items on the heap */
89 WORD first
; /* 06 First item of the heap */
90 WORD pad1
; /* 08 Always 0 */
91 WORD last
; /* 0a Last item of the heap */
92 WORD pad2
; /* 0c Always 0 */
93 BYTE ncompact
; /* 0e Compactions counter */
94 BYTE dislevel
; /* 0f Discard level */
95 DWORD distotal
; /* 10 Total bytes discarded */
96 WORD htable
; /* 14 Pointer to handle table */
97 WORD hfree
; /* 16 Pointer to free handle table */
98 WORD hdelta
; /* 18 Delta to expand the handle table */
99 WORD expand
; /* 1a Pointer to expand function (unused) */
100 WORD pstat
; /* 1c Pointer to status structure (unused) */
101 FARPROC16 notify WINE_PACKED
; /* 1e Pointer to LocalNotify() function */
102 WORD lock
; /* 22 Lock count for the heap */
103 WORD extra
; /* 24 Extra bytes to allocate when expanding */
104 WORD minsize
; /* 26 Minimum size of the heap */
105 WORD magic
; /* 28 Magic number */
110 #define LOCAL_HEAP_MAGIC 0x484c /* 'LH' */
112 WORD USER_HeapSel
= 0; /* USER heap selector */
113 WORD GDI_HeapSel
= 0; /* GDI heap selector */
115 /* All local heap allocations are aligned on 4-byte boundaries */
116 #define LALIGN(word) (((word) + 3) & ~3)
118 #define ARENA_PTR(ptr,arena) ((LOCALARENA *)((char*)(ptr)+(arena)))
119 #define ARENA_PREV(ptr,arena) (ARENA_PTR((ptr),(arena))->prev & ~3)
120 #define ARENA_NEXT(ptr,arena) (ARENA_PTR((ptr),(arena))->next)
121 #define ARENA_FLAGS(ptr,arena) (ARENA_PTR((ptr),(arena))->prev & 3)
123 /* determine whether the handle belongs to a fixed or a moveable block */
124 #define HANDLE_FIXED(handle) (((handle) & 3) == 0)
125 #define HANDLE_MOVEABLE(handle) (((handle) & 3) == 2)
127 /***********************************************************************
130 * Return a pointer to the local heap, making sure it exists.
132 static LOCALHEAPINFO
*LOCAL_GetHeap( HANDLE16 ds
)
134 LOCALHEAPINFO
*pInfo
;
135 INSTANCEDATA
*ptr
= (INSTANCEDATA
*)PTR_SEG_OFF_TO_LIN( ds
, 0 );
136 TRACE_(local
)("Heap at %p, %04x\n", ptr
, (ptr
!= NULL
? ptr
->heap
: 0xFFFF));
137 if (!ptr
|| !ptr
->heap
) return NULL
;
138 if (IsBadReadPtr16( (SEGPTR
)MAKELONG(ptr
->heap
,ds
), sizeof(LOCALHEAPINFO
)))
140 pInfo
= (LOCALHEAPINFO
*)((char*)ptr
+ ptr
->heap
);
141 if (pInfo
->magic
!= LOCAL_HEAP_MAGIC
) return NULL
;
146 /***********************************************************************
147 * LOCAL_MakeBlockFree
149 * Make a block free, inserting it in the free-list.
150 * 'block' is the handle of the block arena; 'baseptr' points to
151 * the beginning of the data segment containing the heap.
153 static void LOCAL_MakeBlockFree( char *baseptr
, WORD block
)
155 LOCALARENA
*pArena
, *pNext
;
158 /* Mark the block as free */
160 pArena
= ARENA_PTR( baseptr
, block
);
161 pArena
->prev
= (pArena
->prev
& ~3) | LOCAL_ARENA_FREE
;
162 pArena
->size
= pArena
->next
- block
;
164 /* Find the next free block (last block is always free) */
169 pNext
= ARENA_PTR( baseptr
, next
);
170 if ((pNext
->prev
& 3) == LOCAL_ARENA_FREE
) break;
174 TRACE_(local
)("Local_MakeBlockFree %04x, next %04x\n", block
, next
);
175 /* Insert the free block in the free-list */
177 pArena
->free_prev
= pNext
->free_prev
;
178 pArena
->free_next
= next
;
179 ARENA_PTR(baseptr
,pNext
->free_prev
)->free_next
= block
;
180 pNext
->free_prev
= block
;
184 /***********************************************************************
185 * LOCAL_RemoveFreeBlock
187 * Remove a block from the free-list.
188 * 'block' is the handle of the block arena; 'baseptr' points to
189 * the beginning of the data segment containing the heap.
191 static void LOCAL_RemoveFreeBlock( char *baseptr
, WORD block
)
193 /* Mark the block as fixed */
195 LOCALARENA
*pArena
= ARENA_PTR( baseptr
, block
);
196 pArena
->prev
= (pArena
->prev
& ~3) | LOCAL_ARENA_FIXED
;
198 /* Remove it from the list */
200 ARENA_PTR(baseptr
,pArena
->free_prev
)->free_next
= pArena
->free_next
;
201 ARENA_PTR(baseptr
,pArena
->free_next
)->free_prev
= pArena
->free_prev
;
205 /***********************************************************************
208 * Insert a new block in the heap.
209 * 'new' is the handle of the new block arena; 'baseptr' points to
210 * the beginning of the data segment containing the heap; 'prev' is
211 * the block before the new one.
213 static void LOCAL_AddBlock( char *baseptr
, WORD prev
, WORD
new )
215 LOCALARENA
*pPrev
= ARENA_PTR( baseptr
, prev
);
216 LOCALARENA
*pNew
= ARENA_PTR( baseptr
, new );
218 pNew
->prev
= (prev
& ~3) | LOCAL_ARENA_FIXED
;
219 pNew
->next
= pPrev
->next
;
220 ARENA_PTR(baseptr
,pPrev
->next
)->prev
&= 3;
221 ARENA_PTR(baseptr
,pPrev
->next
)->prev
|= new;
226 /***********************************************************************
229 * Remove a block from the heap.
230 * 'block' is the handle of the block arena; 'baseptr' points to
231 * the beginning of the data segment containing the heap.
233 static void LOCAL_RemoveBlock( char *baseptr
, WORD block
)
235 LOCALARENA
*pArena
, *pTmp
;
237 /* Remove the block from the free-list */
239 TRACE_(local
)("Local_RemoveBlock\n");
240 pArena
= ARENA_PTR( baseptr
, block
);
241 if ((pArena
->prev
& 3) == LOCAL_ARENA_FREE
)
242 LOCAL_RemoveFreeBlock( baseptr
, block
);
244 /* If the previous block is free, expand its size */
246 pTmp
= ARENA_PTR( baseptr
, pArena
->prev
& ~3 );
247 if ((pTmp
->prev
& 3) == LOCAL_ARENA_FREE
)
248 pTmp
->size
+= pArena
->next
- block
;
250 /* Remove the block from the linked list */
252 pTmp
->next
= pArena
->next
;
253 pTmp
= ARENA_PTR( baseptr
, pArena
->next
);
254 pTmp
->prev
= (pTmp
->prev
& 3) | (pArena
->prev
& ~3);
258 /***********************************************************************
261 static void LOCAL_PrintHeap( HANDLE16 ds
)
264 LOCALHEAPINFO
*pInfo
;
267 /* FIXME - the test should be done when calling the function!
268 plus is not clear that we should print this info
269 only when TRACE_ON is on! */
270 if(!TRACE_ON(local
)) return;
272 ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
273 pInfo
= LOCAL_GetHeap( ds
);
277 DPRINTF( "Local Heap corrupted! ds=%04x\n", ds
);
280 DPRINTF( "Local Heap ds=%04x first=%04x last=%04x items=%d\n",
281 ds
, pInfo
->first
, pInfo
->last
, pInfo
->items
);
283 arena
= pInfo
->first
;
286 LOCALARENA
*pArena
= ARENA_PTR(ptr
,arena
);
287 DPRINTF( " %04x: prev=%04x next=%04x type=%d\n", arena
,
288 pArena
->prev
& ~3, pArena
->next
, pArena
->prev
& 3 );
289 if (arena
== pInfo
->first
)
291 DPRINTF( " size=%d free_prev=%04x free_next=%04x\n",
292 pArena
->size
, pArena
->free_prev
, pArena
->free_next
);
294 if ((pArena
->prev
& 3) == LOCAL_ARENA_FREE
)
296 DPRINTF( " size=%d free_prev=%04x free_next=%04x\n",
297 pArena
->size
, pArena
->free_prev
, pArena
->free_next
);
298 if (pArena
->next
== arena
) break; /* last one */
299 if (ARENA_PTR(ptr
,pArena
->free_next
)->free_prev
!= arena
)
301 DPRINTF( "*** arena->free_next->free_prev != arena\n" );
305 if (pArena
->next
== arena
)
307 DPRINTF( "*** last block is not marked free\n" );
310 if ((ARENA_PTR(ptr
,pArena
->next
)->prev
& ~3) != arena
)
312 DPRINTF( "*** arena->next->prev != arena (%04x, %04x)\n",
313 pArena
->next
, ARENA_PTR(ptr
,pArena
->next
)->prev
);
316 arena
= pArena
->next
;
321 /***********************************************************************
322 * LocalInit (KERNEL.4)
324 BOOL16 WINAPI
LocalInit16( HANDLE16 selector
, WORD start
, WORD end
)
327 WORD heapInfoArena
, freeArena
, lastArena
;
328 LOCALHEAPINFO
*pHeapInfo
;
329 LOCALARENA
*pArena
, *pFirstArena
, *pLastArena
;
332 /* The initial layout of the heap is: */
333 /* - first arena (FIXED) */
334 /* - heap info structure (FIXED) */
335 /* - large free block (FREE) */
336 /* - last arena (FREE) */
338 TRACE_(local
)("%04x %04x-%04x\n", selector
, start
, end
);
339 if (!selector
) selector
= CURRENT_DS
;
343 /* If TRACE_ON(heap) is set, the global heap blocks are */
344 /* cleared before use, so we can test for double initialization. */
345 if (LOCAL_GetHeap(selector
))
347 ERR_(local
)("Heap %04x initialized twice.\n", selector
);
348 LOCAL_PrintHeap(selector
);
354 /* start == 0 means: put the local heap at the end of the segment */
356 DWORD size
= GlobalSize16( GlobalHandle16( selector
) );
357 start
= (WORD
)(size
> 0xffff ? 0xffff : size
) - 1;
363 if ((pModule
= NE_GetPtr( GlobalHandle16( selector
) )))
365 SEGTABLEENTRY
*pSeg
= NE_SEG_TABLE( pModule
);
368 for ( segNr
= 0; segNr
< pModule
->seg_count
; segNr
++, pSeg
++ )
369 if ( GlobalHandleToSel16(pSeg
->hSeg
) == selector
)
372 if ( segNr
< pModule
->seg_count
)
374 WORD minsize
= pSeg
->minsize
;
375 if ( pModule
->ss
== segNr
+1 )
376 minsize
+= pModule
->stack_size
;
378 TRACE_(local
)(" new start %04x, minstart: %04x\n", start
, minsize
);
382 ptr
= PTR_SEG_OFF_TO_LIN( selector
, 0 );
384 start
= LALIGN( MAX( start
, sizeof(INSTANCEDATA
) ) );
385 heapInfoArena
= LALIGN(start
+ sizeof(LOCALARENA
) );
386 freeArena
= LALIGN( heapInfoArena
+ ARENA_HEADER_SIZE
387 + sizeof(LOCALHEAPINFO
) );
388 lastArena
= (end
- sizeof(LOCALARENA
)) & ~3;
390 /* Make sure there's enough space. */
392 if (freeArena
+ sizeof(LOCALARENA
) >= lastArena
) return FALSE
;
394 /* Initialise the first arena */
396 pFirstArena
= ARENA_PTR( ptr
, start
);
397 pFirstArena
->prev
= start
| LOCAL_ARENA_FIXED
;
398 pFirstArena
->next
= heapInfoArena
;
399 pFirstArena
->size
= LALIGN(sizeof(LOCALARENA
));
400 pFirstArena
->free_prev
= start
; /* this one */
401 pFirstArena
->free_next
= freeArena
;
403 /* Initialise the arena of the heap info structure */
405 pArena
= ARENA_PTR( ptr
, heapInfoArena
);
406 pArena
->prev
= start
| LOCAL_ARENA_FIXED
;
407 pArena
->next
= freeArena
;
409 /* Initialise the heap info structure */
411 pHeapInfo
= (LOCALHEAPINFO
*) (ptr
+ heapInfoArena
+ ARENA_HEADER_SIZE
);
412 memset( pHeapInfo
, 0, sizeof(LOCALHEAPINFO
) );
413 pHeapInfo
->items
= 4;
414 pHeapInfo
->first
= start
;
415 pHeapInfo
->last
= lastArena
;
416 pHeapInfo
->htable
= 0;
417 pHeapInfo
->hdelta
= 0x20;
418 pHeapInfo
->extra
= 0x200;
419 pHeapInfo
->minsize
= lastArena
- freeArena
;
420 pHeapInfo
->magic
= LOCAL_HEAP_MAGIC
;
422 /* Initialise the large free block */
424 pArena
= ARENA_PTR( ptr
, freeArena
);
425 pArena
->prev
= heapInfoArena
| LOCAL_ARENA_FREE
;
426 pArena
->next
= lastArena
;
427 pArena
->size
= lastArena
- freeArena
;
428 pArena
->free_prev
= start
;
429 pArena
->free_next
= lastArena
;
431 /* Initialise the last block */
433 pLastArena
= ARENA_PTR( ptr
, lastArena
);
434 pLastArena
->prev
= freeArena
| LOCAL_ARENA_FREE
;
435 pLastArena
->next
= lastArena
; /* this one */
436 pLastArena
->size
= LALIGN(sizeof(LOCALARENA
));
437 pLastArena
->free_prev
= freeArena
;
438 pLastArena
->free_next
= lastArena
; /* this one */
440 /* Store the local heap address in the instance data */
442 ((INSTANCEDATA
*)ptr
)->heap
= heapInfoArena
+ ARENA_HEADER_SIZE
;
443 LOCAL_PrintHeap( selector
);
447 /***********************************************************************
450 static BOOL16
LOCAL_GrowHeap( HANDLE16 ds
)
455 LOCALHEAPINFO
*pHeapInfo
;
456 WORD freeArena
, lastArena
;
457 LOCALARENA
*pArena
, *pLastArena
;
460 hseg
= GlobalHandle16( ds
);
461 /* maybe mem allocated by Virtual*() ? */
462 if (!hseg
) return FALSE
;
464 oldsize
= GlobalSize16( hseg
);
465 /* if nothing can be gained, return */
466 if (oldsize
> 0xfff0) return FALSE
;
467 hseg
= GlobalReAlloc16( hseg
, 0x10000, GMEM_FIXED
);
468 ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
469 pHeapInfo
= LOCAL_GetHeap( ds
);
470 if (pHeapInfo
== NULL
) {
471 ERR_(local
)("Heap not found\n" );
474 end
= GlobalSize16( hseg
);
475 lastArena
= (end
- sizeof(LOCALARENA
)) & ~3;
477 /* Update the HeapInfo */
479 freeArena
= pHeapInfo
->last
;
480 pHeapInfo
->last
= lastArena
;
481 pHeapInfo
->minsize
+= end
- oldsize
;
483 /* grow the old last block */
484 pArena
= ARENA_PTR( ptr
, freeArena
);
485 pArena
->size
= lastArena
- freeArena
;
486 pArena
->next
= lastArena
;
487 pArena
->free_next
= lastArena
;
489 /* Initialise the new last block */
491 pLastArena
= ARENA_PTR( ptr
, lastArena
);
492 pLastArena
->prev
= freeArena
| LOCAL_ARENA_FREE
;
493 pLastArena
->next
= lastArena
; /* this one */
494 pLastArena
->size
= LALIGN(sizeof(LOCALARENA
));
495 pLastArena
->free_prev
= freeArena
;
496 pLastArena
->free_next
= lastArena
; /* this one */
498 /* If block before freeArena is also free then merge them */
499 if((ARENA_PTR(ptr
, (pArena
->prev
& ~3))->prev
& 3) == LOCAL_ARENA_FREE
)
501 LOCAL_RemoveBlock(ptr
, freeArena
);
505 TRACE_(local
)("Heap expanded\n" );
506 LOCAL_PrintHeap( ds
);
511 /***********************************************************************
514 static HLOCAL16
LOCAL_FreeArena( WORD ds
, WORD arena
)
516 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
517 LOCALHEAPINFO
*pInfo
;
518 LOCALARENA
*pArena
, *pPrev
, *pNext
;
520 TRACE_(local
)("%04x ds=%04x\n", arena
, ds
);
521 if (!(pInfo
= LOCAL_GetHeap( ds
))) return arena
;
523 pArena
= ARENA_PTR( ptr
, arena
);
524 if ((pArena
->prev
& 3) == LOCAL_ARENA_FREE
)
526 /* shouldn't happen */
527 ERR_(local
)("Trying to free block %04x twice!\n",
529 LOCAL_PrintHeap( ds
);
533 /* Check if we can merge with the previous block */
535 pPrev
= ARENA_PTR( ptr
, pArena
->prev
& ~3 );
536 pNext
= ARENA_PTR( ptr
, pArena
->next
);
537 if ((pPrev
->prev
& 3) == LOCAL_ARENA_FREE
)
539 arena
= pArena
->prev
& ~3;
541 LOCAL_RemoveBlock( ptr
, pPrev
->next
);
544 else /* Make a new free block */
546 LOCAL_MakeBlockFree( ptr
, arena
);
549 /* Check if we can merge with the next block */
551 if ((pArena
->next
== pArena
->free_next
) &&
552 (pArena
->next
!= pInfo
->last
))
554 LOCAL_RemoveBlock( ptr
, pArena
->next
);
561 /***********************************************************************
564 * Shrink an arena by creating a free block at its end if possible.
565 * 'size' includes the arena header, and must be aligned.
567 static void LOCAL_ShrinkArena( WORD ds
, WORD arena
, WORD size
)
569 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
570 LOCALARENA
*pArena
= ARENA_PTR( ptr
, arena
);
572 if (arena
+ size
+ LALIGN(sizeof(LOCALARENA
)) < pArena
->next
)
574 LOCALHEAPINFO
*pInfo
= LOCAL_GetHeap( ds
);
576 LOCAL_AddBlock( ptr
, arena
, arena
+ size
);
578 LOCAL_FreeArena( ds
, arena
+ size
);
583 /***********************************************************************
584 * LOCAL_GrowArenaDownward
586 * Grow an arena downward by using the previous arena (must be free).
588 static void LOCAL_GrowArenaDownward( WORD ds
, WORD arena
, WORD newsize
)
590 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
591 LOCALHEAPINFO
*pInfo
;
592 LOCALARENA
*pArena
= ARENA_PTR( ptr
, arena
);
593 WORD prevArena
= pArena
->prev
& ~3;
594 LOCALARENA
*pPrevArena
= ARENA_PTR( ptr
, prevArena
);
598 if (!(pInfo
= LOCAL_GetHeap( ds
))) return;
599 offset
= pPrevArena
->size
;
600 size
= pArena
->next
- arena
- ARENA_HEADER_SIZE
;
601 LOCAL_RemoveFreeBlock( ptr
, prevArena
);
602 LOCAL_RemoveBlock( ptr
, arena
);
604 p
= (char *)pPrevArena
+ ARENA_HEADER_SIZE
;
605 while (offset
< size
)
607 memcpy( p
, p
+ offset
, offset
);
611 if (size
) memcpy( p
, p
+ offset
, size
);
612 LOCAL_ShrinkArena( ds
, prevArena
, newsize
);
617 /***********************************************************************
618 * LOCAL_GrowArenaUpward
620 * Grow an arena upward by using the next arena (must be free and big
621 * enough). Newsize includes the arena header and must be aligned.
623 static void LOCAL_GrowArenaUpward( WORD ds
, WORD arena
, WORD newsize
)
625 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
626 LOCALHEAPINFO
*pInfo
;
627 LOCALARENA
*pArena
= ARENA_PTR( ptr
, arena
);
628 WORD nextArena
= pArena
->next
;
630 if (!(pInfo
= LOCAL_GetHeap( ds
))) return;
631 LOCAL_RemoveBlock( ptr
, nextArena
);
633 LOCAL_ShrinkArena( ds
, arena
, newsize
);
637 /***********************************************************************
640 static WORD
LOCAL_GetFreeSpace(WORD ds
, WORD countdiscard
)
642 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
643 LOCALHEAPINFO
*pInfo
;
648 if (!(pInfo
= LOCAL_GetHeap( ds
)))
650 ERR_(local
)("Local heap not found\n" );
654 arena
= pInfo
->first
;
655 pArena
= ARENA_PTR( ptr
, arena
);
656 while (arena
!= pArena
->free_next
)
658 arena
= pArena
->free_next
;
659 pArena
= ARENA_PTR( ptr
, arena
);
660 if (pArena
->size
>= freespace
) freespace
= pArena
->size
;
662 /* FIXME doesn't yet calculate space that would become free if everything
663 were discarded when countdiscard == 1 */
664 if (freespace
< ARENA_HEADER_SIZE
) freespace
= 0;
665 else freespace
-= ARENA_HEADER_SIZE
;
670 /***********************************************************************
673 WORD
LOCAL_Compact( HANDLE16 ds
, UINT16 minfree
, UINT16 flags
)
675 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
676 LOCALHEAPINFO
*pInfo
;
677 LOCALARENA
*pArena
, *pMoveArena
, *pFinalArena
;
678 WORD arena
, movearena
, finalarena
, table
;
679 WORD count
, movesize
, size
;
681 LOCALHANDLEENTRY
*pEntry
;
683 if (!(pInfo
= LOCAL_GetHeap( ds
)))
685 ERR_(local
)("Local heap not found\n" );
689 TRACE_(local
)("ds = %04x, minfree = %04x, flags = %04x\n",
691 freespace
= LOCAL_GetFreeSpace(ds
, minfree
? 0 : 1);
692 if(freespace
>= minfree
|| (flags
& LMEM_NOCOMPACT
))
694 TRACE_(local
)("Returning %04x.\n", freespace
);
697 TRACE_(local
)("Compacting heap %04x.\n", ds
);
698 table
= pInfo
->htable
;
701 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ table
+ sizeof(WORD
));
702 for(count
= *(WORD
*)(ptr
+ table
); count
> 0; count
--, pEntry
++)
704 if((pEntry
->lock
== 0) && (pEntry
->flags
!= (LMEM_DISCARDED
>> 8)))
706 /* OK we can move this one if we want */
707 TRACE_(local
)("handle %04x (block %04x) can be moved.\n",
708 (WORD
)((char *)pEntry
- ptr
), pEntry
->addr
);
709 movearena
= ARENA_HEADER(pEntry
->addr
);
710 pMoveArena
= ARENA_PTR(ptr
, movearena
);
711 movesize
= pMoveArena
->next
- movearena
;
712 arena
= pInfo
->first
;
713 pArena
= ARENA_PTR(ptr
, arena
);
716 /* Try to find the smallest arena that will do, */
717 /* which is below us in memory */
720 arena
= pArena
->free_next
;
721 pArena
= ARENA_PTR(ptr
, arena
);
722 if(arena
>= movearena
)
724 if(arena
== pArena
->free_next
)
726 if((pArena
->size
>= movesize
) && (pArena
->size
< size
))
732 if (finalarena
) /* Actually got somewhere to move */
734 TRACE_(local
)("Moving it to %04x.\n", finalarena
);
735 pFinalArena
= ARENA_PTR(ptr
, finalarena
);
736 size
= pFinalArena
->size
;
737 LOCAL_RemoveFreeBlock(ptr
, finalarena
);
738 LOCAL_ShrinkArena( ds
, finalarena
, movesize
);
739 /* Copy the arena to it's new location */
740 memcpy((char *)pFinalArena
+ ARENA_HEADER_SIZE
,
741 (char *)pMoveArena
+ ARENA_HEADER_SIZE
,
742 movesize
- ARENA_HEADER_SIZE
);
743 /* Free the old location */
744 LOCAL_FreeArena(ds
, movearena
);
746 Callbacks
->CallLocalNotifyFunc(pInfo
->notify
, LN_MOVE
,
747 (WORD
)((char *)pEntry
- ptr
), pEntry
->addr
);
748 /* Update handle table entry */
749 pEntry
->addr
= finalarena
+ ARENA_HEADER_SIZE
+ sizeof(HLOCAL16
) ;
751 else if((ARENA_PTR(ptr
, pMoveArena
->prev
& ~3)->prev
& 3)
754 /* Previous arena is free (but < movesize) */
755 /* so we can 'slide' movearena down into it */
756 finalarena
= pMoveArena
->prev
& ~3;
757 LOCAL_GrowArenaDownward( ds
, movearena
, movesize
);
758 /* Update handle table entry */
759 pEntry
->addr
= finalarena
+ ARENA_HEADER_SIZE
+ sizeof(HLOCAL16
) ;
763 table
= *(WORD
*)pEntry
;
765 freespace
= LOCAL_GetFreeSpace(ds
, minfree
? 0 : 1);
766 if(freespace
>= minfree
|| (flags
& LMEM_NODISCARD
))
768 TRACE_(local
)("Returning %04x.\n", freespace
);
772 table
= pInfo
->htable
;
775 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ table
+ sizeof(WORD
));
776 for(count
= *(WORD
*)(ptr
+ table
); count
> 0; count
--, pEntry
++)
778 if(pEntry
->addr
&& pEntry
->lock
== 0 &&
779 (pEntry
->flags
& (LMEM_DISCARDABLE
>> 8)))
781 TRACE_(local
)("Discarding handle %04x (block %04x).\n",
782 (char *)pEntry
- ptr
, pEntry
->addr
);
783 LOCAL_FreeArena(ds
, ARENA_HEADER(pEntry
->addr
));
785 Callbacks
->CallLocalNotifyFunc(pInfo
->notify
, LN_DISCARD
,
786 (char *)pEntry
- ptr
, pEntry
->flags
);
788 pEntry
->flags
= (LMEM_DISCARDED
>> 8);
791 table
= *(WORD
*)pEntry
;
793 return LOCAL_Compact(ds
, 0xffff, LMEM_NODISCARD
);
797 /***********************************************************************
798 * LOCAL_FindFreeBlock
800 static HLOCAL16
LOCAL_FindFreeBlock( HANDLE16 ds
, WORD size
)
802 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
803 LOCALHEAPINFO
*pInfo
;
807 if (!(pInfo
= LOCAL_GetHeap( ds
)))
809 ERR_(local
)("Local heap not found\n" );
814 arena
= pInfo
->first
;
815 pArena
= ARENA_PTR( ptr
, arena
);
817 arena
= pArena
->free_next
;
818 pArena
= ARENA_PTR( ptr
, arena
);
819 if (arena
== pArena
->free_next
) break;
820 if (pArena
->size
>= size
) return arena
;
822 TRACE_(local
)("not enough space\n" );
827 /***********************************************************************
829 * The segment may get moved around in this function, so all callers
830 * should reset their pointer variables.
832 static HLOCAL16
LOCAL_GetBlock( HANDLE16 ds
, WORD size
, WORD flags
)
834 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
835 LOCALHEAPINFO
*pInfo
;
839 if (!(pInfo
= LOCAL_GetHeap( ds
)))
841 ERR_(local
)("Local heap not found\n");
846 size
+= ARENA_HEADER_SIZE
;
847 size
= LALIGN( MAX( size
, sizeof(LOCALARENA
) ) );
852 /* Find a suitable free block */
853 arena
= LOCAL_FindFreeBlock( ds
, size
);
855 /* no space: try to make some */
856 LOCAL_Compact( ds
, size
, flags
);
857 arena
= LOCAL_FindFreeBlock( ds
, size
);
860 /* still no space: try to grow the segment */
861 if (!(LOCAL_GrowHeap( ds
)))
864 /* FIXME: doesn't work correctly yet */
865 if ((pInfo
->notify
) && (Callbacks
->CallLocalNotifyFunc(pInfo
->notify
, LN_OUTOFMEM
, ds
- 20, size
))) /* FIXME: "size" correct ? (should indicate bytes needed) */
870 ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
871 pInfo
= LOCAL_GetHeap( ds
);
872 arena
= LOCAL_FindFreeBlock( ds
, size
);
875 if (ds
== GDI_HeapSel
) {
876 ERR_(local
)("not enough space in GDI local heap "
877 "(%04x) for %d bytes\n", ds
, size
);
878 } else if (ds
== USER_HeapSel
) {
879 ERR_(local
)("not enough space in USER local heap "
880 "(%04x) for %d bytes\n", ds
, size
);
882 ERR_(local
)("not enough space in local heap "
883 "%04x for %d bytes\n", ds
, size
);
886 if ((pInfo
->notify
) &&
887 /* FIXME: "size" correct ? (should indicate bytes needed) */
888 (Callbacks
->CallLocalNotifyFunc(pInfo
->notify
, LN_OUTOFMEM
, ds
, size
)))
894 /* Make a block out of the free arena */
895 pArena
= ARENA_PTR( ptr
, arena
);
896 TRACE_(local
)("LOCAL_GetBlock size = %04x, arena %04x size %04x\n",
897 size
, arena
, pArena
->size
);
898 LOCAL_RemoveFreeBlock( ptr
, arena
);
899 LOCAL_ShrinkArena( ds
, arena
, size
);
901 if (flags
& LMEM_ZEROINIT
)
902 memset((char *)pArena
+ ARENA_HEADER_SIZE
, 0, size
-ARENA_HEADER_SIZE
);
903 return arena
+ ARENA_HEADER_SIZE
;
907 /***********************************************************************
910 static BOOL16
LOCAL_NewHTable( HANDLE16 ds
)
912 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
913 LOCALHEAPINFO
*pInfo
;
914 LOCALHANDLEENTRY
*pEntry
;
918 TRACE_(local
)("Local_NewHTable\n" );
919 if (!(pInfo
= LOCAL_GetHeap( ds
)))
921 ERR_(local
)("Local heap not found\n");
926 if (!(handle
= LOCAL_GetBlock( ds
, pInfo
->hdelta
* sizeof(LOCALHANDLEENTRY
)
927 + 2 * sizeof(WORD
), LMEM_FIXED
)))
929 if (!(ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 )))
930 ERR_(local
)("ptr == NULL after GetBlock.\n");
931 if (!(pInfo
= LOCAL_GetHeap( ds
)))
932 ERR_(local
)("pInfo == NULL after GetBlock.\n");
934 /* Fill the entry table */
936 *(WORD
*)(ptr
+ handle
) = pInfo
->hdelta
;
937 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
+ sizeof(WORD
));
938 for (i
= pInfo
->hdelta
; i
> 0; i
--, pEntry
++) {
939 pEntry
->lock
= pEntry
->flags
= 0xff;
942 *(WORD
*)pEntry
= pInfo
->htable
;
943 pInfo
->htable
= handle
;
948 /***********************************************************************
949 * LOCAL_GetNewHandleEntry
951 static HLOCAL16
LOCAL_GetNewHandleEntry( HANDLE16 ds
)
953 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
954 LOCALHEAPINFO
*pInfo
;
955 LOCALHANDLEENTRY
*pEntry
= NULL
;
958 if (!(pInfo
= LOCAL_GetHeap( ds
)))
960 ERR_(local
)("Local heap not found\n");
965 /* Find a free slot in existing tables */
967 table
= pInfo
->htable
;
970 WORD count
= *(WORD
*)(ptr
+ table
);
971 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ table
+ sizeof(WORD
));
972 for (; count
> 0; count
--, pEntry
++)
973 if (pEntry
->lock
== 0xff) break;
975 table
= *(WORD
*)pEntry
;
978 if (!table
) /* We need to create a new table */
980 if (!LOCAL_NewHTable( ds
)) return 0;
981 ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
982 pInfo
= LOCAL_GetHeap( ds
);
983 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ pInfo
->htable
+ sizeof(WORD
));
986 /* Now allocate this entry */
990 TRACE_(local
)("(%04x): %04x\n",
991 ds
, ((char *)pEntry
- ptr
) );
992 return (HLOCAL16
)((char *)pEntry
- ptr
);
996 /***********************************************************************
997 * LOCAL_FreeHandleEntry
999 * Free a handle table entry.
1001 static void LOCAL_FreeHandleEntry( HANDLE16 ds
, HLOCAL16 handle
)
1003 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1004 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1005 LOCALHEAPINFO
*pInfo
;
1007 WORD table
, count
, i
;
1009 if (!(pInfo
= LOCAL_GetHeap( ds
))) return;
1011 /* Find the table where this handle comes from */
1013 pTable
= &pInfo
->htable
;
1016 WORD size
= (*(WORD
*)(ptr
+ *pTable
)) * sizeof(LOCALHANDLEENTRY
);
1017 if ((handle
>= *pTable
+ sizeof(WORD
)) &&
1018 (handle
< *pTable
+ sizeof(WORD
) + size
)) break; /* Found it */
1019 pTable
= (WORD
*)(ptr
+ *pTable
+ sizeof(WORD
) + size
);
1023 ERR_(local
)("Invalid entry %04x\n", handle
);
1024 LOCAL_PrintHeap( ds
);
1028 /* Make the entry free */
1030 pEntry
->addr
= 0; /* just in case */
1031 pEntry
->lock
= 0xff;
1032 pEntry
->flags
= 0xff;
1033 /* Now check if all entries in this table are free */
1036 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ table
+ sizeof(WORD
));
1037 count
= *(WORD
*)(ptr
+ table
);
1038 for (i
= count
; i
> 0; i
--, pEntry
++) if (pEntry
->lock
!= 0xff) return;
1040 /* Remove the table from the linked list and free it */
1042 TRACE_(local
)("(%04x): freeing table %04x\n",
1044 *pTable
= *(WORD
*)pEntry
;
1045 LOCAL_FreeArena( ds
, ARENA_HEADER( table
) );
1049 /***********************************************************************
1052 * Implementation of LocalFree().
1054 HLOCAL16
LOCAL_Free( HANDLE16 ds
, HLOCAL16 handle
)
1056 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1058 TRACE_(local
)("%04x ds=%04x\n", handle
, ds
);
1060 if (!handle
) { WARN_(local
)("Handle is 0.\n" ); return 0; }
1061 if (HANDLE_FIXED( handle
))
1063 if (!LOCAL_FreeArena( ds
, ARENA_HEADER( handle
) )) return 0; /* OK */
1064 else return handle
; /* couldn't free it */
1068 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1069 if (pEntry
->flags
!= (LMEM_DISCARDED
>> 8))
1071 TRACE_(local
)("real block at %04x\n",
1073 if (LOCAL_FreeArena( ds
, ARENA_HEADER(pEntry
->addr
) ))
1074 return handle
; /* couldn't free it */
1076 LOCAL_FreeHandleEntry( ds
, handle
);
1082 /***********************************************************************
1085 * Implementation of LocalAlloc().
1088 HLOCAL16
LOCAL_Alloc( HANDLE16 ds
, WORD flags
, WORD size
)
1093 TRACE_(local
)("%04x %d ds=%04x\n", flags
, size
, ds
);
1095 if(size
> 0 && size
<= 4) size
= 5;
1096 if (flags
& LMEM_MOVEABLE
)
1098 LOCALHANDLEENTRY
*plhe
;
1103 if (!(hmem
= LOCAL_GetBlock( ds
, size
+ sizeof(HLOCAL16
), flags
)))
1106 else /* We just need to allocate a discarded handle */
1108 if (!(handle
= LOCAL_GetNewHandleEntry( ds
)))
1110 WARN_(local
)("Couldn't get handle.\n");
1112 LOCAL_FreeArena( ds
, ARENA_HEADER(hmem
) );
1115 ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1116 plhe
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1120 plhe
->addr
= hmem
+ sizeof(HLOCAL16
);
1121 plhe
->flags
= (BYTE
)((flags
& 0x0f00) >> 8);
1122 *(HLOCAL16
*)(ptr
+ hmem
) = handle
;
1127 plhe
->flags
= LMEM_DISCARDED
>> 8;
1134 handle
= LOCAL_GetBlock( ds
, size
, flags
);
1140 /***********************************************************************
1143 * Implementation of LocalReAlloc().
1145 HLOCAL16
LOCAL_ReAlloc( HANDLE16 ds
, HLOCAL16 handle
, WORD size
, WORD flags
)
1147 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1148 LOCALHEAPINFO
*pInfo
;
1149 LOCALARENA
*pArena
, *pNext
;
1150 LOCALHANDLEENTRY
*pEntry
= NULL
;
1151 WORD arena
, oldsize
;
1152 HLOCAL16 hmem
, blockhandle
;
1155 if (!handle
) return 0;
1156 if(HANDLE_MOVEABLE(handle
) &&
1157 ((LOCALHANDLEENTRY
*)(ptr
+ handle
))->lock
== 0xff) /* An unused handle */
1160 TRACE_(local
)("%04x %d %04x ds=%04x\n",
1161 handle
, size
, flags
, ds
);
1162 if (!(pInfo
= LOCAL_GetHeap( ds
))) return 0;
1164 if (HANDLE_FIXED( handle
))
1165 blockhandle
= handle
;
1168 pEntry
= (LOCALHANDLEENTRY
*) (ptr
+ handle
);
1169 if(pEntry
->flags
== (LMEM_DISCARDED
>> 8))
1173 WARN_(local
)("Dicarded block has non-zero addr.\n");
1174 TRACE_(local
)("ReAllocating discarded block\n");
1175 if(size
<= 4) size
= 5;
1176 if (!(hl
= LOCAL_GetBlock( ds
, size
+ sizeof(HLOCAL16
), flags
)))
1178 ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 ); /* Reload ptr */
1179 pEntry
= (LOCALHANDLEENTRY
*) (ptr
+ handle
);
1180 pEntry
->addr
= hl
+ sizeof(HLOCAL16
);
1183 *(HLOCAL16
*)(ptr
+ hl
) = handle
;
1186 if (((blockhandle
= pEntry
->addr
) & 3) != 2)
1188 ERR_(local
)("(%04x,%04x): invalid handle\n",
1192 if(*((HLOCAL16
*)(ptr
+ blockhandle
) - 1) != handle
) {
1193 ERR_(local
)("Back ptr to handle is invalid\n");
1198 if (flags
& LMEM_MODIFY
)
1200 if (HANDLE_MOVEABLE(handle
))
1202 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1203 pEntry
->flags
= (flags
& 0x0f00) >> 8;
1204 TRACE_(local
)("Changing flags to %x.\n", pEntry
->flags
);
1211 if (flags
& LMEM_MOVEABLE
)
1213 if (HANDLE_FIXED(handle
))
1215 TRACE_(local
)("Freeing fixed block.\n");
1216 return LOCAL_Free( ds
, handle
);
1218 else /* Moveable block */
1220 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1221 if (pEntry
->lock
== 0)
1223 /* discards moveable blocks */
1224 TRACE_(local
)("Discarding block\n");
1225 LOCAL_FreeArena(ds
, ARENA_HEADER(pEntry
->addr
));
1227 pEntry
->flags
= (LMEM_DISCARDED
>> 8);
1235 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1236 if (pEntry
->lock
== 0)
1239 return LOCAL_Free( ds
, handle
);
1245 arena
= ARENA_HEADER( blockhandle
);
1246 TRACE_(local
)("arena is %04x\n", arena
);
1247 pArena
= ARENA_PTR( ptr
, arena
);
1249 if(size
<= 4) size
= 5;
1250 oldsize
= pArena
->next
- arena
- ARENA_HEADER_SIZE
;
1251 nextarena
= LALIGN(blockhandle
+ size
);
1253 /* Check for size reduction */
1255 if (nextarena
<= pArena
->next
)
1257 TRACE_(local
)("size reduction, making new free block\n");
1258 LOCAL_ShrinkArena(ds
, arena
, nextarena
- arena
);
1259 TRACE_(local
)("returning %04x\n", handle
);
1263 /* Check if the next block is free and large enough */
1265 pNext
= ARENA_PTR( ptr
, pArena
->next
);
1266 if (((pNext
->prev
& 3) == LOCAL_ARENA_FREE
) &&
1267 (nextarena
<= pNext
->next
))
1269 TRACE_(local
)("size increase, making new free block\n");
1270 LOCAL_GrowArenaUpward(ds
, arena
, nextarena
- arena
);
1271 TRACE_(local
)("returning %04x\n", handle
);
1275 /* Now we have to allocate a new block, but not if (fixed block or locked
1276 block) and no LMEM_MOVEABLE */
1278 if (!(flags
& LMEM_MOVEABLE
))
1280 if (HANDLE_FIXED(handle
))
1282 ERR_(local
)("Needed to move fixed block, but LMEM_MOVEABLE not specified.\n");
1287 if(((LOCALHANDLEENTRY
*)(ptr
+ handle
))->lock
!= 0)
1289 ERR_(local
)("Needed to move locked block, but LMEM_MOVEABLE not specified.\n");
1294 if(HANDLE_MOVEABLE(handle
)) size
+= sizeof(HLOCAL16
);
1295 hmem
= LOCAL_GetBlock( ds
, size
, flags
);
1296 ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 ); /* Reload ptr */
1297 if(HANDLE_MOVEABLE(handle
)) /* LOCAL_GetBlock might have triggered */
1298 { /* a compaction, which might in turn have */
1299 blockhandle
= pEntry
->addr
; /* moved the very block we are resizing */
1300 arena
= ARENA_HEADER( blockhandle
); /* thus, we reload arena, too */
1304 /* Remove the block from the heap and try again */
1305 LPSTR buffer
= HeapAlloc( GetProcessHeap(), 0, oldsize
);
1306 if (!buffer
) return 0;
1307 memcpy( buffer
, ptr
+ arena
+ ARENA_HEADER_SIZE
, oldsize
);
1308 LOCAL_FreeArena( ds
, arena
);
1309 if (!(hmem
= LOCAL_GetBlock( ds
, size
, flags
)))
1311 if (!(hmem
= LOCAL_GetBlock( ds
, oldsize
, flags
)))
1313 ERR_(local
)("Can't restore saved block\n" );
1314 HeapFree( GetProcessHeap(), 0, buffer
);
1319 ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 ); /* Reload ptr */
1320 memcpy( ptr
+ hmem
, buffer
, oldsize
);
1321 HeapFree( GetProcessHeap(), 0, buffer
);
1325 memcpy( ptr
+ hmem
, ptr
+ (arena
+ ARENA_HEADER_SIZE
), oldsize
);
1326 LOCAL_FreeArena( ds
, arena
);
1328 if (HANDLE_MOVEABLE( handle
))
1330 TRACE_(local
)("fixing handle\n");
1331 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1332 pEntry
->addr
= hmem
+ sizeof(HLOCAL16
);
1333 /* Back ptr should still be correct */
1334 if(*(HLOCAL16
*)(ptr
+ hmem
) != handle
)
1335 ERR_(local
)("back ptr is invalid.\n");
1338 if (size
== oldsize
) hmem
= 0; /* Realloc failed */
1339 TRACE_(local
)("returning %04x\n", hmem
);
1344 /***********************************************************************
1345 * LOCAL_InternalLock
1347 static HLOCAL16
LOCAL_InternalLock( LPSTR heap
, HLOCAL16 handle
)
1349 HLOCAL16 old_handle
= handle
;
1351 if (HANDLE_MOVEABLE(handle
))
1353 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(heap
+ handle
);
1354 if (pEntry
->flags
== LMEM_DISCARDED
) return 0;
1355 if (pEntry
->lock
< 0xfe) pEntry
->lock
++;
1356 handle
= pEntry
->addr
;
1358 TRACE_(local
)("%04x returning %04x\n",
1359 old_handle
, handle
);
1364 /***********************************************************************
1367 LPSTR
LOCAL_Lock( HANDLE16 ds
, HLOCAL16 handle
)
1369 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1370 return handle
? ptr
+ LOCAL_InternalLock( ptr
, handle
) : NULL
;
1374 /***********************************************************************
1377 SEGPTR
LOCAL_LockSegptr( HANDLE16 ds
, HLOCAL16 handle
)
1379 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1380 return PTR_SEG_OFF_TO_SEGPTR( ds
, LOCAL_InternalLock( ptr
, handle
) );
1384 /***********************************************************************
1387 BOOL16
LOCAL_Unlock( HANDLE16 ds
, HLOCAL16 handle
)
1389 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1391 TRACE_(local
)("%04x\n", handle
);
1392 if (HANDLE_MOVEABLE(handle
))
1394 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1395 if (!pEntry
->lock
|| (pEntry
->lock
== 0xff)) return FALSE
;
1396 /* For moveable block, return the new lock count */
1397 /* (see _Windows_Internals_ p. 197) */
1398 return --pEntry
->lock
;
1404 /***********************************************************************
1407 * Implementation of LocalSize().
1409 WORD
LOCAL_Size( HANDLE16 ds
, HLOCAL16 handle
)
1411 char *ptr
= PTR_SEG_OFF_TO_LIN( CURRENT_DS
, 0 );
1414 TRACE_(local
)("%04x ds=%04x\n", handle
, ds
);
1416 if (HANDLE_MOVEABLE( handle
)) handle
= *(WORD
*)(ptr
+ handle
);
1417 if (!handle
) return 0;
1418 pArena
= ARENA_PTR( ptr
, ARENA_HEADER(handle
) );
1419 return pArena
->next
- handle
;
1423 /***********************************************************************
1426 * Implementation of LocalFlags().
1428 WORD
LOCAL_Flags( HANDLE16 ds
, HLOCAL16 handle
)
1430 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1432 if (HANDLE_MOVEABLE(handle
))
1434 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1435 TRACE_(local
)("(%04x,%04x): returning %04x\n",
1436 ds
, handle
, pEntry
->lock
| (pEntry
->flags
<< 8) );
1437 return pEntry
->lock
| (pEntry
->flags
<< 8);
1441 TRACE_(local
)("(%04x,%04x): returning 0\n",
1448 /***********************************************************************
1451 * Implementation of LocalHeapSize().
1453 WORD
LOCAL_HeapSize( HANDLE16 ds
)
1455 LOCALHEAPINFO
*pInfo
= LOCAL_GetHeap( ds
);
1456 if (!pInfo
) return 0;
1457 return pInfo
->last
- pInfo
->first
;
1461 /***********************************************************************
1464 * Implementation of LocalCountFree().
1466 WORD
LOCAL_CountFree( HANDLE16 ds
)
1470 LOCALHEAPINFO
*pInfo
;
1471 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1473 if (!(pInfo
= LOCAL_GetHeap( ds
)))
1475 ERR_(local
)("(%04x): Local heap not found\n", ds
);
1476 LOCAL_PrintHeap( ds
);
1481 arena
= pInfo
->first
;
1482 pArena
= ARENA_PTR( ptr
, arena
);
1485 arena
= pArena
->free_next
;
1486 pArena
= ARENA_PTR( ptr
, arena
);
1487 if (arena
== pArena
->free_next
) break;
1488 total
+= pArena
->size
;
1490 TRACE_(local
)("(%04x): returning %d\n", ds
, total
);
1495 /***********************************************************************
1498 * Implementation of LocalHandle().
1500 HLOCAL16
LOCAL_Handle( HANDLE16 ds
, WORD addr
)
1502 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1503 LOCALHEAPINFO
*pInfo
;
1506 if (!(pInfo
= LOCAL_GetHeap( ds
)))
1508 ERR_(local
)("(%04x): Local heap not found\n", ds
);
1509 LOCAL_PrintHeap( ds
);
1513 /* Find the address in the entry tables */
1515 table
= pInfo
->htable
;
1518 WORD count
= *(WORD
*)(ptr
+ table
);
1519 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+table
+sizeof(WORD
));
1520 for (; count
> 0; count
--, pEntry
++)
1521 if (pEntry
->addr
== addr
) return (HLOCAL16
)((char *)pEntry
- ptr
);
1522 table
= *(WORD
*)pEntry
;
1525 return (HLOCAL16
)addr
; /* Fixed block handle is addr */
1529 /***********************************************************************
1530 * LocalAlloc16 (KERNEL.5)
1532 HLOCAL16 WINAPI
LocalAlloc16( UINT16 flags
, WORD size
)
1534 return LOCAL_Alloc( CURRENT_DS
, flags
, size
);
1538 /***********************************************************************
1541 void WINAPI
WIN16_LocalAlloc( CONTEXT86
*context
)
1543 WORD
*stack
= PTR_SEG_OFF_TO_LIN(SS_reg(context
), SP_reg(context
));
1544 UINT16 flags
= (UINT16
)stack
[3];
1545 WORD size
= (WORD
)stack
[2];
1546 TRACE_(local
)("WIN16LocalAlloc: %04x %d \n", flags
, size
);
1547 AX_reg(context
) = CX_reg(context
) = LOCAL_Alloc( DS_reg(context
), flags
, size
);
1551 /***********************************************************************
1552 * LocalReAlloc16 (KERNEL.6)
1554 HLOCAL16 WINAPI
LocalReAlloc16( HLOCAL16 handle
, WORD size
, UINT16 flags
)
1556 return LOCAL_ReAlloc( CURRENT_DS
, handle
, size
, flags
);
1560 /***********************************************************************
1561 * LocalFree16 (KERNEL.7)
1563 HLOCAL16 WINAPI
LocalFree16( HLOCAL16 handle
)
1565 return LOCAL_Free( CURRENT_DS
, handle
);
1569 /***********************************************************************
1570 * LocalLock16 (KERNEL.8)
1572 * Note: only the offset part of the pointer is returned by the relay code.
1574 SEGPTR WINAPI
LocalLock16( HLOCAL16 handle
)
1576 return LOCAL_LockSegptr( CURRENT_DS
, handle
);
1580 /***********************************************************************
1581 * LocalUnlock16 (KERNEL.9)
1583 BOOL16 WINAPI
LocalUnlock16( HLOCAL16 handle
)
1585 return LOCAL_Unlock( CURRENT_DS
, handle
);
1589 /***********************************************************************
1590 * LocalSize16 (KERNEL.10)
1592 UINT16 WINAPI
LocalSize16( HLOCAL16 handle
)
1594 return LOCAL_Size( CURRENT_DS
, handle
);
1598 /***********************************************************************
1599 * LocalHandle16 (KERNEL.11)
1601 HLOCAL16 WINAPI
LocalHandle16( WORD addr
)
1603 return LOCAL_Handle( CURRENT_DS
, addr
);
1607 /***********************************************************************
1608 * LocalFlags16 (KERNEL.12)
1610 UINT16 WINAPI
LocalFlags16( HLOCAL16 handle
)
1612 return LOCAL_Flags( CURRENT_DS
, handle
);
1616 /***********************************************************************
1617 * LocalCompact16 (KERNEL.13)
1619 UINT16 WINAPI
LocalCompact16( UINT16 minfree
)
1621 TRACE_(local
)("%04x\n", minfree
);
1622 return LOCAL_Compact( CURRENT_DS
, minfree
, 0 );
1626 /***********************************************************************
1627 * LocalNotify (KERNEL.14)
1629 * Installs a callback function that is called for local memory events
1630 * Callback function prototype is
1631 * BOOL16 NotifyFunc(WORD wMsg, HLOCAL16 hMem, WORD wArg)
1634 * NotifyFunc seems to be responsible for allocating some memory,
1635 * returns TRUE for success.
1636 * wArg = number of bytes needed additionally
1638 * hMem = handle; wArg = old mem location
1640 * NotifyFunc seems to be strongly encouraged to return TRUE,
1641 * otherwise LogError() gets called.
1642 * hMem = handle; wArg = flags
1644 FARPROC16 WINAPI
LocalNotify16( FARPROC16 func
)
1646 LOCALHEAPINFO
*pInfo
;
1647 FARPROC16 oldNotify
;
1648 HANDLE16 ds
= CURRENT_DS
;
1650 if (!(pInfo
= LOCAL_GetHeap( ds
)))
1652 ERR_(local
)("(%04x): Local heap not found\n", ds
);
1653 LOCAL_PrintHeap( ds
);
1656 TRACE_(local
)("(%04x): %08lx\n", ds
, (DWORD
)func
);
1657 FIXME_(local
)("Half implemented\n");
1658 oldNotify
= pInfo
->notify
;
1659 pInfo
->notify
= func
;
1664 /***********************************************************************
1665 * LocalShrink16 (KERNEL.121)
1667 UINT16 WINAPI
LocalShrink16( HGLOBAL16 handle
, UINT16 newsize
)
1669 TRACE_(local
)("%04x %04x\n", handle
, newsize
);
1674 /***********************************************************************
1675 * GetHeapSpaces (KERNEL.138)
1677 DWORD WINAPI
GetHeapSpaces16( HMODULE16 module
)
1682 if (!(pModule
= NE_GetPtr( module
))) return 0;
1684 GlobalHandleToSel16((NE_SEG_TABLE( pModule
) + pModule
->dgroup
- 1)->hSeg
);
1685 return MAKELONG( LOCAL_CountFree( ds
), LOCAL_HeapSize( ds
) );
1689 /***********************************************************************
1690 * LocalCountFree (KERNEL.161)
1692 WORD WINAPI
LocalCountFree16(void)
1694 return LOCAL_CountFree( CURRENT_DS
);
1698 /***********************************************************************
1699 * LocalHeapSize (KERNEL.162)
1701 WORD WINAPI
LocalHeapSize16(void)
1703 TRACE_(local
)("(void)\n" );
1704 return LOCAL_HeapSize( CURRENT_DS
);
1708 /***********************************************************************
1709 * LocalHandleDelta (KERNEL.310)
1711 WORD WINAPI
LocalHandleDelta16( WORD delta
)
1713 LOCALHEAPINFO
*pInfo
;
1715 if (!(pInfo
= LOCAL_GetHeap( CURRENT_DS
)))
1717 ERR_(local
)("Local heap not found\n");
1718 LOCAL_PrintHeap( CURRENT_DS
);
1721 if (delta
) pInfo
->hdelta
= delta
;
1722 TRACE_(local
)("returning %04x\n", pInfo
->hdelta
);
1723 return pInfo
->hdelta
;
1727 /***********************************************************************
1728 * LocalInfo (TOOLHELP.56)
1730 BOOL16 WINAPI
LocalInfo16( LOCALINFO
*pLocalInfo
, HGLOBAL16 handle
)
1732 LOCALHEAPINFO
*pInfo
= LOCAL_GetHeap(SELECTOROF(WIN16_GlobalLock16(handle
)));
1733 if (!pInfo
) return FALSE
;
1734 pLocalInfo
->wcItems
= pInfo
->items
;
1739 /***********************************************************************
1740 * LocalFirst (TOOLHELP.57)
1742 BOOL16 WINAPI
LocalFirst16( LOCALENTRY
*pLocalEntry
, HGLOBAL16 handle
)
1744 WORD ds
= GlobalHandleToSel16( handle
);
1745 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1746 LOCALHEAPINFO
*pInfo
= LOCAL_GetHeap( ds
);
1747 if (!pInfo
) return FALSE
;
1749 pLocalEntry
->hHandle
= pInfo
->first
+ ARENA_HEADER_SIZE
;
1750 pLocalEntry
->wAddress
= pLocalEntry
->hHandle
;
1751 pLocalEntry
->wFlags
= LF_FIXED
;
1752 pLocalEntry
->wcLock
= 0;
1753 pLocalEntry
->wType
= LT_NORMAL
;
1754 pLocalEntry
->hHeap
= handle
;
1755 pLocalEntry
->wHeapType
= NORMAL_HEAP
;
1756 pLocalEntry
->wNext
= ARENA_PTR(ptr
,pInfo
->first
)->next
;
1757 pLocalEntry
->wSize
= pLocalEntry
->wNext
- pLocalEntry
->hHandle
;
1762 /***********************************************************************
1763 * LocalNext (TOOLHELP.58)
1765 BOOL16 WINAPI
LocalNext16( LOCALENTRY
*pLocalEntry
)
1767 WORD ds
= GlobalHandleToSel16( pLocalEntry
->hHeap
);
1768 char *ptr
= PTR_SEG_OFF_TO_LIN( ds
, 0 );
1771 if (!LOCAL_GetHeap( ds
)) return FALSE
;
1772 if (!pLocalEntry
->wNext
) return FALSE
;
1773 pArena
= ARENA_PTR( ptr
, pLocalEntry
->wNext
);
1775 pLocalEntry
->hHandle
= pLocalEntry
->wNext
+ ARENA_HEADER_SIZE
;
1776 pLocalEntry
->wAddress
= pLocalEntry
->hHandle
;
1777 pLocalEntry
->wFlags
= (pArena
->prev
& 3) + 1;
1778 pLocalEntry
->wcLock
= 0;
1779 pLocalEntry
->wType
= LT_NORMAL
;
1780 if (pArena
->next
!= pLocalEntry
->wNext
) /* last one? */
1781 pLocalEntry
->wNext
= pArena
->next
;
1783 pLocalEntry
->wNext
= 0;
1784 pLocalEntry
->wSize
= pLocalEntry
->wNext
- pLocalEntry
->hHandle
;
1789 /***********************************************************************
1790 * LocalAlloc32 (KERNEL32.371)
1795 HLOCAL WINAPI
LocalAlloc(
1796 UINT flags
, /* [in] Allocation attributes */
1797 DWORD size
/* [in] Number of bytes to allocate */
1799 return (HLOCAL
)GlobalAlloc( flags
, size
);
1803 /***********************************************************************
1804 * LocalCompact32 (KERNEL32.372)
1806 UINT WINAPI
LocalCompact( UINT minfree
)
1808 return 0; /* LocalCompact does nothing in Win32 */
1812 /***********************************************************************
1813 * LocalFlags32 (KERNEL32.374)
1815 * Value specifying allocation flags and lock count.
1816 * LMEM_INVALID_HANDLE: Failure
1818 UINT WINAPI
LocalFlags(
1819 HLOCAL handle
/* [in] Handle of memory object */
1821 return GlobalFlags( (HGLOBAL
)handle
);
1825 /***********************************************************************
1826 * LocalFree32 (KERNEL32.375)
1831 HLOCAL WINAPI
LocalFree(
1832 HLOCAL handle
/* [in] Handle of memory object */
1834 return (HLOCAL
)GlobalFree( (HGLOBAL
)handle
);
1838 /***********************************************************************
1839 * LocalHandle32 (KERNEL32.376)
1844 HLOCAL WINAPI
LocalHandle(
1845 LPCVOID ptr
/* [in] Address of local memory object */
1847 return (HLOCAL
)GlobalHandle( ptr
);
1851 /***********************************************************************
1852 * LocalLock32 (KERNEL32.377)
1853 * Locks a local memory object and returns pointer to the first byte
1854 * of the memory block.
1860 LPVOID WINAPI
LocalLock(
1861 HLOCAL handle
/* [in] Address of local memory object */
1863 return GlobalLock( (HGLOBAL
)handle
);
1867 /***********************************************************************
1868 * LocalReAlloc32 (KERNEL32.378)
1873 HLOCAL WINAPI
LocalReAlloc(
1874 HLOCAL handle
, /* [in] Handle of memory object */
1875 DWORD size
, /* [in] New size of block */
1876 UINT flags
/* [in] How to reallocate object */
1878 return (HLOCAL
)GlobalReAlloc( (HGLOBAL
)handle
, size
, flags
);
1882 /***********************************************************************
1883 * LocalShrink32 (KERNEL32.379)
1885 UINT WINAPI
LocalShrink( HGLOBAL handle
, UINT newsize
)
1887 return 0; /* LocalShrink does nothing in Win32 */
1891 /***********************************************************************
1892 * LocalSize32 (KERNEL32.380)
1897 UINT WINAPI
LocalSize(
1898 HLOCAL handle
/* [in] Handle of memory object */
1900 return GlobalSize( (HGLOBAL
)handle
);
1904 /***********************************************************************
1905 * LocalUnlock32 (KERNEL32.381)
1907 * TRUE: Object is still locked
1908 * FALSE: Object is unlocked
1910 BOOL WINAPI
LocalUnlock(
1911 HLOCAL handle
/* [in] Handle of memory object */
1913 return GlobalUnlock( (HGLOBAL
)handle
);