library/heap.c

   1 /*
   2  * Memory alllocation for the Wine Library toolkit
   3  *
   4  * Copyright (C) 1994 Miguel de Icaza
   5  *
   6  * All the memory management is being done by the libc malloc and friends.
   7  */
   8
   9 /* #ifndef __STDC__ */
  10 #include <malloc.h>
  11 #include <stdio.h>
  12 #include <string.h>
  13 /* #endif */
  14 #include "windows.h"
  15 #include "xmalloc.h"
  16
  17 #ifdef WINELIB16
  18
  19 /* Controls the blocks per handle table */
  20 #define MAXBLOCKS 1024
  21
  22 static char Copyright [] = "Copyright (C) 1994 Miguel de Icaza";
  23
  24 typedef struct handle_table {
  25     struct handle_table *next;
  26     void *blocks [MAXBLOCKS];
  27 } handle_table_t;
  28
  29 static handle_table_t handle_table;
  30
  31 static void **HEAP_GetFreeSlot (HANDLE *hNum)
  32 {
  33     handle_table_t *table, *last;
  34     int i, j;
  35
  36     for (table = &handle_table, j = 0; table; table = table->next, j++){
  37         for (i = 0; i < MAXBLOCKS; i++)
  38             if (!table->blocks [i])
  39                 goto AssignBlock;
  40         last = table;
  41     }
  42
  43     /* No free slots */
  44     last->next = xmalloc (sizeof (handle_table_t));
  45     table = last->next;
  46     memset (table, 0, sizeof (handle_table_t));
  47     i = 0;
  48
  49  AssignBlock:
  50     *hNum = j*MAXBLOCKS+i;
  51     return &table->blocks [i];
  52 }
  53
  54 static void HEAP_Handle_is_Zero ()
  55 {
  56     printf ("Warning: Handle is Zero, segmentation fault comming\n");
  57 }
  58
  59 static void **HEAP_FindSlot (HANDLE hNum)
  60 {
  61     handle_table_t *table = &handle_table;
  62     int i, j;
  63
  64     if (!hNum)
  65         HEAP_Handle_is_Zero ();
  66
  67     hNum--;
  68     for (j = hNum; j > MAXBLOCKS; j -= MAXBLOCKS){
  69         table = table->next;
  70         if (!table) return 0;
  71     }
  72     return &table->blocks [hNum%MAXBLOCKS];
  73 }
  74
  75 HANDLE LocalAlloc (WORD flags, WORD bytes)
  76 {
  77     void *m;
  78     void **slot;
  79     HANDLE hMem;
  80
  81     slot = HEAP_GetFreeSlot (&hMem);
  82     if ((m = malloc (bytes)))
  83     {
  84         *slot = m;
  85         if (flags & LMEM_ZEROINIT)
  86             bzero (m, bytes);
  87
  88 #ifdef DEBUG_HEAP
  89         printf ("Handle %d [%d] = %p\n", hMem+1, bytes, m);
  90 #endif
  91         return hMem+1;
  92     }
  93     return 0;
  94 }
  95
  96 WORD LocalCompact (WORD min_free)
  97 {
  98     return min_free;
  99 }
 100
 101 WORD LocalFlags (HANDLE hMem)
 102 {
 103     return 0;
 104 }
 105
 106 HANDLE LocalFree (HANDLE hMem)
 107 {
 108     void **m;
 109   if(!hMem)
 110     return 0;
 111   m = HEAP_FindSlot (hMem);
 112
 113     free (*m);
 114     *m = 0;
 115     return 0;
 116 }
 117
 118 BOOL LocalInit (WORD segment, WORD start, WORD end)
 119 {
 120     return 1;
 121 }
 122
 123 WORD LocalLock (HANDLE hMem)
 124 {
 125     void **m = HEAP_FindSlot (hMem);
 126 #ifdef DEBUG_HEAP
 127     printf (">%d->%p\n", hMem, *m);
 128 #endif
 129     return m ? *m : 0;
 130 }
 131
 132 HANDLE LocalReAlloc (HANDLE hMem, WORD flags, WORD bytes)
 133 {
 134     void **m = HEAP_FindSlot (hMem);
 135
 136     xrealloc (*m, bytes);
 137 }
 138
 139 WORD LocalSize (HANDLE hMem)
 140 {
 141     /* Not implemented yet */
 142 }
 143
 144
 145 BOOL LocalUnlock (HANDLE hMem)
 146 {
 147     return 0;
 148 }
 149
 150 HANDLE GlobalAlloc (WORD flags, DWORD size)
 151 {
 152     return LocalAlloc (flags, size);
 153 }
 154
 155 HANDLE GlobalFree (HANDLE hMem)
 156 {
 157     return LocalFree (hMem);
 158 }
 159
 160 char *GlobalLock (HANDLE hMem)
 161 {
 162     return LocalLock (hMem);
 163 }
 164
 165 BOOL GlobalUnlock (HANDLE hMem)
 166 {
 167     return LocalUnlock (hMem);
 168 }
 169
 170 WORD GlobalFlags (HANDLE hMem)
 171 {
 172     return LocalFlags (hMem);
 173 }
 174
 175 DWORD GlobalSize (HANDLE hMem)
 176 {
 177     return LocalSize (hMem);
 178 }
 179
 180 DWORD GlobalCompact(DWORD desired)
 181 {
 182     if (desired)
 183         return desired;
 184     else
 185         return 0x01000000;      /* Should check the available core. */
 186 }
 187
 188 HANDLE GlobalReAlloc(HANDLE hMem, DWORD new_size, WORD flags)
 189 {
 190     if (!(flags & GMEM_MODIFY))
 191         return LocalReAlloc (hMem, new_size, flags);
 192 }
 193
 194 int HEAP_LocalSize ()
 195 {
 196     return 0;
 197 }
 198
 199 int HEAP_LocalFindHeap ()
 200 {
 201     return 0;
 202 }
 203
 204 #ifdef UNIMPLEMENTED
 205
 206 DWORD int GlobalHandle(WORD selector)
 207 {
 208 }
 209
 210 #endif
 211
 212 #else /* WINELIB16 */
 213
 214 typedef struct { DWORD Size; DWORD Padding[3]; } HeapData;
 215
 216 HANDLE HEAP_Alloc (WORD flags, DWORD bytes)
 217 {
 218     HeapData* m;
 219
 220     bytes+=sizeof(HeapData);
 221     if ((m = malloc (bytes)))
 222     {
 223         if (flags & LMEM_ZEROINIT)
 224             bzero (m, bytes);
 225     }
 226     m->Size=bytes-sizeof(HeapData);
 227     return m+1;
 228 }
 229
 230 HANDLE HEAP_Free (HANDLE hMem)
 231 {
 232   HeapData* m;
 233   if(!hMem)
 234     return 0;
 235   m=(HeapData*)hMem;
 236   free(m-1);
 237   return 0;
 238 }
 239
 240 DWORD HEAP_Size (HANDLE hMem)
 241 {
 242   HeapData* m=(HeapData*)hMem;
 243   return (m-1)->Size;
 244 }
 245
 246 HANDLE HEAP_ReAlloc(HANDLE hMem,DWORD bytes,UINT flags)
 247 {
 248   HeapData* m=(HeapData*)hMem;
 249   if(!bytes)
 250   {
 251     free(m-1);
 252     return 0; /* Inaccurate behavior, but should suffice */
 253   }
 254   m=realloc (m-1, bytes+sizeof(HeapData));
 255   if(flags & LMEM_ZEROINIT && bytes > m->Size)
 256     bzero ((char*)m+sizeof(HeapData)+m->Size, bytes-m->Size);
 257   m->Size=bytes;
 258   return m+1;
 259 }
 260
 261 HANDLE LocalAlloc (WORD flags, WORD bytes)
 262 {
 263   return HEAP_Alloc(flags,bytes);
 264 }
 265
 266 UINT LocalFlags (HANDLE hMem)
 267 {
 268   return 0;
 269 }
 270
 271 HANDLE LocalFree (HANDLE hMem)
 272 {
 273   return HEAP_Free(hMem);
 274 }
 275
 276 BOOL LocalInit (HANDLE segment, WORD start, WORD end)
 277 {
 278   return TRUE;
 279 }
 280
 281 LPVOID LocalLock (HANDLE hMem)
 282 {
 283   return hMem;
 284 }
 285
 286 HANDLE LocalReAlloc (HANDLE hMem, WORD new_size, WORD flags)
 287 {
 288   if (!(flags & LMEM_MODIFY))
 289     return HEAP_ReAlloc (hMem, new_size, flags);
 290   else
 291     return hMem;
 292 }
 293
 294 UINT LocalSize (HANDLE hMem)
 295 {
 296   return HEAP_Size(hMem);
 297 }
 298
 299 BOOL LocalUnlock (HANDLE hMem)
 300 {
 301   return 0;
 302 }
 303
 304 HANDLE GlobalAlloc (WORD flags, DWORD size)
 305 {
 306   return HEAP_Alloc (flags,size);
 307 }
 308
 309 HANDLE GlobalFree (HANDLE hMem)
 310 {
 311   return HEAP_Free (hMem);
 312 }
 313
 314 LPVOID GlobalLock (HGLOBAL hMem)
 315 {
 316   return hMem;
 317 }
 318
 319 BOOL GlobalUnlock (HANDLE hMem)
 320 {
 321   return 0;
 322 }
 323
 324 WORD GlobalFlags (HANDLE hMem)
 325 {
 326   return LocalFlags (hMem);
 327 }
 328
 329 DWORD GlobalSize (HANDLE hMem)
 330 {
 331   return HEAP_Size (hMem);
 332 }
 333
 334 HANDLE GlobalReAlloc(HANDLE hMem, DWORD new_size, WORD flags)
 335 {
 336   if (!(flags & GMEM_MODIFY))
 337     return HEAP_ReAlloc (hMem, new_size, flags);
 338   else
 339     return hMem;
 340 }
 341
 342 #endif