oxbow.h

OXCC is a multipass, interpreting C compiler with several language extensions. It generates an Archi

#ifndef __STDIOH__
#define __STDIOH__

#define __BUFSIZ_  (4096)

extern  struct  cf_iobuf {
    int      _cnt;
    char*    _ptr;
    char*    _base;
	int		 _bufsiz;
    short	 _flag;
    unsigned char	 _file;
	char	 _sbuf;
} cf_iob[];
#endif /* __STDIOH__ */

#define cfstdin     (&cf_iob[0])
#define cfstdout    (&cf_iob[1])
#define cfstderr    (&cf_iob[2])
#define cfstdaux    (&cf_iob[3])
#define cfstdprn    (&cf_iob[4])

extern void *cf_filelist[];

typedef struct cf_iobuf cfFILE;

#define cf_IOFBF    (00000)
#define cf_IOREAD   (00001)
#define cf_IOWRT    (00002)
#define cf_IONBF    (00004)
#define cf_IOMYBUF  (00010)
#define cf_IOEOF    (00020)
#define cf_IOERR    (00040)
#define cf_IOSTRG   (00100)
#define cf_IOLBF    (00200)
#define cf_IORW     (00400)
#define cf_IOAPPEND (01000)
#define cf_IOTEXT   (02000)  /* for MSDOS cr/lf style files */


#define cfgetc(p) (--(p)->_cnt>=0 ? \
  (int)(*(unsigned char*)(p)->_ptr++) : \
  cf_filbuf(p))
#define cfputc(x,p) (--(p)->_cnt>=0? \
  ((int)((unsigned char)((*(p)->_ptr++=(unsigned)(x))))): \
  cf_flsbuf((unsigned)(x),p))

#define cfclearerr(p) ((p)->_flag &= ~(cf_IOERR|cf_IOEOF))
#define cfgetchar()   cfgetc(cfstdin)
#define cfputchar(x)  cfputc(x,cfstdout)
#define cffeof(p)     (((p)->_flag&cf_IOEOF)!=0)
#define cfferror(p)   (((p)->_flag&cf_IOERR)!=0)
#define cffileno(p)   (cf_filelist[(p)->_file])

int    cf_filbuf(cfFILE*);
int    cf_flsbuf(unsigned, cfFILE*);
int    cffclose(cfFILE*);
cfFILE*  cffdopen(void *, const char*);
int    cffflush(cfFILE*);
int    cffgetc(cfFILE*);
char*  cffgets(char*, int, cfFILE *);
cfFILE*  cffopen(const char*, const char*);
int    cffputc(int, cfFILE*);
int    cffputs(const char*, cfFILE*);
int    cffread(void*, int, int, cfFILE*);
cfFILE*  cffreopen(const char*, const char*, cfFILE*);
int    cffseek(cfFILE*, long, int);
long   cfftell(cfFILE *);
int    cffwrite(const void*, int, int, cfFILE*);
char*  cfgets(char*);
int    cfgetw(cfFILE*);
int    cfputs(const char*);
int    cfputw(int, cfFILE*);
void   cfrewind(cfFILE*);
int    cfsetbuf(cfFILE*, char*);
int    cfsetbuffer(cfFILE*, char*, int);
int    cfsetlinebuf(cfFILE*);
int    cfsetvbuf(cfFILE*, char*, int, int);
int    cfungetc(int, cfFILE*);
int	   cffgetpos(cfFILE*, long *);
int	   cffsetpos(cfFILE*, long *);
cfFILE *cftmpfile(void);
char   *cftmpnam(char *);
char   *cftempnam(char *, char *);
int	cfprintf(const char *fmt, ...);
int	cfeprintf(const char *fmt, ...);
int cfveprintf(const char *fmt, char *args);
int cffprintf(cfFILE *iop, const char *fmt, ...);
int cfsprintf(char *str, const char *fmt, ...);
int cfvprintf(const char *fmt, char *args);
int cfvvprintf(const char *fmt, char **args);
int cfvfprintf(cfFILE *iop, const char *fmt, char *args);
int cfvvfprintf(cfFILE *iop, const char *fmt, char **args);
int cfvsprintf(char *str, const char *fmt, char *args);
int cfvvsprintf(char *str, const char *fmt, char **args);

