#ifndef __GISHLIB__
#define __GISHLIB__
/* if not already included... */
#include <gish.h>

void aputc PROTO((int ch, FILE *fp));
int aprintf VPROTO((FILE *fp, CharPtr fmt, ...));
int awrite PROTO((Nlm_VoidPtr ptr, size_t size, size_t nitems, FILE *fp));

void LIBCALL	LinkPreviousCreate PROTO((VoidPtr lp, size_t nextoff, size_t prevoff));
int LIBCALL	LinkSort PROTO((VoidPtr PNTR list, size_t nextoff, int (LIBCALLBACK *cmpfunc)() ));
int LIBCALL	LinkSort1 PROTO((VoidPtr PNTR list, size_t nextoff, int (LIBCALLBACK *cmpfunc)(), Nlm_VoidPtr onearg));
int LIBCALL	DblLinkSort PROTO((VoidPtr PNTR list, size_t nextoff, size_t prevoff, int (LIBCALLBACK *cmpfunc)() ));
int LIBCALL	LinkApply PROTO((VoidPtr list, size_t nextoff, int (LIBCALLBACK *func)()));
int LIBCALL	LinkApplyData PROTO((VoidPtr list, size_t nextoff, int (LIBCALLBACK *func)(), VoidPtr funcdata));

Link1BlkPtr LIBCALL Link1New PROTO((size_t size));
void LIBCALL Link1Destruct PROTO((Link1BlkPtr));
Link1BlkPtr LIBCALL Link1Append PROTO((Link1BlkPtr lp0, Link1BlkPtr lp1));
size_t LIBCALL Link1Count PROTO((Link1BlkPtr));
Link1BlkPtr LIBCALL Link1Save PROTO((Nlm_VoidPtr buf, size_t buflen));

PoolBlkPtr LIBCALL PoolNew PROTO((size_t nitems, size_t size, size_t nextoff, ValNodePtr));
void LIBCALL	PoolInit PROTO((PoolBlkPtr));
void LIBCALL PoolDestruct PROTO((PoolBlkPtr));
VoidPtr LIBCALL PoolGet PROTO((PoolBlkPtr));
VoidPtr LIBCALL PoolGetClr PROTO((PoolBlkPtr));
void LIBCALL PoolPut PROTO((PoolBlkPtr,VoidPtr));
void LIBCALL PoolPutLink PROTO((PoolBlkPtr,VoidPtr));
int LIBCALL	PoolContains PROTO((PoolBlkPtr,VoidPtr));

CharPtr LIBCALL vstr_cpy PROTO((CharPtr PNTR base, size_t PNTR maxlen, CharPtr dst, CharPtr src));
int LIBCALL vstr_cat PROTO((CharPtr PNTR dst, size_t PNTR maxlen, CharPtr src));

/*
	low-level string and memory manipulators.
	Some of these are patterned after UNIX string and bstring functions.
	(See "man 3 strings" and "man 3 bstring").
*/
CharPtr LIBCALL	str_mov PROTO((CharPtr dst, CharPtr src));
CharPtr LIBCALL	str_nmov PROTO((CharPtr dst, CharPtr src, size_t n));

CharPtr LIBCALL	str_append PROTO((CharPtr dst, CharPtr src));
CharPtr LIBCALL	str_nappend PROTO((CharPtr dst, CharPtr src, size_t n));

int LIBCALL	str_ccmp PROTO((CharPtr s1, CharPtr s2));
int LIBCALL	str_rcmp PROTO((CharPtr s1, CharPtr s2));

size_t LIBCALL str_cnt PROTO((CharPtr s, CharPtr list));

int LIBCALL	str_prefix PROTO((CharPtr s1, CharPtr s2));
int LIBCALL	str_nprefix PROTO((CharPtr s1, CharPtr s2, size_t n));
int LIBCALL	str_ncaseprefix PROTO((CharPtr s1, CharPtr s2, size_t n));

int LIBCALL	str_suffix PROTO((CharPtr s1, CharPtr s2));
int LIBCALL	str_nsuffix PROTO((CharPtr s1, CharPtr s2, size_t n));

