annotate loader/win32.c @ 37:b5ce4f6a8651

TODO: updated codecs

/***********************************************************

	Win32 emulation code. Functions that emulate
	responses from corresponding Win32 API calls.
         Since we are not going to be able to load 
       virtually any DLL, we can only implement this
      much, adding needed functions with each new codec.

************************************************************/

#include <config.h>

#include "win32.h"
#include <stdio.h>
#include <pthread.h>
#ifdef HAVE_MALLOC_H
#include <malloc.h>
#else
#include <stdlib.h>
#endif
#include <time.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/timeb.h>

#include <wine/winbase.h>
#include <wine/winreg.h>
#include <wine/winnt.h>
#include <wine/winerror.h>
#include <wine/debugtools.h>
#include <wine/module.h>

#include <registry.h>
#include <loader.h>
#ifdef USE_TSC
static unsigned int localcount()
{
    int a;
    __asm__ __volatile__("rdtsc\n\t"
    :"=a"(a)
    :
    :"edx");
    return a;
}
static void longcount(long long* z)
{
    __asm__ __volatile__(
    "pushl %%ebx\n\t"
    "movl %%eax, %%ebx\n\t"
    "rdtsc\n\t"
    "movl %%eax, 0(%%ebx)\n\t"
    "movl %%edx, 4(%%ebx)\n\t"
    "popl %%ebx\n\t"
    ::"a"(z));
}    
#else
#include <sys/time.h>
#include <unistd.h>
static unsigned int localcount()
{
    struct timeval tv;
    unsigned limit=~0;
    limit/=1000000;
    gettimeofday(&tv, 0);
    return limit*tv.tv_usec;
}
static void longcount(long long* z)
{
    struct timeval tv;
    unsigned long long result;
    unsigned limit=~0;
    if(!z)return;
    limit/=1000000;
    gettimeofday(&tv, 0);
    result=tv.tv_sec;
    result<<=32;
    result+=limit*tv.tv_usec;
    *z=result;
}
#endif

void dbgprintf(char* fmt, ...)
{
#ifdef DETAILED_OUT
#if 1
    va_list va;
    va_start(va, fmt);
    vprintf(fmt, va);
    va_end(va);
#else
    va_list va;
    FILE* f;
    va_start(va, fmt);
    f=fopen("./log", "a");
    if(f==0)return;
    vfprintf(f, fmt, va);
    fsync(f);
    fclose(f);
#endif
#endif
}    
char export_names[500][30]={
"name1",
//"name2",
//"name3"
};
//#define min(x,y) ((x)<(y)?(x):(y))

static unsigned char* heap=NULL; 
static int heap_counter=0;
void test_heap()
{
    int offset=0;	
    if(heap==0)
	return;
    while(offset<heap_counter)
    {
	if(*(int*)(heap+offset)!=0x433476)
	{
	    printf("Heap corruption at address %d\n", offset);
	    return;
	}
	offset+=8+*(int*)(heap+offset+4);
    }
    for(;offset<min(offset+1000, 20000000); offset++)
	if(heap[offset]!=0xCC)
	    {
		printf("Free heap corruption at address %d\n", offset);
	}	    
}
#undef MEMORY_DEBUG

#ifdef MEMORY_DEBUG

void* my_mreq(int size, int to_zero)
{
    static int test=0;
    test++;
    if(test%10==0)printf("Memory: %d bytes allocated\n", heap_counter);
//    test_heap();
    if(heap==NULL)
    {
	heap=malloc(20000000);
	memset(heap, 0xCC,20000000);
    }
    if(heap==0)
    {
	printf("No enough memory\n");
	return 0;
    }	
    if(heap_counter+size>20000000)
    {
	printf("No enough memory\n");
	return 0;
    }	
    *(int*)(heap+heap_counter)=0x433476;
    heap_counter+=4;
    *(int*)(heap+heap_counter)=size;
    heap_counter+=4;
    printf("Allocated %d bytes of memory: sys %d, user %d-%d\n", size, heap_counter-8, heap_counter, heap_counter+size);
    if(to_zero)
    	memset(heap+heap_counter, 0, size);	    
    heap_counter+=size;
    return heap+heap_counter-size;	
}
int my_release(char* memory)
{
//    test_heap();
    if(memory==NULL)
    {
	printf("ERROR: free(0)\n");
	return 0;
    }	
    if(*(int*)(memory-8)!=0x433476)
    {
	printf("MEMORY CORRUPTION !!!!!!!!!!!!!!!!!!!\n");
	return 0;
    }
    printf("Freed %d bytes of memory\n", *(int*)(memory-4));
//    memset(memory-8, *(int*)(memory-4), 0xCC);
    return 0;
}    	     

#else
void* my_mreq(int size, int to_zero)
{
    void* answer; 
    if(to_zero)
	answer=calloc(size+4, 1);
    else
	answer=malloc(size+4);
    *(int*)answer=size;
    return (int*)answer+1;
}	
int my_release(char* memory)
{
    if(memory==0)return 0;
    free(memory-4);
    return 0;
}
#endif
int my_size(char* memory)
{
    return *(int*)(memory-4);
}    

extern int unk_exp1;
char extcode[20000];// place for 200 unresolved exports
int pos=0;

int WINAPI ext_unknown()
{
    printf("Unknown func called\n");
    return 0;
}    
int WINAPI expIsBadWritePtr(void* ptr, unsigned int count)
{
    dbgprintf("IsBadWritePtr(%x, %x)\n", ptr, count);
    if(count==0)
	return 0;
    if(ptr==0)
        return 1;
    return 0;
}
int WINAPI expIsBadReadPtr(void* ptr, unsigned int count)
{
    dbgprintf("IsBadReadPtr(%x, %x)\n", ptr, count);
    if(count==0)
	return 0;
    if(ptr==0)
        return 1;
    return 0;
}
void* CDECL expmalloc(int size)
{
//printf("malloc");
//    return malloc(size);
    void* result=my_mreq(size,0);
    dbgprintf("malloc(%x)\n", size);
    if(result==0)
    {
	dbgprintf("returns 0\n");
	printf("WARNING: malloc() failed\n");
    }	
    return result;
}
void CDECL expfree(void* mem)
{
//    return free(mem);
    dbgprintf("free(%x)\n", mem);
    my_release(mem);
}
void* CDECL expnew(int size)
{
//    printf("NEW:: Call from address %08x\n STACK DUMP:\n", *(-1+(int*)&size));
//    printf("%08x %08x %08x %08x\n",
//    size, *(1+(int*)&size),
//    *(2+(int*)&size),*(3+(int*)&size));
    void* result=expmalloc(size);
    dbgprintf("new(%x)\n", size);
    if(result==0)
    {
	dbgprintf("returns 0\n");
	printf("WARNING: malloc() failed\n");
    }	
    return result;

}    
int CDECL expdelete(void* memory)
{
    dbgprintf("delete(%x)\n", memory);
    expfree(memory);
    return 0;
}
int WINAPI expDisableThreadLibraryCalls(int module)
{
    dbgprintf("DisableThreadLibraryCalls(%x)\n", module);
    return 0;
}    
int CDECL exp_initterm(int v1, int v2)
{
    return 0;
}    