int cfsscanf(char *str, const char *fmt, ...);
int cfvsscanf(char *str, const char *fmt, char **args);
int cffscanf(cfFILE *iop, const char *fmt, ...);
int cfvfscanf(cfFILE *iop, const char *fmt, char **args);
int cfscanf(const char *fmt, ...);
int cfvscanf(const char *fmt, char **args);

void cfinit(char *appname, int lbufpages, char *permfile);
void cfexit();
void cfport_settestflags(int flags);

void cfhash(const void *keyptr, int keysize, CAT *cat);
long cfrdwr_object(void *handle, void *userbuffer, long amount, int mode);
long cfseek(void *handle, long amount, int mode);

int cfkeycmp (void *keya, int lena, void *keyb, int lenb);
int cflexical_keycmp (void *keya, int lena, void *keyb, int lenb);
int cfitemcmp(void *itema, void *itemb);

void cfprintbitmaps(void *something);
void cfprintentries(void *something);
void *cfopen(const char *path, long mode, void *info);
void *cfsubopen(void *handle, const char *name, long mode, void *info);
void *cfopen_chunk(void *handle, void *item);
void *cfmake_chunk(void *handle, void *key, int keylen, int size);
void *cfdup(void *handle);
void *cfreopen(void *handle);
void cfclose(void *handle);
int cfunlink(void *something, ... );
int cfstat(void *something, void *stbuf);
int cfsubstat(void *handle,const char *name, void *stbuf);
void *cfcopy(void *something_dst, void *something_src);
long cfcopy_file(void *handle_dst, void *handle_src);
int cfcopy_object(void *handle_dst, void *handle_src);
void cftotalloc(void *something, unsigned long *used, unsigned long *alloc);
long cffilesize(void *something);
void *cflocalize(void *handle, void *item);
void cfrelease(void *ptr, long mode);

#define cfread(a,b,c) \
cfrdwr_object(a,b,c,S_READBLK)
#define cfwrite(a,b,c) \
cfrdwr_object(a,b,c,S_WRITEBLK)

int cfdef(const char *key, const char *def);
int cfsysdef(const char *key, const char *def);
int cfappdef(const char *key, const char *def);
int cfundef(const char *key);
int cfsysundef(const char *key); 
int cfappundef(const char *key);
int cftrn(const char *strn, char **newstrn);
int cfpathtrn(const char *strn, char **newstrn);
void cfflush(void *handle);
void cfsync(void);
int cftruncate(void *something, unsigned long size);

int cfqinsert(void *handle,const void *key, int len, void *item);
int cfinsertx(void *handle,const void *key,int len,void *item,int dups,void *adup);
#define cfinsert(handle,keyptr,keylen,itemptr) \
cfinsertx(handle,keyptr,keylen,itemptr,NODUPS,NULL)
#define cfinsert_dupnum(handle,keyptr,keylen,itemptr,dupnum) \
cfinsertx(handle,keyptr,keylen,itemptr,OKDUPS,dupnum)
#define cfinsert_dupname(handle,keyptr,keylen,itemptr,dupname) \
cfinsertx(handle,keyptr,keylen,itemptr,DUPNAMES,dupname)

int cfqget(void *handle, const void *keyptr, int keylen, void *bufptr, int buflen);
int cfqfind(void *handle, const void *keyptr, int keylen, Item *keyi, Item *dati);
int cfqfindkey(void *handle, const void *keyptr, int keylen, Item *keyi);
int cfqfinddat(void *handle, const void *keyptr, int keylen, Item *dati);

int cffindx(void *handle, const void *keyptr, int keylen, void *itemptr, void *adup);
#define cffind(handle,key,len,item) \
cffindx(handle,key,len,item,NULL)
#define cffind_dupnum(handle,key,len,item,dupnum) \
cffindx(handle,key,len,item,dupnum)
#define cffind_dupname(handle,dupname,itemptr) \
cffindx(handle,dupname,8,itemptr,(void *)0xffffffff)
#define cfreinsert(handle,key,len,item) \
cffindx(handle,key,-len,item,NULL)
#define cfreinsert_dupnum(handle,key,len,item,dupnum) \
cffindx(handle,key,-len,item,dupnum)
#define cfreinsert_dupname(handle,key,len,itemptr,dupname) \
cffindx(handle,dupname,-8,itemptr,(void *)0xffffffff)

