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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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"
39 #include "kernel_private.h"
40 #include "kernel16_private.h"
41 #include "wine/debug.h"
43 WINE_DEFAULT_DEBUG_CHANNEL(local
);
48 WORD prev
; /* Previous arena | arena type */
49 WORD next
; /* Next arena */
50 /* Start of the memory block or free-list info */
51 WORD size
; /* Size of the free block */
52 WORD free_prev
; /* Previous free block */
53 WORD free_next
; /* Next free block */
56 #define ARENA_HEADER_SIZE 4
57 #define ARENA_HEADER( handle) ((handle) - ARENA_HEADER_SIZE)
59 /* Arena types (stored in 'prev' field of the arena) */
60 #define LOCAL_ARENA_FREE 0
61 #define LOCAL_ARENA_FIXED 1
63 /* LocalNotify() msgs */
69 /* Layout of a handle entry table
71 * WORD count of entries
72 * LOCALHANDLEENTRY[count] entries
73 * WORD near ptr to next table
77 WORD addr
; /* Address of the MOVEABLE block */
78 BYTE flags
; /* Flags for this block */
79 BYTE lock
; /* Lock count */
83 * We make addr = 4n + 2 and set *((WORD *)addr - 1) = &addr like Windows does
84 * in case something actually relies on this.
85 * Note that if the architecture does not allow unaligned accesses, we make
86 * addr = 4n + 4 to avoid returning unaligned pointers from LocalAlloc etc.
88 * An unused handle has lock = flags = 0xff. In windows addr is that of next
89 * free handle, at the moment in wine we set it to 0.
91 * A discarded block's handle has lock = addr = 0 and flags = 0x40
92 * (LMEM_DISCARDED >> 8)
95 #ifdef ALLOW_UNALIGNED_ACCESS
96 # define MOVEABLE_PREFIX sizeof(HLOCAL16)
98 # define MOVEABLE_PREFIX sizeof(int)
102 #include "pshpack1.h"
106 WORD check
; /* 00 Heap checking flag */
107 WORD freeze
; /* 02 Heap frozen flag */
108 WORD items
; /* 04 Count of items on the heap */
109 WORD first
; /* 06 First item of the heap */
110 WORD pad1
; /* 08 Always 0 */
111 WORD last
; /* 0a Last item of the heap */
112 WORD pad2
; /* 0c Always 0 */
113 BYTE ncompact
; /* 0e Compactions counter */
114 BYTE dislevel
; /* 0f Discard level */
115 DWORD distotal
; /* 10 Total bytes discarded */
116 WORD htable
; /* 14 Pointer to handle table */
117 WORD hfree
; /* 16 Pointer to free handle table */
118 WORD hdelta
; /* 18 Delta to expand the handle table */
119 WORD expand
; /* 1a Pointer to expand function (unused) */
120 WORD pstat
; /* 1c Pointer to status structure (unused) */
121 FARPROC16 notify
; /* 1e Pointer to LocalNotify() function */
122 WORD lock
; /* 22 Lock count for the heap */
123 WORD extra
; /* 24 Extra bytes to allocate when expanding */
124 WORD minsize
; /* 26 Minimum size of the heap */
125 WORD magic
; /* 28 Magic number */
130 DWORD dwSize
; /* 00 */
131 DWORD dwMemReserved
; /* 04 */
132 DWORD dwMemCommitted
; /* 08 */
133 DWORD dwTotalFree
; /* 0C */
134 DWORD dwLargestFreeBlock
; /* 10 */
135 DWORD dwcFreeHandles
; /* 14 */
140 DWORD dwSize
; /* 00 */
141 WORD hHandle
; /* 04 */
142 DWORD dwAddress
; /* 06 */
143 DWORD dwSizeBlock
; /* 0A */
144 WORD wFlags
; /* 0E */
147 WORD wHeapType
; /* 14 */
148 DWORD dwNext
; /* 16 */
149 DWORD dwNextAlt
; /* 1A */
154 #define LOCAL_HEAP_MAGIC 0x484c /* 'LH' */
156 /* All local heap allocations are aligned on 4-byte boundaries */
157 #define LALIGN(word) (((word) + 3) & ~3)
159 #define ARENA_PTR(ptr,arena) ((LOCALARENA *)((char *)(ptr)+(arena)))
160 #define ARENA_PREV(ptr,arena) (ARENA_PTR((ptr),(arena))->prev & ~3)
161 #define ARENA_NEXT(ptr,arena) (ARENA_PTR((ptr),(arena))->next)
162 #define ARENA_FLAGS(ptr,arena) (ARENA_PTR((ptr),(arena))->prev & 3)
164 /* determine whether the handle belongs to a fixed or a moveable block */
165 #define HANDLE_FIXED(handle) (((handle) & 3) == 0)
166 #define HANDLE_MOVEABLE(handle) (((handle) & 3) == 2)
169 /* 32-bit heap definitions */
171 #define HTABLE_SIZE 0x10000
172 #define HTABLE_PAGESIZE 0x1000
173 #define HTABLE_NPAGES (HTABLE_SIZE / HTABLE_PAGESIZE)
175 #include "pshpack1.h"
176 typedef struct _LOCAL32HEADER
178 WORD freeListFirst
[HTABLE_NPAGES
];
179 WORD freeListSize
[HTABLE_NPAGES
];
180 WORD freeListLast
[HTABLE_NPAGES
];
182 DWORD selectorTableOffset
;
183 WORD selectorTableSize
;
198 #define LOCAL32_MAGIC ((DWORD)('L' | ('H'<<8) | ('3'<<16) | ('2'<<24)))
201 static inline BOOL16
call_notify_func( FARPROC16 proc
, WORD msg
, HLOCAL16 handle
, WORD arg
)
206 if (!proc
) return FALSE
;
210 WOWCallback16Ex( (DWORD
)proc
, WCB16_PASCAL
, sizeof(args
), args
, &ret
);
215 /***********************************************************************
218 * Return a pointer to the local heap, making sure it exists.
220 static LOCALHEAPINFO
*LOCAL_GetHeap( HANDLE16 ds
)
222 LOCALHEAPINFO
*pInfo
;
223 INSTANCEDATA
*ptr
= MapSL( MAKESEGPTR( ds
, 0 ));
224 TRACE("Heap at %p, %04x\n", ptr
, (ptr
!= NULL
? ptr
->heap
: 0xFFFF));
225 if (!ptr
|| !ptr
->heap
) return NULL
;
226 if (IsBadReadPtr16( (SEGPTR
)MAKELONG(ptr
->heap
,ds
), sizeof(LOCALHEAPINFO
)))
228 WARN("Bad pointer\n");
231 pInfo
= (LOCALHEAPINFO
*)((char*)ptr
+ ptr
->heap
);
232 if (pInfo
->magic
!= LOCAL_HEAP_MAGIC
)
241 /***********************************************************************
242 * LOCAL_MakeBlockFree
244 * Make a block free, inserting it in the free-list.
245 * 'block' is the handle of the block arena; 'baseptr' points to
246 * the beginning of the data segment containing the heap.
248 static void LOCAL_MakeBlockFree( char *baseptr
, WORD block
)
250 LOCALARENA
*pArena
, *pNext
;
253 /* Mark the block as free */
255 pArena
= ARENA_PTR( baseptr
, block
);
256 pArena
->prev
= (pArena
->prev
& ~3) | LOCAL_ARENA_FREE
;
257 pArena
->size
= pArena
->next
- block
;
259 /* Find the next free block (last block is always free) */
264 pNext
= ARENA_PTR( baseptr
, next
);
265 if ((pNext
->prev
& 3) == LOCAL_ARENA_FREE
) break;
269 TRACE("%04x, next %04x\n", block
, next
);
270 /* Insert the free block in the free-list */
272 pArena
->free_prev
= pNext
->free_prev
;
273 pArena
->free_next
= next
;
274 ARENA_PTR(baseptr
,pNext
->free_prev
)->free_next
= block
;
275 pNext
->free_prev
= block
;
279 /***********************************************************************
280 * LOCAL_RemoveFreeBlock
282 * Remove a block from the free-list.
283 * 'block' is the handle of the block arena; 'baseptr' points to
284 * the beginning of the data segment containing the heap.
286 static void LOCAL_RemoveFreeBlock( char *baseptr
, WORD block
)
288 /* Mark the block as fixed */
290 LOCALARENA
*pArena
= ARENA_PTR( baseptr
, block
);
291 pArena
->prev
= (pArena
->prev
& ~3) | LOCAL_ARENA_FIXED
;
293 /* Remove it from the list */
295 ARENA_PTR(baseptr
,pArena
->free_prev
)->free_next
= pArena
->free_next
;
296 ARENA_PTR(baseptr
,pArena
->free_next
)->free_prev
= pArena
->free_prev
;
300 /***********************************************************************
303 * Insert a new block in the heap.
304 * 'new' is the handle of the new block arena; 'baseptr' points to
305 * the beginning of the data segment containing the heap; 'prev' is
306 * the block before the new one.
308 static void LOCAL_AddBlock( char *baseptr
, WORD prev
, WORD
new )
310 LOCALARENA
*pPrev
= ARENA_PTR( baseptr
, prev
);
311 LOCALARENA
*pNew
= ARENA_PTR( baseptr
, new );
313 pNew
->prev
= (prev
& ~3) | LOCAL_ARENA_FIXED
;
314 pNew
->next
= pPrev
->next
;
315 ARENA_PTR(baseptr
,pPrev
->next
)->prev
&= 3;
316 ARENA_PTR(baseptr
,pPrev
->next
)->prev
|= new;
321 /***********************************************************************
324 * Remove a block from the heap.
325 * 'block' is the handle of the block arena; 'baseptr' points to
326 * the beginning of the data segment containing the heap.
328 static void LOCAL_RemoveBlock( char *baseptr
, WORD block
)
330 LOCALARENA
*pArena
, *pTmp
;
332 /* Remove the block from the free-list */
335 pArena
= ARENA_PTR( baseptr
, block
);
336 if ((pArena
->prev
& 3) == LOCAL_ARENA_FREE
)
337 LOCAL_RemoveFreeBlock( baseptr
, block
);
339 /* If the previous block is free, expand its size */
341 pTmp
= ARENA_PTR( baseptr
, pArena
->prev
& ~3 );
342 if ((pTmp
->prev
& 3) == LOCAL_ARENA_FREE
)
343 pTmp
->size
+= pArena
->next
- block
;
345 /* Remove the block from the linked list */
347 pTmp
->next
= pArena
->next
;
348 pTmp
= ARENA_PTR( baseptr
, pArena
->next
);
349 pTmp
->prev
= (pTmp
->prev
& 3) | (pArena
->prev
& ~3);
353 /***********************************************************************
356 static void LOCAL_PrintHeap( HANDLE16 ds
)
359 LOCALHEAPINFO
*pInfo
;
362 /* FIXME - the test should be done when calling the function!
363 plus is not clear that we should print this info
364 only when TRACE_ON is on! */
365 if(!TRACE_ON(local
)) return;
367 ptr
= MapSL( MAKESEGPTR( ds
, 0 ));
368 pInfo
= LOCAL_GetHeap( ds
);
372 ERR( "Local Heap corrupted! ds=%04x\n", ds
);
375 TRACE( "Local Heap ds=%04x first=%04x last=%04x items=%d\n",
376 ds
, pInfo
->first
, pInfo
->last
, pInfo
->items
);
378 arena
= pInfo
->first
;
381 LOCALARENA
*pArena
= ARENA_PTR(ptr
,arena
);
382 TRACE( " %04x: prev=%04x next=%04x type=%d\n", arena
,
383 pArena
->prev
& ~3, pArena
->next
, pArena
->prev
& 3 );
384 if (arena
== pInfo
->first
)
386 TRACE( " size=%d free_prev=%04x free_next=%04x\n",
387 pArena
->size
, pArena
->free_prev
, pArena
->free_next
);
389 if ((pArena
->prev
& 3) == LOCAL_ARENA_FREE
)
391 TRACE( " size=%d free_prev=%04x free_next=%04x\n",
392 pArena
->size
, pArena
->free_prev
, pArena
->free_next
);
393 if (pArena
->next
== arena
) break; /* last one */
394 if (ARENA_PTR(ptr
,pArena
->free_next
)->free_prev
!= arena
)
396 TRACE( "*** arena->free_next->free_prev != arena\n" );
400 if (pArena
->next
== arena
)
402 TRACE( "*** last block is not marked free\n" );
405 if ((ARENA_PTR(ptr
,pArena
->next
)->prev
& ~3) != arena
)
407 TRACE( "*** arena->next->prev != arena (%04x, %04x)\n",
408 pArena
->next
, ARENA_PTR(ptr
,pArena
->next
)->prev
);
411 arena
= pArena
->next
;
416 /***********************************************************************
417 * LocalInit (KERNEL.4)
419 BOOL16 WINAPI
LocalInit16( HANDLE16 selector
, WORD start
, WORD end
)
422 WORD heapInfoArena
, freeArena
, lastArena
;
423 LOCALHEAPINFO
*pHeapInfo
;
424 LOCALARENA
*pArena
, *pFirstArena
, *pLastArena
;
427 /* The initial layout of the heap is: */
428 /* - first arena (FIXED) */
429 /* - heap info structure (FIXED) */
430 /* - large free block (FREE) */
431 /* - last arena (FREE) */
433 TRACE("%04x %04x-%04x\n", selector
, start
, end
);
434 if (!selector
) selector
= CURRENT_DS
;
438 /* If TRACE_ON(local) is set, the global heap blocks are */
439 /* cleared before use, so we can test for double initialization. */
440 if (LOCAL_GetHeap(selector
))
442 ERR("Heap %04x initialized twice.\n", selector
);
443 LOCAL_PrintHeap(selector
);
449 /* start == 0 means: put the local heap at the end of the segment */
451 DWORD size
= GlobalSize16( GlobalHandle16( selector
) );
452 start
= (WORD
)(size
> 0xffff ? 0xffff : size
) - 1;
453 if ( end
> 0xfffe ) end
= 0xfffe;
457 ptr
= MapSL( MAKESEGPTR( selector
, 0 ) );
459 start
= LALIGN( max( start
, sizeof(INSTANCEDATA
) ) );
460 heapInfoArena
= LALIGN(start
+ sizeof(LOCALARENA
) );
461 freeArena
= LALIGN( heapInfoArena
+ ARENA_HEADER_SIZE
462 + sizeof(LOCALHEAPINFO
) );
463 lastArena
= (end
- sizeof(LOCALARENA
)) & ~3;
465 /* Make sure there's enough space. */
467 if (freeArena
+ sizeof(LOCALARENA
) >= lastArena
) goto done
;
469 /* Initialise the first arena */
471 pFirstArena
= ARENA_PTR( ptr
, start
);
472 pFirstArena
->prev
= start
| LOCAL_ARENA_FIXED
;
473 pFirstArena
->next
= heapInfoArena
;
474 pFirstArena
->size
= LALIGN(sizeof(LOCALARENA
));
475 pFirstArena
->free_prev
= start
; /* this one */
476 pFirstArena
->free_next
= freeArena
;
478 /* Initialise the arena of the heap info structure */
480 pArena
= ARENA_PTR( ptr
, heapInfoArena
);
481 pArena
->prev
= start
| LOCAL_ARENA_FIXED
;
482 pArena
->next
= freeArena
;
484 /* Initialise the heap info structure */
486 pHeapInfo
= (LOCALHEAPINFO
*) (ptr
+ heapInfoArena
+ ARENA_HEADER_SIZE
);
487 memset( pHeapInfo
, 0, sizeof(LOCALHEAPINFO
) );
488 pHeapInfo
->items
= 4;
489 pHeapInfo
->first
= start
;
490 pHeapInfo
->last
= lastArena
;
491 pHeapInfo
->htable
= 0;
492 pHeapInfo
->hdelta
= 0x20;
493 pHeapInfo
->extra
= 0x200;
494 pHeapInfo
->minsize
= lastArena
- freeArena
;
495 pHeapInfo
->magic
= LOCAL_HEAP_MAGIC
;
497 /* Initialise the large free block */
499 pArena
= ARENA_PTR( ptr
, freeArena
);
500 pArena
->prev
= heapInfoArena
| LOCAL_ARENA_FREE
;
501 pArena
->next
= lastArena
;
502 pArena
->size
= lastArena
- freeArena
;
503 pArena
->free_prev
= start
;
504 pArena
->free_next
= lastArena
;
506 /* Initialise the last block */
508 pLastArena
= ARENA_PTR( ptr
, lastArena
);
509 pLastArena
->prev
= freeArena
| LOCAL_ARENA_FREE
;
510 pLastArena
->next
= lastArena
; /* this one */
511 pLastArena
->size
= LALIGN(sizeof(LOCALARENA
));
512 pLastArena
->free_prev
= freeArena
;
513 pLastArena
->free_next
= lastArena
; /* this one */
515 /* Store the local heap address in the instance data */
517 ((INSTANCEDATA
*)ptr
)->heap
= heapInfoArena
+ ARENA_HEADER_SIZE
;
518 LOCAL_PrintHeap( selector
);
522 CURRENT_STACK16
->ecx
= ret
; /* must be returned in cx too */
527 /***********************************************************************
530 static BOOL16
LOCAL_GrowHeap( HANDLE16 ds
)
535 LOCALHEAPINFO
*pHeapInfo
;
536 WORD freeArena
, lastArena
;
537 LOCALARENA
*pArena
, *pLastArena
;
540 hseg
= GlobalHandle16( ds
);
541 /* maybe mem allocated by Virtual*() ? */
542 if (!hseg
) return FALSE
;
544 oldsize
= GlobalSize16( hseg
);
545 /* if nothing can be gained, return */
546 if (oldsize
> 0xfff0) return FALSE
;
547 hseg
= GlobalReAlloc16( hseg
, 0x10000, GMEM_FIXED
);
548 ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
549 pHeapInfo
= LOCAL_GetHeap( ds
);
550 if (pHeapInfo
== NULL
) {
551 ERR("Heap not found\n" );
554 end
= GlobalSize16( hseg
);
555 lastArena
= (end
- sizeof(LOCALARENA
)) & ~3;
557 /* Update the HeapInfo */
559 freeArena
= pHeapInfo
->last
;
560 pHeapInfo
->last
= lastArena
;
561 pHeapInfo
->minsize
+= end
- oldsize
;
563 /* grow the old last block */
564 pArena
= ARENA_PTR( ptr
, freeArena
);
565 pArena
->size
= lastArena
- freeArena
;
566 pArena
->next
= lastArena
;
567 pArena
->free_next
= lastArena
;
569 /* Initialise the new last block */
571 pLastArena
= ARENA_PTR( ptr
, lastArena
);
572 pLastArena
->prev
= freeArena
| LOCAL_ARENA_FREE
;
573 pLastArena
->next
= lastArena
; /* this one */
574 pLastArena
->size
= LALIGN(sizeof(LOCALARENA
));
575 pLastArena
->free_prev
= freeArena
;
576 pLastArena
->free_next
= lastArena
; /* this one */
578 /* If block before freeArena is also free then merge them */
579 if((ARENA_PTR(ptr
, (pArena
->prev
& ~3))->prev
& 3) == LOCAL_ARENA_FREE
)
581 LOCAL_RemoveBlock(ptr
, freeArena
);
585 TRACE("Heap expanded\n" );
586 LOCAL_PrintHeap( ds
);
591 /***********************************************************************
594 static HLOCAL16
LOCAL_FreeArena( WORD ds
, WORD arena
)
596 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
597 LOCALHEAPINFO
*pInfo
;
598 LOCALARENA
*pArena
, *pPrev
;
600 TRACE("%04x ds=%04x\n", arena
, ds
);
601 if (!(pInfo
= LOCAL_GetHeap( ds
))) return arena
;
603 pArena
= ARENA_PTR( ptr
, arena
);
604 if ((pArena
->prev
& 3) == LOCAL_ARENA_FREE
)
606 /* shouldn't happen */
607 ERR("Trying to free block %04x twice!\n",
609 LOCAL_PrintHeap( ds
);
613 /* Check if we can merge with the previous block */
615 pPrev
= ARENA_PTR( ptr
, pArena
->prev
& ~3 );
616 if ((pPrev
->prev
& 3) == LOCAL_ARENA_FREE
)
618 arena
= pArena
->prev
& ~3;
620 LOCAL_RemoveBlock( ptr
, pPrev
->next
);
623 else /* Make a new free block */
625 LOCAL_MakeBlockFree( ptr
, arena
);
628 /* Check if we can merge with the next block */
630 if ((pArena
->next
== pArena
->free_next
) &&
631 (pArena
->next
!= pInfo
->last
))
633 LOCAL_RemoveBlock( ptr
, pArena
->next
);
640 /***********************************************************************
643 * Shrink an arena by creating a free block at its end if possible.
644 * 'size' includes the arena header, and must be aligned.
646 static void LOCAL_ShrinkArena( WORD ds
, WORD arena
, WORD size
)
648 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
649 LOCALARENA
*pArena
= ARENA_PTR( ptr
, arena
);
651 if (arena
+ size
+ LALIGN(sizeof(LOCALARENA
)) < pArena
->next
)
653 LOCALHEAPINFO
*pInfo
= LOCAL_GetHeap( ds
);
655 LOCAL_AddBlock( ptr
, arena
, arena
+ size
);
657 LOCAL_FreeArena( ds
, arena
+ size
);
662 /***********************************************************************
663 * LOCAL_GrowArenaDownward
665 * Grow an arena downward by using the previous arena (must be free).
667 static void LOCAL_GrowArenaDownward( WORD ds
, WORD arena
, WORD newsize
)
669 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
670 LOCALHEAPINFO
*pInfo
;
671 LOCALARENA
*pArena
= ARENA_PTR( ptr
, arena
);
672 WORD prevArena
= pArena
->prev
& ~3;
673 LOCALARENA
*pPrevArena
= ARENA_PTR( ptr
, prevArena
);
677 if (!(pInfo
= LOCAL_GetHeap( ds
))) return;
678 offset
= pPrevArena
->size
;
679 size
= pArena
->next
- arena
- ARENA_HEADER_SIZE
;
680 LOCAL_RemoveFreeBlock( ptr
, prevArena
);
681 LOCAL_RemoveBlock( ptr
, arena
);
683 p
= (char *)pPrevArena
+ ARENA_HEADER_SIZE
;
684 while (offset
< size
)
686 memcpy( p
, p
+ offset
, offset
);
690 if (size
) memcpy( p
, p
+ offset
, size
);
691 LOCAL_ShrinkArena( ds
, prevArena
, newsize
);
696 /***********************************************************************
697 * LOCAL_GrowArenaUpward
699 * Grow an arena upward by using the next arena (must be free and big
700 * enough). Newsize includes the arena header and must be aligned.
702 static void LOCAL_GrowArenaUpward( WORD ds
, WORD arena
, WORD newsize
)
704 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
705 LOCALHEAPINFO
*pInfo
;
706 LOCALARENA
*pArena
= ARENA_PTR( ptr
, arena
);
707 WORD nextArena
= pArena
->next
;
709 if (!(pInfo
= LOCAL_GetHeap( ds
))) return;
710 LOCAL_RemoveBlock( ptr
, nextArena
);
712 LOCAL_ShrinkArena( ds
, arena
, newsize
);
716 /***********************************************************************
719 static WORD
LOCAL_GetFreeSpace(WORD ds
, WORD countdiscard
)
721 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
722 LOCALHEAPINFO
*pInfo
;
727 if (!(pInfo
= LOCAL_GetHeap( ds
)))
729 ERR("Local heap not found\n" );
733 arena
= pInfo
->first
;
734 pArena
= ARENA_PTR( ptr
, arena
);
735 while (arena
!= pArena
->free_next
)
737 arena
= pArena
->free_next
;
738 pArena
= ARENA_PTR( ptr
, arena
);
739 if (pArena
->size
>= freespace
) freespace
= pArena
->size
;
741 /* FIXME doesn't yet calculate space that would become free if everything
742 were discarded when countdiscard == 1 */
743 if (freespace
< ARENA_HEADER_SIZE
) freespace
= 0;
744 else freespace
-= ARENA_HEADER_SIZE
;
749 /***********************************************************************
752 static UINT16
LOCAL_Compact( HANDLE16 ds
, UINT16 minfree
, UINT16 flags
)
754 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
755 LOCALHEAPINFO
*pInfo
;
756 LOCALARENA
*pArena
, *pMoveArena
, *pFinalArena
;
757 WORD arena
, movearena
, finalarena
, table
;
758 WORD count
, movesize
, size
;
760 LOCALHANDLEENTRY
*pEntry
;
762 if (!(pInfo
= LOCAL_GetHeap( ds
)))
764 ERR("Local heap not found\n" );
768 TRACE("ds = %04x, minfree = %04x, flags = %04x\n",
770 freespace
= LOCAL_GetFreeSpace(ds
, minfree
? 0 : 1);
771 if(freespace
>= minfree
|| (flags
& LMEM_NOCOMPACT
))
773 TRACE("Returning %04x.\n", freespace
);
776 TRACE("Compacting heap %04x.\n", ds
);
777 table
= pInfo
->htable
;
780 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ table
+ sizeof(WORD
));
781 for(count
= *(WORD
*)(ptr
+ table
); count
> 0; count
--, pEntry
++)
783 if((pEntry
->lock
== 0) && (pEntry
->flags
!= (LMEM_DISCARDED
>> 8)))
785 /* OK we can move this one if we want */
786 TRACE("handle %04x (block %04x) can be moved.\n",
787 (WORD
)((char *)pEntry
- ptr
), pEntry
->addr
);
788 movearena
= ARENA_HEADER(pEntry
->addr
- MOVEABLE_PREFIX
);
789 pMoveArena
= ARENA_PTR(ptr
, movearena
);
790 movesize
= pMoveArena
->next
- movearena
;
791 arena
= pInfo
->first
;
792 pArena
= ARENA_PTR(ptr
, arena
);
795 /* Try to find the smallest arena that will do, */
796 /* which is below us in memory */
799 arena
= pArena
->free_next
;
800 pArena
= ARENA_PTR(ptr
, arena
);
801 if(arena
>= movearena
)
803 if(arena
== pArena
->free_next
)
805 if((pArena
->size
>= movesize
) && (pArena
->size
< size
))
811 if (finalarena
) /* Actually got somewhere to move */
813 TRACE("Moving it to %04x.\n", finalarena
);
814 pFinalArena
= ARENA_PTR(ptr
, finalarena
);
815 size
= pFinalArena
->size
;
816 LOCAL_RemoveFreeBlock(ptr
, finalarena
);
817 LOCAL_ShrinkArena( ds
, finalarena
, movesize
);
818 /* Copy the arena to it's new location */
819 memcpy((char *)pFinalArena
+ ARENA_HEADER_SIZE
,
820 (char *)pMoveArena
+ ARENA_HEADER_SIZE
,
821 movesize
- ARENA_HEADER_SIZE
);
822 /* Free the old location */
823 LOCAL_FreeArena(ds
, movearena
);
824 call_notify_func(pInfo
->notify
, LN_MOVE
,
825 (WORD
)((char *)pEntry
- ptr
), pEntry
->addr
);
826 /* Update handle table entry */
827 pEntry
->addr
= finalarena
+ ARENA_HEADER_SIZE
+ MOVEABLE_PREFIX
;
829 else if((ARENA_PTR(ptr
, pMoveArena
->prev
& ~3)->prev
& 3)
832 /* Previous arena is free (but < movesize) */
833 /* so we can 'slide' movearena down into it */
834 finalarena
= pMoveArena
->prev
& ~3;
835 LOCAL_GrowArenaDownward( ds
, movearena
, movesize
);
836 /* Update handle table entry */
837 pEntry
->addr
= finalarena
+ ARENA_HEADER_SIZE
+ MOVEABLE_PREFIX
;
841 table
= *(WORD
*)pEntry
;
843 freespace
= LOCAL_GetFreeSpace(ds
, minfree
? 0 : 1);
844 if(freespace
>= minfree
|| (flags
& LMEM_NODISCARD
))
846 TRACE("Returning %04x.\n", freespace
);
850 table
= pInfo
->htable
;
853 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ table
+ sizeof(WORD
));
854 for(count
= *(WORD
*)(ptr
+ table
); count
> 0; count
--, pEntry
++)
856 if(pEntry
->addr
&& pEntry
->lock
== 0 &&
857 (pEntry
->flags
& (LMEM_DISCARDABLE
>> 8)))
859 TRACE("Discarding handle %04x (block %04x).\n",
860 (char *)pEntry
- ptr
, pEntry
->addr
);
861 LOCAL_FreeArena(ds
, ARENA_HEADER(pEntry
->addr
- MOVEABLE_PREFIX
));
862 call_notify_func(pInfo
->notify
, LN_DISCARD
, (char *)pEntry
- ptr
, pEntry
->flags
);
864 pEntry
->flags
= (LMEM_DISCARDED
>> 8);
867 table
= *(WORD
*)pEntry
;
869 return LOCAL_Compact(ds
, 0xffff, LMEM_NODISCARD
);
873 /***********************************************************************
874 * LOCAL_FindFreeBlock
876 static HLOCAL16
LOCAL_FindFreeBlock( HANDLE16 ds
, WORD size
)
878 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
879 LOCALHEAPINFO
*pInfo
;
883 if (!(pInfo
= LOCAL_GetHeap( ds
)))
885 ERR("Local heap not found\n" );
890 arena
= pInfo
->first
;
891 pArena
= ARENA_PTR( ptr
, arena
);
893 arena
= pArena
->free_next
;
894 pArena
= ARENA_PTR( ptr
, arena
);
895 if (arena
== pArena
->free_next
) break;
896 if (pArena
->size
>= size
) return arena
;
898 TRACE("not enough space\n" );
904 /***********************************************************************
907 static const char *get_heap_name( WORD ds
)
909 HINSTANCE16 inst
= LoadLibrary16( "GDI" );
910 if (ds
== GlobalHandleToSel16( inst
))
912 FreeLibrary16( inst
);
915 FreeLibrary16( inst
);
916 inst
= LoadLibrary16( "USER" );
917 if (ds
== GlobalHandleToSel16( inst
))
919 FreeLibrary16( inst
);
922 FreeLibrary16( inst
);
926 /***********************************************************************
928 * The segment may get moved around in this function, so all callers
929 * should reset their pointer variables.
931 static HLOCAL16
LOCAL_GetBlock( HANDLE16 ds
, WORD size
, WORD flags
)
933 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
934 LOCALHEAPINFO
*pInfo
;
938 if (!(pInfo
= LOCAL_GetHeap( ds
)))
940 ERR("Local heap not found\n");
945 size
+= ARENA_HEADER_SIZE
;
946 size
= LALIGN( max( size
, sizeof(LOCALARENA
) ) );
951 /* Find a suitable free block */
952 arena
= LOCAL_FindFreeBlock( ds
, size
);
954 /* no space: try to make some */
955 LOCAL_Compact( ds
, size
, flags
);
956 arena
= LOCAL_FindFreeBlock( ds
, size
);
959 /* still no space: try to grow the segment */
960 if (!(LOCAL_GrowHeap( ds
)))
963 /* FIXME: doesn't work correctly yet */
964 if (call_notify_func(pInfo
->notify
, LN_OUTOFMEM
, ds
- 20, size
)) /* FIXME: "size" correct ? (should indicate bytes needed) */
967 ERR( "not enough space in %s heap %04x for %d bytes\n",
968 get_heap_name(ds
), ds
, size
);
971 ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
972 pInfo
= LOCAL_GetHeap( ds
);
973 arena
= LOCAL_FindFreeBlock( ds
, size
);
976 ERR( "not enough space in %s heap %04x for %d bytes\n",
977 get_heap_name(ds
), ds
, size
);
979 /* FIXME: "size" correct ? (should indicate bytes needed) */
980 if (call_notify_func(pInfo
->notify
, LN_OUTOFMEM
, ds
, size
)) goto notify_done
;
985 /* Make a block out of the free arena */
986 pArena
= ARENA_PTR( ptr
, arena
);
987 TRACE("size = %04x, arena %04x size %04x\n", size
, arena
, pArena
->size
);
988 LOCAL_RemoveFreeBlock( ptr
, arena
);
989 LOCAL_ShrinkArena( ds
, arena
, size
);
991 if (flags
& LMEM_ZEROINIT
)
992 memset((char *)pArena
+ ARENA_HEADER_SIZE
, 0, size
-ARENA_HEADER_SIZE
);
993 return arena
+ ARENA_HEADER_SIZE
;
997 /***********************************************************************
1000 static BOOL16
LOCAL_NewHTable( HANDLE16 ds
)
1002 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1003 LOCALHEAPINFO
*pInfo
;
1004 LOCALHANDLEENTRY
*pEntry
;
1009 if (!(pInfo
= LOCAL_GetHeap( ds
)))
1011 ERR("Local heap not found\n");
1012 LOCAL_PrintHeap(ds
);
1016 if (!(handle
= LOCAL_GetBlock( ds
, pInfo
->hdelta
* sizeof(LOCALHANDLEENTRY
)
1017 + 2 * sizeof(WORD
), LMEM_FIXED
)))
1019 if (!(ptr
= MapSL( MAKESEGPTR( ds
, 0 ) )))
1020 ERR("ptr == NULL after GetBlock.\n");
1021 if (!(pInfo
= LOCAL_GetHeap( ds
)))
1022 ERR("pInfo == NULL after GetBlock.\n");
1024 /* Fill the entry table */
1026 *(WORD
*)(ptr
+ handle
) = pInfo
->hdelta
;
1027 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
+ sizeof(WORD
));
1028 for (i
= pInfo
->hdelta
; i
> 0; i
--, pEntry
++) {
1029 pEntry
->lock
= pEntry
->flags
= 0xff;
1032 *(WORD
*)pEntry
= pInfo
->htable
;
1033 pInfo
->htable
= handle
;
1038 /***********************************************************************
1039 * LOCAL_GetNewHandleEntry
1041 static HLOCAL16
LOCAL_GetNewHandleEntry( HANDLE16 ds
)
1043 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1044 LOCALHEAPINFO
*pInfo
;
1045 LOCALHANDLEENTRY
*pEntry
= NULL
;
1048 if (!(pInfo
= LOCAL_GetHeap( ds
)))
1050 ERR("Local heap not found\n");
1051 LOCAL_PrintHeap(ds
);
1055 /* Find a free slot in existing tables */
1057 table
= pInfo
->htable
;
1060 WORD count
= *(WORD
*)(ptr
+ table
);
1061 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ table
+ sizeof(WORD
));
1062 for (; count
> 0; count
--, pEntry
++)
1063 if (pEntry
->lock
== 0xff) break;
1065 table
= *(WORD
*)pEntry
;
1068 if (!table
) /* We need to create a new table */
1070 if (!LOCAL_NewHTable( ds
)) return 0;
1071 ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1072 pInfo
= LOCAL_GetHeap( ds
);
1073 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ pInfo
->htable
+ sizeof(WORD
));
1076 /* Now allocate this entry */
1080 TRACE("(%04x): %04x\n", ds
, ((char *)pEntry
- ptr
) );
1081 return (HLOCAL16
)((char *)pEntry
- ptr
);
1085 /***********************************************************************
1086 * LOCAL_FreeHandleEntry
1088 * Free a handle table entry.
1090 static void LOCAL_FreeHandleEntry( HANDLE16 ds
, HLOCAL16 handle
)
1092 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1093 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1094 LOCALHEAPINFO
*pInfo
;
1096 WORD table
, count
, i
;
1098 if (!(pInfo
= LOCAL_GetHeap( ds
))) return;
1100 /* Find the table where this handle comes from */
1102 pTable
= &pInfo
->htable
;
1105 WORD size
= (*(WORD
*)(ptr
+ *pTable
)) * sizeof(LOCALHANDLEENTRY
);
1106 if ((handle
>= *pTable
+ sizeof(WORD
)) &&
1107 (handle
< *pTable
+ sizeof(WORD
) + size
)) break; /* Found it */
1108 pTable
= (WORD
*)(ptr
+ *pTable
+ sizeof(WORD
) + size
);
1112 ERR("Invalid entry %04x\n", handle
);
1113 LOCAL_PrintHeap( ds
);
1117 /* Make the entry free */
1119 pEntry
->addr
= 0; /* just in case */
1120 pEntry
->lock
= 0xff;
1121 pEntry
->flags
= 0xff;
1122 /* Now check if all entries in this table are free */
1125 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ table
+ sizeof(WORD
));
1126 count
= *(WORD
*)(ptr
+ table
);
1127 for (i
= count
; i
> 0; i
--, pEntry
++) if (pEntry
->lock
!= 0xff) return;
1129 /* Remove the table from the linked list and free it */
1131 TRACE("(%04x): freeing table %04x\n", ds
, table
);
1132 *pTable
= *(WORD
*)pEntry
;
1133 LOCAL_FreeArena( ds
, ARENA_HEADER( table
) );
1137 /***********************************************************************
1138 * LocalFree (KERNEL.7)
1140 HLOCAL16 WINAPI
LocalFree16( HLOCAL16 handle
)
1142 HANDLE16 ds
= CURRENT_DS
;
1143 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1145 TRACE("%04x ds=%04x\n", handle
, ds
);
1147 if (!handle
) { WARN("Handle is 0.\n" ); return 0; }
1148 if (HANDLE_FIXED( handle
))
1150 if (!LOCAL_FreeArena( ds
, ARENA_HEADER( handle
) )) return 0; /* OK */
1151 else return handle
; /* couldn't free it */
1155 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1156 if (pEntry
->flags
!= (LMEM_DISCARDED
>> 8))
1158 TRACE("real block at %04x\n", pEntry
->addr
);
1159 if (LOCAL_FreeArena( ds
, ARENA_HEADER(pEntry
->addr
- MOVEABLE_PREFIX
) ))
1160 return handle
; /* couldn't free it */
1162 LOCAL_FreeHandleEntry( ds
, handle
);
1168 /***********************************************************************
1169 * LocalAlloc (KERNEL.5)
1171 HLOCAL16 WINAPI
LocalAlloc16( UINT16 flags
, WORD size
)
1173 HANDLE16 ds
= CURRENT_DS
;
1174 HLOCAL16 handle
= 0;
1177 TRACE("%04x %d ds=%04x\n", flags
, size
, ds
);
1179 if(size
> 0 && size
<= 4) size
= 5;
1180 if (flags
& LMEM_MOVEABLE
)
1182 LOCALHANDLEENTRY
*plhe
;
1187 if (!(hmem
= LOCAL_GetBlock( ds
, size
+ MOVEABLE_PREFIX
, flags
)))
1190 else /* We just need to allocate a discarded handle */
1192 if (!(handle
= LOCAL_GetNewHandleEntry( ds
)))
1194 WARN("Couldn't get handle.\n");
1196 LOCAL_FreeArena( ds
, ARENA_HEADER(hmem
) );
1199 ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1200 plhe
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1204 plhe
->addr
= hmem
+ MOVEABLE_PREFIX
;
1205 plhe
->flags
= (BYTE
)((flags
& 0x0f00) >> 8);
1206 *(HLOCAL16
*)(ptr
+ hmem
) = handle
;
1211 plhe
->flags
= LMEM_DISCARDED
>> 8;
1216 if(size
) handle
= LOCAL_GetBlock( ds
, size
, flags
);
1220 CURRENT_STACK16
->ecx
= handle
; /* must be returned in cx too */
1225 /***********************************************************************
1226 * LocalReAlloc (KERNEL.6)
1228 HLOCAL16 WINAPI
LocalReAlloc16( HLOCAL16 handle
, WORD size
, UINT16 flags
)
1230 HANDLE16 ds
= CURRENT_DS
;
1231 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1232 LOCALHEAPINFO
*pInfo
;
1233 LOCALARENA
*pArena
, *pNext
;
1234 LOCALHANDLEENTRY
*pEntry
= NULL
;
1235 WORD arena
, oldsize
;
1236 HLOCAL16 hmem
, blockhandle
;
1239 if (!handle
) return 0;
1240 if(HANDLE_MOVEABLE(handle
) &&
1241 ((LOCALHANDLEENTRY
*)(ptr
+ handle
))->lock
== 0xff) /* An unused handle */
1244 TRACE("%04x %d %04x ds=%04x\n", handle
, size
, flags
, ds
);
1245 if (!(pInfo
= LOCAL_GetHeap( ds
))) return 0;
1247 if (HANDLE_FIXED( handle
))
1248 blockhandle
= handle
;
1251 pEntry
= (LOCALHANDLEENTRY
*) (ptr
+ handle
);
1252 if(pEntry
->flags
== (LMEM_DISCARDED
>> 8))
1256 WARN("Dicarded block has non-zero addr.\n");
1257 TRACE("ReAllocating discarded block\n");
1258 if(size
<= 4) size
= 5;
1259 if (!(hl
= LOCAL_GetBlock( ds
, size
+ MOVEABLE_PREFIX
, flags
)))
1261 ptr
= MapSL( MAKESEGPTR( ds
, 0 ) ); /* Reload ptr */
1262 pEntry
= (LOCALHANDLEENTRY
*) (ptr
+ handle
);
1263 pEntry
->addr
= hl
+ MOVEABLE_PREFIX
;
1266 *(HLOCAL16
*)(ptr
+ hl
) = handle
;
1269 if (((blockhandle
= pEntry
->addr
- MOVEABLE_PREFIX
) & 3) != 0)
1271 ERR("(%04x,%04x): invalid handle\n",
1275 if (*(HLOCAL16
*)(ptr
+ blockhandle
) != handle
) {
1276 ERR("Back ptr to handle is invalid\n");
1281 if (flags
& LMEM_MODIFY
)
1283 if (HANDLE_MOVEABLE(handle
))
1285 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1286 pEntry
->flags
= (flags
& 0x0f00) >> 8;
1287 TRACE("Changing flags to %x.\n", pEntry
->flags
);
1294 if (flags
& LMEM_MOVEABLE
)
1296 if (HANDLE_FIXED(handle
))
1298 TRACE("Freeing fixed block.\n");
1299 return LocalFree16( handle
);
1301 else /* Moveable block */
1303 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1304 if (pEntry
->lock
== 0)
1306 /* discards moveable blocks */
1307 TRACE("Discarding block\n");
1308 LOCAL_FreeArena(ds
, ARENA_HEADER(pEntry
->addr
- MOVEABLE_PREFIX
));
1310 pEntry
->flags
= (LMEM_DISCARDED
>> 8);
1318 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1319 if (pEntry
->lock
== 0)
1322 return LocalFree16( handle
);
1328 arena
= ARENA_HEADER( blockhandle
);
1329 TRACE("arena is %04x\n", arena
);
1330 pArena
= ARENA_PTR( ptr
, arena
);
1332 if(size
<= 4) size
= 5;
1333 if(HANDLE_MOVEABLE(handle
)) size
+= MOVEABLE_PREFIX
;
1334 oldsize
= pArena
->next
- arena
- ARENA_HEADER_SIZE
;
1335 nextarena
= LALIGN(blockhandle
+ size
);
1337 /* Check for size reduction */
1339 if (nextarena
<= pArena
->next
)
1341 TRACE("size reduction, making new free block\n");
1342 LOCAL_ShrinkArena(ds
, arena
, nextarena
- arena
);
1343 TRACE("returning %04x\n", handle
);
1347 /* Check if the next block is free and large enough */
1349 pNext
= ARENA_PTR( ptr
, pArena
->next
);
1350 if (((pNext
->prev
& 3) == LOCAL_ARENA_FREE
) &&
1351 (nextarena
<= pNext
->next
))
1353 TRACE("size increase, making new free block\n");
1354 LOCAL_GrowArenaUpward(ds
, arena
, nextarena
- arena
);
1355 if (flags
& LMEM_ZEROINIT
)
1357 char *oldend
= (char *)pArena
+ ARENA_HEADER_SIZE
+ oldsize
;
1358 char *newend
= ptr
+ pArena
->next
;
1359 TRACE("Clearing memory from %p to %p (DS -> %p)\n", oldend
, newend
, ptr
);
1360 memset(oldend
, 0, newend
- oldend
);
1363 TRACE("returning %04x\n", handle
);
1367 /* Now we have to allocate a new block, but not if (fixed block or locked
1368 block) and no LMEM_MOVEABLE */
1370 if (!(flags
& LMEM_MOVEABLE
))
1372 if (HANDLE_FIXED(handle
))
1374 ERR("Needed to move fixed block, but LMEM_MOVEABLE not specified.\n");
1379 if(((LOCALHANDLEENTRY
*)(ptr
+ handle
))->lock
!= 0)
1381 ERR("Needed to move locked block, but LMEM_MOVEABLE not specified.\n");
1387 hmem
= LOCAL_GetBlock( ds
, size
, flags
);
1388 ptr
= MapSL( MAKESEGPTR( ds
, 0 )); /* Reload ptr */
1389 if(HANDLE_MOVEABLE(handle
)) /* LOCAL_GetBlock might have triggered */
1390 { /* a compaction, which might in turn have */
1391 blockhandle
= pEntry
->addr
- MOVEABLE_PREFIX
; /* moved the very block we are resizing */
1392 arena
= ARENA_HEADER( blockhandle
); /* thus, we reload arena, too */
1396 /* Remove the block from the heap and try again */
1397 LPSTR buffer
= HeapAlloc( GetProcessHeap(), 0, oldsize
);
1398 if (!buffer
) return 0;
1399 memcpy( buffer
, ptr
+ arena
+ ARENA_HEADER_SIZE
, oldsize
);
1400 LOCAL_FreeArena( ds
, arena
);
1401 if (!(hmem
= LOCAL_GetBlock( ds
, size
, flags
)))
1403 if (!(hmem
= LOCAL_GetBlock( ds
, oldsize
, flags
)))
1405 ERR("Can't restore saved block\n" );
1406 HeapFree( GetProcessHeap(), 0, buffer
);
1411 ptr
= MapSL( MAKESEGPTR( ds
, 0 ) ); /* Reload ptr */
1412 memcpy( ptr
+ hmem
, buffer
, oldsize
);
1413 HeapFree( GetProcessHeap(), 0, buffer
);
1417 memcpy( ptr
+ hmem
, ptr
+ (arena
+ ARENA_HEADER_SIZE
), oldsize
);
1418 LOCAL_FreeArena( ds
, arena
);
1420 if (HANDLE_MOVEABLE( handle
))
1422 TRACE("fixing handle\n");
1423 pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1424 pEntry
->addr
= hmem
+ MOVEABLE_PREFIX
;
1425 /* Back ptr should still be correct */
1426 if(*(HLOCAL16
*)(ptr
+ hmem
) != handle
)
1427 ERR("back ptr is invalid.\n");
1430 if (size
== oldsize
) hmem
= 0; /* Realloc failed */
1431 TRACE("returning %04x\n", hmem
);
1436 /***********************************************************************
1437 * LOCAL_InternalLock
1439 static HLOCAL16
LOCAL_InternalLock( LPSTR heap
, HLOCAL16 handle
)
1441 HLOCAL16 old_handle
= handle
;
1443 if (HANDLE_MOVEABLE(handle
))
1445 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(heap
+ handle
);
1446 if (pEntry
->flags
== (LMEM_DISCARDED
>> 8)) return 0;
1447 if (pEntry
->lock
< 0xfe) pEntry
->lock
++;
1448 handle
= pEntry
->addr
;
1450 TRACE("%04x returning %04x\n", old_handle
, handle
);
1455 /***********************************************************************
1456 * LocalUnlock (KERNEL.9)
1458 BOOL16 WINAPI
LocalUnlock16( HLOCAL16 handle
)
1460 HANDLE16 ds
= CURRENT_DS
;
1461 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1463 TRACE("%04x\n", handle
);
1464 if (HANDLE_MOVEABLE(handle
))
1466 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1467 if (!pEntry
->lock
|| (pEntry
->lock
== 0xff)) return FALSE
;
1468 /* For moveable block, return the new lock count */
1469 /* (see _Windows_Internals_ p. 197) */
1470 return --pEntry
->lock
;
1476 /***********************************************************************
1477 * LocalSize (KERNEL.10)
1479 UINT16 WINAPI
LocalSize16( HLOCAL16 handle
)
1481 HANDLE16 ds
= CURRENT_DS
;
1482 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1485 TRACE("%04x ds=%04x\n", handle
, ds
);
1487 if (!handle
) return 0;
1488 if (HANDLE_MOVEABLE( handle
))
1490 handle
= *(WORD
*)(ptr
+ handle
);
1491 if (!handle
) return 0;
1492 pArena
= ARENA_PTR( ptr
, ARENA_HEADER(handle
- MOVEABLE_PREFIX
) );
1495 pArena
= ARENA_PTR( ptr
, ARENA_HEADER(handle
) );
1497 return pArena
->next
- handle
;
1501 /***********************************************************************
1502 * LocalFlags (KERNEL.12)
1504 UINT16 WINAPI
LocalFlags16( HLOCAL16 handle
)
1506 HANDLE16 ds
= CURRENT_DS
;
1507 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1509 if (HANDLE_MOVEABLE(handle
))
1511 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+ handle
);
1512 TRACE("(%04x,%04x): returning %04x\n",
1513 ds
, handle
, pEntry
->lock
| (pEntry
->flags
<< 8) );
1514 return pEntry
->lock
| (pEntry
->flags
<< 8);
1518 TRACE("(%04x,%04x): returning 0\n",
1525 /***********************************************************************
1526 * LocalHeapSize (KERNEL.162)
1528 WORD WINAPI
LocalHeapSize16(void)
1530 HANDLE16 ds
= CURRENT_DS
;
1531 LOCALHEAPINFO
*pInfo
= LOCAL_GetHeap( ds
);
1532 return pInfo
? pInfo
->last
- pInfo
->first
: 0;
1536 /***********************************************************************
1537 * LocalCountFree (KERNEL.161)
1539 WORD WINAPI
LocalCountFree16(void)
1541 HANDLE16 ds
= CURRENT_DS
;
1544 LOCALHEAPINFO
*pInfo
;
1545 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1547 if (!(pInfo
= LOCAL_GetHeap( ds
)))
1549 ERR("(%04x): Local heap not found\n", ds
);
1550 LOCAL_PrintHeap( ds
);
1555 arena
= pInfo
->first
;
1556 pArena
= ARENA_PTR( ptr
, arena
);
1559 arena
= pArena
->free_next
;
1560 pArena
= ARENA_PTR( ptr
, arena
);
1561 if (arena
== pArena
->free_next
) break;
1562 total
+= pArena
->size
;
1564 TRACE("(%04x): returning %d\n", ds
, total
);
1569 /***********************************************************************
1570 * LocalHandle (KERNEL.11)
1572 HLOCAL16 WINAPI
LocalHandle16( WORD addr
)
1574 HANDLE16 ds
= CURRENT_DS
;
1575 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1576 LOCALHEAPINFO
*pInfo
;
1579 if (!(pInfo
= LOCAL_GetHeap( ds
)))
1581 ERR("(%04x): Local heap not found\n", ds
);
1582 LOCAL_PrintHeap( ds
);
1586 /* Find the address in the entry tables */
1588 table
= pInfo
->htable
;
1591 WORD count
= *(WORD
*)(ptr
+ table
);
1592 LOCALHANDLEENTRY
*pEntry
= (LOCALHANDLEENTRY
*)(ptr
+table
+sizeof(WORD
));
1593 for (; count
> 0; count
--, pEntry
++)
1594 if (pEntry
->addr
== addr
) return (HLOCAL16
)((char *)pEntry
- ptr
);
1595 table
= *(WORD
*)pEntry
;
1598 return (HLOCAL16
)addr
; /* Fixed block handle is addr */
1604 /***********************************************************************
1605 * LocalLock (KERNEL.8)
1607 * Note: only the offset part of the pointer is returned by the relay code.
1609 SEGPTR WINAPI
LocalLock16( HLOCAL16 handle
)
1611 WORD ds
= CURRENT_DS
;
1612 char *ptr
= MapSL( MAKESEGPTR( ds
, 0 ) );
1613 return MAKESEGPTR( ds
, LOCAL_InternalLock( ptr
, handle
) );
1617 /***********************************************************************
1618 * LocalCompact (KERNEL.13)
1620 UINT16 WINAPI
LocalCompact16( UINT16 minfree
)
1622 TRACE("%04x\n", minfree
);
1623 return LOCAL_Compact( CURRENT_DS
, minfree
, 0 );
1627 /***********************************************************************
1628 * LocalNotify (KERNEL.14)
1630 * Installs a callback function that is called for local memory events
1631 * Callback function prototype is
1632 * BOOL16 NotifyFunc(WORD wMsg, HLOCAL16 hMem, WORD wArg)
1635 * NotifyFunc seems to be responsible for allocating some memory,
1636 * returns TRUE for success.
1637 * wArg = number of bytes needed additionally
1639 * hMem = handle; wArg = old mem location
1641 * NotifyFunc seems to be strongly encouraged to return TRUE,
1642 * otherwise LogError() gets called.
1643 * hMem = handle; wArg = flags
1645 FARPROC16 WINAPI
LocalNotify16( FARPROC16 func
)
1647 LOCALHEAPINFO
*pInfo
;
1648 FARPROC16 oldNotify
;
1649 HANDLE16 ds
= CURRENT_DS
;
1651 if (!(pInfo
= LOCAL_GetHeap( ds
)))
1653 ERR("(%04x): Local heap not found\n", ds
);
1654 LOCAL_PrintHeap( ds
);
1657 TRACE("(%04x): %p\n", ds
, func
);
1658 FIXME("Half implemented\n");
1659 oldNotify
= pInfo
->notify
;
1660 pInfo
->notify
= func
;
1665 /***********************************************************************
1666 * LocalShrink (KERNEL.121)
1668 UINT16 WINAPI
LocalShrink16( HGLOBAL16 handle
, UINT16 newsize
)
1670 TRACE("%04x %04x\n", handle
, newsize
);
1675 /***********************************************************************
1676 * GetHeapSpaces (KERNEL.138)
1678 DWORD WINAPI
GetHeapSpaces16( HMODULE16 module
)
1681 WORD oldDS
= CURRENT_DS
;
1684 if (!(pModule
= NE_GetPtr( module
))) return 0;
1685 CURRENT_DS
= GlobalHandleToSel16((NE_SEG_TABLE( pModule
) + pModule
->ne_autodata
- 1)->hSeg
);
1686 spaces
= MAKELONG( LocalCountFree16(), LocalHeapSize16() );
1692 /***********************************************************************
1693 * LocalHandleDelta (KERNEL.310)
1695 WORD WINAPI
LocalHandleDelta16( WORD delta
)
1697 LOCALHEAPINFO
*pInfo
;
1699 if (!(pInfo
= LOCAL_GetHeap( CURRENT_DS
)))
1701 ERR("Local heap not found\n");
1702 LOCAL_PrintHeap( CURRENT_DS
);
1705 if (delta
) pInfo
->hdelta
= delta
;
1706 TRACE("returning %04x\n", pInfo
->hdelta
);
1707 return pInfo
->hdelta
;
1711 /***********************************************************************
1712 * 32-bit local heap functions (Win95; undocumented)
1715 /***********************************************************************
1718 HANDLE WINAPI
Local32Init16( WORD segment
, DWORD tableSize
,
1719 DWORD heapSize
, DWORD flags
)
1721 DWORD totSize
, segSize
= 0;
1723 LOCAL32HEADER
*header
;
1725 WORD
*selectorTable
;
1726 WORD selectorEven
, selectorOdd
;
1729 /* Determine new heap size */
1733 if ( (segSize
= GetSelectorLimit16( segment
)) == 0 )
1739 if ( heapSize
== (DWORD
)-1 )
1740 heapSize
= 1024*1024; /* FIXME */
1742 heapSize
= (heapSize
+ 0xffff) & 0xffff0000;
1743 segSize
= (segSize
+ 0x0fff) & 0xfffff000;
1744 totSize
= segSize
+ HTABLE_SIZE
+ heapSize
;
1747 /* Allocate memory and initialize heap */
1749 if ( !(base
= VirtualAlloc( NULL
, totSize
, MEM_RESERVE
, PAGE_READWRITE
)) )
1752 if ( !VirtualAlloc( base
, segSize
+ HTABLE_PAGESIZE
,
1753 MEM_COMMIT
, PAGE_READWRITE
) )
1755 VirtualFree( base
, 0, MEM_RELEASE
);
1759 if (!(heap
= RtlCreateHeap( 0, base
+ segSize
+ HTABLE_SIZE
, heapSize
, 0x10000, NULL
, NULL
)))
1761 VirtualFree( base
, 0, MEM_RELEASE
);
1766 /* Set up header and handle table */
1768 header
= (LOCAL32HEADER
*)(base
+ segSize
);
1769 header
->base
= base
;
1770 header
->limit
= HTABLE_PAGESIZE
-1;
1772 header
->magic
= LOCAL32_MAGIC
;
1773 header
->heap
= heap
;
1775 header
->freeListFirst
[0] = sizeof(LOCAL32HEADER
);
1776 header
->freeListLast
[0] = HTABLE_PAGESIZE
- 4;
1777 header
->freeListSize
[0] = (HTABLE_PAGESIZE
- sizeof(LOCAL32HEADER
)) / 4;
1779 for (i
= header
->freeListFirst
[0]; i
< header
->freeListLast
[0]; i
+= 4)
1780 *(DWORD
*)((LPBYTE
)header
+ i
) = i
+4;
1782 header
->freeListFirst
[1] = 0xffff;
1785 /* Set up selector table */
1787 nrBlocks
= (totSize
+ 0x7fff) >> 15;
1788 selectorTable
= HeapAlloc( header
->heap
, 0, nrBlocks
* 2 );
1789 selectorEven
= SELECTOR_AllocBlock( base
, totSize
, WINE_LDT_FLAGS_DATA
);
1790 selectorOdd
= SELECTOR_AllocBlock( base
+ 0x8000, totSize
- 0x8000, WINE_LDT_FLAGS_DATA
);
1791 if ( !selectorTable
|| !selectorEven
|| !selectorOdd
)
1793 HeapFree( header
->heap
, 0, selectorTable
);
1794 if ( selectorEven
) SELECTOR_FreeBlock( selectorEven
);
1795 if ( selectorOdd
) SELECTOR_FreeBlock( selectorOdd
);
1796 HeapDestroy( header
->heap
);
1797 VirtualFree( base
, 0, MEM_RELEASE
);
1801 header
->selectorTableOffset
= (LPBYTE
)selectorTable
- header
->base
;
1802 header
->selectorTableSize
= nrBlocks
* 4; /* ??? Win95 does it this way! */
1803 header
->selectorDelta
= selectorEven
- selectorOdd
;
1804 header
->segment
= segment
? segment
: selectorEven
;
1806 for (i
= 0; i
< nrBlocks
; i
++)
1807 selectorTable
[i
] = (i
& 1)? selectorOdd
+ ((i
>> 1) << __AHSHIFT
)
1808 : selectorEven
+ ((i
>> 1) << __AHSHIFT
);
1810 /* Move old segment */
1814 /* FIXME: This is somewhat ugly and relies on implementation
1815 details about 16-bit global memory handles ... */
1817 LPBYTE oldBase
= (LPBYTE
)GetSelectorBase( segment
);
1818 memcpy( base
, oldBase
, segSize
);
1819 GLOBAL_MoveBlock( segment
, base
, totSize
);
1820 HeapFree( GetProcessHeap(), 0, oldBase
);
1826 /***********************************************************************
1827 * Local32_SearchHandle
1829 static LPDWORD
Local32_SearchHandle( LOCAL32HEADER
*header
, DWORD addr
)
1833 for ( handle
= (LPDWORD
)((LPBYTE
)header
+ sizeof(LOCAL32HEADER
));
1834 handle
< (LPDWORD
)((LPBYTE
)header
+ header
->limit
);
1837 if (*handle
== addr
)
1844 /***********************************************************************
1847 static VOID
Local32_ToHandle( LOCAL32HEADER
*header
, INT16 type
,
1848 DWORD addr
, LPDWORD
*handle
, LPBYTE
*ptr
)
1855 case -2: /* 16:16 pointer, no handles */
1856 *ptr
= MapSL( addr
);
1857 *handle
= (LPDWORD
)*ptr
;
1860 case -1: /* 32-bit offset, no handles */
1861 *ptr
= header
->base
+ addr
;
1862 *handle
= (LPDWORD
)*ptr
;
1865 case 0: /* handle */
1866 if ( addr
>= sizeof(LOCAL32HEADER
)
1867 && addr
< header
->limit
&& !(addr
& 3)
1868 && *(LPDWORD
)((LPBYTE
)header
+ addr
) >= HTABLE_SIZE
)
1870 *handle
= (LPDWORD
)((LPBYTE
)header
+ addr
);
1871 *ptr
= header
->base
+ **handle
;
1875 case 1: /* 16:16 pointer */
1876 *ptr
= MapSL( addr
);
1877 *handle
= Local32_SearchHandle( header
, *ptr
- header
->base
);
1880 case 2: /* 32-bit offset */
1881 *ptr
= header
->base
+ addr
;
1882 *handle
= Local32_SearchHandle( header
, *ptr
- header
->base
);
1887 /***********************************************************************
1888 * Local32_FromHandle
1890 static VOID
Local32_FromHandle( LOCAL32HEADER
*header
, INT16 type
,
1891 DWORD
*addr
, LPDWORD handle
, LPBYTE ptr
)
1896 case -2: /* 16:16 pointer */
1899 WORD
*selTable
= (LPWORD
)(header
->base
+ header
->selectorTableOffset
);
1900 DWORD offset
= ptr
- header
->base
;
1901 *addr
= MAKELONG( offset
& 0x7fff, selTable
[offset
>> 15] );
1905 case -1: /* 32-bit offset */
1907 *addr
= ptr
- header
->base
;
1910 case 0: /* handle */
1911 *addr
= (LPBYTE
)handle
- (LPBYTE
)header
;
1916 /***********************************************************************
1919 DWORD WINAPI
Local32Alloc16( HANDLE heap
, DWORD size
, INT16 type
, DWORD flags
)
1921 LOCAL32HEADER
*header
= heap
;
1926 /* Allocate memory */
1927 ptr
= HeapAlloc( header
->heap
,
1928 (flags
& LMEM_MOVEABLE
)? HEAP_ZERO_MEMORY
: 0, size
);
1932 /* Allocate handle if requested */
1937 /* Find first page of handle table with free slots */
1938 for (page
= 0; page
< HTABLE_NPAGES
; page
++)
1939 if (header
->freeListFirst
[page
] != 0)
1941 if (page
== HTABLE_NPAGES
)
1943 WARN("Out of handles!\n" );
1944 HeapFree( header
->heap
, 0, ptr
);
1948 /* If virgin page, initialize it */
1949 if (header
->freeListFirst
[page
] == 0xffff)
1951 if ( !VirtualAlloc( (LPBYTE
)header
+ (page
<< 12),
1952 0x1000, MEM_COMMIT
, PAGE_READWRITE
) )
1954 WARN("Cannot grow handle table!\n" );
1955 HeapFree( header
->heap
, 0, ptr
);
1959 header
->limit
+= HTABLE_PAGESIZE
;
1961 header
->freeListFirst
[page
] = 0;
1962 header
->freeListLast
[page
] = HTABLE_PAGESIZE
- 4;
1963 header
->freeListSize
[page
] = HTABLE_PAGESIZE
/ 4;
1965 for (i
= 0; i
< HTABLE_PAGESIZE
; i
+= 4)
1966 *(DWORD
*)((LPBYTE
)header
+ i
) = i
+4;
1968 if (page
< HTABLE_NPAGES
-1)
1969 header
->freeListFirst
[page
+1] = 0xffff;
1972 /* Allocate handle slot from page */
1973 handle
= (LPDWORD
)((LPBYTE
)header
+ header
->freeListFirst
[page
]);
1974 if (--header
->freeListSize
[page
] == 0)
1975 header
->freeListFirst
[page
] = header
->freeListLast
[page
] = 0;
1977 header
->freeListFirst
[page
] = *handle
;
1979 /* Store 32-bit offset in handle slot */
1980 *handle
= ptr
- header
->base
;
1984 handle
= (LPDWORD
)ptr
;
1989 /* Convert handle to requested output type */
1990 Local32_FromHandle( header
, type
, &addr
, handle
, ptr
);
1994 /***********************************************************************
1997 DWORD WINAPI
Local32ReAlloc16( HANDLE heap
, DWORD addr
, INT16 type
,
1998 DWORD size
, DWORD flags
)
2000 LOCAL32HEADER
*header
= heap
;
2005 return Local32Alloc16( heap
, size
, type
, flags
);
2007 /* Retrieve handle and pointer */
2008 Local32_ToHandle( header
, type
, addr
, &handle
, &ptr
);
2009 if (!handle
) return FALSE
;
2011 /* Reallocate memory block */
2012 ptr
= HeapReAlloc( header
->heap
,
2013 (flags
& LMEM_MOVEABLE
)? HEAP_ZERO_MEMORY
: 0,
2019 *handle
= ptr
- header
->base
;
2021 handle
= (LPDWORD
)ptr
;
2023 /* Convert handle to requested output type */
2024 Local32_FromHandle( header
, type
, &addr
, handle
, ptr
);
2028 /***********************************************************************
2031 BOOL WINAPI
Local32Free16( HANDLE heap
, DWORD addr
, INT16 type
)
2033 LOCAL32HEADER
*header
= heap
;
2037 /* Retrieve handle and pointer */
2038 Local32_ToHandle( header
, type
, addr
, &handle
, &ptr
);
2039 if (!handle
) return FALSE
;
2041 /* Free handle if necessary */
2044 int offset
= (LPBYTE
)handle
- (LPBYTE
)header
;
2045 int page
= offset
>> 12;
2047 /* Return handle slot to page free list */
2048 if (header
->freeListSize
[page
]++ == 0)
2049 header
->freeListFirst
[page
] = header
->freeListLast
[page
] = offset
;
2051 *(LPDWORD
)((LPBYTE
)header
+ header
->freeListLast
[page
]) = offset
,
2052 header
->freeListLast
[page
] = offset
;
2056 /* Shrink handle table when possible */
2057 while (page
> 0 && header
->freeListSize
[page
] == HTABLE_PAGESIZE
/ 4)
2059 if ( VirtualFree( (LPBYTE
)header
+
2060 (header
->limit
& ~(HTABLE_PAGESIZE
-1)),
2061 HTABLE_PAGESIZE
, MEM_DECOMMIT
) )
2064 header
->limit
-= HTABLE_PAGESIZE
;
2065 header
->freeListFirst
[page
] = 0xffff;
2071 return HeapFree( header
->heap
, 0, ptr
);
2074 /***********************************************************************
2077 DWORD WINAPI
Local32Translate16( HANDLE heap
, DWORD addr
, INT16 type1
, INT16 type2
)
2079 LOCAL32HEADER
*header
= heap
;
2083 Local32_ToHandle( header
, type1
, addr
, &handle
, &ptr
);
2084 if (!handle
) return 0;
2086 Local32_FromHandle( header
, type2
, &addr
, handle
, ptr
);
2090 /***********************************************************************
2093 DWORD WINAPI
Local32Size16( HANDLE heap
, DWORD addr
, INT16 type
)
2095 LOCAL32HEADER
*header
= heap
;
2099 Local32_ToHandle( header
, type
, addr
, &handle
, &ptr
);
2100 if (!handle
) return 0;
2102 return HeapSize( header
->heap
, 0, ptr
);
2105 /***********************************************************************
2108 BOOL WINAPI
Local32ValidHandle16( HANDLE heap
, WORD addr
)
2110 LOCAL32HEADER
*header
= heap
;
2114 Local32_ToHandle( header
, 0, addr
, &handle
, &ptr
);
2115 return handle
!= NULL
;
2118 /***********************************************************************
2121 WORD WINAPI
Local32GetSegment16( HANDLE heap
)
2123 LOCAL32HEADER
*header
= heap
;
2124 return header
->segment
;
2127 /***********************************************************************
2130 static LOCAL32HEADER
*Local32_GetHeap( HGLOBAL16 handle
)
2132 WORD selector
= GlobalHandleToSel16( handle
);
2133 DWORD base
= GetSelectorBase( selector
);
2134 DWORD limit
= GetSelectorLimit16( selector
);
2136 /* Hmmm. This is a somewhat stupid heuristic, but Windows 95 does
2139 if ( limit
> 0x10000 && ((LOCAL32HEADER
*)base
)->magic
== LOCAL32_MAGIC
)
2140 return (LOCAL32HEADER
*)base
;
2145 if ( limit
> 0x10000 && ((LOCAL32HEADER
*)base
)->magic
== LOCAL32_MAGIC
)
2146 return (LOCAL32HEADER
*)base
;
2151 /***********************************************************************
2152 * Local32Info (KERNEL.444)
2154 BOOL16 WINAPI
Local32Info16( LOCAL32INFO
*pLocal32Info
, HGLOBAL16 handle
)
2156 PROCESS_HEAP_ENTRY entry
;
2159 LOCAL32HEADER
*header
= Local32_GetHeap( handle
);
2160 if ( !header
) return FALSE
;
2162 if ( !pLocal32Info
|| pLocal32Info
->dwSize
< sizeof(LOCAL32INFO
) )
2165 pLocal32Info
->dwMemReserved
= 0;
2166 pLocal32Info
->dwMemCommitted
= 0;
2167 pLocal32Info
->dwTotalFree
= 0;
2168 pLocal32Info
->dwLargestFreeBlock
= 0;
2170 while (HeapWalk( header
->heap
, &entry
))
2172 if (entry
.wFlags
& PROCESS_HEAP_REGION
)
2174 pLocal32Info
->dwMemReserved
+= entry
.u
.Region
.dwCommittedSize
2175 + entry
.u
.Region
.dwUnCommittedSize
;
2176 pLocal32Info
->dwMemCommitted
= entry
.u
.Region
.dwCommittedSize
;
2178 else if (!(entry
.wFlags
& PROCESS_HEAP_ENTRY_BUSY
))
2180 DWORD size
= entry
.cbData
+ entry
.cbOverhead
;
2181 pLocal32Info
->dwTotalFree
+= size
;
2182 if (size
> pLocal32Info
->dwLargestFreeBlock
) pLocal32Info
->dwLargestFreeBlock
= size
;
2186 pLocal32Info
->dwcFreeHandles
= 0;
2187 for ( i
= 0; i
< HTABLE_NPAGES
; i
++ )
2189 if ( header
->freeListFirst
[i
] == 0xffff ) break;
2190 pLocal32Info
->dwcFreeHandles
+= header
->freeListSize
[i
];
2192 pLocal32Info
->dwcFreeHandles
+= (HTABLE_NPAGES
- i
) * HTABLE_PAGESIZE
/4;
2197 /***********************************************************************
2198 * Local32First (KERNEL.445)
2200 BOOL16 WINAPI
Local32First16( LOCAL32ENTRY
*pLocal32Entry
, HGLOBAL16 handle
)
2202 FIXME("(%p, %04X): stub!\n", pLocal32Entry
, handle
);
2206 /***********************************************************************
2207 * Local32Next (KERNEL.446)
2209 BOOL16 WINAPI
Local32Next16( LOCAL32ENTRY
*pLocal32Entry
)
2211 FIXME("(%p): stub!\n", pLocal32Entry
);