/* SKELETON.C -- THE PROTOTYPE APPLICATION FOR THE OXBOW FRAMEWORK
	COMPILE WITH GCC

   COPYRIGHT 1994 Norman D. Culver, Ft. Lauderdale, FL

NOTE: 'main()' is at the end of the file.
*/
#define SYMLINK(from,to) badsyms += oxlink_symlink(#from,#to)

#define EARLY_PRINT 1	/* set to 1 if trace before linkup needed */

#define BASE_CATEGORY 0
#define MEMORY_BUG 0
#define PRINT_RAWDATA 0

#if 0
#define DPRINTF lprintf
#else
#define DPRINTF(args...)
#endif

#if 0
#define MPRINTF lprintf
#else
#define MPRINTF(args...)
#endif

#if EARLY_PRINT == 1
#define TPRINTF lprintf
#else
#define TPRINTF VPRINTF
#endif

#include <go32.h>

/* extracts from 'oxbow.h' */
typedef unsigned long long  KeyItem;   /* type for a key's associated item */

typedef union 			/* 2 BYTES */
	{
		unsigned short val;
		unsigned char b[2];
} SVAL;

typedef union			/* 4 BYTES */
	{
	unsigned long a0;
	void *a1;
	struct
		{
		SVAL	lo_word;
		SVAL	hi_word;
		} a2;
	struct
		{
			unsigned int pad :28;
			unsigned int type :4;
		} a3;
	struct
		{
			unsigned char b[4];
		} a4;
	int a8;
	short a9;
	char a10;
	float a11;
} ADDR;

typedef union _stor	/* 8 BYTES */
	{
	unsigned long	a0;
	void *a1;
	KeyItem item;
	struct
		{
		unsigned short	lo_word;
		unsigned short	hi_word;
		unsigned int size :28;		/* in bytes or nibbles */
		unsigned int type :4;	    /* describes the STOR type */
		} a2;
	struct
		{
			short s0;
			short s1;
			short s2;
			short s3;
		} a3;
	struct
		{
			unsigned long	s0;
			unsigned long	s1;
		} a4;
	struct
		{
			unsigned char	b[8];
		} a5;
	struct
		{
			unsigned long long dupname :48;
			unsigned long long dupid :16;
		} a6;
	struct
		{
			unsigned int home : 30;
			unsigned int full : 2;
		} a7;
	int a8;
	short a9;
	char a10;
	float a11;
	double a12;
} STOR, Item;

typedef struct			/* 12 BYTES */
	{
		STOR c0;
		ADDR c1;
} CAT;

#define OB_XFILE	(0x00004000)
#define OB_ROOTDIR	(0x00000200)
#define OB_TREEDIR	(0x10000000)
#define OB_HASHDIR	(0x20000000)
#define F_RDONLY	(0x0001)
#define F_STAT		(0x20000)	/* TRULY READONLY */
#define O_RDONLY	(0x0001)
#define O_BINARY	(0x8000)
#define R_CLEAN		(0x40000000)
#undef NULL
#define NULL		((void *)0)
#define FOUND		(1)
#define NODUPS		(0)
#define S_SET		(0)
#define S_READBLK	(1)
#define S_WRITEBLK	(2)

#define	_cat2_(a, b)	a##b
#define _cat_(a, b)	_cat2_(a, b)
#define _qt2_(x) #x
#define _qt_(x) _qt2_(x)

#define oxfunc(func, args...) ({ \
typedef _fret = (appfunc()); \
_fret (*dofunc)(); _fret _ret; \
dofunc = oxlink_load_bare_symb(func,1); \
if(dofunc) _ret = dofunc(## args) & 0x0fffffff; \
else _ret = (_fret) -1; \
_ret;})

#define oxload(func) \
oxlink_load_bare_symb(_qt_(_cat_(_, func)),1)

