203 lines
3.3 KiB
C
203 lines
3.3 KiB
C
/*
|
|
* Memory alllocation for the Wine Library toolkit
|
|
*
|
|
* Copyright (C) 1994 Miguel de Icaza
|
|
*
|
|
* All the memory management is being done by the libc malloc and friends.
|
|
*/
|
|
|
|
#ifndef __STDC__
|
|
#include <malloc.h>
|
|
#endif
|
|
#include "windows.h"
|
|
|
|
/* Controls the blocks per handle table */
|
|
#define MAXBLOCKS 512
|
|
|
|
static char Copyright [] = "Copyright (C) 1994 Miguel de Icaza";
|
|
|
|
typedef struct handle_table {
|
|
struct handle_table *next;
|
|
void *blocks [MAXBLOCKS];
|
|
} handle_table_t;
|
|
|
|
static handle_table_t handle_table;
|
|
|
|
static void **HEAP_GetFreeSlot (HANDLE *hNum)
|
|
{
|
|
handle_table_t *table, *last;
|
|
int i, j;
|
|
|
|
for (table = &handle_table, j = 0; table; table = table->next, j++){
|
|
for (i = 0; i < MAXBLOCKS; i++)
|
|
if (!table->blocks [i])
|
|
goto AssignBlock;
|
|
last = table;
|
|
}
|
|
|
|
/* No free slots */
|
|
last->next = malloc (sizeof (handle_table_t));
|
|
table = last->next;
|
|
memset (table, 0, sizeof (handle_table_t));
|
|
i = 0;
|
|
|
|
AssignBlock:
|
|
*hNum = j*MAXBLOCKS+i;
|
|
return &table->blocks [i];
|
|
}
|
|
|
|
static void HEAP_Handle_is_Zero ()
|
|
{
|
|
printf ("Warning: Handle is Zero, segmentation fault comming\n");
|
|
}
|
|
|
|
static void **HEAP_FindSlot (HANDLE hNum)
|
|
{
|
|
handle_table_t *table = &handle_table;
|
|
int i, j;
|
|
|
|
if (!hNum)
|
|
HEAP_Handle_is_Zero ();
|
|
|
|
hNum--;
|
|
for (j = hNum; j > MAXBLOCKS; j -= MAXBLOCKS){
|
|
table = table->next;
|
|
if (!table) return 0;
|
|
}
|
|
return &table->blocks [hNum%MAXBLOCKS];
|
|
}
|
|
|
|
HANDLE LocalAlloc (WORD flags, WORD bytes)
|
|
{
|
|
void *m;
|
|
void **slot;
|
|
HANDLE hMem;
|
|
|
|
slot = HEAP_GetFreeSlot (&hMem);
|
|
if (flags & LMEM_WINE_ALIGN)
|
|
m = memalign (4, bytes);
|
|
else
|
|
m = malloc (bytes);
|
|
if (m){
|
|
*slot = m;
|
|
if (flags & LMEM_ZEROINIT)
|
|
bzero (m, bytes);
|
|
|
|
#ifdef DEBUG_HEAP
|
|
printf ("Handle %d [%d] = %p\n", hMem+1, bytes, m);
|
|
#endif
|
|
return hMem+1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
WORD LocalCompact (WORD min_free)
|
|
{
|
|
return min_free;
|
|
}
|
|
|
|
WORD LocalFlags (HANDLE hMem)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
HANDLE LocalFree (HANDLE hMem)
|
|
{
|
|
void **m = HEAP_FindSlot (hMem);
|
|
|
|
free (*m);
|
|
*m = 0;
|
|
return 0;
|
|
}
|
|
|
|
BOOL LocalInit (WORD segment, WORD start, WORD end)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
char *LocalLock (HANDLE hMem)
|
|
{
|
|
void **m = HEAP_FindSlot (hMem);
|
|
#ifdef DEBUG_HEAP
|
|
printf (">%d->%p\n", hMem, *m);
|
|
#endif
|
|
return *m;
|
|
}
|
|
|
|
HANDLE LocalReAlloc (HANDLE hMem, WORD flags, WORD bytes)
|
|
{
|
|
void **m = HEAP_FindSlot (hMem);
|
|
|
|
realloc (*m, bytes);
|
|
}
|
|
|
|
WORD LocalSize (HANDLE hMem)
|
|
{
|
|
/* Not implemented yet */
|
|
}
|
|
|
|
|
|
BOOL LocalUnLock (HANDLE hMem)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
HANDLE GlobalAlloc (WORD flags, DWORD size)
|
|
{
|
|
return LocalAlloc (flags, size);
|
|
}
|
|
|
|
HANDLE GlobalFree (HANDLE hMem)
|
|
{
|
|
return LocalFree (hMem);
|
|
}
|
|
|
|
char *GlobalLock (HANDLE hMem)
|
|
{
|
|
return LocalLock (hMem);
|
|
}
|
|
|
|
BOOL GlobalUnlock (HANDLE hMem)
|
|
{
|
|
return LocalUnLock (hMem);
|
|
}
|
|
|
|
WORD GlobalFlags (HANDLE hMem)
|
|
{
|
|
return LocalFlags (hMem);
|
|
}
|
|
|
|
DWORD GlobalSize (HANDLE hMem)
|
|
{
|
|
return LocalSize (hMem);
|
|
}
|
|
|
|
DWORD GlobalCompact(DWORD desired)
|
|
{
|
|
if (desired)
|
|
return desired;
|
|
else
|
|
return 0x01000000; /* Should check the available core. */
|
|
}
|
|
|
|
HANDLE GlobalReAlloc(HANDLE hMem, DWORD new_size, WORD flags)
|
|
{
|
|
if (!(flags & GMEM_MODIFY))
|
|
return LocalReAlloc (hMem, new_size, flags);
|
|
}
|
|
|
|
#ifdef UNIMPLEMENTED
|
|
void *GlobalQuickAlloc(int size)
|
|
{
|
|
}
|
|
|
|
DWORD int GlobalHandle(WORD selector)
|
|
{
|
|
}
|
|
|
|
unsigned int GlobalHandleFromPointer(void *block)
|
|
{
|
|
}
|
|
|
|
#endif
|