/* xlftab.c - xlisp function table */
/* Copyright (c) 1989, by David Michael Betz.                            */
/* You may give out copies of this software; for conditions see the file */
/* COPYING included with this distribution.                              */

#include "xlisp.h"

/* include system dependant definitions */
#include "osdefs.h"

/* SUBR/FSUBR indicator */
#define S	SUBR
#define F	FSUBR
#ifdef MULVALS
/* extra codes for subrs that return multiple values */
#define SM  (SUBR+ TYPEFIELD+1)
#define FM  (FSUBR+ TYPEFIELD+1)
#else
#define SM  SUBR
#define FM  FSUBR
#endif

/* forward declarations */
LOCAL LVAL xnotimp _((void));

/* xnotimp - function table entries that are currently not implemented */
LOCAL LVAL xnotimp()
{
    xlfail("function not implemented");
    return NIL;
}

/* the function table */
#if defined(_Windows) && ! defined(WIN32)   /* L. Tierney */
FUNDEF far funtab[] = {
#else
FUNDEF funtab[] = {
#endif
/* DO NOT ALTER ENTRIES UNTIL AFTER OBPRIN1 */
	/* read macro functions */
{   NULL,               S, rmhash       },
{   NULL,               S, rmquote      },
{   NULL,               S, rmdquote     },
{   NULL,               S, rmbquote     },
{   NULL,               S, rmcomma      },
{   NULL,               S, rmlpar       },
{   NULL,               S, rmrpar       },
{   NULL,               S, rmsemi       },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },

	/* methods */
{   NULL,               S, clnew        },
{   NULL,               S, clisnew      },
{   NULL,               S, clanswer     },
{   NULL,               S, obisnew      },
{   NULL,               S, obclass      },
{   NULL,               S, obshow       },
{   NULL,               S, obprin1      },
{   NULL,               S, clmethod     },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },

	/* evaluator functions */
{   "EVAL",             SM, xeval       },
{   "APPLY",            SM, xapply      },
{   "FUNCALL",          SM, xfuncall    },
{   "QUOTE",            F, xquote       },
{   "IDENTITY",         S, xquote       },  /* IDENTITY is same as QUOTE */
{   "FUNCTION",         F, xfunction    },
{   "COMPLEMENT",       F, xcomplement  },
{   "BACKQUOTE",        F, xbquote      },
{   "LAMBDA",           F, xlambda      },

	/* symbol functions */
{   "SET",              S, xset         },
{   "SETQ",             F, xsetq        },
{   "SETF",             F, xsetf        },
{   "DEFUN",            F, xdefun       },
{   "DEFMACRO",         F, xdefmacro    },
{   "GENSYM",           S, xgensym      },
{   "MAKE-SYMBOL",      S, xmakesymbol  },
{   "INTERN",           SM, xintern     },
{   "SYMBOL-NAME",      S, xsymname     },
{   "SYMBOL-VALUE",     S, xsymvalue    },
{   "SYMBOL-PLIST",     S, xsymplist    },
{   "GET",              S, xget         },
{   "GETF",             S, xgetf        },
{   "PUTPROP",          S, xputprop     },
{   "REMPROP",          S, xremprop     },
{   "HASH",             S, xhash        },

	/* array functions */
{   "MAKE-ARRAY",       S, xmkarray     },
{   "AREF",             S, xaref        },
			
	/* list functions */
{   "CAR",              S, xcar         },
{   "CDR",              S, xcdr         },
			
{   "CAAR",             S, xcaar        },
{   "CADR",             S, xcadr        },
{   "CDAR",             S, xcdar        },
{   "CDDR",             S, xcddr        },

{   "CAAAR",            S, xcaaar       },
{   "CAADR",            S, xcaadr       },
{   "CADAR",            S, xcadar       },
{   "CADDR",            S, xcaddr       },
{   "CDAAR",            S, xcdaar       },
{   "CDADR",            S, xcdadr       },
{   "CDDAR",            S, xcddar       },
{   "CDDDR",            S, xcdddr       },