int cffind_item(void *handle, const void *key, int keylen, void *itemptr);
int cffind_mark(void *handle, void *itemptr);

#define cfdelete(a,b,c) \
cfdelete_item(a,b,c,NULL)
int cfdelete_item(void *handle, void *key, int keylen, void *itemptr);
int cfdelete_dupnum(void *handle, void *key, int keylen, long dupnum);
#define cfdelete_lastdupnum(a,b,c) \
cfdelete_dupnum(a,b,c,-1)
int cfdelete_dupname(void *handle, const void *key, int keylen, void *dupname);
int cfdelete_lastdupname(void *handle, const void *key, int keylen);
int cfdelete_alldupnames(void *handle, const void *key, int keylen);
int cfdelete_alldupnums(void *handle, const void *key, int keylen);
int cflastdupname(void *handle, const void *key, int keylen, void *dupname);

long cfpush_item(void *handle, void *itemptr);
long cfpush_value(void *handle, unsigned long *value);
long cfpush_data(void *handle, void *datptr, int datsize);
long cfpop_item(void *handle, void *itemptr);
long cfpop_value(void *handle, unsigned long *value);
long cfpop_data(void *handle, void *datptr, int datsize);
long cfstackdepth(void *handle);

long cfcountdups(void *handle, void *key, int keylen);
long cfmisc(void *something, int func, ...);

void *cfopendir(const void *path);
void cfclosedir(void *it);
CFDIRENT *cfreaddir(void *it);
CFDIRENT *cfreadfulldir(void *it);
void cfrewinddir(void *it);
void cftelldir(void *it, STOR *entry);
void cfseekdir(void *it, STOR *entry);
long cfentrycnt(void *something);

int cfseq_dupnum(void *handle, const void *key, int len, void *itemptr, int mode);
#define cfhead_dupnum(a,b,c,d) cfseq_dupnum(a,b,c,d,CF_HEAD)
#define cftail_dupnum(a,b,c,d) cfseq_dupnum(a,b,c,d,CF_TAIL)
#define cfnext_dupnum(a,b,c,d) cfseq_dupnum(a,b,c,d,CF_NEXT)
#define cfprev_dupnum(a,b,c,d) cfseq_dupnum(a,b,c,d,CF_PREV)

int cfseq_dupname(void *handle, void *key, int len, void *itemptr, int mode);
#define cfhead_dupname(a,b,c,d) cfseq_dupname(a,b,c,d,CF_HEAD)
#define cftail_dupname(a,b,c,d) cfseq_dupname(a,b,c,d,CF_TAIL)
#define cfnext_dupname(a,b,c,d) cfseq_dupname(a,b,c,d,CF_NEXT)
#define cfprev_dupname(a,b,c,d) cfseq_dupname(a,b,c,d,CF_PREV)


#define cfdepth(a) \
cfmisc(a, CF_DEPTH)
#define cfmark(a) \
cfmisc(a, CF_MARK)
#define cfgetmark(a,b) \
cfmisc(a, CF_GETMARK, b)
#define cfsetmark(a,b) \
cfmisc(a, CF_SETMARK, b)
#define cfhead(a,b) \
cfmisc(a, CF_HEAD, b)
#define cftail(a,b) \
cfmisc(a, CF_TAIL, b)
#define cfnext(a,b) \
cfmisc(a, CF_NEXT, b)
#define cfprev(a,b) \
cfmisc(a, CF_PREV, b)
#define cfkeylen(a,b) \
cfmisc(a, CF_KEYLEN, b)
#define cfdatalen(a,b) \
cfmisc(a, CF_DATALEN, b)
#define cfbytesused(a) \
cfmisc(a, CF_USED)
#define cfbytesalloc(a) \
cfmisc(a, CF_ALLOC)
#define cfmodbufs(a) \
cfmisc(NULL, CF_MODBUFS, a)
#define cfcurbufs() \
cfmisc(NULL, CF_CURBUFS)
#define cfsetkeycmp(a,b) \
cfmisc(a, CF_SETKEYCMP, b)
#define cfsetitemcmp(a,b) \
cfmisc(a, CF_SETITEMCMP, b)
#define cfseterrfunc(a) \
cfmisc(NULL, CF_SETERRFUNC, a)
#define cfsetprintfunc(a) \
cfmisc(NULL, CF_SETPRINTFUNC, a)
#define cfisnew(a) \
cfmisc(a,CF_ISNEW)
#define cfsetverylazy(a) \
cfmisc(a, CF_LAZY)
#define cfsetlazy(a) \
cfmisc(a, CF_VERYLAZY)
#define cfclrlazy(a) \
cfmisc(a, CF_CLRLAZY)
#define cffilealloc(a) \
cfmisc(a, CF_FILEALLOC)
#define cfprealloc(a) \
cfmisc(a, CF_PREALLOC)
#define cfalignment(a) \
cfmisc(a, CF_ALIGNMENT)
#define cfmapsize(a) \
cfmisc(a, CF_MAPSIZE)
#define cfissorted(a) \
cfmisc(a, CF_ISSORTED)
#define cfkey(ccb,key,len) \
cfmisc(ccb, CF_KEY, key, len)
#define cfitem(ccb, item) \
cfmisc(ccb, CF_ITEM, item)
#define cfdata(ccb, buf, len) \
cfmisc(ccb, CF_DATA, buf, len)