typedef struct {
    unsigned int     	uDriverSignature;
    void*        	hDriverModule;
    void*    		DriverProc;
    unsigned int        dwDriverID;
} DRVR;

void* WINAPI expGetDriverModuleHandle(DRVR* pdrv)
{
    dbgprintf("GetDriverModuleHandle(%x)\n", pdrv);
    return pdrv->hDriverModule;
}

void* WINAPI expGetModuleHandleA(const char* name)
{
	WINE_MODREF* wm;
        dbgprintf("GetModuleHandleA(%s)\n", name);
	if(!name)return 0;
        wm=MODULE_FindModule(name);
        if(wm==0)return 0;
        return (void*)(wm->module);
}
struct th_list_t;
typedef struct th_list_t{
int id;
void* thread;
struct th_list_t* next;
struct th_list_t* prev;
}th_list;

static th_list* list=NULL;



void* WINAPI expCreateThread(void* pSecAttr, long dwStackSize, void* lpStartAddress,
	void* lpParameter, long dwFlags, long* dwThreadId)
{
    pthread_t *pth;
//    printf("CreateThread:");
    pth=my_mreq(sizeof(pthread_t), 0);
    dbgprintf("pthread_create\n");
    pthread_create(pth, NULL, (void*(*)(void*))lpStartAddress, lpParameter);
    if(dwFlags)
	dbgprintf( "WARNING: CreateThread flags not supported\n");
    if(dwThreadId)
	*dwThreadId=(long)pth;
    dbgprintf( "Created thread %08X\n", pth);
    if(list==NULL)
    {
	list=my_mreq(sizeof(th_list), 1);
	list->next=list->prev=NULL;
    }
    else
    {
	list->next=my_mreq(sizeof(th_list), 0);
	list->next->prev=list;
	list->next->next=NULL;
	list=list->next;
    }		
    list->thread=pth;
    return pth;
}

struct mutex_list_t;

struct mutex_list_t
{
    pthread_mutex_t *pm;
    char name[64];
    struct mutex_list_t* next;
    struct mutex_list_t* prev;
};
typedef struct mutex_list_t mutex_list;
static mutex_list* mlist=NULL; 
void* WINAPI expCreateEventA(void* pSecAttr, char bManualReset, 
    char bInitialState, const char* name)
{
#warning ManualReset
    pthread_mutex_t *pm;
    dbgprintf("CreateEvent\n");
    if(mlist!=NULL)
    {
	mutex_list* pp=mlist;
	if(name!=NULL)
	do
	{
	    if(strcmp(pp->name, name)==0)
		return pp->pm;
	}while(pp=pp->prev);
    }	
    pm=my_mreq(sizeof(pthread_mutex_t), 0);
    pthread_mutex_init(pm, NULL);
    if(mlist==NULL)
    {
	mlist=my_mreq(sizeof(mutex_list), 00);
	mlist->next=mlist->prev=NULL;
    }
    else
    {
	mlist->next=my_mreq(sizeof(mutex_list), 00);
	mlist->next->prev=mlist->next;
	mlist->next->next=NULL;
	mlist=mlist->next;
    }
    mlist->pm=pm;
    if(name!=NULL)
        strncpy(mlist->name, name, 64);
	else
	mlist->name[0]=0;
    if(pm==NULL)
	dbgprintf("ERROR::: CreateEventA failure\n");
    if(bInitialState)
        pthread_mutex_lock(pm);
    return pm;
}    

void* WINAPI expSetEvent(void* event)
{
    dbgprintf("Trying to lock %X\n", event);
    pthread_mutex_lock(event);
}
void* WINAPI expResetEvent(void* event)
{
    dbgprintf("Unlocking %X\n", event);
    pthread_mutex_unlock(event);    
}

void* WINAPI expWaitForSingleObject(void* object, int duration)
{
#warning not sure
    dbgprintf("WaitForSingleObject: duration %d\n", duration);
    pthread_mutex_lock(object);
    pthread_mutex_unlock(object);
}    

static BYTE PF[64] = {0,};