{   "CAAAAR",           S, xcaaaar      },
{   "CAAADR",           S, xcaaadr      },
{   "CAADAR",           S, xcaadar      },
{   "CAADDR",           S, xcaaddr      },
{   "CADAAR",           S, xcadaar      },
{   "CADADR",           S, xcadadr      },
{   "CADDAR",           S, xcaddar      },
{   "CADDDR",           S, xcadddr      },
{   "CDAAAR",           S, xcdaaar      },
{   "CDAADR",           S, xcdaadr      },
{   "CDADAR",           S, xcdadar      },
{   "CDADDR",           S, xcdaddr      },
{   "CDDAAR",           S, xcddaar      },
{   "CDDADR",           S, xcddadr      },
{   "CDDDAR",           S, xcdddar      },
{   "CDDDDR",           S, xcddddr      },

{   "CONS",             S, xcons        },
{   "LIST",             S, xlist        },
{   "LIST*",            S, xliststar    },
{   "APPEND",           S, xappend      },
{   "REVERSE",          S, xreverse     },
{   "LAST",             S, xlast        },
{   "NTH",              S, xnth         },
{   "NTHCDR",           S, xnthcdr      },
{   "MEMBER",           S, xmember      },
{   "ASSOC",            S, xassoc       },
{   "SUBST",            S, xsubst       },
{   "SUBLIS",           S, xsublis      },
{   "NSUBST",           S, xnsubst      },
{   "NSUBST-IF",        S, xnsubstif    },
{   "NSUBST-IF-NOT",    S, xnsubstifnot },
{   "NSUBLIS",          S, xnsublis     },
{   "REMOVE",           S, xremove      },
{   "LENGTH",           S, xlength      },
{   "LIST-LENGTH",      S, xlistlength  },
{   "MAPC",             S, xmapc        },
{   "MAPCAR",           S, xmapcar      },
{   "MAPL",             S, xmapl        },
{   "MAPLIST",          S, xmaplist     },
{   "MAPCAN",           S, xmapcan      },
{   "MAPCON",           S, xmapcon      },
			
	/* destructive list functions */
{   "RPLACA",           S, xrplca       },
{   "RPLACD",           S, xrplcd       },
{   "NCONC",            S, xnconc       },
{   "DELETE",           S, xdelete      },

	/* predicate functions */
{   "ATOM",             S, xatom        },
{   "SYMBOLP",          S, xsymbolp     },
{   "NUMBERP",          S, xnumberp     },
{   "BOUNDP",           S, xboundp      },
{   "NULL",             S, xnull        },
{   "LISTP",            S, xlistp       },
{   "CONSP",            S, xconsp       },
{   "VECTORP",          S, xvectorp     },
{   "MINUSP",           S, xminusp      },
{   "ZEROP",            S, xzerop       },
{   "PLUSP",            S, xplusp       },
{   "EVENP",            S, xevenp       },
{   "ODDP",             S, xoddp        },
{   "EQ",               S, xeq          },
{   "EQL",              S, xeql         },
{   "EQUAL",            S, xequal       },

	/* special forms */
{   "COND",             FM, xcond       },
{   "CASE",             FM, xcase       },
{   "AND",              FM, xand        },
{   "OR",               FM, xor         },
{   "LET",              FM, xlet        },
{   "LET*",             FM, xletstar    },
{   "IF",               FM, xif         },
{   "PROG",             FM, xprog       },
{   "PROG*",            FM, xprogstar   },
{   "PROG1",            F, xprog1       },
{   "PROG2",            F, xprog2       },
{   "PROGN",            FM, xprogn      },
{   "GO",               F, xgo          },
{   "RETURN",           F, xreturn      },
{   "DO",               FM, xdo         },
{   "DO*",              FM, xdostar     },
{   "DOLIST",           FM, xdolist     },
{   "DOTIMES",          FM, xdotimes    },
{   "CATCH",            FM, xcatch      },
{   "THROW",            F, xthrow       },
	
	/* debugging and error handling functions */
{   "ERROR",            S, xerror       },
{   "CERROR",           S, xcerror      },
{   "BREAK",            S, xbreak       },
{   "CLEAN-UP",         S, xcleanup     },
{   "TOP-LEVEL",        S, xtoplevel    },
{   "CONTINUE",         S, xcontinue    },
{   "ERRSET",           F, xerrset      },
{   "BAKTRACE",         S, xbaktrace    },
{   "EVALHOOK",         SM, xevalhook   },

	/* arithmetic functions */
{   "TRUNCATE",         SM, xfix        },
{   "FLOAT",            S, xfloat       },
{   "+",                S, xadd         },
{   "-",                S, xsub         },
{   "*",                S, xmul         },
{   "/",                S, xdiv         },
{   "1+",               S, xadd1        },
{   "1-",               S, xsub1        },
{   "REM",              S, xrem         },
{   "MIN",              S, xmin         },
{   "MAX",              S, xmax         },
{   "ABS",              S, xabs         },
{   "SIN",              S, xsin         },
{   "COS",              S, xcos         },
{   "TAN",              S, xtan         },
{   "EXPT",             S, xexpt        },
{   "EXP",              S, xexp         },
{   "SQRT",             S, xsqrt        },
{   "RANDOM",           S, xrand        },
			
	/* bitwise logical functions */
{   "LOGAND",           S, xlogand      },
{   "LOGIOR",           S, xlogior      },
{   "LOGXOR",           S, xlogxor      },
{   "LOGNOT",           S, xlognot      },
#ifdef BIGNUMS
{   "LOGEQV",           S, xlogeqv	},
{   "LOGNAND",	        S, xlognand	},
{   "LOGNOR",		S, xlognor	},
{   "LOGANDC1",		S, xlogandc1	},
{   "LOGANDC2",		S, xlogandc2	},
{   "LOGORC1",		S, xlogorc1	},
{   "LOGORC2",		S, xlogorc2	},
{   "LOGTEST",		S, xlogtest	},
{   "LOGBITP",		S, xlogbitp	},
{   "LOGCOUNT",		S, xlogcount	},
{   "INTEGER-LENGTH",	S, xintlen	},
#else
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
#endif
{   "ASH",              S, xash         },

	/* numeric comparison functions */
{   "<",                S, xlss         },
{   "<=",               S, xleq         },
{   "=",                S, xequ         },
{   "/=",               S, xneq         },
{   ">=",               S, xgeq         },
{   ">",                S, xgtr         },
			
	/* string functions */
{   "CONCATENATE",      S, xconcatenate },
{   "SUBSEQ",           S, xsubseq      },
{   "STRING",           S, xstring      },
{   "CHAR",             S, xchar        },

	/* I/O functions */
{   "READ",             S, xread        },
{   "READ-PRESERVING-WHITESPACE",S, xreadpw     },
{   "PRINT",            S, xprint       },
{   "PRIN1",            S, xprin1       },
{   "PRINC",            S, xprinc       },
{   "TERPRI",           S, xterpri      },
{   "FLATSIZE",         S, xflatsize    },
{   "FLATC",            S, xflatc       },
			
	/* file I/O functions */
{   "OPEN",             S, xopen        },
{   "FORMAT",           S, xformat      },
{   "CLOSE",            S, xclose       },
{   "READ-CHAR",        S, xrdchar      },
{   "PEEK-CHAR",        S, xpkchar      },
{   "WRITE-CHAR",       S, xwrchar      },
{   "READ-LINE",        S, xreadline    },
{   "UNREAD-CHAR",      S, xunrdchar    },

	/* system functions */
{   "LOAD",             S, xload        },
{   "DRIBBLE",          S, xtranscript  },
{   "SYSTEM::ENABLE-INTERRUPTS",S, xenablintr },

