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 = 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 (flags & LMEM_WINE_ALIGN)
 222         m = memalign (4, bytes);
 223     else
 224         m = malloc (bytes);
 225     if (m){
 226         if (flags & LMEM_ZEROINIT)
 227             bzero (m, bytes);
 228     }
 229     m->Size=bytes-sizeof(HeapData);
 230     return m+1;
 231 }
 232
 233 HANDLE HEAP_Free (HANDLE hMem)
 234 {
 235   HeapData* 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
 300 BOOL LocalUnlock (HANDLE hMem)
 301 {
 302   return 0;
 303 }
 304
 305 HANDLE GlobalAlloc (WORD flags, DWORD size)
 306 {
 307   return HEAP_Alloc (flags,size);
 308 }
 309
 310 HANDLE GlobalFree (HANDLE hMem)
 311 {
 312   return HEAP_Free (hMem);
 313 }
 314
 315 LPVOID GlobalLock (HGLOBAL hMem)
 316 {
 317   return hMem;
 318 }
 319
 320 BOOL GlobalUnlock (HANDLE hMem)
 321 {
 322   return 0;
 323 }
 324
 325 WORD GlobalFlags (HANDLE hMem)
 326 {
 327   return LocalFlags (hMem);
 328 }
 329
 330 DWORD GlobalSize (HANDLE hMem)
 331 {
 332   return HEAP_Size (hMem);
 333 }
 334
 335 HANDLE GlobalReAlloc(HANDLE hMem, DWORD new_size, WORD flags)
 336 {
 337   if (!(flags & GMEM_MODIFY))
 338     return HEAP_ReAlloc (hMem, new_size, flags);
 339   else
 340     return hMem;
 341 }
 342
 343 #endif