void WINAPI expGetSystemInfo(SYSTEM_INFO* si)
{
    	/* FIXME: better values for the two entries below... */
	static int cache = 0;
	static SYSTEM_INFO cachedsi;
	HKEY	xhkey=0,hkey;
        dbgprintf("GetSystemInfo()\n");

	if (cache) {
		memcpy(si,&cachedsi,sizeof(*si));
		return;
	}
	memset(PF,0,sizeof(PF));

	cachedsi.u.s.wProcessorArchitecture     = PROCESSOR_ARCHITECTURE_INTEL;
	cachedsi.dwPageSize 			= getpagesize();

	/* FIXME: better values for the two entries below... */
	cachedsi.lpMinimumApplicationAddress	= (void *)0x40000000;
	cachedsi.lpMaximumApplicationAddress	= (void *)0x7FFFFFFF;
	cachedsi.dwActiveProcessorMask		= 1;
	cachedsi.dwNumberOfProcessors		= 1;
	cachedsi.dwProcessorType		= PROCESSOR_INTEL_386;
	cachedsi.dwAllocationGranularity	= 0x10000;
	cachedsi.wProcessorLevel		= 3; /* pentium */
	cachedsi.wProcessorRevision		= 0;
	
#ifdef __FreeBSD__
        cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
        cachedsi.wProcessorLevel= 5;
	PF[PF_COMPARE_EXCHANGE_DOUBLE] = TRUE;
#ifdef MMX
        PF[PF_MMX_INSTRUCTIONS_AVAILABLE] = TRUE;
#endif
        cachedsi.dwNumberOfProcessors=1;
#else
	{
	char buf[20];
	char line[200];
	FILE *f = fopen ("/proc/cpuinfo", "r");

	if (!f)
		return;
        xhkey = 0;
	while (fgets(line,200,f)!=NULL) {
		char	*s,*value;

		/* NOTE: the ':' is the only character we can rely on */
		if (!(value = strchr(line,':')))
			continue;
		/* terminate the valuename */
		*value++ = '\0';
		/* skip any leading spaces */
		while (*value==' ') value++;
		if ((s=strchr(value,'\n')))
			*s='\0';

		/* 2.1 method */
		if (!lstrncmpiA(line, "cpu family",strlen("cpu family"))) {
			if (isdigit (value[0])) {
				switch (value[0] - '0') {
				case 3: cachedsi.dwProcessorType = PROCESSOR_INTEL_386;
					cachedsi.wProcessorLevel= 3;
					break;
				case 4: cachedsi.dwProcessorType = PROCESSOR_INTEL_486;
					cachedsi.wProcessorLevel= 4;
					break;
				case 5: cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
					cachedsi.wProcessorLevel= 5;
					break;
				case 6: cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
					cachedsi.wProcessorLevel= 5;
					break;
				default:cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
					cachedsi.wProcessorLevel= 5;
					break;
				}
			}
			/* set the CPU type of the current processor */
			sprintf(buf,"CPU %ld",cachedsi.dwProcessorType);
			continue;
		}
		/* old 2.0 method */
		if (!lstrncmpiA(line, "cpu",strlen("cpu"))) {
			if (	isdigit (value[0]) && value[1] == '8' && 
				value[2] == '6' && value[3] == 0
			) {
				switch (value[0] - '0') {
				case 3: cachedsi.dwProcessorType = PROCESSOR_INTEL_386;
					cachedsi.wProcessorLevel= 3;
					break;
				case 4: cachedsi.dwProcessorType = PROCESSOR_INTEL_486;
					cachedsi.wProcessorLevel= 4;
					break;
				case 5: cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
					cachedsi.wProcessorLevel= 5;
					break;
				case 6: cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
					cachedsi.wProcessorLevel= 5;
					break;
				default:cachedsi.dwProcessorType = PROCESSOR_INTEL_PENTIUM;
					cachedsi.wProcessorLevel= 5;
					break;
				}
			}
			/* set the CPU type of the current processor */
			sprintf(buf,"CPU %ld",cachedsi.dwProcessorType);
			continue;
		}
		if (!lstrncmpiA(line,"fdiv_bug",strlen("fdiv_bug"))) {
			if (!lstrncmpiA(value,"yes",3))
				PF[PF_FLOATING_POINT_PRECISION_ERRATA] = TRUE;

			continue;
		}
		if (!lstrncmpiA(line,"fpu",strlen("fpu"))) {
			if (!lstrncmpiA(value,"no",2))
				PF[PF_FLOATING_POINT_EMULATED] = TRUE;

			continue;
		}
		if (!lstrncmpiA(line,"processor",strlen("processor"))) {
			/* processor number counts up...*/
			int	x;

			if (sscanf(value,"%d",&x))
				if (x+1>cachedsi.dwNumberOfProcessors)
					cachedsi.dwNumberOfProcessors=x+1;

			/* Create a new processor subkey on a multiprocessor
			 * system
			 */
			sprintf(buf,"%d",x);
		}
		if (!lstrncmpiA(line,"stepping",strlen("stepping"))) {
			int	x;

			if (sscanf(value,"%d",&x))
				cachedsi.wProcessorRevision = x;
		}
		if ( (!lstrncmpiA(line,"flags",strlen("flags"))) ||
                     (!lstrncmpiA(line,"features",strlen("features"))) ) {
			if (strstr(value,"cx8"))
				PF[PF_COMPARE_EXCHANGE_DOUBLE] = TRUE;
			if (strstr(value,"mmx"))
				PF[PF_MMX_INSTRUCTIONS_AVAILABLE] = TRUE;

		}
	}
	fclose (f);
	}
#endif /* __FreeBSD__ */
	memcpy(si,&cachedsi,sizeof(*si));
}

long WINAPI expGetVersion()
{
    return 0xC0000A04;//Windows 98
}    

HANDLE WINAPI expHeapCreate(long flags, long init_size, long max_size)
{
//    printf("HeapCreate:");
    dbgprintf("HeapCreate(%X, %X, %X)\n", flags, init_size, max_size); 
    if(init_size==0)
    	return (HANDLE)my_mreq(0x110000, 0);
    else
	return (HANDLE)my_mreq(init_size, 0);
}		
void* WINAPI expHeapAlloc(HANDLE heap, int flags, int size)
{
    void* z;
    dbgprintf("HeapAlloc(%X, %X, %X)\n", heap, flags, size); 
//    printf("HeapAlloc:");
    z=my_mreq(size, flags&8);    
//    z=HeapAlloc(heap,flags,size);
    if(z==0)
	printf("HeapAlloc failure\n");
    return z;
}
long WINAPI expHeapDestroy(void* heap)
{
    dbgprintf("HeapDestroy(%X)\n", heap); 
    my_release(heap);
    return 1;
}

long WINAPI expHeapFree(int arg1, int arg2, void* ptr)
{
    dbgprintf("HeapFree(%X, %X, %X)\n", arg1, arg2, ptr);
    my_release(ptr);
    return 1;
}    	
long WINAPI expHeapSize(int heap, int flags, void* pointer)
{
    return my_size(pointer);
} 
long WINAPI expGetProcessHeap(void)
{
    return 1;
}    
void* WINAPI expVirtualAlloc(void* v1, long v2, long v3, long v4)
{
    void* z;
    dbgprintf("VirtualAlloc(%d %d %d %d) \n",v1,v2,v3,v4);
    z=VirtualAlloc(v1, v2, v3, v4);
    if(z==0)
	printf("VirtualAlloc failure\n");
    return z;
}
int WINAPI expVirtualFree(void* v1, int v2, int v3)
{
    dbgprintf("VirtualFree(%X %X %X) \n",v1,v2,v3);
    return VirtualFree(v1,v2,v3);
}    
struct CRITSECT 
{
    pthread_t id;
    pthread_mutex_t mutex;
    int locked;
};
void WINAPI expInitializeCriticalSection(CRITICAL_SECTION* c)
{
    struct CRITSECT cs;
    dbgprintf("InitCriticalSection(%X) \n", c);
/*    if(sizeof(pthread_mutex_t)>sizeof(CRITICAL_SECTION))
    {
	printf(" ERROR:::: sizeof(pthread_mutex_t) is %d, expected <=%d!\n",
	     sizeof(pthread_mutex_t), sizeof(CRITICAL_SECTION));
	return;
    }*/
/*    pthread_mutex_init((pthread_mutex_t*)c, NULL);   */
    pthread_mutex_init(&cs.mutex, NULL);   
    cs.locked=0;
    *(void**)c=malloc(sizeof cs);
    memcpy(*(void**)c, &cs, sizeof cs);
    return;
}          
void WINAPI expEnterCriticalSection(CRITICAL_SECTION* c)
{
    struct CRITSECT* cs=(struct CRITSECT*)c;
    dbgprintf("EnterCriticalSection(%X) \n",c);
//    cs.id=pthread_self();
    if(cs->locked)
	if(cs->id==pthread_self())
	    return;
    pthread_mutex_lock(&(cs->mutex));
    cs->locked=1;
    cs->id=pthread_self();
    return;
}          
void WINAPI expLeaveCriticalSection(CRITICAL_SECTION* c)
{
    struct CRITSECT* cs=(struct CRITSECT*)c;
    dbgprintf("LeaveCriticalSection(%X) \n",c);
    cs->locked=0;
    pthread_mutex_unlock(&(cs->mutex));
    return;
}
void WINAPI expDeleteCriticalSection(CRITICAL_SECTION *c)
{
    dbgprintf("DeleteCriticalSection(%X) \n",c);
    pthread_mutex_destroy((pthread_mutex_t*)c);
    return;
}
int WINAPI expGetCurrentThreadId()
{
    dbgprintf("GetCurrentThreadId() \n");
    return getpid();
}                  
struct tls_s;
typedef struct tls_s
{
    void* value;
    int used;
    struct tls_s* prev;
    struct tls_s* next;
}tls_t;

