home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / zip / language / xlisp_21.zoo / xlftab.c < prev    next >
C/C++ Source or Header  |  1990-02-28  |  17KB  |  460 lines
  1. /* xlftab.c - xlisp function table */
  2. /*    Copyright (c) 1985, by David Michael Betz
  3.     All Rights Reserved
  4.     Permission is granted for unrestricted non-commercial use    */
  5.  
  6. #include "xlisp.h"
  7.  
  8. /* external functions */
  9. extern LVAL
  10.     xbisubr(),xbifsubr(),
  11.     rmhash(),rmquote(),rmdquote(),rmbquote(),rmcomma(),
  12.     clnew(),clisnew(),clanswer(),
  13.     obisnew(),obclass(),obshow(),
  14.     rmlpar(),rmrpar(),rmsemi(),
  15.     xeval(),xapply(),xfuncall(),xquote(),xfunction(),xbquote(),
  16.     xlambda(),xset(),xsetq(),xsetf(),xdefun(),xdefmacro(),
  17.     xgensym(),xmakesymbol(),xintern(),
  18.     xsymname(),xsymvalue(),xsymplist(),
  19.     xget(),xputprop(),xremprop(),
  20.     xhash(),xmkarray(),xaref(),
  21.     xcar(),xcdr(),
  22.     xcaar(),xcadr(),xcdar(),xcddr(),
  23.     xcaaar(),xcaadr(),xcadar(),xcaddr(),
  24.     xcdaar(),xcdadr(),xcddar(),xcdddr(),
  25.     xcaaaar(),xcaaadr(),xcaadar(),xcaaddr(),
  26.     xcadaar(),xcadadr(),xcaddar(),xcadddr(),
  27.     xcdaaar(),xcdaadr(),xcdadar(),xcdaddr(),
  28.     xcddaar(),xcddadr(),xcdddar(),xcddddr(),
  29.     xcons(),xlist(),xappend(),xreverse(),xlast(),xnth(),xnthcdr(),
  30.     xmember(),xassoc(),xsubst(),xsublis(),xlength(),xsort(),
  31.     xremove(),xremif(),xremifnot(),
  32.     xmapc(),xmapcar(),xmapl(),xmaplist(),
  33.     xrplca(),xrplcd(),xnconc(),
  34.     xdelete(),xdelif(),xdelifnot(),
  35.     xatom(),xsymbolp(),xnumberp(),xboundp(),xnull(),xlistp(),xendp(),xconsp(),
  36.     xeq(),xeql(),xequal(),
  37.     xcond(),xcase(),xand(),xor(),xlet(),xletstar(),xif(),
  38.     xprog(),xprogstar(),xprog1(),xprog2(),xprogn(),xgo(),xreturn(),
  39.     xcatch(),xthrow(),
  40.     xerror(),xcerror(),xbreak(),
  41.     xcleanup(),xtoplevel(),xcontinue(),xerrset(),
  42.     xbaktrace(),xevalhook(),
  43.     xdo(),xdostar(),xdolist(),xdotimes(),
  44.     xminusp(),xzerop(),xplusp(),xevenp(),xoddp(),
  45.     xfix(),xfloat(),
  46.     xgcd(),xadd(),xsub(),xmul(),xdiv(),xrem(),xmin(),xmax(),xabs(),
  47.     xadd1(),xsub1(),xlogand(),xlogior(),xlogxor(),xlognot(),
  48.     xsin(),xcos(),xtan(),xexpt(),xexp(),xsqrt(),xrand(),
  49.     xlss(),xleq(),xequ(),xneq(),xgeq(),xgtr(),
  50.     xstrcat(),xsubseq(),xstring(),xchar(),
  51.     xread(),xprint(),xprin1(),xprinc(),xterpri(),
  52.     xflatsize(),xflatc(),
  53.     xopen(),xclose(),xrdchar(),xpkchar(),xwrchar(),xreadline(),
  54.     xload(),xtranscript(),
  55.     xtype(),xexit(),xpeek(),xpoke(),xaddrs(),
  56.     xvector(),xblock(),xrtnfrom(),xtagbody(),
  57.     xpsetq(),xflet(),xlabels(),xmacrolet(),xunwindprotect(),xpp(),
  58.     xstrlss(),xstrleq(),xstreql(),xstrneq(),xstrgeq(),xstrgtr(),
  59.     xstrilss(),xstrileq(),xstrieql(),xstrineq(),xstrigeq(),xstrigtr(),
  60.     xupcase(),xdowncase(),xnupcase(),xndowncase(),
  61.     xtrim(),xlefttrim(),xrighttrim(),
  62.     xuppercasep(),xlowercasep(),xbothcasep(),xdigitp(),xalphanumericp(),
  63.     xcharcode(),xcodechar(),xchupcase(),xchdowncase(),xdigitchar(),
  64.     xchrlss(),xchrleq(),xchreql(),xchrneq(),xchrgeq(),xchrgtr(),
  65.     xchrilss(),xchrileq(),xchrieql(),xchrineq(),xchrigeq(),xchrigtr(),
  66.     xintegerp(),xfloatp(),xstringp(),xarrayp(),xstreamp(),xobjectp(),
  67.     xwhen(),xunless(),xloop(),
  68.     xsymfunction(),xfboundp(),xsend(),xsendsuper(),
  69.     xprogv(),xrdbyte(),xwrbyte(),xformat(),
  70.     xcharp(),xcharint(),xintchar(),
  71.     xmkstrinput(),xmkstroutput(),xgetstroutput(),xgetlstoutput(),
  72.     xgetlambda(),xmacroexpand(),x1macroexpand(),
  73.     xtrace(),xuntrace(),
  74.     xdefstruct(),xmkstruct(),xcpystruct(),xstrref(),xstrset(),xstrtypep(),
  75.     xasin(),xacos(),xatan();
  76.  
  77. /* functions specific to xldmem.c */
  78. LVAL xgc(),xexpand(),xalloc(),xmem();
  79. #ifdef SAVERESTORE
  80. LVAL xsave(),xrestore();
  81. #endif
  82.  
  83. /* include system dependant definitions */
  84. #include "osdefs.h"
  85.  
  86. /* SUBR/FSUBR indicator */
  87. #define S    SUBR
  88. #define F    FSUBR
  89.  
  90. /* forward declarations */
  91. LVAL xnotimp();
  92.  
  93. /* the function table */
  94. FUNDEF funtab[] = {
  95.  
  96.     /* read macro functions */
  97. {    NULL,                S, rmhash        }, /*   0 */
  98. {    NULL,                S, rmquote        }, /*   1 */
  99. {    NULL,                S, rmdquote        }, /*   2 */
  100. {    NULL,                S, rmbquote        }, /*   3 */
  101. {    NULL,                S, rmcomma        }, /*   4 */
  102. {    NULL,                S, rmlpar        }, /*   5 */
  103. {    NULL,                S, rmrpar        }, /*   6 */
  104. {    NULL,                S, rmsemi        }, /*   7 */
  105. {    NULL,                S, xnotimp        }, /*   8 */
  106. {    NULL,                S, xnotimp        }, /*   9 */
  107.  
  108.     /* methods */
  109. {    NULL,                S, clnew        }, /*  10 */
  110. {    NULL,                S, clisnew        }, /*  11 */
  111. {    NULL,                S, clanswer        }, /*  12 */
  112. {    NULL,                S, obisnew        }, /*  13 */
  113. {    NULL,                S, obclass        }, /*  14 */
  114. {    NULL,                S, obshow        }, /*  15 */
  115. {    NULL,                S, xnotimp        }, /*  16 */
  116. {    NULL,                S, xnotimp        }, /*  17 */
  117. {    NULL,                S, xnotimp        }, /*  18 */
  118. {    NULL,                S, xnotimp        }, /*  19 */
  119.  
  120.     /* evaluator functions */
  121. {    "EVAL",                S, xeval        }, /*  20 */
  122. {    "APPLY",            S, xapply        }, /*  21 */
  123. {    "FUNCALL",            S, xfuncall        }, /*  22 */
  124. {    "QUOTE",            F, xquote        }, /*  23 */
  125. {    "FUNCTION",            F, xfunction        }, /*  24 */
  126. {    "BACKQUOTE",            F, xbquote        }, /*  25 */
  127. {    "LAMBDA",            F, xlambda        }, /*  26 */
  128.  
  129.     /* symbol functions */
  130. {    "SET",                S, xset            }, /*  27 */
  131. {    "SETQ",                F, xsetq        }, /*  28 */
  132. {    "SETF",                F, xsetf        }, /*  29 */
  133. {    "DEFUN",            F, xdefun        }, /*  30 */
  134. {    "DEFMACRO",            F, xdefmacro        }, /*  31 */
  135. {    "GENSYM",            S, xgensym        }, /*  32 */
  136. {    "MAKE-SYMBOL",            S, xmakesymbol        }, /*  33 */
  137. {    "INTERN",             S, xintern        }, /*  34 */
  138. {    "SYMBOL-NAME",            S, xsymname        }, /*  35 */
  139. {    "SYMBOL-VALUE",            S, xsymvalue        }, /*  36 */
  140. {    "SYMBOL-PLIST",            S, xsymplist        }, /*  37 */
  141. {    "GET",                S, xget            }, /*  38 */
  142. {    "PUTPROP",             S, xputprop        }, /*  39 */
  143. {    "REMPROP",            S, xremprop        }, /*  40 */
  144. {    "HASH",                S, xhash        }, /*  41 */
  145.  
  146.     /* array functions */
  147. {    "MAKE-ARRAY",            S, xmkarray        }, /*  42 */
  148. {    "AREF",                S, xaref        }, /*  43 */
  149.             
  150.     /* list functions */
  151. {    "CAR",                S, xcar            }, /*  44 */
  152. {    "CDR",                S, xcdr            }, /*  45 */
  153.             
  154. {    "CAAR",                S, xcaar        }, /*  46 */
  155. {    "CADR",                S, xcadr        }, /*  47 */
  156. {    "CDAR",                S, xcdar        }, /*  48 */
  157. {    "CDDR",                S, xcddr        }, /*  49 */
  158.  
  159. {    "CAAAR",            S, xcaaar        }, /*  50 */
  160. {    "CAADR",            S, xcaadr        }, /*  51 */
  161. {    "CADAR",            S, xcadar        }, /*  52 */
  162. {    "CADDR",            S, xcaddr        }, /*  53 */
  163. {    "CDAAR",            S, xcdaar        }, /*  54 */
  164. {    "CDADR",            S, xcdadr        }, /*  55 */
  165. {    "CDDAR",            S, xcddar        }, /*  56 */
  166. {    "CDDDR",            S, xcdddr        }, /*  57 */
  167.  
  168. {    "CAAAAR",             S, xcaaaar        }, /*  58 */
  169. {    "CAAADR",            S, xcaaadr        }, /*  59 */
  170. {    "CAADAR",            S, xcaadar        }, /*  60 */
  171. {    "CAADDR",            S, xcaaddr        }, /*  61 */
  172. {    "CADAAR",             S, xcadaar        }, /*  62 */
  173. {    "CADADR",            S, xcadadr        }, /*  63 */
  174. {    "CADDAR",            S, xcaddar        }, /*  64 */
  175. {    "CADDDR",            S, xcadddr        }, /*  65 */
  176. {    "CDAAAR",            S, xcdaaar        }, /*  66 */
  177. {    "CDAADR",            S, xcdaadr        }, /*  67 */
  178. {    "CDADAR",            S, xcdadar        }, /*  68 */
  179. {    "CDADDR",            S, xcdaddr        }, /*  69 */
  180. {    "CDDAAR",            S, xcddaar        }, /*  70 */
  181. {    "CDDADR",            S, xcddadr        }, /*  71 */
  182. {    "CDDDAR",            S, xcdddar        }, /*  72 */
  183. {    "CDDDDR",            S, xcddddr        }, /*  73 */
  184.  
  185. {    "CONS",                S, xcons        }, /*  74 */
  186. {    "LIST",                S, xlist        }, /*  75 */
  187. {    "APPEND",            S, xappend        }, /*  76 */
  188. {    "REVERSE",            S, xreverse        }, /*  77 */
  189. {    "LAST",                S, xlast        }, /*  78 */
  190. {    "NTH",                S, xnth            }, /*  79 */
  191. {    "NTHCDR",            S, xnthcdr        }, /*  80 */
  192. {    "MEMBER",            S, xmember        }, /*  81 */
  193. {    "ASSOC",            S, xassoc        }, /*  82 */
  194. {    "SUBST",             S, xsubst        }, /*  83 */
  195. {    "SUBLIS",            S, xsublis        }, /*  84 */
  196. {    "REMOVE",            S, xremove        }, /*  85 */
  197. {    "LENGTH",            S, xlength        }, /*  86 */
  198. {    "MAPC",                S, xmapc        }, /*  87 */
  199. {    "MAPCAR",            S, xmapcar        }, /*  88 */
  200. {    "MAPL",                S, xmapl        }, /*  89 */
  201. {    "MAPLIST",            S, xmaplist        }, /*  90 */
  202.             
  203.     /* destructive list functions */
  204. {    "RPLACA",            S, xrplca        }, /*  91 */
  205. {    "RPLACD",            S, xrplcd        }, /*  92 */
  206. {    "NCONC",            S, xnconc        }, /*  93 */
  207. {    "DELETE",            S, xdelete        }, /*  94 */
  208.  
  209.     /* predicate functions */
  210. {    "ATOM",                S, xatom        }, /*  95 */
  211. {    "SYMBOLP",            S, xsymbolp        }, /*  96 */
  212. {    "NUMBERP",            S, xnumberp        }, /*  97 */
  213. {    "BOUNDP",            S, xboundp         }, /*  98 */
  214. {    "NULL",                S, xnull        }, /*  99 */
  215. {    "LISTP",            S, xlistp        }, /* 100 */
  216. {    "CONSP",            S, xconsp        }, /* 101 */
  217. {    "MINUSP",            S, xminusp         }, /* 102 */
  218. {    "ZEROP",            S, xzerop        }, /* 103 */
  219. {    "PLUSP",            S, xplusp        }, /* 104 */
  220. {    "EVENP",            S, xevenp        }, /* 105 */
  221. {    "ODDP",                S, xoddp        }, /* 106 */
  222. {    "EQ",                S, xeq            }, /* 107 */
  223. {    "EQL",                S, xeql            }, /* 108 */
  224. {    "EQUAL",            S, xequal        }, /* 109 */
  225.  
  226.     /* special forms */
  227. {    "COND",                F, xcond        }, /* 110 */
  228. {    "CASE",                F, xcase        }, /* 111 */
  229. {    "AND",                F, xand            }, /* 112 */
  230. {    "OR",                F, xor            }, /* 113 */
  231. {    "LET",                F, xlet            }, /* 114 */
  232. {    "LET*",                F, xletstar        }, /* 115 */
  233. {    "IF",                F, xif            }, /* 116 */
  234. {    "PROG",                F, xprog        }, /* 117 */
  235. {    "PROG*",            F, xprogstar        }, /* 118 */
  236. {    "PROG1",            F, xprog1        }, /* 119 */
  237. {    "PROG2",            F, xprog2        }, /* 120 */
  238. {    "PROGN",            F, xprogn        }, /* 121 */
  239. {    "GO",                F, xgo            }, /* 122 */
  240. {    "RETURN",            F, xreturn          }, /* 123 */
  241. {    "DO",                F, xdo            }, /* 124 */
  242. {    "DO*",                F, xdostar          }, /* 125 */
  243. {    "DOLIST",            F, xdolist          }, /* 126 */
  244. {    "DOTIMES",            F, xdotimes        }, /* 127 */
  245. {    "CATCH",            F, xcatch        }, /* 128 */
  246. {    "THROW",            F, xthrow        }, /* 129 */
  247.     
  248.     /* debugging and error handling functions */
  249. {    "ERROR",            S, xerror        }, /* 130 */
  250. {    "CERROR",            S, xcerror          }, /* 131 */
  251. {    "BREAK",            S, xbreak        }, /* 132 */
  252. {    "CLEAN-UP",            S, xcleanup        }, /* 133 */
  253. {    "TOP-LEVEL",            S, xtoplevel        }, /* 134 */
  254. {    "CONTINUE",            S, xcontinue        }, /* 135 */
  255. {    "ERRSET",             F, xerrset          }, /* 136 */
  256. {    "BAKTRACE",            S, xbaktrace        }, /* 137 */
  257. {    "EVALHOOK",            S, xevalhook        }, /* 138 */
  258.  
  259.     /* arithmetic functions */
  260. {    "TRUNCATE",            S, xfix            }, /* 139 */
  261. {    "FLOAT",            S, xfloat        }, /* 140 */
  262. {    "+",                S, xadd            }, /* 141 */
  263. {    "-",                S, xsub            }, /* 142 */
  264. {    "*",                S, xmul            }, /* 143 */
  265. {    "/",                S, xdiv            }, /* 144 */
  266. {    "1+",                S, xadd1        }, /* 145 */
  267. {    "1-",                S, xsub1        }, /* 146 */
  268. {    "REM",                S, xrem            }, /* 147 */
  269. {    "MIN",                S, xmin            }, /* 148 */
  270. {    "MAX",                S, xmax            }, /* 149 */
  271. {    "ABS",                S, xabs            }, /* 150 */
  272. {    "SIN",                S, xsin            }, /* 151 */
  273. {    "COS",                S, xcos            }, /* 152 */
  274. {    "TAN",                S, xtan            }, /* 153 */
  275. {    "EXPT",                S, xexpt        }, /* 154 */
  276. {    "EXP",                S, xexp            }, /* 155 */
  277. {    "SQRT",                  S, xsqrt        }, /* 156 */
  278. {    "RANDOM",            S, xrand        }, /* 157 */
  279.             
  280.     /* bitwise logical functions */
  281. {    "LOGAND",            S, xlogand          }, /* 158 */
  282. {    "LOGIOR",            S, xlogior          }, /* 159 */
  283. {    "LOGXOR",            S, xlogxor          }, /* 160 */
  284. {    "LOGNOT",            S, xlognot          }, /* 161 */
  285.  
  286.     /* numeric comparison functions */
  287. {    "<",                S, xlss            }, /* 162 */
  288. {    "<=",                S, xleq            }, /* 163 */
  289. {    "=",                S, xequ            }, /* 164 */
  290. {    "/=",                S, xneq            }, /* 165 */
  291. {    ">=",                S, xgeq            }, /* 166 */
  292. {    ">",                S, xgtr            }, /* 167 */
  293.             
  294.     /* string functions */
  295. {    "STRCAT",            S, xstrcat          }, /* 168 */
  296. {    "SUBSEQ",            S, xsubseq          }, /* 169 */
  297. {    "STRING",            S, xstring          }, /* 170 */
  298. {    "CHAR",                S, xchar        }, /* 171 */
  299.  
  300.     /* I/O functions */
  301. {    "READ",                S, xread        }, /* 172 */
  302. {    "PRINT",            S, xprint        }, /* 173 */
  303. {    "PRIN1",            S, xprin1        }, /* 174 */
  304. {    "PRINC",            S, xprinc        }, /* 175 */
  305. {    "TERPRI",            S, xterpri          }, /* 176 */
  306. {    "FLATSIZE",            S, xflatsize        }, /* 177 */
  307. {    "FLATC",            S, xflatc        }, /* 178 */
  308.             
  309.     /* file I/O functions */
  310. {    "OPEN",                S, xopen        }, /* 179 */
  311. {    "FORMAT",            S, xformat          }, /* 180 */
  312. {    "CLOSE",            S, xclose        }, /* 181 */
  313. {    "READ-CHAR",            S, xrdchar          }, /* 182 */
  314. {    "PEEK-CHAR",            S, xpkchar          }, /* 183 */
  315. {    "WRITE-CHAR",            S, xwrchar          }, /* 184 */
  316. {    "READ-LINE",            S, xreadline        }, /* 185 */
  317.  
  318.     /* system functions */
  319. {    "LOAD",                S, xload        }, /* 186 */
  320. {    "DRIBBLE",            S, xtranscript        }, /* 187 */
  321.  
  322. /* functions specific to xldmem.c */
  323. {    "GC",                S, xgc            }, /* 188 */
  324. {    "EXPAND",            S, xexpand          }, /* 189 */
  325. {    "ALLOC",            S, xalloc        }, /* 190 */
  326. {    "ROOM",                S, xmem            }, /* 191 */
  327. #ifdef SAVERESTORE
  328. {    "SAVE",                S, xsave        }, /* 192 */
  329. {    "RESTORE",            S, xrestore        }, /* 193 */
  330. #else
  331. {    NULL,                S, xnotimp        }, /* 192 */
  332. {    NULL,                S, xnotimp        }, /* 193 */
  333. #endif
  334. /* end of functions specific to xldmem.c */
  335.  
  336. {    "TYPE-OF",            S, xtype        }, /* 194 */
  337. {    "EXIT",                S, xexit        }, /* 195 */
  338. {    "PEEK",                S, xpeek        }, /* 196 */
  339. {    "POKE",                S, xpoke        }, /* 197 */
  340. {    "ADDRESS-OF",            S, xaddrs        }, /* 198 */
  341.  
  342.     /* new functions and special forms */
  343. {    "VECTOR",            S, xvector          }, /* 199 */
  344. {    "BLOCK",            F, xblock        }, /* 200 */
  345. {    "RETURN-FROM",            F, xrtnfrom        }, /* 201 */
  346. {    "TAGBODY",            F, xtagbody        }, /* 202 */
  347. {    "PSETQ",            F, xpsetq        }, /* 203 */
  348. {    "FLET",                F, xflet        }, /* 204 */
  349. {    "LABELS",            F, xlabels          }, /* 205 */
  350. {    "MACROLET",            F, xmacrolet        }, /* 206 */
  351. {    "UNWIND-PROTECT",        F, xunwindprotect    }, /* 207 */
  352. {    "PPRINT",            S, xpp            }, /* 208 */
  353. {    "STRING<",            S, xstrlss          }, /* 209 */
  354. {    "STRING<=",            S, xstrleq          }, /* 210 */
  355. {    "STRING=",            S, xstreql          }, /* 211 */
  356. {    "STRING/=",            S, xstrneq          }, /* 212 */
  357. {    "STRING>=",            S, xstrgeq          }, /* 213 */
  358. {    "STRING>",            S, xstrgtr          }, /* 214 */
  359. {    "STRING-LESSP",            S, xstrilss        }, /* 215 */
  360. {    "STRING-NOT-GREATERP",        S, xstrileq        }, /* 216 */
  361. {    "STRING-EQUAL",            S, xstrieql        }, /* 217 */
  362. {    "STRING-NOT-EQUAL",        S, xstrineq        }, /* 218 */
  363. {    "STRING-NOT-LESSP",        S, xstrigeq        }, /* 219 */
  364. {    "STRING-GREATERP",        S, xstrigtr        }, /* 220 */
  365. {    "INTEGERP",            S, xintegerp        }, /* 221 */
  366. {    "FLOATP",            S, xfloatp          }, /* 222 */
  367. {    "STRINGP",            S, xstringp        }, /* 223 */
  368. {    "ARRAYP",            S, xarrayp          }, /* 224 */
  369. {    "STREAMP",            S, xstreamp        }, /* 225 */
  370. {    "OBJECTP",            S, xobjectp        }, /* 226 */
  371. {    "STRING-UPCASE",        S, xupcase          }, /* 227 */
  372. {    "STRING-DOWNCASE",        S, xdowncase        }, /* 228 */
  373. {    "NSTRING-UPCASE",        S, xnupcase        }, /* 229 */
  374. {    "NSTRING-DOWNCASE",        S, xndowncase        }, /* 230 */
  375. {    "STRING-TRIM",            S, xtrim        }, /* 231 */
  376. {    "STRING-LEFT-TRIM",        S, xlefttrim        }, /* 232 */
  377. {    "STRING-RIGHT-TRIM",        S, xrighttrim        }, /* 233 */
  378. {    "WHEN",                F, xwhen        }, /* 234 */
  379. {    "UNLESS",            F, xunless          }, /* 235 */
  380. {    "LOOP",                F, xloop        }, /* 236 */
  381. {    "SYMBOL-FUNCTION",        S, xsymfunction        }, /* 237 */
  382. {    "FBOUNDP",            S, xfboundp        }, /* 238 */
  383. {    "SEND",                S, xsend        }, /* 239 */
  384. {    "SEND-SUPER",            S, xsendsuper        }, /* 240 */
  385. {    "PROGV",            F, xprogv        }, /* 241 */
  386. {    "CHARACTERP",            S, xcharp        }, /* 242 */
  387. {    "CHAR-INT",            S, xcharint        }, /* 243 */
  388. {    "INT-CHAR",            S, xintchar        }, /* 244 */
  389. {    "READ-BYTE",            S, xrdbyte          }, /* 245 */
  390. {    "WRITE-BYTE",            S, xwrbyte          }, /* 246 */
  391. {    "MAKE-STRING-INPUT-STREAM",     S, xmkstrinput        }, /* 247 */
  392. {    "MAKE-STRING-OUTPUT-STREAM",    S, xmkstroutput        }, /* 248 */
  393. {    "GET-OUTPUT-STREAM-STRING",    S, xgetstroutput    }, /* 249 */
  394. {    "GET-OUTPUT-STREAM-LIST",    S, xgetlstoutput    }, /* 250 */
  395. {    "GCD",                S, xgcd            }, /* 251 */
  396. {    "GET-LAMBDA-EXPRESSION",     S, xgetlambda        }, /* 252 */
  397. {    "MACROEXPAND",            S, xmacroexpand        }, /* 253 */
  398. {    "MACROEXPAND-1",        S, x1macroexpand    }, /* 254 */
  399. {    "CHAR<",            S, xchrlss          }, /* 255 */
  400. {    "CHAR<=",            S, xchrleq          }, /* 256 */
  401. {    "CHAR=",            S, xchreql          }, /* 257 */
  402. {    "CHAR/=",            S, xchrneq          }, /* 258 */
  403. {    "CHAR>=",            S, xchrgeq          }, /* 259 */
  404. {    "CHAR>",            S, xchrgtr          }, /* 260 */
  405. {    "CHAR-LESSP",            S, xchrilss        }, /* 261 */
  406. {    "CHAR-NOT-GREATERP",        S, xchrileq        }, /* 262 */
  407. {    "CHAR-EQUAL",            S, xchrieql        }, /* 263 */
  408. {    "CHAR-NOT-EQUAL",        S, xchrineq        }, /* 264 */
  409. {    "CHAR-NOT-LESSP",        S, xchrigeq        }, /* 265 */
  410. {    "CHAR-GREATERP",        S, xchrigtr        }, /* 266 */
  411. {    "UPPER-CASE-P",            S, xuppercasep        }, /* 267 */
  412. {    "LOWER-CASE-P",            S, xlowercasep        }, /* 268 */
  413. {    "BOTH-CASE-P",            S, xbothcasep        }, /* 269 */
  414. {    "DIGIT-CHAR-P",            S, xdigitp        }, /* 270 */
  415. {    "ALPHANUMERICP",        S, xalphanumericp    }, /* 271 */
  416. {    "CHAR-UPCASE",            S, xchupcase        }, /* 272 */
  417. {    "CHAR-DOWNCASE",        S, xchdowncase        }, /* 273 */
  418. {    "DIGIT-CHAR",            S, xdigitchar        }, /* 274 */
  419. {    "CHAR-CODE",            S, xcharcode        }, /* 275 */
  420. {    "CODE-CHAR",            S, xcodechar        }, /* 276 */
  421. {    "ENDP",                S, xendp        }, /* 277 */
  422. {    "REMOVE-IF",            S, xremif        }, /* 278 */
  423. {    "REMOVE-IF-NOT",        S, xremifnot        }, /* 279 */
  424. {    "DELETE-IF",            S, xdelif        }, /* 280 */
  425. {    "DELETE-IF-NOT",        S, xdelifnot        }, /* 281 */
  426. {    "TRACE",            F, xtrace        }, /* 282 */
  427. {    "UNTRACE",            F, xuntrace        }, /* 283 */
  428. {    "SORT",                S, xsort        }, /* 284 */
  429. {    "DEFSTRUCT",            F, xdefstruct        }, /* 285 */
  430. {    "%STRUCT-TYPE-P",        S, xstrtypep        }, /* 286 */
  431. {    "%MAKE-STRUCT",            S, xmkstruct        }, /* 287 */
  432. {    "%COPY-STRUCT",            S, xcpystruct        }, /* 288 */
  433. {    "%STRUCT-REF",            S, xstrref        }, /* 289 */
  434. {    "%STRUCT-SET",            S, xstrset        }, /* 290 */
  435. {    "ASIN",                S, xasin        }, /* 291 */
  436. {    "ACOS",                S, xacos        }, /* 292 */
  437. {    "ATAN",                S, xatan        }, /* 293 */
  438.  
  439.     /* extra table entries */
  440. {    NULL,                S, xnotimp        }, /* 294 */
  441. {    NULL,                S, xnotimp        }, /* 295 */
  442. {    NULL,                S, xnotimp        }, /* 296 */
  443. {    NULL,                S, xnotimp        }, /* 297 */
  444. {    NULL,                S, xnotimp        }, /* 298 */
  445. {    NULL,                S, xnotimp        }, /* 299 */
  446.  
  447.     /* include system dependant function pointers */
  448. #include "osptrs.h"
  449.  
  450. {0,0,0} /* end of table marker */
  451.  
  452. };            
  453.  
  454. /* xnotimp - function table entries that are currently not implemented */
  455. LOCAL LVAL xnotimp()
  456. {
  457.     xlfail("function not implemented");
  458. }
  459.  
  460.