CharPtr LIBCALL	str_tail PROTO((CharPtr s));
CharPtr LIBCALL	str_ntail PROTO((CharPtr s, size_t n));

int LIBCALL	str_casecmp PROTO((CharPtr s1, CharPtr s2));
int LIBCALL	str_ncasecmp PROTO((CharPtr s1, CharPtr s2, size_t n));

CharPtr LIBCALL	str_dup PROTO((CharPtr s));

CharPtr LIBCALL	str_chr PROTO((CharPtr s, int c));
CharPtr LIBCALL	str_rchr PROTO((CharPtr s, int c));
CharPtr LIBCALL	str_casechr PROTO((CharPtr s, int c));
CharPtr LIBCALL	str_rcasechr PROTO((CharPtr s, int c));

void LIBCALL	str_tolower PROTO((CharPtr s));
void LIBCALL	str_toupper PROTO((CharPtr s));

/* Find start of substring */
CharPtr LIBCALL	str_str PROTO((CharPtr s1, CharPtr s2));
CharPtr LIBCALL	str_nstr PROTO((CharPtr s1, CharPtr s2, size_t n));

/* Find start of substring, case-independent search */
CharPtr LIBCALL	str_casestr PROTO((CharPtr s1, CharPtr s2));
CharPtr LIBCALL	str_ncasestr PROTO((CharPtr s1, CharPtr s2, size_t n));

CharPtr LIBCALL	str_pbrk PROTO((CharPtr s1, CharPtr s2));

size_t LIBCALL	str_spn PROTO((CharPtr s1, CharPtr s2));
size_t LIBCALL	str_cspn PROTO((CharPtr s1, CharPtr s2));
CharPtr LIBCALL	str_trim PROTO((CharPtr s, CharPtr list));

CharPtr LIBCALL	str_tok PROTO((CharPtr s1, CharPtr s2));
void LIBCALL	str_tr PROTO((CharPtr s, CharPtr to, CharPtr from, int defalt));


VoidPtr LIBCALL mem_malloc PROTO((size_t size));
VoidPtr LIBCALL mem_calloc PROTO((size_t nelem, size_t elsize));
VoidPtr LIBCALL mem_realloc PROTO((Nlm_VoidPtr oldptr, size_t newsize));
void LIBCALL mem_free PROTO((Nlm_VoidPtr));
int LIBCALL	mem_rcmp PROTO((Nlm_VoidPtr p1, Nlm_VoidPtr p2, size_t len));
Nlm_VoidPtr LIBCALL	mem_ccpy PROTO((Nlm_VoidPtr dst, Nlm_VoidPtr src, int c, size_t len));
Nlm_VoidPtr LIBCALL	mem_dup PROTO((Nlm_VoidPtr b, size_t n));
/* Find start of p in b */
Nlm_VoidPtr LIBCALL	mem_index PROTO((Nlm_VoidPtr b, size_t blen, Nlm_VoidPtr p, size_t plen));

/* Miscellaneous functions */
CharPtr LIBCALL	d2s PROTO((double x));
CharPtr LIBCALL	misc_basename PROTO((CharPtr fname, CharPtr extension));
CharPtr LIBCALL	dirname PROTO((CharPtr fname));
CharPtr LIBCALL	vfgets PROTO((CharPtr PNTR base, size_t PNTR basemax, CharPtr PNTR bp, FILE *fp));
CharPtr LIBCALL xfgets PROTO((CharPtr xltab, CharPtr buf, size_t buflen, CharPtr PNTR bpend, FILE *fp));
CharPtr LIBCALL vxfgets PROTO((CharPtr xltab, CharPtr PNTR base, size_t PNTR basemax, CharPtr PNTR bp, CharPtr PNTR bpend, FILE *fp));
int LIBCALL		wrap PROTO((FILE *fp, CharPtr title, CharPtr s, int slen, int linelen, int indent));
int LIBCALL	getedit PROTO((FILE *fp, CharPtr buf, int buflen, int *nlines));