void cfpflags(char *name, void *handle);
long cfobtype(void *handle);
void *cfgetspace(void *handle, long amount, void *addr);
int cfretspace(void *handle, void *addr);

void *cfputx(void *handle, const void *keyptr, int keylen, void *itemptr,
					int dupflg, void *adup, void *bufptr, long buflen);
#define cfput(handle,key,len,buf,buflen,itemptr) \
cfputx(handle,key,len,itemptr,NODUPS,NULL,buf,buflen)
#define cfput_dupnum(handle,key,len,buf,buflen,itemptr,dupnum) \
cfputx(handle,key,len,itemptr,OKDUPS,dupnum,buf,buflen)
#define cfput_dupname(handle,key,len,buf,buflen,itemptr,dupname) \
cfputx(handle,key,len,itemptr,DUPNAMES,dupname,buf,buflen)
#define cfreput(handle,key,len,buf,buflen,itemptr) \
cfputx(handle,key,len,itemptr,NODUPS,NULL,buf,-buflen)
#define cfreput_dupnum(handle,key,len,buf,buflen,itemptr,dupnum) \
cfputx(handle,key,len,itemptr,OKDUPS,dupnum,buf,-buflen)
#define cfreput_dupname(handle,key,len,buf,buflen,itemptr,dupname) \
cfputx(handle,key,len,itemptr,DUPNAMES,dupname,buf,-buflen)


int cfgetx(void *handle, const void *keyptr, int keylen,
					void *bufptr, long buflen, void *adup);
#define cfget(handle,key,len,buf,buflen) \
cfgetx(handle,key,len,buf,buflen,NULL)
#define cfget_dupnum(handle,key,len,buf,buflen,dupnum) \
cfgetx(handle,key,len,buf,buflen,dupnum)
#define cfget_dupname(handle,dupname,buf,buflen) \
cfgetx(handle,dupname,8,buf,buflen,(void *)0xffffffff)
int cfchdir(char *);
void cfgetcwd(char *cwd, int size);
int cfdozip(void *, int, void *, int, int);
#define cfzip(dst,dsize,src,ssize)\
cfdozip(dst,dsize,src,ssize,0)
#define cfunzip(dst,dsize,src,ssize)\
cfdozip(dst,dsize,src,ssize,-1)


void *malloc(SIZE_T);
void free(void *);
unsigned mallocsize(const void *);

void *calloc(SIZE_T, SIZE_T);
void *realloc(void *, SIZE_T);
void *memalign(unsigned, unsigned);
void *valloc(unsigned);

void *mallocC(long, unsigned);
void *callocC(long, unsigned, unsigned);
void *reallocC(long, void *, unsigned);
void *vallocC(long, unsigned);
void *memalignC(long, unsigned, unsigned);
void freeC(long, void *);
void freecat(long);
void *cfmalloc(unsigned, STOR *);
void cffree(STOR *);
void cfmemrange(long category, unsigned int* min, unsigned int* max);
void cftotrange(unsigned int* min, unsigned int* max);
char *cf_find_file(const char *, char *);
void cf_set_search_path(char *);
char *cf_get_search_path(void);

