text: /* xlftab.c - xlisp function table */
  /*	Copyright (c) 1985, by David Michael Betz
      All Rights Reserved
      Permission is granted for unrestricted non-commercial use
  
  HISTORY
  23-Apr-03   Mazzoni
          Eliminated some compiler warnings
   1-Apr-88	Dale Amon at CSD
          Added include file hook for local language extensions:
          localdefs.h and localptrs.h
  
  */
  
  #include "switches.h"
  #include "xlisp.h"
  #ifndef NO_PROTOTYPES_IN_XLISP_H
  /* external functions */
  extern LVAL
      xbisubr(void),xbifsubr(void),
      rmhash(void),rmquote(void),rmdquote(void),rmbquote(void),rmcomma(void),
      clnew(void),clisnew(void),clanswer(void),
      obisnew(void),obclass(void),obshow(void),obisa(void),
      rmlpar(void),rmrpar(void),rmsemi(void),
      xeval(void),xapply(void),xfuncall(void),xquote(void),xfunction(void),xbquote(void),
      xlambda(void),xset(void),xsetq(void),xsetf(void),xdefun(void),xdefmacro(void),
      xgensym(void),xmakesymbol(void),xintern(void),
      xsymname(void),xsymvalue(void),xsymplist(void),
      xget(void),xputprop(void),xremprop(void),
      xhash(void),xmkarray(void),xaref(void),
      xcar(void),xcdr(void),
      xcaar(void),xcadr(void),xcdar(void),xcddr(void),
      xcaaar(void),xcaadr(void),xcadar(void),xcaddr(void),
      xcdaar(void),xcdadr(void),xcddar(void),xcdddr(void),
      xcaaaar(void),xcaaadr(void),xcaadar(void),xcaaddr(void),
      xcadaar(void),xcadadr(void),xcaddar(void),xcadddr(void),
      xcdaaar(void),xcdaadr(void),xcdadar(void),xcdaddr(void),
      xcddaar(void),xcddadr(void),xcdddar(void),xcddddr(void),
      xcons(void),xlist(void),xappend(void),xreverse(void),xlast(void),xnth(void),xnthcdr(void),
      xmember(void),xassoc(void),xsubst(void),xsublis(void),xlength(void),xsort(void),
      xremove(void),xremif(void),xremifnot(void),
      xmapc(void),xmapcar(void),xmapl(void),xmaplist(void),
      xrplca(void),xrplcd(void),xnconc(void),
      xdelete(void),xdelif(void),xdelifnot(void),
      xatom(void),xsymbolp(void),xnumberp(void),xboundp(void),xnull(void),xlistp(void),xendp(void),xconsp(void),
      xeq(void),xeql(void),xequal(void),
      xcond(void),xcase(void),xand(void),x_or(void),xlet(void),xletstar(void),xif(void),
      xprog(void),xprogstar(void),xprog1(void),xprog2(void),xprogn(void),xgo(void),xreturn(void),
      xcatch(void),xthrow(void),
      xerror(void),xcerror(void),xbreak(void),
      xcleanup(void),xtoplevel(void),xcontinue(void),xerrset(void),
      xbaktrace(void),xevalhook(void),
      xdo(void),xdostar(void),xdolist(void),xdotimes(void),
      xminusp(void),xzerop(void),xplusp(void),xevenp(void),xoddp(void),
      xfix(void),xfloat(void),
      xgcd(void),xadd(void),xsub(void),xmul(void),xdiv(void),xrem(void),xmin(void),xmax(void),xabs(void),
      xadd1(void),xsub1(void),xlogand(void),xlogior(void),xlogxor(void),xlognot(void),
      xsin(void),xcos(void),xtan(void),xatan(void),xexpt(void),xexp(void),xsqrt(void),xrand(void), xrealrand(void),
      xlss(void),xleq(void),xequ(void),xneq(void),xgeq(void),xgtr(void),
      xstrcat(void),xsubseq(void),xstring(void),xchar(void),
      xread(void),xprint(void),xprin1(void),xprinc(void),xterpri(void),
      xflatsize(void),xflatc(void),
      xopen(void),xbopen(void),xclose(void),xrdchar(void),xpkchar(void),xwrchar(void),xreadline(void),
      xrdint(void),xwrint(void),xrdfloat(void),xwrfloat(void),
      xget_env(void), xload(void),xtranscript(void),
      xtype(void),xquit(void),xexit(void),xpeek(void),xpoke(void),xaddrs(void),
      xvector(void),xblock(void),xrtnfrom(void),xtagbody(void),
      xpsetq(void),xflet(void),xlabels(void),xmacrolet(void),xunwindprotect(void),xpp(void),
      xstrlss(void),xstrleq(void),xstreql(void),xstrneq(void),xstrgeq(void),xstrgtr(void),
      xstrilss(void),xstrileq(void),xstrieql(void),xstrineq(void),xstrigeq(void),xstrigtr(void),
      xupcase(void),xdowncase(void),xnupcase(void),xndowncase(void),
      xtrim(void),xlefttrim(void),xrighttrim(void),
      xuppercasep(void),xlowercasep(void),xbothcasep(void),xdigitp(void),xalphanumericp(void),
      xcharcode(void),xcodechar(void),xchupcase(void),xchdowncase(void),xdigitchar(void),
      xchrlss(void),xchrleq(void),xchreql(void),xchrneq(void),xchrgeq(void),xchrgtr(void),
      xchrilss(void),xchrileq(void),xchrieql(void),xchrineq(void),xchrigeq(void),xchrigtr(void),
      xintegerp(void),xfloatp(void),xstringp(void),xarrayp(void),xstreamp(void),xobjectp(void),
      xwhen(void),xunless(void),xloop(void),
      xsymfunction(void),xfboundp(void),xsend(void),xsendsuper(void),
      xprogv(void),xrdbyte(void),xwrbyte(void),xformat(void),
      xcharp(void),xcharint(void),xintchar(void),
      xmkstrinput(void),xmkstroutput(void),xgetstroutput(void),xgetlstoutput(void),
      xgetlambda(void),xmacroexpand(void),x1macroexpand(void),
      xinfo(void),					//Added by Ning Hu	Apr.2001
      xsetdir(void),					//Added by Ning Hu	May.2001
      xbigendianp(void),
      xtrace(void),xuntrace(void),xprofile(void),xstrsearch(void), xsetupconsole(void),
      xechoenabled(void),xslider_read(void),
      xget_user(void), // added by RBD, Jul 2007
      xfind_in_xlisp_path(void); // added by RBD, Jan 2008
  #endif
  
  /* functions specific to xldmem.c */
  LVAL xgc(void),xexpand(void),xalloc(void),xmem(void);
  #ifdef SAVERESTORE
  LVAL xsave(void),xrestore(void);
  #endif
  
  /* include system dependant definitions */
  #include "osdefs.h"
  #include "localdefs.h"
  
  /* SUBR/FSUBR indicator */
  #define S	SUBR
  #define F	FSUBR
  
  /* forward declarations */
  LOCAL LVAL xnotimp(void);
  
  /* debugging functions */
  #ifdef DEBUG_INPUT
  LVAL xstartrecordio(void);
  LVAL xstoprecordio(void);
  #endif
  
  /* the function table */
  FUNDEF funtab[] = {
  
      /* read macro functions */
  {	NULL,				S, rmhash		}, /*   0 */
  {	NULL,				S, rmquote		}, /*   1 */
  {	NULL,				S, rmdquote		}, /*   2 */
  {	NULL,				S, rmbquote		}, /*   3 */
  {	NULL,				S, rmcomma		}, /*   4 */
  {	NULL,				S, rmlpar		}, /*   5 */
  {	NULL,				S, rmrpar		}, /*   6 */
  {	NULL,				S, rmsemi		}, /*   7 */
  {	NULL,				S, xnotimp		}, /*   8 */
  {	NULL,				S, xnotimp		}, /*   9 */
  
      /* methods */
  {	NULL,				S, clnew		}, /*  10 */
  {	NULL,				S, clisnew		}, /*  11 */
  {	NULL,				S, clanswer		}, /*  12 */
  {	NULL,				S, obisnew		}, /*  13 */
  {	NULL,				S, obclass		}, /*  14 */
  {	NULL,				S, obshow		}, /*  15 */
  {	NULL,				S, obisa		}, /*  16 */
  {	NULL,				S, xnotimp		}, /*  17 */
  {	NULL,				S, xnotimp		}, /*  18 */
  {	NULL,				S, xnotimp		}, /*  19 */
  
      /* evaluator functions */
  {	"EVAL",				S, xeval		}, /*  20 */
  {	"APPLY",			S, xapply		}, /*  21 */
  {	"FUNCALL",			S, xfuncall		}, /*  22 */
  {	"QUOTE",			F, xquote		}, /*  23 */
  {	"FUNCTION",			F, xfunction		}, /*  24 */
  {	"BACKQUOTE",			F, xbquote		}, /*  25 */
  {	"LAMBDA",			F, xlambda		}, /*  26 */
  
      /* symbol functions */
  {	"SET",				S, xset			}, /*  27 */
  {	"SETQ",				F, xsetq		}, /*  28 */
  {	"SETF",				F, xsetf		}, /*  29 */
  {	"DEFUN",			F, xdefun		}, /*  30 */
  {	"DEFMACRO",			F, xdefmacro		}, /*  31 */
  {	"GENSYM",			S, xgensym		}, /*  32 */
  {	"MAKE-SYMBOL",			S, xmakesymbol		}, /*  33 */
  {	"INTERN", 			S, xintern		}, /*  34 */
  {	"SYMBOL-NAME",			S, xsymname		}, /*  35 */
  {	"SYMBOL-VALUE",			S, xsymvalue		}, /*  36 */
  {	"SYMBOL-PLIST",			S, xsymplist		}, /*  37 */
  {	"GET",				S, xget			}, /*  38 */
  {	"PUTPROP", 			S, xputprop		}, /*  39 */
  {	"REMPROP",			S, xremprop		}, /*  40 */
  {	"HASH",				S, xhash		}, /*  41 */
  
      /* array functions */
  {	"MAKE-ARRAY",			S, xmkarray		}, /*  42 */
  {	"AREF",				S, xaref		}, /*  43 */
              
      /* list functions */
  {	"CAR",				S, xcar			}, /*  44 */
  {	"CDR",				S, xcdr			}, /*  45 */
              
  {	"CAAR",				S, xcaar		}, /*  46 */
  {	"CADR",				S, xcadr		}, /*  47 */
  {	"CDAR",				S, xcdar		}, /*  48 */
  {	"CDDR",				S, xcddr		}, /*  49 */
  
  {	"CAAAR",			S, xcaaar		}, /*  50 */
  {	"CAADR",			S, xcaadr		}, /*  51 */
  {	"CADAR",			S, xcadar		}, /*  52 */
  {	"CADDR",			S, xcaddr		}, /*  53 */
  {	"CDAAR",			S, xcdaar		}, /*  54 */
  {	"CDADR",			S, xcdadr		}, /*  55 */
  {	"CDDAR",			S, xcddar		}, /*  56 */
  {	"CDDDR",			S, xcdddr		}, /*  57 */
  
  {	"CAAAAR", 			S, xcaaaar		}, /*  58 */
  {	"CAAADR",			S, xcaaadr		}, /*  59 */
  {	"CAADAR",			S, xcaadar		}, /*  60 */
  {	"CAADDR",			S, xcaaddr		}, /*  61 */
  {	"CADAAR",		 	S, xcadaar		}, /*  62 */
  {	"CADADR",			S, xcadadr		}, /*  63 */
  {	"CADDAR",			S, xcaddar		}, /*  64 */
  {	"CADDDR",			S, xcadddr		}, /*  65 */
  {	"CDAAAR",			S, xcdaaar		}, /*  66 */
  {	"CDAADR",			S, xcdaadr		}, /*  67 */
  {	"CDADAR",			S, xcdadar		}, /*  68 */
  {	"CDADDR",			S, xcdaddr		}, /*  69 */
  {	"CDDAAR",			S, xcddaar		}, /*  70 */
  {	"CDDADR",			S, xcddadr		}, /*  71 */
  {	"CDDDAR",			S, xcdddar		}, /*  72 */
  {	"CDDDDR",			S, xcddddr		}, /*  73 */
  
  {	"CONS",				S, xcons		}, /*  74 */
  {	"LIST",				S, xlist		}, /*  75 */
  {	"APPEND",			S, xappend		}, /*  76 */
  {	"REVERSE",			S, xreverse		}, /*  77 */
  {	"LAST",				S, xlast		}, /*  78 */
  {	"NTH",				S, xnth			}, /*  79 */
  {	"NTHCDR",			S, xnthcdr		}, /*  80 */
  {	"MEMBER",			S, xmember		}, /*  81 */
  {	"ASSOC",			S, xassoc		}, /*  82 */
  {	"SUBST", 			S, xsubst		}, /*  83 */
  {	"SUBLIS",			S, xsublis		}, /*  84 */
  {	"REMOVE",			S, xremove		}, /*  85 */
  {	"LENGTH",			S, xlength		}, /*  86 */
  {	"MAPC",				S, xmapc		}, /*  87 */
  {	"MAPCAR",			S, xmapcar		}, /*  88 */
  {	"MAPL",				S, xmapl		}, /*  89 */
  {	"MAPLIST",			S, xmaplist		}, /*  90 */
              
      /* destructive list functions */
  {	"RPLACA",			S, xrplca		}, /*  91 */
  {	"RPLACD",			S, xrplcd		}, /*  92 */
  {	"NCONC",			S, xnconc		}, /*  93 */
  {	"DELETE",			S, xdelete		}, /*  94 */
  
      /* predicate functions */
  {	"ATOM",				S, xatom		}, /*  95 */
  {	"SYMBOLP",			S, xsymbolp		}, /*  96 */
  {	"NUMBERP",			S, xnumberp		}, /*  97 */
  {	"BOUNDP",			S, xboundp 		}, /*  98 */
  {	"NULL",				S, xnull		}, /*  99 */
  {	"LISTP",			S, xlistp		}, /* 100 */
  {	"CONSP",			S, xconsp		}, /* 101 */
  {	"MINUSP",			S, xminusp 		}, /* 102 */
  {	"ZEROP",			S, xzerop		}, /* 103 */
  {	"PLUSP",			S, xplusp		}, /* 104 */
  {	"EVENP",			S, xevenp		}, /* 105 */
  {	"ODDP",				S, xoddp		}, /* 106 */
  {	"EQ",				S, xeq			}, /* 107 */
  {	"EQL",				S, xeql			}, /* 108 */
  {	"EQUAL",			S, xequal		}, /* 109 */
  
      /* special forms */
  {	"COND",				F, xcond		}, /* 110 */
  {	"CASE",				F, xcase		}, /* 111 */
  {	"AND",				F, xand			}, /* 112 */
  {	"OR",				F, x_or			}, /* 113 */
  {	"LET",				F, xlet			}, /* 114 */
  {	"LET*",				F, xletstar		}, /* 115 */
  {	"IF",				F, xif			}, /* 116 */
  {	"PROG",				F, xprog		}, /* 117 */
  {	"PROG*",			F, xprogstar		}, /* 118 */
  {	"PROG1",			F, xprog1		}, /* 119 */
  {	"PROG2",			F, xprog2		}, /* 120 */
  {	"PROGN",			F, xprogn		}, /* 121 */
  {	"GO",				F, xgo			}, /* 122 */
  {	"RETURN",			F, xreturn  		}, /* 123 */
  {	"DO",				F, xdo			}, /* 124 */
  {	"DO*",				F, xdostar  		}, /* 125 */
  {	"DOLIST",			F, xdolist  		}, /* 126 */
  {	"DOTIMES",			F, xdotimes		}, /* 127 */
  {	"CATCH",			F, xcatch		}, /* 128 */
  {	"THROW",			F, xthrow		}, /* 129 */
      
      /* debugging and error handling functions */
  {	"ERROR",			S, xerror		}, /* 130 */
  {	"CERROR",			S, xcerror  		}, /* 131 */
  {	"BREAK",			S, xbreak		}, /* 132 */
  {	"CLEAN-UP",			S, xcleanup		}, /* 133 */
  {	"TOP-LEVEL",			S, xtoplevel		}, /* 134 */
  {	"CONTINUE",			S, xcontinue		}, /* 135 */
  {	"ERRSET", 			F, xerrset  		}, /* 136 */
  {	"BAKTRACE",			S, xbaktrace		}, /* 137 */
  {	"EVALHOOK",			S, xevalhook		}, /* 138 */
  
      /* arithmetic functions */
  {	"TRUNCATE",			S, xfix			}, /* 139 */
  {	"FLOAT",			S, xfloat		}, /* 140 */
  {	"+",				S, xadd			}, /* 141 */
  {	"-",				S, xsub			}, /* 142 */
  {	"*",				S, xmul			}, /* 143 */
  {	"/",				S, xdiv			}, /* 144 */
  {	"1+",				S, xadd1		}, /* 145 */
  {	"1-",				S, xsub1		}, /* 146 */
  {	"REM",				S, xrem			}, /* 147 */
  {	"MIN",				S, xmin			}, /* 148 */
  {	"MAX",				S, xmax			}, /* 149 */
  {	"ABS",				S, xabs			}, /* 150 */
  {	"SIN",				S, xsin			}, /* 151 */
  {	"COS",				S, xcos			}, /* 152 */
  {	"TAN",				S, xtan			}, /* 153 */
  {	"EXPT",				S, xexpt		}, /* 154 */
  {	"EXP",				S, xexp			}, /* 155 */
  {	"SQRT",		  		S, xsqrt		}, /* 156 */
  {	"RANDOM",			S, xrand		}, /* 157 */
              
      /* bitwise logical functions */
  {	"LOGAND",			S, xlogand  		}, /* 158 */
  {	"LOGIOR",			S, xlogior  		}, /* 159 */
  {	"LOGXOR",			S, xlogxor  		}, /* 160 */
  {	"LOGNOT",			S, xlognot  		}, /* 161 */
  
      /* numeric comparison functions */
  {	"<",				S, xlss			}, /* 162 */
  {	"<=",				S, xleq			}, /* 163 */
  {	"=",				S, xequ			}, /* 164 */
  {	"/=",				S, xneq			}, /* 165 */
  {	">=",				S, xgeq			}, /* 166 */
  {	">",				S, xgtr			}, /* 167 */
              
      /* string functions */
  {	"STRCAT",			S, xstrcat  		}, /* 168 */
  {	"SUBSEQ",			S, xsubseq  		}, /* 169 */
  {	"STRING",			S, xstring  		}, /* 170 */
  {	"CHAR",				S, xchar		}, /* 171 */
  
      /* I/O functions */
  {	"READ",				S, xread		}, /* 172 */
  {	"PRINT",			S, xprint		}, /* 173 */
  {	"PRIN1",			S, xprin1		}, /* 174 */
  {	"PRINC",			S, xprinc		}, /* 175 */
  {	"TERPRI",			S, xterpri  		}, /* 176 */
  {	"FLATSIZE",			S, xflatsize		}, /* 177 */
  {	"FLATC",			S, xflatc		}, /* 178 */
              
      /* file I/O functions */
  {	"OPEN",				S, xopen		}, /* 179 */
  {	"FORMAT",			S, xformat  		}, /* 180 */
  {	"CLOSE",			S, xclose		}, /* 181 */
  {	"READ-CHAR",			S, xrdchar  		}, /* 182 */
  {	"PEEK-CHAR",			S, xpkchar  		}, /* 183 */
  {	"WRITE-CHAR",			S, xwrchar  		}, /* 184 */
  {	"READ-LINE",			S, xreadline		}, /* 185 */
  
      /* system functions */
  {	"LOAD",				S, xload		}, /* 186 */
  {	"DRIBBLE",			S, xtranscript		}, /* 187 */
  
  /* functions specific to xldmem.c */
  {	"GC",				S, xgc			}, /* 188 */
  {	"EXPAND",			S, xexpand  		}, /* 189 */
  {	"ALLOC",			S, xalloc		}, /* 190 */
  {	"ROOM",				S, xmem			}, /* 191 */
  #ifdef SAVERESTORE
  {	"SAVE",				S, xsave		}, /* 192 */
  {	"RESTORE",			S, xrestore		}, /* 193 */
  #else
  {	NULL,				S, xnotimp		}, /* 192 */
  {	NULL,				S, xnotimp		}, /* 193 */
  #endif
  /* end of functions specific to xldmem.c */
  
  {	"TYPE-OF",			S, xtype		}, /* 194 */
  {	"EXIT",				S, xexit		}, /* 195 */
  #ifdef PEEK_AND_POKE
  {	"PEEK",				S, xpeek		}, /* 196 */
  {	"POKE",				S, xpoke		}, /* 197 */
  {	"ADDRESS-OF",			S, xaddrs		}, /* 198 */
  #else
  {	NULL,				S, xnotimp		}, /* 196 */
  {	NULL,				S, xnotimp		}, /* 197 */
  {	NULL,				S, xnotimp		}, /* 198 */
  #endif
      /* new functions and special forms */
  {	"VECTOR",			S, xvector  		}, /* 199 */
  {	"BLOCK",			F, xblock		}, /* 200 */
  {	"RETURN-FROM",			F, xrtnfrom		}, /* 201 */
  {	"TAGBODY",			F, xtagbody		}, /* 202 */
  {	"PSETQ",			F, xpsetq		}, /* 203 */
  {	"FLET",				F, xflet		}, /* 204 */
  {	"LABELS",			F, xlabels  		}, /* 205 */
  {	"MACROLET",			F, xmacrolet		}, /* 206 */
  {	"UNWIND-PROTECT",		F, xunwindprotect	}, /* 207 */
  {	"PPRINT",			S, xpp			}, /* 208 */
  {	"STRING<",			S, xstrlss  		}, /* 209 */
  {	"STRING<=",			S, xstrleq  		}, /* 210 */
  {	"STRING=",			S, xstreql  		}, /* 211 */
  {	"STRING/=",			S, xstrneq  		}, /* 212 */
  {	"STRING>=",			S, xstrgeq  		}, /* 213 */
  {	"STRING>",			S, xstrgtr  		}, /* 214 */
  {	"STRING-LESSP",			S, xstrilss		}, /* 215 */
  {	"STRING-NOT-GREATERP",		S, xstrileq		}, /* 216 */
  {	"STRING-EQUAL",			S, xstrieql		}, /* 217 */
  {	"STRING-NOT-EQUAL",		S, xstrineq		}, /* 218 */
  {	"STRING-NOT-LESSP",		S, xstrigeq		}, /* 219 */
  {	"STRING-GREATERP",		S, xstrigtr		}, /* 220 */
  {	"INTEGERP",			S, xintegerp		}, /* 221 */
  {	"FLOATP",			S, xfloatp  		}, /* 222 */
  {	"STRINGP",			S, xstringp		}, /* 223 */
  {	"ARRAYP",			S, xarrayp  		}, /* 224 */
  {	"STREAMP",			S, xstreamp		}, /* 225 */
  {	"OBJECTP",			S, xobjectp		}, /* 226 */
  {	"STRING-UPCASE",		S, xupcase  		}, /* 227 */
  {	"STRING-DOWNCASE",		S, xdowncase		}, /* 228 */
  {	"NSTRING-UPCASE",		S, xnupcase		}, /* 229 */
  {	"NSTRING-DOWNCASE",		S, xndowncase		}, /* 230 */
  {	"STRING-TRIM",			S, xtrim		}, /* 231 */
  {	"STRING-LEFT-TRIM",		S, xlefttrim		}, /* 232 */
  {	"STRING-RIGHT-TRIM",		S, xrighttrim		}, /* 233 */
  {	"WHEN",				F, xwhen		}, /* 234 */
  {	"UNLESS",			F, xunless  		}, /* 235 */
  {	"LOOP",				F, xloop		}, /* 236 */
  {	"SYMBOL-FUNCTION",		S, xsymfunction		}, /* 237 */
  {	"FBOUNDP",			S, xfboundp		}, /* 238 */
  {	"SEND",				S, xsend		}, /* 239 */
  {	"SEND-SUPER",			S, xsendsuper		}, /* 240 */
  {	"PROGV",			F, xprogv		}, /* 241 */
  {	"CHARACTERP",			S, xcharp		}, /* 242 */
  {	"CHAR-INT",			S, xcharint		}, /* 243 */
  {	"INT-CHAR",			S, xintchar		}, /* 244 */
  {	"READ-BYTE",			S, xrdbyte  		}, /* 245 */
  {	"WRITE-BYTE",			S, xwrbyte  		}, /* 246 */
  {	"MAKE-STRING-INPUT-STREAM", 	S, xmkstrinput		}, /* 247 */
  {	"MAKE-STRING-OUTPUT-STREAM",	S, xmkstroutput		}, /* 248 */
  {	"GET-OUTPUT-STREAM-STRING",	S, xgetstroutput	}, /* 249 */
  {	"GET-OUTPUT-STREAM-LIST",	S, xgetlstoutput	}, /* 250 */
  {	"GCD",				S, xgcd			}, /* 251 */
  {	"GET-LAMBDA-EXPRESSION", 	S, xgetlambda		}, /* 252 */
  {	"MACROEXPAND",			S, xmacroexpand		}, /* 253 */
  {	"MACROEXPAND-1",		S, x1macroexpand	}, /* 254 */
  {	"CHAR<",			S, xchrlss  		}, /* 255 */
  {	"CHAR<=",			S, xchrleq  		}, /* 256 */
  {	"CHAR=",			S, xchreql  		}, /* 257 */
  {	"CHAR/=",			S, xchrneq  		}, /* 258 */
  {	"CHAR>=",			S, xchrgeq  		}, /* 259 */
  {	"CHAR>",			S, xchrgtr  		}, /* 260 */
  {	"CHAR-LESSP",			S, xchrilss		}, /* 261 */
  {	"CHAR-NOT-GREATERP",		S, xchrileq		}, /* 262 */
  {	"CHAR-EQUAL",			S, xchrieql		}, /* 263 */
  {	"CHAR-NOT-EQUAL",		S, xchrineq		}, /* 264 */
  {	"CHAR-NOT-LESSP",		S, xchrigeq		}, /* 265 */
  {	"CHAR-GREATERP",		S, xchrigtr		}, /* 266 */
  {	"UPPER-CASE-P",			S, xuppercasep		}, /* 267 */
  {	"LOWER-CASE-P",			S, xlowercasep		}, /* 268 */
  {	"BOTH-CASE-P",			S, xbothcasep		}, /* 269 */
  {	"DIGIT-CHAR-P",			S, xdigitp		}, /* 270 */
  {	"ALPHANUMERICP",		S, xalphanumericp	}, /* 271 */
  {	"CHAR-UPCASE",			S, xchupcase		}, /* 272 */
  {	"CHAR-DOWNCASE",		S, xchdowncase		}, /* 273 */
  {	"DIGIT-CHAR",			S, xdigitchar		}, /* 274 */
  {	"CHAR-CODE",			S, xcharcode		}, /* 275 */
  {	"CODE-CHAR",			S, xcodechar		}, /* 276 */
  {	"ENDP",  			S, xendp		}, /* 277 */
  {	"REMOVE-IF",			S, xremif	    	}, /* 278 */
  {	"REMOVE-IF-NOT",		S, xremifnot		}, /* 279 */
  {	"DELETE-IF",			S, xdelif		}, /* 280 */
  {	"DELETE-IF-NOT",		S, xdelifnot		}, /* 281 */
  {	"TRACE",			F, xtrace		}, /* 282 */
  {	"UNTRACE",			F, xuntrace		}, /* 283 */
  {	"SORT",				S, xsort		}, /* 284 */
  
  
      /* extra table entries */
  {	"PROFILE",   			S, xprofile		}, /* 285 */
  {	"STRING-SEARCH",		S, xstrsearch		}, /* 286 */
  {	"QUIT",		    		S, xquit		}, /* 287 */
  {	"OPEN-BINARY",			S, xbopen		}, /* 288 */
  {	"SETUP-CONSOLE",		S, xsetupconsole	}, /* 289 */
  {       "READ-INT",                     S, xrdint               }, /* 290 */
  {	"READ-FLOAT",			S, xrdfloat		}, /* 291 */
  {	"WRITE-INT",			S, xwrint		}, /* 292 */
  {	"WRITE-FLOAT",			S, xwrfloat		}, /* 293 */
  {	"INFO",			    	S, xinfo		}, /* 294 */ /* Ning Hu, Apr 2001 */
  {	"RRANDOM",  		        S, xrealrand	        }, /* 295 */
  #ifdef DEBUG_INPUT
  {	"START-RECORD-IO",  	        S, xstartrecordio       }, /* 296 */
  {	"STOP-RECORD-IO",   	        S, xstoprecordio	}, /* 297 */
  #else
  {	NULL,				S, xnotimp		}, /* 296 */
  {	NULL,				S, xnotimp		}, /* 297 */
  #endif
  {	"ATAN",				S, xatan		}, /* 298 */
  {	"BIGENDIANP",		        S, xbigendianp	        }, /* 299 */
  {	"SETDIR",                       S, xsetdir		}, /* 300 */    //Added by Ning Hu May.2001
  {       "LISTDIR",                      S, xlistdir             }, /* 301 */   // Added by RBD, Mar 2005
  {       "ECHOENABLED",                  S, xechoenabled         }, /* 302 */   // Added by RBD, Dec 2005
  {       "GET-SLIDER-VALUE",             S, xslider_read         }, /* 303 */
  {       "OSC-ENABLE",                   S, xosc_enable          }, /* 304 */
  {       "GET-TEMP-PATH",                S, xget_temp_path       }, /* 305 */
  {       "GET-USER",                     S, xget_user            }, /* 306 */
  {       "FIND-IN-XLISP-PATH",           S, xfind_in_xlisp_path  }, /* 307 */
  {       "GET-ENV",                      S, xget_env             }, /* 308 */
  {       "GET-RUN-TIME",                 S, xgetruntime          }, /* 309 */
  
  #ifdef MACINTOSH
  #include "macptrs.h"
  #endif
  
      /* include system dependant function pointers */
  #include "osptrs.h"
  #include "localptrs.h"
  
  {0,0,0} /* end of table marker */
  
  };			
  
  /* xnotimp does not return anything on purpose, so disable
   * "no return value" warning
   */
  /* #pragma warning(disable: 4716)*/
  
  /* xnotimp - function table entries that are currently not implemented */
  LOCAL LVAL xnotimp(void)
  {
      xlfail("function not implemented");
      return NIL; /* never happens */
  }
  
  