/* functions specific to xldmem.c */
{   "GC",               S, xgc          },
{   "EXPAND",           S, xexpand      },
{   "ALLOC",            S, xalloc       },
{   "ROOM",             S, xmem         },
{   "REGISTER-FINALIZER",S, xregfinal    },
{   "MAKE-WEAK-BOX",    S, xmkweakbox   },
{   "WEAK-BOX-VALUE",   S, xweakboxval  },
#ifdef SAVERESTORE
{   "SAVE",             S, xsave        },
{   "RESTORE",          S, xrestore     },
#else
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
#endif
/* end of functions specific to xldmem.c */

{   "TYPE-OF",          S, xtype        },
{   "EXIT",             S, xexit        },
{   "PEEK",             S, xpeek        },
{   "POKE",             S, xpoke        },
{   "ADDRESS-OF",       S, xaddrs       },
{   "SYSTEM:POINTER-ADDRESS", S, xnpaddr },
{   "SYSTEM:POINTER-PROTECTED", S, xnpprot },
{   "SYSTEM:POINTER-INCREMENT", S, xnpincr },

	/* new functions and special forms */
{   "VECTOR",           S, xvector      },
{   "BLOCK",            FM, xblock      },
{   "RETURN-FROM",      F, xrtnfrom     },
{   "TAGBODY",          F, xtagbody     },
{   "PSETQ",            F, xpsetq       },
{   "PSETF",            F, xpsetf       },
{   "FLET",             FM, xflet       },
{   "LABELS",           FM, xlabels     },
{   "MACROLET",         FM, xmacrolet   },
{   "UNWIND-PROTECT",   FM, xunwindprotect},
{   "PPRINT",           SM, xpp         },
{   "STRING<",          S, xstrlss      },
{   "STRING<=",         S, xstrleq      },
{   "STRING=",          S, xstreql      },
{   "STRING/=",         S, xstrneq      },
{   "STRING>=",         S, xstrgeq      },
{   "STRING>",          S, xstrgtr      },
{   "STRING-LESSP",     S, xstrilss     },
{   "STRING-NOT-GREATERP",S,xstrileq    },
{   "STRING-EQUAL",     S, xstrieql     },
{   "STRING-NOT-EQUAL", S, xstrineq     },
{   "STRING-NOT-LESSP", S, xstrigeq     },
{   "STRING-GREATERP",  S, xstrigtr     },
{   "INTEGERP",         S, xintegerp    },
{   "FLOATP",           S, xfloatp      },
{   "STRINGP",          S, xstringp     },
{   "ARRAYP",           S, xarrayp      },
{   "STREAMP",          S, xstreamp     },
{   "OBJECTP",          S, xobjectp     },
{   "STRING-UPCASE",    S, xupcase      },
{   "STRING-DOWNCASE",  S, xdowncase    },
{   "STRING-CAPITALIZE",S, xcapcase     },
{   "NSTRING-UPCASE",   S, xnupcase     },
{   "NSTRING-DOWNCASE", S, xndowncase   },
{   "NSTRING-CAPITALIZE",S, xncapcase   },
{   "STRING-TRIM",      S, xtrim        },
{   "STRING-LEFT-TRIM", S, xlefttrim    },
{   "STRING-RIGHT-TRIM",S, xrighttrim   },
{   "WHEN",             FM, xwhen       },
{   "UNLESS",           FM, xunless     },
{   "LOOP",             FM, xloop       },
{   "SYMBOL-FUNCTION",  S, xsymfunction },
{   "FBOUNDP",          S, xfboundp     },
{   "SEND",             SM, xsend       },
{   "SEND-SUPER",       SM, xsendsuper  },
{   "PROGV",            FM, xprogv      },
{   "CHARACTERP",       S, xcharp       },
{   "CHAR-INT",         S, xcharint     },
{   "INT-CHAR",         S, xintchar     },
{   "READ-BYTE",        S, xrdbyte      },
{   "WRITE-BYTE",       S, xwrbyte      },
{   "MAKE-STRING-INPUT-STREAM", S, xmkstrinput      },
{   "MAKE-STRING-OUTPUT-STREAM",S, xmkstroutput     },
{   "GET-OUTPUT-STREAM-STRING", S, xgetstroutput    },
{   "GET-OUTPUT-STREAM-LIST",   S, xgetlstoutput    },
{   "GCD",              S, xgcd         },
{   "FUNCTION-LAMBDA-EXPRESSION",    SM, xgetlambda       },
{   "MACROEXPAND",      SM, xmacroexpand },
{   "MACROEXPAND-1",    SM,x1macroexpand},
{   "MACRO-FUNCTION",   S, xmacrofun    },
{   "CHAR<",            S, xchrlss      },
{   "CHAR<=",           S, xchrleq      },
{   "CHAR=",            S, xchreql      },
{   "CHAR/=",           S, xchrneq      },
{   "CHAR>=",           S, xchrgeq      },
{   "CHAR>",            S, xchrgtr      },
{   "CHAR-LESSP",       S, xchrilss     },
{   "CHAR-NOT-GREATERP",S, xchrileq     },
{   "CHAR-EQUAL",       S, xchrieql     },
{   "CHAR-NOT-EQUAL",   S, xchrineq     },
{   "CHAR-NOT-LESSP",   S, xchrigeq     },
{   "CHAR-GREATERP",    S, xchrigtr     },
{   "UPPER-CASE-P",     S, xuppercasep  },
{   "LOWER-CASE-P",     S, xlowercasep  },
{   "BOTH-CASE-P",      S, xbothcasep   },
{   "DIGIT-CHAR-P",     S, xdigitp      },
{   "ALPHANUMERICP",    S, xalphanumericp},
{   "ALPHA-CHAR-P",     S, xalphacharp  },
{   "CHAR-UPCASE",      S, xchupcase    },
{   "CHAR-DOWNCASE",    S, xchdowncase  },
{   "DIGIT-CHAR",       S, xdigitchar   },
{   "CHAR-CODE",        S, xcharcode    },
{   "CODE-CHAR",        S, xcodechar    },
{   "ENDP",             S, xendp        },
{   "REMOVE-IF",        S, xremif       },
{   "REMOVE-IF-NOT",    S, xremifnot    },
{   "DELETE-IF",        S, xdelif       },
{   "DELETE-IF-NOT",    S, xdelifnot    },
{   "TRACE",            F, xtrace       },
{   "UNTRACE",          F, xuntrace     },
{   "SORT",             S, xsort        },
{   "STABLE-SORT",      S, xsort        },
#ifdef SUBSTITUTE
{   "SUBSTITUTE",               S, xsubstitute  },
{   "SUBSTITUTE-IF",            S, xsubstituteif},
{   "SUBSTITUTE-IF-NOT",        S, xsubstituteifnot},
{   "NSUBSTITUTE",              S, xnsubstitute },
{   "NSUBSTITUTE-IF",           S, xnsubstituteif},
{   "NSUBSTITUTE-IF-NOT",       S, xnsubstituteifnot},
#else
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
#endif
#ifdef TIMES
{   "TIME",             FM, xtime       },
{   "GET-INTERNAL-RUN-TIME",    S, xruntime  },
{   "GET-INTERNAL-REAL-TIME",   S, xrealtime },
{   "GET-INTERNAL-GC-TIME",     S, xgctime   },
#else
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
#endif
	/* extra table entries */