extern unsigned long _oxlink_trace;
int oxlink_init ();
int oxlink_load_file (const char *);
int oxlink_load_object(const char*);
void * oxlink_find_symb (const char *);
void *oxlink_find_bare_symb (const char *);
void *oxlink_find_func (const char *);
void *oxlink_find_bare_func (const char *);
int oxlink_unload_file (const char *name, int force);
int oxlink_unload_symb (const char *name, int force);
int oxlink_unload_bare_symb (const char *name, int force);
char **oxlink_list_undefined_sym (void);
int oxlink_export_symb(const char *name, unsigned addr);
int oxlink_export_bare_symb(const char *name, unsigned addr);
int oxlink_unexport_symb(const char *);
int oxlink_unexport_bare_symb(const char *);
void oxlink_demand_load(void);
void oxlink_use_library(const char *);
void oxlink_nouse_library(const char *);
void  *oxlink_resolve_symb(int symnum);
void oxlink_trace(int level);
char *oxlink_symname(int symnum);
void *oxlink_rename_symb(const char *old, const char *new);
int oxlink_rename_file(const char *old, const char *new);
void *oxlink_load_symb(const char *symb, int dynlink);
void *oxlink_load_bare_symb(const char *symb, int dynlink);
int oxlink_scan_file(void *fhandle, void *thandle);
void oxlink_load_thunk(int thunknum);
int oxlink_prep_thunk(const char *symb);
void oxlink_clear_bss(const char *filename);
char *oxlink_file_of(const char *symb);
char *oxlink_file_of_bare(const char *symb);
void *oxlink_get_entry_struct(const char *filename);

void oxlink_lib_check(int dynlink);
void oxlink_set_libtype(int type);
void oxlink_set_libnum(int libnum); 
char *oxlink_errstr(void);

int NewMallocCategory();

/* PATTERN MATCH FLAGS */
#define P_LEADING_DOT	(0x1)
#define P_IS_PATH		(0x2)
#define P_PAT_PATH		(0x4)
#define P_USES_ESCAPES	(0x8)
#define P_PCDOS			(0x10)

int pattern_match (const char *pattern, const char *string, int flags);
int check_for_pattern(const char *cp, int flags);

/* CTYPE DEFINITIONS */
   
#ifndef _CTYPE_
#define _CTYPE_

#ifndef offsetof
#define offsetof(type, member) ((unsigned) &((type *)0)->member)
#endif

#define _mU (0x01)
#define _mL (0x02)
#define _mN (0x04)
#define _mX (0x08)
#define _mS (0x10)
#define _mP (0x20)
#define _mC (0x40)
#define _mB (0x80)

extern  unsigned char      cfctype[];
   
#define isalpha(c)  (cfctype[(unsigned char) c]&(_mU|_mL))
#define isupper(c)  (cfctype[(unsigned char) c]&_mU)
#define islower(c)  (cfctype[(unsigned char) c]&_mL)
#define isdigit(c)  (cfctype[(unsigned char) c]&_mN)
#define isxdigit(c) (cfctype[(unsigned char) c]&(_mX|_mN))
#define isspace(c)  (cfctype[(unsigned char) c]&_mS)
#define ispunct(c)  (cfctype[(unsigned char) c]&_mP)
#define isalnum(c)  (cfctype[(unsigned char) c]&(_mU|_mL|_mN))
#define isprint(c)  (cfctype[(unsigned char) c]&(_mP|_mU|_mL|_mN|_mB))
#define isgraph(c)  (cfctype[(unsigned char) c]&(_mP|_mU|_mL|_mN))
#define iscntrl(c)  (cfctype[(unsigned char) c]&_mC)
#define isascii(c)  ((unsigned char)(c)<=(0x7f))

#define toupper(c)  ({unsigned char _c = (unsigned char)(c); islower(_c) ? (_c-32) : _c; })
#define tolower(c)  ({unsigned char _c = (unsigned char)(c); isupper(_c) ? (_c+32) : _c; })
#define toascii(c)  ((c)&(0x7f))

#endif /* _CTYPE_ */

/* COS.H */