extern int	opterr, optind, optopt; /* feelers into getopt() */
extern char	*optarg;
int LIBCALL		getopt PROTO((int nargc, char *const *nargv, const char *ostr));
void LIBCALL	fatal VPROTO((int err, CharPtr format, ...));
FILE *openfile PROTO((char *fname, char *mode));
int LIBCALL	getfasta PROTO((UcharPtr xltab, CharPtr PNTR name, size_t PNTR namemax, size_t PNTR namelen, UcharPtr PNTR buf0, size_t PNTR bufmax, size_t PNTR seqlen, FILE *fp));
int LIBCALL	putfasta PROTO((CharPtr xltab, CharPtr prefix, size_t prefixlen, CharPtr name, size_t namelen, UcharPtr seq, size_t seqlen, FILE *fp));

int LIBCALL	SameFd PROTO((int,int));
int LIBCALL	SameFp PROTO((FILE *,FILE *));
long LIBCALL	swap_long PROTO((long));
short LIBCALL	swap_short PROTO((int));

TaskBlkPtr LIBCALL	TaskNew PROTO((long, Nlm_VoidPtr, void (LIBCALLBACK *)(), long));
TaskBlkPtr LIBCALL	TaskLink PROTO((TaskBlkPtr tp, unsigned id));
void LIBCALL	TaskInit PROTO((TaskBlkPtr tp, int nchunks));
void LIBCALL	TaskUnlink PROTO((TaskBlkPtr));
long LIBCALL	TaskNext PROTO((TaskBlkPtr));
void LIBCALL	TaskPosIncr PROTO((TaskBlkPtr));
unsigned long LIBCALL	TaskPosSum PROTO((TaskBlkPtr));
void LIBCALL	TaskDestruct PROTO((TaskBlkPtr));
void LIBCALL	TaskTickNext PROTO((TaskBlkPtr,long));

#ifdef MPROC_AVAIL
void LIBCALL	mproc_lock PROTO((void));
void LIBCALL	mproc_unlock PROTO((void));
void LIBCALL	mproc_sync PROTO((TaskBlkPtr));
#endif
int LIBCALL	mproc_next PROTO((TaskBlkPtr));
TaskBlkPtr LIBCALL run_wild PROTO((unsigned long,void (LIBCALLBACK *)(),Nlm_VoidPtr,TaskBlkPtr PNTR,void (LIBCALLBACK *)(),unsigned long,int,int PNTR,void (LIBCALLBACK *)() ));
TaskBlkPtr LIBCALL mrun_wild PROTO((unsigned long,void (LIBCALLBACK *)(),Nlm_VoidPtr,TaskBlkPtr PNTR,void (LIBCALLBACK *)(),unsigned long,int,int PNTR,void (LIBCALLBACK *)() ));


/* shared memory and other interprocess comm. */
int shmexists();
shm_dat	PNTR shm_attfile PROTO((CharPtr filename, CharPtr mode, int verbose));
key_t	shm_mkkey PROTO((CharPtr filename));
VoidPtr	shm_addr PROTO((shm_dat PNTR));
shm_dat	PNTR shm_loadfile PROTO((CharPtr filename, int mmode, int smode, int qmode, int lockfile, int verbose));
int	shm_detach PROTO((CharPtr));
int	shm_sendto PROTO((CharPtr filename, int sig));
int	shm_sendtokey PROTO((key_t key, int sig));