tls_t* g_tls=NULL;    
    
void* WINAPI expTlsAlloc()
{
    dbgprintf("TlsAlloc \n");
    if(g_tls==NULL)
    {
	g_tls=my_mreq(sizeof(tls_t), 0);
	g_tls->next=g_tls->prev=NULL;
    }
    else
    {
	g_tls->next=my_mreq(sizeof(tls_t), 0);
	g_tls->next->prev=g_tls;
	g_tls->next->next=NULL;
	g_tls=g_tls->next;
    }
    return g_tls;
}

int WINAPI expTlsSetValue(tls_t* index, void* value)
{
    dbgprintf("TlsSetVal(%X %X) \n", index, value );
    if(index==0)
	return 0;
    index->value=value;
    return 1;
}
void* WINAPI expTlsGetValue(tls_t* index)
{
    dbgprintf("TlsGetVal(%X) \n", index );
    if(index==0)
	return 0;
    return index->value;	
}
int WINAPI expTlsFree(tls_t* index)
{
    dbgprintf("TlsFree(%X) \n", index);
    if(index==0)
	return 0;
    if(index->next)
	index->next->prev=index->prev;
    if(index->prev)
        index->prev->next=index->next;
    my_release((void*)index);
    return 1;
}     

void* WINAPI expLocalAlloc(int flags, int size)
{
    void* z;
    dbgprintf("LocalAlloc(%d, flags %X)\n", size, flags);
    if(flags&GMEM_ZEROINIT)
	z=my_mreq(size, 1);
    else
	z=my_mreq(size, 0);
    if(z==0)
	printf("LocalAlloc() failed\n");
    return z;
}	
void* WINAPI expLocalLock(void* z)
{
   dbgprintf("LocalLock\n");
    return z;
}    
void* WINAPI expGlobalAlloc(int flags, int size)
{
    void* z;
     dbgprintf("GlobalAlloc(%d, flags 0x%X)\n", size, flags);
    if(flags&GMEM_ZEROINIT)
	z=my_mreq(size, 1);
	else
	z=my_mreq(size, 0);
    if(z==0)
	printf("LocalAlloc() failed\n");
    return z;
}	
void* WINAPI expGlobalLock(void* z)
{
     dbgprintf("GlobalLock\n");
    return z;
}    

int WINAPI expLoadStringA(long instance, long  id, void* buf, long size)
{
    dbgprintf("LoadStringA\n");
    return LoadStringA(instance, id, buf, size);
}    	    	

long WINAPI expMultiByteToWideChar(long v1, long v2, char* s1, long siz1, char* s2, int siz2)
{
#warning FIXME
    dbgprintf("MB2WCh\n");
    dbgprintf("WARNING: Unsupported call: MBToWCh %s\n", s1);       
    if(s2==0)
	return 1;
    s2[0]=s2[1]=0;
    return 1;
}
long WINAPI expWideCharToMultiByte(long v1, long v2, short* s1, long siz1, char* s2, int siz2, char* c3, int* siz3)
{
    int result;
    dbgprintf("WCh2MB\n");
    result=WideCharToMultiByte(v1, v2, s1, siz1, s2, siz2, c3, siz3);
    dbgprintf("=> %d\n", result);
    return result;
}
long WINAPI expGetVersionExA(OSVERSIONINFOA* c)
{
    dbgprintf("GetVersionExA\n");
    c->dwMajorVersion=4;
    c->dwMinorVersion=10;
    c->dwBuildNumber=0x40a07ce;
    c->dwPlatformId=VER_PLATFORM_WIN32_WINDOWS;
    strcpy(c->szCSDVersion, "Win98");
    return 1;
}        
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
HANDLE WINAPI expCreateSemaphoreA(char* v1, long init_count, long max_count, char* name)
{
#warning FIXME
/*    struct sembuf buf[1];
    int sem=semget(IPC_PRIVATE,1,IPC_CREAT);
    if(sem==-1)
    {
	printf("semget() failed\n");
	return (HANDLE)-1;
    }	
    buf[0].sem_num=0;
    printf("%s\n", name);
    printf("Init count %d, max count %d\n", init_count, max_count);
    buf[0].sem_op=-max_count+init_count;
    buf[0].sem_flg=0;
    if(semop(sem, &buf, 1)<0)
    {
	printf("semop() failed\n");
    }
    return sem;	
*/    
    void* z;
    dbgprintf("CreateSemaphoreA\n");
    z=my_mreq(24, 0);
    pthread_mutex_init(z, NULL);
    return (HANDLE)z;
}
        
long WINAPI expReleaseSemaphore(long hsem, long increment, long* prev_count)
{
// The state of a semaphore object is signaled when its count 
// is greater than zero and nonsignaled when its count is equal to zero
// Each time a waiting thread is released because of the semaphore's signaled
// state, the count of the semaphore is decreased by one. 
    struct sembuf buf[1];
    dbgprintf("ReleaseSemaphore\n");
    dbgprintf("WARNING: Unsupported call: ReleaseSemaphoreA\n");       
/*    if(hsem==-1)return 0;
    buf[0].sem_num=0;
    buf[0].sem_op=-1;
    buf[0].sem_flg=0;
    if(semop(hsem, &buf, 1)<0)
    {
	printf("ReleaseSemaphore: semop() failed\n");
    }*/

    return 1;//zero on error
}


