comparison loader/win32.c @ 597:d751f549f29f

no more warnings...

596:6a6b7c471c34

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

    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");

#define GARBAGE
#ifdef GARBAGE
struct alc_list_t;
typedef struct alc_list_t {
  int size;
  int addr;
  struct alc_list_t *prev;
  struct alc_list_t *next;
}alc_list;
static alc_list *alclist=NULL;
static alccnt=0;
#endif

void* my_mreq(int size, int to_zero)
{
    void* answer; 

    alclist->addr=answer;
    alccnt++;
#endif
    return (int*)((int)answer+sizeof(int));
}	
int my_release(char* memory)
{
#ifdef GARBAGE
    alc_list* pp;
    if(memory==0)return 0;
    if(alclist!=NULL)

				alccnt--;
				break;
			}
		}
        	if (pp == NULL) {
			printf("Not Found %x %d\n",memory-4,alccnt);
			return 0;
		}
	}
    }
#endif

    		result=(void*)(wm->module);
	}
	if(!result)
	{
	    if(strcasecmp(name, "kernel32")==0)
		result=0x120;
	}	
         dbgprintf("GetModuleHandleA('%s') => 0x%x\n", name, result);
	return result;
}

	    {
		dbgprintf("CreateEventA(0x%x, 0x%x, 0x%x, 0x%x='%s') => 0x%x\n",
		    pSecAttr, bManualReset, bInitialState, name, name, pp->pm);
		return pp->pm;
	    }
	}while(pp=pp->prev);
    }	
    pm=my_mreq(sizeof(pthread_mutex_t), 0);
    pthread_mutex_init(pm, NULL);
    pc=my_mreq(sizeof(pthread_cond_t), 0);
    pthread_cond_init(pc, NULL);

//    dbgprintf("WaitForSingleObject(0x%x, duration %d) =>\n",object, duration);
    do {
	if (pp == NULL) dbgprintf("WaitForSingleObject: NotFound\n");
	if((pp->pm, mlist->pm)==0)
		break;;
     }while(pp=pp->prev);
    

    pthread_mutex_lock(ml->pm);

    switch(ml->type) {

	    {
	        dbgprintf("CreateSemaphoreA(0x%x, init_count %d, max_count %d, name 0x%x='%s') => 0x%x",
		    v1, init_count, max_count, name, name, mlist);
		return (HANDLE)mlist;
	    }
	}while(pp=pp->prev);
    }	
    pm=my_mreq(sizeof(pthread_mutex_t), 0);
    pthread_mutex_init(pm, NULL);
    pc=my_mreq(sizeof(pthread_cond_t), 0);
    pthread_cond_init(pc, NULL);

