memory/local.c

   1 /*
   2  * Local heap functions
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  * Copyright 1996 Huw Davies
   6  */
   7
   8 /*
   9  * Note:
  10  * All local heap functions need the current DS as first parameter
  11  * when called from the emulation library, so they take one more
  12  * parameter than usual.
  13  */
  14
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include "windows.h"
  18 #include "ldt.h"
  19 #include "global.h"
  20 #include "heap.h"
  21 #include "instance.h"
  22 #include "local.h"
  23 #include "module.h"
  24 #include "stackframe.h"
  25 #include "toolhelp.h"
  26 #include "stddebug.h"
  27 #include "debug.h"
  28
  29 typedef struct
  30 {
  31 /* Arena header */
  32     WORD prev;          /* Previous arena | arena type */
  33     WORD next;          /* Next arena */
  34 /* Start of the memory block or free-list info */
  35     WORD size;          /* Size of the free block */
  36     WORD free_prev;     /* Previous free block */
  37     WORD free_next;     /* Next free block */
  38 } LOCALARENA;
  39
  40 #define ARENA_HEADER_SIZE      4
  41 #define ARENA_HEADER( handle) ( ((handle) & ~3) - ARENA_HEADER_SIZE)
  42
  43   /* Arena types (stored in 'prev' field of the arena) */
  44 #define LOCAL_ARENA_FREE       0
  45 #define LOCAL_ARENA_FIXED      1
  46
  47 /* Layout of a handle entry table
  48  *
  49  * WORD                     count of entries
  50  * LOCALHANDLEENTRY[count]  entries
  51  * WORD                     near ptr to next table
  52  */
  53 typedef struct
  54 {
  55     WORD addr;                /* Address of the MOVEABLE block */
  56     BYTE flags;               /* Flags for this block */
  57     BYTE lock;                /* Lock count */
  58 } LOCALHANDLEENTRY;
  59
  60 /*
  61  * We make addr = 4n + 2 and set *((WORD *)addr - 1) = &addr like Windows does
  62  * in case something actually relies on this.
  63  * Note the ARENA_HEADER(addr) still produces the desired result ie. 4n - 4
  64  *
  65  * An unused handle has lock = flags = 0xff. In windows addr is that of next
  66  * free handle, at the moment in wine we set it to 0.
  67  *
  68  * A discarded block's handle has lock = addr = 0 and flags = 0x40
  69  * (LMEM_DISCARDED >> 8)
  70  */
  71
  72 #pragma pack(1)
  73
  74 typedef struct
  75 {
  76     WORD check;                 /* 00 Heap checking flag */
  77     WORD freeze;                /* 02 Heap frozen flag */
  78     WORD items;                 /* 04 Count of items on the heap */
  79     WORD first;                 /* 06 First item of the heap */
  80     WORD pad1;                  /* 08 Always 0 */
  81     WORD last;                  /* 0a Last item of the heap */
  82     WORD pad2;                  /* 0c Always 0 */
  83     BYTE ncompact;              /* 0e Compactions counter */
  84     BYTE dislevel;              /* 0f Discard level */
  85     DWORD distotal;             /* 10 Total bytes discarded */
  86     WORD htable;                /* 14 Pointer to handle table */
  87     WORD hfree;                 /* 16 Pointer to free handle table */
  88     WORD hdelta;                /* 18 Delta to expand the handle table */
  89     WORD expand;                /* 1a Pointer to expand function (unused) */
  90     WORD pstat;                 /* 1c Pointer to status structure (unused) */
  91     FARPROC16 notify WINE_PACKED; /* 1e Pointer to LocalNotify() function */
  92     WORD lock;                  /* 22 Lock count for the heap */
  93     WORD extra;                 /* 24 Extra bytes to allocate when expanding */
  94     WORD minsize;               /* 26 Minimum size of the heap */
  95     WORD magic;                 /* 28 Magic number */
  96 } LOCALHEAPINFO;
  97
  98 #pragma pack(4)
  99
 100 #define LOCAL_HEAP_MAGIC  0x484c  /* 'LH' */
 101
 102
 103   /* All local heap allocations are aligned on 4-byte boundaries */
 104 #define LALIGN(word)          (((word) + 3) & ~3)
 105
 106 #define ARENA_PTR(ptr,arena)       ((LOCALARENA *)((char*)(ptr)+(arena)))
 107 #define ARENA_PREV(ptr,arena)      (ARENA_PTR((ptr),(arena))->prev & ~3)
 108 #define ARENA_NEXT(ptr,arena)      (ARENA_PTR((ptr),(arena))->next)
 109 #define ARENA_FLAGS(ptr,arena)     (ARENA_PTR((ptr),(arena))->prev & 3)
 110
 111   /* determine whether the handle belongs to a fixed or a moveable block */
 112 #define HANDLE_FIXED(handle) (((handle) & 3) == 0)
 113 #define HANDLE_MOVEABLE(handle) (((handle) & 3) == 2)
 114
 115 /***********************************************************************
 116  *           LOCAL_GetHeap
 117  *
 118  * Return a pointer to the local heap, making sure it exists.
 119  */
 120 static LOCALHEAPINFO *LOCAL_GetHeap( HANDLE16 ds )
 121 {
 122     LOCALHEAPINFO *pInfo;
 123     INSTANCEDATA *ptr = (INSTANCEDATA *)PTR_SEG_OFF_TO_LIN( ds, 0 );
 124     dprintf_local( stddeb, "Heap at %p, %04x\n", ptr, ptr->heap );
 125     if (!ptr || !ptr->heap) return NULL;
 126     if (IsBadReadPtr16( (SEGPTR)MAKELONG(ptr->heap,ds), sizeof(LOCALHEAPINFO)))
 127         return NULL;
 128     pInfo = (LOCALHEAPINFO*)((char*)ptr + ptr->heap);
 129     if (pInfo->magic != LOCAL_HEAP_MAGIC) return NULL;
 130     return pInfo;
 131 }
 132
 133
 134 /***********************************************************************
 135  *           LOCAL_MakeBlockFree
 136  *
 137  * Make a block free, inserting it in the free-list.
 138  * 'block' is the handle of the block arena; 'baseptr' points to
 139  * the beginning of the data segment containing the heap.
 140  */
 141 static void LOCAL_MakeBlockFree( char *baseptr, WORD block )
 142 {
 143     LOCALARENA *pArena, *pNext;
 144     WORD next;
 145
 146       /* Mark the block as free */
 147
 148     pArena = ARENA_PTR( baseptr, block );
 149     pArena->prev = (pArena->prev & ~3) | LOCAL_ARENA_FREE;
 150     pArena->size = pArena->next - block;
 151
 152       /* Find the next free block (last block is always free) */
 153
 154     next = pArena->next;
 155     for (;;)
 156     {
 157         pNext = ARENA_PTR( baseptr, next );
 158         if ((pNext->prev & 3) == LOCAL_ARENA_FREE) break;
 159         next = pNext->next;
 160     }
 161
 162     dprintf_local( stddeb, "Local_AddFreeBlock %04x, next %04x\n", block, next );
 163       /* Insert the free block in the free-list */
 164
 165     pArena->free_prev = pNext->free_prev;
 166     pArena->free_next = next;
 167     ARENA_PTR(baseptr,pNext->free_prev)->free_next = block;
 168     pNext->free_prev  = block;
 169 }
 170
 171
 172 /***********************************************************************
 173  *           LOCAL_RemoveFreeBlock
 174  *
 175  * Remove a block from the free-list.
 176  * 'block' is the handle of the block arena; 'baseptr' points to
 177  * the beginning of the data segment containing the heap.
 178  */
 179 static void LOCAL_RemoveFreeBlock( char *baseptr, WORD block )
 180 {
 181       /* Mark the block as fixed */
 182
 183     LOCALARENA *pArena = ARENA_PTR( baseptr, block );
 184     pArena->prev = (pArena->prev & ~3) | LOCAL_ARENA_FIXED;
 185
 186       /* Remove it from the list */
 187
 188     ARENA_PTR(baseptr,pArena->free_prev)->free_next = pArena->free_next;
 189     ARENA_PTR(baseptr,pArena->free_next)->free_prev = pArena->free_prev;
 190 }
 191
 192
 193 /***********************************************************************
 194  *           LOCAL_AddBlock
 195  *
 196  * Insert a new block in the heap.
 197  * 'new' is the handle of the new block arena; 'baseptr' points to
 198  * the beginning of the data segment containing the heap; 'prev' is
 199  * the block before the new one.
 200  */
 201 static void LOCAL_AddBlock( char *baseptr, WORD prev, WORD new )
 202 {
 203     LOCALARENA *pPrev = ARENA_PTR( baseptr, prev );
 204     LOCALARENA *pNew  = ARENA_PTR( baseptr, new );
 205
 206     pNew->prev = (prev & ~3) | LOCAL_ARENA_FIXED;
 207     pNew->next = pPrev->next;
 208     ARENA_PTR(baseptr,pPrev->next)->prev &= 3;
 209     ARENA_PTR(baseptr,pPrev->next)->prev |= new;
 210     pPrev->next = new;
 211 }
 212
 213
 214 /***********************************************************************
 215  *           LOCAL_RemoveBlock
 216  *
 217  * Remove a block from the heap.
 218  * 'block' is the handle of the block arena; 'baseptr' points to
 219  * the beginning of the data segment containing the heap.
 220  */
 221 static void LOCAL_RemoveBlock( char *baseptr, WORD block )
 222 {
 223     LOCALARENA *pArena, *pTmp;
 224
 225       /* Remove the block from the free-list */
 226
 227     dprintf_local( stddeb, "Local_RemoveBlock\n");
 228     pArena = ARENA_PTR( baseptr, block );
 229     if ((pArena->prev & 3) == LOCAL_ARENA_FREE)
 230         LOCAL_RemoveFreeBlock( baseptr, block );
 231
 232       /* If the previous block is free, expand its size */
 233
 234     pTmp = ARENA_PTR( baseptr, pArena->prev & ~3 );
 235     if ((pTmp->prev & 3) == LOCAL_ARENA_FREE)
 236         pTmp->size += pArena->next - block;
 237
 238       /* Remove the block from the linked list */
 239
 240     pTmp->next = pArena->next;
 241     pTmp = ARENA_PTR( baseptr, pArena->next );
 242     pTmp->prev = (pTmp->prev & 3) | (pArena->prev & ~3);
 243 }
 244
 245
 246 /***********************************************************************
 247  *           LOCAL_PrintHeap
 248  */
 249 static void LOCAL_PrintHeap( HANDLE16 ds )
 250 {
 251     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
 252     LOCALHEAPINFO *pInfo = LOCAL_GetHeap( ds );
 253     WORD arena;
 254
 255     if (!debugging_local) return;
 256     if (!pInfo)
 257     {
 258         printf( "Local Heap corrupted!  ds=%04x\n", ds );
 259         return;
 260     }
 261     printf( "Local Heap  ds=%04x first=%04x last=%04x items=%d\n",
 262             ds, pInfo->first, pInfo->last, pInfo->items );
 263
 264     arena = pInfo->first;
 265     for (;;)
 266     {
 267         LOCALARENA *pArena = ARENA_PTR(ptr,arena);
 268         printf( "  %04x: prev=%04x next=%04x type=%d\n", arena,
 269                 pArena->prev & ~3, pArena->next, pArena->prev & 3 );
 270         if (arena == pInfo->first)
 271         {
 272             printf( "        size=%d free_prev=%04x free_next=%04x\n",
 273                     pArena->size, pArena->free_prev, pArena->free_next );
 274         }
 275         if ((pArena->prev & 3) == LOCAL_ARENA_FREE)
 276         {
 277             printf( "        size=%d free_prev=%04x free_next=%04x\n",
 278                     pArena->size, pArena->free_prev, pArena->free_next );
 279             if (pArena->next == arena) break;  /* last one */
 280             if (ARENA_PTR(ptr,pArena->free_next)->free_prev != arena)
 281             {
 282                 printf( "*** arena->free_next->free_prev != arena\n" );
 283                 break;
 284             }
 285         }
 286         if (pArena->next == arena)
 287         {
 288             printf( "*** last block is not marked free\n" );
 289             break;
 290         }
 291         if ((ARENA_PTR(ptr,pArena->next)->prev & ~3) != arena)
 292         {
 293             printf( "*** arena->next->prev != arena (%04x, %04x)\n",
 294                    pArena->next, ARENA_PTR(ptr,pArena->next)->prev);
 295             break;
 296         }
 297         arena = pArena->next;
 298     }
 299 }
 300
 301
 302 /***********************************************************************
 303  *           LocalInit   (KERNEL.4)
 304  */
 305 BOOL16 LocalInit( HANDLE16 selector, WORD start, WORD end )
 306 {
 307     char *ptr;
 308     WORD heapInfoArena, freeArena, lastArena;
 309     LOCALHEAPINFO *pHeapInfo;
 310     LOCALARENA *pArena, *pFirstArena, *pLastArena;
 311     NE_MODULE *pModule;
 312
 313       /* The initial layout of the heap is: */
 314       /* - first arena         (FIXED)      */
 315       /* - heap info structure (FIXED)      */
 316       /* - large free block    (FREE)       */
 317       /* - last arena          (FREE)       */
 318
 319     dprintf_local(stddeb, "LocalInit: %04x %04x-%04x\n", selector, start, end);
 320     if (!selector) selector = CURRENT_DS;
 321
 322     if (debugging_heap)
 323     {
 324         /* If debugging_heap is set, the global heap blocks are cleared */
 325         /* before use, so we can test for double initialization. */
 326         if (LOCAL_GetHeap(selector))
 327         {
 328             fprintf( stderr, "LocalInit: Heap %04x initialized twice.\n", selector);
 329             if (debugging_local) LOCAL_PrintHeap(selector);
 330         }
 331     }
 332
 333     if (start == 0) {
 334       /* Check if the segment is the DGROUP of a module */
 335
 336         if ((pModule = MODULE_GetPtr( GetExePtr( selector ) )))
 337         {
 338             SEGTABLEENTRY *pSeg = NE_SEG_TABLE( pModule ) + pModule->dgroup - 1;
 339             if (pModule->dgroup && (pSeg->selector == selector)) {
 340                 /* We can't just use the simple method of using the value
 341                  * of minsize + stacksize, since there are programs that
 342                  * resize the data segment before calling InitTask(). So,
 343                  * we must put it at the end of the segment */
 344                 start = GlobalSize16( GlobalHandle16( selector ) );
 345                 start -= end;
 346                 end += start;
 347                 dprintf_local( stddeb," new start %04x, minstart: %04x\n", start, pSeg->minsize + pModule->stack_size);
 348             }
 349         }
 350     }
 351     ptr = PTR_SEG_OFF_TO_LIN( selector, 0 );
 352
 353     start = LALIGN( MAX( start, sizeof(INSTANCEDATA) ) );
 354     heapInfoArena = LALIGN(start + sizeof(LOCALARENA) );
 355     freeArena = LALIGN( heapInfoArena + ARENA_HEADER_SIZE
 356                         + sizeof(LOCALHEAPINFO) );
 357     lastArena = (end - sizeof(LOCALARENA)) & ~3;
 358
 359       /* Make sure there's enough space.       */
 360
 361     if (freeArena + sizeof(LOCALARENA) >= lastArena) return FALSE;
 362
 363       /* Initialise the first arena */
 364
 365     pFirstArena = ARENA_PTR( ptr, start );
 366     pFirstArena->prev      = start | LOCAL_ARENA_FIXED;
 367     pFirstArena->next      = heapInfoArena;
 368     pFirstArena->size      = LALIGN(sizeof(LOCALARENA));
 369     pFirstArena->free_prev = start;  /* this one */
 370     pFirstArena->free_next = freeArena;
 371
 372       /* Initialise the arena of the heap info structure */
 373
 374     pArena = ARENA_PTR( ptr, heapInfoArena );
 375     pArena->prev = start | LOCAL_ARENA_FIXED;
 376     pArena->next = freeArena;
 377
 378       /* Initialise the heap info structure */
 379
 380     pHeapInfo = (LOCALHEAPINFO *) (ptr + heapInfoArena + ARENA_HEADER_SIZE );
 381     memset( pHeapInfo, 0, sizeof(LOCALHEAPINFO) );
 382     pHeapInfo->items   = 4;
 383     pHeapInfo->first   = start;
 384     pHeapInfo->last    = lastArena;
 385     pHeapInfo->htable  = 0;
 386     pHeapInfo->hdelta  = 0x20;
 387     pHeapInfo->extra   = 0x200;
 388     pHeapInfo->minsize = lastArena - freeArena;
 389     pHeapInfo->magic   = LOCAL_HEAP_MAGIC;
 390
 391       /* Initialise the large free block */
 392
 393     pArena = ARENA_PTR( ptr, freeArena );
 394     pArena->prev      = heapInfoArena | LOCAL_ARENA_FREE;
 395     pArena->next      = lastArena;
 396     pArena->size      = lastArena - freeArena;
 397     pArena->free_prev = start;
 398     pArena->free_next = lastArena;
 399
 400       /* Initialise the last block */
 401
 402     pLastArena = ARENA_PTR( ptr, lastArena );
 403     pLastArena->prev      = freeArena | LOCAL_ARENA_FREE;
 404     pLastArena->next      = lastArena;  /* this one */
 405     pLastArena->size      = LALIGN(sizeof(LOCALARENA));
 406     pLastArena->free_prev = freeArena;
 407     pLastArena->free_next = lastArena;  /* this one */
 408
 409       /* Store the local heap address in the instance data */
 410
 411     ((INSTANCEDATA *)ptr)->heap = heapInfoArena + ARENA_HEADER_SIZE;
 412     LOCAL_PrintHeap( selector );
 413     return TRUE;
 414 }
 415
 416 /***********************************************************************
 417  *           LOCAL_GrowHeap
 418  */
 419 static void LOCAL_GrowHeap( HANDLE16 ds )
 420 {
 421     HANDLE16 hseg = GlobalHandle16( ds );
 422     LONG oldsize = GlobalSize16( hseg );
 423     LONG end;
 424     LOCALHEAPINFO *pHeapInfo;
 425     WORD freeArena, lastArena;
 426     LOCALARENA *pArena, *pLastArena;
 427     char *ptr;
 428
 429     /* if nothing can be gained, return */
 430     if (oldsize > 0xfff0) return;
 431     hseg = GlobalReAlloc16( hseg, 0x10000, GMEM_FIXED );
 432     ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
 433     pHeapInfo = LOCAL_GetHeap( ds );
 434     if (pHeapInfo == NULL) {
 435         fprintf( stderr, "Local_GrowHeap: heap not found\n" );
 436         return;
 437     }
 438     end = GlobalSize16( hseg );
 439     lastArena = (end - sizeof(LOCALARENA)) & ~3;
 440
 441       /* Update the HeapInfo */
 442     pHeapInfo->items++;
 443     freeArena = pHeapInfo->last;
 444     pHeapInfo->last = lastArena;
 445     pHeapInfo->minsize += end - oldsize;
 446
 447       /* grow the old last block */
 448     pArena = ARENA_PTR( ptr, freeArena );
 449     pArena->size      = lastArena - freeArena;
 450     pArena->next      = lastArena;
 451     pArena->free_next = lastArena;
 452
 453       /* Initialise the new last block */
 454
 455     pLastArena = ARENA_PTR( ptr, lastArena );
 456     pLastArena->prev      = freeArena | LOCAL_ARENA_FREE;
 457     pLastArena->next      = lastArena;  /* this one */
 458     pLastArena->size      = LALIGN(sizeof(LOCALARENA));
 459     pLastArena->free_prev = freeArena;
 460     pLastArena->free_next = lastArena;  /* this one */
 461
 462     /* If block before freeArena is also free then merge them */
 463     if((ARENA_PTR(ptr, (pArena->prev & ~3))->prev & 3) == LOCAL_ARENA_FREE)
 464     {
 465         LOCAL_RemoveBlock(ptr, freeArena);
 466         pHeapInfo->items--;
 467     }
 468
 469     dprintf_local( stddeb, "Heap expanded\n" );
 470     LOCAL_PrintHeap( ds );
 471 }
 472
 473
 474 /***********************************************************************
 475  *           LOCAL_FreeArena
 476  */
 477 static HLOCAL16 LOCAL_FreeArena( WORD ds, WORD arena )
 478 {
 479     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
 480     LOCALHEAPINFO *pInfo;
 481     LOCALARENA *pArena, *pPrev, *pNext;
 482
 483     dprintf_local( stddeb, "LocalFreeArena: %04x ds=%04x\n", arena, ds );
 484     if (!(pInfo = LOCAL_GetHeap( ds ))) return arena;
 485
 486     pArena = ARENA_PTR( ptr, arena );
 487     if ((pArena->prev & 3) == LOCAL_ARENA_FREE)
 488     {
 489         /* shouldn't happen */
 490         fprintf( stderr, "LocalFreeArena: Trying to free block %04x twice!\n",
 491                  arena );
 492         LOCAL_PrintHeap( ds );
 493         return arena;
 494     }
 495
 496       /* Check if we can merge with the previous block */
 497
 498     pPrev = ARENA_PTR( ptr, pArena->prev & ~3 );
 499     pNext = ARENA_PTR( ptr, pArena->next );
 500     if ((pPrev->prev & 3) == LOCAL_ARENA_FREE)
 501     {
 502         arena  = pArena->prev & ~3;
 503         pArena = pPrev;
 504         LOCAL_RemoveBlock( ptr, pPrev->next );
 505         pInfo->items--;
 506     }
 507     else  /* Make a new free block */
 508     {
 509         LOCAL_MakeBlockFree( ptr, arena );
 510     }
 511
 512       /* Check if we can merge with the next block */
 513
 514     if ((pArena->next == pArena->free_next) &&
 515         (pArena->next != pInfo->last))
 516     {
 517         LOCAL_RemoveBlock( ptr, pArena->next );
 518         pInfo->items--;
 519     }
 520     return 0;
 521 }
 522
 523
 524 /***********************************************************************
 525  *           LOCAL_ShrinkArena
 526  *
 527  * Shrink an arena by creating a free block at its end if possible.
 528  * 'size' includes the arena header, and must be aligned.
 529  */
 530 static void LOCAL_ShrinkArena( WORD ds, WORD arena, WORD size )
 531 {
 532     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
 533     LOCALARENA *pArena = ARENA_PTR( ptr, arena );
 534
 535     if (arena + size + LALIGN(sizeof(LOCALARENA)) < pArena->next)
 536     {
 537         LOCALHEAPINFO *pInfo = LOCAL_GetHeap( ds );
 538         if (!pInfo) return;
 539         LOCAL_AddBlock( ptr, arena, arena + size );
 540         pInfo->items++;
 541         LOCAL_FreeArena( ds, arena + size );
 542     }
 543 }
 544
 545
 546 /***********************************************************************
 547  *           LOCAL_GrowArenaDownward
 548  *
 549  * Grow an arena downward by using the previous arena (must be free).
 550  */
 551 static void LOCAL_GrowArenaDownward( WORD ds, WORD arena, WORD newsize )
 552 {
 553     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
 554     LOCALHEAPINFO *pInfo;
 555     LOCALARENA *pArena = ARENA_PTR( ptr, arena );
 556     WORD prevArena = pArena->prev & ~3;
 557     LOCALARENA *pPrevArena = ARENA_PTR( ptr, prevArena );
 558     WORD offset, size;
 559     char *p;
 560
 561     if (!(pInfo = LOCAL_GetHeap( ds ))) return;
 562     offset = pPrevArena->size;
 563     size = pArena->next - arena - ARENA_HEADER_SIZE;
 564     LOCAL_RemoveFreeBlock( ptr, prevArena );
 565     LOCAL_RemoveBlock( ptr, arena );
 566     pInfo->items--;
 567     p = (char *)pPrevArena + ARENA_HEADER_SIZE;
 568     while (offset < size)
 569     {
 570         memcpy( p, p + offset, offset );
 571         p += offset;
 572         size -= offset;
 573     }
 574     if (size) memcpy( p, p + offset, size );
 575     LOCAL_ShrinkArena( ds, prevArena, newsize );
 576 }
 577
 578
 579
 580 /***********************************************************************
 581  *           LOCAL_GrowArenaUpward
 582  *
 583  * Grow an arena upward by using the next arena (must be free and big
 584  * enough). Newsize includes the arena header and must be aligned.
 585  */
 586 static void LOCAL_GrowArenaUpward( WORD ds, WORD arena, WORD newsize )
 587 {
 588     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
 589     LOCALHEAPINFO *pInfo;
 590     LOCALARENA *pArena = ARENA_PTR( ptr, arena );
 591     WORD nextArena = pArena->next;
 592
 593     if (!(pInfo = LOCAL_GetHeap( ds ))) return;
 594     LOCAL_RemoveBlock( ptr, nextArena );
 595     pInfo->items--;
 596     LOCAL_ShrinkArena( ds, arena, newsize );
 597 }
 598
 599
 600 /***********************************************************************
 601  *           LOCAL_GetFreeSpace
 602  */
 603 static WORD LOCAL_GetFreeSpace(WORD ds, WORD countdiscard)
 604 {
 605     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
 606     LOCALHEAPINFO *pInfo;
 607     LOCALARENA *pArena;
 608     WORD arena;
 609     WORD freespace = 0;
 610
 611     if (!(pInfo = LOCAL_GetHeap( ds )))
 612     {
 613         fprintf( stderr, "LOCAL_GetFreeSpace: Local heap not found\n" );
 614         LOCAL_PrintHeap(ds);
 615         return 0;
 616     }
 617     arena = pInfo->first;
 618     pArena = ARENA_PTR( ptr, arena );
 619     while (arena != pArena->free_next)
 620     {
 621         arena = pArena->free_next;
 622         pArena = ARENA_PTR( ptr, arena );
 623         if (pArena->size >= freespace) freespace = pArena->size;
 624     }
 625     /* FIXME doesn't yet calculate space that would become free if everything
 626        were discarded when countdiscard == 1 */
 627     if (freespace < ARENA_HEADER_SIZE) freespace = 0;
 628     else freespace -= ARENA_HEADER_SIZE;
 629     return freespace;
 630 }
 631
 632
 633 /***********************************************************************
 634  *           LOCAL_Compact
 635  */
 636 static WORD LOCAL_Compact( HANDLE16 ds, WORD minfree, WORD flags )
 637 {
 638     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
 639     LOCALHEAPINFO *pInfo;
 640     LOCALARENA *pArena, *pMoveArena, *pFinalArena;
 641     WORD arena, movearena, finalarena, table;
 642     WORD count, movesize, size;
 643     WORD freespace;
 644     LOCALHANDLEENTRY *pEntry;
 645
 646     if (!(pInfo = LOCAL_GetHeap( ds )))
 647     {
 648         fprintf( stderr, "Local_Compact: Local heap not found\n" );
 649         LOCAL_PrintHeap(ds);
 650         return 0;
 651     }
 652     dprintf_local(stddeb,
 653                   "LOCAL_Compact: ds = %04x, minfree = %04x, flags = %04x\n",
 654                   ds, minfree, flags);
 655     freespace = LOCAL_GetFreeSpace(ds, minfree ? 0 : 1);
 656     if(freespace >= minfree || (flags & LMEM_NOCOMPACT))
 657     {
 658         dprintf_local(stddeb, "Returning %04x.\n", freespace);
 659         return freespace;
 660     }
 661     dprintf_local(stddeb, "Local_Compact: Compacting heap %04x.\n", ds);
 662     table = pInfo->htable;
 663     while(table)
 664     {
 665         pEntry = (LOCALHANDLEENTRY *)(ptr + table + sizeof(WORD));
 666         for(count = *(WORD *)(ptr + table); count > 0; count--, pEntry++)
 667         {
 668             if((pEntry->lock == 0) && (pEntry->flags != (LMEM_DISCARDED >> 8)))
 669             {
 670                 /* OK we can move this one if we want */
 671                 dprintf_local(stddeb,
 672                               "handle %04x (block %04x) can be moved.\n",
 673                               (WORD)((char *)pEntry - ptr), pEntry->addr);
 674                 movearena = ARENA_HEADER(pEntry->addr);
 675                 pMoveArena = ARENA_PTR(ptr, movearena);
 676                 movesize = pMoveArena->next - movearena;
 677                 arena = pInfo->first;
 678                 pArena = ARENA_PTR(ptr, arena);
 679                 size = 0xffff;
 680                 finalarena = 0;
 681                 /* Try to find the smallest arena that will do, */
 682                 /* which is below us in memory */
 683                 for(;;)
 684                 {
 685                     arena = pArena->free_next;
 686                     pArena = ARENA_PTR(ptr, arena);
 687                     if(arena >= movearena)
 688                         break;
 689                     if(arena == pArena->free_next)
 690                         break;
 691                     if((pArena->size >= movesize) && (pArena->size < size))
 692                     {
 693                         size = pArena->size;
 694                         finalarena = arena;
 695                     }
 696                 }
 697                 if (finalarena) /* Actually got somewhere to move */
 698                 {
 699                     dprintf_local(stddeb, "Moving it to %04x.\n", finalarena);
 700                     pFinalArena = ARENA_PTR(ptr, finalarena);
 701                     size = pFinalArena->size;
 702                     LOCAL_RemoveFreeBlock(ptr, finalarena);
 703                     LOCAL_ShrinkArena( ds, finalarena, movesize );
 704                     /* Copy the arena to it's new location */
 705                     memcpy((char *)pFinalArena + ARENA_HEADER_SIZE,
 706                            (char *)pMoveArena + ARENA_HEADER_SIZE,
 707                            movesize - ARENA_HEADER_SIZE );
 708                     /* Free the old location */
 709                     LOCAL_FreeArena(ds, movearena);
 710                     /* Update handle table entry */
 711                     pEntry->addr = finalarena + ARENA_HEADER_SIZE;
 712                 }
 713                 else if((ARENA_PTR(ptr, pMoveArena->prev & ~3)->prev & 3)
 714                                == LOCAL_ARENA_FREE)
 715                 {
 716                     /* Previous arena is free (but < movesize)  */
 717                     /* so we can 'slide' movearena down into it */
 718                     finalarena = pMoveArena->prev & ~3;
 719                     LOCAL_GrowArenaDownward( ds, movearena, movesize );
 720                     /* Update handle table entry */
 721                     pEntry->addr = finalarena + ARENA_HEADER_SIZE;
 722                 }
 723             }
 724         }
 725         table = *(WORD *)pEntry;
 726     }
 727     freespace = LOCAL_GetFreeSpace(ds, minfree ? 0 : 1);
 728     if(freespace >= minfree || (flags & LMEM_NODISCARD))
 729     {
 730         dprintf_local(stddeb, "Returning %04x.\n", freespace);
 731         return freespace;
 732     }
 733
 734     table = pInfo->htable;
 735     while(table)
 736     {
 737         pEntry = (LOCALHANDLEENTRY *)(ptr + table + sizeof(WORD));
 738         for(count = *(WORD *)(ptr + table); count > 0; count--, pEntry++)
 739         {
 740             if(pEntry->addr && pEntry->lock == 0 &&
 741              (pEntry->flags & (LMEM_DISCARDABLE >> 8)))
 742             {
 743                 dprintf_local(stddeb, "Discarding handle %04x (block %04x).\n",
 744                               (char *)pEntry - ptr, pEntry->addr);
 745                 LOCAL_FreeArena(ds, ARENA_HEADER(pEntry->addr));
 746                 pEntry->addr = 0;
 747                 pEntry->flags = (LMEM_DISCARDED >> 8);
 748                 /* Call localnotify proc */
 749             }
 750         }
 751         table = *(WORD *)pEntry;
 752     }
 753     return LOCAL_Compact(ds, 0xffff, LMEM_NODISCARD);
 754 }
 755
 756
 757 /***********************************************************************
 758  *           LOCAL_FindFreeBlock
 759  */
 760 static HLOCAL16 LOCAL_FindFreeBlock( HANDLE16 ds, WORD size )
 761 {
 762     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
 763     LOCALHEAPINFO *pInfo;
 764     LOCALARENA *pArena;
 765     WORD arena;
 766
 767     if (!(pInfo = LOCAL_GetHeap( ds )))
 768     {
 769         fprintf( stderr, "Local_FindFreeBlock: Local heap not found\n" );
 770         LOCAL_PrintHeap(ds);
 771         return 0;
 772     }
 773
 774     arena = pInfo->first;
 775     pArena = ARENA_PTR( ptr, arena );
 776     for (;;) {
 777         arena = pArena->free_next;
 778         pArena = ARENA_PTR( ptr, arena );
 779         if (arena == pArena->free_next) break;
 780         if (pArena->size >= size) return arena;
 781     }
 782     dprintf_local( stddeb, "Local_FindFreeBlock: not enough space\n" );
 783     if (debugging_local) LOCAL_PrintHeap(ds);
 784     return 0;
 785 }
 786
 787 /***********************************************************************
 788  *           LOCAL_GetBlock
 789  * The segment may get moved around in this function, so all callers
 790  * should reset their pointer variables.
 791  */
 792 static HLOCAL16 LOCAL_GetBlock( HANDLE16 ds, WORD size, WORD flags )
 793 {
 794     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
 795     LOCALHEAPINFO *pInfo;
 796     LOCALARENA *pArena;
 797     WORD arena;
 798
 799     if (!(pInfo = LOCAL_GetHeap( ds )))
 800     {
 801         fprintf( stderr, "Local_GetBlock: Local heap not found\n");
 802         LOCAL_PrintHeap(ds);
 803         return 0;
 804     }
 805
 806     size += ARENA_HEADER_SIZE;
 807     size = LALIGN( MAX( size, sizeof(LOCALARENA) ) );
 808
 809       /* Find a suitable free block */
 810     arena = LOCAL_FindFreeBlock( ds, size );
 811     if (arena == 0) {
 812         /* no space: try to make some */
 813         LOCAL_Compact( ds, size, flags );
 814         arena = LOCAL_FindFreeBlock( ds, size );
 815     }
 816     if (arena == 0) {
 817         /* still no space: try to grow the segment */
 818         LOCAL_GrowHeap( ds );
 819         ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
 820         pInfo = LOCAL_GetHeap( ds );
 821         arena = LOCAL_FindFreeBlock( ds, size );
 822     }
 823     if (arena == 0) {
 824         fprintf( stderr, "Local_GetBlock: not enough space in heap %04x for %d bytes\n",
 825                  ds, size );
 826         return 0;
 827     }
 828
 829       /* Make a block out of the free arena */
 830     pArena = ARENA_PTR( ptr, arena );
 831     dprintf_local(stddeb, "LOCAL_GetBlock size = %04x, arena %04x size %04x\n",
 832                   size, arena, pArena->size );
 833     LOCAL_RemoveFreeBlock( ptr, arena );
 834     LOCAL_ShrinkArena( ds, arena, size );
 835
 836     if (flags & LMEM_ZEROINIT)
 837         memset((char *)pArena + ARENA_HEADER_SIZE, 0, size-ARENA_HEADER_SIZE);
 838     return arena + ARENA_HEADER_SIZE;
 839 }
 840
 841
 842 /***********************************************************************
 843  *           LOCAL_NewHTable
 844  */
 845 static BOOL16 LOCAL_NewHTable( HANDLE16 ds )
 846 {
 847     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
 848     LOCALHEAPINFO *pInfo;
 849     LOCALHANDLEENTRY *pEntry;
 850     HLOCAL16 handle;
 851     int i;
 852
 853     dprintf_local( stddeb, "Local_NewHTable\n" );
 854     if (!(pInfo = LOCAL_GetHeap( ds )))
 855     {
 856         fprintf( stderr, "Local heap not found\n");
 857         LOCAL_PrintHeap(ds);
 858         return FALSE;
 859     }
 860
 861     if (!(handle = LOCAL_GetBlock( ds, pInfo->hdelta * sizeof(LOCALHANDLEENTRY)
 862                                    + 2 * sizeof(WORD), LMEM_FIXED )))
 863         return FALSE;
 864     if (!(ptr = PTR_SEG_OFF_TO_LIN( ds, 0 )))
 865         fprintf(stderr, "LOCAL_NewHTable: ptr == NULL after GetBlock.\n");
 866     if (!(pInfo = LOCAL_GetHeap( ds )))
 867         fprintf(stderr,"LOCAL_NewHTable: pInfo == NULL after GetBlock.\n");
 868
 869     /* Fill the entry table */
 870
 871     *(WORD *)(ptr + handle) = pInfo->hdelta;
 872     pEntry = (LOCALHANDLEENTRY *)(ptr + handle + sizeof(WORD));
 873     for (i = pInfo->hdelta; i > 0; i--, pEntry++) {
 874         pEntry->lock = pEntry->flags = 0xff;
 875         pEntry->addr = 0;
 876     }
 877     *(WORD *)pEntry = pInfo->htable;
 878     pInfo->htable = handle;
 879     return TRUE;
 880 }
 881
 882
 883 /***********************************************************************
 884  *           LOCAL_GetNewHandleEntry
 885  */
 886 static HLOCAL16 LOCAL_GetNewHandleEntry( HANDLE16 ds )
 887 {
 888     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
 889     LOCALHEAPINFO *pInfo;
 890     LOCALHANDLEENTRY *pEntry = NULL;
 891     WORD table;
 892
 893     if (!(pInfo = LOCAL_GetHeap( ds )))
 894     {
 895         fprintf( stderr, "LOCAL_GetNewHandleEntry: Local heap not found\n");
 896         LOCAL_PrintHeap(ds);
 897         return 0;
 898     }
 899
 900     /* Find a free slot in existing tables */
 901
 902     table = pInfo->htable;
 903     while (table)
 904     {
 905         WORD count = *(WORD *)(ptr + table);
 906         pEntry = (LOCALHANDLEENTRY *)(ptr + table + sizeof(WORD));
 907         for (; count > 0; count--, pEntry++)
 908             if (pEntry->lock == 0xff) break;
 909         if (count) break;
 910         table = *(WORD *)pEntry;
 911     }
 912
 913     if (!table)  /* We need to create a new table */
 914     {
 915         if (!LOCAL_NewHTable( ds )) return 0;
 916         ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
 917         pInfo = LOCAL_GetHeap( ds );
 918         pEntry = (LOCALHANDLEENTRY *)(ptr + pInfo->htable + sizeof(WORD));
 919     }
 920
 921     /* Now allocate this entry */
 922
 923     pEntry->lock = 0;
 924     pEntry->flags = 0;
 925     dprintf_local( stddeb, "LOCAL_GetNewHandleEntry(%04x): %04x\n",
 926                    ds, ((char *)pEntry - ptr) );
 927     return (HLOCAL16)((char *)pEntry - ptr);
 928 }
 929
 930
 931 /***********************************************************************
 932  *           LOCAL_FreeHandleEntry
 933  *
 934  * Free a handle table entry.
 935  */
 936 static void LOCAL_FreeHandleEntry( HANDLE16 ds, HLOCAL16 handle )
 937 {
 938     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
 939     LOCALHANDLEENTRY *pEntry = (LOCALHANDLEENTRY *)(ptr + handle);
 940     LOCALHEAPINFO *pInfo;
 941     WORD *pTable;
 942     WORD table, count, i;
 943
 944     if (!(pInfo = LOCAL_GetHeap( ds ))) return;
 945
 946     /* Find the table where this handle comes from */
 947
 948     pTable = &pInfo->htable;
 949     while (*pTable)
 950     {
 951         WORD size = (*(WORD *)(ptr + *pTable)) * sizeof(LOCALHANDLEENTRY);
 952         if ((handle >= *pTable + sizeof(WORD)) &&
 953             (handle < *pTable + sizeof(WORD) + size)) break;  /* Found it */
 954         pTable = (WORD *)(ptr + *pTable + sizeof(WORD) + size);
 955     }
 956     if (!*pTable)
 957     {
 958         fprintf(stderr, "LOCAL_FreeHandleEntry: invalid entry %04x\n", handle);
 959         LOCAL_PrintHeap( ds );
 960         return;
 961     }
 962
 963     /* Make the entry free */
 964
 965     pEntry->addr = 0;  /* just in case */
 966     pEntry->lock = 0xff;
 967     pEntry->flags = 0xff;
 968     /* Now check if all entries in this table are free */
 969
 970     table = *pTable;
 971     pEntry = (LOCALHANDLEENTRY *)(ptr + table + sizeof(WORD));
 972     count = *(WORD *)(ptr + table);
 973     for (i = count; i > 0; i--, pEntry++) if (pEntry->lock != 0xff) return;
 974
 975     /* Remove the table from the linked list and free it */
 976
 977     dprintf_local( stddeb, "LOCAL_FreeHandleEntry(%04x): freeing table %04x\n",
 978                    ds, table);
 979     *pTable = *(WORD *)pEntry;
 980     LOCAL_FreeArena( ds, ARENA_HEADER( table ) );
 981 }
 982
 983
 984 /***********************************************************************
 985  *           LOCAL_Free
 986  *
 987  * Implementation of LocalFree().
 988  */
 989 HLOCAL16 LOCAL_Free( HANDLE16 ds, HLOCAL16 handle )
 990 {
 991     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
 992
 993     dprintf_local( stddeb, "LocalFree: %04x ds=%04x\n", handle, ds );
 994
 995     if (!handle) { fprintf( stderr, "LOCAL_Free: handle is 0.\n" ); return 0; }
 996     if (HANDLE_FIXED( handle ))
 997     {
 998         if (!LOCAL_FreeArena( ds, ARENA_HEADER( handle ) )) return 0;  /* OK */
 999         else return handle;  /* couldn't free it */
1000     }
1001     else
1002     {
1003         LOCALHANDLEENTRY *pEntry = (LOCALHANDLEENTRY *)(ptr + handle);
1004         if (pEntry->flags != (LMEM_DISCARDED >> 8))
1005         {
1006             dprintf_local( stddeb, "LocalFree: real block at %04x\n",
1007                            pEntry->addr );
1008             if (LOCAL_FreeArena( ds, ARENA_HEADER(pEntry->addr) ))
1009                 return handle; /* couldn't free it */
1010         }
1011         LOCAL_FreeHandleEntry( ds, handle );
1012         return 0;  /* OK */
1013     }
1014 }
1015
1016
1017 /***********************************************************************
1018  *           LOCAL_Alloc
1019  *
1020  * Implementation of LocalAlloc().
1021  *
1022  */
1023 HLOCAL16 LOCAL_Alloc( HANDLE16 ds, WORD flags, WORD size )
1024 {
1025     char *ptr;
1026     HLOCAL16 handle;
1027
1028     dprintf_local( stddeb, "LocalAlloc: %04x %d ds=%04x\n", flags, size, ds );
1029
1030     if(size > 0 && size <= 4) size = 5;
1031     if (flags & LMEM_MOVEABLE)
1032     {
1033         LOCALHANDLEENTRY *plhe;
1034         HLOCAL16 hmem;
1035
1036         if(size)
1037         {
1038             if (!(hmem = LOCAL_GetBlock( ds, size + sizeof(HLOCAL16), flags )))
1039                 return 0;
1040         }
1041         else /* We just need to allocate a discarded handle */
1042             hmem = 0;
1043         if (!(handle = LOCAL_GetNewHandleEntry( ds )))
1044         {
1045             fprintf( stderr, "LocalAlloc: couldn't get handle\n");
1046             if(hmem)
1047                 LOCAL_FreeArena( ds, ARENA_HEADER(hmem) );
1048             return 0;
1049         }
1050         ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
1051         plhe = (LOCALHANDLEENTRY *)(ptr + handle);
1052         plhe->lock = 0;
1053         if(hmem)
1054         {
1055             plhe->addr = hmem + sizeof(HLOCAL16);
1056             plhe->flags = (BYTE)((flags & 0x0f00) >> 8);
1057             *(HLOCAL16 *)(ptr + hmem) = handle;
1058         }
1059         else
1060         {
1061             plhe->addr = 0;
1062             plhe->flags = LMEM_DISCARDED >> 8;
1063         }
1064     }
1065     else /* FIXED */
1066     {
1067         if(!size)
1068             return 0;
1069         handle = LOCAL_GetBlock( ds, size, flags );
1070     }
1071     return handle;
1072 }
1073
1074
1075 /***********************************************************************
1076  *           LOCAL_ReAlloc
1077  *
1078  * Implementation of LocalReAlloc().
1079  */
1080 HLOCAL16 LOCAL_ReAlloc( HANDLE16 ds, HLOCAL16 handle, WORD size, WORD flags )
1081 {
1082     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
1083     LOCALHEAPINFO *pInfo;
1084     LOCALARENA *pArena, *pNext;
1085     LOCALHANDLEENTRY *pEntry;
1086     WORD arena, oldsize;
1087     HLOCAL16 hmem, blockhandle;
1088     LONG nextarena;
1089
1090     if (!handle) return 0;
1091     if(HANDLE_MOVEABLE(handle) &&
1092      ((LOCALHANDLEENTRY *)(ptr + handle))->lock == 0xff) /* An unused handle */
1093         return 0;
1094
1095     dprintf_local( stddeb, "LocalReAlloc: %04x %d %04x ds=%04x\n",
1096                    handle, size, flags, ds );
1097     if (!(pInfo = LOCAL_GetHeap( ds ))) return 0;
1098
1099     if (HANDLE_FIXED( handle ))
1100         blockhandle = handle;
1101     else
1102     {
1103         pEntry = (LOCALHANDLEENTRY *) (ptr + handle);
1104         if(pEntry->flags == (LMEM_DISCARDED >> 8))
1105         {
1106             HLOCAL16 hl;
1107             if(pEntry->addr)
1108                 fprintf(stderr,
1109                         "LOCAL_ReAlloc: Dicarded block has non-zero addr.\n");
1110             dprintf_local(stddeb, "ReAllocating discarded block\n");
1111             if(size <= 4) size = 5;
1112             if (!(hl = LOCAL_GetBlock( ds, size + sizeof(HLOCAL16), flags)))
1113                 return 0;
1114             ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );  /* Reload ptr */
1115             pEntry = (LOCALHANDLEENTRY *) (ptr + handle);
1116             pEntry->addr = hl + sizeof(HLOCAL16);
1117             pEntry->flags = 0;
1118             pEntry->lock = 0;
1119             *(HLOCAL16 *)(ptr + hl) = handle;
1120             return handle;
1121         }
1122         if (((blockhandle = pEntry->addr) & 3) != 2)
1123         {
1124             fprintf( stderr, "Local_ReAlloc(%04x,%04x): invalid handle\n",
1125                      ds, handle );
1126             return 0;
1127         }
1128         if(*((HLOCAL16 *)(ptr + blockhandle) - 1) != handle) {
1129             fprintf(stderr, "Local_ReAlloc: Back ptr to handle is invalid\n");
1130             return 0;
1131         }
1132     }
1133
1134     if (flags & LMEM_MODIFY)
1135     {
1136         if (HANDLE_MOVEABLE(handle))
1137         {
1138             pEntry = (LOCALHANDLEENTRY *)(ptr + handle);
1139             pEntry->flags = (flags & 0x0f00) >> 8;
1140             dprintf_local(stddeb, "Changing flags to %x.\n", pEntry->flags);
1141         }
1142         return handle;
1143     }
1144
1145     if (!size)
1146     {
1147         if (flags & LMEM_MOVEABLE)
1148         {
1149             if (HANDLE_FIXED(handle))
1150             {
1151                 dprintf_local(stddeb, "Freeing fixed block.\n");
1152                 return LOCAL_Free( ds, handle );
1153             }
1154             else /* Moveable block */
1155             {
1156                 pEntry = (LOCALHANDLEENTRY *)(ptr + handle);
1157                 if (pEntry->lock == 0)
1158                 {
1159                     /* discards moveable blocks */
1160                     dprintf_local(stddeb,"Discarding block\n");
1161                     LOCAL_FreeArena(ds, ARENA_HEADER(pEntry->addr));
1162                     pEntry->addr = 0;
1163                     pEntry->flags = (LMEM_DISCARDED >> 8);
1164                     return handle;
1165                 }
1166             }
1167             return 0;
1168         }
1169         else if(flags == 0)
1170         {
1171             pEntry = (LOCALHANDLEENTRY *)(ptr + handle);
1172             if (pEntry->lock == 0)
1173             {
1174                 /* Frees block */
1175                 return LOCAL_Free( ds, handle );
1176             }
1177         }
1178         return 0;
1179     }
1180
1181     arena = ARENA_HEADER( blockhandle );
1182     dprintf_local( stddeb, "LocalReAlloc: arena is %04x\n", arena );
1183     pArena = ARENA_PTR( ptr, arena );
1184
1185     if(size <= 4) size = 5;
1186     oldsize = pArena->next - arena - ARENA_HEADER_SIZE;
1187     nextarena = LALIGN(blockhandle + size);
1188
1189       /* Check for size reduction */
1190
1191     if (nextarena <= pArena->next)
1192     {
1193         dprintf_local( stddeb, "size reduction, making new free block\n");
1194         LOCAL_ShrinkArena(ds, arena, nextarena - arena);
1195         dprintf_local( stddeb, "LocalReAlloc: returning %04x\n", handle );
1196         return handle;
1197     }
1198
1199       /* Check if the next block is free and large enough */
1200
1201     pNext = ARENA_PTR( ptr, pArena->next );
1202     if (((pNext->prev & 3) == LOCAL_ARENA_FREE) &&
1203         (nextarena <= pNext->next))
1204     {
1205         dprintf_local( stddeb, "size increase, making new free block\n");
1206         LOCAL_GrowArenaUpward(ds, arena, nextarena - arena);
1207         dprintf_local( stddeb, "LocalReAlloc: returning %04x\n", handle );
1208         return handle;
1209     }
1210
1211     /* Now we have to allocate a new block, but not if (fixed block or locked
1212        block) and no LMEM_MOVEABLE */
1213
1214     if (!(flags & LMEM_MOVEABLE))
1215     {
1216         if (HANDLE_FIXED(handle))
1217         {
1218             dprintf_local(stddeb,
1219              "Needed to move fixed block, but LMEM_MOVEABLE not specified.\n");
1220             return 0;
1221         }
1222         else
1223         {
1224             if(((LOCALHANDLEENTRY *)(ptr + handle))->lock != 0)
1225             {
1226                 dprintf_local(stddeb,
1227         "Needed to move locked block, but LMEM_MOVEABLE not specified.\n");
1228                 return 0;
1229             }
1230         }
1231     }
1232     if(HANDLE_MOVEABLE(handle)) size += sizeof(HLOCAL16);
1233     hmem = LOCAL_GetBlock( ds, size, flags );
1234     ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );  /* Reload ptr */
1235     if (!hmem)
1236     {
1237         /* Remove the block from the heap and try again */
1238         LPSTR buffer = HeapAlloc( SystemHeap, 0, oldsize );
1239         if (!buffer) return 0;
1240         memcpy( buffer, ptr + arena + ARENA_HEADER_SIZE, oldsize );
1241         LOCAL_FreeArena( ds, arena );
1242         if (!(hmem = LOCAL_GetBlock( ds, size, flags )))
1243         {
1244             if (!(hmem = LOCAL_GetBlock( ds, oldsize, flags )))
1245             {
1246                 fprintf( stderr, "LocalRealloc: can't restore saved block\n" );
1247                 HeapFree( SystemHeap, 0, buffer );
1248                 return 0;
1249             }
1250             size = oldsize;
1251         }
1252         ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );  /* Reload ptr */
1253         memcpy( ptr + hmem, buffer, oldsize );
1254         HeapFree( SystemHeap, 0, buffer );
1255     }
1256     else
1257     {
1258         memcpy( ptr + hmem, ptr + (arena + ARENA_HEADER_SIZE), oldsize );
1259         LOCAL_FreeArena( ds, arena );
1260     }
1261     if (HANDLE_MOVEABLE( handle ))
1262     {
1263         dprintf_local( stddeb, "LocalReAlloc: fixing handle\n");
1264         pEntry = (LOCALHANDLEENTRY *)(ptr + handle);
1265         pEntry->addr = hmem + sizeof(HLOCAL16);
1266         /* Back ptr should still be correct */
1267         if(*(HLOCAL16 *)(ptr + hmem) != handle)
1268             fprintf(stderr, "Local_ReAlloc: back ptr is invalid.\n");
1269         hmem = handle;
1270     }
1271     if (size == oldsize) hmem = 0;  /* Realloc failed */
1272     dprintf_local( stddeb, "LocalReAlloc: returning %04x\n", hmem );
1273     return hmem;
1274 }
1275
1276
1277 /***********************************************************************
1278  *           LOCAL_InternalLock
1279  */
1280 static HLOCAL16 LOCAL_InternalLock( LPSTR heap, HLOCAL16 handle )
1281 {
1282     dprintf_local( stddeb, "LocalLock: %04x ", handle );
1283     if (HANDLE_MOVEABLE(handle))
1284     {
1285         LOCALHANDLEENTRY *pEntry = (LOCALHANDLEENTRY *)(heap + handle);
1286         if (pEntry->flags == LMEM_DISCARDED) return 0;
1287         if (pEntry->lock < 0xfe) pEntry->lock++;
1288         handle = pEntry->addr;
1289     }
1290     dprintf_local( stddeb, "returning %04x\n", handle );
1291     return handle;
1292 }
1293
1294
1295 /***********************************************************************
1296  *           LOCAL_Lock
1297  */
1298 LPSTR LOCAL_Lock( HANDLE16 ds, HLOCAL16 handle )
1299 {
1300     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
1301     return handle ? ptr + LOCAL_InternalLock( ptr, handle ) : NULL;
1302 }
1303
1304
1305 /***********************************************************************
1306  *           LOCAL_LockSegptr
1307  */
1308 SEGPTR LOCAL_LockSegptr( HANDLE16 ds, HLOCAL16 handle )
1309 {
1310     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
1311     return PTR_SEG_OFF_TO_SEGPTR( ds, LOCAL_InternalLock( ptr, handle ) );
1312 }
1313
1314
1315 /***********************************************************************
1316  *           LOCAL_Unlock
1317  */
1318 BOOL16 LOCAL_Unlock( HANDLE16 ds, HLOCAL16 handle )
1319 {
1320     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
1321
1322     dprintf_local( stddeb, "LocalUnlock: %04x\n", handle );
1323     if (HANDLE_MOVEABLE(handle))
1324     {
1325         LOCALHANDLEENTRY *pEntry = (LOCALHANDLEENTRY *)(ptr + handle);
1326         if (!pEntry->lock || (pEntry->lock == 0xff)) return FALSE;
1327         /* For moveable block, return the new lock count */
1328         /* (see _Windows_Internals_ p. 197) */
1329         return --pEntry->lock;
1330     }
1331     else return FALSE;
1332 }
1333
1334
1335 /***********************************************************************
1336  *           LOCAL_Size
1337  *
1338  * Implementation of LocalSize().
1339  */
1340 WORD LOCAL_Size( HANDLE16 ds, HLOCAL16 handle )
1341 {
1342     char *ptr = PTR_SEG_OFF_TO_LIN( CURRENT_DS, 0 );
1343     LOCALARENA *pArena;
1344
1345     dprintf_local( stddeb, "LocalSize: %04x ds=%04x\n", handle, ds );
1346
1347     if (HANDLE_MOVEABLE( handle )) handle = *(WORD *)(ptr + handle);
1348     if (!handle) return 0;
1349     pArena = ARENA_PTR( ptr, ARENA_HEADER(handle) );
1350     return pArena->next - handle;
1351 }
1352
1353
1354 /***********************************************************************
1355  *           LOCAL_Flags
1356  *
1357  * Implementation of LocalFlags().
1358  */
1359 WORD LOCAL_Flags( HANDLE16 ds, HLOCAL16 handle )
1360 {
1361     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
1362
1363     if (HANDLE_MOVEABLE(handle))
1364     {
1365         LOCALHANDLEENTRY *pEntry = (LOCALHANDLEENTRY *)(ptr + handle);
1366         dprintf_local( stddeb, "LOCAL_Flags(%04x,%04x): returning %04x\n",
1367                        ds, handle, pEntry->lock | (pEntry->flags << 8) );
1368         return pEntry->lock | (pEntry->flags << 8);
1369     }
1370     else
1371     {
1372         dprintf_local( stddeb, "LOCAL_Flags(%04x,%04x): returning 0\n",
1373                        ds, handle );
1374         return 0;
1375     }
1376 }
1377
1378
1379 /***********************************************************************
1380  *           LOCAL_HeapSize
1381  *
1382  * Implementation of LocalHeapSize().
1383  */
1384 WORD LOCAL_HeapSize( HANDLE16 ds )
1385 {
1386     LOCALHEAPINFO *pInfo = LOCAL_GetHeap( ds );
1387     if (!pInfo) return 0;
1388     return pInfo->last - pInfo->first;
1389 }
1390
1391
1392 /***********************************************************************
1393  *           LOCAL_CountFree
1394  *
1395  * Implementation of LocalCountFree().
1396  */
1397 WORD LOCAL_CountFree( HANDLE16 ds )
1398 {
1399     WORD arena, total;
1400     LOCALARENA *pArena;
1401     LOCALHEAPINFO *pInfo;
1402     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
1403
1404     if (!(pInfo = LOCAL_GetHeap( ds )))
1405     {
1406         fprintf( stderr, "LOCAL_Handle(%04x): Local heap not found\n", ds );
1407         LOCAL_PrintHeap( ds );
1408         return 0;
1409     }
1410
1411     total = 0;
1412     arena = pInfo->first;
1413     pArena = ARENA_PTR( ptr, arena );
1414     for (;;)
1415     {
1416         arena = pArena->free_next;
1417         pArena = ARENA_PTR( ptr, arena );
1418         if (arena == pArena->free_next) break;
1419         total += pArena->size;
1420     }
1421     dprintf_local( stddeb, "LOCAL_CountFree(%04x): returning %d\n", ds, total);
1422     return total;
1423 }
1424
1425
1426 /***********************************************************************
1427  *           LOCAL_Handle
1428  *
1429  * Implementation of LocalHandle().
1430  */
1431 HLOCAL16 LOCAL_Handle( HANDLE16 ds, WORD addr )
1432 {
1433     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
1434     LOCALHEAPINFO *pInfo;
1435     WORD table;
1436
1437     if (!(pInfo = LOCAL_GetHeap( ds )))
1438     {
1439         fprintf( stderr, "LOCAL_Handle(%04x): Local heap not found\n", ds );
1440         LOCAL_PrintHeap( ds );
1441         return 0;
1442     }
1443
1444     /* Find the address in the entry tables */
1445
1446     table = pInfo->htable;
1447     while (table)
1448     {
1449         WORD count = *(WORD *)(ptr + table);
1450         LOCALHANDLEENTRY *pEntry = (LOCALHANDLEENTRY*)(ptr+table+sizeof(WORD));
1451         for (; count > 0; count--, pEntry++)
1452             if (pEntry->addr == addr) return (HLOCAL16)((char *)pEntry - ptr);
1453         table = *(WORD *)pEntry;
1454     }
1455
1456     return (HLOCAL16)addr;  /* Fixed block handle is addr */
1457 }
1458
1459
1460 /***********************************************************************
1461  *           LocalAlloc16   (KERNEL.5)
1462  */
1463 HLOCAL16 LocalAlloc16( UINT16 flags, WORD size )
1464 {
1465     return LOCAL_Alloc( CURRENT_DS, flags, size );
1466 }
1467
1468
1469 /***********************************************************************
1470  *           LocalReAlloc16   (KERNEL.6)
1471  */
1472 HLOCAL16 LocalReAlloc16( HLOCAL16 handle, WORD size, UINT16 flags )
1473 {
1474     return LOCAL_ReAlloc( CURRENT_DS, handle, size, flags );
1475 }
1476
1477
1478 /***********************************************************************
1479  *           LocalFree16   (KERNEL.7)
1480  */
1481 HLOCAL16 LocalFree16( HLOCAL16 handle )
1482 {
1483     return LOCAL_Free( CURRENT_DS, handle );
1484 }
1485
1486
1487 /***********************************************************************
1488  *           LocalLock16   (KERNEL.8)
1489  *
1490  * Note: only the offset part of the pointer is returned by the relay code.
1491  */
1492 SEGPTR LocalLock16( HLOCAL16 handle )
1493 {
1494     return LOCAL_LockSegptr( CURRENT_DS, handle );
1495 }
1496
1497
1498 /***********************************************************************
1499  *           LocalUnlock16   (KERNEL.9)
1500  */
1501 BOOL16 LocalUnlock16( HLOCAL16 handle )
1502 {
1503     return LOCAL_Unlock( CURRENT_DS, handle );
1504 }
1505
1506
1507 /***********************************************************************
1508  *           LocalSize16   (KERNEL.10)
1509  */
1510 UINT16 LocalSize16( HLOCAL16 handle )
1511 {
1512     return LOCAL_Size( CURRENT_DS, handle );
1513 }
1514
1515
1516 /***********************************************************************
1517  *           LocalHandle16   (KERNEL.11)
1518  */
1519 HLOCAL16 LocalHandle16( WORD addr )
1520 {
1521     return LOCAL_Handle( CURRENT_DS, addr );
1522 }
1523
1524
1525 /***********************************************************************
1526  *           LocalFlags16   (KERNEL.12)
1527  */
1528 UINT16 LocalFlags16( HLOCAL16 handle )
1529 {
1530     return LOCAL_Flags( CURRENT_DS, handle );
1531 }
1532
1533
1534 /***********************************************************************
1535  *           LocalCompact16   (KERNEL.13)
1536  */
1537 UINT16 LocalCompact16( UINT16 minfree )
1538 {
1539     dprintf_local( stddeb, "LocalCompact: %04x\n", minfree );
1540     return LOCAL_Compact( CURRENT_DS, minfree, 0 );
1541 }
1542
1543
1544 /***********************************************************************
1545  *           LocalNotify   (KERNEL.14)
1546  */
1547 FARPROC16 LocalNotify( FARPROC16 func )
1548 {
1549     LOCALHEAPINFO *pInfo;
1550     FARPROC16 oldNotify;
1551     HANDLE16 ds = CURRENT_DS;
1552
1553     if (!(pInfo = LOCAL_GetHeap( ds )))
1554     {
1555         fprintf( stderr, "LOCAL_Notify(%04x): Local heap not found\n", ds );
1556         LOCAL_PrintHeap( ds );
1557         return 0;
1558     }
1559     dprintf_local( stddeb, "LocalNotify(%04x): %08lx\n", ds, (DWORD)func );
1560     fprintf(stdnimp, "LocalNotify(): Half implemented\n");
1561     oldNotify = pInfo->notify;
1562     pInfo->notify = func;
1563     return oldNotify;
1564 }
1565
1566
1567 /***********************************************************************
1568  *           LocalShrink16   (KERNEL.121)
1569  */
1570 UINT16 LocalShrink16( HGLOBAL16 handle, UINT16 newsize )
1571 {
1572     dprintf_local( stddeb, "LocalShrink: %04x %04x\n", handle, newsize );
1573     return 0;
1574 }
1575
1576
1577 /***********************************************************************
1578  *           GetHeapSpaces   (KERNEL.138)
1579  */
1580 DWORD GetHeapSpaces( HMODULE16 module )
1581 {
1582     NE_MODULE *pModule;
1583     WORD ds;
1584
1585     module = GetExePtr( module );
1586     if (!(pModule = MODULE_GetPtr( module ))) return 0;
1587     ds = (NE_SEG_TABLE( pModule ) + pModule->dgroup - 1)->selector;
1588     return MAKELONG( LOCAL_CountFree( ds ), LOCAL_HeapSize( ds ) );
1589 }
1590
1591
1592 /***********************************************************************
1593  *           LocalCountFree   (KERNEL.161)
1594  */
1595 WORD LocalCountFree(void)
1596 {
1597     return LOCAL_CountFree( CURRENT_DS );
1598 }
1599
1600
1601 /***********************************************************************
1602  *           LocalHeapSize   (KERNEL.162)
1603  */
1604 WORD LocalHeapSize()
1605 {
1606     dprintf_local( stddeb, "LocalHeapSize:\n" );
1607     return LOCAL_HeapSize( CURRENT_DS );
1608 }
1609
1610
1611 /***********************************************************************
1612  *           LocalHandleDelta   (KERNEL.310)
1613  */
1614 WORD LocalHandleDelta( WORD delta )
1615 {
1616     LOCALHEAPINFO *pInfo;
1617
1618     if (!(pInfo = LOCAL_GetHeap( CURRENT_DS )))
1619     {
1620         fprintf( stderr, "LocalHandleDelta: Local heap not found\n");
1621         LOCAL_PrintHeap( CURRENT_DS );
1622         return 0;
1623     }
1624     if (delta) pInfo->hdelta = delta;
1625     dprintf_local(stddeb, "LocalHandleDelta: returning %04x\n", pInfo->hdelta);
1626     return pInfo->hdelta;
1627 }
1628
1629
1630 /***********************************************************************
1631  *           LocalInfo   (TOOLHELP.56)
1632  */
1633 BOOL16 LocalInfo( LOCALINFO *pLocalInfo, HGLOBAL16 handle )
1634 {
1635     LOCALHEAPINFO *pInfo = LOCAL_GetHeap(SELECTOROF(WIN16_GlobalLock16(handle)));
1636     if (!pInfo) return FALSE;
1637     pLocalInfo->wcItems = pInfo->items;
1638     return TRUE;
1639 }
1640
1641
1642 /***********************************************************************
1643  *           LocalFirst   (TOOLHELP.57)
1644  */
1645 BOOL16 LocalFirst( LOCALENTRY *pLocalEntry, HGLOBAL16 handle )
1646 {
1647     WORD ds = GlobalHandleToSel( handle );
1648     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
1649     LOCALHEAPINFO *pInfo = LOCAL_GetHeap( ds );
1650     if (!pInfo) return FALSE;
1651
1652     pLocalEntry->hHandle   = pInfo->first + ARENA_HEADER_SIZE;
1653     pLocalEntry->wAddress  = pLocalEntry->hHandle;
1654     pLocalEntry->wFlags    = LF_FIXED;
1655     pLocalEntry->wcLock    = 0;
1656     pLocalEntry->wType     = LT_NORMAL;
1657     pLocalEntry->hHeap     = handle;
1658     pLocalEntry->wHeapType = NORMAL_HEAP;
1659     pLocalEntry->wNext     = ARENA_PTR(ptr,pInfo->first)->next;
1660     pLocalEntry->wSize     = pLocalEntry->wNext - pLocalEntry->hHandle;
1661     return TRUE;
1662 }
1663
1664
1665 /***********************************************************************
1666  *           LocalNext   (TOOLHELP.58)
1667  */
1668 BOOL16 LocalNext( LOCALENTRY *pLocalEntry )
1669 {
1670     WORD ds = GlobalHandleToSel( pLocalEntry->hHeap );
1671     char *ptr = PTR_SEG_OFF_TO_LIN( ds, 0 );
1672     LOCALARENA *pArena;
1673
1674     if (!LOCAL_GetHeap( ds )) return FALSE;
1675     if (!pLocalEntry->wNext) return FALSE;
1676     pArena = ARENA_PTR( ptr, pLocalEntry->wNext );
1677
1678     pLocalEntry->hHandle   = pLocalEntry->wNext + ARENA_HEADER_SIZE;
1679     pLocalEntry->wAddress  = pLocalEntry->hHandle;
1680     pLocalEntry->wFlags    = (pArena->prev & 3) + 1;
1681     pLocalEntry->wcLock    = 0;
1682     pLocalEntry->wType     = LT_NORMAL;
1683     if (pArena->next != pLocalEntry->wNext)  /* last one? */
1684         pLocalEntry->wNext = pArena->next;
1685     else
1686         pLocalEntry->wNext = 0;
1687     pLocalEntry->wSize     = pLocalEntry->wNext - pLocalEntry->hHandle;
1688     return TRUE;
1689 }
1690
1691
1692 /***********************************************************************
1693  *           LocalAlloc32   (KERNEL32.371)
1694  */
1695 HLOCAL32 LocalAlloc32( UINT32 flags, DWORD size )
1696 {
1697     return (HLOCAL32)GlobalAlloc32( flags, size );
1698 }
1699
1700
1701 /***********************************************************************
1702  *           LocalCompact32   (KERNEL32.372)
1703  */
1704 UINT32 LocalCompact32( UINT32 minfree )
1705 {
1706     return 0;  /* LocalCompact does nothing in Win32 */
1707 }
1708
1709
1710 /***********************************************************************
1711  *           LocalFlags32   (KERNEL32.374)
1712  */
1713 UINT32 LocalFlags32( HLOCAL32 handle )
1714 {
1715     return GlobalFlags32( (HGLOBAL32)handle );
1716 }
1717
1718
1719 /***********************************************************************
1720  *           LocalFree32   (KERNEL32.375)
1721  */
1722 HLOCAL32 LocalFree32( HLOCAL32 handle )
1723 {
1724     return (HLOCAL32)GlobalFree32( (HGLOBAL32)handle );
1725 }
1726
1727
1728 /***********************************************************************
1729  *           LocalHandle32   (KERNEL32.376)
1730  */
1731 HLOCAL32 LocalHandle32( LPCVOID ptr )
1732 {
1733     return (HLOCAL32)GlobalHandle32( ptr );
1734 }
1735
1736
1737 /***********************************************************************
1738  *           LocalLock32   (KERNEL32.377)
1739  */
1740 LPVOID LocalLock32( HLOCAL32 handle )
1741 {
1742     return GlobalLock32( (HGLOBAL32)handle );
1743 }
1744
1745
1746 /***********************************************************************
1747  *           LocalReAlloc32   (KERNEL32.378)
1748  */
1749 HLOCAL32 LocalReAlloc32( HLOCAL32 handle, DWORD size, UINT32 flags )
1750 {
1751     return (HLOCAL32)GlobalReAlloc32( (HGLOBAL32)handle, size, flags );
1752 }
1753
1754
1755 /***********************************************************************
1756  *           LocalShrink32   (KERNEL32.379)
1757  */
1758 UINT32 LocalShrink32( HGLOBAL32 handle, UINT32 newsize )
1759 {
1760     return 0;  /* LocalShrink does nothing in Win32 */
1761 }
1762
1763
1764 /***********************************************************************
1765  *           LocalSize32   (KERNEL32.380)
1766  */
1767 UINT32 LocalSize32( HLOCAL32 handle )
1768 {
1769     return GlobalSize32( (HGLOBAL32)handle );
1770 }
1771
1772
1773 /***********************************************************************
1774  *           LocalUnlock32   (KERNEL32.381)
1775  */
1776 BOOL32 LocalUnlock32( HLOCAL32 handle )
1777 {
1778     return GlobalUnlock32( (HGLOBAL32)handle );
1779 }