long WINAPI expRegOpenKeyExA(long key, const char* subkey, long reserved, long access, int* newkey)
{
    dbgprintf("RegOpenKeyExA(%d,%s)\n", key, subkey);
    return RegOpenKeyExA(key, subkey, reserved, access, newkey);
}    
long WINAPI expRegCloseKey(long key)
{
    dbgprintf("RegCloseKey()\n");
    return RegCloseKey(key);
}         
long WINAPI expRegQueryValueExA(long key, const char* value, int* reserved, int* type, int* data, int* count)
{
    dbgprintf("RegQueryValueExA()\n");
    return RegQueryValueExA(key, value, reserved, type, data, count);
}  
long WINAPI expRegCreateKeyExA(long key, const char* name, long reserved,
							   void* classs, long options, long security,
							   void* sec_attr, int* newkey, int* status) 
{
    dbgprintf("RegCreateKeyExA()\n");
    return RegCreateKeyExA(key, name, reserved, classs, options, security, sec_attr, newkey, status);
}
long WINAPI expRegSetValueExA(long key, const char* name, long v1, long v2, void* data, long size)
{
    dbgprintf("RegSetValueExA()\n");
    return RegSetValueExA(key, name, v1, v2, data, size);
}        

long WINAPI expRegOpenKeyA (
long hKey,
 LPCSTR lpSubKey,
 int* phkResult
){
    return  RegOpenKeyExA(hKey, lpSubKey, 0, 0, phkResult);
}

long WINAPI expQueryPerformanceCounter(long long* z)
{
    dbgprintf("QueryPerformanceCounter()\n");
    longcount(z);
    return 1; 
}

static double old_freq()
{
    int i=time(NULL);
    int x,y;
    while(i==time(NULL));
    x=localcount();
    i++;
    while(i==time(NULL));
    y=localcount();
    return (double)(y-x)/1000.;
}
static double CPU_Freq()
{
#ifdef USE_TSC
	FILE *f = fopen ("/proc/cpuinfo", "r");
	char line[200];
	char model[200]="unknown";
	char flags[500]="";
	char	*s,*value;
	double freq=-1;
	
	if (!f)
	{
	    printf("Can't open /proc/cpuinfo for reading\n");
	    return old_freq();
	}    
	while (fgets(line,200,f)!=NULL) 
	{
		/* NOTE: the ':' is the only character we can rely on */
		if (!(value = strchr(line,':')))
			continue;
		/* terminate the valuename */
		*value++ = '\0';
		/* skip any leading spaces */
		while (*value==' ') value++;
		if ((s=strchr(value,'\n')))
			*s='\0';

		if (!strncasecmp(line, "cpu MHz",strlen("cpu MHz"))) 
		{
		    sscanf(value, "%lf", &freq);
		    freq*=1000;
		    break;
		}
		continue;
		
	}
	fclose(f);
	if(freq<0)return old_freq();
	return freq;
#else
	return old_freq();
#endif    	
}

long WINAPI expQueryPerformanceFrequency(long long* z)
{
    dbgprintf("QueryPerformanceFrequency()\n");
    *z=(long long)CPU_Freq();
    return 1; 
}
long WINAPI exptimeGetTime()
{
    struct timeval t;
    dbgprintf("timeGetTime()\n");
    gettimeofday(&t, 0);
    return 1000*t.tv_sec+t.tv_usec/1000;
}
void* WINAPI expLocalHandle(void* v)
{
    dbgprintf("LocalHandle\n");
    return v;
}        
void* WINAPI expGlobalHandle(void* v)
{
    dbgprintf("GlobalHandle\n");
    return v;
}        
int WINAPI expGlobalUnlock(void* v)
{
    dbgprintf("GlobalUnlock\n");
    return 1;
}
//
void* WINAPI expGlobalFree(void* v)
{
    dbgprintf("GlobalFree(%X)\n", v);
    my_release(v);
    return 0;
}        

int WINAPI expLocalUnlock(void* v)
{
    dbgprintf("LocalUnlock\n");
    return 1;
}
//
void* WINAPI expLocalFree(void* v)
{
    dbgprintf("LocalFree(%X)\n", v);
    my_release(v);
    return 0;
}        

HRSRC WINAPI expFindResourceA(HMODULE module, char* name, char* type)
{
    dbgprintf("FindResourceA\n");
    return FindResourceA(module, name, type);
}
HGLOBAL WINAPI expLoadResource(HMODULE module, HRSRC res)
{
    dbgprintf("LoadResource\n");
    return LoadResource(module, res);;    
}
void* WINAPI expLockResource(long res)
{
    dbgprintf("LockResource\n");
    return LockResource(res);
}    
int WINAPI expFreeResource(long res)
{
    dbgprintf("FreeResource\n");
    return FreeResource(res);
}    
//bool fun(HANDLE)
//!0 on success
int WINAPI expCloseHandle(long v1)
{
    dbgprintf("CloseHandle\n");
    return 1;
}    

const char* WINAPI expGetCommandLineA()
{
    dbgprintf("GetCommandLine\n");
    return "c:\\aviplay.exe";
}
LPWSTR WINAPI expGetEnvironmentStringsW()
{
    static wchar_t envs[]={'p', 'a', 't', 'h', ' ', 'c', ':', '\\', 0, 0};
    dbgprintf("GetEnvStringsW\n");
    return (LPWSTR)envs;
}

int WINAPI expFreeEnvironmentStringsW(short* strings)
{
    dbgprintf("FreeEnvStringsW\n");
    return 1;
}
LPCSTR WINAPI expGetEnvironmentStrings()
{
    dbgprintf("GetEnvStrings\n");
    return "\0\0";
}

int WINAPI expGetStartupInfoA(STARTUPINFOA *s)
{
    int i;    
    dbgprintf("GetStartupInfoA\n");
/*    
    for(i=0; i<sizeof(STARTUPINFOA)/4; i++)
     ((int*)s)[i]=i+0x200;
*/
    memset(s, 0, sizeof(*s));
    s->cb=sizeof(*s);
    s->lpReserved="qwe";
    s->lpDesktop="rty";
    s->lpTitle="uio";
    s->dwX=s->dwY=0;
    s->dwXSize=s->dwYSize=200;
    s->dwFlags=s->wShowWindow=0;
    return 1;
}    

int WINAPI expGetStdHandle(int z)
{
    dbgprintf("GetStdHandle\n");
    dbgprintf("WARNING: Unsupported call: GetStdHandle\n");       
    return 1234;
}
int WINAPI expGetFileType(int handle)
{
    dbgprintf("GetFileType\n");
    dbgprintf("WARNING: Unsupported call: GetFileType\n");       
    return 5678;
}
int WINAPI expSetHandleCount(int count)
{
    dbgprintf("SetHandleCount\n");
    return 1;        
}
int WINAPI expGetACP()
{
    dbgprintf("GetACP\n");
    dbgprintf("WARNING: Unsupported call: GetACP\n");       
    return 0; 
}
extern WINE_MODREF *MODULE32_LookupHMODULE(HMODULE m);
int WINAPI expGetModuleFileNameA(int module, char* s, int len)
{
    WINE_MODREF *mr;
    dbgprintf("GetModuleFileNameA\n");
//    printf("File name of module %X requested\n", module);
    if(s==0)
    return 0;
    if(len<35)
    return 0;
    strcpy(s, "c:\\windows\\system\\");
    mr=MODULE32_LookupHMODULE(module);
    if(mr==0)//oops
    {
        strcat(s, "aviplay.dll");
	return 1;
    }	
    if(strrchr(mr->filename, '/')==NULL)
	strcat(s, mr->filename);
    else
	strcat(s, strrchr(mr->filename, '/')+1);
    return 1;
}    
    