#ifdef POSFCNS
{   "COUNT",            S, xcount       },
{   "FIND",             S, xfind        },
{   "POSITION",         S, xposition    },
{   "COUNT-IF",         S, xcountif     },
{   "FIND-IF",          S, xfindif      },
{   "POSITION-IF",      S, xpositionif  },
{   "COUNT-IF-NOT",     S, xcountifnot  },
{   "FIND-IF-NOT",      S, xfindifnot   },
{   "POSITION-IF-NOT",  S, xpositionifnot },
#else
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
#endif
{   "COERCE",           S, xcoerce      },
{   "ELT",              S, xelt         },
#ifdef SRCHFCN
{   "SEARCH",           S, xsearch      },
#else
{   NULL,               S, xnotimp      },
#endif
#ifdef MAPFCNS
{   "MAP",              S, xmap         },
{   "MAP-INTO",         S, xmapinto     },
{   "SOME",             S, xsome        },
{   "EVERY",            S, xevery       },
{   "NOTANY",           S, xnotany      },
{   "NOTEVERY",         S, xnotevery    },
#else
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
#endif
{   "REPLACE",		S, xreplace	},
{   "SYSTEM:TYPED-VECTOR-ELEMENT-SIZE",S, xtveceltsize	},
{   "FILE-POSITION",    S, xfileposition},
{   "FILE-LENGTH",      S, xfilelength  },
{   "FRESH-LINE",       S, xfreshline   },
{   "OPEN-STREAM-P",    S, xopenstreamp },
{   "INPUT-STREAM-P",   S, xinputstreamp},
{   "OUTPUT-STREAM-P",  S, xoutputstreamp},
#ifdef FILETABLE
{   "TRUENAME",         S, xtruename    },
{   "DELETE-FILE",      S, xdeletefile  },
{   "FILE-WRITE-DATE",  S, xfilemtime   },
{   "RENAME-FILE",      S, xrenamefile  },
{   "SYSTEM::BASE-DIRECTORY",S, xbasedir     },
{   "SYSTEM::FILE-TYPE",S, xfiletype    },
#else
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
#endif
{   "DEFSTRUCT",        F, xdefstruct   },
{   "%STRUCT-TYPE-P",   S, xstrtypep    },
{   "%MAKE-STRUCT",     S, xmkstruct    },
{   "%COPY-STRUCT",     S, xcpystruct   },
{   "%STRUCT-REF",      S, xstrref      },
{   "%STRUCT-SET",      S, xstrset      },
{   "ASIN",             S, xasin        },
{   "ACOS",             S, xacos        },
{   "ATAN",             S, xatan        },
#ifdef APPLYHOOK
{   "APPLYHOOK",        SM, xapplyhook  },
#else
{   NULL,               S, xnotimp      },
#endif
{   "NREVERSE",         S, xnreverse    },
{   "BUTLAST",          S, xbutlast     },
{   "TYPEP",            S, xtypep       },
#ifdef REDUCE
{   "REDUCE",           S, xreduce      },
#else
{   NULL,               S, xnotimp      },
#endif
#ifdef REMDUPS
{   "REMOVE-DUPLICATES",S, xremove_duplicates },
{   "DELETE-DUPLICATES",S, xremove_duplicates },
#else
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
#endif