#ifndef mfil_open
MFILE PNTR mfil_open PROTO((CharPtr name, CharPtr mode, int flags));
int LIBCALL mfil_inmemory PROTO((MFILE PNTR mfp));
long int LIBCALL mfil_tell PROTO((MFILE PNTR mfp));
int LIBCALL mfil_seek PROTO((MFILE PNTR mfp,long offset,int ptrname));
int LIBCALL mfil_read PROTO((CharPtr buf,size_t size,size_t nitems,MFILE PNTR mfp));
int LIBCALL mfil_write PROTO((CharPtr buf,size_t size,size_t nitems,MFILE PNTR mfp));
int LIBCALL mfil_close PROTO((MFILE PNTR mfp));
int LIBCALL mfil_unlock PROTO((MFILE PNTR mfp));
int LIBCALL mfil_eof PROTO((MFILE PNTR mfp));
CharPtr LIBCALL mfil_gets PROTO((CharPtr buf, size_t buflen, MFILE *mfp));
CharPtr LIBCALL mfil_vgets PROTO((CharPtr PNTR base, size_t PNTR basemax, CharPtr PNTR bp, MFILE *mfp));
int LIBCALL mfil_getc PROTO((MFILE *));
int LIBCALL mfil_ungetc PROTO((int ch, MFILE *));
int LIBCALL mfil_flush PROTO((MFILE *));
void LIBCALL mfil_rewind PROTO((MFILE *));
CharPtr LIBCALL mfil_vgetsend PROTO((CharPtr PNTR base,size_t PNTR basemax,CharPtr PNTR bp,CharPtr PNTR bpend,MFILE *mfp));
CharPtr LIBCALL mfil_vxgets PROTO((CharPtr xltab,CharPtr PNTR base,size_t PNTR basemax,CharPtr PNTR bp,CharPtr PNTR bpend,MFILE *mfp));
int LIBCALL mfil_getfasta PROTO((UcharPtr xltab, CharPtr PNTR name, size_t PNTR namemax, size_t PNTR namelen, UcharPtr PNTR buf0, size_t PNTR bufmax, size_t PNTR seqlen, MFILE *fp));
#endif
MFILE PNTR mfil_link PROTO((MFILE *mfp, CharPtr fname, CharPtr mode));
int LIBCALL mfil_maplen PROTO((int newlen));
CharPtr LIBCALL mfil_get PROTO((MFILE PNTR mfp, size_t len));
void LIBCALL mfil_prefetch PROTO((MFILE PNTR mfp));
long PNTR LIBCALL mfil_get_long PROTO((MFILE PNTR mfp, size_t nelem));
size_t LIBCALL mfil_dup_long PROTO((MFILE PNTR mfp,long PNTR i,size_t nelem));
size_t LIBCALL mfil_put_long PROTO((MFILE PNTR mfp, long PNTR i, size_t nelem));


/* System level functions */
long LIBCALL sys_filesize PROTO((CharPtr fname));
int LIBCALL sys_lockfile PROTO((int fd,int cmd,int type,off_t offset,int whence,off_t len));
void LIBCALL sys_times PROTO((Cputime_t PNTR t));
void LIBCALL sys_strtime PROTO((CharPtr buf, Cputime_t PNTR t0, Cputime_t PNTR t1));
void LIBCALL		sys_showtime PROTO((CharPtr str, Cputime_t PNTR t0, Cputime_t PNTR t1, FILE *fp));
CharPtr LIBCALL	sys_whoami PROTO((void));
int LIBCALL sys_sigsetmask PROTO((int how, sigset_t *mask, sigset_t *omask));
void (*sys_signal PROTO((int sig, void(*disp)(int)))) PROTO((int));
void LIBCALL sys_sigpurge PROTO((int signo));

/* Random number generator */
void LIBCALL		rnd_seed PROTO((long seed));
long LIBCALL		rnd_gen PROTO((void));

/* Heap sort */
#ifndef hsort
void LIBCALL	hsort PROTO((Nlm_VoidPtr base, size_t nel, size_t width, int (LIBCALLBACK *) (Nlm_VoidPtr,Nlm_VoidPtr)));
#endif
void LIBCALL	hsort1 PROTO((Nlm_VoidPtr base, size_t nel, size_t width, int (LIBCALLBACK *) (Nlm_VoidPtr,Nlm_VoidPtr,Nlm_VoidPtr), Nlm_VoidPtr onearg));

/* AVL trees */
VoidPtr LIBCALL	(*avl_setalloc PROTO((VoidPtr (*)())))();
void LIBCALL	(*avl_setfree PROTO((void (*)())))();
void LIBCALL	avl_init PROTO((avl_tree **tree));
VoidPtr LIBCALL	avl_srch PROTO((avl_tree **tree, FnPtr compar, VoidPtr key));
void LIBCALL	avl_add PROTO((avl_tree **tree, FnPtr compar, VoidPtr key, void (*delet)()));
int LIBCALL	avl_delete PROTO((avl_tree **tree, FnPtr compar, VoidPtr key, void (*delet)()));
int LIBCALL	avl_trav PROTO((avl_tree **tree, FnPtr trav));

