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 #endif
  12 #include "windows.h"
  13
  14 /* Controls the blocks per handle table */
  15 #define MAXBLOCKS 1024
  16
  17 static char Copyright [] = "Copyright (C) 1994 Miguel de Icaza";
  18
  19 typedef struct handle_table {
  20     struct handle_table *next;
  21     void *blocks [MAXBLOCKS];
  22 } handle_table_t;
  23
  24 static handle_table_t handle_table;
  25
  26 static void **HEAP_GetFreeSlot (HANDLE *hNum)
  27 {
  28     handle_table_t *table, *last;
  29     int i, j;
  30
  31     for (table = &handle_table, j = 0; table; table = table->next, j++){
  32         for (i = 0; i < MAXBLOCKS; i++)
  33             if (!table->blocks [i])
  34                 goto AssignBlock;
  35         last = table;
  36     }
  37
  38     /* No free slots */
  39     last->next = malloc (sizeof (handle_table_t));
  40     table = last->next;
  41     memset (table, 0, sizeof (handle_table_t));
  42     i = 0;
  43
  44  AssignBlock:
  45     *hNum = j*MAXBLOCKS+i;
  46     return &table->blocks [i];
  47 }
  48
  49 static void HEAP_Handle_is_Zero ()
  50 {
  51     printf ("Warning: Handle is Zero, segmentation fault comming\n");
  52 }
  53
  54 static void **HEAP_FindSlot (HANDLE hNum)
  55 {
  56     handle_table_t *table = &handle_table;
  57     int i, j;
  58
  59     if (!hNum)
  60         HEAP_Handle_is_Zero ();
  61
  62     hNum--;
  63     for (j = hNum; j > MAXBLOCKS; j -= MAXBLOCKS){
  64         table = table->next;
  65         if (!table) return 0;
  66     }
  67     return &table->blocks [hNum%MAXBLOCKS];
  68 }
  69
  70 HANDLE LocalAlloc (WORD flags, WORD bytes)
  71 {
  72     void *m;
  73     void **slot;
  74     HANDLE hMem;
  75
  76     slot = HEAP_GetFreeSlot (&hMem);
  77     if (flags & LMEM_WINE_ALIGN)
  78         m = memalign (4, bytes);
  79     else
  80         m = malloc (bytes);
  81     if (m){
  82         *slot = m;
  83         if (flags & LMEM_ZEROINIT)
  84             bzero (m, bytes);
  85
  86 #ifdef DEBUG_HEAP
  87         printf ("Handle %d [%d] = %p\n", hMem+1, bytes, m);
  88 #endif
  89         return hMem+1;
  90     }
  91     return 0;
  92 }
  93
  94 WORD LocalCompact (WORD min_free)
  95 {
  96     return min_free;
  97 }
  98
  99 WORD LocalFlags (HANDLE hMem)
 100 {
 101     return 0;
 102 }
 103
 104 HANDLE LocalFree (HANDLE hMem)
 105 {
 106     void **m = HEAP_FindSlot (hMem);
 107
 108     free (*m);
 109     *m = 0;
 110     return 0;
 111 }
 112
 113 BOOL LocalInit (WORD segment, WORD start, WORD end)
 114 {
 115     return 1;
 116 }
 117
 118 char *LocalLock (HANDLE hMem)
 119 {
 120     void **m = HEAP_FindSlot (hMem);
 121 #ifdef DEBUG_HEAP
 122     printf (">%d->%p\n", hMem, *m);
 123 #endif
 124     return m ? *m : 0;
 125 }
 126
 127 HANDLE LocalReAlloc (HANDLE hMem, WORD flags, WORD bytes)
 128 {
 129     void **m = HEAP_FindSlot (hMem);
 130
 131     realloc (*m, bytes);
 132 }
 133
 134 WORD LocalSize (HANDLE hMem)
 135 {
 136     /* Not implemented yet */
 137 }
 138
 139
 140 BOOL LocalUnLock (HANDLE hMem)
 141 {
 142     return 0;
 143 }
 144
 145 HANDLE GlobalAlloc (WORD flags, DWORD size)
 146 {
 147     return LocalAlloc (flags, size);
 148 }
 149
 150 HANDLE GlobalFree (HANDLE hMem)
 151 {
 152     return LocalFree (hMem);
 153 }
 154
 155 char *GlobalLock (HANDLE hMem)
 156 {
 157     return LocalLock (hMem);
 158 }
 159
 160 BOOL GlobalUnlock (HANDLE hMem)
 161 {
 162     return LocalUnLock (hMem);
 163 }
 164
 165 WORD GlobalFlags (HANDLE hMem)
 166 {
 167     return LocalFlags (hMem);
 168 }
 169
 170 DWORD GlobalSize (HANDLE hMem)
 171 {
 172     return LocalSize (hMem);
 173 }
 174
 175 DWORD GlobalCompact(DWORD desired)
 176 {
 177     if (desired)
 178         return desired;
 179     else
 180         return 0x01000000;      /* Should check the available core. */
 181 }
 182
 183 HANDLE GlobalReAlloc(HANDLE hMem, DWORD new_size, WORD flags)
 184 {
 185     if (!(flags & GMEM_MODIFY))
 186         return LocalReAlloc (hMem, new_size, flags);
 187 }
 188
 189 char *GlobalLinearLock (HANDLE hMem)
 190 {
 191     return GlobalLock (hMem);
 192 }
 193
 194 HANDLE GlobalLinearUnlock (HANDLE hMem)
 195 {
 196     return GlobalUnlock (hMem);
 197 }
 198
 199 int HEAP_LocalSize ()
 200 {
 201     return 0;
 202 }
 203
 204 int HEAP_LocalFindHeap ()
 205 {
 206     return 0;
 207 }
 208
 209 #ifdef UNIMPLEMENTED
 210 void *GlobalQuickAlloc(int size)
 211 {
 212 }
 213
 214 DWORD int GlobalHandle(WORD selector)
 215 {
 216 }
 217
 218 unsigned int GlobalHandleFromPointer(void *block)
 219 {
 220 }
 221
 222 #endif