#define oxunload(func) \
oxlink_unload_symb(#func, 1)

typedef int jmp_buf[32];			   /* an adequate buffer for setjmp */
int setjmp();
void longjmp();

/* end: extracts from 'oxbow.h' */
/* ==================== A LIST OF PROBLEMS ======================= */
/* external function prototypes needed initially,
	THESE NEED TO BE LOCALIZED */
void *sbrk();
int open();
int creat();
int close();
int read();
int write();
int lseek();
char *getenv();
char *getwd();

int strlen();
char *strdup();
char *strcat();
char *strcpy();
char *strchr();
char *strrchr();
char *strstr();
int _strcpy();
long strtol();
int strcmp(const char *, const char *);
int strncmp();
void CF_Interactive_IO();
int appfunc();
void *malloc(unsigned);
void *calloc(unsigned, unsigned);
void free(void*);
void *memcpy();

/* external function prototypes needed by the portability modules
	THESE TOO NEED TO BE LOCALIZED (or something) */
void exit();
int ftruncate();
void abort();

/* internal function prototypes */
static int lnulfunc();
static void lhash(void *, int, CAT *);
static int laccess(char *, int);
static int lpagesize(void);
static int lprintchar(int);
static void lprintstr(char *);
static void lcrash(char *, ...);
void CF_InitIO(long arg, long long (*msgproc)());

/* ======================== END LIST OF PROBLEMS ==================== */

/* DYNAMIC LINKER FUNCTIONS */
int oxlink_init ();		    /* initialize the routines */
int oxlink_load_file ();	/* dynamically link and load an object file */
int oxlink_load_object ();	/* link object file from libraries in list */
void *oxlink_find_func ();	/* return the address of the named function */
void *oxlink_find_bare_func ();/* same as oxlink_find_func except that
						       no underscore (_) is prepended (also faster). */
void * oxlink_find_sym ();	/* return the address of the named identifier  */
void *oxlink_find_bare_symb ();/* same as oxlink_find_symb except that
						       no underscore (_) is prepended (also faster). */
int oxlink_unload_file ();   /* unlink a file */
int oxlink_unload_symb (); /* unlink the module that defines the given symbol */
int oxlink_unload_bare_symb (); /* unlink the module that defines the given symbol */
char **oxlink_list_undefined_symb ();/* return an array of undefined symbols */
char *cf_find_file ();/* return the full path name of the given file. */
void *oxlink_load_symb(char *symb, int dynlink);
void *oxlink_load_bare_symb(char *symb, int dynlink);
int oxlink_export_symb();
int oxlink_export_bare_symb();
void oxlink_unexport_symb();
void oxlink_unexport_bare_symb();
int oxlink_symlink();			/* give new symbol same values as old symbol */
void oxlink_demand_load();	/* define all undefined symbols with negative numbers */
void oxlink_use_library();	/* add a filename for undefined symbol search */
void oxlink_nouse_library();	/* remove a library from the search list */
void  *oxlink_resolve_symb();	/* resolve one of the demand loadable undefs */
void oxlink_trace();		/* set the trace level */
char *oxlink_symname();		/* return name of a demand loadable undef */
void *oxlink_rename_symb(char *old,char *new);
int oxlink_rename_file(char *old,char *new);
void oxlink_lib_check(int dynlink);	/* force search of library list */
char *oxlink_file_of(char *symb);
char *oxlink_file_of_bare(char *symb);
int oxlink_scan_file(void *fhandle, void *thandle);
void oxlink_set_libtype(int type);
void oxlink_set_libnum(int libnum);
void oxlink_load_thunk(int thunknum);
int oxlink_prep_thunk(char *symb);
void oxlink_clear_bss(char *filename);
void *oxlink_get_entry_struct(char *filename);
char *oxlink_errstr(void);

/* virtual function pointers initially hard linked to the load module */
/* needed in order to initialize and read a .o or .a file */
int (*VCFREAD)() = read;
int (*VCFWRITE)() = write;
void *(*VCFOPEN)() = (void *)open;
int (*VCFCLOSE)() = close;
int (*VCFLSEEK)() = lseek;
int (*VACCESS)() = laccess;
void *(*VSBRK)() = sbrk;
char *(*VGETENV)() = getenv;
char *(*VGETCWD)() = getwd;
int (*VOBTYPE)() = lnulfunc;

void (*VHASH)() = lhash;
int (*VGETPAGESIZE)() = lpagesize;


#if EARLY_PRINT == 0
int (*VVPRINTF)() = lnulfunc;
int (*VSPRINTF)() = lnulfunc;
int (*VPRINTF)() = lnulfunc;
int (*BUGPRINTF)() = lnulfunc;
#else
static int lvprintf(char *, void *);
static int lsprintf(char *, char *, ...);
static int lprintf(char *, ...);
int (*VVPRINTF)(char *, void*) = lvprintf;
int (*VSPRINTF)(char *, char *, ...) = lsprintf;
int (*VPRINTF)(char *, ...) = lprintf;
int (*BUGPRINTF)(char *, ...) = lprintf;
#endif

/* function pointers needed by portability modules */
void *(*VMALLOC)() = malloc;
void *(*VCALLOC)() = calloc;
void (*VFREE)() = free;
void (*VEXIT)() = exit;
int (*VREAD)() = read;
int (*VOPEN)() = open;
int (*VCLOSE)() = close;
int (*VLSEEK)() = lseek;
int (*VWRITE)() = write;
void (*VABORT)() = abort;
int (*VPRINTCHAR)() = lprintchar;
void (*VPRINTSTR)() = lprintstr;
void (*VCRASH)(char* fmt, ...) = lcrash;
void (*VBITBLT)();
int (*VSTAT)() = lnulfunc;

/* function pointers used internally */
int (*CFINIT)();
void (*CFEXIT)();
int (*COSINIT)();
void (*THREADER)();
void (*THREAD)();
int *VINHIBIT_THREADER;

/* cff function pointers used but not available until cff is loaded */
int (*VPUSH_VALUE)();
int (*VPUSH_DATA)();
int (*VFIND)();
int (*VGET)();
void *(*VSUBOPEN)();
int (*VPUT)();
int (*VFILESIZE)();
void *(*VOPEN_CHUNK)();
void *(*VLOCALIZE)();
int (*VRELEASE)();
void **VMEMTEMP;

/* function pointers used by the COS threader but not available until
	the message class is loaded */
int (*VWASMSG)() = lnulfunc;
int (*VDISPATCHMSG)() = lnulfunc;


/* Global variables, here to suppress re-linking */
long long (*VAPPMSG)();
void *Application;
int numTextModes;
int numGraphicModes;
void *TextModes;
void *GraphicModes;
int GuiEnabled;
int _SCREENXMAX;
int _SCREENYMAX;
int _REMOTEFD;
int _SCREENHEIGHT;
int _EFFECTIVE_SCREENHEIGHT;
int _SCREENWIDTH;
int _EFFECTIVE_SCREENWIDTH;
int _GLOBALWIDTH;
int _GLOBALHEIGHT;
int _CURCOLS;
int _CURROWS;
int _FONTWIDTH;
int _FONTHEIGHT;
int _CHARWIDTH;
int _LINEHEIGHT;
int _GRIDWIDTH;
int _GRIDHEIGHT;
int _GLOBALX;
int _GLOBALY;
int _MAXROWS;
int _MAXCOLS;
int _VIDEOMODE;
int _LOOK;
int _FEEL;

/* variables needed by the cos threader */
int _no_context_switch = 1;
jmp_buf _t_start;

/* application initializer word */
long AppArg;

/* flag used to force early symbols to be permanent */
static int permanent_symbols;
static char path_sep;

/* ================ START OF INTERNAL SUPPORT FUNCTIONS ============ */

/* ========================= MULTI HEAP MALLOC ========================== */
/*
   NOTE: In a demand paged environment, this implementation of malloc
         (using skip_lists) can be ENORMOUSLY faster than buddy_block
         style mallocs.
*/
void *mallocC(int category, unsigned amount);
void *callocC(int category, unsigned nelems, unsigned elemsize);
void *reallocC(int category, void* buf, unsigned newsize);
void freeC(int category, void* buf);
void freecat(int category);
int memrangeC(int category, unsigned* minp, unsigned* maxp);
int usedrangeC(int category, unsigned* minp, unsigned* maxp);
void totrangeC(unsigned* minp,unsigned* maxp);
void *heapcheckC(int category, void *start);
void guardC(int category);
void *memalignC(int category, unsigned alignment, unsigned req);

#define PAGESIZE VGETPAGESIZE()
#define ALIGNMENTM (sizeof(unsigned long))
#define MAL_MAXLEVEL (12)
#define ROUNDINGM(a) ((ALIGNMENTM-(a&(ALIGNMENTM-1)))&(ALIGNMENTM-1))
#define ALLOCSIZE (4096)
#define FRNTGUARD (0x544e5246UL)
#define BACKGUARD (0x48434142UL)
#define THEWELL do_sbrk

#define NUMTYPES 3
#define SIZEH 0
#define FREEH 1
#define USEDH 2

#define SKIPVARS NodePM update[MAL_MAXLEVEL+1];NodePM node,prev;int level

#define DELETENODE(TYPE) \
{for(level=0;level<=bp->TYPE##level; level++)\
{if(update[level]->fptr[level] == node)\
update[level]->fptr[level] = node->fptr[level];else break;}\
while(bp->TYPE##level>0 && bp->TYPE##header->fptr[bp->TYPE##level]==_NILLL)\
bp->TYPE##level--;free_Mnode(bp,node,TYPE);}

#define INSERT() \
{while(level >= 0){\
node->fptr[level] = update[level]->fptr[level];\
update[level]->fptr[level] = node;level--;}}

#define SETLEVEL(TYPE) \
{level = getMlevel(bp, bp->TYPE##level);\
while(bp->TYPE##level < level)update[++bp->TYPE##level]=bp->TYPE##header;}

#define FINDKEY(TYPE, KEYVAL)\
{node = bp->TYPE##header;\
for(level = bp->TYPE##level; level >= 0; level--){\
while(node->fptr[level]->key < KEYVAL)\
node = node->fptr[level];\
update[level] = node;}prev=node;node=node->fptr[0];}

#define DETACH(SN)\
{SN->bptr->fptr=SN->fptr;if(SN->fptr)SN->fptr->bptr=SN->bptr;}

#define UNLINK(SN, N)\
{if(!sp->fptr&&sp->bptr->bptr<=(AddrP)(MAL_MAXLEVEL+1))dsize[N]=sp->size;\
DETACH(SN);free_addr(bp,SN);}

#define CHECKGUARDS(MSG)\
{if(bp->guarded){\
unsigned *p2;\
p2 = (void*)((char*)address+cursize-ALIGNMENTM);\
if(*address != FRNTGUARD)\
VCRASH(#MSG ":%d: corrupted at 0x%x\n", bp->bincat, addr);\
if(*p2 != BACKGUARD)\
VCRASH(#MSG ":%d: corrupted by 0x%x\n", bp->bincat, addr);}}

#if MEMORY_BUG == 1
#define HEAPCHECK \
{void *lastaddr;\
if(category > 0){\
guardC(category);\
if((lastaddr = heapcheckC(category, NULL))){\
FINDKEY(USEDH, (unsigned)lastaddr-ALIGNMENTM)\
BUGPRINTF("bad heap at %x c:%u size=%u\n", lastaddr, category, node->value);\
(void)print_rawdata(lastaddr-ALIGNMENTM, node->value);\
VABORT();}}}
#else
#define HEAPCHECK
#endif

struct _catlocs {
	void *addr;
	struct _catlocs *fptr;
};

typedef struct _nodeM
{
	unsigned key;
	unsigned value;
	unsigned levels;	/* must always be after value */
	struct _nodeM *fptr[1];
} NodeM, *NodePM;

typedef struct _addr
{
	struct _addr *fptr;
	struct _addr *bptr;
	NodePM maddr;
	unsigned size;
} *AddrP;

struct _bins {
	unsigned bits;
	unsigned nbits;
	NodePM SIZEHheader;
	int SIZEHlevel;
	NodePM FREEHheader;
	int FREEHlevel; 
	NodePM USEDHheader;
	int USEDHlevel;

	unsigned bincat;
	unsigned maxloc;
	unsigned minloc;
	struct _catlocs *catlocs;
	struct _bins *fptr;
	NodePM freenodes[NUMTYPES][MAL_MAXLEVEL+2];
	struct _addr *freeaddrlocs;
	char *chunkbase[NUMTYPES];
	int chunksize[NUMTYPES];
	int guarded;
	int addrbump;
};

static struct _bins zbp;
static struct _bins *hmap[1009];
static struct _nodeM _nilll = {0xffffffff,0,0,{0}};
static struct _nodeM *_NILLL = &_nilll;
static unsigned maxloc;
static unsigned minloc;
static struct _bins *freebinlocs;
static struct _catlocs *freecatlocs;
static char *binbase;
static int binsize;
static int chunksizes[] = {ALLOCSIZE,3*ALLOCSIZE,2*ALLOCSIZE};


static long randtbl[32]	= { 0L,
	0x9a319039L, 0x32d9c024L, 0x9b663182L, 0x5da1f342L, 
	0xde3b81e0L, 0xdf0a6fb5L, 0xf103bc02L, 0x48f340fbL, 
	0x7449e56bL, 0xbeb1dbb0L, 0xab5c5918L, 0x946554fdL, 
	0x8c2e680fL, 0xeb3d799fL, 0xb11ee0b7L, 0x2d436b86L, 
	0xda672e2aL, 0x1588ca88L, 0xe369735dL, 0x904f35f7L, 
	0xd7158fd6L, 0x6fa6f051L, 0x616e6b96L, 0xac94efdcL, 
	0x36413f93L, 0xc622c298L, 0xf5a42ab8L, 0x8a88d77bL, 
	0xf5ad9d0eL, 0x8999220bL, 0x27fb47b9L
};

static  long *fptr	= &randtbl[4];
static  long *rptr	= &randtbl[1];


/* ================== THE CRASH FUNCTION IS FIRST IN .TEXT ================ */
static void
lcrash(char *msg, ...)
{
	VVPRINTF(msg, &msg+1);
/*	CFEXIT();*/
	*((char *)0) = 0;	/* force exception */
}
#if PRINT_RAWDATA == 1
static char
hexbyte(unsigned int c)
{
char x = c & 0xf;

	return x + ((x>9) ? 55 : 48);
}
static void
print_rawdata(void *rawdata, long size)
{
unsigned long vaddr = 0;
unsigned char *d = rawdata;
int i,j;
char addr[9];
char hex1[24];
char hex2[24];
char side1[9];
char side2[9];

	addr[8] = 0;
	hex1[23] = 0;
	hex2[23] = 0;
	side1[8] = 0;
	side2[8] = 0;
	while(size > 0)
	{
	unsigned long qaddr = vaddr;
		memset(addr, '0', 8);
		memset(hex1, ' ', 23);
		memset(hex2, ' ', 23);
		memset(side1, ' ', 8);
		memset(side2, ' ', 8);
		i = 7;
		while(qaddr)
		{
			addr[i--] = hexbyte(qaddr);
			qaddr >>= 4;
		}
		for(i=0,j=0; i < 8; ++i)