int WINAPI expSetUnhandledExceptionFilter(void* filter)
{
    dbgprintf("SetUnhandledExcFilter\n");
    return 1;//unsupported and probably won't ever be supported
}    
extern char* def_path;

int WINAPI expLoadLibraryA(char* name)
{
    char qq[256];
    dbgprintf("LoadLibraryA\n");
    printf("They want library %s\n", name);
    strcpy(qq, def_path);
    strcat(qq, "/");
    strcat(qq, name);
    return LoadLibraryA(qq);
}      
int WINAPI expFreeLibrary(int module)
{
    dbgprintf("FreeLibrary\n");
    return FreeLibrary(module);
}   
void* WINAPI expGetProcAddress(HMODULE mod, char* name)
{
    dbgprintf("GetProcAddress\n");
    return GetProcAddress(mod, name);
}    

long WINAPI expCreateFileMappingA(int hFile, void* lpAttr,
    long flProtect, long dwMaxHigh, long dwMaxLow, const char* name)
{
    dbgprintf("CreateFileMappingA\n");
    return CreateFileMappingA(hFile, lpAttr, flProtect, dwMaxHigh, dwMaxLow, name);
}    

long WINAPI expOpenFileMappingA(long hFile, long hz, const char* name)
{
    dbgprintf("OpenFileMappingA\n");
    return OpenFileMappingA(hFile, hz, name);
}

void* WINAPI expMapViewOfFile(HANDLE file, DWORD mode, DWORD offHigh, DWORD offLow, DWORD size)
{
    dbgprintf("MapViewOfFile(%d, %x, %x, %x, %x)\n",
	file,mode,offHigh,offLow,size);
    return (char*)file+offLow;
}

void* WINAPI expUnmapViewOfFile(void* view)
{
    dbgprintf("UnmapViewOfFile()\n");
    return 0;
}

void* WINAPI expSleep(int time)
{
    dbgprintf("Sleep(%d)\n", time);
    usleep(time);
    return 0;
}
 // why does IV32 codec want to call this? I don't know ...
void* WINAPI expCreateCompatibleDC(int hdc)
{
        dbgprintf("CreateCompatibleDC(%d)\n", hdc);
        return (void*)129;
}

int WINAPI expGetDeviceCaps(int hdc, int unk)
{
        dbgprintf("GetDeviceCaps(%d, %d)\n", hdc, unk);
        return 0;
}

WIN_BOOL WINAPI expDeleteDC(int hdc)
{
        dbgprintf("DeleteDC(%d)\n", hdc);
        return 0;
}

int expwsprintfA(char* string, char* format, ...)
{
    va_list va;
    va_start(va, format);
    dbgprintf("wsprintfA\n");
    return vsprintf(string, format, va);
}

int WINAPI expGetPrivateProfileIntA(const char* appname, const char* keyname, int default_value, const char* filename)
{
    int size=255;
    char buffer[256];
    char* fullname;
    int result;
    
    buffer[255]=0;
    dbgprintf("GetPrivateProfileIntA(%s, %s, %s)\n", appname, keyname, filename );
    if(!(appname && keyname && filename) ) return default_value;
    fullname=(char*)malloc(50+strlen(appname)+strlen(keyname)+strlen(filename));
    strcpy(fullname, "Software\\IniFileMapping\\");
    strcat(fullname, appname);
    strcat(fullname, "\\");
    strcat(fullname, keyname);
    strcat(fullname, "\\");
    strcat(fullname, filename);
    result=RegQueryValueExA(HKEY_LOCAL_MACHINE, fullname, NULL, NULL, (int*)buffer, &size);
    if((size>=0)&&(size<256))
	buffer[size]=0;
//    printf("GetPrivateProfileIntA(%s, %s, %s) -> %s\n", appname, keyname, filename, buffer);
    free(fullname); 
    if(result)
    return default_value;
    else
	return atoi(buffer);    	
}
int WINAPI expGetPrivateProfileStringA(const char* appname, const char* keyname,
	const char* def_val, char* dest, unsigned int len, const char* filename)
{
    int result;
    int size;
    char* fullname;
    dbgprintf("GetPrivateProfileStringA(%s, %s, %s, %X, %X, %s)\n", appname, keyname, def_val, dest, len, filename );
    if(!(appname && keyname && filename) ) return 0;
    fullname=(char*)malloc(50+strlen(appname)+strlen(keyname)+strlen(filename));
    strcpy(fullname, "Software\\IniFileMapping\\");
    strcat(fullname, appname);
    strcat(fullname, "\\");
    strcat(fullname, keyname);
    strcat(fullname, "\\");
    strcat(fullname, filename);
    size=len;
    result=RegQueryValueExA(HKEY_LOCAL_MACHINE, fullname, NULL, NULL, (int*)dest, &size);
//    printf("GetPrivateProfileStringA(%s, %s, %s, %X, %X, %s)\n", appname, keyname, def_val, dest, len, filename );
    free(fullname); 
    if(!result)
	return size;
    strncpy(dest, def_val, size);
    return size;
}
int WINAPI expWritePrivateProfileStringA(const char* appname, const char* keyname,
	const char* string, const char* filename)
{
    int size=256;
    char* fullname;
    dbgprintf("WritePrivateProfileStringA(%s, %s, %s, %s)\n", appname, keyname, string, filename );
    if(!(appname && keyname && filename) ) return -1;
    fullname=(char*)malloc(50+strlen(appname)+strlen(keyname)+strlen(filename));
    strcpy(fullname, "Software\\IniFileMapping\\");
    strcat(fullname, appname);
    strcat(fullname, "\\");
    strcat(fullname, keyname);
    strcat(fullname, "\\");
    strcat(fullname, filename);
    RegSetValueExA(HKEY_LOCAL_MACHINE, fullname, 0, REG_SZ, (int*)string, strlen(string));
//    printf("RegSetValueExA(%s,%d)\n", string, strlen(string));
//    printf("WritePrivateProfileStringA(%s, %s, %s, %s)\n", appname, keyname, string, filename );
    free(fullname); 
    return 0;
}