{
    int result=FreeLibrary(module);
    dbgprintf("FreeLibrary(0x%x) => %d\n", module, result);
    return result;
}   
void* WINAPI expGetProcAddress(HMODULE mod, char* name)
{
    int result;
    if(mod!=0x120)
	result=GetProcAddress(mod, name);
    else
	result=LookupExternalByName("kernel32.dll", name);
    dbgprintf("GetProcAddress(0x%x, '%s') => 0x%x\n", mod, name, result);

{
    int result=strlen(str);
    dbgprintf("strlen(0x%x='%s') => %d\n", str, str, result);
    return result; 
}
int expstrcpy(char* str1, const char* str2) 
{
    int result=strcpy(str1, str2);
    dbgprintf("strcpy(0x%x, 0x%x='%s') => %d\n", str1, str2, str2, result);
    return result;
}
int expstrcmp(const char* str1, const char* str2)
{
    int result=strcmp(str1, str2);
    dbgprintf("strcmp(0x%x='%s', 0x%x='%s') => %d\n", str1, str1, str2, str2, result);
    return result;
}
int expstrcat(char* str1, const char* str2) 
{
    int result=strcat(str1, str2);
    dbgprintf("strcat(0x%x='%s', 0x%x='%s') => %d\n", str1, str1, str2, str2, result);
    return result;    
}
int expmemmove(void* dest, void* src, int n) 
{
    int result=memmove(dest, src, n);
    dbgprintf("memmove(0x%x, 0x%x, %d) => %d\n", dest, src, n, result);
    return memmove;
}
int expmemcmp(void* dest, void* src, int n) 
{
    int result=memcmp(dest, src, n);
    dbgprintf("memcmp(0x%x, 0x%x, %d) => %d\n", dest, src, n, result);
    return result;
}
int expmemcpy(void* dest, void* src, int n) 
{
    int result=memcpy(dest, src, n);
    dbgprintf("memcpy(0x%x, 0x%x, %d) => %x\n", dest, src, n, result);
    return result;
}
time_t exptime(time_t* t)
{
    time_t result=time(t);

    return result;
}

int WINAPI expStringFromGUID2(GUID* guid, char* str, int cbMax)
{
    int result=snprintf(str, cbMax, "%.8x-%.4x-%.4x-%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x",
     guid->f1, guid->f2, guid->f3,
     (unsigned char)guid->f4[0], (unsigned char)guid->f4[1], (unsigned char)guid->f4[2], (unsigned char)guid->f4[3], 
     (unsigned char)guid->f4[4], (unsigned char)guid->f4[5], (unsigned char)guid->f4[6], (unsigned char)guid->f4[7]);
    dbgprintf("StringFromGUID2(0x%x, 0x%x='%s', %d) => %d\n", guid, str, str, cbMax, result);
    return result;

		ppsv = pp;
		pp=pp->prev;
		free(ppsv);
		alccnt--;
	} 
   printf("Total Unfree %d bytes cnt %d [%x,%d]\n",unfree,unfreecnt,alclist,alccnt);
#endif
}

597:d751f549f29f

#include "win32.h"
#include <stdio.h>
#include <pthread.h>
#include <errno.h>
#include <ctype.h>
#include <stdlib.h>
#ifdef HAVE_MALLOC_H
#include <malloc.h>
#endif
#include <time.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>

    if(to_zero)
    	memset(heap+heap_counter, 0, size);	    
    heap_counter+=size;
    return heap+heap_counter-size;	
}
int my_release(void* memory)
{
//    test_heap();
    if(memory==NULL)
    {
	printf("ERROR: free(0)\n");

#define GARBAGE
#ifdef GARBAGE
struct alc_list_t;
typedef struct alc_list_t {
  int size;
  void *addr;
  struct alc_list_t *prev;
  struct alc_list_t *next;
}alc_list;
static alc_list *alclist=NULL;
static int alccnt=0;
#endif

void* my_mreq(int size, int to_zero)
{
    void* answer; 

    alclist->addr=answer;
    alccnt++;
#endif
    return (int*)((int)answer+sizeof(int));
}	
int my_release(void* memory)
{
#ifdef GARBAGE
    alc_list* pp;
    if(memory==0)return 0;
    if(alclist!=NULL)

				alccnt--;
				break;
			}
		}
        	if (pp == NULL) {
			printf("Not Found %p %d\n",memory-4,alccnt);
			return 0;
		}
	}
    }
#endif

    		result=(void*)(wm->module);
	}
	if(!result)
	{
	    if(strcasecmp(name, "kernel32")==0)
		result=(void *) 0x120;
	}	
         dbgprintf("GetModuleHandleA('%s') => 0x%x\n", name, result);
	return result;
}

	    {
		dbgprintf("CreateEventA(0x%x, 0x%x, 0x%x, 0x%x='%s') => 0x%x\n",
		    pSecAttr, bManualReset, bInitialState, name, name, pp->pm);
		return pp->pm;
	    }
	}while((pp=pp->prev));
    }	
    pm=my_mreq(sizeof(pthread_mutex_t), 0);
    pthread_mutex_init(pm, NULL);
    pc=my_mreq(sizeof(pthread_cond_t), 0);
    pthread_cond_init(pc, NULL);