#ifdef SETS
{   "ADJOIN",           S, xadjoin          },
{   "UNION",            S, xunion           },
{   "INTERSECTION",     S, xintersection    },
{   "SET-DIFFERENCE",   S, xset_difference  },
{   "SUBSETP",          S, xsubsetp         },
#else
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
#endif

#ifdef HASHFCNS
{   "GETHASH",          SM, xgethash        },
{   "REMHASH",          S, xremhash         },
{   "MAKE-HASH-TABLE",  S, xmakehash        },
{   "CLRHASH",          S, xclrhash         },
{   "MAPHASH",          S, xmaphash         },
{   "HASH-TABLE-COUNT", S, xhashcount       },
{   "HASH-TABLE-P",     S, xhashtablep      },
{   "HASH-TABLE-TEST",  S, xhashtablefun    },
{   "HASH-TABLE-SIZE",  S, xhashtablesize   },
{   "HASH-TABLE-REHASH-THRESHOLD", S, xhashtablerhthresh },
{   "HASH-TABLE-REHASH-SIZE", S, xhashtablerhsize },
#else
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
#endif

{   "COMPLEXP",         S, xcomplexp        },
{   "COMPLEX",          S, xcomplex         },
{   "CONJUGATE",        S, xconjugate       },
{   "REALPART",         S, xrealpart        },
{   "IMAGPART",         S, ximagpart        },
{   "LOG",              S, xlog             },
{   "FLOOR",            SM, xfloor          },
{   "CEILING",          SM, xceil           },
{   "ROUND",            SM, xround          },
{   "PHASE",            S, xphase           },
{   "LCM",              S, xlcm             },
{   "MOD",              S, xmod             },