unsigned int _GetPrivateProfileIntA(const char* appname, const char* keyname, INT default_value, const char* filename)
{
    return expGetPrivateProfileIntA(appname, keyname, default_value, filename);
}
int _GetPrivateProfileStringA(const char* appname, const char* keyname,
	const char* def_val, char* dest, unsigned int len, const char* filename)
{
    return expGetPrivateProfileStringA(appname, keyname, def_val, dest, len, filename);
}
int _WritePrivateProfileStringA(const char* appname, const char* keyname,
	const char* string, const char* filename)
{
    return expWritePrivateProfileStringA(appname, keyname, string, filename);
}


int WINAPI expDefDriverProc(int _private, int id, int msg, int arg1, int arg2)
{
    printf("Called DefDriverProc(%X)\n", msg);
    return 0;
}    

int WINAPI expSizeofResource(int v1, int v2)
{
    dbgprintf("SizeofResource()\n");
    return SizeofResource(v1, v2);
}    

int WINAPI expGetLastError()
{
    dbgprintf("GetLastError()\n");
    return GetLastError();
}

void WINAPI expSetLastError(int error)
{
    dbgprintf("SetLastError()\n");
    SetLastError(error);
}        

char* expstrrchr(char* string, int value)
{
    return strrchr(string, value);
}    

char* expstrchr(char* string, int value)
{
    return strchr(string, value);
}    

int WINAPI expGetFileVersionInfoSizeA(const char* name, int* lpHandle)
{
    printf("GetFileVersionInfoSizeA(%s,0x%X)\n", name, lpHandle);
    return 0;
}    

int WINAPI expIsBadStringPtrW(const short* string, int nchars)
{
    if(string==0)return 1;
    return 0;
}    
extern long WINAPI InterlockedExchangeAdd( long* dest, long incr )
{
    long ret;
    __asm__ __volatile__( "lock; xaddl %0,(%1)"
                          : "=r" (ret) : "r" (dest), "0" (incr) : "memory" );
    return ret;
}

extern long WINAPI expInterlockedIncrement( long* dest )
{
    return InterlockedExchangeAdd( dest, 1 ) + 1;
}
extern long WINAPI expInterlockedDecrement( long* dest )
{
    return InterlockedExchangeAdd( dest, -1 ) - 1;
}

extern void WINAPI expOutputDebugStringA( const char* string )
{
    fprintf(stderr, "DEBUG: %s\n", string);
}    

int WINAPI expGetDC(int hwnd)
{
    return 0;
}

int WINAPI expGetDesktopWindow()
{
    return 0;
}
     
int WINAPI expReleaseDC(int hwnd, int hdc)
{
    return 0;
}    

int WINAPI expGetSystemPaletteEntries(int hdc, int iStartIndex, int nEntries, void* lppe)
{
    return 0;
}    
/*
typedef struct _TIME_ZONE_INFORMATION {
    long Bias;
    char StandardName[32];
    SYSTEMTIME StandardDate;
    long StandardBias;
    char DaylightName[32];
    SYSTEMTIME DaylightDate;
    long DaylightBias;
} TIME_ZONE_INFORMATION, *LPTIME_ZONE_INFORMATION;    
*/

int WINAPI expGetTimeZoneInformation(LPTIME_ZONE_INFORMATION lpTimeZoneInformation)
{
    memset(lpTimeZoneInformation, 0, sizeof(TIME_ZONE_INFORMATION));
    return 0;
}    

void WINAPI expGetLocalTime(SYSTEMTIME* systime)
{
    time_t local_time;
    struct tm *local_tm;
    struct timeval tv;
    
    gettimeofday(&tv, NULL);
    local_time=tv.tv_sec;
    local_tm=localtime(&local_time);
    
    systime->wYear = local_tm->tm_year + 1900;
    systime->wMonth = local_tm->tm_mon + 1;
    systime->wDayOfWeek = local_tm->tm_wday;
    systime->wDay = local_tm->tm_mday;
    systime->wHour = local_tm->tm_hour;
    systime->wMinute = local_tm->tm_min;
    systime->wSecond = local_tm->tm_sec;
    systime->wMilliseconds = (tv.tv_usec / 1000) % 1000;
}

int WINAPI expGetSystemTime(SYSTEMTIME* systime)
{
    time_t local_time;
    struct tm *local_tm;
    struct timeval tv;
    
    gettimeofday(&tv, NULL);
    local_time=tv.tv_sec;
    local_tm=gmtime(&local_time);
    
    systime->wYear = local_tm->tm_year + 1900;
    systime->wMonth = local_tm->tm_mon + 1;
    systime->wDayOfWeek = local_tm->tm_wday;
    systime->wDay = local_tm->tm_mday;
    systime->wHour = local_tm->tm_hour;
    systime->wMinute = local_tm->tm_min;
    systime->wSecond = local_tm->tm_sec;
    systime->wMilliseconds = (tv.tv_usec / 1000) % 1000;
    
}

int WINAPI expGetEnvironmentVariableA(const char* name, char* field, int size)
{
    dbgprintf("GetEnvironmentVariableA\n");
    printf("%s %x %x\n", name, field, size);
    if(field)field[0]=0;
    return 0;
}


//HDRVR WINAPI expOpenDriverA(LPCSTR szDriverName, LPCSTR szSectionName, LPARAM lParam2);
//HDRVR WINAPI expOpenDriverW(LPCWSTR szDriverName, LPCWSTR szSectionName, LPARAM lParam2);
HDRVR WINAPI expOpenDriver(LPCSTR szDriverName, LPCSTR szSectionName, LPARAM lParam2){
  printf("winmm32::OpenDriver() called\n");
  return NULL;
}


struct exports
{
    char name[64];
    int id;
    void* func;
};
struct libs 
{
    char name[64];
    int length;
    struct exports* exps;
};