//    dbgprintf("WaitForSingleObject(0x%x, duration %d) =>\n",object, duration);
    do {
	if (pp == NULL) dbgprintf("WaitForSingleObject: NotFound\n");
	if((pp->pm, mlist->pm)==0)
		break;;
     }while((pp=pp->prev));
    

    pthread_mutex_lock(ml->pm);

    switch(ml->type) {

	    {
	        dbgprintf("CreateSemaphoreA(0x%x, init_count %d, max_count %d, name 0x%x='%s') => 0x%x",
		    v1, init_count, max_count, name, name, mlist);
		return (HANDLE)mlist;
	    }
	}while((pp=pp->prev));
    }	
    pm=my_mreq(sizeof(pthread_mutex_t), 0);
    pthread_mutex_init(pm, NULL);
    pc=my_mreq(sizeof(pthread_cond_t), 0);
    pthread_cond_init(pc, NULL);

{
    int result=FreeLibrary(module);
    dbgprintf("FreeLibrary(0x%x) => %d\n", module, result);
    return result;
}   
void* LookupExternalByName(const char* library, const char* name);
void* WINAPI expGetProcAddress(HMODULE mod, char* name)
{
    void *result;
    if(mod!=0x120)
	result=GetProcAddress(mod, name);
    else
	result=LookupExternalByName("kernel32.dll", name);
    dbgprintf("GetProcAddress(0x%x, '%s') => 0x%x\n", mod, name, result);

{
    int result=strlen(str);
    dbgprintf("strlen(0x%x='%s') => %d\n", str, str, result);
    return result; 
}
void *expstrcpy(char* str1, const char* str2) 
{
    void *result=strcpy(str1, str2);
    dbgprintf("strcpy(0x%x, 0x%x='%s') => %p\n", str1, str2, str2, result);
    return result;
}
int expstrcmp(const char* str1, const char* str2)
{
    int result=strcmp(str1, str2);
    dbgprintf("strcmp(0x%x='%s', 0x%x='%s') => %d\n", str1, str1, str2, str2, result);
    return result;
}
void *expstrcat(char* str1, const char* str2)
{
    void *result=strcat(str1, str2);
    dbgprintf("strcat(0x%x='%s', 0x%x='%s') => %p\n", str1, str1, str2, str2, result);
    return result;    
}
void *expmemmove(void* dest, void* src, int n) 
{
    void *result=memmove(dest, src, n);
    dbgprintf("memmove(0x%x, 0x%x, %d) => %p\n", dest, src, n, result);
    return memmove;
}
int expmemcmp(void* dest, void* src, int n) 
{
    int result=memcmp(dest, src, n);
    dbgprintf("memcmp(0x%x, 0x%x, %d) => %d\n", dest, src, n, result);
    return result;
}
void *expmemcpy(void* dest, void* src, int n) 
{
    void *result=memcpy(dest, src, n);
    dbgprintf("memcpy(0x%x, 0x%x, %d) => %p\n", dest, src, n, result);
    return result;
}
time_t exptime(time_t* t)
{
    time_t result=time(t);

    return result;
}

int WINAPI expStringFromGUID2(GUID* guid, char* str, int cbMax)
{
    int result=snprintf(str, cbMax, "%.8lx-%.4x-%.4x-%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x",
     guid->f1, guid->f2, guid->f3,
     (unsigned char)guid->f4[0], (unsigned char)guid->f4[1], (unsigned char)guid->f4[2], (unsigned char)guid->f4[3], 
     (unsigned char)guid->f4[4], (unsigned char)guid->f4[5], (unsigned char)guid->f4[6], (unsigned char)guid->f4[7]);
    dbgprintf("StringFromGUID2(0x%x, 0x%x='%s', %d) => %d\n", guid, str, str, cbMax, result);
    return result;

		ppsv = pp;
		pp=pp->prev;
		free(ppsv);
		alccnt--;
	} 
   printf("Total Unfree %d bytes cnt %d [%p,%d]\n",unfree,unfreecnt,alclist,alccnt);
#endif
}