#ifdef BIGNUMS
{   "FTRUNCATE",        S, xffix            },
{   "FFLOOR",           S, xffloor          },
{   "FCEILING",         S, xfceil           },
{   "FROUND",           S, xfround          },
{   "RATIONALP",        S, xrationalp       },
{   "NUMERATOR",        S, xnumerator       },
{   "DENOMINATOR",      S, xdenominator     },
{   "RATIONAL",         S, xrational        },
#else
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
#endif

{   "DEFCONSTANT",      F, xdefconstant     },
{   "CONSTANTP",        S, xconstantp       },
{   "DEFPARAMETER",     F, xdefparameter    },
{   "DEFVAR",           F, xdefvar          },
{   "MAKUNBOUND",       S, xmakunbound      },
{   "FMAKUNBOUND",      S, xfmakunbound     },
{   "SPECIALP",         S, xspecialp        },
{   "MARK-AS-SPECIAL",  S, xmarkspecial     },
{   "MAKE-LIST",        S, xmklist          },
{   "FORCE-OUTPUT",     S, xforceoutput     },

{   "TOP-LEVEL-LOOP",   S, xtoplevelloop    },
{   "RESET-SYSTEM",     S, xresetsystem     },

#ifdef STSZ
{   "SET-STACK-MARK",   S, xsetmark     },
#else
{   NULL,               S, xnotimp      },
#endif

{   "ARRAY-IN-BOUNDS-P",     S, xarrayinboundsp     },
{   "ARRAY-DIMENSIONS",      S, xarraydimensions    },
{   "ARRAY-RANK",            S, xarrayrank          },
{   "ARRAY-TOTAL-SIZE",      S, xarraytotalsize     },
{   "ARRAY-DIMENSION",       S, xarraydimension     },
{   "ARRAY-ROW-MAJOR-INDEX", S, xarrayrowmajorindex },
{   "ROW-MAJOR-AREF",        S, xrowmajoraref       },
{   "ARRAY-ELEMENT-TYPE",    S, xarrayelementtype   },

