text: /* xlisp - a small subset of lisp */
  /*	Copyright (c) 1985, by David Michael Betz
          All Rights Reserved
          Permission is granted for unrestricted non-commercial use
  
  HISTORY
  28-Apr-03   Mazzoni
                  Added declarations for path.c (new file)
  30-Mar-88	Dale Amon CMU-CSD
                  Set it up for unix. Picked _TURBOC_  because defs
                  are reasonable.
  */
  
  /* system specific definitions */
  
  #ifndef __XLISP__
  #define __XLISP__
  
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  #include <stdlib.h> /* needed for getenv(); note that this was a problem
      for PMAX implementation, but I assume PMAX is obsolete now. 
      - RBD 16apr04 */
  #include <stdio.h>
  #include <ctype.h>
  #include <setjmp.h>
  
  /* NNODES	number of nodes to allocate in each request (1000) */
  /* EDEPTH	evaluation stack depth (2000) */
  /* ADEPTH	argument stack depth (1000) */
  /* FORWARD	type of a forward declaration () */
  /* LOCAL	type of a local function (static) */
  /* AFMT		printf format for addresses ("%x") */
  /* FIXTYPE	data type for fixed point numbers (long) */
  /* ITYPE	fixed point input conversion routine type (long atol()) */
  /* ICNV		fixed point input conversion routine (atol) */
  /* IFMT		printf format for fixed point numbers ("%ld") */
  /* FLOTYPE	data type for floating point numbers (float) */
  /* OFFTYPE	number the size of an address (int) */
  
  /* for the Win32 environment */
  #ifdef WIN32
  #define NNODES		2000
  #define AFMT		"%p"
  // TRY 64bit-ints throughout XLisp even on 32-bit Windows
  // #ifdef _WIN64
  #define OFFTYPE     long long
  #define FIXTYPE     long long
  #define IFMT        "%lld"
  #define ICNV(n)     atoll(n)
  // #else
  // #define OFFTYPE		long
  // #define IFMT        "%ld"
  // #endif
  /* #define SAVERESTORE */
  #define XL_LITTLE_ENDIAN 
  #define _longjmp longjmp
  #define _setjmp setjmp
  #endif
  
  /* for the Turbo C compiler - MS-DOS, large model */
  #ifdef _TURBOC_
  #define NNODES		2000
  #define AFMT		"%lx"
  #define OFFTYPE		long
  /* #define SAVERESTORE */
  #define XL_LITTLE_ENDIAN
  #endif
  
  /* for the AZTEC C compiler - MS-DOS, large model */
  #ifdef AZTEC_LM
  #define NNODES		2000
  #define AFMT		"%lx"
  #define OFFTYPE		long
  #define CVPTR(x)	ptrtoabs(x)
  #define NIL		(void *)0
  extern long ptrtoabs();
  /* #define SAVERESTORE */
  #define XL_LITTLE_ENDIAN
  #endif
  
  /* for the AZTEC C compiler - Macintosh */
  #ifdef AZTEC_MAC
  #define NNODES		2000
  #define AFMT		"%lx"
  #define OFFTYPE		long
  #define NIL		(void *)0
  #define SAVERESTORE
  #define XL_BIG_ENDIAN
  #endif
  
  /* for the AZTEC C compiler - Amiga */
  #ifdef AZTEC_AMIGA
  #define NNODES		2000
  #define AFMT		"%lx"
  #define OFFTYPE		long
  #define NIL		(void *)0
  #define SAVERESTORE
  #define XL_BIG_ENDIAN
  #endif
  
  /* for the Lightspeed C compiler - Macintosh */
  #ifdef LSC
  #define NNODES		2000
  #define AFMT		"%lx"
  #define OFFTYPE		long
  #define NIL		(void *)0
  #define SAVERESTORE
  #define XL_BIG_ENDIAN
  #endif
  
  /* for the Microsoft C compiler - MS-DOS, large model */
  #ifdef MSC
  #define NNODES		2000
  #define AFMT		"%lx"
  #define OFFTYPE		long
  #define XL_LITTLE_ENDIAN
  #endif
  
  /* for the Mark Williams C compiler - Atari ST */
  #ifdef MWC
  #define AFMT		"%lx"
  #define OFFTYPE		long
  #define XL_BIG_ENDIAN
  #endif
  
  /* for the Lattice C compiler - Atari ST */
  #ifdef LATTICE
  #define FIXTYPE		int
  #define ITYPE		int atoi()
  #define ICNV(n)		atoi(n)
  #define IFMT		"%d"
  #define XL_BIG_ENDIAN
  #endif
  
  /* for the Digital Research C compiler - Atari ST */
  #ifdef DR
  #define LOCAL
  #define AFMT		"%lx"
  #define OFFTYPE		long
  #undef NULL
  #define NULL		0L
  #define XL_BIG_ENDIAN
  #endif
  
  /* Mac Metrowerks CW 6 */
  #ifdef __MWERKS__
  #define LSC
  #undef PATHNAMES
  #undef FILETABLE
  #undef SAVERESTORE
  #undef MEDMEM
  #define EDEPTH 4000
  #define ADEPTH 3000
  #define OSAOPEN osaopen
  #define OSBOPEN osbopen
  #define NO_EXTENSIONS  /* don't add ".lsp" onto filenames */
  #define XL_BIG_ENDIAN
  #endif
  
  /* Linux on Pentium */
  #if defined(__linux__) || defined(__GLIBC__) || defined(__CYGWIN__)
  #define AFMT            "%p"
  #include <inttypes.h>
  #include <endian.h>
  #if __BYTE_ORDER == __LITTLE_ENDIAN
  #define XL_LITTLE_ENDIAN
  #else
  #define XL_BIG_ENDIAN
  #endif
  #endif
  
  /* Apple CC (xcode, macOS, macintosh) */
  #ifdef __APPLE__
  #define NNODES 2000
  #define AFMT "%p"
  #define OFFTYPE long
  #define NIL (void *)0
  /* #define SAVERESTORE */
  #include <sys/types.h>
  /* #if __BYTE_ORDER == __LITTLE_ENDIAN */
  #if defined(__LITTLE_ENDIAN__)
  #define XL_LITTLE_ENDIAN
  #else
  #define XL_BIG_ENDIAN
  #endif
  #endif
  
  /* default important definitions */
  #ifndef NNODES
  #define NNODES		1000
  #endif
  #ifndef NTYPES
  #define NTYPES		20
  #endif
  #ifndef EDEPTH
  /* originally was 2000 */
  #define EDEPTH		4000
  #endif
  #ifndef ADEPTH
  /* originally was 1000 */
  #define ADEPTH		2000
  #endif
  #ifndef FORWARD
  #define FORWARD
  #endif
  #ifndef LOCAL
  #define LOCAL		static
  #endif
  #ifndef AFMT
  #define AFMT		"%lx"
  #endif
  #ifndef FIXTYPE
  #define FIXTYPE		long
  #endif
  #ifndef ITYPE
  #ifndef atol  /* if atol is a macro, this will mess things up */
  #define ITYPE		long atol()
  #endif
  #endif
  #ifndef ICNV
  #define ICNV(n)		atol(n)
  #endif
  #ifndef IFMT
  #define IFMT		"%ld"
  #endif
  #ifndef FLOTYPE
  #define FLOTYPE		double
  #endif
  #ifndef OFFTYPE
  #define OFFTYPE		int
  #endif
  #ifndef CVPTR
  #define CVPTR(x)	(x)
  #endif
  #ifndef UCHAR
  #define UCHAR		unsigned char
  #endif
  
  #ifndef STDERR
  #define STDERR stderr
  #endif
  
  /* useful definitions */
  #ifndef TRUE
  #define TRUE	1
  #define FALSE	0
  #endif
  #define externp(x) ((x) && ntype(x) == EXTERN)
  #ifndef NIL
  #define NIL	(LVAL )0
  #endif
  
  /* include the dynamic memory definitions */
  #include "xldmem.h"
  
  /* program limits */
  #define STRMAX		250		/* maximum length of a string constant */
  /* this was 100 -- I had a perfectly good full path to init.lsp using
     a directory structure created by Apple's Xcode that was about 108
     characters, so I picked a bigger value. -RBD */
  
  #define HSIZE		1499		/* symbol hash table size */
  #define SAMPLE		50000		/* control character sample rate */
  /* Jul 2014: Under Xcode, debug, 2.4 GHz Intel Core i7: oscheck rate is
     about 66Hz */
  
  /* function table offsets for the initialization functions */
  #define FT_RMHASH	0
  #define FT_RMQUOTE	1
  #define FT_RMDQUOTE	2
  #define FT_RMBQUOTE	3
  #define FT_RMCOMMA	4
  #define FT_RMLPAR	5
  #define FT_RMRPAR	6
  #define FT_RMSEMI	7
  #define FT_CLNEW	10
  #define FT_CLISNEW	11
  #define FT_CLANSWER	12
  #define FT_OBISNEW	13
  #define FT_OBCLASS	14
  #define FT_OBSHOW	15
  #define FT_OBISA        16
          
  /* macro to push a value onto the argument stack */
  #define pusharg(x)	{if (xlsp >= xlargstktop) xlargstkoverflow();\
                           *xlsp++ = (x);}
  
  /* #define DEBUG_GC */
  
  /* macros to protect pointers */
  #ifdef DEBUG_GC
  void dbg_gc_xlsave(LVAL *n);
  
  #define xlstkcheck(n)	{if (xlstack - (n) < xlstkbase) xlstkoverflow();}
  #define xlsave(n)	{*--xlstack = &n; n = NIL; dbg_gc_xlsave(&n);}
  #define xlprotect(n)	{*--xlstack = &n; dbg_gc_xlsave(&n);}
  
  /* check the stack and protect a single pointer */
  #define xlsave1(n)	{if (xlstack <= xlstkbase) xlstkoverflow();\
                           *--xlstack = &n; n = NIL; dbg_gc_xlsave(&n);}
  #define xlprot1(n)	{if (xlstack <= xlstkbase) xlstkoverflow();\
                           *--xlstack = &n; dbg_gc_xlsave(&n);}
  
  /* macros to pop pointers off the stack */
  #define xlpop()		{++xlstack;}
  #define xlpopn(n)	{xlstack+=(n);}
  
  #else
  
  #define xlstkcheck(n)	{if (xlstack - (n) < xlstkbase) xlstkoverflow();}
  #define xlsave(n)	{*--xlstack = &n; n = NIL;}
  #define xlprotect(n)	{*--xlstack = &n;}
  
  /* check the stack and protect a single pointer */
  #define xlsave1(n)	{if (xlstack <= xlstkbase) xlstkoverflow();\
                           *--xlstack = &n; n = NIL;}
  #define xlprot1(n)	{if (xlstack <= xlstkbase) xlstkoverflow();\
                           *--xlstack = &n;}
  
  /* macros to pop pointers off the stack */
  #define xlpop()		{++xlstack;}
  #define xlpopn(n)	{xlstack+=(n);}
  #endif
  
  /* macros to manipulate the lexical environment */
  #define xlframe(e)	cons(NIL,e)
  #define xlbind(s,v)	xlpbind(s,v,xlenv)
  #define xlfbind(s,v)	xlpbind(s,v,xlfenv);
  #define xlpbind(s,v,e)	{rplaca(e,cons(cons(s,v),car(e)));}
  
  /* macros to manipulate the dynamic environment */
  #define xldbind(s,v)	{xldenv = cons(cons(s,getvalue(s)),xldenv);\
                           setvalue(s,v);}
  #define xlunbind(e)	{for (; xldenv != (e); xldenv = cdr(xldenv))\
                             setvalue(car(car(xldenv)),cdr(car(xldenv)));}
  
  /* type predicates */			       
  #define atomp(x)		((x) == NIL || ntype(x) != CONS)
  #define null(x)		((x) == NIL)
  #define listp(x)	((x) == NIL || ntype(x) == CONS)
  #define consp(x)	((x) && ntype(x) == CONS)
  #define subrp(x)	((x) && ntype(x) == SUBR)
  #define fsubrp(x)	((x) && ntype(x) == FSUBR)
  #define stringp(x)	((x) && ntype(x) == STRING)
  #define symbolp(x)	((x) && ntype(x) == SYMBOL)
  #define streamp(x)	((x) && ntype(x) == STREAM)
  #define objectp(x)	((x) && ntype(x) == OBJECT)
  #define fixp(x)		((x) && ntype(x) == FIXNUM)
  #define floatp(x)	((x) && ntype(x) == FLONUM)
  #define vectorp(x)	((x) && ntype(x) == VECTOR)
  #define closurep(x)	((x) && ntype(x) == CLOSURE)
  #define charp(x)	((x) && ntype(x) == CHAR)
  #define ustreamp(x)	((x) && ntype(x) == USTREAM)
  #define boundp(x)	(getvalue(x) != s_unbound)
  #define fboundp(x)	(getfunction(x) != s_unbound)
  
  /* shorthand functions */
  #define consa(x)	cons(x,NIL)
  #define consd(x)	cons(NIL,x)
  
  /* argument list parsing macros */
  #define xlgetarg()	(testarg(nextarg()))
  #define xllastarg()	{if (xlargc != 0) xltoomany();}
  #define testarg(e)	(moreargs() ? (e) : xltoofew())
  #define typearg(tp)	(tp(*xlargv) ? nextarg() : xlbadtype(*xlargv))
  #define nextarg()	(--xlargc, *xlargv++)
  #define moreargs()	(xlargc > 0)
  
  /* macros to get arguments of a particular type */
  #define xlgacons()	(testarg(typearg(consp)))
  #define xlgalist()	(testarg(typearg(listp)))
  #define xlgasymbol()	(testarg(typearg(symbolp)))
  #define xlgastring()	(testarg(typearg(stringp)))
  #define xlgaobject()	(testarg(typearg(objectp)))
  #define xlgafixnum()	(testarg(typearg(fixp)))
  #define xlgaflonum()	(testarg(typearg(floatp)))
  #define xlgachar()	(testarg(typearg(charp)))
  #define xlgavector()	(testarg(typearg(vectorp)))
  #define xlgastream()	(testarg(typearg(streamp)))
  #define xlgaustream()	(testarg(typearg(ustreamp)))
  #define xlgaclosure()	(testarg(typearg(closurep)))
  
  /* function definition structure */
  typedef struct {
      const char *fd_name;	/* function name */
      int fd_type;	/* function type */
      LVAL (*fd_subr)(void);	/* function entry point */
  } FUNDEF;
  
  /* execution context flags */
  #define CF_GO		0x0001
  #define CF_RETURN	0x0002
  #define CF_THROW	0x0004
  #define CF_ERROR	0x0008
  #define CF_CLEANUP	0x0010
  #define CF_CONTINUE	0x0020
  #define CF_TOPLEVEL	0x0040
  #define CF_BRKLEVEL	0x0080
  #define CF_UNWIND	0x0100
  
  
  /* execution context */
  typedef struct context {
      int c_flags;			/* context type flags */
      LVAL c_expr;			/* expression (type dependant) */
      jmp_buf c_jmpbuf;			/* _longjmp context */
      struct context *c_xlcontext;	/* old value of xlcontext */
      LVAL **c_xlstack;			/* old value of xlstack */
      LVAL *c_xlargv;			/* old value of xlargv */
      int c_xlargc;			/* old value of xlargc */
      LVAL *c_xlfp;			/* old value of xlfp */
      LVAL *c_xlsp;			/* old value of xlsp */
      LVAL c_xlenv;			/* old value of xlenv */
      LVAL c_xlfenv;			/* old value of xlfenv */
      LVAL c_xldenv;			/* old value of xldenv */
  } XLCONTEXT;
  
  /* external variables */
  extern LVAL **xlstktop;       	/* top of the evaluation stack */
  extern LVAL **xlstkbase;	/* base of the evaluation stack */
  extern LVAL **xlstack;		/* evaluation stack pointer */
  extern LVAL *xlargstkbase;	/* base of the argument stack */
  extern LVAL *xlargstktop;	/* top of the argument stack */
  extern LVAL *xlfp;		/* argument frame pointer */
  extern LVAL *xlsp;		/* argument stack pointer */
  extern LVAL *xlargv;		/* current argument vector */
  extern int xlargc;		/* current argument count */
  
  /* more external variables */
  extern LVAL xlenv,xlfenv,xldenv,xlvalue,s_true;
  extern LVAL lk_optional,lk_rest,lk_key,lk_aux,lk_allow_other_keys;
  extern LVAL s_evalhook,s_applyhook,s_tracelist;
  extern LVAL s_lambda,s_macro;
  extern LVAL s_unbound;
  extern int xlsample;
  extern char buf[];
  extern LVAL obarray,s_gcflag,s_gchook;
  extern int xldebug;
  extern LVAL s_debugio;
  extern LVAL s_tracenable,s_tlimit,s_breakenable;
  extern LVAL s_loadingfiles;
  extern LVAL k_direction,k_input,k_output;
  extern LVAL s_stdin,s_stdout;
  extern int xlfsize;
  /* external variables */
  extern LVAL s_car,s_cdr,s_nth,s_get,s_svalue,s_splist,s_aref;
  extern LVAL s_comma,s_comat;
  extern char gsprefix[];
  extern int gsnumber;
  
  
  /* additional prototypes */
  
  extern FILE *osaopen (const char *name, const char *mode);
  extern FILE *osbopen (const char *name, const char *mode);
  
  #ifdef __MWERKS__
  /* macfun.c */
  
  LVAL xptsize(void);
  LVAL xhidepen(void);
  LVAL xshowpen(void);
  LVAL xgetpen(void);
  LVAL xpenmode(void);
  LVAL xpensize(void);
  LVAL xpenpat(void);
  LVAL xpennormal(void);
  LVAL xmoveto(void);
  LVAL xmove(void);
  LVAL xdrawto(void);
  LVAL xdraw(void);
  LVAL xshowgraphics(void);
  LVAL xhidegraphics(void);
  LVAL xcleargraphics(void);
  LVAL xtool(void);
  LVAL xtool16(void);
  LVAL xtool32(void);
  LVAL xnewhandle(void);
  LVAL xnewptr(void);
  LVAL xhiword(void);
  LVAL xloword(void);
  LVAL xrdnohang(void);
  /* #include "macstuff.h" */
  #endif
  
  /* for extern.c */
  
  void inval_caches(void);
  
  
  /* for xlbfun.c */
  
  LVAL xeval(void);
  LVAL xapply(void);
  LVAL xfuncall(void);
  LVAL xmacroexpand(void);
  LVAL x1macroexpand(void);
  LVAL xatom(void);
  LVAL xsymbolp(void);
  LVAL xnumberp(void);
  LVAL xintegerp(void);
  LVAL xfloatp(void);
  LVAL xcharp(void);
  LVAL xstringp(void);
  LVAL xarrayp(void);
  LVAL xstreamp(void);
  LVAL xobjectp(void);
  LVAL xboundp(void);
  LVAL xfboundp(void);
  LVAL xnull(void);
  LVAL xlistp(void);
  LVAL xendp(void);
  LVAL xconsp(void);
  LVAL xeq(void);
  LVAL xeql(void);
  LVAL xequal(void);
  LVAL xset(void);
  LVAL xgensym(void);
  LVAL xmakesymbol(void);
  LVAL xintern(void);
  LVAL xsymname(void);
  LVAL xsymvalue(void);
  LVAL xsymfunction(void);
  LVAL xsymplist(void);
  LVAL xget(void);
  LVAL xputprop(void);
  LVAL xremprop(void);
  LVAL xhash(void);
  LVAL xaref(void);
  LVAL xmkarray(void);
  LVAL xvector(void);
  LVAL xerror(void);
  LVAL xcerror(void);
  LVAL xbreak(void);
  LVAL xcleanup(void);
  LVAL xtoplevel(void);
  LVAL xcontinue(void);
  LVAL xevalhook(void);
  
  
  /* xlcont.c */
  
  LVAL xquote(void);
  LVAL xfunction(void);
  LVAL xbquote(void);
  LVAL xlambda(void);
  LVAL xgetlambda(void);
  LVAL xsetq(void);
  LVAL xpsetq(void);
  LVAL xsetf(void);
  LVAL xdefun(void);
  LVAL xdefmacro(void);
  LVAL xcond(void);
  LVAL xwhen(void);
  LVAL xunless(void);
  LVAL xcase(void);
  LVAL xand(void);
  LVAL x_or(void); // xor causes problems for gcc, so I renamed it. -RBD
  LVAL xif(void);
  LVAL xlet(void);
  LVAL xletstar(void);
  LVAL xflet(void);
  LVAL xlabels(void);
  LVAL xmacrolet(void);
  LVAL xprog(void);
  LVAL xprogstar(void);
  LVAL xgo(void);
  LVAL xreturn(void);
  LVAL xrtnfrom(void);
  LVAL xprog1(void);
  LVAL xprog2(void);
  LVAL xprogn(void);
  LVAL xprogv(void);
  LVAL xloop(void);
  LVAL xdo(void);
  LVAL xdostar(void);
  LVAL xdolist(void);
  LVAL xdotimes(void);
  LVAL xblock(void);
  LVAL xtagbody(void);
  LVAL xcatch(void);
  LVAL xthrow(void);
  LVAL xunwindprotect(void);
  LVAL xerrset(void);
  LVAL xtrace(void);
  LVAL xuntrace(void);
  
  
  /* xldbug.c */
  
  void xlabort(const char *emsg);
  void xlbreak(const char *emsg, LVAL arg);
  void xlfail(const char *emsg);
  void xlerror(const char *emsg, LVAL arg);
  void xlcerror(const char *cmsg, const char *emsg, LVAL arg);
  void xlerrprint(const char *hdr, const char *cmsg, const char *emsg, LVAL arg);
  void xlbaktrace(int n);
  void xldinit(void);
  void close_loadingfiles(void);
  
  /* xldmem.c */
  extern long total; /* total bytes allocated by xlisp */
  
  LVAL cons(LVAL x, LVAL y);
  LVAL cvstring(const char *str);
  LVAL new_string(int size);
  LVAL cvsymbol(const char *pname);
  LVAL cvsubr(LVAL (*fcn)(void), int type, int offset);
  LVAL cvfile(FILE *fp);
  LVAL cvfixnum(FIXTYPE n);
  LVAL cvflonum(FLOTYPE n);
  LVAL cvchar(int n);
  LVAL newustream(void);
  LVAL newobject(LVAL cls, int size);
  LVAL newclosure(LVAL name, LVAL type, LVAL env, LVAL fenv);
  LVAL newvector(int size);
  void gc(void);
  SEGMENT *newsegment(int n);
  LVAL xgc(void);
  LVAL xexpand(void);
  LVAL xalloc(void);
  LVAL xmem(void);
  LVAL xsave(void);
  LVAL xrestore(void);
  void xlminit(void);
  LVAL cvextern(xtype_desc typeptr, unsigned char *instptr);		/* convert an external type */
  LVAL newnode(int type);
  void mark(LVAL ptr);
  
  
  /* xleval.c */
  
  LVAL xleval(LVAL expr);
  LVAL xlxeval(LVAL expr);
  LVAL xlapply(int argc);
  LVAL xlexpandmacros(LVAL form);
  int macroexpand(LVAL fun, LVAL args, LVAL *pval);
  int pushargs(LVAL fun, LVAL args);
  LVAL makearglist(int argc, LVAL *argv);
  LVAL xlclose(LVAL name, LVAL type, LVAL fargs, LVAL body, LVAL env, LVAL fenv);
  void xlabind(LVAL fun, int argc, LVAL *argv);
  void xlunbound(LVAL sym);
  void xlfunbound(LVAL sym);
  void xlstkoverflow(void);
  void xlargstkoverflow(void);
  
  
  /* xlfio.c */
  
  LVAL xread(void);
  LVAL xprint(void);
  LVAL xprin1(void);
  LVAL xprinc(void);
  LVAL xterpri(void);
  LVAL xflatsize(void);
  LVAL xflatc(void);
  LVAL xopen(void);
  LVAL xbopen(void);
  LVAL xclose(void);
  LVAL xrdchar(void);
  LVAL xrdbyte(void);
  LVAL xpkchar(void);
  LVAL xwrchar(void);
  LVAL xwrbyte(void);
  LVAL xrdint(void);
  LVAL xwrint(void);
  LVAL xrdfloat(void);
  LVAL xwrfloat(void);
  LVAL xreadline(void);
  LVAL xmkstrinput(void);
  LVAL xmkstroutput(void);
  LVAL xgetstroutput(void);
  LVAL xgetlstoutput(void);
  LVAL xformat(void);
  LVAL xlistdir(void);
  LVAL xbigendianp(void);
  
  /* xlimage.c */
  
  int xlisave(const char *fname);
  int xlirestore(const char *fname);
  
  
  /* xlinit.c */
  
  void xlinit(void);
  void xlsymbols(void);
  
  
  /* xlftab.c */
  /* returns true on success,
     false if table limits would be exceeded and the table remains unchanged
     Call this, any number of times, before calling xlisp_main_init
   */
  int xlbindfunctions(const FUNDEF *functions, size_t nfunctions);
  
  /* xlio.c */
  
  int xlgetc(LVAL fptr);
  void xlungetc(LVAL fptr, int ch);
  int xlpeek(LVAL fptr);
  void xlputc(LVAL fptr, int ch);
  void xloutflush(LVAL fptr);
  void xlflush(void);
  void stdprint(LVAL expr);
  void stdputstr(const char *str);
  void stdflush(void);
  void errprint(LVAL expr);
  void errputstr(const char *str);
  void dbgprint(LVAL expr);
  void dbgputstr(const char *str);
  void trcprin1(LVAL expr);
  void trcputstr(const char *str);
  
  
  /* xlisp.c */
  long xlsrand(long seed);
  long xlrand(long range);
  double xlrealrand(void);
  void xlrdsave(LVAL expr);
  void xlevsave(LVAL expr);
  void xlfatal(const char *msg);
  void xlisp_main_init(int, char **);
  void xlisp_main(void);
  void xlisp_wrapup(void);
  
  
  /* xljump.c */
  
  void xlbegin(XLCONTEXT *cptr, int flags, LVAL expr);
  void xlend(XLCONTEXT *cptr);
  void xlgo(LVAL label);
  void xlreturn(LVAL name, LVAL val);
  void xlthrow(LVAL tag, LVAL val);
  void xlsignal(const char *emsg, LVAL arg);
  void xltoplevel(void);
  void xlbrklevel(void);
  void xlcleanup(void);
  void xlcontinue(void);
  void xljump(XLCONTEXT *target, int mask, LVAL val);
  
  
  /* xllist.c */
  
  LVAL xcar(void);
  LVAL xcdr(void);
  LVAL xcaar(void);
  LVAL xcadr(void);
  LVAL xcdar(void);
  LVAL xcddr(void);
  LVAL xcaaar(void);
  LVAL xcaadr(void);
  LVAL xcadar(void);
  LVAL xcaddr(void);
  LVAL xcdaar(void);
  LVAL xcdadr(void);
  LVAL xcddar(void);
  LVAL xcdddr(void);
  
  /* cxxxxr functions */
  LVAL xcaaaar(void);
  LVAL xcaaadr(void);
  LVAL xcaadar(void);
  LVAL xcaaddr(void);
  LVAL xcadaar(void);
  LVAL xcadadr(void);
  LVAL xcaddar(void);
  LVAL xcadddr(void);
  LVAL xcdaaar(void);
  LVAL xcdaadr(void);
  LVAL xcdadar(void);
  LVAL xcdaddr(void);
  LVAL xcddaar(void);
  LVAL xcddadr(void);
  LVAL xcdddar(void);
  LVAL xcddddr(void);
  LVAL xcons(void);
  LVAL xlist(void);
  LVAL xappend(void);
  LVAL xreverse(void);
  LVAL xlast(void);
  LVAL xmember(void);
  LVAL xassoc(void);
  LVAL xsubst(void);
  LVAL xsublis(void);
  LVAL xremove(void);
  LVAL xremif(void);
  LVAL xremifnot(void);
  int dotest1(LVAL arg, LVAL fun);
  int dotest2(LVAL arg1, LVAL arg2, LVAL fun);
  LVAL xnth(void);
  LVAL xnthcdr(void);
  LVAL xlength(void);
  LVAL xmapc(void);
  LVAL xmapcar(void);
  LVAL xmapl(void);
  LVAL xmaplist(void);
  LVAL xrplca(void);
  LVAL xrplcd(void);
  LVAL xnconc(void);
  LVAL xdelete(void);
  LVAL xdelif(void);
  LVAL xdelifnot(void);
  LVAL xsort(void);
  
  
  /* xlmath.c */
  
  LVAL xadd(void);
  LVAL xsub(void);
  LVAL xmul(void);
  LVAL xdiv(void);
  LVAL xrem(void);
  LVAL xmin(void);
  LVAL xmax(void);
  LVAL xexpt(void);
  LVAL xlogand(void);
  LVAL xlogior(void);
  LVAL xlogxor(void);
  LVAL xgcd(void);
  void checkizero(FIXTYPE iarg);
  void checkfzero(FLOTYPE farg);
  void checkfneg(FLOTYPE farg);
  LVAL xlognot(void);
  LVAL xabs(void);
  LVAL xadd1(void);
  LVAL xsub1(void);
  LVAL xsin(void);
  LVAL xcos(void);
  LVAL xtan(void);
  LVAL xexp(void);
  LVAL xsqrt(void);
  LVAL xfix(void);
  LVAL xfloat(void);
  LVAL xrand(void);
  LVAL xsrand(void);
  LVAL xminusp(void);
  LVAL xzerop(void);
  LVAL xplusp(void);
  LVAL xevenp(void);
  LVAL xoddp(void);
  LVAL xlss(void);
  LVAL xleq(void);
  LVAL xequ(void);
  LVAL xneq(void);
  LVAL xgeq(void);
  LVAL xgtr(void);
  LVAL xrealrand(void);
  LVAL xtan(void);
  LVAL xatan(void);
  
  /* xlobj.c */
  
  LVAL xsend(void);
  LVAL xsendsuper(void);
  LVAL xlclass(const char *name, int vcnt);
  void xladdivar(LVAL cls, const char *var);
  void xladdmsg(LVAL cls, const char *msg, int offset);
  int xlobgetvalue(LVAL pair, LVAL sym, LVAL *pval);
  int xlobsetvalue(LVAL pair, LVAL sym, LVAL val);
  LVAL obisnew(void);
  LVAL obclass(void);
  LVAL obshow(void);
  LVAL obisa(void);
  LVAL clnew(void);
  LVAL clisnew(void);
  LVAL clanswer(void);
  void obsymbols(void);
  void xloinit(void);
  
  
  /* xlpp.c */
  
  LVAL xpp(void);
  
  
  /* xlprin.c */
  
  void xlprint(LVAL fptr, LVAL vptr, int flag);
  void xlterpri(LVAL fptr);
  void xlputstr(LVAL fptr, const char *str);
  void putatm(LVAL fptr, const char *tag, LVAL val);
  
  
  /* xlread.c */
  
  int xlload(const char *fname, int vflag, int pflag);
  int xlread(LVAL fptr, LVAL *pval, int rflag);
  int readone(LVAL fptr, LVAL *pval);
  LVAL rmhash(void);
  LVAL rmquote(void);
  LVAL rmdquote(void);
  LVAL rmbquote(void);
  LVAL rmcomma(void);
  LVAL rmlpar(void);
  LVAL rmrpar(void);
  LVAL rmsemi(void);
  LVAL tentry(int ch);
  int xlisnumber(char *str, LVAL *pval);
  void defmacro(int ch, LVAL type, int offset);
  LVAL callmacro(LVAL fptr, int ch);
  void xlrinit(void);
  
  
  /* xlstr.c */
  
  LVAL xstrlss(void);
  LVAL xstrleq(void);
  LVAL xstreql(void);
  LVAL xstrneq(void);
  LVAL xstrgeq(void);
  LVAL xstrgtr(void);
  LVAL xstrilss(void);
  LVAL xstrileq(void);
  LVAL xstrieql(void);
  LVAL xstrineq(void);
  LVAL xstrigeq(void);
  LVAL xstrigtr(void);
  LVAL xupcase(void);
  LVAL xdowncase(void);
  LVAL xnupcase(void);
  LVAL xndowncase(void);
  LVAL xstrsearch(void);
  LVAL xtrim(void);
  LVAL xlefttrim(void);
  LVAL xrighttrim(void);
  LVAL xstrcat(void);
  LVAL xsubseq(void);
  LVAL xstring(void);
  LVAL xchar(void);
  LVAL xcharint(void);
  LVAL xintchar(void);
  LVAL xuppercasep(void);
  LVAL xlowercasep(void);
  LVAL xbothcasep(void);
  LVAL xdigitp(void);
  LVAL xcharcode(void);
  LVAL xcodechar(void);
  LVAL xchupcase(void);
  LVAL xchdowncase(void);
  LVAL xdigitchar(void);
  LVAL xalphanumericp(void);
  LVAL xchrlss(void);
  LVAL xchrleq(void);
  LVAL xchreql(void);
  LVAL xchrneq(void);
  LVAL xchrgeq(void);
  LVAL xchrgtr(void);
  LVAL xchrilss(void);
  LVAL xchrileq(void);
  LVAL xchrieql(void);
  LVAL xchrineq(void);
  LVAL xchrigeq(void);
  LVAL xchrigtr(void);
  LVAL xinfo(void);
  
  /* xlsubr.c */
  
  LVAL xlsubr(const char *sname, int type, LVAL (*fcn)(void), int offset);
  int xlgetkeyarg(LVAL key, LVAL *pval);
  void xltest(LVAL *pfcn, int *ptresult);
  int xlgkfixnum(LVAL key, LVAL *pval);
  /* argument list parsing functions */
  extern LVAL xlgetfile(void);  	/* get a file/stream argument */
  extern LVAL xlgetfname(void);	/* get a filename argument */
  int needsextension(const char *name);
  /* error reporting functions (don't *really* return at all) */
  extern LVAL xlbadtype(LVAL arg);	/* report "bad argument type" error */
  extern LVAL xltoofew(void);		/* report "too few arguments" error */
  extern LVAL xltoomany(void);
  int eq(LVAL arg1, LVAL arg2);
  int eql(LVAL arg1, LVAL arg2);
  int lval_equal(LVAL arg1, LVAL arg2);
  
  
  /* xlsym.c */
  
  LVAL xlenter(const char *name);	/* enter a symbol */
  LVAL xlmakesym(const char *name);	/* make an uninterned symbol */
  LVAL xlgetvalue(LVAL sym);	/* get value of a symbol (checked) */
  LVAL xlxgetvalue(LVAL sym);	/* get value of a symbol */
  void xlsetvalue(LVAL sym, LVAL val);
  LVAL xlgetfunction(LVAL sym);	/* get functional value of a symbol */
  LVAL xlxgetfunction(LVAL sym);	/* get functional value of a symbol (checked) */
  void xlsetfunction(LVAL sym, LVAL val);
  LVAL xlgetprop(LVAL sym, LVAL prp);
  void xlputprop(LVAL sym, LVAL val, LVAL prp);
  void xlremprop(LVAL sym, LVAL prp);
  int hash(const char *str, int len);
  void xlsinit(void);
  LVAL findprop(LVAL sym, LVAL prp);
  
  /* xlsys.c */
  
  LVAL xget_env(void);
  LVAL xload(void);
  LVAL xtranscript(void);
  LVAL xtype(void);
  LVAL xbaktrace(void);
  LVAL xexit(void);
  LVAL xpeek(void);
  LVAL xpoke(void);
  LVAL xaddrs(void);
  LVAL xgetruntime(void);
  LVAL xprofile(void);
  LVAL xquit(void);
  
  /* macstuff, unixstuff, winstuff, osstuff */
  
  LVAL xgetrealtime(void);
  extern const char os_pathchar;
  extern const char os_sepchar;
  
  void osinit(const char *banner);
  void oserror(const char *msg);
  void osfinish(void);
  int osclose(FILE *fp);
  void osflush(void);
  void oscheck(void);
  int osaputc(int ch, FILE *fp);
  void osoutflush(FILE *fp);
  int osbputc(int ch, FILE *fp);
  void ostputc(int ch);
  void ostoutflush(void);
  int osagetc(FILE *fp);
  int osbgetc(FILE *fp);
  int ostgetc(void);
  void ossymbols(void);
  LVAL xlinfo(void);
  LVAL xsetdir(void);
  int osdir_list_start(const char *path);
  const char *osdir_list_next(void);
  void osdir_list_finish(void);
  LVAL xosc_enable(void);
  LVAL xget_temp_path(void);
  LVAL xfind_in_xlisp_path(void);
  LVAL xsetupconsole(void);
  LVAL xechoenabled(void);
  LVAL xget_user(void);
  
  /* security.c */
  
  extern char *secure_read_path;
  extern char *safe_write_path;
  extern int run_time_limit;
  extern int run_time;
  extern int memory_limit;
  #define SAFE_NYQUIST (safe_write_path != NULL)
  int ok_to_open(const char *filename, const char *mode);
  
  /* These are now implemented in path.c   -dmazzoni */
  const char *return_xlisp_path(void);
  const char *find_in_xlisp_path(const char *fname);
  void set_xlisp_path(const char *p);
  
  /* local.c - these procedures are specific to each implementation */
  
  void localinit(void);
  void localsymbols(void);
  void print_local_gc_info(void);
  void local_toplevel(void);
  
  #ifdef __cplusplus
  }
  #endif
  
  #endif
  
  