2 * 16-bit local heap functions
4 * Copyright 1995 Alexandre Julliard
5 * Copyright 1996 Huw Davies
6 * Copyright 1998 Ulrich Weigand
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 * All local heap functions need the current DS as first parameter
26 * when called from the emulation library, so they take one more
27 * parameter than usual.
32 #define NONAMELESSUNION
33 #define NONAMELESSSTRUCT
36 #include "wine/winbase16.h"
42 #include "stackframe.h"
43 #include "selectors.h"
45 #include "wine/debug.h"
47 WINE_DEFAULT_DEBUG_CHANNEL(local
);
52 WORD prev
; /* Previous arena | arena type */
53 WORD next
; /* Next arena */
54 /* Start of the memory block or free-list info */
55 WORD size
; /* Size of the free block */
56 WORD free_prev
; /* Previous free block */
57 WORD free_next
; /* Next free block */
60 #define ARENA_HEADER_SIZE 4
61 #define ARENA_HEADER( handle) ((handle) - ARENA_HEADER_SIZE)
63 /* Arena types (stored in 'prev' field of the arena) */
64 #define LOCAL_ARENA_FREE 0
65 #define LOCAL_ARENA_FIXED 1
67 /* LocalNotify() msgs */
73 /* Layout of a handle entry table
75 * WORD count of entries
76 * LOCALHANDLEENTRY[count] entries
77 * WORD near ptr to next table
81 WORD addr
; /* Address of the MOVEABLE block */
82 BYTE flags
; /* Flags for this block */
83 BYTE lock
; /* Lock count */
87 * We make addr = 4n + 2 and set *((WORD *)addr - 1) = &addr like Windows does
88 * in case something actually relies on this.
89 * Note that if the architecture does not allow unaligned accesses, we make
90 * addr = 4n + 4 to avoid returning unaligned pointers from LocalAlloc etc.
92 * An unused handle has lock = flags = 0xff. In windows addr is that of next
93 * free handle, at the moment in wine we set it to 0.
95 * A discarded block's handle has lock = addr = 0 and flags = 0x40
96 * (LMEM_DISCARDED >> 8)
99 #ifdef ALLOW_UNALIGNED_ACCESS
100 #define MOVEABLE_PREFIX sizeof(HLOCAL16)
102 #define MOVEABLE_PREFIX sizeof(int)
106 #include "pshpack1.h"
110 WORD check
; /* 00 Heap checking flag */
111 WORD freeze
; /* 02 Heap frozen flag */
112 WORD items
; /* 04 Count of items on the heap */
113 WORD first
; /* 06 First item of the heap */
114 WORD pad1
; /* 08 Always 0 */
115 WORD last
; /* 0a Last item of the heap */
116 WORD pad2
; /* 0c Always 0 */
117 BYTE ncompact
; /* 0e Compactions counter */
118 BYTE dislevel
; /* 0f Discard level */
119 DWORD distotal
; /* 10 Total bytes discarded */
120 WORD htable
; /* 14 Pointer to handle table */
121 WORD hfree
; /* 16 Pointer to free handle table */
122 WORD hdelta
; /* 18 Delta to expand the handle table */
123 WORD expand
; /* 1a Pointer to expand function (unused) */
124 WORD pstat
; /* 1c Pointer to status structure (unused) */
125 FARPROC16 notify WINE_PACKED
; /* 1e Pointer to LocalNotify() function */
126 WORD lock
; /* 22 Lock count for the heap */
127 WORD extra
; /* 24 Extra bytes to allocate when expanding */
128 WORD minsize
; /* 26 Minimum size of the heap */
129 WORD magic
; /* 28 Magic number */
134 #define LOCAL_HEAP_MAGIC 0x484c /* 'LH' */
136 /* All local heap allocations are aligned on 4-byte boundaries */
137 #define LALIGN(word) (((word) + 3) & ~3)
139 #define ARENA_PTR(ptr,arena) ((LOCALARENA *)((char*)(ptr)+(arena)))
140 #define ARENA_PREV(ptr,arena) (ARENA_PTR((ptr),(arena))->prev & ~3)
141 #define ARENA_NEXT(ptr,arena) (ARENA_PTR((ptr),(arena))->next)
142 #define ARENA_FLAGS(ptr,arena) (ARENA_PTR((ptr),(arena))->prev & 3)
144 /* determine whether the handle belongs to a fixed or a moveable block */
145 #define HANDLE_FIXED(handle) (((handle) & 3) == 0)
146 #define HANDLE_MOVEABLE(handle) (((handle) & 3) == 2)
149 /* 32-bit heap definitions */
151 #define HTABLE_SIZE 0x10000
152 #define HTABLE_PAGESIZE 0x1000
153 #define HTABLE_NPAGES (HTABLE_SIZE / HTABLE_PAGESIZE)
155 #include "pshpack1.h"
156 typedef struct _LOCAL32HEADER
158 WORD freeListFirst
[HTABLE_NPAGES
];
159 WORD freeListSize
[HTABLE_NPAGES
];
160 WORD freeListLast
[HTABLE_NPAGES
];
162 DWORD selectorTableOffset
;
163 WORD selectorTableSize
;
178 #define LOCAL32_MAGIC ((DWORD)('L' | ('H'<<8) | ('3'<<16) | ('2'<<24)))
181 static inline BOOL16
call_notify_func( FARPROC16 proc
, WORD msg
, HLOCAL16 handle
, WORD arg
)
186 if (!proc
) return FALSE
;
190 WOWCallback16Ex( (DWORD
)proc
, WCB16_PASCAL
, sizeof(args
), args
, &ret
);
195 /***********************************************************************
198 * Return a pointer to the local heap, making sure it exists.
200 static LOCALHEAPINFO
*LOCAL_GetHeap( HANDLE16 ds
)
202 LOCALHEAPINFO
*pInfo
;
203 INSTANCEDATA
*ptr
= MapSL( MAKESEGPTR( ds
, 0 ));
204 TRACE("Heap at %p, %04x\n", ptr
, (ptr
!= NULL
? ptr
->heap
: 0xFFFF));
205 if (!ptr
|| !ptr
->heap
) return NULL
;
206 if (IsBadReadPtr16( (SEGPTR
)MAKELONG(ptr
->heap
,ds
), sizeof(LOCALHEAPINFO
)))
208 WARN("Bad pointer\n");
211 pInfo
= (LOCALHEAPINFO
*)((char*)ptr
+ ptr
->heap
);
212 if (pInfo
->magic
!= LOCAL_HEAP_MAGIC
)
221 /***********************************************************************
222 * LOCAL_MakeBlockFree
224 * Make a block free, inserting it in the free-list.
225 * 'block' is the handle of the block arena; 'baseptr' points to
226 * the beginning of the data segment containing the heap.
228 static void LOCAL_MakeBlockFree( char *baseptr
, WORD block
)
230 LOCALARENA
*pArena
, *pNext
;
233 /* Mark the block as free */
235 pArena
= ARENA_PTR( baseptr
, block
);
236 pArena
->prev
= (pArena
->prev
& ~3) | LOCAL_ARENA_FREE
;
237 pArena
->size
= pArena
->next
- block
;
239 /* Find the next free block (last block is always free) */
244 pNext
= ARENA_PTR( baseptr
, next
);
245 if ((pNext
->prev
& 3) == LOCAL_ARENA_FREE
) break;
249 TRACE("%04x, next %04x\n", block
, next
);
250 /* Insert the free block in the free-list */
252 pArena
->free_prev
= pNext
->free_prev
;
253 pArena
->free_next
= next
;
254 ARENA_PTR(baseptr
,pNext
->free_prev
)->free_next
= block
;
255 pNext
->free_prev
= block
;
259 /***********************************************************************
260 * LOCAL_RemoveFreeBlock
262 * Remove a block from the free-list.
263 * 'block' is the handle of the block arena; 'baseptr' points to
264 * the beginning of the data segment containing the heap.
266 static void LOCAL_RemoveFreeBlock( char *baseptr
, WORD block
)
268 /* Mark the block as fixed */
270 LOCALARENA
*pArena
= ARENA_PTR( baseptr
, block
);
271 pArena
->prev
= (pArena
->prev
& ~3) | LOCAL_ARENA_FIXED
;
273 /* Remove it from the list */
275 ARENA_PTR(baseptr
,pArena
->free_prev
)->free_next
= pArena
->free_next
;
276 ARENA_PTR(baseptr
,pArena
->free_next
)->free_prev
= pArena
->free_prev
;
280 /***********************************************************************
283 * Insert a new block in the heap.
284 * 'new' is the handle of the new block arena; 'baseptr' points to
285 * the beginning of the data segment containing the heap; 'prev' is
286 * the block before the new one.
288 static void LOCAL_AddBlock( char *baseptr
, WORD prev
, WORD
new )
290 LOCALARENA
*pPrev
= ARENA_PTR( baseptr
, prev
);
291 LOCALARENA
*pNew
= ARENA_PTR( baseptr
, new );
293 pNew
->prev
= (prev
& ~3) | LOCAL_ARENA_FIXED
;
294 pNew
->next
= pPrev
->next
;
295 ARENA_PTR(baseptr
,pPrev
->next
)->prev
&= 3;
296 ARENA_PTR(baseptr
,pPrev
->next
)->prev
|= new;
301 /***********************************************************************
304 * Remove a block from the heap.
305 * 'block' is the handle of the block arena; 'baseptr' points to
306 * the beginning of the data segment containing the heap.
308 static void LOCAL_RemoveBlock( char *baseptr
, WORD block
)
310 LOCALARENA
*pArena
, *pTmp
;
312 /* Remove the block from the free-list */
315 pArena
= ARENA_PTR( baseptr
, block
);
316 if ((pArena
->prev
& 3) == LOCAL_ARENA_FREE
)
317 LOCAL_RemoveFreeBlock( baseptr
, block
);
319 /* If the previous block is free, expand its size */
321 pTmp
= ARENA_PTR( baseptr
, pArena
->prev
& ~3 );
322 if ((pTmp
->prev
& 3) == LOCAL_ARENA_FREE
)
323 pTmp
->size
+= pArena
->next
- block
;
325 /* Remove the block from the linked list */
327 pTmp
->next
= pArena
->next
;
328 pTmp
= ARENA_PTR( baseptr
, pArena
->next
);
329 pTmp
->prev
= (pTmp
->prev
& 3) | (pArena
->prev
& ~3);
333 /***********************************************************************
336 static void LOCAL_PrintHeap( HANDLE16 ds
)
339 LOCALHEAPINFO
*pInfo
;
342 /* FIXME - the test should be done when calling the function!
343 plus is not clear that we should print this info
344 only when TRACE_ON is on! */
345 if(!TRACE_ON(local
)) return;
347 ptr
= MapSL( MAKESEGPTR( ds
, 0 ));
348 pInfo
= LOCAL_GetHeap( ds
);
352 DPRINTF( "Local Heap corrupted! ds=%04x\n", ds
);
355 DPRINTF( "Local Heap ds=%04x first=%04x last=%04x items=%d\n",
356 ds
, pInfo
->first
, pInfo
->last
, pInfo
->items
);
358 arena
= pInfo
->first
;
361 LOCALARENA
*pArena
= ARENA_PTR(ptr
,arena
);
362 DPRINTF( " %04x: prev=%04x next=%04x type=%d\n", arena
,
363 pArena
->prev
& ~3, pArena
->next
, pArena
->prev
& 3 );
364 if (arena
== pInfo
->first
)
366 DPRINTF( " size=%d free_prev=%04x free_next=%04x\n",
367 pArena
->size
, pArena
->free_prev
, pArena
->free_next
);
369 if ((pArena
->prev
& 3) == LOCAL_ARENA_FREE
)
371 DPRINTF( " size=%d free_prev=%04x free_next=%04x\n",
372 pArena
->size
, pArena
->free_prev
, pArena
->free_next
);
373 if (pArena
->next
== arena
) break; /* last one */
374 if (ARENA_PTR(ptr
,pArena
->free_next
)->free_prev
!= arena
)
376 DPRINTF( "*** arena->free_next->free_prev != arena\n" );
380 if (pArena
->next
== arena
)
382 DPRINTF( "*** last block is not marked free\n" );
385 if ((ARENA_PTR(ptr
,pArena
->next
)->prev
& ~3) != arena
)
387 DPRINTF( "*** arena->next->prev != arena (%04x, %04x)\n",
388 pArena
->next
, ARENA_PTR(ptr
,pArena
->next
)->prev
);
391 arena
= pArena
->next
;
396 #if 0 /* FIXME: LocalInit16 must still be in ntdll for now */
398 /***********************************************************************
399 * LocalInit (KERNEL.4)
401 BOOL16 WINAPI
LocalInit16( HANDLE16 selector
, WORD start
, WORD end
)
404 WORD heapInfoArena
, freeArena
, lastArena
;
405 LOCALHEAPINFO
*pHeapInfo
;
406 LOCALARENA
*pArena
, *pFirstArena
, *pLastArena
;
410 /* The initial layout of the heap is: */
411 /* - first arena (FIXED) */
412 /* - heap info structure (FIXED) */
413 /* - large free block (FREE) */
414 /* - last arena (FREE) */
416 TRACE("%04x %04x-%04x\n", selector
, start
, end
);
417 if (!selector
) selector
= CURRENT_DS
;
421 /* If TRACE_ON(heap) is set, the global heap blocks are */
422 /* cleared before use, so we can test for double initialization. */
423 if (LOCAL_GetHeap(selector
))
425 ERR("Heap %04x initialized twice.\n", selector
);
426 LOCAL_PrintHeap(selector
);
432 /* start == 0 means: put the local heap at the end of the segment */
434 DWORD size
= GlobalSize16( GlobalHandle16( selector
) );
435 start
= (WORD
)(size
> 0xffff ? 0xffff : size
) - 1;
436 if ( end
> 0xfffe ) end
= 0xfffe;
442 if ((pModule
= NE_GetPtr( GlobalHandle16( selector
) )))
444 SEGTABLEENTRY
*pSeg
= NE_SEG_TABLE( pModule
);
447 for ( segNr
= 0; segNr
< pModule
->seg_count
; segNr
++, pSeg
++ )
448 if ( GlobalHandleToSel16(pSeg
->hSeg
) == selector
)
451 if ( segNr
< pModule
->seg_count
)
453 WORD minsize
= pSeg
->minsize
;
454 if ( pModule
->ss
== segNr
+1 )
455 minsize
+= pModule
->stack_size
;
457 TRACE(" new start %04x, minstart: %04x\n", start
, minsize
);
461 ptr
= MapSL( MAKESEGPTR( selector
, 0 ) );
463 start
= LALIGN( max( start
, sizeof(INSTANCEDATA
) ) );
464 heapInfoArena
= LALIGN(start
+ sizeof(LOCALARENA
) );
465 freeArena
= LALIGN( heapInfoArena
+ ARENA_HEADER_SIZE
466 + sizeof(LOCALHEAPINFO
) );
467 lastArena
= (end
- sizeof(LOCALARENA
)) & ~3;
469 /* Make sure there's enough space. */
471 if (freeArena
+ sizeof(LOCALARENA
) >= lastArena
) goto done
;
473 /* Initialise the first arena */
475 pFirstArena
= ARENA_PTR( ptr
, start
);
476 pFirstArena
->prev
= start
| LOCAL_ARENA_FIXED
;
477 pFirstArena
->next
= heapInfoArena
;
478 pFirstArena
->size
= LALIGN(sizeof(LOCALARENA
));
479 pFirstArena
->free_prev
= start
; /* this one */
480 pFirstArena
->free_next
= freeArena
;
482 /* Initialise the arena of the heap info structure */
484 pArena
= ARENA_PTR( ptr
, heapInfoArena
);
485 pArena
->prev
= start
| LOCAL_ARENA_FIXED
;
486 pArena
->next
= freeArena
;
488 /* Initialise the heap info structure */
490 pHeapInfo
= (LOCALHEAPINFO
*) (ptr
+ heapInfoArena
+ ARENA_HEADER_SIZE
);
491 memset( pHeapInfo
, 0, sizeof(LOCALHEAPINFO
) );
492 pHeapInfo
->items
= 4;
493 pHeapInfo
->first
= start
;
494 pHeapInfo
->last
= lastArena
;
495 pHeapInfo
->htable
= 0;
496 pHeapInfo
->hdelta
= 0x20;
497 pHeapInfo
->extra
= 0x200;
498 pHeapInfo
->minsize
= lastArena
- freeArena
;
499 pHeapInfo
->magic
= LOCAL_HEAP_MAGIC
;
501 /* Initialise the large free block */
503 pArena
= ARENA_PTR( ptr
, freeArena
);
504 pArena
->prev
= heapInfoArena
| LOCAL_ARENA_FREE
;
505 pArena
->next
= lastArena
;
506 pArena
->size
= lastArena
- freeArena
;
507 pArena
->free_prev
= start
;
508 pArena
->free_next
= lastArena
;
510 /* Initialise the last block */
512 pLastArena
= ARENA_PTR( ptr
, lastArena
);
513 pLastArena
->prev
= freeArena
| LOCAL_ARENA_FREE
;
514 pLastArena
->next
= lastArena
; /* this one */
515 pLastArena
->size
= LALIGN(sizeof(LOCALARENA
));
516 pLastArena
->free_prev
= freeArena
;
517 pLastArena
->free_next
= lastArena
; /* this one */
519 /* Store the local heap address in the instance data */
521 ((INSTANCEDATA
*)ptr
)->heap
= heapInfoArena
+ ARENA_HEADER_SIZE
;
522 LOCAL_PrintHeap( selector
);
526 CURRENT_STACK16
->ecx
= ret
; /* must be returned in cx too */
531 /***********************************************************************
534 static BOOL16
LOCAL_GrowHeap( HANDLE16 ds
)
539 LOCALHEAPINFO
*pHeapInfo
;
540 WORD freeArena
, lastArena
;
541 LOCALARENA
*pArena
, *pLastArena
;
544 hseg
= GlobalHandle16( ds
);
545 /* maybe mem allocated by Virtual*() ? */
546 if (!hseg
) return FALSE
;
548 oldsize
= GlobalSize16( hseg
);
549 /* if nothing can be gained, return */
550 if (oldsize
> 0xfff0) return FALSE
;
551 hseg
= GlobalReAlloc16( hseg
, 0x10000, GMEM_FIXED
);
552 ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
553 pHeapInfo
= LOCAL_GetHeap( ds
);
554 if (pHeapInfo
== NULL
) {
555 ERR("Heap not found\n" );
558 end
= GlobalSize16( hseg
);
559 lastArena
= (end
- sizeof(LOCALARENA
)) & ~3;
561 /* Update the HeapInfo */
563 freeArena
= pHeapInfo
->last
;
564 pHeapInfo
->last
= lastArena
;
565 pHeapInfo
->minsize
+= end
- oldsize
;
567 /* grow the old last block */
568 pArena
= ARENA_PTR( ptr
, freeArena
);
569 pArena
->size
= lastArena
- freeArena
;
570 pArena
->next
= lastArena
;
571 pArena
->free_next
= lastArena
;
573 /* Initialise the new last block */
575 pLastArena
= ARENA_PTR( ptr
, lastArena
);
576 pLastArena
->prev
= freeArena
| LOCAL_ARENA_FREE
;
577 pLastArena
->next
= lastArena
; /* this one */
578 pLastArena
->size
= LALIGN(sizeof(LOCALARENA
));
579 pLastArena
->free_prev
= freeArena
;
580 pLastArena
->free_next
= lastArena
; /* this one */
582 /* If block before freeArena is also free then merge them */
583 if((ARENA_PTR(ptr
, (pArena
->prev
& ~3))->prev
& 3) == LOCAL_ARENA_FREE
)
585 LOCAL_RemoveBlock(ptr
, freeArena
);
589 TRACE("Heap expanded\n" );
590 LOCAL_PrintHeap( ds
);
595 /***********************************************************************
598 static HLOCAL16
LOCAL_FreeArena( WORD ds
, WORD arena
)
600 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
601 LOCALHEAPINFO
*pInfo
;
602 LOCALARENA
*pArena
, *pPrev
, *pNext
;
604 TRACE("%04x ds=%04x\n", arena
, ds
);
605 if (!(pInfo
= LOCAL_GetHeap( ds
))) return arena
;
607 pArena
= ARENA_PTR( ptr
, arena
);
608 if ((pArena
->prev
& 3) == LOCAL_ARENA_FREE
)
610 /* shouldn't happen */
611 ERR("Trying to free block %04x twice!\n",
613 LOCAL_PrintHeap( ds
);
617 /* Check if we can merge with the previous block */
619 pPrev
= ARENA_PTR( ptr
, pArena
->prev
& ~3 );
620 pNext
= ARENA_PTR( ptr
, pArena
->next
);
621 if ((pPrev
->prev
& 3) == LOCAL_ARENA_FREE
)
623 arena
= pArena
->prev
& ~3;
625 LOCAL_RemoveBlock( ptr
, pPrev
->next
);
628 else /* Make a new free block */
630 LOCAL_MakeBlockFree( ptr
, arena
);
633 /* Check if we can merge with the next block */
635 if ((pArena
->next
== pArena
->free_next
) &&
636 (pArena
->next
!= pInfo
->last
))
638 LOCAL_RemoveBlock( ptr
, pArena
->next
);
645 /***********************************************************************
648 * Shrink an arena by creating a free block at its end if possible.
649 * 'size' includes the arena header, and must be aligned.
651 static void LOCAL_ShrinkArena( WORD ds
, WORD arena
, WORD size
)
653 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
654 LOCALARENA
*pArena
= ARENA_PTR( ptr
, arena
);
656 if (arena
+ size
+ LALIGN(sizeof(LOCALARENA
)) < pArena
->next
)
658 LOCALHEAPINFO
*pInfo
= LOCAL_GetHeap( ds
);
660 LOCAL_AddBlock( ptr
, arena
, arena
+ size
);
662 LOCAL_FreeArena( ds
, arena
+ size
);
667 /***********************************************************************
668 * LOCAL_GrowArenaDownward
670 * Grow an arena downward by using the previous arena (must be free).
672 static void LOCAL_GrowArenaDownward( WORD ds
, WORD arena
, WORD newsize
)
674 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
675 LOCALHEAPINFO
*pInfo
;
676 LOCALARENA
*pArena
= ARENA_PTR( ptr
, arena
);
677 WORD prevArena
= pArena
->prev
& ~3;
678 LOCALARENA
*pPrevArena
= ARENA_PTR( ptr
, prevArena
);
682 if (!(pInfo
= LOCAL_GetHeap( ds
))) return;
683 offset
= pPrevArena
->size
;
684 size
= pArena
->next
- arena
- ARENA_HEADER_SIZE
;
685 LOCAL_RemoveFreeBlock( ptr
, prevArena
);
686 LOCAL_RemoveBlock( ptr
, arena
);
688 p
= (char *)pPrevArena
+ ARENA_HEADER_SIZE
;
689 while (offset
< size
)
691 memcpy( p
, p
+ offset
, offset
);
695 if (size
) memcpy( p
, p
+ offset
, size
);
696 LOCAL_ShrinkArena( ds
, prevArena
, newsize
);
701 /***********************************************************************
702 * LOCAL_GrowArenaUpward
704 * Grow an arena upward by using the next arena (must be free and big
705 * enough). Newsize includes the arena header and must be aligned.
707 static void LOCAL_GrowArenaUpward( WORD ds
, WORD arena
, WORD newsize
)
709 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
710 LOCALHEAPINFO
*pInfo
;
711 LOCALARENA
*pArena
= ARENA_PTR( ptr
, arena
);
712 WORD nextArena
= pArena
->next
;
714 if (!(pInfo
= LOCAL_GetHeap( ds
))) return;
715 LOCAL_RemoveBlock( ptr
, nextArena
);
717 LOCAL_ShrinkArena( ds
, arena
, newsize
);
721 /***********************************************************************
724 static WORD
LOCAL_GetFreeSpace(WORD ds
, WORD countdiscard
)
726 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
727 LOCALHEAPINFO
*pInfo
;
732 if (!(pInfo
= LOCAL_GetHeap( ds
)))
734 ERR("Local heap not found\n" );
738 arena
= pInfo
->first
;
739 pArena
= ARENA_PTR( ptr
, arena
);
740 while (arena
!= pArena
->free_next
)
742 arena
= pArena
->free_next
;
743 pArena
= ARENA_PTR( ptr
, arena
);
744 if (pArena
->size
>= freespace
) freespace
= pArena
->size
;
746 /* FIXME doesn't yet calculate space that would become free if everything
747 were discarded when countdiscard == 1 */
748 if (freespace
< ARENA_HEADER_SIZE
) freespace
= 0;
749 else freespace
-= ARENA_HEADER_SIZE
;
754 /***********************************************************************
757 WORD
LOCAL_Compact( HANDLE16 ds
, UINT16 minfree
, UINT16 flags
)
759 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
760 LOCALHEAPINFO
*pInfo
;
761 LOCALARENA
*pArena
, *pMoveArena
, *pFinalArena
;
762 WORD arena
, movearena
, finalarena
, table
;
763 WORD count
, movesize
, size
;
765 LOCALHANDLEENTRY
*pEntry
;
767 if (!(pInfo
= LOCAL_GetHeap( ds
)))
769 ERR("Local heap not found\n" );
773 TRACE("ds = %04x, minfree = %04x, flags = %04x\n",
775 freespace
= LOCAL_GetFreeSpace(ds
, minfree
? 0 : 1);
776 if(freespace
>= minfree
|| (flags
& LMEM_NOCOMPACT
))
778 TRACE("Returning %04x.\n", freespace
);
781 TRACE("Compacting heap %04x.\n", ds
);
782 table
= pInfo
->htable
;
785 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ table
+ sizeof(WORD
));
786 for(count
= *(WORD
*)(ptr
+ table
); count
> 0; count
--, pEntry
++)
788 if((pEntry
->lock
== 0) && (pEntry
->flags
!= (LMEM_DISCARDED
>> 8)))
790 /* OK we can move this one if we want */
791 TRACE("handle %04x (block %04x) can be moved.\n",
792 (WORD
)((char *)pEntry
- ptr
), pEntry
->addr
);
793 movearena
= ARENA_HEADER(pEntry
->addr
- MOVEABLE_PREFIX
);
794 pMoveArena
= ARENA_PTR(ptr
, movearena
);
795 movesize
= pMoveArena
->next
- movearena
;
796 arena
= pInfo
->first
;
797 pArena
= ARENA_PTR(ptr
, arena
);
800 /* Try to find the smallest arena that will do, */
801 /* which is below us in memory */
804 arena
= pArena
->free_next
;
805 pArena
= ARENA_PTR(ptr
, arena
);
806 if(arena
>= movearena
)
808 if(arena
== pArena
->free_next
)
810 if((pArena
->size
>= movesize
) && (pArena
->size
< size
))
816 if (finalarena
) /* Actually got somewhere to move */
818 TRACE("Moving it to %04x.\n", finalarena
);
819 pFinalArena
= ARENA_PTR(ptr
, finalarena
);
820 size
= pFinalArena
->size
;
821 LOCAL_RemoveFreeBlock(ptr
, finalarena
);
822 LOCAL_ShrinkArena( ds
, finalarena
, movesize
);
823 /* Copy the arena to it's new location */
824 memcpy((char *)pFinalArena
+ ARENA_HEADER_SIZE
,
825 (char *)pMoveArena
+ ARENA_HEADER_SIZE
,
826 movesize
- ARENA_HEADER_SIZE
);
827 /* Free the old location */
828 LOCAL_FreeArena(ds
, movearena
);
829 call_notify_func(pInfo
->notify
, LN_MOVE
,
830 (WORD
)((char *)pEntry
- ptr
), pEntry
->addr
);
831 /* Update handle table entry */
832 pEntry
->addr
= finalarena
+ ARENA_HEADER_SIZE
+ MOVEABLE_PREFIX
;
834 else if((ARENA_PTR(ptr
, pMoveArena
->prev
& ~3)->prev
& 3)
837 /* Previous arena is free (but < movesize) */
838 /* so we can 'slide' movearena down into it */
839 finalarena
= pMoveArena
->prev
& ~3;
840 LOCAL_GrowArenaDownward( ds
, movearena
, movesize
);
841 /* Update handle table entry */
842 pEntry
->addr
= finalarena
+ ARENA_HEADER_SIZE
+ MOVEABLE_PREFIX
;
846 table
= *(WORD
*)pEntry
;
848 freespace
= LOCAL_GetFreeSpace(ds
, minfree
? 0 : 1);
849 if(freespace
>= minfree
|| (flags
& LMEM_NODISCARD
))
851 TRACE("Returning %04x.\n", freespace
);
855 table
= pInfo
->htable
;
858 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ table
+ sizeof(WORD
));
859 for(count
= *(WORD
*)(ptr
+ table
); count
> 0; count
--, pEntry
++)
861 if(pEntry
->addr
&& pEntry
->lock
== 0 &&
862 (pEntry
->flags
& (LMEM_DISCARDABLE
>> 8)))
864 TRACE("Discarding handle %04x (block %04x).\n",
865 (char *)pEntry
- ptr
, pEntry
->addr
);
866 LOCAL_FreeArena(ds
, ARENA_HEADER(pEntry
->addr
- MOVEABLE_PREFIX
));
867 call_notify_func(pInfo
->notify
, LN_DISCARD
, (char *)pEntry
- ptr
, pEntry
->flags
);
869 pEntry
->flags
= (LMEM_DISCARDED
>> 8);
872 table
= *(WORD
*)pEntry
;
874 return LOCAL_Compact(ds
, 0xffff, LMEM_NODISCARD
);
878 /***********************************************************************
879 * LOCAL_FindFreeBlock
881 static HLOCAL16
LOCAL_FindFreeBlock( HANDLE16 ds
, WORD size
)
883 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
884 LOCALHEAPINFO
*pInfo
;
888 if (!(pInfo
= LOCAL_GetHeap( ds
)))
890 ERR("Local heap not found\n" );
895 arena
= pInfo
->first
;
896 pArena
= ARENA_PTR( ptr
, arena
);
898 arena
= pArena
->free_next
;
899 pArena
= ARENA_PTR( ptr
, arena
);
900 if (arena
== pArena
->free_next
) break;
901 if (pArena
->size
>= size
) return arena
;
903 TRACE("not enough space\n" );
909 /***********************************************************************
912 static const char *get_heap_name( WORD ds
)
914 HINSTANCE16 inst
= LoadLibrary16( "GDI" );
915 if (ds
== GlobalHandleToSel16( inst
))
917 FreeLibrary16( inst
);
920 FreeLibrary16( inst
);
921 inst
= LoadLibrary16( "USER" );
922 if (ds
== GlobalHandleToSel16( inst
))
924 FreeLibrary16( inst
);
927 FreeLibrary16( inst
);
931 /***********************************************************************
933 * The segment may get moved around in this function, so all callers
934 * should reset their pointer variables.
936 static HLOCAL16
LOCAL_GetBlock( HANDLE16 ds
, WORD size
, WORD flags
)
938 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
939 LOCALHEAPINFO
*pInfo
;
943 if (!(pInfo
= LOCAL_GetHeap( ds
)))
945 ERR("Local heap not found\n");
950 size
+= ARENA_HEADER_SIZE
;
951 size
= LALIGN( max( size
, sizeof(LOCALARENA
) ) );
956 /* Find a suitable free block */
957 arena
= LOCAL_FindFreeBlock( ds
, size
);
959 /* no space: try to make some */
960 LOCAL_Compact( ds
, size
, flags
);
961 arena
= LOCAL_FindFreeBlock( ds
, size
);
964 /* still no space: try to grow the segment */
965 if (!(LOCAL_GrowHeap( ds
)))
968 /* FIXME: doesn't work correctly yet */
969 if (call_notify_func(pInfo
->notify
, LN_OUTOFMEM
, ds
- 20, size
)) /* FIXME: "size" correct ? (should indicate bytes needed) */
972 ERR( "not enough space in %s heap %04x for %d bytes\n",
973 get_heap_name(ds
), ds
, size
);
976 ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
977 pInfo
= LOCAL_GetHeap( ds
);
978 arena
= LOCAL_FindFreeBlock( ds
, size
);
981 ERR( "not enough space in %s heap %04x for %d bytes\n",
982 get_heap_name(ds
), ds
, size
);
984 /* FIXME: "size" correct ? (should indicate bytes needed) */
985 if (call_notify_func(pInfo
->notify
, LN_OUTOFMEM
, ds
, size
)) goto notify_done
;
990 /* Make a block out of the free arena */
991 pArena
= ARENA_PTR( ptr
, arena
);
992 TRACE("size = %04x, arena %04x size %04x\n",
993 size
, arena
, pArena
->size
);
994 LOCAL_RemoveFreeBlock( ptr
, arena
);
995 LOCAL_ShrinkArena( ds
, arena
, size
);
997 if (flags
& LMEM_ZEROINIT
)
998 memset((char *)pArena
+ ARENA_HEADER_SIZE
, 0, size
-ARENA_HEADER_SIZE
);
999 return arena
+ ARENA_HEADER_SIZE
;
1003 /***********************************************************************
1006 static BOOL16
LOCAL_NewHTable( HANDLE16 ds
)
1008 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1009 LOCALHEAPINFO
*pInfo
;
1010 LOCALHANDLEENTRY
*pEntry
;
1015 if (!(pInfo
= LOCAL_GetHeap( ds
)))
1017 ERR("Local heap not found\n");
1018 LOCAL_PrintHeap(ds
);
1022 if (!(handle
= LOCAL_GetBlock( ds
, pInfo
->hdelta
* sizeof(LOCALHANDLEENTRY
)
1023 + 2 * sizeof(WORD
), LMEM_FIXED
)))
1025 if (!(ptr
= MapSL( MAKESEGPTR( ds
, 0 ) )))
1026 ERR("ptr == NULL after GetBlock.\n");
1027 if (!(pInfo
= LOCAL_GetHeap( ds
)))
1028 ERR("pInfo == NULL after GetBlock.\n");
1030 /* Fill the entry table */
1032 *(WORD
*)(ptr
+ handle
) = pInfo
->hdelta
;
1033 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
+ sizeof(WORD
));
1034 for (i
= pInfo
->hdelta
; i
> 0; i
--, pEntry
++) {
1035 pEntry
->lock
= pEntry
->flags
= 0xff;
1038 *(WORD
*)pEntry
= pInfo
->htable
;
1039 pInfo
->htable
= handle
;
1044 /***********************************************************************
1045 * LOCAL_GetNewHandleEntry
1047 static HLOCAL16
LOCAL_GetNewHandleEntry( HANDLE16 ds
)
1049 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1050 LOCALHEAPINFO
*pInfo
;
1051 LOCALHANDLEENTRY
*pEntry
= NULL
;
1054 if (!(pInfo
= LOCAL_GetHeap( ds
)))
1056 ERR("Local heap not found\n");
1057 LOCAL_PrintHeap(ds
);
1061 /* Find a free slot in existing tables */
1063 table
= pInfo
->htable
;
1066 WORD count
= *(WORD
*)(ptr
+ table
);
1067 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ table
+ sizeof(WORD
));
1068 for (; count
> 0; count
--, pEntry
++)
1069 if (pEntry
->lock
== 0xff) break;
1071 table
= *(WORD
*)pEntry
;
1074 if (!table
) /* We need to create a new table */
1076 if (!LOCAL_NewHTable( ds
)) return 0;
1077 ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1078 pInfo
= LOCAL_GetHeap( ds
);
1079 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ pInfo
->htable
+ sizeof(WORD
));
1082 /* Now allocate this entry */
1086 TRACE("(%04x): %04x\n",
1087 ds
, ((char *)pEntry
- ptr
) );
1088 return (HLOCAL16
)((char *)pEntry
- ptr
);
1092 /***********************************************************************
1093 * LOCAL_FreeHandleEntry
1095 * Free a handle table entry.
1097 static void LOCAL_FreeHandleEntry( HANDLE16 ds
, HLOCAL16 handle
)
1099 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1100 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1101 LOCALHEAPINFO
*pInfo
;
1103 WORD table
, count
, i
;
1105 if (!(pInfo
= LOCAL_GetHeap( ds
))) return;
1107 /* Find the table where this handle comes from */
1109 pTable
= &pInfo
->htable
;
1112 WORD size
= (*(WORD
*)(ptr
+ *pTable
)) * sizeof(LOCALHANDLEENTRY
);
1113 if ((handle
>= *pTable
+ sizeof(WORD
)) &&
1114 (handle
< *pTable
+ sizeof(WORD
) + size
)) break; /* Found it */
1115 pTable
= (WORD
*)(ptr
+ *pTable
+ sizeof(WORD
) + size
);
1119 ERR("Invalid entry %04x\n", handle
);
1120 LOCAL_PrintHeap( ds
);
1124 /* Make the entry free */
1126 pEntry
->addr
= 0; /* just in case */
1127 pEntry
->lock
= 0xff;
1128 pEntry
->flags
= 0xff;
1129 /* Now check if all entries in this table are free */
1132 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ table
+ sizeof(WORD
));
1133 count
= *(WORD
*)(ptr
+ table
);
1134 for (i
= count
; i
> 0; i
--, pEntry
++) if (pEntry
->lock
!= 0xff) return;
1136 /* Remove the table from the linked list and free it */
1138 TRACE("(%04x): freeing table %04x\n",
1140 *pTable
= *(WORD
*)pEntry
;
1141 LOCAL_FreeArena( ds
, ARENA_HEADER( table
) );
1145 /***********************************************************************
1148 * Implementation of LocalFree().
1150 HLOCAL16
LOCAL_Free( HANDLE16 ds
, HLOCAL16 handle
)
1152 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1154 TRACE("%04x ds=%04x\n", handle
, ds
);
1156 if (!handle
) { WARN("Handle is 0.\n" ); return 0; }
1157 if (HANDLE_FIXED( handle
))
1159 if (!LOCAL_FreeArena( ds
, ARENA_HEADER( handle
) )) return 0; /* OK */
1160 else return handle
; /* couldn't free it */
1164 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1165 if (pEntry
->flags
!= (LMEM_DISCARDED
>> 8))
1167 TRACE("real block at %04x\n",
1169 if (LOCAL_FreeArena( ds
, ARENA_HEADER(pEntry
->addr
- MOVEABLE_PREFIX
) ))
1170 return handle
; /* couldn't free it */
1172 LOCAL_FreeHandleEntry( ds
, handle
);
1178 /***********************************************************************
1181 * Implementation of LocalAlloc().
1184 HLOCAL16
LOCAL_Alloc( HANDLE16 ds
, WORD flags
, WORD size
)
1189 TRACE("%04x %d ds=%04x\n", flags
, size
, ds
);
1191 if(size
> 0 && size
<= 4) size
= 5;
1192 if (flags
& LMEM_MOVEABLE
)
1194 LOCALHANDLEENTRY
*plhe
;
1199 if (!(hmem
= LOCAL_GetBlock( ds
, size
+ MOVEABLE_PREFIX
, flags
)))
1202 else /* We just need to allocate a discarded handle */
1204 if (!(handle
= LOCAL_GetNewHandleEntry( ds
)))
1206 WARN("Couldn't get handle.\n");
1208 LOCAL_FreeArena( ds
, ARENA_HEADER(hmem
) );
1211 ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1212 plhe
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1216 plhe
->addr
= hmem
+ MOVEABLE_PREFIX
;
1217 plhe
->flags
= (BYTE
)((flags
& 0x0f00) >> 8);
1218 *(HLOCAL16
*)(ptr
+ hmem
) = handle
;
1223 plhe
->flags
= LMEM_DISCARDED
>> 8;
1230 handle
= LOCAL_GetBlock( ds
, size
, flags
);
1236 /***********************************************************************
1239 * Implementation of LocalReAlloc().
1241 HLOCAL16
LOCAL_ReAlloc( HANDLE16 ds
, HLOCAL16 handle
, WORD size
, WORD flags
)
1243 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1244 LOCALHEAPINFO
*pInfo
;
1245 LOCALARENA
*pArena
, *pNext
;
1246 LOCALHANDLEENTRY
*pEntry
= NULL
;
1247 WORD arena
, oldsize
;
1248 HLOCAL16 hmem
, blockhandle
;
1251 if (!handle
) return 0;
1252 if(HANDLE_MOVEABLE(handle
) &&
1253 ((LOCALHANDLEENTRY
*)(ptr
+ handle
))->lock
== 0xff) /* An unused handle */
1256 TRACE("%04x %d %04x ds=%04x\n",
1257 handle
, size
, flags
, ds
);
1258 if (!(pInfo
= LOCAL_GetHeap( ds
))) return 0;
1260 if (HANDLE_FIXED( handle
))
1261 blockhandle
= handle
;
1264 pEntry
= (LOCALHANDLEENTRY
*) (ptr
+ handle
);
1265 if(pEntry
->flags
== (LMEM_DISCARDED
>> 8))
1269 WARN("Dicarded block has non-zero addr.\n");
1270 TRACE("ReAllocating discarded block\n");
1271 if(size
<= 4) size
= 5;
1272 if (!(hl
= LOCAL_GetBlock( ds
, size
+ MOVEABLE_PREFIX
, flags
)))
1274 ptr
= MapSL( MAKESEGPTR( ds
, 0 ) ); /* Reload ptr */
1275 pEntry
= (LOCALHANDLEENTRY
*) (ptr
+ handle
);
1276 pEntry
->addr
= hl
+ MOVEABLE_PREFIX
;
1279 *(HLOCAL16
*)(ptr
+ hl
) = handle
;
1282 if (((blockhandle
= pEntry
->addr
- MOVEABLE_PREFIX
) & 3) != 0)
1284 ERR("(%04x,%04x): invalid handle\n",
1288 if (*(HLOCAL16
*)(ptr
+ blockhandle
) != handle
) {
1289 ERR("Back ptr to handle is invalid\n");
1294 if (flags
& LMEM_MODIFY
)
1296 if (HANDLE_MOVEABLE(handle
))
1298 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1299 pEntry
->flags
= (flags
& 0x0f00) >> 8;
1300 TRACE("Changing flags to %x.\n", pEntry
->flags
);
1307 if (flags
& LMEM_MOVEABLE
)
1309 if (HANDLE_FIXED(handle
))
1311 TRACE("Freeing fixed block.\n");
1312 return LOCAL_Free( ds
, handle
);
1314 else /* Moveable block */
1316 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1317 if (pEntry
->lock
== 0)
1319 /* discards moveable blocks */
1320 TRACE("Discarding block\n");
1321 LOCAL_FreeArena(ds
, ARENA_HEADER(pEntry
->addr
- MOVEABLE_PREFIX
));
1323 pEntry
->flags
= (LMEM_DISCARDED
>> 8);
1331 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1332 if (pEntry
->lock
== 0)
1335 return LOCAL_Free( ds
, handle
);
1341 arena
= ARENA_HEADER( blockhandle
);
1342 TRACE("arena is %04x\n", arena
);
1343 pArena
= ARENA_PTR( ptr
, arena
);
1345 if(size
<= 4) size
= 5;
1346 if(HANDLE_MOVEABLE(handle
)) size
+= MOVEABLE_PREFIX
;
1347 oldsize
= pArena
->next
- arena
- ARENA_HEADER_SIZE
;
1348 nextarena
= LALIGN(blockhandle
+ size
);
1350 /* Check for size reduction */
1352 if (nextarena
<= pArena
->next
)
1354 TRACE("size reduction, making new free block\n");
1355 LOCAL_ShrinkArena(ds
, arena
, nextarena
- arena
);
1356 TRACE("returning %04x\n", handle
);
1360 /* Check if the next block is free and large enough */
1362 pNext
= ARENA_PTR( ptr
, pArena
->next
);
1363 if (((pNext
->prev
& 3) == LOCAL_ARENA_FREE
) &&
1364 (nextarena
<= pNext
->next
))
1366 TRACE("size increase, making new free block\n");
1367 LOCAL_GrowArenaUpward(ds
, arena
, nextarena
- arena
);
1368 TRACE("returning %04x\n", handle
);
1372 /* Now we have to allocate a new block, but not if (fixed block or locked
1373 block) and no LMEM_MOVEABLE */
1375 if (!(flags
& LMEM_MOVEABLE
))
1377 if (HANDLE_FIXED(handle
))
1379 ERR("Needed to move fixed block, but LMEM_MOVEABLE not specified.\n");
1384 if(((LOCALHANDLEENTRY
*)(ptr
+ handle
))->lock
!= 0)
1386 ERR("Needed to move locked block, but LMEM_MOVEABLE not specified.\n");
1392 hmem
= LOCAL_GetBlock( ds
, size
, flags
);
1393 ptr
= MapSL( MAKESEGPTR( ds
, 0 )); /* Reload ptr */
1394 if(HANDLE_MOVEABLE(handle
)) /* LOCAL_GetBlock might have triggered */
1395 { /* a compaction, which might in turn have */
1396 blockhandle
= pEntry
->addr
- MOVEABLE_PREFIX
; /* moved the very block we are resizing */
1397 arena
= ARENA_HEADER( blockhandle
); /* thus, we reload arena, too */
1401 /* Remove the block from the heap and try again */
1402 LPSTR buffer
= HeapAlloc( GetProcessHeap(), 0, oldsize
);
1403 if (!buffer
) return 0;
1404 memcpy( buffer
, ptr
+ arena
+ ARENA_HEADER_SIZE
, oldsize
);
1405 LOCAL_FreeArena( ds
, arena
);
1406 if (!(hmem
= LOCAL_GetBlock( ds
, size
, flags
)))
1408 if (!(hmem
= LOCAL_GetBlock( ds
, oldsize
, flags
)))
1410 ERR("Can't restore saved block\n" );
1411 HeapFree( GetProcessHeap(), 0, buffer
);
1416 ptr
= MapSL( MAKESEGPTR( ds
, 0 ) ); /* Reload ptr */
1417 memcpy( ptr
+ hmem
, buffer
, oldsize
);
1418 HeapFree( GetProcessHeap(), 0, buffer
);
1422 memcpy( ptr
+ hmem
, ptr
+ (arena
+ ARENA_HEADER_SIZE
), oldsize
);
1423 LOCAL_FreeArena( ds
, arena
);
1425 if (HANDLE_MOVEABLE( handle
))
1427 TRACE("fixing handle\n");
1428 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1429 pEntry
->addr
= hmem
+ MOVEABLE_PREFIX
;
1430 /* Back ptr should still be correct */
1431 if(*(HLOCAL16
*)(ptr
+ hmem
) != handle
)
1432 ERR("back ptr is invalid.\n");
1435 if (size
== oldsize
) hmem
= 0; /* Realloc failed */
1436 TRACE("returning %04x\n", hmem
);
1441 /***********************************************************************
1442 * LOCAL_InternalLock
1444 static HLOCAL16
LOCAL_InternalLock( LPSTR heap
, HLOCAL16 handle
)
1446 HLOCAL16 old_handle
= handle
;
1448 if (HANDLE_MOVEABLE(handle
))
1450 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(heap
+ handle
);
1451 if (pEntry
->flags
== LMEM_DISCARDED
) return 0;
1452 if (pEntry
->lock
< 0xfe) pEntry
->lock
++;
1453 handle
= pEntry
->addr
;
1455 TRACE("%04x returning %04x\n",
1456 old_handle
, handle
);
1461 /***********************************************************************
1464 void *LOCAL_Lock( HANDLE16 ds
, HLOCAL16 handle
)
1466 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1467 return handle
? ptr
+ LOCAL_InternalLock( ptr
, handle
) : NULL
;
1471 /***********************************************************************
1474 BOOL16
LOCAL_Unlock( HANDLE16 ds
, HLOCAL16 handle
)
1476 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1478 TRACE("%04x\n", handle
);
1479 if (HANDLE_MOVEABLE(handle
))
1481 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1482 if (!pEntry
->lock
|| (pEntry
->lock
== 0xff)) return FALSE
;
1483 /* For moveable block, return the new lock count */
1484 /* (see _Windows_Internals_ p. 197) */
1485 return --pEntry
->lock
;
1491 /***********************************************************************
1494 * Implementation of LocalSize().
1496 WORD
LOCAL_Size( HANDLE16 ds
, HLOCAL16 handle
)
1498 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1501 TRACE("%04x ds=%04x\n", handle
, ds
);
1503 if (!handle
) return 0;
1504 if (HANDLE_MOVEABLE( handle
))
1506 handle
= *(WORD
*)(ptr
+ handle
);
1507 if (!handle
) return 0;
1508 pArena
= ARENA_PTR( ptr
, ARENA_HEADER(handle
- MOVEABLE_PREFIX
) );
1511 pArena
= ARENA_PTR( ptr
, ARENA_HEADER(handle
) );
1513 return pArena
->next
- handle
;
1517 /***********************************************************************
1520 * Implementation of LocalFlags().
1522 WORD
LOCAL_Flags( HANDLE16 ds
, HLOCAL16 handle
)
1524 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1526 if (HANDLE_MOVEABLE(handle
))
1528 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1529 TRACE("(%04x,%04x): returning %04x\n",
1530 ds
, handle
, pEntry
->lock
| (pEntry
->flags
<< 8) );
1531 return pEntry
->lock
| (pEntry
->flags
<< 8);
1535 TRACE("(%04x,%04x): returning 0\n",
1542 /***********************************************************************
1545 * Implementation of LocalHeapSize().
1547 WORD
LOCAL_HeapSize( HANDLE16 ds
)
1549 LOCALHEAPINFO
*pInfo
= LOCAL_GetHeap( ds
);
1550 if (!pInfo
) return 0;
1551 return pInfo
->last
- pInfo
->first
;
1555 /***********************************************************************
1558 * Implementation of LocalCountFree().
1560 WORD
LOCAL_CountFree( HANDLE16 ds
)
1564 LOCALHEAPINFO
*pInfo
;
1565 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1567 if (!(pInfo
= LOCAL_GetHeap( ds
)))
1569 ERR("(%04x): Local heap not found\n", ds
);
1570 LOCAL_PrintHeap( ds
);
1575 arena
= pInfo
->first
;
1576 pArena
= ARENA_PTR( ptr
, arena
);
1579 arena
= pArena
->free_next
;
1580 pArena
= ARENA_PTR( ptr
, arena
);
1581 if (arena
== pArena
->free_next
) break;
1582 total
+= pArena
->size
;
1584 TRACE("(%04x): returning %d\n", ds
, total
);
1589 /***********************************************************************
1592 * Implementation of LocalHandle().
1594 HLOCAL16
LOCAL_Handle( HANDLE16 ds
, WORD addr
)
1596 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1597 LOCALHEAPINFO
*pInfo
;
1600 if (!(pInfo
= LOCAL_GetHeap( ds
)))
1602 ERR("(%04x): Local heap not found\n", ds
);
1603 LOCAL_PrintHeap( ds
);
1607 /* Find the address in the entry tables */
1609 table
= pInfo
->htable
;
1612 WORD count
= *(WORD
*)(ptr
+ table
);
1613 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+table
+sizeof(WORD
));
1614 for (; count
> 0; count
--, pEntry
++)
1615 if (pEntry
->addr
== addr
) return (HLOCAL16
)((char *)pEntry
- ptr
);
1616 table
= *(WORD
*)pEntry
;
1619 return (HLOCAL16
)addr
; /* Fixed block handle is addr */
1623 /***********************************************************************
1624 * LocalAlloc (KERNEL.5)
1626 HLOCAL16 WINAPI
LocalAlloc16( UINT16 flags
, WORD size
)
1628 HLOCAL16 ret
= LOCAL_Alloc( CURRENT_DS
, flags
, size
);
1629 CURRENT_STACK16
->ecx
= ret
; /* must be returned in cx too */
1634 /***********************************************************************
1635 * LocalReAlloc (KERNEL.6)
1637 HLOCAL16 WINAPI
LocalReAlloc16( HLOCAL16 handle
, WORD size
, UINT16 flags
)
1639 return LOCAL_ReAlloc( CURRENT_DS
, handle
, size
, flags
);
1643 /***********************************************************************
1644 * LocalFree (KERNEL.7)
1646 HLOCAL16 WINAPI
LocalFree16( HLOCAL16 handle
)
1648 return LOCAL_Free( CURRENT_DS
, handle
);
1652 /***********************************************************************
1653 * LocalLock (KERNEL.8)
1655 * Note: only the offset part of the pointer is returned by the relay code.
1657 SEGPTR WINAPI
LocalLock16( HLOCAL16 handle
)
1659 WORD ds
= CURRENT_DS
;
1660 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1661 return MAKESEGPTR( ds
, LOCAL_InternalLock( ptr
, handle
) );
1665 /***********************************************************************
1666 * LocalUnlock (KERNEL.9)
1668 BOOL16 WINAPI
LocalUnlock16( HLOCAL16 handle
)
1670 return LOCAL_Unlock( CURRENT_DS
, handle
);
1674 /***********************************************************************
1675 * LocalSize (KERNEL.10)
1677 UINT16 WINAPI
LocalSize16( HLOCAL16 handle
)
1679 return LOCAL_Size( CURRENT_DS
, handle
);
1683 /***********************************************************************
1684 * LocalHandle (KERNEL.11)
1686 HLOCAL16 WINAPI
LocalHandle16( WORD addr
)
1688 return LOCAL_Handle( CURRENT_DS
, addr
);
1692 /***********************************************************************
1693 * LocalFlags (KERNEL.12)
1695 UINT16 WINAPI
LocalFlags16( HLOCAL16 handle
)
1697 return LOCAL_Flags( CURRENT_DS
, handle
);
1701 /***********************************************************************
1702 * LocalCompact (KERNEL.13)
1704 UINT16 WINAPI
LocalCompact16( UINT16 minfree
)
1706 TRACE("%04x\n", minfree
);
1707 return LOCAL_Compact( CURRENT_DS
, minfree
, 0 );
1711 /***********************************************************************
1712 * LocalNotify (KERNEL.14)
1714 * Installs a callback function that is called for local memory events
1715 * Callback function prototype is
1716 * BOOL16 NotifyFunc(WORD wMsg, HLOCAL16 hMem, WORD wArg)
1719 * NotifyFunc seems to be responsible for allocating some memory,
1720 * returns TRUE for success.
1721 * wArg = number of bytes needed additionally
1723 * hMem = handle; wArg = old mem location
1725 * NotifyFunc seems to be strongly encouraged to return TRUE,
1726 * otherwise LogError() gets called.
1727 * hMem = handle; wArg = flags
1729 FARPROC16 WINAPI
LocalNotify16( FARPROC16 func
)
1731 LOCALHEAPINFO
*pInfo
;
1732 FARPROC16 oldNotify
;
1733 HANDLE16 ds
= CURRENT_DS
;
1735 if (!(pInfo
= LOCAL_GetHeap( ds
)))
1737 ERR("(%04x): Local heap not found\n", ds
);
1738 LOCAL_PrintHeap( ds
);
1741 TRACE("(%04x): %08lx\n", ds
, (DWORD
)func
);
1742 FIXME("Half implemented\n");
1743 oldNotify
= pInfo
->notify
;
1744 pInfo
->notify
= func
;
1749 /***********************************************************************
1750 * LocalShrink (KERNEL.121)
1752 UINT16 WINAPI
LocalShrink16( HGLOBAL16 handle
, UINT16 newsize
)
1754 TRACE("%04x %04x\n", handle
, newsize
);
1759 /***********************************************************************
1760 * GetHeapSpaces (KERNEL.138)
1762 DWORD WINAPI
GetHeapSpaces16( HMODULE16 module
)
1767 if (!(pModule
= NE_GetPtr( module
))) return 0;
1769 GlobalHandleToSel16((NE_SEG_TABLE( pModule
) + pModule
->dgroup
- 1)->hSeg
);
1770 return MAKELONG( LOCAL_CountFree( ds
), LOCAL_HeapSize( ds
) );
1774 /***********************************************************************
1775 * LocalCountFree (KERNEL.161)
1777 WORD WINAPI
LocalCountFree16(void)
1779 return LOCAL_CountFree( CURRENT_DS
);
1783 /***********************************************************************
1784 * LocalHeapSize (KERNEL.162)
1786 WORD WINAPI
LocalHeapSize16(void)
1789 return LOCAL_HeapSize( CURRENT_DS
);
1793 /***********************************************************************
1794 * LocalHandleDelta (KERNEL.310)
1796 WORD WINAPI
LocalHandleDelta16( WORD delta
)
1798 LOCALHEAPINFO
*pInfo
;
1800 if (!(pInfo
= LOCAL_GetHeap( CURRENT_DS
)))
1802 ERR("Local heap not found\n");
1803 LOCAL_PrintHeap( CURRENT_DS
);
1806 if (delta
) pInfo
->hdelta
= delta
;
1807 TRACE("returning %04x\n", pInfo
->hdelta
);
1808 return pInfo
->hdelta
;
1812 /***********************************************************************
1813 * LocalInfo (TOOLHELP.56)
1815 BOOL16 WINAPI
LocalInfo16( LOCALINFO
*pLocalInfo
, HGLOBAL16 handle
)
1817 LOCALHEAPINFO
*pInfo
= LOCAL_GetHeap(SELECTOROF(K32WOWGlobalLock16(handle
)));
1818 if (!pInfo
) return FALSE
;
1819 pLocalInfo
->wcItems
= pInfo
->items
;
1824 /***********************************************************************
1825 * LocalFirst (TOOLHELP.57)
1827 BOOL16 WINAPI
LocalFirst16( LOCALENTRY
*pLocalEntry
, HGLOBAL16 handle
)
1829 WORD ds
= GlobalHandleToSel16( handle
);
1830 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1831 LOCALHEAPINFO
*pInfo
= LOCAL_GetHeap( ds
);
1832 if (!pInfo
) return FALSE
;
1834 pLocalEntry
->hHandle
= pInfo
->first
+ ARENA_HEADER_SIZE
;
1835 pLocalEntry
->wAddress
= pLocalEntry
->hHandle
;
1836 pLocalEntry
->wFlags
= LF_FIXED
;
1837 pLocalEntry
->wcLock
= 0;
1838 pLocalEntry
->wType
= LT_NORMAL
;
1839 pLocalEntry
->hHeap
= handle
;
1840 pLocalEntry
->wHeapType
= NORMAL_HEAP
;
1841 pLocalEntry
->wNext
= ARENA_PTR(ptr
,pInfo
->first
)->next
;
1842 pLocalEntry
->wSize
= pLocalEntry
->wNext
- pLocalEntry
->hHandle
;
1847 /***********************************************************************
1848 * LocalNext (TOOLHELP.58)
1850 BOOL16 WINAPI
LocalNext16( LOCALENTRY
*pLocalEntry
)
1852 WORD ds
= GlobalHandleToSel16( pLocalEntry
->hHeap
);
1853 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1856 if (!LOCAL_GetHeap( ds
)) return FALSE
;
1857 if (!pLocalEntry
->wNext
) return FALSE
;
1858 pArena
= ARENA_PTR( ptr
, pLocalEntry
->wNext
);
1860 pLocalEntry
->hHandle
= pLocalEntry
->wNext
+ ARENA_HEADER_SIZE
;
1861 pLocalEntry
->wAddress
= pLocalEntry
->hHandle
;
1862 pLocalEntry
->wFlags
= (pArena
->prev
& 3) + 1;
1863 pLocalEntry
->wcLock
= 0;
1864 pLocalEntry
->wType
= LT_NORMAL
;
1865 if (pArena
->next
!= pLocalEntry
->wNext
) /* last one? */
1866 pLocalEntry
->wNext
= pArena
->next
;
1868 pLocalEntry
->wNext
= 0;
1869 pLocalEntry
->wSize
= pLocalEntry
->wNext
- pLocalEntry
->hHandle
;
1874 /***********************************************************************
1875 * 32-bit local heap functions (Win95; undocumented)
1878 /***********************************************************************
1881 HANDLE WINAPI
Local32Init16( WORD segment
, DWORD tableSize
,
1882 DWORD heapSize
, DWORD flags
)
1884 DWORD totSize
, segSize
= 0;
1886 LOCAL32HEADER
*header
;
1888 WORD
*selectorTable
;
1889 WORD selectorEven
, selectorOdd
;
1892 /* Determine new heap size */
1896 if ( (segSize
= GetSelectorLimit16( segment
)) == 0 )
1902 if ( heapSize
== -1L )
1903 heapSize
= 1024L*1024L; /* FIXME */
1905 heapSize
= (heapSize
+ 0xffff) & 0xffff0000;
1906 segSize
= (segSize
+ 0x0fff) & 0xfffff000;
1907 totSize
= segSize
+ HTABLE_SIZE
+ heapSize
;
1910 /* Allocate memory and initialize heap */
1912 if ( !(base
= VirtualAlloc( NULL
, totSize
, MEM_RESERVE
, PAGE_READWRITE
)) )
1915 if ( !VirtualAlloc( base
, segSize
+ HTABLE_PAGESIZE
,
1916 MEM_COMMIT
, PAGE_READWRITE
) )
1918 VirtualFree( base
, 0, MEM_RELEASE
);
1922 if (!(heap
= RtlCreateHeap( 0, base
+ segSize
+ HTABLE_SIZE
, heapSize
, 0x10000, NULL
, NULL
)))
1924 VirtualFree( base
, 0, MEM_RELEASE
);
1929 /* Set up header and handle table */
1931 header
= (LOCAL32HEADER
*)(base
+ segSize
);
1932 header
->base
= base
;
1933 header
->limit
= HTABLE_PAGESIZE
-1;
1935 header
->magic
= LOCAL32_MAGIC
;
1936 header
->heap
= heap
;
1938 header
->freeListFirst
[0] = sizeof(LOCAL32HEADER
);
1939 header
->freeListLast
[0] = HTABLE_PAGESIZE
- 4;
1940 header
->freeListSize
[0] = (HTABLE_PAGESIZE
- sizeof(LOCAL32HEADER
)) / 4;
1942 for (i
= header
->freeListFirst
[0]; i
< header
->freeListLast
[0]; i
+= 4)
1943 *(DWORD
*)((LPBYTE
)header
+ i
) = i
+4;
1945 header
->freeListFirst
[1] = 0xffff;
1948 /* Set up selector table */
1950 nrBlocks
= (totSize
+ 0x7fff) >> 15;
1951 selectorTable
= (LPWORD
) HeapAlloc( header
->heap
, 0, nrBlocks
* 2 );
1952 selectorEven
= SELECTOR_AllocBlock( base
, totSize
, WINE_LDT_FLAGS_DATA
);
1953 selectorOdd
= SELECTOR_AllocBlock( base
+ 0x8000, totSize
- 0x8000, WINE_LDT_FLAGS_DATA
);
1954 if ( !selectorTable
|| !selectorEven
|| !selectorOdd
)
1956 if ( selectorTable
) HeapFree( header
->heap
, 0, selectorTable
);
1957 if ( selectorEven
) SELECTOR_FreeBlock( selectorEven
);
1958 if ( selectorOdd
) SELECTOR_FreeBlock( selectorOdd
);
1959 HeapDestroy( header
->heap
);
1960 VirtualFree( base
, 0, MEM_RELEASE
);
1964 header
->selectorTableOffset
= (LPBYTE
)selectorTable
- header
->base
;
1965 header
->selectorTableSize
= nrBlocks
* 4; /* ??? Win95 does it this way! */
1966 header
->selectorDelta
= selectorEven
- selectorOdd
;
1967 header
->segment
= segment
? segment
: selectorEven
;
1969 for (i
= 0; i
< nrBlocks
; i
++)
1970 selectorTable
[i
] = (i
& 1)? selectorOdd
+ ((i
>> 1) << __AHSHIFT
)
1971 : selectorEven
+ ((i
>> 1) << __AHSHIFT
);
1973 /* Move old segment */
1977 /* FIXME: This is somewhat ugly and relies on implementation
1978 details about 16-bit global memory handles ... */
1980 LPBYTE oldBase
= (LPBYTE
)GetSelectorBase( segment
);
1981 memcpy( base
, oldBase
, segSize
);
1982 GLOBAL_MoveBlock( segment
, base
, totSize
);
1983 HeapFree( GetProcessHeap(), 0, oldBase
);
1986 return (HANDLE
)header
;
1989 /***********************************************************************
1990 * Local32_SearchHandle
1992 static LPDWORD
Local32_SearchHandle( LOCAL32HEADER
*header
, DWORD addr
)
1996 for ( handle
= (LPDWORD
)((LPBYTE
)header
+ sizeof(LOCAL32HEADER
));
1997 handle
< (LPDWORD
)((LPBYTE
)header
+ header
->limit
);
2000 if (*handle
== addr
)
2007 /***********************************************************************
2010 static VOID
Local32_ToHandle( LOCAL32HEADER
*header
, INT16 type
,
2011 DWORD addr
, LPDWORD
*handle
, LPBYTE
*ptr
)
2018 case -2: /* 16:16 pointer, no handles */
2019 *ptr
= MapSL( addr
);
2020 *handle
= (LPDWORD
)*ptr
;
2023 case -1: /* 32-bit offset, no handles */
2024 *ptr
= header
->base
+ addr
;
2025 *handle
= (LPDWORD
)*ptr
;
2028 case 0: /* handle */
2029 if ( addr
>= sizeof(LOCAL32HEADER
)
2030 && addr
< header
->limit
&& !(addr
& 3)
2031 && *(LPDWORD
)((LPBYTE
)header
+ addr
) >= HTABLE_SIZE
)
2033 *handle
= (LPDWORD
)((LPBYTE
)header
+ addr
);
2034 *ptr
= header
->base
+ **handle
;
2038 case 1: /* 16:16 pointer */
2039 *ptr
= MapSL( addr
);
2040 *handle
= Local32_SearchHandle( header
, *ptr
- header
->base
);
2043 case 2: /* 32-bit offset */
2044 *ptr
= header
->base
+ addr
;
2045 *handle
= Local32_SearchHandle( header
, *ptr
- header
->base
);
2050 /***********************************************************************
2051 * Local32_FromHandle
2053 static VOID
Local32_FromHandle( LOCAL32HEADER
*header
, INT16 type
,
2054 DWORD
*addr
, LPDWORD handle
, LPBYTE ptr
)
2058 case -2: /* 16:16 pointer */
2061 WORD
*selTable
= (LPWORD
)(header
->base
+ header
->selectorTableOffset
);
2062 DWORD offset
= (LPBYTE
)ptr
- header
->base
;
2063 *addr
= MAKELONG( offset
& 0x7fff, selTable
[offset
>> 15] );
2067 case -1: /* 32-bit offset */
2069 *addr
= ptr
- header
->base
;
2072 case 0: /* handle */
2073 *addr
= (LPBYTE
)handle
- (LPBYTE
)header
;
2078 /***********************************************************************
2081 DWORD WINAPI
Local32Alloc16( HANDLE heap
, DWORD size
, INT16 type
, DWORD flags
)
2083 LOCAL32HEADER
*header
= (LOCAL32HEADER
*)heap
;
2088 /* Allocate memory */
2089 ptr
= HeapAlloc( header
->heap
,
2090 (flags
& LMEM_MOVEABLE
)? HEAP_ZERO_MEMORY
: 0, size
);
2094 /* Allocate handle if requested */
2099 /* Find first page of handle table with free slots */
2100 for (page
= 0; page
< HTABLE_NPAGES
; page
++)
2101 if (header
->freeListFirst
[page
] != 0)
2103 if (page
== HTABLE_NPAGES
)
2105 WARN("Out of handles!\n" );
2106 HeapFree( header
->heap
, 0, ptr
);
2110 /* If virgin page, initialize it */
2111 if (header
->freeListFirst
[page
] == 0xffff)
2113 if ( !VirtualAlloc( (LPBYTE
)header
+ (page
<< 12),
2114 0x1000, MEM_COMMIT
, PAGE_READWRITE
) )
2116 WARN("Cannot grow handle table!\n" );
2117 HeapFree( header
->heap
, 0, ptr
);
2121 header
->limit
+= HTABLE_PAGESIZE
;
2123 header
->freeListFirst
[page
] = 0;
2124 header
->freeListLast
[page
] = HTABLE_PAGESIZE
- 4;
2125 header
->freeListSize
[page
] = HTABLE_PAGESIZE
/ 4;
2127 for (i
= 0; i
< HTABLE_PAGESIZE
; i
+= 4)
2128 *(DWORD
*)((LPBYTE
)header
+ i
) = i
+4;
2130 if (page
< HTABLE_NPAGES
-1)
2131 header
->freeListFirst
[page
+1] = 0xffff;
2134 /* Allocate handle slot from page */
2135 handle
= (LPDWORD
)((LPBYTE
)header
+ header
->freeListFirst
[page
]);
2136 if (--header
->freeListSize
[page
] == 0)
2137 header
->freeListFirst
[page
] = header
->freeListLast
[page
] = 0;
2139 header
->freeListFirst
[page
] = *handle
;
2141 /* Store 32-bit offset in handle slot */
2142 *handle
= ptr
- header
->base
;
2146 handle
= (LPDWORD
)ptr
;
2151 /* Convert handle to requested output type */
2152 Local32_FromHandle( header
, type
, &addr
, handle
, ptr
);
2156 /***********************************************************************
2159 DWORD WINAPI
Local32ReAlloc16( HANDLE heap
, DWORD addr
, INT16 type
,
2160 DWORD size
, DWORD flags
)
2162 LOCAL32HEADER
*header
= (LOCAL32HEADER
*)heap
;
2167 return Local32Alloc16( heap
, size
, type
, flags
);
2169 /* Retrieve handle and pointer */
2170 Local32_ToHandle( header
, type
, addr
, &handle
, &ptr
);
2171 if (!handle
) return FALSE
;
2173 /* Reallocate memory block */
2174 ptr
= HeapReAlloc( header
->heap
,
2175 (flags
& LMEM_MOVEABLE
)? HEAP_ZERO_MEMORY
: 0,
2181 *handle
= ptr
- header
->base
;
2183 handle
= (LPDWORD
)ptr
;
2185 /* Convert handle to requested output type */
2186 Local32_FromHandle( header
, type
, &addr
, handle
, ptr
);
2190 /***********************************************************************
2193 BOOL WINAPI
Local32Free16( HANDLE heap
, DWORD addr
, INT16 type
)
2195 LOCAL32HEADER
*header
= (LOCAL32HEADER
*)heap
;
2199 /* Retrieve handle and pointer */
2200 Local32_ToHandle( header
, type
, addr
, &handle
, &ptr
);
2201 if (!handle
) return FALSE
;
2203 /* Free handle if necessary */
2206 int offset
= (LPBYTE
)handle
- (LPBYTE
)header
;
2207 int page
= offset
>> 12;
2209 /* Return handle slot to page free list */
2210 if (header
->freeListSize
[page
]++ == 0)
2211 header
->freeListFirst
[page
] = header
->freeListLast
[page
] = offset
;
2213 *(LPDWORD
)((LPBYTE
)header
+ header
->freeListLast
[page
]) = offset
,
2214 header
->freeListLast
[page
] = offset
;
2218 /* Shrink handle table when possible */
2219 while (page
> 0 && header
->freeListSize
[page
] == HTABLE_PAGESIZE
/ 4)
2221 if ( VirtualFree( (LPBYTE
)header
+
2222 (header
->limit
& ~(HTABLE_PAGESIZE
-1)),
2223 HTABLE_PAGESIZE
, MEM_DECOMMIT
) )
2226 header
->limit
-= HTABLE_PAGESIZE
;
2227 header
->freeListFirst
[page
] = 0xffff;
2233 return HeapFree( header
->heap
, 0, ptr
);
2236 /***********************************************************************
2239 DWORD WINAPI
Local32Translate16( HANDLE heap
, DWORD addr
, INT16 type1
, INT16 type2
)
2241 LOCAL32HEADER
*header
= (LOCAL32HEADER
*)heap
;
2245 Local32_ToHandle( header
, type1
, addr
, &handle
, &ptr
);
2246 if (!handle
) return 0;
2248 Local32_FromHandle( header
, type2
, &addr
, handle
, ptr
);
2252 /***********************************************************************
2255 DWORD WINAPI
Local32Size16( HANDLE heap
, DWORD addr
, INT16 type
)
2257 LOCAL32HEADER
*header
= (LOCAL32HEADER
*)heap
;
2261 Local32_ToHandle( header
, type
, addr
, &handle
, &ptr
);
2262 if (!handle
) return 0;
2264 return HeapSize( header
->heap
, 0, ptr
);
2267 /***********************************************************************
2270 BOOL WINAPI
Local32ValidHandle16( HANDLE heap
, WORD addr
)
2272 LOCAL32HEADER
*header
= (LOCAL32HEADER
*)heap
;
2276 Local32_ToHandle( header
, 0, addr
, &handle
, &ptr
);
2277 return handle
!= NULL
;
2280 /***********************************************************************
2283 WORD WINAPI
Local32GetSegment16( HANDLE heap
)
2285 LOCAL32HEADER
*header
= (LOCAL32HEADER
*)heap
;
2286 return header
->segment
;
2289 /***********************************************************************
2292 static LOCAL32HEADER
*Local32_GetHeap( HGLOBAL16 handle
)
2294 WORD selector
= GlobalHandleToSel16( handle
);
2295 DWORD base
= GetSelectorBase( selector
);
2296 DWORD limit
= GetSelectorLimit16( selector
);
2298 /* Hmmm. This is a somewhat stupid heuristic, but Windows 95 does
2301 if ( limit
> 0x10000 && ((LOCAL32HEADER
*)base
)->magic
== LOCAL32_MAGIC
)
2302 return (LOCAL32HEADER
*)base
;
2307 if ( limit
> 0x10000 && ((LOCAL32HEADER
*)base
)->magic
== LOCAL32_MAGIC
)
2308 return (LOCAL32HEADER
*)base
;
2313 /***********************************************************************
2314 * Local32Info (KERNEL.444)
2315 * Local32Info (TOOLHELP.84)
2317 BOOL16 WINAPI
Local32Info16( LOCAL32INFO
*pLocal32Info
, HGLOBAL16 handle
)
2319 PROCESS_HEAP_ENTRY entry
;
2322 LOCAL32HEADER
*header
= Local32_GetHeap( handle
);
2323 if ( !header
) return FALSE
;
2325 if ( !pLocal32Info
|| pLocal32Info
->dwSize
< sizeof(LOCAL32INFO
) )
2328 pLocal32Info
->dwMemReserved
= 0;
2329 pLocal32Info
->dwMemCommitted
= 0;
2330 pLocal32Info
->dwTotalFree
= 0;
2331 pLocal32Info
->dwLargestFreeBlock
= 0;
2333 while (HeapWalk( header
->heap
, &entry
))
2335 if (entry
.wFlags
& PROCESS_HEAP_REGION
)
2337 pLocal32Info
->dwMemReserved
+= entry
.u
.Region
.dwCommittedSize
2338 + entry
.u
.Region
.dwUnCommittedSize
;
2339 pLocal32Info
->dwMemCommitted
= entry
.u
.Region
.dwCommittedSize
;
2341 else if (!(entry
.wFlags
& PROCESS_HEAP_ENTRY_BUSY
))
2343 DWORD size
= entry
.cbData
+ entry
.cbOverhead
;
2344 pLocal32Info
->dwTotalFree
+= size
;
2345 if (size
> pLocal32Info
->dwLargestFreeBlock
) pLocal32Info
->dwLargestFreeBlock
= size
;
2349 pLocal32Info
->dwcFreeHandles
= 0;
2350 for ( i
= 0; i
< HTABLE_NPAGES
; i
++ )
2352 if ( header
->freeListFirst
[i
] == 0xffff ) break;
2353 pLocal32Info
->dwcFreeHandles
+= header
->freeListSize
[i
];
2355 pLocal32Info
->dwcFreeHandles
+= (HTABLE_NPAGES
- i
) * HTABLE_PAGESIZE
/4;
2360 /***********************************************************************
2361 * Local32First (KERNEL.445)
2362 * Local32First (TOOLHELP.85)
2364 BOOL16 WINAPI
Local32First16( LOCAL32ENTRY
*pLocal32Entry
, HGLOBAL16 handle
)
2366 FIXME("(%p, %04X): stub!\n", pLocal32Entry
, handle
);
2370 /***********************************************************************
2371 * Local32Next (KERNEL.446)
2372 * Local32Next (TOOLHELP.86)
2374 BOOL16 WINAPI
Local32Next16( LOCAL32ENTRY
*pLocal32Entry
)
2376 FIXME("(%p): stub!\n", pLocal32Entry
);