#ifdef PACKAGES
{   "MAKE-PACKAGE",          S, xmakepackage        },
{   "IN-PACKAGE",            F, xinpackage          },
{   "EXPORT",                S, xexport             },
{   "UNEXPORT",              S, xunexport           },
{   "IMPORT",                S, ximport             },
{   "SYMBOL-PACKAGE",        S, xsympackage         },
{   "USE-PACKAGE",           S, xusepackage         },
{   "UNUSE-PACKAGE",         S, xunusepackage       },
{   "PACKAGE-USE-LIST",      S, xpackageuselist     },
{   "PACKAGE-USED-BY-LIST",  S, xpackageusedbylist  },
{   "PACKAGE-SHADOWING-SYMBOLS", S, xpackageshadows },
{   "PACKAGE-NAME",          S, xpackagename        },
{   "PACKAGE-NICKNAMES",     S, xpackagenicknames   },
{   "PACKAGE-OBARRAY",       S, xpackageobarray     },
{   "PACKAGE-VALID-P",       S, xpackagevalidp      },
{   "LIST-ALL-PACKAGES",     S, xlistallpackages    },
{   "UNINTERN",              S, xunintern           },
{   "SHADOW",                S, xshadow             },
{   "SHADOWING-IMPORT",      S, xshadowingimport    },
{   "FIND-PACKAGE",          S, xfindpackage        },
{   "FIND-SYMBOL",           SM, xfindsymbol        },
{   "DELETE-PACKAGE",        S, xdeletepackage      },
{   "RENAME-PACKAGE",        S, xrenamepackage      },
{   "FIND-ALL-SYMBOLS",      S, xfindallsymbols     },
#else
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
#endif /* PACKAGES */
#ifdef MULVALS
{   "VALUES",                SM, xvalues            },
{   "MULTIPLE-VALUE-CALL",   FM, xmulvalcall        },
{   "MULTIPLE-VALUE-PROG1",  FM, xmulvalprog1       },
{   "NTH-VALUE",             F, xnthvalue           },
#else
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
#endif /* MULVALUES */
{   "FUNCTIONP",        S, xfunctionp   },

{   "COPY-LIST",        S, xcopyseq     },
{   "COPY-SEQ",         S, xcopyseq     },
#ifdef CONDITIONS
{   "SIGNAL",           S, xsignal      },
{   "WARN",             S, xwarn        },
{   "INVOKE-DEBUGGER",  S, xdebug       },
{   "STACK-VALUE",      S, xstackval    },
#else
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
#endif /* CONDITIONS */
#if (defined(TIMES) && defined(MULVALS) && defined(BIGNUMS))
{   "GET-DECODED-TIME", SM, xgetdectime },
#else
{   NULL,               S, xnotimp      },
#endif
{   "MAKE-STRING",      S, xmkstring    },
{   "MAKE-RANDOM-STATE",S, xmkrndstate  },
{   "RANDOM-STATE-P",   S, xrndstatep   },