#define FF(X,Y) \
{#X, Y, (void*)exp##X},

struct exports exp_kernel32[]={
FF(IsBadWritePtr, 357)
FF(IsBadReadPtr, 354)
FF(IsBadStringPtrW, -1)
FF(DisableThreadLibraryCalls, -1)
FF(CreateThread, -1)
FF(CreateEventA, -1)
FF(SetEvent, -1)
FF(ResetEvent, -1)
FF(WaitForSingleObject, -1)
FF(GetSystemInfo, -1)
FF(GetVersion, 332)
FF(HeapCreate, 461)
FF(HeapAlloc, -1)
FF(HeapDestroy, -1)
FF(HeapFree, -1)
FF(HeapSize, -1)
FF(GetProcessHeap, -1)
FF(VirtualAlloc, -1)
FF(VirtualFree, -1)
FF(InitializeCriticalSection, -1) 
FF(EnterCriticalSection, -1)
FF(LeaveCriticalSection, -1) 
FF(DeleteCriticalSection, -1)
FF(TlsAlloc, -1)
FF(TlsFree, -1)
FF(TlsGetValue, -1)
FF(TlsSetValue, -1)
FF(GetCurrentThreadId, -1)
FF(LocalAlloc, -1) 
FF(LocalLock, -1)
FF(GlobalAlloc, -1)
FF(GlobalLock, -1)
FF(MultiByteToWideChar, 427)
FF(WideCharToMultiByte, -1)
FF(GetVersionExA, -1)
FF(CreateSemaphoreA, -1)
FF(QueryPerformanceCounter, -1)
FF(QueryPerformanceFrequency, -1)
FF(LocalHandle, -1)
FF(LocalUnlock, -1)
FF(LocalFree, -1)
FF(GlobalHandle, -1)
FF(GlobalUnlock, -1)
FF(GlobalFree, -1)
FF(LoadResource, -1)
FF(ReleaseSemaphore, -1) 
FF(FindResourceA, -1)
FF(LockResource, -1)
FF(FreeResource, -1)
FF(SizeofResource, -1)
FF(CloseHandle, -1)
FF(GetCommandLineA, -1)
FF(GetEnvironmentStringsW, -1)
FF(FreeEnvironmentStringsW, -1)
FF(GetEnvironmentStrings, -1)  
FF(GetStartupInfoA, -1)
FF(GetStdHandle, -1)
FF(GetFileType, -1)
FF(SetHandleCount, -1)
FF(GetACP, -1)
FF(GetModuleFileNameA, -1)
FF(SetUnhandledExceptionFilter, -1)
FF(LoadLibraryA, -1)
FF(GetProcAddress, -1)
FF(FreeLibrary, -1)
FF(CreateFileMappingA, -1)
FF(OpenFileMappingA, -1)
FF(MapViewOfFile, -1)
FF(UnmapViewOfFile, -1)
FF(Sleep, -1)
FF(GetModuleHandleA, -1)
FF(GetPrivateProfileIntA, -1)
FF(GetPrivateProfileStringA, -1)
FF(WritePrivateProfileStringA, -1)
FF(GetLastError, -1)
FF(SetLastError, -1)
FF(InterlockedIncrement, -1)
FF(InterlockedDecrement, -1)
FF(GetTimeZoneInformation, -1)
FF(OutputDebugStringA, -1)
FF(GetLocalTime, -1)
FF(GetSystemTime, -1)
FF(GetEnvironmentVariableA, -1)
};

struct exports exp_msvcrt[]={
FF(malloc, -1)
FF(_initterm, -1)
FF(free, -1)
{"??3@YAXPAX@Z", -1, expdelete},
{"??2@YAPAXI@Z", -1, expnew},
FF(strrchr, -1)
FF(strchr, -1)
};
struct exports exp_winmm[]={
FF(GetDriverModuleHandle, -1)
FF(timeGetTime, -1)
FF(DefDriverProc, -1)
FF(OpenDriver, -1)
};
struct exports exp_user32[]={
FF(LoadStringA, -1)
FF(wsprintfA, -1)
FF(GetDC, -1)
FF(GetDesktopWindow, -1)
FF(ReleaseDC, -1)
};
struct exports exp_advapi32[]={
FF(RegOpenKeyA, -1)
FF(RegOpenKeyExA, -1)
FF(RegCreateKeyExA, -1)
FF(RegQueryValueExA, -1)
FF(RegSetValueExA, -1)
FF(RegCloseKey, -1)
};
struct exports exp_gdi32[]={
FF(CreateCompatibleDC, -1)
FF(GetDeviceCaps, -1)
FF(DeleteDC, -1)
FF(GetSystemPaletteEntries, -1)
};
struct exports exp_version[]={
FF(GetFileVersionInfoSizeA, -1)
};
#define LL(X) \
{#X".dll", sizeof(exp_##X)/sizeof(struct exports), exp_##X},

struct libs libraries[]={
LL(kernel32)
LL(msvcrt)
LL(winmm)
LL(user32)
LL(advapi32)
LL(gdi32)
LL(version)
};

void* LookupExternal(const char* library, int ordinal)
{
    char* answ;
    int i,j;
    if(library==0)
    {
	printf("ERROR: library=0\n");
	return (void*)ext_unknown;
    }
    printf("External func %s:%d\n", library, ordinal);
//    printf("%x %x\n", &unk_exp1, &unk_exp2);

    for(i=0; i<sizeof(libraries)/sizeof(struct libs); i++)
    {
	if(strcasecmp(library, libraries[i].name))
	    continue;
	for(j=0; j<libraries[i].length; j++)
	{
	    if(ordinal!=libraries[i].exps[j].id)
		continue;
	    printf("Hit: 0x%08X\n", libraries[i].exps[j].func);
	    return libraries[i].exps[j].func;
	}
    }
    if(pos>150)return 0;
    answ=(char*)extcode+pos*0x64;
    memcpy(answ, &unk_exp1, 0x64);
    *(int*)(answ+9)=pos;
    *(int*)(answ+47)-=((int)answ-(int)&unk_exp1);
    sprintf(export_names[pos], "%s:%d", library, ordinal);
    pos++;    
    return (void*)answ;
}    

void* LookupExternalByName(const char* library, const char* name)
{
    char* answ;
    int i,j;
//   return (void*)ext_unknown;
    if(library==0)
    {
	printf("ERROR: library=0\n");
	return (void*)ext_unknown;
    }
    if(name==0)
    {
	printf("ERROR: name=0\n");
	return (void*)ext_unknown;
    }
//    printf("External func %s:%s\n", library, name);
    for(i=0; i<sizeof(libraries)/sizeof(struct libs); i++)
    {
	if(strcasecmp(library, libraries[i].name))
	    continue;
	for(j=0; j<libraries[i].length; j++)
	{
	    if(strcmp(name, libraries[i].exps[j].name))
		continue;
//	    printf("Hit: 0x%08X\n", libraries[i].exps[j].func);
	    return libraries[i].exps[j].func;
	}
    }//    printf("%x %x\n", &unk_exp1, &unk_exp2);
    //printf("Missing (%d) External func %s:%s\n", pos, library, name);
    if(pos>150){
//      printf("Warning! Too many missing externals!\n");
      return 0;
    }
    strcpy(export_names[pos], name);
    answ=(char*)extcode+pos*0x64;
    memcpy(answ, &unk_exp1, 0x64);
    *(int*)(answ+9)=pos;
    *(int*)(answ+47)-=((int)answ-(int)&unk_exp1);
    pos++;
    return (void*)answ;
//    memcpy(extcode, &unk_exp1, 0x64);
//    *(int*)(extcode+52)-=((int)extcode-(int)&unk_exp1);
//    return (void*)extcode;
//    printf("Unknown func %s:%s\n", library, name);
//    return (void*)ext_unknown;
}