toolkit/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 (flags & LMEM_WINE_ALIGN)
  83         m = memalign (4, bytes);
  84     else
  85         m = malloc (bytes);
  86     if (m){
  87         *slot = m;
  88         if (flags & LMEM_ZEROINIT)
  89             bzero (m, bytes);
  90
  91 #ifdef DEBUG_HEAP
  92         printf ("Handle %d [%d] = %p\n", hMem+1, bytes, m);
  93 #endif
  94         return hMem+1;
  95     }
  96     return 0;
  97 }
  98
  99 WORD LocalCompact (WORD min_free)
 100 {
 101     return min_free;
 102 }
 103
 104 WORD LocalFlags (HANDLE hMem)
 105 {
 106     return 0;
 107 }
 108
 109 HANDLE LocalFree (HANDLE hMem)
 110 {
 111     void **m;
 112   if(!hMem)
 113     return 0;
 114   m = HEAP_FindSlot (hMem);
 115
 116     free (*m);
 117     *m = 0;
 118     return 0;
 119 }
 120
 121 BOOL LocalInit (WORD segment, WORD start, WORD end)
 122 {
 123     return 1;
 124 }
 125
 126 WORD LocalLock (HANDLE hMem)
 127 {
 128     void **m = HEAP_FindSlot (hMem);
 129 #ifdef DEBUG_HEAP
 130     printf (">%d->%p\n", hMem, *m);
 131 #endif
 132     return m ? *m : 0;
 133 }
 134
 135 HANDLE LocalReAlloc (HANDLE hMem, WORD flags, WORD bytes)
 136 {
 137     void **m = HEAP_FindSlot (hMem);
 138
 139     xrealloc (*m, bytes);
 140 }
 141
 142 WORD LocalSize (HANDLE hMem)
 143 {
 144     /* Not implemented yet */
 145 }
 146
 147
 148 BOOL LocalUnlock (HANDLE hMem)
 149 {
 150     return 0;
 151 }
 152
 153 HANDLE GlobalAlloc (WORD flags, DWORD size)
 154 {
 155     return LocalAlloc (flags, size);
 156 }
 157
 158 HANDLE GlobalFree (HANDLE hMem)
 159 {
 160     return LocalFree (hMem);
 161 }
 162
 163 char *GlobalLock (HANDLE hMem)
 164 {
 165     return LocalLock (hMem);
 166 }
 167
 168 BOOL GlobalUnlock (HANDLE hMem)
 169 {
 170     return LocalUnlock (hMem);
 171 }
 172
 173 WORD GlobalFlags (HANDLE hMem)
 174 {
 175     return LocalFlags (hMem);
 176 }
 177
 178 DWORD GlobalSize (HANDLE hMem)
 179 {
 180     return LocalSize (hMem);
 181 }
 182
 183 DWORD GlobalCompact(DWORD desired)
 184 {
 185     if (desired)
 186         return desired;
 187     else
 188         return 0x01000000;      /* Should check the available core. */
 189 }
 190
 191 HANDLE GlobalReAlloc(HANDLE hMem, DWORD new_size, WORD flags)
 192 {
 193     if (!(flags & GMEM_MODIFY))
 194         return LocalReAlloc (hMem, new_size, flags);
 195 }
 196
 197 int HEAP_LocalSize ()
 198 {
 199     return 0;
 200 }
 201
 202 int HEAP_LocalFindHeap ()
 203 {
 204     return 0;
 205 }
 206
 207 #ifdef UNIMPLEMENTED
 208
 209 DWORD int GlobalHandle(WORD selector)
 210 {
 211 }
 212
 213 #endif
 214
 215 #else /* WINELIB16 */
 216
 217 typedef struct { DWORD Size; DWORD Padding[3]; } HeapData;
 218
 219 HANDLE HEAP_Alloc (WORD flags, DWORD bytes)
 220 {
 221     HeapData* m;
 222
 223     bytes+=sizeof(HeapData);
 224     if (flags & LMEM_WINE_ALIGN)
 225         m = memalign (4, bytes);
 226     else
 227         m = malloc (bytes);
 228     if (m){
 229         if (flags & LMEM_ZEROINIT)
 230             bzero (m, bytes);
 231     }
 232     m->Size=bytes-sizeof(HeapData);
 233     return m+1;
 234 }
 235
 236 HANDLE HEAP_Free (HANDLE hMem)
 237 {
 238   HeapData* m;
 239   if(!hMem)
 240     return 0;
 241   m=(HeapData*)hMem;
 242   free(m-1);
 243   return 0;
 244 }
 245
 246 DWORD HEAP_Size (HANDLE hMem)
 247 {
 248   HeapData* m=(HeapData*)hMem;
 249   return (m-1)->Size;
 250 }
 251
 252 HANDLE HEAP_ReAlloc(HANDLE hMem,DWORD bytes,UINT flags)
 253 {
 254   HeapData* m=(HeapData*)hMem;
 255   if(!bytes)
 256   {
 257     free(m-1);
 258     return 0; /* Inaccurate behavior, but should suffice */
 259   }
 260   m=realloc (m-1, bytes+sizeof(HeapData));
 261   if(flags & LMEM_ZEROINIT && bytes > m->Size)
 262     bzero ((char*)m+sizeof(HeapData)+m->Size, bytes-m->Size);
 263   m->Size=bytes;
 264   return m+1;
 265 }
 266
 267 HANDLE LocalAlloc (WORD flags, WORD bytes)
 268 {
 269   return HEAP_Alloc(flags,bytes);
 270 }
 271
 272 UINT LocalFlags (HANDLE hMem)
 273 {
 274   return 0;
 275 }
 276
 277 HANDLE LocalFree (HANDLE hMem)
 278 {
 279   return HEAP_Free(hMem);
 280 }
 281
 282 BOOL LocalInit (HANDLE segment, WORD start, WORD end)
 283 {
 284   return TRUE;
 285 }
 286
 287 LPVOID LocalLock (HANDLE hMem)
 288 {
 289   return hMem;
 290 }
 291
 292 HANDLE LocalReAlloc (HANDLE hMem, WORD new_size, WORD flags)
 293 {
 294   if (!(flags & LMEM_MODIFY))
 295     return HEAP_ReAlloc (hMem, new_size, flags);
 296   else
 297     return hMem;
 298 }
 299
 300 UINT LocalSize (HANDLE hMem)
 301 {
 302   return HEAP_Size(hMem);
 303 }
 304
 305 BOOL LocalUnlock (HANDLE hMem)
 306 {
 307   return 0;
 308 }
 309
 310 HANDLE GlobalAlloc (WORD flags, DWORD size)
 311 {
 312   return HEAP_Alloc (flags,size);
 313 }
 314
 315 HANDLE GlobalFree (HANDLE hMem)
 316 {
 317   return HEAP_Free (hMem);
 318 }
 319
 320 LPVOID GlobalLock (HGLOBAL hMem)
 321 {
 322   return hMem;
 323 }
 324
 325 BOOL GlobalUnlock (HANDLE hMem)
 326 {
 327   return 0;
 328 }
 329
 330 WORD GlobalFlags (HANDLE hMem)
 331 {
 332   return LocalFlags (hMem);
 333 }
 334
 335 DWORD GlobalSize (HANDLE hMem)
 336 {
 337   return HEAP_Size (hMem);
 338 }
 339
 340 HANDLE GlobalReAlloc(HANDLE hMem, DWORD new_size, WORD flags)
 341 {
 342   if (!(flags & GMEM_MODIFY))
 343     return HEAP_ReAlloc (hMem, new_size, flags);
 344   else
 345     return hMem;
 346 }
 347
 348 #endif