#ifdef BYTECODE
{   "MAKE-BYTE-CODE",	S, xlmakebcode	},
{   "BYTE-CODE-CLOSE",	S, xlbcclose	},
{   "DYNAMIC-VALUE",	S, xldval	},
{   "GET-LAMBDA-NAME",	S, xlgetlambdaname},
{   "COERCE-TO-MACRO",	S, xlcoercemacro},
{   "MAKE-CPS-NODE",	S, xlmakecpsnode},
{   "CPS-NODE-INTERNAL",S, xlcpsinternal},
{   "CPS-NODE-TRANSFORM",S, xlcpstransform},
{   "CPS-LEAF-NODE-P",	S, xlcpsleafnodep},
{   "CPS-LAMBDA-NODE-P",S, xlcpslambdanodep},
{   "CPS-CALL-NODE-P",	S, xlcpscallnodep},
{   "CPS-ANY-REFERENCES-P",S, xlcpsanyrefs},
{   "CPS-FIND-REFERENCES",S, xlcpsfindrefs},
{   "CPS-NODE-CHILDREN",S, xlcpsnodechildren},
{   "CPS-NODE-PARENT",	S, xlcpsnodeparent},
{   "CPS-NODE-SIMPLIFIED-P",S, xlcpsnodesimplified},
{   "CPS-NODE-NOTE",	S, xlcpsnodenote},
{   "CPS-LEAF-NODE-VALUE",S, xlcpsleafnodevalue},
{   "CPS-LEAF-NODE-COUNT",S, xlcpsleafnodecount},
{   "CPS-LAMBDA-NODE-ARGLIST",S, xlcpslambdanodearglist},
{   "CPS-LAMBDA-NODE-LAMBDA-LIST",S, xlcpslambdanodelambdalist},
{   "CPS-LAMBDA-NODE-NAME",S, xlcpslambdanodename},
{   "CPS-SET-NODE-CHILDREN",	S, xlcpssetnodechildren		},
{   "CPS-SET-NODE-PARENT",		S, xlcpssetnodeparent		},
{   "CPS-SET-NODE-SIMPLIFIED",	S, xlcpssetnodesimplified	},
{   "CPS-SET-NODE-NOTE",		S, xlcpssetnodenote		},
{   "CPS-SET-LEAF-NODE-VALUE",	S, xlcpssetleafnodevalue	},
{   "CPS-SET-LEAF-NODE-COUNT",	S, xlcpssetleafnodecount	},
{   "CPS-SET-LAMBDA-NODE-ARGLIST",	S, xlcpssetlambdanodearglist	},
{   "CPS-SET-LAMBDA-NODE-LAMBDA-LIST",S, xlcpssetlambdanodelambdalist},
{   "CPS-SET-LAMBDA-NODE-NAME",	S, xlcpssetlambdanodename	},
{   "CPS-LAMBDA-NODE-BODY",		S, xlcpslambdanodebody		},
{   "CPS-CALL-NODE-FUNCTION",	S, xlcpscallnodefunction	},
{   "CPS-CALL-NODE-ARGS",		S, xlcpscallnodeargs		},
{   "%SET-GET",         S, xsetget      },
{   "%SET-SYMBOL-VALUE", S, xsetsymval   },
{   "%SET-SYMBOL-FUNCTION", S, xsetsymfun },
{   "%SET-SYMBOL-PLIST", S, xsetsymplist },
{   "%SET-AREF",        S, xsetaref     },
{   "%SET-GETHASH",     S, xsetgethash  },
{   "%SET-CAR",     S, xsetcar  },
{   "%SET-CDR",     S, xsetcdr  },
{   "%SET-NTH",     S, xsetnth  },
{   "%SET-ELT",     S, xsetelt  },
{   "%SET-SVREF",     S, xsetsvref  },
#else
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
#endif /* BYTECODE */

{	"GET-WORKING-DIRECTORY",	S, xgetwd			},
{	"SET-WORKING-DIRECTORY",	S, xsetwd			},

#ifdef SHAREDLIBS
{   "SHARED-LIBRARY::SHLIB-OPEN",               S, xshlibopen      },
{   "SHARED-LIBRARY::SHLIB-SYMADDR",            S, xshlibsymaddr   },
{   "SHARED-LIBRARY::SHLIB-CLOSE",              S, xshlibclose     },
{   "SHARED-LIBRARY::CALL-BY-ADDRESS",          S, xshlibcalladdr  },
#ifdef _Windows
{   "SHARED-LIBRARY::STDCALL-BY-ADDRESS",       S, xshlibstdcalladdr},
#else
{   NULL,                                       S, xnotimp         },
#endif
{   "ARRAY-DATA-ADDRESS",                       S, xarraydata_addr },
{   "SHARED-LIBRARY::MAKE-SUBR",                S, xmakesubr       },
{   "SHARED-LIBRARY::CLEAR-SUBR",               S, xclearsubr      },
{   "SHARED-LIBRARY::SHLIB-INIT",               S, xshlibinit      },
{   "SHARED-LIBRARY::SHLIB-INFO",               S, xshlibinfo      },
{   "SYSTEM:CPTR-PROTECT",                      S, xcptrprotect    },
#else
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
#endif /* SHAREDLIBS */

{   "LOCALLY",          FM, xprogn      },
{   "THE",              FM, xthe        },
{   "SYMBOL-MACROLET",  FM, xsymaclet   },
{   "XLISP::INSTALL-FUNCTION", S, xinstallfun},

	/* extra table entries */
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },
{   NULL,               S, xnotimp      },

    /* include system dependent function pointers */
#include "osptrs.h"
    /* Two patches here to promote module portability to xscheme:*/
    /* $putpatch.c$: "MODULE_XLFTAB_C_FUNTAB_S" */
    /* $putpatch.c$: "MODULE_XLFTAB_C_FUNTAB_F" */
{0,0,0} /* end of table marker */

};			

int ftabsize = sizeof(funtab); /* TAA MOD -- added validity check */