/* Numerical functions */
double LIBCALL	fct_powi PROTO((double x, int power));	/* Integral powers of x */
double LIBCALL	fct_ilog PROTO((double x)); /* nearest integer log */
long LIBCALL	fct_gcd PROTO((long a, long b)); /* Greatest Common Divisor */
long LIBCALL	fct_nint PROTO((double x));	/* Round to nearest long integer */
double LIBCALL	fct_factorial PROTO((long n));	/* n! */
double LIBCALL	fct_ntakek PROTO((unsigned long n, unsigned long k));
double LIBCALL	fct_gammln PROTO((double x)); /* ln[gamma(x)] */
double LIBCALL	fct_gamma PROTO((double x)); /* ln[gamma(x)] */
double LIBCALL	fct_expm1 PROTO((double x)); /* accurate exp(x)-1 for all x */
double LIBCALL	fct_log1p PROTO((double x)); /* accurate log(1+x) for valid x */
double LIBCALL	fct_dbl_min PROTO((void)); /* min. value for a double */
float LIBCALL	fct_flt_min PROTO((void)); /* min. value for a float */

	/* Bisection & Newton-Raphson root finder */
double LIBCALL	fct_bisnr PROTO((double, double (PNTR)(), double (PNTR)(), double, double, double, double));

	/* System-dependent functions */

void LIBCALL critical_begin PROTO((void));
void LIBCALL critical_end PROTO((void));

int LIBCALL	sys_usleep PROTO((unsigned long u_sec));

int LIBCALL AlarmSet PROTO((AlarmBlkPtr PNTR abpp, time_t when, FnPtr func, VoidPtr arg));
int LIBCALL AlarmEvery PROTO((AlarmBlkPtr PNTR abpp, time_t period, FnPtr func, VoidPtr arg));
long LIBCALL AlarmWhen PROTO((void));
void LIBCALL AlarmReset PROTO((AlarmBlkPtr,time_t));
void LIBCALL AlarmClr PROTO((AlarmBlkPtr));
void LIBCALL AlarmClrAll PROTO((void));


PatTreePtr	PatTreeNew PROTO((Nlm_VoidPtr (*keyfunc)(Nlm_VoidPtr), VoidPtr firstkey));
int			PatTreeInit PROTO((PatTreePtr ptp, Nlm_VoidPtr (*keyfunc)(Nlm_VoidPtr), VoidPtr firstkey));
void		PatTreeReinit PROTO((PatTreePtr ptp));
void		PatTreeFree PROTO((PatTreePtr));
void		PatTreeDestruct PROTO((PatTreePtr));
PatNodePtr	PatNodeNew PROTO((PatTreePtr));
PatNodePtr	PatFindNode PROTO((PatTreePtr ptp, VoidPtr key));
PatNodePtr	PatFindNodeLen PROTO((PatTreePtr ptp, VoidPtr key, size_t keylen));
PatNodePtr	PatFindNodeCmp PROTO((PatTreePtr ptp, VoidPtr key, size_t keylen));
PatNodePtr	PatInsertLen PROTO((PatTreePtr ptp, VoidPtr key, size_t keylen));
PatNodePtr	PatInsert PROTO((PatTreePtr ptp, VoidPtr key));
PatNodePtr	PatInsertNode PROTO((PatTreePtr ptp, PatNodePtr node, VoidPtr key));
int LIBCALL	PatNodeFollow PROTO((PatNodePtr node, size_t bits, int (*userfunc)(), Nlm_VoidPtr userdata));

#ifdef _ASNTOOL_ /* extensions to NCBI Core Library's Asn functions */
Boolean LIBCALL AsnBufWrite PROTO((AsnIoPtr,AsnTypePtr,CharPtr,size_t));
Boolean LIBCALL AsnBinBufWrite PROTO((AsnIoPtr,AsnTypePtr,CharPtr,size_t));
Boolean LIBCALL AsnTxtBufWrite PROTO((AsnIoPtr,AsnTypePtr,CharPtr,size_t));
#endif /* _ASNTOOL_ */

#endif /* !__GISHLIB__ */