1
2 /* $destdir\u02.c Machine generated C code */
3
4 /* Signature: 00000000 28-Sep-2011 */
5
6 #include <stdio.h>
7 #include <stdlib.h>
8 #include <string.h>
9 #include <ctype.h>
10 #include <stdarg.h>
11 #include <time.h>
12 #ifndef _cplusplus
13 #include <setjmp.h>
14 #endif
15
16 #include "config.h"
17
18 #ifndef header_machine_h
19 #define header_machine_h 1
20 #if !defined UNDER_CE && !defined EMBEDDED
21 #if ((defined HAVE_SOCKET && defined HAVE_SYS_SOCKET_H) || defined WIN32)
22 #define SOCKETS 1
23 #endif
24 #endif
25 #ifndef MS_CDECL
26 #ifdef _MSC_VER
27 # define MS_CDECL __cdecl
28 #else
29 # define MS_CDECL
30 #endif
31 #endif
32 #ifdef WIN32
33 # if defined WIN64 || defined __WIN64__
34 # define OPSYS "win64"
35 # define IMPNAME "win64"
36 # else
37 # define OPSYS "win32"
38 # define IMPNAME "win32"
39 # endif
40 #else
41 # ifdef HOST_OS
42 # define OPSYS HOST_OS
43 # ifdef HOST_CPU
44 # define IMPNAME HOST_OS ":" HOST_CPU
45 # else
46 # define IMPNAME HOST_OS
47 # endif
48 # else
49 # define OPSYS "Unknown"
50 # define IMPNAME "Generic"
51 # endif
52 #endif
53 #ifdef HAVE_STDINT_H
54 #include <stdint.h>
55 #else
56 #ifndef HAVE_UINT32_T
57 #ifdef HAVE_U_INT32_T
58 typedef u_int32_t uint32_t;
59 #define HAVE_UINT32_T 1
60 #endif
61 #endif
62 #ifndef HAVE_UINT64_T
63 #ifdef HAVE_U_INT64_T
64 typedef u_int64_t uint64_t;
65 #define HAVE_UINT64_T 1
66 #endif
67 #endif
68 #ifndef HAVE_UINTPTR_T
69 #ifdef HAVE_U_INTPTR_T
70 typedef u_intptr_t uintptr_t;
71 #define HAVE_UINTPTR_T 1
72 #endif
73 #endif
74 #if !defined HAVE_INT32_T && defined SIZEOF_INT && (SIZEOF_INT == 4)
75 typedef int int32_t;
76 #define HAVE_INT32_T 1
77 #endif
78 #if !defined HAVE_UINT32_T && defined SIZEOF_INT && (SIZEOF_INT == 4)
79 typedef unsigned int uint32_t;
80 #define HAVE_UINT32_T 1
81 #endif
82 #if !defined HAVE_INT32_T && defined SIZEOF_SHORT_INT && (SIZEOF_SHORT_INT == 4)
83 typedef short int int32_t;
84 #define HAVE_INT32_T 1
85 #endif
86 #if !defined HAVE_UINT32_T && defined SIZEOF_SHORT_INT && (SIZEOF_SHORT_INT == 4)
87 typedef unsigned short int uint32_t;
88 #define HAVE_UINT32_T 1
89 #endif
90 #if !defined HAVE_INT64_T && defined SIZEOF_LONG && (SIZEOF_LONG == 8)
91 typedef long int64_t;
92 #define HAVE_INT64_T 1
93 #endif
94 #if !defined HAVE_UINT64_T && defined SIZEOF_LONG && (SIZEOF_LONG == 8)
95 typedef unsigned long uint64_t;
96 #define HAVE_UINT64_T 1
97 #endif
98 #if !defined HAVE_INT64_T && defined SIZEOF_LONG_LONG && (SIZEOF_LONG_LONG == 8)
99 typedef long long int64_t;
100 #define HAVE_INT64_T 1
101 #endif
102 #if !defined HAVE_UINT64_T && defined SIZEOF_LONG_LONG && (SIZEOF_LONG_LONG == 8)
103 typedef unsigned long long uint64_t;
104 #define HAVE_UINT64_T 1
105 #endif
106 #if !defined HAVE_INTPTR_T && defined SIZEOF_VOID_P && (SIZEOF_VOID_P == 4) && defined HAVE_INT32_T
107 typedef int32_t intptr_t;
108 #define HAVE_INTPTR_T 1
109 #endif
110 #if !defined HAVE_INTPTR_T && defined SIZEOF_VOID_P && (SIZEOF_VOID_P == 8) && defined HAVE_INT64_T
111 typedef int64_t intptr_t;
112 #define HAVE_INTPTR_T 1
113 #endif
114 #if !defined HAVE_UINTPTR_T && defined SIZEOF_VOID_P && (SIZEOF_VOID_P == 4) && defined HAVE_UINT32_T
115 typedef uint32_t uintptr_t;
116 #define HAVE_UINTPTR_T 1
117 #endif
118 #if !defined HAVE_UINTPTR_T && defined SIZEOF_VOID_P && (SIZEOF_VOID_P == 8) && defined HAVE_UINT64_T
119 typedef uint64_t uintptr_t;
120 #define HAVE_UINTPTR_T 1
121 #endif
122 #endif
123 #endif
124 #ifndef header_tags_h
125 #define header_tags_h 1
126 #if !defined HAVE_STDINT_H || !defined HAVE_INT32_T
127 #error This system needs a 32-bit integer type.
128 #endif
129 #define SIXTY_FOUR_BIT (sizeof(intptr_t) == 8)
130 typedef int CSLbool;
131 #define YES 1
132 #define NO 0
133 #ifndef PAGE_BITS
134 # define PAGE_BITS 22
135 #endif
136 #define PAGE_POWER_OF_TWO (((uint32_t)1) << PAGE_BITS)
137 #define CSL_PAGE_SIZE (PAGE_POWER_OF_TWO - 256U)
138 #ifndef MAX_HEAPSIZE
139 # define MAX_HEAPSIZE (SIXTY_FOUR_BIT ? (512*1024) : 2048)
140 #endif
141 #ifndef MAX_BPSSIZE
142 # define MAX_BPSSIZE 64
143 #endif
144 #define MEGABYTE ((uint32_t)0x100000U)
145 #if PAGE_BITS >= 20
146 #define MAX_PAGES (MAX_HEAPSIZE >> (PAGE_BITS-20))
147 #define MAX_BPS_PAGES (MAX_BPSSIZE >> (PAGE_BITS-20))
148 #else
149 #define MAX_PAGES (MAX_HEAPSIZE << (20-PAGE_BITS))
150 #define MAX_BPS_PAGES (MAX_BPSSIZE << (20-PAGE_BITS))
151 #endif
152 #define MAX_NATIVE_PAGES MAX_BPS_PAGES
153 #define CSL_IGNORE(x) (x = x)
154 #define LONGEST_LEGAL_FILENAME 1024
155 #define FP_WORD_ORDER 0x01
156 #define FP_BYTE_ORDER 0x02
157 #define FP_MASK 0xff
158 typedef intptr_t Lisp_Object;
159 #define CELL sizeof(Lisp_Object)
160 #define TAG_BITS 7
161 #define TAG_CONS 0
162
163 #define TAG_FIXNUM 1
164 #define TAG_ODDS 2
165 #ifdef COMMON
166 #define TAG_SFLOAT 3
167 #endif
168 #define TAG_SYMBOL 4
169 #define TAG_NUMBERS 5
170 #define TAG_VECTOR 6
171 #define TAG_BOXFLOAT 7
172 #define fixnum_of_int(x) ((Lisp_Object)(TAG_FIXNUM + (((int32_t)(x)) << 4)))
173 #ifdef SIGNED_SHIFTS_ARE_LOGICAL
174 #define int_of_fixnum(x) ((int32_t)(((int32_t)(x)) < 0 ? \
175 (((int32_t)(x))>>4) | (-0x10000000) : \
176 (((int32_t)(x))>>4)))
177 #else
178 #define int_of_fixnum(x) ((int32_t)(((int32_t)(x)) >> 4))
179 #endif
180 #define GC_BIT_I 8
181 #define GC_BIT_H 8
182 #define GC_BIT_P ((intptr_t)~((~(uintptr_t)0) >> 1))
183 #define is_marked_i(w) (((int)(w) & GC_BIT_I) != 0)
184 extern Lisp_Object address_sign;
185 #define is_marked_p(w) (((Lisp_Object)(w) - address_sign) < 0)
186 #define clear_mark_bit_p(w) (((Lisp_Object)(w) & ~GC_BIT_P) + \
187 address_sign)
188 #define flip_mark_bit_i(w) ((Lisp_Object)(w) ^ GC_BIT_I)
189 #define flip_mark_bit_h(w) ((Header)(w) ^ GC_BIT_H)
190 #define flip_mark_bit_p(w) ((Lisp_Object)(w) ^ GC_BIT_P)
191 #define is_marked_h(w) (((int)(w) & GC_BIT_H) != 0)
192 #define exception_pending() (((int)nil & 1) != 0)
193 #define flip_exception() (nil = C_nil = (nil ^ 1))
194 #define ignore_exception() \
195 do { nil = C_nil; if (exception_pending()) flip_exception(); } while (0)
196 #define set_mark_bit_h(h) ((Header)(h) | GC_BIT_H)
197 #define clear_mark_bit_h(h) ((Header)(h) & ~GC_BIT_H)
198 #define set_mark_bit_i(h) ((Lisp_Object)(h) | GC_BIT_I)
199 #define clear_mark_bit_i(h) ((Lisp_Object)(h) & ~GC_BIT_I)
200 #define is_cons(p) ((((int)(p)) & TAG_BITS) == TAG_CONS)
201 #define is_fixnum(p) ((((int)(p)) & TAG_BITS) == TAG_FIXNUM)
202 #define is_odds(p) ((((int)(p)) & TAG_BITS) == TAG_ODDS)
203 #ifdef COMMON
204 #define is_sfloat(p) ((((int)(p)) & TAG_BITS) == TAG_SFLOAT)
205 #endif
206 #define is_symbol(p) ((((int)(p)) & TAG_BITS) == TAG_SYMBOL)
207 #define is_numbers(p)((((int)(p)) & TAG_BITS) == TAG_NUMBERS)
208 #define is_vector(p) ((((int)(p)) & TAG_BITS) == TAG_VECTOR)
209 #define is_bfloat(p) ((((int)(p)) & TAG_BITS) == TAG_BOXFLOAT)
210 #ifdef COMMON
211 #define consp(p) (is_cons(p) && (p) != nil)
212 #define symbolp(p) (is_symbol(p) || (p) == nil)
213 #else
214 #define consp(p) is_cons(p)
215 #define symbolp(p) is_symbol(p)
216 #endif
217 #define car_legal(p) is_cons(p)
218 #define is_number(p) ((((int)(p)) & 1) != 0)
219 #define is_float(p) ((((int)(p)) & 3) == 3)
220 #define is_immed_or_cons(p) ((((int)(p)) & 4) == 0)
221 typedef struct Cons_Cell
222 {
223 Lisp_Object car;
224 Lisp_Object cdr;
225 } Cons_Cell;
226 #ifdef MEMORY_TRACE
227 extern Cons_Cell *memory_reference(intptr_t p);
228 extern char *cmemory_reference(intptr_t p);
229 extern void identify_page_types();
230 extern long int car_counter;
231 extern unsigned long int car_low, car_high;
232 #define qcar(p) (memory_reference((intptr_t)p)->car)
233 #define qcdr(p) (memory_reference((intptr_t)p)->cdr)
234 #else
235 #define qcar(p) (((Cons_Cell *) (p))->car)
236 #define qcdr(p) (((Cons_Cell *) (p))->cdr)
237 #endif
238 #define car32(p) (*(int32_t *)(p))
239 #define cdr32(p) (*(int32_t *)(p))[1])
240 typedef Lisp_Object Special_Form(Lisp_Object, Lisp_Object);
241 typedef Lisp_Object one_args(Lisp_Object, Lisp_Object);
242 typedef Lisp_Object two_args(Lisp_Object, Lisp_Object, Lisp_Object);
243 typedef Lisp_Object MS_CDECL n_args(Lisp_Object, int, ...);
244 typedef uintptr_t Header;
245 #define header_mask 0x3f0
246 #define type_of_header(h) (((unsigned int)(h)) & header_mask)
247 #define length_of_header(h) (((uint32_t)(h)) >> 10)
248 #define TYPE_SYMBOL 0x00000010
249 #define SYM_SPECIAL_VAR 0x00000040
250 #define SYM_GLOBAL_VAR 0x00000080
251 #define SYM_SPECIAL_FORM 0x00000100
252 #define SYM_MACRO 0x00000200
253 #define SYM_C_DEF 0x00000400
254 #define SYM_CODEPTR 0x00000800
255 #define SYM_ANY_GENSYM 0x00001000
256 #define SYM_TRACED 0x00002000
257 #define SYM_FASTGET_MASK 0x000fc000
258 #define SYM_FASTGET_SHIFT 14
259 #ifdef COMMON
260 #define SYM_EXTERN_IN_HOME 0x00100000
261 #define SYM_IN_PACKAGE 0xffe00000
262 #define SYM_IN_PKG_SHIFT 23
263 #define SYM_IN_PKG_COUNT 11
264 #else
265 #define SYM_UNPRINTED_GENSYM 0x00100000
266 #endif
267 #define symhdr_length ((sizeof(Symbol_Head) + 7) & ~7)
268 #define is_symbol_header(h) (((int)h & 0x30) == TYPE_SYMBOL)
269 #define header_fastget(h) (((h) >> SYM_FASTGET_SHIFT) & 0x3f)
270 #define TYPE_BIGNUM 0x020
271 #ifdef COMMON
272 #define TYPE_RATNUM 0x060
273 #define TYPE_COMPLEX_NUM 0x0a0
274 #define TYPE_SINGLE_FLOAT 0x120
275 #endif
276 #define TYPE_DOUBLE_FLOAT 0x160
277 #ifdef COMMON
278 #define TYPE_LONG_FLOAT 0x1a0
279 #endif
280 #ifdef MEMORY_TRACE
281 #define numhdr(v) (*(Header *)memory_reference((intptr_t)((char *)(v) - \
282 TAG_NUMBERS)))
283 #define flthdr(v) (*(Header *)memory_reference((intptr_t)((char *)(v) - \
284 TAG_BOXFLOAT)))
285 #else
286 #define numhdr(v) (*(Header *)((char *)(v) - TAG_NUMBERS))
287 #define flthdr(v) (*(Header *)((char *)(v) - TAG_BOXFLOAT))
288 #endif
289 #define is_numbers_header(h) (((int)(h) & 0x330) == 0x020)
290 #define is_boxfloat_header(h)(((int)(h) & 0x330) == 0x120)
291 #ifdef COMMON
292 #define is_ratio(n) \
293 (type_of_header(numhdr(n)) == TYPE_RATNUM)
294 #define is_complex(n) \
295 (type_of_header(numhdr(n)) == TYPE_COMPLEX_NUM)
296 #endif
297 #define is_bignum_header(h) (type_of_header(h) == TYPE_BIGNUM)
298 #define is_bignum(n) is_bignum_header(numhdr(n))
299 #define ADDRESS_SHIFT (SIXTY_FOUR_BIT ? 3 : 2)
300 #ifdef MEMORY_TRACE
301 #define vechdr(v) (*(Header *)memory_reference((intptr_t)((char *)(v) - \
302 TAG_VECTOR)))
303 #define elt(v, n) (*(Lisp_Object *)memory_reference((intptr_t)((char *)(v) + \
304 (CELL-TAG_VECTOR) + \
305 (((intptr_t)(n))<<ADDRESS_SHIFT))))
306 #define celt(v, n) (*cmemory_reference((intptr_t)((char *)(v) + \
307 (CELL-TAG_VECTOR)+((intptr_t)(n)))))
308 #define ucelt(v, n) (*(unsigned char *)cmemory_reference( \
309 (intptr_t)((char *)(v) + \
310 (CELL-TAG_VECTOR)+((intptr_t)(n)))))
311 #define scelt(v, n) (*(signed char *)cmemory_reference( \
312 (intptr_t)((char *)(v) + \
313 (CELL-TAG_VECTOR)+((intptr_t)(n)))))
314 #else
315 #define vechdr(v) (*(Header *)((char *)(v) - TAG_VECTOR))
316 #define elt(v, n) (*(Lisp_Object *)((char *)(v) + \
317 (CELL-TAG_VECTOR) + \
318 (((intptr_t)(n))<<ADDRESS_SHIFT)))
319 #define celt(v, n) (*((char *)(v) + (CELL-TAG_VECTOR)+((intptr_t)(n))))
320 #define ucelt(v, n) (*((unsigned char *)(v) + (CELL-TAG_VECTOR)+((intptr_t)(n))))
321 #define scelt(v, n) (*((signed char *)(v) + (CELL-TAG_VECTOR)+((intptr_t)(n))))
322 #endif
323 #define helt(v, n) \
324 ((*(unsigned char *)((v) + (CELL-TAG_VECTOR) + (2*(intptr_t)(n))) | \
325 (*(signed char *)((v) + (CELL-TAG_VECTOR+1) + (2*(intptr_t)(n)))) << 8))
326 #define sethelt(v, n, x) \
327 do { \
328 *(char *)((v) + (CELL-TAG_VECTOR+0) + (2*(intptr_t)(n))) = (x); \
329 *(char *)((v) + (CELL-TAG_VECTOR+1) + (2*(intptr_t)(n))) = (x)>>8; \
330 } while (0)
331 #define ielt(v, n) (*(intptr_t *)((char *)(v) + \
332 (CELL-TAG_VECTOR)+(((intptr_t)(n))<<ADDRESS_SHIFT)))
333 #define ielt32(v, n) (*(int32_t *)((char *)(v) + \
334 (CELL-TAG_VECTOR)+(((intptr_t)(n))<<2)))
335 #define felt(v, n) (*(float *)((char *)(v) + \
336 (CELL-TAG_VECTOR)+(((intptr_t)(n))<<2)))
337 #define delt(v, n) (*(double *)((char *)(v) + \
338 (2*CELL-TAG_VECTOR)+(((intptr_t)(n))<<3)))
339 #ifdef COMMON
340 #define TYPE_BITVEC1 0x030
341 #define TYPE_BITVEC2 0x0b0
342 #define TYPE_BITVEC3 0x130
343 #define TYPE_BITVEC4 0x1b0
344 #define TYPE_BITVEC5 0x230
345 #define TYPE_BITVEC6 0x2b0
346 #define TYPE_BITVEC7 0x330
347 #define TYPE_BITVEC8 0x3b0
348 #define header_of_bitvector(h) (((h) & 0x70) == TYPE_BITVEC1)
349 #endif
350 #define TYPE_STRING 0x070
351 #define TYPE_BPS 0x170
352 #define TYPE_SPARE 0x270
353 #define TYPE_MAPLEREF TYPE_SPARE
354 #define TYPE_SP 0x370
355 #ifdef COMMON
356 #define vector_holds_binary(h) (((h) & 0x80) == 0 || header_of_bitvector(h))
357 #else
358 #define vector_holds_binary(h) (((h) & 0x80) == 0)
359 #endif
360 #define TYPE_SIMPLE_VEC 0x0f0
361 #define TYPE_HASH 0x1f0
362 #define TYPE_ARRAY 0x2f0
363 #define TYPE_STRUCTURE 0x3f0
364 #define is_mixed_header(h) (((h) & 0x2b0) == TYPE_MIXED1)
365 #define TYPE_VEC8 TYPE_BPS
366 #define TYPE_VEC16 0x220
367 #define TYPE_VEC32 0x260
368 #define TYPE_MIXED1 0x2a0
369 #define TYPE_MIXED2 0x2e0
370 #define TYPE_FLOAT32 0x320
371 #define TYPE_FLOAT64 0x360
372 #define TYPE_MIXED3 0x3a0
373 #define TYPE_STREAM 0x3e0
374 #define ODDS_MASK 0xff
375 #define TAG_CHAR 0x02
376 #define TAG_BPS 0x42
377 #define TAG_SPID 0xc2
378 #define SPID_NIL (TAG_SPID+0x0000)
379 #define SPID_FBIND (TAG_SPID+0x0100)
380 #define SPID_CATCH (TAG_SPID+0x0200)
381 #define SPID_PROTECT (TAG_SPID+0x0300)
382 #define SPID_HASH0 (TAG_SPID+0x0400)
383 #define SPID_HASH1 (TAG_SPID+0x0500)
384 #define SPID_GCMARK (TAG_SPID+0x0600)
385 #define SPID_NOINPUT (TAG_SPID+0x0700)
386 #define SPID_ERROR (TAG_SPID+0x0800)
387 #define SPID_PVBIND (TAG_SPID+0x0900)
388 #define SPID_NOARG (TAG_SPID+0x0a00)
389 #define SPID_NOPROP (TAG_SPID+0x0b00)
390 #define SPID_LIBRARY (TAG_SPID+0x0c00)
391 #define is_header(x) (((int)(x) & 0x30) != 0)
392 #define is_char(x) (((int)(x) & ODDS_MASK) == TAG_CHAR)
393 #define is_bps(x) (((int)(x) & ODDS_MASK) == TAG_BPS)
394 #define is_spid(x) (((int)(x) & ODDS_MASK) == TAG_SPID)
395 #define is_library(x)(((int)(x) & 0xffff) == SPID_LIBRARY)
396 #define library_number(x) (((x) >> 20) & 0xfff)
397 #ifdef OLD_VERSION
398 #define font_of_char(n) (((int32_t)(n) >> 24) & 0xff)
399 #define bits_of_char(n) (((int32_t)(n) >> 16) & 0xff)
400 #ifdef Kanji
401 #define code_of_char(n) (((int32_t)(n) >> 8) & 0xffff)
402 #else
403 #define code_of_char(n) ((char)(((int32_t)(n) >> 8) & 0xff))
404 #endif
405 #define pack_char(bits, font, code) \
406 ((Lisp_Object)((((uint32_t)(font)) << 24) | \
407 (((uint32_t)(bits)) << 16) | (((uint32_t)(code)) << 8) | TAG_CHAR))
408
409 #define CHAR_EOF pack_char(0, 0xff, 4)
410 #else
411 #define font_of_char(n) (((int32_t)(n) >> 29) & 0x03)
412 #define bits_of_char(n) (0)
413 #define code_of_char(n) (((int32_t)(n) >> 8) & 0x001fffff)
414 #define pack_char(bits, font, code) \
415 ((Lisp_Object)((((uint32_t)(font)) << 29) | \
416 (((uint32_t)(code)) << 8) | TAG_CHAR))
417
418 #define CHAR_EOF ((Lisp_Object)(int32_t)0xff000402)
419 #endif
420 #define data_of_bps(v) \
421 ((char *)(doubleword_align_up((intptr_t) \
422 bps_pages[((uint32_t)(v))>>(PAGE_BITS+6)]) + \
423 (SIXTY_FOUR_BIT ? \
424 (intptr_t)((((uint64_t)(v))>>(32-PAGE_BITS)) & \
425 PAGE_POWER_OF_TWO) : \
426 0) + \
427 (((v) >> 6) & (PAGE_POWER_OF_TWO-4))))
428 typedef int32_t junk;
429 typedef intptr_t junkxx;
430 typedef struct Symbol_Head
431 {
432 Header header;
433 Lisp_Object value;
434 Lisp_Object env;
435 intptr_t function1;
436 intptr_t function2;
437 intptr_t functionn;
438 Lisp_Object pname;
439 Lisp_Object plist;
440 Lisp_Object fastgets;
441 uintptr_t count;
442 #ifdef COMMON
443 Lisp_Object package;
444 #endif
445 } Symbol_Head;
446 #define MAX_FASTGET_SIZE 63
447 #ifdef COMMON
448 #define symalign(n) (SIXTY_FOUR_BIT ? \
449 ((char *)((intptr_t)(n) & ~(intptr_t)TAG_SYMBOL)) : \
450 (n)
451 #else
452 #define symalign(n) (n)
453 #endif
454 #ifndef MEMORY_TRACE
455 #define qheader(p) (*(Header *) symalign((char *)(p) - TAG_SYMBOL))
456 #define qvalue(p) (*(Lisp_Object *)symalign((char *)(p) + (CELL - TAG_SYMBOL)))
457 #define qenv(p) (*(Lisp_Object *)symalign((char *)(p) + (2*CELL - TAG_SYMBOL)))
458 #define qfn1(p) ((one_args *) *((intptr_t *)symalign((char *)(p) + \
459 (3*CELL - TAG_SYMBOL))))
460 #define qfn2(p) ((two_args *) *((intptr_t *)symalign((char *)(p) + \
461 (4*CELL - TAG_SYMBOL))))
462 #define qfnn(p) ((n_args *) *((intptr_t *)symalign((char *)(p) + \
463 (5*CELL - TAG_SYMBOL))))
464 #define ifn1(p) (*(intptr_t *) symalign((char *)(p) + (3*CELL-TAG_SYMBOL)))
465 #define ifn2(p) (*(intptr_t *) symalign((char *)(p) + (4*CELL-TAG_SYMBOL)))
466 #define ifnn(p) (*(intptr_t *) symalign((char *)(p) + (5*CELL-TAG_SYMBOL)))
467 #define qpname(p) (*(Lisp_Object *)symalign((char *)(p) + (6*CELL-TAG_SYMBOL)))
468 #define qplist(p) (*(Lisp_Object *)symalign((char *)(p) + (7*CELL-TAG_SYMBOL)))
469 #define qfastgets(p) (*(Lisp_Object *)symalign((char *)(p) + (8*CELL-TAG_SYMBOL)))
470 #define qcount(p) (*(uintptr_t *) symalign((char *)(p) + (9*CELL-TAG_SYMBOL)))
471 #ifdef COMMON
472 #define qpackage(p) (*(Lisp_Object *)symalign((char *)(p) + (10*CELL-TAG_SYMBOL)))
473 #endif
474 #else
475 #define qheader(p) (*(Header *) memory_reference((intptr_t) \
476 symalign((char *)(p) - TAG_SYMBOL)))
477 #define qvalue(p) (*(Lisp_Object *)memory_reference((intptr_t) \
478 symalign((char *)(p) + (CELL-TAG_SYMBOL))))
479 #define qenv(p) (*(Lisp_Object *)memory_reference((intptr_t) \
480 symalign((char *)(p) + (2*CELL-TAG_SYMBOL))))
481 #define qfn1(p) ((one_args *) *(intptr_t *)memory_reference((intptr_t) \
482 symalign((char *)(p) + (3*CELL-TAG_SYMBOL))))
483 #define qfn2(p) ((two_args *) *(intptr_t *)memory_reference((intptr_t) \
484 symalign((char *)(p) + (4*CELL-TAG_SYMBOL))))
485 #define qfnn(p) ((n_args *) *(intptr_t *)memory_reference((intptr_t) \
486 symalign((char *)(p) + (5*CELL-TAG_SYMBOL))))
487 #define ifn1(p) (*(intptr_t *) memory_reference((intptr_t) \
488 symalign((char *)(p) + (3*CELL-TAG_SYMBOL))))
489 #define ifn2(p) (*(intptr_t *) memory_reference((intptr_t) \
490 symalign((char *)(p) + (4*CELL-TAG_SYMBOL))))
491 #define ifnn(p) (*(intptr_t *) memory_reference((intptr_t) \
492 symalign((char *)(p) + (5*CELL-TAG_SYMBOL))))
493 #define qpname(p) (*(Lisp_Object *)memory_reference((intptr_t) \
494 symalign((char *)(p) + (6*CELL-TAG_SYMBOL))))
495 #define qplist(p) (*(Lisp_Object *)memory_reference((intptr_t) \
496 symalign((char *)(p) + (7*CELL-TAG_SYMBOL))))
497 #define qfastgets(p) (*(Lisp_Object *)memory_reference((intptr_t) \
498 symalign((char *)(p) + (8*CELL-TAG_SYMBOL))))
499 #define qcount(p) (*(uintptr_t *) memory_reference((intptr_t) \
500 symalign((char *)(p) + (9*CELL-TAG_SYMBOL))))
501 #ifdef COMMON
502 #define qpackage(p) (*(Lisp_Object *)memory_reference((intptr_t) \
503 symalign((char *)(p) + (10*CELL-TAG_SYMBOL))))
504 #endif
505 #endif
506 #ifdef COMMON
507 typedef union Float_union
508 {
509 float f;
510 int32_t i;
511 } Float_union;
512 #endif
513 typedef struct Big_Number
514 {
515 Header h;
516 uint32_t d[1];
517 } Big_Number;
518 #define bignum_length(b) length_of_header(numhdr(b))
519 #ifdef MEMORY_TRACE
520 #define bignum_digits(b) ((uint32_t *)memory_reference((intptr_t)((char *)b + \
521 (CELL-TAG_NUMBERS))))
522 #else
523 #define bignum_digits(b) ((uint32_t *)((char *)b + (CELL-TAG_NUMBERS)))
524 #endif
525 #define make_bighdr(n) (TAG_ODDS+TYPE_BIGNUM+(((intptr_t)(n))<<12))
526 #define pack_hdrlength(n) (((intptr_t)(n))<<12)
527 #ifdef COMMON
528 typedef struct Rational_Number
529 {
530 Header header;
531 Lisp_Object num;
532 Lisp_Object den;
533 } Rational_Number;
534 #define numerator(r) (((Rational_Number *)((char *)(r)-TAG_NUMBERS))->num)
535 #define denominator(r) (((Rational_Number *)((char *)(r)-TAG_NUMBERS))->den)
536 typedef struct Complex_Number
537 {
538 Header header;
539 Lisp_Object real;
540 Lisp_Object imag;
541 } Complex_Number;
542 #define real_part(r) (((Complex_Number *)((char *)(r)-TAG_NUMBERS))->real)
543 #define imag_part(r) (((Complex_Number *)((char *)(r)-TAG_NUMBERS))->imag)
544 typedef struct Single_Float
545 {
546 Header header;
547 union float_or_int {
548 float f;
549 int32_t i;
550 } f;
551 } Single_Float;
552 #define single_float_val(v) \
553 (((Single_Float *)((char *)(v)-TAG_BOXFLOAT))->f.f)
554 #endif
555 #define SIZEOF_DOUBLE_FLOAT 16
556 #define double_float_addr(v) ((double *)((char *)(v) + \
557 (8-TAG_BOXFLOAT)))
558 #define double_float_val(v) (*(double *)((char *)(v) + \
559 (8-TAG_BOXFLOAT)))
560 #ifdef COMMON
561 #define SIZEOF_LONG_FLOAT 16
562 #define long_float_addr(v) ((double *)((char *)(v) + \
563 (8-TAG_BOXFLOAT)))
564 #define long_float_val(v) (*(double *)((char *)(v) + \
565 (8-TAG_BOXFLOAT)))
566 #endif
567 #define word_align_up(n) ((Lisp_Object)(((intptr_t)(n) + 3) & (-4)))
568 #define doubleword_align_up(n) ((Lisp_Object)(((intptr_t)(n) + 7) & (-8)))
569 #define doubleword_align_down(n) ((Lisp_Object)((intptr_t)(n) & (-8)))
570 #define object_align_up(n) ((Lisp_Object)(((intptr_t)(n) + \
571 sizeof(Lisp_Object) - 1) & (-sizeof(Lisp_Object))))
572 #define quadword_align_up(n) ((Lisp_Object)(((intptr_t)(n) + 15) & (-16)))
573 #define quadword_align_down(n) ((Lisp_Object)((intptr_t)(n) & (-16)))
574 #define UNWIND_NULL 0x0
575 #define UNWIND_GO 0x1
576 #define UNWIND_RETURN 0x2
577 #define UNWIND_THROW 0x3
578 #define UNWIND_RESTART 0x4
579 #define UNWIND_RESOURCE 0x5
580 #define UNWIND_FNAME 0x100
581 #define UNWIND_ARGS 0x200
582 #define UNWIND_ERROR (UNWIND_FNAME|UNWIND_ARGS)
583 #define UNWIND_UNWIND 0x400
584 #endif
585 #ifndef header_cslerror_h
586 #define header_cslerror_h 1
587 extern Lisp_Object interrupted(Lisp_Object p);
588 extern Lisp_Object MS_CDECL error(int nargs, int code, ...);
589 extern Lisp_Object MS_CDECL cerror(int nargs, int code1, int code2, ...);
590 extern Lisp_Object too_few_2(Lisp_Object env, Lisp_Object a1);
591 extern Lisp_Object too_many_1(Lisp_Object env, Lisp_Object a1, Lisp_Object a2);
592 extern Lisp_Object wrong_no_0a(Lisp_Object env, Lisp_Object a1);
593 extern Lisp_Object wrong_no_0b(Lisp_Object env, Lisp_Object a1, Lisp_Object a2);
594 extern Lisp_Object wrong_no_3a(Lisp_Object env, Lisp_Object a1);
595 extern Lisp_Object wrong_no_3b(Lisp_Object env, Lisp_Object a1, Lisp_Object a2);
596 extern Lisp_Object wrong_no_na(Lisp_Object env, Lisp_Object a1);
597 extern Lisp_Object wrong_no_nb(Lisp_Object env, Lisp_Object a1, Lisp_Object a2);
598 extern Lisp_Object MS_CDECL wrong_no_1(Lisp_Object env, int nargs, ...);
599 extern Lisp_Object MS_CDECL wrong_no_2(Lisp_Object env, int nargs, ...);
600 extern Lisp_Object bad_special2(Lisp_Object env, Lisp_Object a1, Lisp_Object a2);
601 extern Lisp_Object MS_CDECL bad_specialn(Lisp_Object env, int nargs, ...);
602 extern Lisp_Object aerror(char *s);
603 extern Lisp_Object aerror0(char *s);
604 extern Lisp_Object aerror1(char *s, Lisp_Object a);
605 extern Lisp_Object aerror2(char *s, Lisp_Object a, Lisp_Object b);
606 extern void MS_CDECL fatal_error(int code, ...);
607 #define GC_MESSAGES 0x01
608 #define FASL_MESSAGES 0x02
609 #define VERBOSE_MSGS 0x04
610 #define GC_MSG_BITS 0x07
611 #define verbos_flag (miscflags & GC_MSG_BITS)
612 #define HEADLINE_FLAG 0x08
613 #define FNAME_FLAG 0x10
614 #define ARGS_FLAG 0x20
615 #define BACKTRACE_MSG_BITS 0x38
616
617 #define err_bad_car 0
618 #define err_bad_cdr 1
619 #define err_no_store 2
620 #define err_undefined_function_1 3
621 #define err_undefined_function_2 4
622 #define err_undefined_function_n 5
623 #define err_wrong_no_args 6
624 #define err_unbound_lexical 7
625 #define err_bad_rplac 8
626 #define err_bad_arith 9
627 #define err_redef_special 10
628 #define err_bad_arg 11
629 #define err_bad_declare 12
630 #define err_bad_fn 13
631 #define err_unset_var 14
632 #define err_too_many_args1 15
633 #define err_too_many_args2 16
634 #define err_bad_apply 17
635 #define err_macroex_hook 18
636 #define err_block_tag 19
637 #define err_go_tag 20
638 #define err_excess_args 21
639 #define err_insufficient_args 22
640 #define err_bad_bvl 23
641 #define err_bad_keyargs 24
642 #define err_write_err 25
643 #define err_bad_endp 26
644 #define err_no_fasldir 27
645 #define err_no_fasl 28
646 #define err_open_failed 29
647 #define err_pipe_failed 30
648 #define err_stack_overflow 31
649 #define err_top_bit 32
650 #define err_mem_spans_zero 33
651 #define err_no_longer_used 34
652 #define err_no_tempdir 35
653
654 #ifdef INCLUDE_ERROR_STRING_TABLE
655 static char *error_message_table[] =
656 {
657 "attempt to take car of an atom",
658 "attempt to take cdr of an atom",
659 "insufficient freestore to run this package",
660 "undefined function (1 arg)",
661 "undefined function (2 args)",
662 "undefined function",
663 "wrong number of arguments",
664 "unbound lexical variable",
665 "bad rplaca/rplacd",
666 "bad argument for an arithmetic function",
667 "attempt to redefine a special form",
668 "not a variable",
669 "bad use of declare",
670 "attempt to apply non-function",
671 "unset variable",
672 "too many arguments",
673 "too many arguments",
674 "object not valid as a function (apply,",
675 "macroexpand-hook failure",
676 "block tag not found",
677 "go tag not found",
678 "too many arguments provided",
679 "not enough arguments provided",
680 "bad item in bound variable list",
681 "bad keyword arguments",
682 "write-error on file",
683 "endp used on badly terminated list",
684 "environment parameter 'fasldir' not set",
685 "loadable module not found for loading",
686 "file could not be opened",
687 "unable to establish pipe",
688 "stack overflow",
689 "top bit of address has unexpected value",
690 "memory block spans the zero address",
691 "this error code available for re-use",
692 "unable to find a directory for temporary files",
693 "dummy final error message"
694 };
695 #endif
696 #endif
697 #ifndef header_externs_h
698 #define header_externs_h 1
699 #ifdef __cplusplus
700 extern "C" {
701 #endif
702 #ifdef USE_MPI
703 #include "mpi.h"
704 extern int32_t mpi_rank,mpi_size;
705 #endif
706 #define D do { \
707 char *fffff = strrchr(__FILE__, '/'); \
708 if (fffff == NULL) fffff = strrchr(__FILE__, '\\'); \
709 if (fffff == NULL) fffff = __FILE__; else fffff++; \
710 fprintf(stderr, "Line %d File %s\n", __LINE__, fffff); \
711 fflush(stderr); \
712 } while (0)
713 #define DS(s) do { \
714 char *fffff = strrchr(__FILE__, '/'); \
715 if (fffff == NULL) fffff = strrchr(__FILE__, '\\'); \
716 if (fffff == NULL) fffff = __FILE__; else fffff++; \
717 fprintf(stderr, "Line %d File %s: %s\n", __LINE__, fffff, (s)); \
718 fflush(stderr); \
719 } while (0)
720 #define DX(s) do { \
721 char *fffff = strrchr(__FILE__, '/'); \
722 if (fffff == NULL) fffff = strrchr(__FILE__, '\\'); \
723 if (fffff == NULL) fffff = __FILE__; else fffff++; \
724 fprintf(stderr, "Line %d File %s: %llx\n", __LINE__, fffff, \
725 (long long unsigned)(s)); \
726 fflush(stderr); \
727 } while (0)
728 extern void **pages,
729 **heap_pages, **vheap_pages,
730 **bps_pages, **native_pages;
731 extern void **new_heap_pages, **new_vheap_pages,
732 **new_bps_pages, **new_native_pages;
733 #ifdef CONSERVATIVE
734 #define PAGE_TYPE_CONS 0
735 #define PAGE_TYPE_VECTOR 1
736 #define PAGE_TYPE_BPS 2
737 #define PAGE_TYPE_NATIVE 3
738 typedef struct page_map_t
739 {
740 void *start;
741 void *end;
742 int type;
743 } page_map_t;
744 #endif
745 extern int32_t pages_count,
746 heap_pages_count, vheap_pages_count,
747 bps_pages_count, native_pages_count;
748 extern int32_t new_heap_pages_count, new_vheap_pages_count,
749 new_bps_pages_count, new_native_pages_count;
750 extern int32_t native_pages_changed;
751 extern int32_t native_fringe;
752 extern Lisp_Object *nilsegment, *stacksegment;
753 extern Lisp_Object *stackbase;
754 extern int32_t stack_segsize;
755 extern Lisp_Object *C_stack;
756 #define stack C_stack
757 extern char *C_stack_limit;
758 extern CSLbool restartp;
759 extern char *big_chunk_start, *big_chunk_end;
760 #ifdef CONSERVATIVE
761 extern Lisp_Object *C_stackbase, *C_stacktop;
762 #endif
763 #ifdef MEMORY_TRACE
764 #define push(a) do { \
765 *++stack = (a); \
766 memory_reference((intptr_t)stack); } while (0)
767 #define push2(a,b) do { \
768 *++stack = (a); \
769 memory_reference((intptr_t)stack); \
770 *++stack = (b); \
771 memory_reference((intptr_t)stack); } while (0)
772 #define push3(a,b,c) do { \
773 *++stack = (a); \
774 memory_reference((intptr_t)stack); \
775 *++stack = (b); \
776 memory_reference((intptr_t)stack); \
777 *++stack = (c); \
778 memory_reference((intptr_t)stack); } while (0)
779 #define push4(a,b,c,d) do { \
780 *++stack = (a); \
781 memory_reference((intptr_t)stack); \
782 *++stack = (b); \
783 memory_reference((intptr_t)stack); \
784 *++stack = (c); \
785 memory_reference((intptr_t)stack); \
786 *++stack = (d); \
787 memory_reference((intptr_t)stack); } while (0)
788 #define push5(a,b,c,d,e)do { \
789 *++stack = (a); \
790 memory_reference((intptr_t)stack); \
791 *++stack = (b); \
792 memory_reference((intptr_t)stack); \
793 *++stack = (c); \
794 memory_reference((intptr_t)stack); \
795 *++stack = (d); \
796 memory_reference((intptr_t)stack); \
797 *++stack = (e); \
798 memory_reference((intptr_t)stack); } while (0)
799 #define push6(a,b,c,d,e,f) do {push3(a,b,c); push3(d,e,f); } while (0)
800 #define my_pop() (memory_reference((int32_t)stack), (*stack--))
801 #define pop(a) { memory_reference((intptr_t)stack); (a) = *stack--; }
802 #define pop2(a,b) { memory_reference((intptr_t)stack); (a) = *stack--; memory_reference((intptr_t)stack); (b) = *stack--; }
803 #define pop3(a,b,c) { memory_reference((intptr_t)stack); (a) = *stack--; memory_reference((intptr_t)stack); (b) = *stack--; memory_reference((intptr_t)stack); (c) = *stack--; }
804 #define pop4(a,b,c,d) { memory_reference((intptr_t)stack); (a) = *stack--; memory_reference((intptr_t)stack); (b) = *stack--; memory_reference((intptr_t)stack); (c) = *stack--; \
805 memory_reference((intptr_t)stack); (d) = *stack--; }
806 #define pop5(a,b,c,d,e) { memory_reference((intptr_t)stack); (a) = *stack--; memory_reference((intptr_t)stack); (b) = *stack--; memory_reference((intptr_t)stack); (c) = *stack--; \
807 memory_reference((intptr_t)stack); (d) = *stack--; memory_reference((intptr_t)stack); (e) = *stack--; }
808 #define pop6(a,b,c,d,e,f) {pop3(a,b,c); pop3(d,e,f)}
809 #define popv(n) stack -= (n)
810 #else
811 #define push(a) { *++stack = (a); }
812 #define push2(a,b) { stack[1] = (a); stack[2] = (b); stack += 2; }
813 #define push3(a,b,c) { stack[1] = (a); stack[2] = (b); stack[3] = (c); \
814 stack += 3; }
815 #define push4(a,b,c,d) { stack[1] = (a); stack[2] = (b); stack[3] = (c); \
816 stack[4] = (d); stack += 4; }
817 #define push5(a,b,c,d,e){ stack[1] = (a); stack[2] = (b); stack[3] = (c); \
818 stack[4] = (d); stack[5] = (e); stack += 5; }
819 #define push6(a,b,c,d,e,f) { \
820 stack[1] = (a); stack[2] = (b); stack[3] = (c); \
821 stack[4] = (d); stack[5] = (e); stack[6] = (f); \
822 stack += 6; }
823 #define pop(a) { (a) = *stack--; }
824 #define pop2(a,b) { stack -= 2; (a) = stack[2]; (b) = stack[1]; }
825 #define pop3(a,b,c) { stack -= 3; (a) = stack[3]; (b) = stack[2]; \
826 (c) = stack[1]; }
827 #define pop4(a,b,c,d) { stack -= 4; (a) = stack[4]; (b) = stack[3]; \
828 (c) = stack[2]; (d) = stack[1]; }
829 #define pop5(a,b,c,d,e) { stack -= 5; (a) = stack[5]; (b) = stack[4]; \
830 (c) = stack[3]; (d) = stack[2]; (e) = stack[1]; }
831 #define pop6(a,b,c,d,e, f) { stack -= 6; \
832 (a) = stack[6]; (b) = stack[5]; (c) = stack[4]; \
833 (d) = stack[3]; (e) = stack[2]; (f) = stack[1]; }
834 #define popv(n) stack -= (n)
835 #endif
836 #define errexit() { nil = C_nil; if (exception_pending()) return nil; }
837 #define errexitn(n) { nil = C_nil; \
838 if (exception_pending()) { popv(n); return nil; } }
839 #define errexitv() { nil = C_nil; if (exception_pending()) return; }
840 #define errexitvn(n) { nil = C_nil; \
841 if (exception_pending()) { popv(n); return; } }
842 #define GC_USER_SOFT 0
843 #define GC_USER_HARD 1
844 #define GC_STACK 2
845 #define GC_CONS 3
846 #define GC_VEC 4
847 #define GC_BPS 5
848 #define GC_PRESERVE 6
849 #define GC_NATIVE 7
850 extern volatile char stack_contents_temp;
851 #ifdef CHECK_STACK
852 extern int check_stack(char *file, int line);
853 extern void show_stack();
854 #define if_check_stack \
855 if (check_stack(__FILE__,__LINE__)) \
856 { show_stack(); return aerror("stack overflow"); }
857 #else
858 #define if_check_stack \
859 { char *p = (char *)&p; \
860 if (p < C_stack_limit) return aerror("stack overflow"); \
861 }
862 #endif
863 extern int32_t software_ticks, countdown;
864 #define stackcheck0(k) \
865 if_check_stack \
866 if ((--countdown < 0 && deal_with_tick()) || \
867 stack >= stacklimit) \
868 { reclaim(nil, "stack", GC_STACK, 0); \
869 nil = C_nil; \
870 if (exception_pending()) { popv(k); return nil; } \
871 }
872 #define stackcheck1(k, a1) \
873 if_check_stack \
874 if ((--countdown < 0 && deal_with_tick()) || \
875 stack >= stacklimit) \
876 { a1 = reclaim(a1, "stack", GC_STACK, 0); \
877 nil = C_nil; \
878 if (exception_pending()) { popv(k); return nil; } \
879 }
880 #define stackcheck2(k, a1, a2) \
881 if_check_stack \
882 if ((--countdown < 0 && deal_with_tick()) || \
883 stack >= stacklimit) \
884 { push(a2); \
885 a1 = reclaim(a1, "stack", GC_STACK, 0); pop(a2); \
886 nil = C_nil; \
887 if (exception_pending()) { popv(k); return nil; } \
888 }
889 #define stackcheck3(k, a1, a2, a3) \
890 if_check_stack \
891 if ((--countdown < 0 && deal_with_tick()) || \
892 stack >= stacklimit) \
893 { push2(a2, a3); \
894 a1 = reclaim(a1, "stack", GC_STACK, 0); \
895 pop2(a3, a2); \
896 nil = C_nil; \
897 if (exception_pending()) { popv(k); return nil; } \
898 }
899 #define stackcheck4(k, a1, a2, a3, a4) \
900 if_check_stack \
901 if ((--countdown < 0 && deal_with_tick()) || \
902 stack >= stacklimit) \
903 { push3(a2, a3, a4); \
904 a1 = reclaim(a1, "stack", GC_STACK, 0); \
905 pop3(a4, a3, a2); \
906 nil = C_nil; \
907 if (exception_pending()) { popv(k); return nil; } \
908 }
909 extern Lisp_Object C_nil;
910 #define first_nil_offset 50
911 #define work_0_offset 200
912 #define last_nil_offset 251
913 #define NIL_SEGMENT_SIZE (last_nil_offset*sizeof(Lisp_Object) + 32)
914 #define SPARE 512
915 #ifdef COMMON
916 #define BASE ((Lisp_Object *)nil)
917 #else
918 #define BASE (SIXTY_FOUR_BIT ? ((Lisp_Object *)(nil+4)): ((Lisp_Object *)nil))
919 #endif
920 #ifdef NILSEG_EXTERNS
921 #define nil_as_base
922 extern intptr_t byteflip;
923 extern Lisp_Object codefringe;
924 extern Lisp_Object volatile codelimit;
925 extern Lisp_Object * volatile stacklimit;
926 extern Lisp_Object fringe;
927 extern Lisp_Object volatile heaplimit;
928 extern Lisp_Object volatile vheaplimit;
929 extern Lisp_Object vfringe;
930 extern intptr_t nwork;
931 extern intptr_t exit_count;
932 extern intptr_t gensym_ser, print_precision, miscflags;
933 extern intptr_t current_modulus, fastget_size, package_bits;
934 extern Lisp_Object lisp_true, lambda, funarg, unset_var, opt_key, rest_key;
935 extern Lisp_Object quote_symbol, function_symbol, comma_symbol;
936 extern Lisp_Object comma_at_symbol, cons_symbol, eval_symbol;
937 extern Lisp_Object work_symbol, evalhook, applyhook, macroexpand_hook;
938 extern Lisp_Object append_symbol, exit_tag, exit_value, catch_tags;
939 extern Lisp_Object current_package, startfn;
940 extern Lisp_Object gensym_base, string_char_sym, boffo;
941 extern Lisp_Object err_table;
942 extern Lisp_Object progn_symbol;
943 extern Lisp_Object lisp_work_stream, charvec, raise_symbol, lower_symbol;
944 extern Lisp_Object echo_symbol, codevec, litvec, supervisor, B_reg;
945 extern Lisp_Object savedef, comp_symbol, compiler_symbol, faslvec;
946 extern Lisp_Object tracedfn, lisp_terminal_io;
947 extern Lisp_Object lisp_standard_output, lisp_standard_input, lisp_error_output;
948 extern Lisp_Object lisp_trace_output, lisp_debug_io, lisp_query_io;
949 extern Lisp_Object prompt_thing, faslgensyms;
950 extern Lisp_Object prinl_symbol, emsg_star, redef_msg;
951 extern Lisp_Object expr_symbol, fexpr_symbol, macro_symbol;
952 extern Lisp_Object cl_symbols, active_stream, current_module;
953 extern Lisp_Object native_defs, features_symbol, lisp_package;
954 extern Lisp_Object sys_hash_table, help_index, cfunarg, lex_words;
955 extern Lisp_Object get_counts, fastget_names, input_libraries;
956 extern Lisp_Object output_library, current_file, break_function;
957 extern Lisp_Object standard_output, standard_input, debug_io;
958 extern Lisp_Object error_output, query_io, terminal_io;
959 extern Lisp_Object trace_output, fasl_stream;
960 extern Lisp_Object native_code, native_symbol, traceprint_symbol;
961 extern Lisp_Object loadsource_symbol;
962 extern Lisp_Object hankaku_symbol, bytecoded_symbol, nativecoded_symbol;
963 extern Lisp_Object gchook, resources, callstack, procstack, procmem;
964 #ifdef COMMON
965 extern Lisp_Object keyword_package;
966 extern Lisp_Object all_packages, package_symbol, internal_symbol;
967 extern Lisp_Object external_symbol, inherited_symbol;
968 extern Lisp_Object key_key, allow_other_keys, aux_key;
969 extern Lisp_Object format_symbol;
970 extern Lisp_Object expand_def_symbol, allow_key_key;
971 #endif
972 extern Lisp_Object declare_symbol, special_symbol;
973 #ifdef OPENMATH
974 extern Lisp_Object MS_CDECL om_openFileDev(Lisp_Object env, int nargs, ...);
975 extern Lisp_Object om_openStringDev(Lisp_Object nil, Lisp_Object lstr, Lisp_Object lenc);
976 extern Lisp_Object om_closeDev(Lisp_Object env, Lisp_Object dev);
977 extern Lisp_Object om_setDevEncoding(Lisp_Object nil, Lisp_Object ldev, Lisp_Object lenc);
978 extern Lisp_Object om_makeConn(Lisp_Object nil, Lisp_Object ltimeout);
979 extern Lisp_Object om_closeConn(Lisp_Object nil, Lisp_Object lconn);
980 extern Lisp_Object om_getConnInDevice(Lisp_Object nil, Lisp_Object lconn);
981 extern Lisp_Object om_getConnOutDevice(Lisp_Object nil, Lisp_Object lconn);
982 extern Lisp_Object MS_CDECL om_connectTCP(Lisp_Object nil, int nargs, ...);
983 extern Lisp_Object om_bindTCP(Lisp_Object nil, Lisp_Object lconn, Lisp_Object lport);
984 extern Lisp_Object om_putApp(Lisp_Object nil, Lisp_Object ldev);
985 extern Lisp_Object om_putEndApp(Lisp_Object nil, Lisp_Object ldev);
986 extern Lisp_Object om_putAtp(Lisp_Object nil, Lisp_Object ldev);
987 extern Lisp_Object om_putEndAtp(Lisp_Object nil, Lisp_Object ldev);
988 extern Lisp_Object om_putAttr(Lisp_Object nil, Lisp_Object ldev);
989 extern Lisp_Object om_putEndAttr(Lisp_Object nil, Lisp_Object ldev);
990 extern Lisp_Object om_putBind(Lisp_Object nil, Lisp_Object ldev);
991 extern Lisp_Object om_putEndBind(Lisp_Object nil, Lisp_Object ldev);
992 extern Lisp_Object om_putBVar(Lisp_Object nil, Lisp_Object ldev);
993 extern Lisp_Object om_putEndBVar(Lisp_Object nil, Lisp_Object ldev);
994 extern Lisp_Object om_putError(Lisp_Object nil, Lisp_Object ldev);
995 extern Lisp_Object om_putEndError(Lisp_Object nil, Lisp_Object ldev);
996 extern Lisp_Object om_putObject(Lisp_Object nil, Lisp_Object ldev);
997 extern Lisp_Object om_putEndObject(Lisp_Object nil, Lisp_Object ldev);
998 extern Lisp_Object om_putInt(Lisp_Object nil, Lisp_Object ldev, Lisp_Object val);
999 extern Lisp_Object om_putFloat(Lisp_Object nil, Lisp_Object ldev, Lisp_Object val);
1000 extern Lisp_Object om_putByteArray(Lisp_Object nil, Lisp_Object ldev, Lisp_Object val);
1001 extern Lisp_Object om_putVar(Lisp_Object nil, Lisp_Object ldev, Lisp_Object val);
1002 extern Lisp_Object om_putString(Lisp_Object nil, Lisp_Object ldev, Lisp_Object val);
1003 extern Lisp_Object om_putSymbol(Lisp_Object nil, Lisp_Object ldev, Lisp_Object val);
1004 extern Lisp_Object MS_CDECL om_putSymbol2(Lisp_Object nil, int nargs, ...);
1005 extern Lisp_Object om_getApp(Lisp_Object nil, Lisp_Object ldev);
1006 extern Lisp_Object om_getEndApp(Lisp_Object nil, Lisp_Object ldev);
1007 extern Lisp_Object om_getAtp(Lisp_Object nil, Lisp_Object ldev);
1008 extern Lisp_Object om_getEndAtp(Lisp_Object nil, Lisp_Object ldev);
1009 extern Lisp_Object om_getAttr(Lisp_Object nil, Lisp_Object ldev);
1010 extern Lisp_Object om_getEndAttr(Lisp_Object nil, Lisp_Object ldev);
1011 extern Lisp_Object om_getBind(Lisp_Object nil, Lisp_Object ldev);
1012 extern Lisp_Object om_getEndBind(Lisp_Object nil, Lisp_Object ldev);
1013 extern Lisp_Object om_getBVar(Lisp_Object nil, Lisp_Object ldev);
1014 extern Lisp_Object om_getEndBVar(Lisp_Object nil, Lisp_Object ldev);
1015 extern Lisp_Object om_getError(Lisp_Object nil, Lisp_Object ldev);
1016 extern Lisp_Object om_getEndError(Lisp_Object nil, Lisp_Object ldev);
1017 extern Lisp_Object om_getObject(Lisp_Object nil, Lisp_Object ldev);
1018 extern Lisp_Object om_getEndObject(Lisp_Object nil, Lisp_Object ldev);
1019 extern Lisp_Object om_getInt(Lisp_Object nil, Lisp_Object ldev);
1020 extern Lisp_Object om_getFloat(Lisp_Object nil, Lisp_Object ldev);
1021 extern Lisp_Object om_getByteArray(Lisp_Object nil, Lisp_Object ldev);
1022 extern Lisp_Object om_getVar(Lisp_Object nil, Lisp_Object ldev);
1023 extern Lisp_Object om_getString(Lisp_Object nil, Lisp_Object ldev);
1024 extern Lisp_Object om_getSymbol(Lisp_Object nil, Lisp_Object ldev);
1025 extern Lisp_Object om_getType(Lisp_Object nil, Lisp_Object ldev);
1026 extern Lisp_Object om_stringToStringPtr(Lisp_Object nil, Lisp_Object lstr);
1027 extern Lisp_Object om_stringPtrToString(Lisp_Object nil, Lisp_Object lpstr);
1028 extern Lisp_Object om_read(Lisp_Object nil, Lisp_Object dev);
1029 extern Lisp_Object om_supportsCD(Lisp_Object nil, Lisp_Object lcd);
1030 extern Lisp_Object om_supportsSymbol(Lisp_Object nil, Lisp_Object lcd, Lisp_Object lsym);
1031 extern Lisp_Object MS_CDECL om_listCDs(Lisp_Object nil, int nargs, ...);
1032 extern Lisp_Object om_listSymbols(Lisp_Object nil, Lisp_Object lcd);
1033 extern Lisp_Object om_whichCDs(Lisp_Object nil, Lisp_Object lsym);
1034 #endif
1035 extern Lisp_Object workbase[51];
1036 extern Lisp_Object user_base_0, user_base_1, user_base_2;
1037 extern Lisp_Object user_base_3, user_base_4, user_base_5;
1038 extern Lisp_Object user_base_6, user_base_7, user_base_8;
1039 extern Lisp_Object user_base_9;
1040 #define work_0 workbase[0]
1041 #define work_1 workbase[1]
1042 #define mv_1 workbase[1]
1043 #define mv_2 workbase[2]
1044 #define mv_3 workbase[3]
1045 #define work_50 workbase[50]
1046 #else
1047 #define nil_as_base Lisp_Object nil = C_nil;
1048 #define byteflip BASE[12]
1049 #define codefringe BASE[13]
1050 #define codelimit (*(Lisp_Object volatile *)&BASE[14])
1051 extern Lisp_Object * volatile stacklimit;
1052 #define fringe BASE[18]
1053 #define heaplimit (*(Lisp_Object volatile *)&BASE[19])
1054 #define vheaplimit (*(Lisp_Object volatile *)&BASE[20])
1055 #define vfringe BASE[21]
1056 #define miscflags BASE[22]
1057 #define nwork BASE[24]
1058 #define exit_count BASE[26]
1059 #define gensym_ser BASE[27]
1060 #define print_precision BASE[28]
1061 #define current_modulus BASE[29]
1062 #define fastget_size BASE[30]
1063 #define package_bits BASE[31]
1064 #define current_package BASE[52]
1065 #define B_reg BASE[53]
1066 #define codevec BASE[54]
1067 #define litvec BASE[55]
1068 #define exit_tag BASE[56]
1069 #define exit_value BASE[57]
1070 #define catch_tags BASE[58]
1071 #define lisp_package BASE[59]
1072 #define boffo BASE[60]
1073 #define charvec BASE[61]
1074 #define sys_hash_table BASE[62]
1075 #define help_index BASE[63]
1076 #define gensym_base BASE[64]
1077 #define err_table BASE[65]
1078 #define supervisor BASE[66]
1079 #define startfn BASE[67]
1080 #define faslvec BASE[68]
1081 #define tracedfn BASE[69]
1082 #define prompt_thing BASE[70]
1083 #define faslgensyms BASE[71]
1084 #define cl_symbols BASE[72]
1085 #define active_stream BASE[73]
1086 #define current_module BASE[74]
1087 #define native_defs BASE[75]
1088 #define append_symbol BASE[90]
1089 #define applyhook BASE[91]
1090 #define cfunarg BASE[92]
1091 #define comma_at_symbol BASE[93]
1092 #define comma_symbol BASE[94]
1093 #define compiler_symbol BASE[95]
1094 #define comp_symbol BASE[96]
1095 #define cons_symbol BASE[97]
1096 #define echo_symbol BASE[98]
1097 #define emsg_star BASE[99]
1098 #define evalhook BASE[100]
1099 #define eval_symbol BASE[101]
1100 #define expr_symbol BASE[102]
1101 #define features_symbol BASE[103]
1102 #define fexpr_symbol BASE[104]
1103 #define funarg BASE[105]
1104 #define function_symbol BASE[106]
1105 #define lambda BASE[107]
1106 #define lisp_true BASE[108]
1107 #define lower_symbol BASE[109]
1108 #define macroexpand_hook BASE[110]
1109 #define macro_symbol BASE[111]
1110 #define opt_key BASE[112]
1111 #define prinl_symbol BASE[113]
1112 #define progn_symbol BASE[114]
1113 #define quote_symbol BASE[115]
1114 #define raise_symbol BASE[116]
1115 #define redef_msg BASE[117]
1116 #define rest_key BASE[118]
1117 #define savedef BASE[119]
1118 #define string_char_sym BASE[120]
1119 #define unset_var BASE[121]
1120 #define work_symbol BASE[122]
1121 #define lex_words BASE[123]
1122 #define get_counts BASE[124]
1123 #define fastget_names BASE[125]
1124 #define input_libraries BASE[126]
1125 #define output_library BASE[127]
1126 #define current_file BASE[128]
1127 #define break_function BASE[129]
1128 #define lisp_work_stream BASE[130]
1129 #define lisp_standard_output BASE[131]
1130 #define lisp_standard_input BASE[132]
1131 #define lisp_debug_io BASE[133]
1132 #define lisp_error_output BASE[134]
1133 #define lisp_query_io BASE[135]
1134 #define lisp_terminal_io BASE[136]
1135 #define lisp_trace_output BASE[137]
1136 #define standard_output BASE[138]
1137 #define standard_input BASE[139]
1138 #define debug_io BASE[140]
1139 #define error_output BASE[141]
1140 #define query_io BASE[142]
1141 #define terminal_io BASE[143]
1142 #define trace_output BASE[144]
1143 #define fasl_stream BASE[145]
1144 #define native_code BASE[146]
1145 #define native_symbol BASE[147]
1146 #define traceprint_symbol BASE[148]
1147 #define loadsource_symbol BASE[149]
1148 #define hankaku_symbol BASE[150]
1149 #define bytecoded_symbol BASE[151]
1150 #define nativecoded_symbol BASE[152]
1151 #define gchook BASE[153]
1152 #define resources BASE[154]
1153 #define callstack BASE[155]
1154 #define procstack BASE[156]
1155 #define procmem BASE[157]
1156 #ifdef COMMON
1157 #define keyword_package BASE[170]
1158 #define all_packages BASE[171]
1159 #define package_symbol BASE[172]
1160 #define internal_symbol BASE[173]
1161 #define external_symbol BASE[174]
1162 #define inherited_symbol BASE[175]
1163 #define key_key BASE[176]
1164 #define allow_other_keys BASE[177]
1165 #define aux_key BASE[178]
1166 #define format_symbol BASE[179]
1167 #define expand_def_symbol BASE[180]
1168 #define allow_key_key BASE[181]
1169 #endif
1170 #define declare_symbol BASE[182]
1171 #define special_symbol BASE[183]
1172 extern Lisp_Object user_base_0, user_base_1, user_base_2;
1173 extern Lisp_Object user_base_3, user_base_4, user_base_5;
1174 extern Lisp_Object user_base_6, user_base_7, user_base_8;
1175 extern Lisp_Object user_base_9;
1176 #define work_0 BASE[200]
1177 #define work_1 BASE[201]
1178 #define mv_1 work_1
1179 #define mv_2 BASE[202]
1180 #define mv_3 BASE[203]
1181 #define work_50 BASE[250]
1182 #endif
1183 extern void copy_into_nilseg(int fg);
1184 extern void copy_out_of_nilseg(int fg);
1185 #define eq_hash_table_list BASE[50]
1186 #define equal_hash_table_list BASE[51]
1187 #define current_package_offset 52
1188 extern void rehash_this_table(Lisp_Object v);
1189 extern Lisp_Object eq_hash_tables, equal_hash_tables;
1190 extern Lisp_Object volatile savecodelimit;
1191 extern Lisp_Object * volatile savestacklimit;
1192 extern Lisp_Object volatile saveheaplimit;
1193 extern Lisp_Object volatile savevheaplimit;
1194 extern char *exit_charvec;
1195 extern intptr_t exit_reason;
1196 extern int procstackp;
1197 #ifdef DEBUG
1198 extern int trace_all;
1199 #endif
1200 extern int garbage_collection_permitted;
1201 #define MAX_INPUT_FILES 40
1202 #define MAX_SYMBOLS_TO_DEFINE 40
1203 #define MAX_FASL_PATHS 20
1204 extern char *files_to_read[MAX_INPUT_FILES],
1205 *symbols_to_define[MAX_SYMBOLS_TO_DEFINE],
1206 *fasl_paths[MAX_FASL_PATHS];
1207 extern int csl_argc;
1208 extern char **csl_argv;
1209 extern int fasl_output_file, output_directory;
1210 extern FILE *binary_read_file;
1211 extern int boffop;
1212 extern void packbyte(int c);
1213 #ifndef COMMON
1214 #ifdef HAVE_FWIN
1215 extern char **loadable_packages;
1216 extern char **switches;
1217 extern void review_switch_settings();
1218 #endif
1219 #endif
1220 #ifdef SOCKETS
1221 extern int sockets_ready;
1222 extern void flush_socket(void);
1223 #endif
1224 extern void report_file(const char *s);
1225 extern CSLbool undefine_this_one[MAX_SYMBOLS_TO_DEFINE];
1226 extern int errorset_min, errorset_max;
1227 extern int number_of_input_files,
1228 number_of_symbols_to_define,
1229 number_of_fasl_paths,
1230 init_flags;
1231 extern int native_code_tag;
1232 extern char *standard_directory;
1233 extern int gc_number;
1234 extern CSLbool gc_method_is_copying;
1235 extern int force_reclaim_method, reclaim_trap_count;
1236 #define INIT_QUIET 1
1237 #define INIT_VERBOSE 2
1238 #define INIT_EXPANDABLE 4
1239 #define Lispify_predicate(p) ((p) ? lisp_true : nil)
1240 extern int tty_count;
1241 extern FILE *spool_file;
1242 extern char spool_file_name[32];
1243 typedef struct Ihandle
1244 {
1245 FILE *f;
1246 long int o;
1247 long int n;
1248 uint32_t chk;
1249 int status;
1250 int nativedir;
1251 } Ihandle;
1252 extern int32_t compression_worth_while;
1253 #define CODESIZE 0x1000
1254 typedef struct entry_point1
1255 {
1256 one_args *p;
1257 char *s;
1258 } entry_point1;
1259 typedef struct entry_point2
1260 {
1261 two_args *p;
1262 char *s;
1263 } entry_point2;
1264 typedef struct entry_pointn
1265 {
1266 n_args *p;
1267 char *s;
1268 } entry_pointn;
1269 extern entry_point1 entries_table1[];
1270 extern entry_point2 entries_table2[];
1271 extern entry_pointn entries_tablen[];
1272 extern entry_pointn entries_table_io[];
1273 extern void set_up_entry_lookup(void);
1274 extern int32_t code_up_fn1(one_args *e);
1275 extern int32_t code_up_fn2(two_args *e);
1276 extern int32_t code_up_fnn(n_args *e);
1277 extern int32_t code_up_io(void *e);
1278 extern int doubled_execution;
1279 extern char *linker_type;
1280 extern char *compiler_command[], *import_data[],
1281 *config_header[], *csl_headers[];
1282 extern Lisp_Object encapsulate_pointer(void *);
1283 typedef void initfn(Lisp_Object *, Lisp_Object **, Lisp_Object * volatile *);
1284 extern int load_dynamic(char *objname, char *modname,
1285 Lisp_Object name, Lisp_Object fns);
1286 extern Lisp_Object Linstate_c_code(Lisp_Object nil,
1287 Lisp_Object name, Lisp_Object fns);
1288 #ifdef MEMORY_TRACE
1289 extern intptr_t memory_base, memory_size;
1290 extern unsigned char *memory_map;
1291 extern FILE *memory_file;
1292 extern void memory_comment(int n);
1293 #endif
1294 #define ARG_CUT_OFF 25
1295 extern void push_args(va_list a, int nargs);
1296 extern void push_args_1(va_list a, int nargs);
1297 extern void Iinit(void);
1298 extern void IreInit(void);
1299 extern void Icontext(Ihandle *);
1300 extern void Irestore_context(Ihandle);
1301 extern void Ilist(void);
1302 extern CSLbool open_output(char *s, int len);
1303 #define IOPEN_OUT 0
1304 #define IOPEN_UNCHECKED 1
1305 #define IOPEN_CHECKED 2
1306 extern CSLbool Iopen(char *name, int len, int dirn, char *expanded_name);
1307 extern CSLbool Iopen_from_stdin(void), Iopen_to_stdout(void);
1308 extern CSLbool IopenRoot(char *expanded_name, int hard, int sixtyfour);
1309 extern CSLbool Iwriterootp(char *expanded);
1310 extern CSLbool Iopen_help(int32_t offset);
1311 extern CSLbool Iopen_banner(int code);
1312 extern CSLbool Imodulep(char *name, int len, char *datestamp, int32_t *size,
1313 char *expanded_name);
1314 extern CSLbool Icopy(char *name, int len);
1315 extern CSLbool Idelete(char *name, int len);
1316 extern CSLbool IcloseInput(int check_checksum);
1317 extern CSLbool IcloseOutput(int write_checksum);
1318 extern CSLbool Ifinished(void);
1319 extern int Igetc(void);
1320 extern int32_t Iread(void *buff, int32_t size);
1321 extern CSLbool Iputc(int ch);
1322 extern CSLbool Iwrite(void *buff, int32_t size);
1323 extern long int Ioutsize(void);
1324 extern char *CSLtmpnam(char *suffix, int32_t suffixlen);
1325 extern int Cmkdir(char *s);
1326 extern char *look_in_lisp_variable(char *o, int prefix);
1327 extern void CSL_MD5_Init(void);
1328 extern void CSL_MD5_Update(unsigned char *data, int len);
1329 extern void CSL_MD5_Final(unsigned char *md);
1330 extern CSLbool CSL_MD5_busy;
1331 extern unsigned char *CSL_MD5(unsigned char *data, int n, unsigned char *md);
1332 extern void checksum(Lisp_Object a);
1333 extern unsigned char unpredictable[256];
1334 extern void inject_randomness(int n);
1335 extern void ensure_screen(void);
1336 extern int window_heading;
1337 extern void my_exit(int n);
1338 extern void *my_malloc(size_t n);
1339 extern clock_t base_time;
1340 extern double *clock_stack;
1341 extern void push_clock(void);
1342 extern double pop_clock(void);
1343 extern double consolidated_time[10], gc_time;
1344 extern CSLbool volatile already_in_gc, tick_on_gc_exit;
1345 extern CSLbool volatile interrupt_pending, tick_pending;
1346 extern int deal_with_tick(void);
1347 extern int current_fp_rep;
1348 #ifndef __cplusplus
1349 #ifdef USE_SIGALTSTACK
1350 extern sigjmp_buf *errorset_buffer;
1351 extern sigjmp_buf my_exit_buffer;
1352 #else
1353 extern jmp_buf *errorset_buffer;
1354 extern jmp_buf my_exit_buffer;
1355 #endif
1356 #endif
1357 extern char *errorset_msg;
1358 extern int errorset_code;
1359 extern void unwind_stack(Lisp_Object *, CSLbool findcatch);
1360 extern CSLbool segvtrap;
1361 extern CSLbool batch_flag;
1362 extern int escaped_printing;
1363 extern void MS_CDECL low_level_signal_handler(int code);
1364 extern int async_interrupt(int a);
1365 extern void MS_CDECL sigint_handler(int code);
1366 extern void record_get(Lisp_Object tag, CSLbool found);
1367 extern int primep(int32_t);
1368 extern void adjust_all(void);
1369 extern void set_up_functions(CSLbool restartp);
1370 extern void get_user_files_checksum(unsigned char *);
1371 extern Lisp_Object acons(Lisp_Object a, Lisp_Object b, Lisp_Object c);
1372 extern Lisp_Object ash(Lisp_Object a, Lisp_Object b);
1373 extern Lisp_Object bytestream_interpret(Lisp_Object code, Lisp_Object lit,
1374 Lisp_Object *entry_stack);
1375 extern CSLbool complex_stringp(Lisp_Object a);
1376 extern void freshline_trace(void);
1377 extern void freshline_debug(void);
1378 extern Lisp_Object cons(Lisp_Object a, Lisp_Object b);
1379 extern Lisp_Object cons_no_gc(Lisp_Object a, Lisp_Object b);
1380 extern Lisp_Object cons_gc_test(Lisp_Object a);
1381 extern void convert_fp_rep(void *p, int old_rep, int new_rep, int type);
1382 extern Lisp_Object Ceval(Lisp_Object u, Lisp_Object env);
1383 extern uint32_t Crand(void);
1384 extern Lisp_Object Cremainder(Lisp_Object a, Lisp_Object b);
1385 extern void Csrand(uint32_t a, uint32_t b);
1386 extern void discard(Lisp_Object a);
1387 extern CSLbool eql_fn(Lisp_Object a, Lisp_Object b);
1388 extern CSLbool cl_equal_fn(Lisp_Object a, Lisp_Object b);
1389 extern CSLbool equal_fn(Lisp_Object a, Lisp_Object b);
1390 #ifdef TRACED_EQUAL
1391 extern CSLbool traced_equal_fn(Lisp_Object a, Lisp_Object b,
1392 char *, int, int);
1393 #define equal_fn(a, b) traced_equal_fn(a, b, __FILE__, __LINE__, 0)
1394 extern void dump_equals();
1395 #endif
1396 extern CSLbool equalp(Lisp_Object a, Lisp_Object b);
1397 extern Lisp_Object apply(Lisp_Object fn, int nargs,
1398 Lisp_Object env, Lisp_Object fname);
1399 extern Lisp_Object apply_lambda(Lisp_Object def, int nargs,
1400 Lisp_Object env, Lisp_Object name);
1401 extern void deallocate_pages(void);
1402 extern void drop_heap_segments(void);
1403 extern Lisp_Object gcd(Lisp_Object a, Lisp_Object b);
1404 extern Lisp_Object get_pname(Lisp_Object a);
1405 #ifdef COMMON
1406 extern Lisp_Object get(Lisp_Object a, Lisp_Object b, Lisp_Object c);
1407 #else
1408 extern Lisp_Object get(Lisp_Object a, Lisp_Object b);
1409 #endif
1410 extern Lisp_Object getvector(int tag, int type, int32_t length);
1411 extern Lisp_Object getvector_init(int32_t n, Lisp_Object v);
1412 extern Lisp_Object getcodevector(int type, int32_t size);
1413 extern uint32_t hash_lisp_string(Lisp_Object s);
1414 extern void lose_C_def(Lisp_Object a);
1415 extern CSLbool geq2(Lisp_Object a, Lisp_Object b);
1416 extern CSLbool greaterp2(Lisp_Object a, Lisp_Object b);
1417 extern CSLbool lesseq2(Lisp_Object a, Lisp_Object b);
1418 extern CSLbool lessp2(Lisp_Object a, Lisp_Object b);
1419 extern Lisp_Object list2(Lisp_Object a, Lisp_Object b);
1420 extern Lisp_Object list2star(Lisp_Object a, Lisp_Object b, Lisp_Object c);
1421 extern Lisp_Object list3(Lisp_Object a, Lisp_Object b, Lisp_Object c);
1422 extern Lisp_Object list3star(Lisp_Object a, Lisp_Object b,
1423 Lisp_Object c, Lisp_Object d);
1424 extern Lisp_Object list4(Lisp_Object a, Lisp_Object b,
1425 Lisp_Object c, Lisp_Object d);
1426 extern Lisp_Object lognot(Lisp_Object a);
1427 extern Lisp_Object macroexpand(Lisp_Object form, Lisp_Object env);
1428 extern Lisp_Object make_one_word_bignum(int32_t n);
1429 extern Lisp_Object make_package(Lisp_Object name);
1430 extern Lisp_Object make_string(const char *b);
1431 extern Lisp_Object make_nstring(char *b, int32_t n);
1432 extern Lisp_Object make_undefined_symbol(char const *s);
1433 extern Lisp_Object make_symbol(char const *s, int restartp,
1434 one_args *f1, two_args *f2, n_args *fn);
1435 extern void MS_CDECL stdout_printf(char *fmt, ...);
1436 extern void MS_CDECL term_printf(char *fmt, ...);
1437 extern void MS_CDECL err_printf(char *fmt, ...);
1438 extern void MS_CDECL debug_printf(char *fmt, ...);
1439 extern void MS_CDECL trace_printf(char *fmt, ...);
1440 extern char *my_getenv(char *name);
1441 extern Lisp_Object ncons(Lisp_Object a);
1442 extern Lisp_Object ndelete(Lisp_Object a, Lisp_Object b);
1443 extern Lisp_Object negate(Lisp_Object a);
1444 extern Lisp_Object nreverse(Lisp_Object a);
1445 extern FILE *open_file(char *filename, char *original_name,
1446 size_t n, char *dirn, FILE *old_file);
1447 extern Lisp_Object plus2(Lisp_Object a, Lisp_Object b);
1448 extern void preserve(char *msg, int len);
1449 extern void preserve_native_code(void);
1450 extern void relocate_native_function(unsigned char *bps);
1451 extern Lisp_Object prin(Lisp_Object u);
1452 extern char *get_string_data(Lisp_Object a, char *why, int32_t *len);
1453 extern void prin_to_stdout(Lisp_Object u);
1454 extern void prin_to_terminal(Lisp_Object u);
1455 extern void prin_to_debug(Lisp_Object u);
1456 extern void prin_to_query(Lisp_Object u);
1457 extern void prin_to_trace(Lisp_Object u);
1458 extern void prin_to_error(Lisp_Object u);
1459 extern void loop_print_stdout(Lisp_Object o);
1460 extern void loop_print_terminal(Lisp_Object o);
1461 extern void loop_print_debug(Lisp_Object o);
1462 extern void loop_print_query(Lisp_Object o);
1463 extern void loop_print_trace(Lisp_Object o);
1464 extern void loop_print_error(Lisp_Object o);
1465 extern void internal_prin(Lisp_Object u, int prefix);
1466 extern Lisp_Object princ(Lisp_Object u);
1467 extern Lisp_Object print(Lisp_Object u);
1468 extern Lisp_Object printc(Lisp_Object u);
1469 extern void print_bignum(Lisp_Object u, CSLbool blankp, int nobreak);
1470 extern void print_bighexoctbin(Lisp_Object u,
1471 int radix, int width, CSLbool blankp, int nobreak);
1472 extern Lisp_Object putprop(Lisp_Object a, Lisp_Object b,
1473 Lisp_Object c);
1474 extern Lisp_Object quot2(Lisp_Object a, Lisp_Object b);
1475 extern Lisp_Object rational(Lisp_Object a);
1476 extern void read_eval_print(int noisy);
1477 extern Lisp_Object reclaim(Lisp_Object value_to_return, char *why,
1478 int stg_class, intptr_t size);
1479 #ifdef DEBUG
1480 extern void validate_all(char *why, int line, char *file);
1481 extern int check_env(Lisp_Object env);
1482 #endif
1483 extern CSLbool do_not_kill_native_code;
1484 extern void set_fns(Lisp_Object sym, one_args *f1,
1485 two_args *f2, n_args *fn);
1486 extern void setup(int restartp, double storesize);
1487 extern Lisp_Object simplify_string(Lisp_Object s);
1488 extern CSLbool stringp(Lisp_Object a);
1489 extern Lisp_Object times2(Lisp_Object a, Lisp_Object b);
1490 extern int32_t thirty_two_bits(Lisp_Object a);
1491 #ifdef HAVE_INT64_T
1492 extern int64_t sixty_four_bits(Lisp_Object a);
1493 #endif
1494 #ifdef DEBUG
1495 extern void validate_string_fn(Lisp_Object a, char *f, int l);
1496 #define validate_string(a) validate_string_fn(a, __FILE__, __LINE__)
1497 #else
1498 #define validate_string(a)
1499 #endif
1500 #ifdef COMMON
1501 #define onevalue(r) (exit_count=1, (r))
1502 #define nvalues(r, n) (exit_count=(n), (r))
1503 #else
1504 #define onevalue(r) (r)
1505 #define nvalues(r, n) (r)
1506 #endif
1507 #ifdef COMMON
1508 #define eval(a, b) Ceval(a, b)
1509 #define voideval(a, b) Ceval(a, b)
1510 #else
1511 #define eval(a, b) \
1512 (is_cons(a) ? Ceval(a, b) : \
1513 is_symbol(a) ? (qvalue(a) == unset_var ? error(1, err_unset_var, a) : \
1514 onevalue(qvalue(a))) : \
1515 onevalue(a))
1516 #define voideval(a, b) \
1517 if (is_cons(a)) Ceval(a, b)
1518 #endif
1519 #define equal(a, b) \
1520 ((a) == (b) || \
1521 (((((a) ^ (b)) & TAG_BITS) == 0) && \
1522 ((unsigned)(((a) & TAG_BITS) - 1) > 3) && \
1523 equal_fn(a, b)))
1524 #define cl_equal(a, b) \
1525 ((a) == (b) || \
1526 (((((a) ^ (b)) & TAG_BITS) == 0) && \
1527 ((unsigned)(((a) & TAG_BITS) - 1) > 3) && \
1528 cl_equal_fn(a, b)))
1529 #define eql(a, b) \
1530 ((a) == (b) || \
1531 (((((a) ^ (b)) & TAG_BITS) == 0) && \
1532 ((unsigned)(((a) & TAG_BITS) - 1) > 3) && \
1533 eql_fn(a, b)))
1534 #ifndef IMULTIPLY
1535 extern uint32_t Imultiply(uint32_t *rlow, uint32_t a,
1536 uint32_t b, uint32_t c);
1537 #endif
1538 #ifndef IDIVIDE
1539 extern uint32_t Idivide(uint32_t *qp, uint32_t a,
1540 uint32_t b, uint32_t c);
1541 extern uint32_t Idiv10_9(uint32_t *qp, uint32_t a, uint32_t b);
1542 #endif
1543 #define argcheck(var, n, msg) if ((var)!=(n)) return aerror(msg);
1544 extern n_args *zero_arg_functions[];
1545 extern one_args *one_arg_functions[];
1546 extern two_args *two_arg_functions[];
1547 extern n_args *three_arg_functions[];
1548 extern void *useful_functions[];
1549 extern char *address_of_var(int n);
1550 typedef struct setup_type
1551 {
1552 char *name;
1553 one_args *one;
1554 two_args *two;
1555 n_args *n;
1556 } setup_type;
1557 typedef struct setup_type_1
1558 {
1559 char *name;
1560 one_args *one;
1561 two_args *two;
1562 n_args *n;
1563 uint32_t c1;
1564 uint32_t c2;
1565 } setup_type_1;
1566 extern setup_type const
1567 arith06_setup[], arith08_setup[], arith10_setup[], arith12_setup[],
1568 char_setup[], eval1_setup[], eval2_setup[], eval3_setup[],
1569 funcs1_setup[], funcs2_setup[], funcs3_setup[], print_setup[],
1570 read_setup[], mpi_setup[];
1571 extern setup_type const
1572 u01_setup[], u02_setup[], u03_setup[], u04_setup[],
1573 u05_setup[], u06_setup[], u07_setup[], u08_setup[], u09_setup[],
1574 u10_setup[], u11_setup[], u12_setup[], u13_setup[], u14_setup[],
1575 u15_setup[], u16_setup[], u17_setup[], u18_setup[], u19_setup[],
1576 u20_setup[], u21_setup[], u22_setup[], u23_setup[], u24_setup[],
1577 u25_setup[], u26_setup[], u27_setup[], u28_setup[], u29_setup[],
1578 u30_setup[], u31_setup[], u32_setup[], u33_setup[], u34_setup[],
1579 u35_setup[], u36_setup[], u37_setup[], u38_setup[], u39_setup[],
1580 u40_setup[], u41_setup[], u42_setup[], u43_setup[], u44_setup[],
1581 u45_setup[], u46_setup[], u47_setup[], u48_setup[], u49_setup[],
1582 u50_setup[], u51_setup[], u52_setup[], u53_setup[], u54_setup[],
1583 u55_setup[], u56_setup[], u57_setup[], u58_setup[], u59_setup[],
1584 u60_setup[];
1585 extern setup_type const *setup_tables[];
1586 #ifdef NAG
1587 extern setup_type const nag_setup[], asp_setup[];
1588 extern setup_type const socket_setup[], xdr_setup[], grep_setup[];
1589 extern setup_type const gr_setup[], axfns_setup[];
1590 #endif
1591 #ifdef OPENMATH
1592 extern setup_type const om_setup[];
1593 extern setup_type const om_parse_setup[];
1594 #endif
1595 extern char *find_image_directory(int argc, char *argv[]);
1596 extern char program_name[64];
1597 extern Lisp_Object declare_fn(Lisp_Object args, Lisp_Object env);
1598 extern Lisp_Object function_fn(Lisp_Object args, Lisp_Object env);
1599 extern Lisp_Object let_fn_1(Lisp_Object bvl, Lisp_Object body,
1600 Lisp_Object env, int compilerp);
1601 extern Lisp_Object mv_call_fn(Lisp_Object args, Lisp_Object env);
1602 extern Lisp_Object progn_fn(Lisp_Object args, Lisp_Object env);
1603 extern Lisp_Object quote_fn(Lisp_Object args, Lisp_Object env);
1604 extern Lisp_Object tagbody_fn(Lisp_Object args, Lisp_Object env);
1605 extern Lisp_Object resource_exceeded();
1606 extern int64_t time_base, space_base, io_base, errors_base;
1607 extern int64_t time_now, space_now, io_now, errors_now;
1608 extern int64_t time_limit, space_limit, io_limit, errors_limit;
1609 extern CSLbool symbol_protect_flag, warn_about_protected_symbols;
1610 #ifdef JIT
1611 extern char *Jcompile(Lisp_Object def, Lisp_Object env);
1612 extern unsigned long jit_size;
1613 #define JIT_INIT_SIZE 8192
1614 #endif
1615 #ifdef __cplusplus
1616 }
1617 #endif
1618 #endif
1619 #ifndef header_arith_h
1620 #define header_arith_h 1
1621 #define TWO_32 4294967296.0
1622 #define TWO_31 2147483648.0
1623 #define TWO_24 16777216.0
1624 #define TWO_22 4194304.0
1625 #define TWO_21 2097152.0
1626 #define TWO_20 1048576.0
1627 #define M2_31_1 -2147483649.0
1628 #define _pi 3.14159265358979323846
1629 #define _half_pi 1.57079632679489661923
1630 #define boole_clr 0
1631 #define boole_and 1
1632 #define boole_andc2 2
1633 #define boole_1 3
1634 #define boole_andc1 4
1635 #define boole_2 5
1636 #define boole_xor 6
1637 #define boole_ior 7
1638 #define boole_nor 8
1639 #define boole_eqv 9
1640 #define boole_c2 10
1641 #define boole_orc2 11
1642 #define boole_c1 12
1643 #define boole_orc1 13
1644 #define boole_nand 14
1645 #define boole_set 15
1646 #define top_bit_set(n) (((int32_t)(n)) < 0)
1647 #define top_bit(n) (((uint32_t)(n)) >> 31)
1648 #define set_top_bit(n) ((n) | (uint32_t)0x80000000)
1649 #define clear_top_bit(n) ((n) & 0x7fffffff)
1650 #define signed_overflow(n) top_bit_set((n) ^ (((int32_t)(n))<<1))
1651 #ifdef HAVE_UINT64_T
1652 #define IMULTIPLY 1
1653 #define Dmultiply(hi, lo, a, b, c) \
1654 do { uint64_t r64 = (uint64_t)(a) * (uint64_t)(b) + \
1655 (uint32_t)(c); \
1656 (lo) = 0x7fffffffu & (uint32_t)r64; \
1657 (hi) = (uint32_t)(r64 >> 31); } while (0)
1658 #define IDIVIDE 1
1659 #define Ddivide(r, q, a, b, c) \
1660 do { uint64_t r64 = (((uint64_t)(a)) << 31) | (uint64_t)(b); \
1661 uint64_t c64 = (uint64_t)(uint32_t)(c); \
1662 q = (uint32_t)(r64 / c64); \
1663 r = (uint32_t)(r64 % c64); } while (0)
1664 #define Ddiv10_9(r, q, a, b) Ddivide(r, q, a, b, 1000000000u)
1665 #else
1666 #define Dmultiply(hi, lo, a, b, c) ((hi) = Imultiply(&(lo), (a), (b), (c)))
1667 #define Ddivide(r, q, a, b, c) ((r) = Idivide(&(q), (a), (b), (c)))
1668 #define Ddiv10_9(r, q, a, b) ((r) = Idiv10_9(&(q), (a), (b)))
1669 #endif
1670 #define fix_mask (-0x08000000)
1671 #define fixnum_minusp(a) ((int32_t)(a) < 0)
1672 #define bignum_minusp(a) \
1673 ((int32_t)bignum_digits(a)[((bignum_length(a)-CELL)/4)-1]<0)
1674 extern Lisp_Object negateb(Lisp_Object);
1675 extern Lisp_Object copyb(Lisp_Object);
1676 extern Lisp_Object negate(Lisp_Object);
1677 extern Lisp_Object plus2(Lisp_Object a, Lisp_Object b);
1678 extern Lisp_Object difference2(Lisp_Object a, Lisp_Object b);
1679 extern Lisp_Object times2(Lisp_Object a, Lisp_Object b);
1680 extern Lisp_Object quot2(Lisp_Object a, Lisp_Object b);
1681 extern Lisp_Object CLquot2(Lisp_Object a, Lisp_Object b);
1682 extern Lisp_Object quotbn(Lisp_Object a, int32_t n);
1683 extern Lisp_Object quotbn1(Lisp_Object a, int32_t n);
1684 extern Lisp_Object quotbb(Lisp_Object a, Lisp_Object b);
1685 extern Lisp_Object Cremainder(Lisp_Object a, Lisp_Object b);
1686 extern Lisp_Object rembi(Lisp_Object a, Lisp_Object b);
1687 extern Lisp_Object rembb(Lisp_Object a, Lisp_Object b);
1688 extern Lisp_Object shrink_bignum(Lisp_Object a, int32_t lena);
1689 extern Lisp_Object modulus(Lisp_Object a, Lisp_Object b);
1690 extern Lisp_Object rational(Lisp_Object a);
1691 extern Lisp_Object rationalize(Lisp_Object a);
1692 extern Lisp_Object lcm(Lisp_Object a, Lisp_Object b);
1693 extern Lisp_Object lengthen_by_one_bit(Lisp_Object a, int32_t msd);
1694 extern CSLbool numeq2(Lisp_Object a, Lisp_Object b);
1695 extern CSLbool zerop(Lisp_Object a);
1696 extern CSLbool onep(Lisp_Object a);
1697 extern CSLbool minusp(Lisp_Object a);
1698 extern CSLbool plusp(Lisp_Object a);
1699 extern CSLbool lesspbd(Lisp_Object a, double b);
1700 extern CSLbool lessprd(Lisp_Object a, double b);
1701 extern CSLbool lesspdb(double a, Lisp_Object b);
1702 extern CSLbool lesspdr(double a, Lisp_Object b);
1703 extern Lisp_Object make_one_word_bignum(int32_t n);
1704 extern Lisp_Object make_two_word_bignum(int32_t a, uint32_t b);
1705 extern Lisp_Object make_n_word_bignum(int32_t a1, uint32_t a2,
1706 uint32_t a3, int32_t n);
1707 extern Lisp_Object make_sfloat(double d);
1708 extern double float_of_integer(Lisp_Object a);
1709 extern Lisp_Object add1(Lisp_Object p);
1710 extern Lisp_Object sub1(Lisp_Object p);
1711 extern Lisp_Object integerp(Lisp_Object p);
1712 extern double float_of_number(Lisp_Object a);
1713 extern Lisp_Object make_boxfloat(double a, int32_t type);
1714 extern Lisp_Object make_complex(Lisp_Object r, Lisp_Object i);
1715 extern Lisp_Object make_ratio(Lisp_Object p, Lisp_Object q);
1716 extern Lisp_Object ash(Lisp_Object a, Lisp_Object b);
1717 extern Lisp_Object lognot(Lisp_Object a);
1718 extern Lisp_Object logior2(Lisp_Object a, Lisp_Object b);
1719 extern Lisp_Object logxor2(Lisp_Object a, Lisp_Object b);
1720 extern Lisp_Object logand2(Lisp_Object a, Lisp_Object b);
1721 extern Lisp_Object logeqv2(Lisp_Object a, Lisp_Object b);
1722 extern Lisp_Object rationalf(double d);
1723 extern int _reduced_exp(double, double *);
1724 extern CSLbool lesspbi(Lisp_Object a, Lisp_Object b);
1725 extern CSLbool lesspib(Lisp_Object a, Lisp_Object b);
1726 #ifdef COMMON
1727 typedef struct Complex
1728 {
1729 double real;
1730 double imag;
1731 } Complex;
1732 extern Complex MS_CDECL Cln(Complex a);
1733 extern Complex MS_CDECL Ccos(Complex a);
1734 extern Complex MS_CDECL Cexp(Complex a);
1735 extern Complex MS_CDECL Cpow(Complex a, Complex b);
1736 extern double MS_CDECL Cabs(Complex a);
1737 #endif
1738 #endif
1739 #ifndef header_entries_h
1740 #define header_entries_h 1
1741 #ifdef __cplusplus
1742 extern "C" {
1743 #endif
1744 extern Lisp_Object MS_CDECL Lbatchp(Lisp_Object env, int nargs, ...);
1745 extern Lisp_Object MS_CDECL bytecounts(Lisp_Object nil, int nargs, ...);
1746 extern Lisp_Object MS_CDECL Ldate(Lisp_Object env, int nargs, ...);
1747 extern Lisp_Object MS_CDECL Ldatestamp(Lisp_Object nil, int nargs, ...);
1748 extern Lisp_Object MS_CDECL Leject(Lisp_Object env, int nargs, ...);
1749 extern Lisp_Object MS_CDECL Lerror(Lisp_Object env, int nargs, ...);
1750 extern Lisp_Object MS_CDECL Lerror0(Lisp_Object env, int nargs, ...);
1751 extern Lisp_Object MS_CDECL Lflush(Lisp_Object nil, int nargs, ...);
1752 extern Lisp_Object MS_CDECL Lgc0(Lisp_Object nil, int nargs, ...);
1753 extern Lisp_Object MS_CDECL Lgctime(Lisp_Object env, int nargs, ...);
1754 extern Lisp_Object MS_CDECL Lgensym(Lisp_Object env, int nargs, ...);
1755 extern Lisp_Object MS_CDECL Llist_modules(Lisp_Object env, int nargs, ...);
1756 extern Lisp_Object MS_CDECL Llibrary_members0(Lisp_Object env, int nargs, ...);
1757 extern Lisp_Object MS_CDECL Llposn(Lisp_Object env, int nargs, ...);
1758 extern Lisp_Object MS_CDECL Lmapstore0(Lisp_Object env, int nargs, ...);
1759 extern Lisp_Object MS_CDECL Lnext_random(Lisp_Object env, int nargs, ...);
1760 extern Lisp_Object MS_CDECL Lposn(Lisp_Object env, int nargs, ...);
1761 extern Lisp_Object MS_CDECL Lread(Lisp_Object env, int nargs, ...);
1762 extern Lisp_Object MS_CDECL Lreadch(Lisp_Object env, int nargs, ...);
1763 extern Lisp_Object MS_CDECL Lrtell(Lisp_Object nil, int nargs, ...);
1764 extern Lisp_Object MS_CDECL Lterpri(Lisp_Object env, int nargs, ...);
1765 extern Lisp_Object MS_CDECL Ltime(Lisp_Object env, int nargs, ...);
1766 extern Lisp_Object MS_CDECL Ltmpnam(Lisp_Object nil, int nargs, ...);
1767 extern Lisp_Object MS_CDECL Ltyi(Lisp_Object env, int nargs, ...);
1768 extern Lisp_Object autoload1(Lisp_Object env, Lisp_Object a1);
1769 extern Lisp_Object bytecoded1(Lisp_Object env, Lisp_Object a);
1770 extern Lisp_Object byteopt1(Lisp_Object def, Lisp_Object a);
1771 extern Lisp_Object byteoptrest1(Lisp_Object def, Lisp_Object a);
1772 extern Lisp_Object double_bytecoded1(Lisp_Object env, Lisp_Object a);
1773 extern Lisp_Object double_byteopt1(Lisp_Object def, Lisp_Object a);
1774 extern Lisp_Object double_byteoptrest1(Lisp_Object def, Lisp_Object a);
1775 extern Lisp_Object double_funarged1(Lisp_Object env, Lisp_Object a1);
1776 extern Lisp_Object double_hardopt1(Lisp_Object def, Lisp_Object a);
1777 extern Lisp_Object double_hardoptrest1(Lisp_Object def, Lisp_Object a);
1778 extern Lisp_Object double_interpreted1(Lisp_Object env, Lisp_Object a1);
1779 extern Lisp_Object funarged1(Lisp_Object env, Lisp_Object a1);
1780 extern Lisp_Object tracefunarged1(Lisp_Object env, Lisp_Object a1);
1781 extern Lisp_Object hardopt1(Lisp_Object def, Lisp_Object a);
1782 extern Lisp_Object hardoptrest1(Lisp_Object def, Lisp_Object a);
1783 extern Lisp_Object interpreted1(Lisp_Object env, Lisp_Object a1);
1784 extern Lisp_Object tracebytecoded1(Lisp_Object env, Lisp_Object a);
1785 extern Lisp_Object jitcompileme1(Lisp_Object env, Lisp_Object a);
1786 extern Lisp_Object tracebyteopt1(Lisp_Object def, Lisp_Object a);
1787 extern Lisp_Object tracebyteoptrest1(Lisp_Object def, Lisp_Object a);
1788 extern Lisp_Object tracebytecoded1(Lisp_Object env, Lisp_Object a);
1789 extern Lisp_Object traceinterpreted1(Lisp_Object env, Lisp_Object a1);
1790 extern Lisp_Object tracehardopt1(Lisp_Object def, Lisp_Object a);
1791 extern Lisp_Object tracehardoptrest1(Lisp_Object def, Lisp_Object a);
1792 extern Lisp_Object undefined1(Lisp_Object env, Lisp_Object a1);
1793 extern Lisp_Object f1_as_0(Lisp_Object env, Lisp_Object a);
1794 extern Lisp_Object f1_as_1(Lisp_Object env, Lisp_Object a);
1795 #ifdef CJAVA
1796 extern Lisp_Object java1(Lisp_Object env, Lisp_Object a);
1797 #endif
1798 extern Lisp_Object Labsval(Lisp_Object env, Lisp_Object a);
1799 extern Lisp_Object Ladd1(Lisp_Object env, Lisp_Object a);
1800 extern Lisp_Object Lalpha_char_p(Lisp_Object env, Lisp_Object a);
1801 extern Lisp_Object Lapply0(Lisp_Object env, Lisp_Object a);
1802 extern Lisp_Object Lapply_1(Lisp_Object env, Lisp_Object fn);
1803 extern Lisp_Object Latan(Lisp_Object env, Lisp_Object a);
1804 extern Lisp_Object Latom(Lisp_Object env, Lisp_Object a);
1805 extern Lisp_Object Lbanner(Lisp_Object env, Lisp_Object a);
1806 extern Lisp_Object Lboundp(Lisp_Object env, Lisp_Object a);
1807 extern Lisp_Object Lbpsp(Lisp_Object nil, Lisp_Object a);
1808 extern Lisp_Object Lbpsupbv(Lisp_Object nil, Lisp_Object v);
1809 extern Lisp_Object Lcaaaar(Lisp_Object env, Lisp_Object a);
1810 extern Lisp_Object Lcaaadr(Lisp_Object env, Lisp_Object a);
1811 extern Lisp_Object Lcaaar(Lisp_Object env, Lisp_Object a);
1812 extern Lisp_Object Lcaadar(Lisp_Object env, Lisp_Object a);
1813 extern Lisp_Object Lcaaddr(Lisp_Object env, Lisp_Object a);
1814 extern Lisp_Object Lcaadr(Lisp_Object env, Lisp_Object a);
1815 extern Lisp_Object Lcaar(Lisp_Object env, Lisp_Object a);
1816 extern Lisp_Object Lcaar(Lisp_Object env, Lisp_Object a);
1817 extern Lisp_Object Lcadaar(Lisp_Object env, Lisp_Object a);
1818 extern Lisp_Object Lcadadr(Lisp_Object env, Lisp_Object a);
1819 extern Lisp_Object Lcadar(Lisp_Object env, Lisp_Object a);
1820 extern Lisp_Object Lcaddar(Lisp_Object env, Lisp_Object a);
1821 extern Lisp_Object Lcadddr(Lisp_Object env, Lisp_Object a);
1822 extern Lisp_Object Lcaddr(Lisp_Object env, Lisp_Object a);
1823 extern Lisp_Object Lcadr(Lisp_Object env, Lisp_Object a);
1824 extern Lisp_Object Lcadr(Lisp_Object env, Lisp_Object a);
1825 extern Lisp_Object Lcar(Lisp_Object env, Lisp_Object a);
1826 extern Lisp_Object Lcar(Lisp_Object env, Lisp_Object a);
1827 extern Lisp_Object Lcdaaar(Lisp_Object env, Lisp_Object a);
1828 extern Lisp_Object Lcdaadr(Lisp_Object env, Lisp_Object a);
1829 extern Lisp_Object Lcdaar(Lisp_Object env, Lisp_Object a);
1830 extern Lisp_Object Lcdadar(Lisp_Object env, Lisp_Object a);
1831 extern Lisp_Object Lcdaddr(Lisp_Object env, Lisp_Object a);
1832 extern Lisp_Object Lcdadr(Lisp_Object env, Lisp_Object a);
1833 extern Lisp_Object Lcdar(Lisp_Object env, Lisp_Object a);
1834 extern Lisp_Object Lcdar(Lisp_Object env, Lisp_Object a);
1835 extern Lisp_Object Lcddaar(Lisp_Object env, Lisp_Object a);
1836 extern Lisp_Object Lcddadr(Lisp_Object env, Lisp_Object a);
1837 extern Lisp_Object Lcddar(Lisp_Object env, Lisp_Object a);
1838 extern Lisp_Object Lcdddar(Lisp_Object env, Lisp_Object a);
1839 extern Lisp_Object Lcddddr(Lisp_Object env, Lisp_Object a);
1840 extern Lisp_Object Lcdddr(Lisp_Object env, Lisp_Object a);
1841 extern Lisp_Object Lcddr(Lisp_Object env, Lisp_Object a);
1842 extern Lisp_Object Lcddr(Lisp_Object env, Lisp_Object a);
1843 extern Lisp_Object Lcdr(Lisp_Object env, Lisp_Object a);
1844 extern Lisp_Object Lcdr(Lisp_Object env, Lisp_Object a);
1845 extern Lisp_Object Lchar_code(Lisp_Object env, Lisp_Object a);
1846 extern Lisp_Object Lclose(Lisp_Object env, Lisp_Object a);
1847 extern Lisp_Object Lcodep(Lisp_Object env, Lisp_Object a);
1848 extern Lisp_Object Lcompress(Lisp_Object env, Lisp_Object a);
1849 extern Lisp_Object Lconsp(Lisp_Object env, Lisp_Object a);
1850 extern Lisp_Object Lconstantp(Lisp_Object env, Lisp_Object a);
1851 extern Lisp_Object Lcopy_module(Lisp_Object env, Lisp_Object a);
1852 extern Lisp_Object Ldefine_in_module(Lisp_Object env, Lisp_Object a);
1853 extern Lisp_Object Ldelete_module(Lisp_Object env, Lisp_Object a);
1854 extern Lisp_Object Ldigitp(Lisp_Object env, Lisp_Object a);
1855 extern Lisp_Object Lendp(Lisp_Object env, Lisp_Object a);
1856 extern Lisp_Object Lerror1(Lisp_Object nil, Lisp_Object a1);
1857 extern Lisp_Object Lerrorset1(Lisp_Object nil, Lisp_Object form);
1858 extern Lisp_Object Leval(Lisp_Object env, Lisp_Object a);
1859 extern Lisp_Object Levenp(Lisp_Object env, Lisp_Object a);
1860 extern Lisp_Object Levlis(Lisp_Object env, Lisp_Object a);
1861 extern Lisp_Object Lexplode(Lisp_Object env, Lisp_Object a);
1862 extern Lisp_Object Lexplode2lc(Lisp_Object env, Lisp_Object a);
1863 extern Lisp_Object Lexplode2lcn(Lisp_Object nil, Lisp_Object a);
1864 extern Lisp_Object Lexplode2n(Lisp_Object env, Lisp_Object a);
1865 extern Lisp_Object Lexplodec(Lisp_Object env, Lisp_Object a);
1866 extern Lisp_Object Lexplodecn(Lisp_Object env, Lisp_Object a);
1867 extern Lisp_Object Lexplodehex(Lisp_Object nil, Lisp_Object a);
1868 extern Lisp_Object Lexploden(Lisp_Object env, Lisp_Object a);
1869 extern Lisp_Object Lexplodeoctal(Lisp_Object nil, Lisp_Object a);
1870 extern Lisp_Object Lfixp(Lisp_Object env, Lisp_Object a);
1871 extern Lisp_Object Lfloat(Lisp_Object env, Lisp_Object a);
1872 extern Lisp_Object Lfloatp(Lisp_Object env, Lisp_Object a);
1873 extern Lisp_Object Lfrexp(Lisp_Object nil, Lisp_Object a);
1874 extern Lisp_Object Lfuncall1(Lisp_Object env, Lisp_Object fn);
1875 extern Lisp_Object Lgc(Lisp_Object nil, Lisp_Object a);
1876 extern Lisp_Object Lgensym1(Lisp_Object env, Lisp_Object a);
1877 extern Lisp_Object Lgensym2(Lisp_Object env, Lisp_Object a);
1878 extern Lisp_Object Lgetd(Lisp_Object env, Lisp_Object a);
1879 extern Lisp_Object Lgetenv(Lisp_Object env, Lisp_Object a);
1880 extern Lisp_Object Lget_bps(Lisp_Object env, Lisp_Object a);
1881 extern Lisp_Object Lhelp(Lisp_Object nil, Lisp_Object a);
1882 extern Lisp_Object Liadd1(Lisp_Object env, Lisp_Object a);
1883 extern Lisp_Object Lidentity(Lisp_Object env, Lisp_Object a);
1884 extern Lisp_Object Liminus(Lisp_Object env, Lisp_Object a);
1885 extern Lisp_Object Liminusp(Lisp_Object env, Lisp_Object a);
1886 extern Lisp_Object Lindirect(Lisp_Object env, Lisp_Object a);
1887 extern Lisp_Object Lintegerp(Lisp_Object env, Lisp_Object a);
1888 extern Lisp_Object Lintern(Lisp_Object env, Lisp_Object a);
1889 extern Lisp_Object Lionep(Lisp_Object nil, Lisp_Object a);
1890 extern Lisp_Object Lisub1(Lisp_Object env, Lisp_Object a);
1891 extern Lisp_Object Lizerop(Lisp_Object nil, Lisp_Object a);
1892 extern Lisp_Object Llength(Lisp_Object env, Lisp_Object a);
1893 extern Lisp_Object Llengthc(Lisp_Object env, Lisp_Object a);
1894 extern Lisp_Object Llibrary_members(Lisp_Object nil, Lisp_Object a);
1895 extern Lisp_Object Llinelength(Lisp_Object env, Lisp_Object a);
1896 extern Lisp_Object Llist_to_string(Lisp_Object env, Lisp_Object a);
1897 extern Lisp_Object Llist_to_vector(Lisp_Object env, Lisp_Object a);
1898 extern Lisp_Object Lload_module(Lisp_Object env, Lisp_Object a);
1899 extern Lisp_Object Lload_source(Lisp_Object env, Lisp_Object a);
1900 extern Lisp_Object Llognot(Lisp_Object env, Lisp_Object a);
1901 extern Lisp_Object Llog_1(Lisp_Object nil, Lisp_Object a);
1902 extern Lisp_Object Llsd(Lisp_Object env, Lisp_Object a);
1903 extern Lisp_Object Lmacroexpand(Lisp_Object env, Lisp_Object a);
1904 extern Lisp_Object Lmacroexpand_1(Lisp_Object env, Lisp_Object a);
1905 extern Lisp_Object Lmacro_function(Lisp_Object env, Lisp_Object a);
1906 extern Lisp_Object Lmake_global(Lisp_Object env, Lisp_Object a);
1907 extern Lisp_Object Lmake_special(Lisp_Object env, Lisp_Object a);
1908 extern Lisp_Object Lmapstore(Lisp_Object env, Lisp_Object a);
1909 extern Lisp_Object Lmd5(Lisp_Object env, Lisp_Object a1);
1910 extern Lisp_Object Lmd60(Lisp_Object env, Lisp_Object a1);
1911 extern Lisp_Object Lminus(Lisp_Object env, Lisp_Object a);
1912 extern Lisp_Object Lminusp(Lisp_Object env, Lisp_Object a);
1913 extern Lisp_Object Lmkevect(Lisp_Object nil, Lisp_Object n);
1914 extern Lisp_Object Lmkquote(Lisp_Object env, Lisp_Object a);
1915 extern Lisp_Object Lmkvect(Lisp_Object env, Lisp_Object a);
1916 extern Lisp_Object Lmodular_minus(Lisp_Object env, Lisp_Object a);
1917 extern Lisp_Object Lmodular_number(Lisp_Object env, Lisp_Object a);
1918 extern Lisp_Object Lmodular_reciprocal(Lisp_Object env, Lisp_Object a);
1919 extern Lisp_Object Lmodule_exists(Lisp_Object env, Lisp_Object a);
1920 extern Lisp_Object Lmsd(Lisp_Object env, Lisp_Object a);
1921 extern Lisp_Object Lmv_list(Lisp_Object nil, Lisp_Object a);
1922 extern Lisp_Object Lncons(Lisp_Object env, Lisp_Object a);
1923 extern Lisp_Object Lnreverse(Lisp_Object env, Lisp_Object a);
1924 extern Lisp_Object Lnull(Lisp_Object env, Lisp_Object a);
1925 extern Lisp_Object Lnumberp(Lisp_Object env, Lisp_Object a);
1926 extern Lisp_Object Loddp(Lisp_Object env, Lisp_Object a);
1927 extern Lisp_Object Lonep(Lisp_Object env, Lisp_Object a);
1928 extern Lisp_Object Lpagelength(Lisp_Object env, Lisp_Object a);
1929 extern Lisp_Object Lplist(Lisp_Object env, Lisp_Object a);
1930 extern Lisp_Object Lplusp(Lisp_Object env, Lisp_Object a);
1931 extern Lisp_Object Lprin(Lisp_Object env, Lisp_Object a);
1932 extern Lisp_Object Lprin(Lisp_Object env, Lisp_Object a);
1933 extern Lisp_Object Lprin2a(Lisp_Object nil, Lisp_Object a);
1934 extern Lisp_Object Lprinc(Lisp_Object env, Lisp_Object a);
1935 extern Lisp_Object Lprinc(Lisp_Object env, Lisp_Object a);
1936 extern Lisp_Object Lprint(Lisp_Object env, Lisp_Object a);
1937 extern Lisp_Object Lprintc(Lisp_Object env, Lisp_Object a);
1938 extern Lisp_Object Lrandom(Lisp_Object env, Lisp_Object a);
1939 extern Lisp_Object Lrational(Lisp_Object env, Lisp_Object a);
1940 extern Lisp_Object Lrdf1(Lisp_Object env, Lisp_Object a);
1941 extern Lisp_Object Lrds(Lisp_Object env, Lisp_Object a);
1942 extern Lisp_Object Lremd(Lisp_Object env, Lisp_Object a);
1943 extern Lisp_Object Lreverse(Lisp_Object env, Lisp_Object a);
1944 extern Lisp_Object Lsetpchar(Lisp_Object env, Lisp_Object a);
1945 extern Lisp_Object Lset_small_modulus(Lisp_Object env, Lisp_Object a);
1946 extern Lisp_Object Lsmkvect(Lisp_Object env, Lisp_Object a);
1947 extern Lisp_Object Lspecial_char(Lisp_Object env, Lisp_Object a);
1948 extern Lisp_Object Lspecial_form_p(Lisp_Object env, Lisp_Object a);
1949 extern Lisp_Object Lspool(Lisp_Object env, Lisp_Object a);
1950 extern Lisp_Object Lstart_module(Lisp_Object env, Lisp_Object a);
1951 extern Lisp_Object Lstop(Lisp_Object env, Lisp_Object a);
1952 extern Lisp_Object Lstringp(Lisp_Object env, Lisp_Object a);
1953 extern Lisp_Object Lsub1(Lisp_Object env, Lisp_Object a);
1954 extern Lisp_Object Lsymbolp(Lisp_Object env, Lisp_Object a);
1955 extern Lisp_Object Lsymbol_argcount(Lisp_Object env, Lisp_Object a);
1956 extern Lisp_Object Lsymbol_argcode(Lisp_Object env, Lisp_Object a);
1957 extern Lisp_Object Lsymbol_env(Lisp_Object env, Lisp_Object a);
1958 extern Lisp_Object Lsymbol_function(Lisp_Object env, Lisp_Object a);
1959 extern Lisp_Object Lsymbol_globalp(Lisp_Object env, Lisp_Object a);
1960 extern Lisp_Object Lsymbol_name(Lisp_Object env, Lisp_Object a);
1961 extern Lisp_Object Lsymbol_restore_fns(Lisp_Object env, Lisp_Object a);
1962 extern Lisp_Object Lsymbol_specialp(Lisp_Object env, Lisp_Object a);
1963 extern Lisp_Object Lsymbol_value(Lisp_Object env, Lisp_Object a);
1964 extern Lisp_Object Lsystem(Lisp_Object env, Lisp_Object a);
1965 extern Lisp_Object Lthreevectorp(Lisp_Object env, Lisp_Object a);
1966 extern Lisp_Object Ltrace(Lisp_Object env, Lisp_Object a);
1967 extern Lisp_Object Ltruncate(Lisp_Object env, Lisp_Object a);
1968 extern Lisp_Object Lttab(Lisp_Object env, Lisp_Object a);
1969 extern Lisp_Object Ltyo(Lisp_Object env, Lisp_Object a);
1970 extern Lisp_Object Lunintern(Lisp_Object env, Lisp_Object a);
1971 extern Lisp_Object Lunmake_global(Lisp_Object env, Lisp_Object a);
1972 extern Lisp_Object Lunmake_special(Lisp_Object env, Lisp_Object a);
1973 extern Lisp_Object Luntrace(Lisp_Object env, Lisp_Object a);
1974 extern Lisp_Object Lupbv(Lisp_Object env, Lisp_Object a);
1975 extern Lisp_Object Lsimple_vectorp(Lisp_Object env, Lisp_Object a);
1976 extern Lisp_Object Lvectorp(Lisp_Object env, Lisp_Object a);
1977 extern Lisp_Object Lverbos(Lisp_Object env, Lisp_Object a);
1978 extern Lisp_Object Lwhitespace_char_p(Lisp_Object env, Lisp_Object a);
1979 extern Lisp_Object Lwritable_libraryp(Lisp_Object env, Lisp_Object a);
1980 extern Lisp_Object Lwrite_module(Lisp_Object env, Lisp_Object a);
1981 extern Lisp_Object Lwrs(Lisp_Object env, Lisp_Object a);
1982 extern Lisp_Object Lxtab(Lisp_Object env, Lisp_Object a);
1983 extern Lisp_Object Lxtab(Lisp_Object env, Lisp_Object a);
1984 extern Lisp_Object Lzerop(Lisp_Object env, Lisp_Object a);
1985 #ifdef COMMON
1986 extern Lisp_Object Lfind_symbol_1(Lisp_Object nil, Lisp_Object str);
1987 extern Lisp_Object Llistp(Lisp_Object env, Lisp_Object a);
1988 #endif
1989 extern Lisp_Object autoload2(Lisp_Object env, Lisp_Object a1, Lisp_Object a2);
1990 extern Lisp_Object bytecoded2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
1991 extern Lisp_Object byteopt2(Lisp_Object def, Lisp_Object a, Lisp_Object b);
1992 extern Lisp_Object byteoptrest2(Lisp_Object def, Lisp_Object a, Lisp_Object b);
1993 extern Lisp_Object double_bytecoded2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
1994 extern Lisp_Object double_byteopt2(Lisp_Object def, Lisp_Object a, Lisp_Object b);
1995 extern Lisp_Object double_byteoptrest2(Lisp_Object def, Lisp_Object a, Lisp_Object b);
1996 extern Lisp_Object double_funarged2(Lisp_Object env, Lisp_Object a1, Lisp_Object a2);
1997 extern Lisp_Object double_hardopt2(Lisp_Object def, Lisp_Object a, Lisp_Object b);
1998 extern Lisp_Object double_hardoptrest2(Lisp_Object def, Lisp_Object a, Lisp_Object b);
1999 extern Lisp_Object double_interpreted2(Lisp_Object env, Lisp_Object a1, Lisp_Object a2);
2000 extern Lisp_Object funarged2(Lisp_Object env, Lisp_Object a1, Lisp_Object a2);
2001 extern Lisp_Object tracefunarged2(Lisp_Object env, Lisp_Object a1, Lisp_Object a2);
2002 extern Lisp_Object hardopt2(Lisp_Object def, Lisp_Object a, Lisp_Object b);
2003 extern Lisp_Object hardoptrest2(Lisp_Object def, Lisp_Object a, Lisp_Object b);
2004 extern Lisp_Object interpreted2(Lisp_Object env, Lisp_Object a1, Lisp_Object a2);
2005 extern Lisp_Object tracebyteopt2(Lisp_Object def, Lisp_Object a, Lisp_Object b);
2006 extern Lisp_Object tracebyteoptrest2(Lisp_Object def, Lisp_Object a, Lisp_Object b);
2007 extern Lisp_Object tracebytecoded2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2008 extern Lisp_Object jitcompileme2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2009 extern Lisp_Object traceinterpreted2(Lisp_Object env, Lisp_Object a1, Lisp_Object a2);
2010 extern Lisp_Object tracehardopt2(Lisp_Object def, Lisp_Object a, Lisp_Object b);
2011 extern Lisp_Object tracehardoptrest2(Lisp_Object def, Lisp_Object a, Lisp_Object b);
2012 extern Lisp_Object undefined2(Lisp_Object env, Lisp_Object a1, Lisp_Object a2);
2013 extern Lisp_Object f2_as_0(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2014 extern Lisp_Object f2_as_1(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2015 extern Lisp_Object f2_as_2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2016 #ifdef CJAVA
2017 extern Lisp_Object java2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2018 #endif
2019 extern Lisp_Object Lappend(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2020 extern Lisp_Object Lapply_2(Lisp_Object env, Lisp_Object fn, Lisp_Object a1);
2021 extern Lisp_Object Lapply1(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2022 extern Lisp_Object Lash(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2023 extern Lisp_Object Lash1(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2024 extern Lisp_Object Lassoc(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2025 extern Lisp_Object Latan2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2026 extern Lisp_Object Latan2d(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2027 extern Lisp_Object Latsoc(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2028 extern Lisp_Object Lbpsgetv(Lisp_Object nil, Lisp_Object v, Lisp_Object n);
2029 extern Lisp_Object Lcons(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2030 extern Lisp_Object Lcopy_native(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2031 extern Lisp_Object Ldeleq(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2032 extern Lisp_Object Ldelete(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2033 extern Lisp_Object Ldifference2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2034 extern Lisp_Object Ldivide(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2035 extern Lisp_Object Lelt(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2036 extern Lisp_Object Leq(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2037 extern Lisp_Object Leqcar(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2038 extern Lisp_Object Lequalcar(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2039 extern Lisp_Object Leql(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2040 extern Lisp_Object Leqn(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2041 extern Lisp_Object Lcl_equal(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2042 extern Lisp_Object Lequal(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2043 extern Lisp_Object Lerror2(Lisp_Object nil, Lisp_Object a1, Lisp_Object a2);
2044 extern Lisp_Object Lerrorset2(Lisp_Object nil, Lisp_Object form, Lisp_Object ffg1);
2045 extern Lisp_Object Lexpt(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2046 extern Lisp_Object Lflag(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2047 extern Lisp_Object Lflagp(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2048 extern Lisp_Object Lflagpcar(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2049 extern Lisp_Object Lfuncall2(Lisp_Object env, Lisp_Object fn, Lisp_Object a1);
2050 extern Lisp_Object Lgcd(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2051 extern Lisp_Object Lgeq(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2052 extern Lisp_Object Lget(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2053 extern Lisp_Object Lget_hash_2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2054 extern Lisp_Object Lgetv(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2055 extern Lisp_Object Lgreaterp(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2056 extern Lisp_Object Lhelp_2(Lisp_Object nil, Lisp_Object a, Lisp_Object b);
2057 extern Lisp_Object Lidifference(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2058 extern Lisp_Object Ligeq(Lisp_Object nil, Lisp_Object a, Lisp_Object b);
2059 extern Lisp_Object Ligreaterp(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2060 extern Lisp_Object Lileq(Lisp_Object nil, Lisp_Object a, Lisp_Object b);
2061 extern Lisp_Object Lilessp(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2062 extern Lisp_Object Limax(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2063 extern Lisp_Object Limin(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2064 extern Lisp_Object Linorm(Lisp_Object nil, Lisp_Object a, Lisp_Object k);
2065 extern Lisp_Object Linstate_c_code(Lisp_Object nil, Lisp_Object a, Lisp_Object b);
2066 extern Lisp_Object Lintersect(Lisp_Object nil, Lisp_Object a, Lisp_Object b);
2067 extern Lisp_Object Liplus2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2068 extern Lisp_Object Liquotient(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2069 extern Lisp_Object Liremainder(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2070 extern Lisp_Object Lirightshift(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2071 extern Lisp_Object Litimes2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2072 extern Lisp_Object Llcm(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2073 extern Lisp_Object Lleq(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2074 extern Lisp_Object Llessp(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2075 extern Lisp_Object Llist2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2076 extern Lisp_Object Llog(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2077 extern Lisp_Object Llog_2(Lisp_Object nil, Lisp_Object a, Lisp_Object b);
2078 extern Lisp_Object Lmake_random_state(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2079 extern Lisp_Object Lmake_random_state(Lisp_Object nil, Lisp_Object a, Lisp_Object b);
2080 extern Lisp_Object Lmax2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2081 extern Lisp_Object Lmember(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2082 extern Lisp_Object Lmemq(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2083 extern Lisp_Object Lmin2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2084 extern Lisp_Object Lmod(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2085 extern Lisp_Object Lmodular_difference(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2086 extern Lisp_Object Lmodular_expt(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2087 extern Lisp_Object Lmodular_plus(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2088 extern Lisp_Object Lmodular_quotient(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2089 extern Lisp_Object Lmodular_times(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2090 extern Lisp_Object Lnconc(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2091 extern Lisp_Object Lneq(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2092 extern Lisp_Object Lnreverse2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2093 extern Lisp_Object Lorderp(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2094 extern Lisp_Object Lpair(Lisp_Object nil, Lisp_Object a, Lisp_Object b);
2095 extern Lisp_Object Lplus2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2096 extern Lisp_Object Lquotient(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2097 extern Lisp_Object Lrem(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2098 extern Lisp_Object Lremflag(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2099 extern Lisp_Object Lremprop(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2100 extern Lisp_Object Lresource_limit2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2101 extern Lisp_Object Lrplaca(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2102 extern Lisp_Object Lrplacd(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2103 extern Lisp_Object Lrseek(Lisp_Object nil, Lisp_Object a);
2104 extern Lisp_Object Lset(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2105 extern Lisp_Object Lset_help_file(Lisp_Object nil, Lisp_Object a, Lisp_Object b);
2106 extern Lisp_Object Lsgetv(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2107 extern Lisp_Object Lsmemq(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2108 extern Lisp_Object Lsubla(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2109 extern Lisp_Object Lsublis(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2110 extern Lisp_Object Lsymbol_protect(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2111 extern Lisp_Object Lsymbol_set_definition(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2112 extern Lisp_Object Lsymbol_set_env(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2113 extern Lisp_Object Ltimes2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2114 extern Lisp_Object Lunion(Lisp_Object nil, Lisp_Object a, Lisp_Object b);
2115 extern Lisp_Object Lwrite_help_module(Lisp_Object nil, Lisp_Object a, Lisp_Object b);
2116 extern Lisp_Object Lxcons(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2117 #ifdef COMMON
2118 extern Lisp_Object Laref2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2119 extern Lisp_Object Latan_2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2120 extern Lisp_Object Lelt(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2121 extern Lisp_Object Lfloat_2(Lisp_Object nil, Lisp_Object a, Lisp_Object b);
2122 extern Lisp_Object Lintern_2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2123 extern Lisp_Object Lmacroexpand_1_2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2124 extern Lisp_Object Lmacroexpand_2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2125 extern Lisp_Object Lrandom_2(Lisp_Object nil, Lisp_Object a, Lisp_Object b);
2126 extern Lisp_Object Ltruncate_2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2127 extern Lisp_Object Lunintern_2(Lisp_Object env, Lisp_Object a, Lisp_Object b);
2128 #endif
2129 extern Lisp_Object MS_CDECL autoloadn(Lisp_Object env, int nargs, ...);
2130 extern Lisp_Object MS_CDECL bytecoded0(Lisp_Object env, int nargs, ...);
2131 extern Lisp_Object MS_CDECL bytecoded3(Lisp_Object env, int nargs, ...);
2132 extern Lisp_Object MS_CDECL bytecodedn(Lisp_Object env, int nargs, ...);
2133 extern Lisp_Object MS_CDECL byteoptn(Lisp_Object def, int nargs, ...);
2134 extern Lisp_Object MS_CDECL byteoptrestn(Lisp_Object def, int nargs, ...);
2135 extern Lisp_Object MS_CDECL double_bytecoded0(Lisp_Object env, int nargs, ...);
2136 extern Lisp_Object MS_CDECL double_bytecoded3(Lisp_Object env, int nargs, ...);
2137 extern Lisp_Object MS_CDECL double_bytecodedn(Lisp_Object env, int nargs, ...);
2138 extern Lisp_Object MS_CDECL double_byteoptn(Lisp_Object def, int nargs, ...);
2139 extern Lisp_Object MS_CDECL double_byteoptrestn(Lisp_Object def, int nargs, ...);
2140 extern Lisp_Object MS_CDECL double_funargedn(Lisp_Object env, int nargs, ...);
2141 extern Lisp_Object MS_CDECL double_hardoptn(Lisp_Object def, int nargs, ...);
2142 extern Lisp_Object MS_CDECL double_hardoptrestn(Lisp_Object def, int nargs, ...);
2143 extern Lisp_Object MS_CDECL double_interpretedn(Lisp_Object env, int nargs, ...);
2144 extern Lisp_Object MS_CDECL funargedn(Lisp_Object env, int nargs, ...);
2145 extern Lisp_Object MS_CDECL tracefunargedn(Lisp_Object env, int nargs, ...);
2146 extern Lisp_Object MS_CDECL hardoptn(Lisp_Object def, int nargs, ...);
2147 extern Lisp_Object MS_CDECL hardoptrestn(Lisp_Object def, int nargs, ...);
2148 extern Lisp_Object MS_CDECL interpretedn(Lisp_Object env, int nargs, ...);
2149 extern Lisp_Object MS_CDECL tracebyteoptn(Lisp_Object def, int nargs, ...);
2150 extern Lisp_Object MS_CDECL tracebyteoptrestn(Lisp_Object def, int nargs, ...);
2151 extern Lisp_Object MS_CDECL tracebytecoded0(Lisp_Object env, int nargs, ...);
2152 extern Lisp_Object MS_CDECL tracebytecoded3(Lisp_Object env, int nargs, ...);
2153 extern Lisp_Object MS_CDECL tracebytecodedn(Lisp_Object env, int nargs, ...);
2154 extern Lisp_Object MS_CDECL jitcompileme0(Lisp_Object env, int nargs, ...);
2155 extern Lisp_Object MS_CDECL jitcompileme3(Lisp_Object env, int nargs, ...);
2156 extern Lisp_Object MS_CDECL jitcompilemen(Lisp_Object env, int nargs, ...);
2157 extern Lisp_Object MS_CDECL traceinterpretedn(Lisp_Object env, int nargs, ...);
2158 extern Lisp_Object MS_CDECL tracehardoptn(Lisp_Object def, int nargs, ...);
2159 extern Lisp_Object MS_CDECL tracehardoptrestn(Lisp_Object def, int nargs, ...);
2160 extern Lisp_Object MS_CDECL undefinedn(Lisp_Object env, int nargs, ...);
2161 extern Lisp_Object MS_CDECL f0_as_0(Lisp_Object env, int nargs, ...);
2162 extern Lisp_Object MS_CDECL f3_as_0(Lisp_Object env, int nargs, ...);
2163 extern Lisp_Object MS_CDECL f3_as_1(Lisp_Object env, int nargs, ...);
2164 extern Lisp_Object MS_CDECL f3_as_2(Lisp_Object env, int nargs, ...);
2165 extern Lisp_Object MS_CDECL f3_as_3(Lisp_Object env, int nargs, ...);
2166 #ifdef CJAVA
2167 extern Lisp_Object MS_CDECL java0(Lisp_Object env, int nargs, ...);
2168 extern Lisp_Object MS_CDECL java3(Lisp_Object env, int nargs, ...);
2169 extern Lisp_Object MS_CDECL javan(Lisp_Object env, int nargs, ...);
2170 #endif
2171 extern Lisp_Object MS_CDECL Lacons(Lisp_Object env, int nargs, ...);
2172 extern Lisp_Object MS_CDECL Lapply_n(Lisp_Object env, int nargs, ...);
2173 extern Lisp_Object MS_CDECL Lapply2(Lisp_Object env, int nargs, ...);
2174 extern Lisp_Object MS_CDECL Lapply3(Lisp_Object env, int nargs, ...);
2175 extern Lisp_Object MS_CDECL Lbpsputv(Lisp_Object env, int nargs, ...);
2176 extern Lisp_Object MS_CDECL Lerrorset3(Lisp_Object nil, int nargs, ...);
2177 extern Lisp_Object MS_CDECL Lerrorsetn(Lisp_Object env, int nargs, ...);
2178 extern Lisp_Object MS_CDECL Lfuncalln(Lisp_Object env, int nargs, ...);
2179 extern Lisp_Object MS_CDECL Lhelp_n(Lisp_Object nil, int nargs, ...);
2180 extern Lisp_Object MS_CDECL Llist(Lisp_Object env, int nargs, ...);
2181 extern Lisp_Object MS_CDECL Llist2star(Lisp_Object env, int nargs, ...);
2182 extern Lisp_Object MS_CDECL Llist3(Lisp_Object env, int nargs, ...);
2183 extern Lisp_Object MS_CDECL Llogand(Lisp_Object env, int nargs, ...);
2184 extern Lisp_Object MS_CDECL Llogeqv(Lisp_Object env, int nargs, ...);
2185 extern Lisp_Object MS_CDECL Llogor(Lisp_Object env, int nargs, ...);
2186 extern Lisp_Object MS_CDECL Llogxor(Lisp_Object env, int nargs, ...);
2187 extern Lisp_Object MS_CDECL Lmax(Lisp_Object env, int nargs, ...);
2188 extern Lisp_Object MS_CDECL Lmin(Lisp_Object env, int nargs, ...);
2189 extern Lisp_Object MS_CDECL Lmkhash(Lisp_Object nil, int nargs, ...);
2190 extern Lisp_Object MS_CDECL Lput_hash(Lisp_Object env, int nargs, ...);
2191 extern Lisp_Object MS_CDECL Lputprop(Lisp_Object env, int nargs, ...);
2192 extern Lisp_Object MS_CDECL Lputv(Lisp_Object env, int nargs, ...);
2193 extern Lisp_Object MS_CDECL Lresource_limitn(Lisp_Object env, int nargs, ...);
2194 extern Lisp_Object MS_CDECL Lsputv(Lisp_Object env, int nargs, ...);
2195 extern Lisp_Object MS_CDECL Lsubst(Lisp_Object env, int nargs, ...);
2196 extern Lisp_Object MS_CDECL Lvalues(Lisp_Object env, int nargs, ...);
2197 #ifdef COMMON
2198 extern Lisp_Object MS_CDECL Lappend_n(Lisp_Object nil, int nargs, ...);
2199 extern Lisp_Object MS_CDECL Laref(Lisp_Object env, int nargs, ...);
2200 extern Lisp_Object MS_CDECL Laset(Lisp_Object env, int nargs, ...);
2201 extern Lisp_Object MS_CDECL Leqn_n(Lisp_Object nil, int nargs, ...);
2202 extern Lisp_Object MS_CDECL Lgcd_n(Lisp_Object env, int nargs, ...);
2203 extern Lisp_Object MS_CDECL Lgeq_n(Lisp_Object nil, int nargs, ...);
2204 extern Lisp_Object MS_CDECL Lget_3(Lisp_Object env, int nargs, ...);
2205 extern Lisp_Object MS_CDECL Lgreaterp_n(Lisp_Object nil, int nargs, ...);
2206 extern Lisp_Object MS_CDECL Llcm_n(Lisp_Object env, int nargs, ...);
2207 extern Lisp_Object MS_CDECL Lleq_n(Lisp_Object nil, int nargs, ...);
2208 extern Lisp_Object MS_CDECL Llessp_n(Lisp_Object nil, int nargs, ...);
2209 extern Lisp_Object MS_CDECL Lquotient_n(Lisp_Object nil, int nargs, ...);
2210 #endif
2211 #ifdef OPENMATH
2212 extern Lisp_Object MS_CDECL om_openFileDev(Lisp_Object env, int nargs, ...);
2213 extern Lisp_Object om_openStringDev(Lisp_Object nil, Lisp_Object lstr, Lisp_Object lenc);
2214 extern Lisp_Object om_closeDev(Lisp_Object env, Lisp_Object dev);
2215 extern Lisp_Object om_setDevEncoding(Lisp_Object nil, Lisp_Object ldev, Lisp_Object lenc);
2216 extern Lisp_Object om_makeConn(Lisp_Object nil, Lisp_Object ltimeout);
2217 extern Lisp_Object om_closeConn(Lisp_Object nil, Lisp_Object lconn);
2218 extern Lisp_Object om_getConnInDevice(Lisp_Object nil, Lisp_Object lconn);
2219 extern Lisp_Object om_getConnOutDevice(Lisp_Object nil, Lisp_Object lconn);
2220 extern Lisp_Object MS_CDECL om_connectTCP(Lisp_Object nil, int nargs, ...);
2221 extern Lisp_Object om_bindTCP(Lisp_Object nil, Lisp_Object lconn, Lisp_Object lport);
2222 extern Lisp_Object om_putApp(Lisp_Object nil, Lisp_Object ldev);
2223 extern Lisp_Object om_putEndApp(Lisp_Object nil, Lisp_Object ldev);
2224 extern Lisp_Object om_putAtp(Lisp_Object nil, Lisp_Object ldev);
2225 extern Lisp_Object om_putEndAtp(Lisp_Object nil, Lisp_Object ldev);
2226 extern Lisp_Object om_putAttr(Lisp_Object nil, Lisp_Object ldev);
2227 extern Lisp_Object om_putEndAttr(Lisp_Object nil, Lisp_Object ldev);
2228 extern Lisp_Object om_putBind(Lisp_Object nil, Lisp_Object ldev);
2229 extern Lisp_Object om_putEndBind(Lisp_Object nil, Lisp_Object ldev);
2230 extern Lisp_Object om_putBVar(Lisp_Object nil, Lisp_Object ldev);
2231 extern Lisp_Object om_putEndBVar(Lisp_Object nil, Lisp_Object ldev);
2232 extern Lisp_Object om_putError(Lisp_Object nil, Lisp_Object ldev);
2233 extern Lisp_Object om_putEndError(Lisp_Object nil, Lisp_Object ldev);
2234 extern Lisp_Object om_putObject(Lisp_Object nil, Lisp_Object ldev);
2235 extern Lisp_Object om_putEndObject(Lisp_Object nil, Lisp_Object ldev);
2236 extern Lisp_Object om_putInt(Lisp_Object nil, Lisp_Object ldev, Lisp_Object val);
2237 extern Lisp_Object om_putFloat(Lisp_Object nil, Lisp_Object ldev, Lisp_Object val);
2238 extern Lisp_Object om_putByteArray(Lisp_Object nil, Lisp_Object ldev, Lisp_Object val);
2239 extern Lisp_Object om_putVar(Lisp_Object nil, Lisp_Object ldev, Lisp_Object val);
2240 extern Lisp_Object om_putString(Lisp_Object nil, Lisp_Object ldev, Lisp_Object val);
2241 extern Lisp_Object om_putSymbol(Lisp_Object nil, Lisp_Object ldev, Lisp_Object val);
2242 extern Lisp_Object MS_CDECL om_putSymbol2(Lisp_Object nil, int nargs, ...);
2243 extern Lisp_Object om_getApp(Lisp_Object nil, Lisp_Object ldev);
2244 extern Lisp_Object om_getEndApp(Lisp_Object nil, Lisp_Object ldev);
2245 extern Lisp_Object om_getAtp(Lisp_Object nil, Lisp_Object ldev);
2246 extern Lisp_Object om_getEndAtp(Lisp_Object nil, Lisp_Object ldev);
2247 extern Lisp_Object om_getAttr(Lisp_Object nil, Lisp_Object ldev);
2248 extern Lisp_Object om_getEndAttr(Lisp_Object nil, Lisp_Object ldev);
2249 extern Lisp_Object om_getBind(Lisp_Object nil, Lisp_Object ldev);
2250 extern Lisp_Object om_getEndBind(Lisp_Object nil, Lisp_Object ldev);
2251 extern Lisp_Object om_getBVar(Lisp_Object nil, Lisp_Object ldev);
2252 extern Lisp_Object om_getEndBVar(Lisp_Object nil, Lisp_Object ldev);
2253 extern Lisp_Object om_getError(Lisp_Object nil, Lisp_Object ldev);
2254 extern Lisp_Object om_getEndError(Lisp_Object nil, Lisp_Object ldev);
2255 extern Lisp_Object om_getObject(Lisp_Object nil, Lisp_Object ldev);
2256 extern Lisp_Object om_getEndObject(Lisp_Object nil, Lisp_Object ldev);
2257 extern Lisp_Object om_getInt(Lisp_Object nil, Lisp_Object ldev);
2258 extern Lisp_Object om_getFloat(Lisp_Object nil, Lisp_Object ldev);
2259 extern Lisp_Object om_getByteArray(Lisp_Object nil, Lisp_Object ldev);
2260 extern Lisp_Object om_getVar(Lisp_Object nil, Lisp_Object ldev);
2261 extern Lisp_Object om_getString(Lisp_Object nil, Lisp_Object ldev);
2262 extern Lisp_Object om_getSymbol(Lisp_Object nil, Lisp_Object ldev);
2263 extern Lisp_Object om_getType(Lisp_Object nil, Lisp_Object ldev);
2264 extern Lisp_Object om_stringToStringPtr(Lisp_Object nil, Lisp_Object lstr);
2265 extern Lisp_Object om_stringPtrToString(Lisp_Object nil, Lisp_Object lpstr);
2266 extern Lisp_Object om_read(Lisp_Object nil, Lisp_Object dev);
2267 extern Lisp_Object om_supportsCD(Lisp_Object nil, Lisp_Object lcd);
2268 extern Lisp_Object om_supportsSymbol(Lisp_Object nil, Lisp_Object lcd, Lisp_Object lsym);
2269 extern Lisp_Object MS_CDECL om_listCDs(Lisp_Object nil, int nargs, ...);
2270 extern Lisp_Object om_listSymbols(Lisp_Object nil, Lisp_Object lcd);
2271 extern Lisp_Object om_whichCDs(Lisp_Object nil, Lisp_Object lsym);
2272 #endif
2273 #ifdef __cplusplus
2274 }
2275 #endif
2276 #endif
2277
2278
2279 /* Code for lto_hashequalq */
2280
CC_lto_hashequalq(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)2281 static Lisp_Object CC_lto_hashequalq(Lisp_Object env,
2282 Lisp_Object v0000, Lisp_Object v0001)
2283 {
2284 Lisp_Object nil = C_nil;
2285 Lisp_Object v0012, v0013;
2286 Lisp_Object fn;
2287 CSL_IGNORE(nil);
2288 #ifdef DEBUG
2289 if (check_env(env)) return aerror("env for lto_hashequalq");
2290 #endif
2291 if (stack >= stacklimit)
2292 {
2293 push2(v0001,v0000);
2294 env = reclaim(env, "stack", GC_STACK, 0);
2295 pop2(v0000,v0001);
2296 nil = C_nil;
2297 if (exception_pending()) return nil;
2298 }
2299 push(env);
2300 /* space for vars preserved across procedure calls */
2301 push5(nil, nil, nil, nil, nil);
2302 /* copy arguments values to proper place */
2303 stack[-2] = v0001;
2304 stack[-3] = v0000;
2305 /* end of prologue */
2306 v0012 = (Lisp_Object)1; /* 0 */
2307 stack[-1] = v0012;
2308 v0012 = (Lisp_Object)1; /* 0 */
2309 stack[0] = v0012;
2310 goto v0014;
2311
2312 v0014:
2313 v0012 = stack[-3];
2314 if (v0012 == nil) goto v0015;
2315 v0012 = stack[-2];
2316 if (v0012 == nil) goto v0015;
2317 v0012 = stack[-3];
2318 v0012 = qcar(v0012);
2319 v0013 = v0012;
2320 v0012 = stack[-2];
2321 v0012 = qcar(v0012);
2322 stack[-4] = v0012;
2323 v0012 = stack[-3];
2324 v0012 = qcdr(v0012);
2325 stack[-3] = v0012;
2326 v0012 = stack[-2];
2327 v0012 = qcdr(v0012);
2328 stack[-2] = v0012;
2329 v0012 = v0013;
2330 fn = elt(env, 2); /* lto_hashid */
2331 v0012 = (*qfn1(fn))(qenv(fn), v0012);
2332 nil = C_nil;
2333 if (exception_pending()) goto v0016;
2334 env = stack[-5];
2335 v0012 = (Lisp_Object)(int32_t)((int32_t)stack[-1] + (int32_t)v0012 - TAG_FIXNUM);
2336 stack[-1] = v0012;
2337 v0012 = stack[-4];
2338 fn = elt(env, 2); /* lto_hashid */
2339 v0012 = (*qfn1(fn))(qenv(fn), v0012);
2340 nil = C_nil;
2341 if (exception_pending()) goto v0016;
2342 env = stack[-5];
2343 v0012 = (Lisp_Object)(int32_t)((int32_t)stack[0] + (int32_t)v0012 - TAG_FIXNUM);
2344 stack[0] = v0012;
2345 goto v0014;
2346
2347 v0015:
2348 v0012 = stack[-3];
2349 if (v0012 == nil) goto v0017;
2350 v0012 = qvalue(elt(env, 1)); /* nil */
2351 { popv(6); return onevalue(v0012); }
2352
2353 v0017:
2354 v0012 = stack[-2];
2355 if (v0012 == nil) goto v0018;
2356 v0012 = qvalue(elt(env, 1)); /* nil */
2357 { popv(6); return onevalue(v0012); }
2358
2359 v0018:
2360 v0013 = stack[-1];
2361 v0012 = stack[0];
2362 popv(6);
2363 return Leqn(nil, v0013, v0012);
2364 /* error exit handlers */
2365 v0016:
2366 popv(6);
2367 return nil;
2368 }
2369
2370
2371
2372 /* Code for compress!* */
2373
CC_compressH(Lisp_Object env,Lisp_Object v0000)2374 static Lisp_Object CC_compressH(Lisp_Object env,
2375 Lisp_Object v0000)
2376 {
2377 Lisp_Object nil = C_nil;
2378 Lisp_Object v0035, v0036, v0037, v0038;
2379 CSL_IGNORE(nil);
2380 #ifdef DEBUG
2381 if (check_env(env)) return aerror("env for compress*");
2382 #endif
2383 if (stack >= stacklimit)
2384 {
2385 push(v0000);
2386 env = reclaim(env, "stack", GC_STACK, 0);
2387 pop(v0000);
2388 nil = C_nil;
2389 if (exception_pending()) return nil;
2390 }
2391 push(env);
2392 /* space for vars preserved across procedure calls */
2393 push(nil);
2394 /* copy arguments values to proper place */
2395 v0035 = v0000;
2396 /* end of prologue */
2397 v0038 = nil;
2398 v0036 = v0035;
2399 v0036 = qcar(v0036);
2400 v0036 = Ldigitp(nil, v0036);
2401 env = stack[-1];
2402 if (v0036 == nil) goto v0004;
2403 popv(2);
2404 return Lcompress(nil, v0035);
2405
2406 v0004:
2407 stack[0] = v0035;
2408 goto v0039;
2409
2410 v0039:
2411 v0035 = stack[0];
2412 if (v0035 == nil) goto v0040;
2413 v0035 = stack[0];
2414 v0035 = qcar(v0035);
2415 v0037 = v0035;
2416 v0036 = v0037;
2417 v0035 = elt(env, 2); /* !/ */
2418 if (v0036 == v0035) goto v0041;
2419 v0036 = v0037;
2420 v0035 = elt(env, 4); /* !- */
2421 if (v0036 == v0035) goto v0042;
2422 v0036 = v0037;
2423 v0035 = elt(env, 5); /* !; */
2424 if (v0036 == v0035) goto v0043;
2425 v0036 = v0037;
2426 v0035 = elt(env, 6); /* !. */
2427 v0035 = (v0036 == v0035 ? lisp_true : nil);
2428 goto v0044;
2429
2430 v0044:
2431 if (v0035 == nil) goto v0045;
2432 v0036 = v0037;
2433 v0035 = elt(env, 7); /* !! */
2434 v0037 = v0038;
2435 v0035 = list2star(v0036, v0035, v0037);
2436 nil = C_nil;
2437 if (exception_pending()) goto v0046;
2438 env = stack[-1];
2439 v0038 = v0035;
2440 goto v0047;
2441
2442 v0047:
2443 v0035 = stack[0];
2444 v0035 = qcdr(v0035);
2445 stack[0] = v0035;
2446 goto v0039;
2447
2448 v0045:
2449 v0035 = v0037;
2450 v0036 = v0038;
2451 v0035 = cons(v0035, v0036);
2452 nil = C_nil;
2453 if (exception_pending()) goto v0046;
2454 env = stack[-1];
2455 v0038 = v0035;
2456 goto v0047;
2457
2458 v0043:
2459 v0035 = qvalue(elt(env, 3)); /* t */
2460 goto v0044;
2461
2462 v0042:
2463 v0035 = qvalue(elt(env, 3)); /* t */
2464 goto v0044;
2465
2466 v0041:
2467 v0035 = qvalue(elt(env, 3)); /* t */
2468 goto v0044;
2469
2470 v0040:
2471 v0035 = v0038;
2472 v0035 = Lnreverse(nil, v0035);
2473 env = stack[-1];
2474 v0035 = Lcompress(nil, v0035);
2475 nil = C_nil;
2476 if (exception_pending()) goto v0046;
2477 popv(2);
2478 return Lintern(nil, v0035);
2479 /* error exit handlers */
2480 v0046:
2481 popv(2);
2482 return nil;
2483 }
2484
2485
2486
2487 /* Code for noncomp1 */
2488
CC_noncomp1(Lisp_Object env,Lisp_Object v0000)2489 static Lisp_Object CC_noncomp1(Lisp_Object env,
2490 Lisp_Object v0000)
2491 {
2492 Lisp_Object nil = C_nil;
2493 Lisp_Object v0048, v0017, v0049;
2494 Lisp_Object fn;
2495 CSL_IGNORE(nil);
2496 #ifdef DEBUG
2497 if (check_env(env)) return aerror("env for noncomp1");
2498 #endif
2499 if (stack >= stacklimit)
2500 {
2501 push(v0000);
2502 env = reclaim(env, "stack", GC_STACK, 0);
2503 pop(v0000);
2504 nil = C_nil;
2505 if (exception_pending()) return nil;
2506 }
2507 push(env);
2508 /* copy arguments values to proper place */
2509 v0017 = v0000;
2510 /* end of prologue */
2511 v0048 = v0017;
2512 v0048 = Lconsp(nil, v0048);
2513 env = stack[0];
2514 if (v0048 == nil) goto v0006;
2515 v0048 = v0017;
2516 v0048 = qcar(v0048);
2517 v0048 = Lconsp(nil, v0048);
2518 env = stack[0];
2519 if (v0048 == nil) goto v0050;
2520 v0048 = qvalue(elt(env, 2)); /* !*ncmp */
2521 if (v0048 == nil) goto v0040;
2522 v0048 = v0017;
2523 {
2524 popv(1);
2525 fn = elt(env, 5); /* noncomfp1 */
2526 return (*qfn1(fn))(qenv(fn), v0048);
2527 }
2528
2529 v0040:
2530 v0048 = qvalue(elt(env, 1)); /* nil */
2531 { popv(1); return onevalue(v0048); }
2532
2533 v0050:
2534 v0048 = v0017;
2535 v0049 = qcar(v0048);
2536 v0048 = elt(env, 3); /* taylor!* */
2537 if (v0049 == v0048) goto v0051;
2538 v0048 = v0017;
2539 v0048 = qcar(v0048);
2540 if (!symbolp(v0048)) v0048 = nil;
2541 else { v0048 = qfastgets(v0048);
2542 if (v0048 != nil) { v0048 = elt(v0048, 0); /* noncom */
2543 #ifdef RECORD_GET
2544 if (v0048 == SPID_NOPROP)
2545 record_get(elt(fastget_names, 0), 0),
2546 v0048 = nil;
2547 else record_get(elt(fastget_names, 0), 1),
2548 v0048 = lisp_true; }
2549 else record_get(elt(fastget_names, 0), 0); }
2550 #else
2551 if (v0048 == SPID_NOPROP) v0048 = nil; else v0048 = lisp_true; }}
2552 #endif
2553 if (v0048 == nil) goto v0008;
2554 v0048 = qvalue(elt(env, 4)); /* t */
2555 { popv(1); return onevalue(v0048); }
2556
2557 v0008:
2558 v0048 = v0017;
2559 v0048 = qcdr(v0048);
2560 {
2561 popv(1);
2562 fn = elt(env, 6); /* noncomlistp */
2563 return (*qfn1(fn))(qenv(fn), v0048);
2564 }
2565
2566 v0051:
2567 v0048 = qvalue(elt(env, 1)); /* nil */
2568 { popv(1); return onevalue(v0048); }
2569
2570 v0006:
2571 v0048 = qvalue(elt(env, 1)); /* nil */
2572 { popv(1); return onevalue(v0048); }
2573 }
2574
2575
2576
2577 /* Code for ps!:order */
2578
CC_psTorder(Lisp_Object env,Lisp_Object v0000)2579 static Lisp_Object CC_psTorder(Lisp_Object env,
2580 Lisp_Object v0000)
2581 {
2582 Lisp_Object nil = C_nil;
2583 Lisp_Object v0054, v0048, v0017;
2584 Lisp_Object fn;
2585 CSL_IGNORE(nil);
2586 #ifdef DEBUG
2587 if (check_env(env)) return aerror("env for ps:order");
2588 #endif
2589 if (stack >= stacklimit)
2590 {
2591 push(v0000);
2592 env = reclaim(env, "stack", GC_STACK, 0);
2593 pop(v0000);
2594 nil = C_nil;
2595 if (exception_pending()) return nil;
2596 }
2597 push(env);
2598 /* copy arguments values to proper place */
2599 v0048 = v0000;
2600 /* end of prologue */
2601 v0054 = v0048;
2602 if (!consp(v0054)) goto v0055;
2603 v0054 = v0048;
2604 v0017 = qcar(v0054);
2605 v0054 = elt(env, 2); /* !:ps!: */
2606 if (v0017 == v0054) goto v0056;
2607 v0054 = v0048;
2608 v0017 = qcar(v0054);
2609 v0054 = elt(env, 3); /* dname */
2610 v0054 = get(v0017, v0054);
2611 env = stack[0];
2612 goto v0057;
2613
2614 v0057:
2615 if (v0054 == nil) goto v0058;
2616 v0054 = (Lisp_Object)1; /* 0 */
2617 { popv(1); return onevalue(v0054); }
2618
2619 v0058:
2620 v0054 = (Lisp_Object)1; /* 0 */
2621 {
2622 popv(1);
2623 fn = elt(env, 5); /* ps!:getv */
2624 return (*qfn2(fn))(qenv(fn), v0048, v0054);
2625 }
2626
2627 v0056:
2628 v0054 = qvalue(elt(env, 4)); /* nil */
2629 goto v0057;
2630
2631 v0055:
2632 v0054 = qvalue(elt(env, 1)); /* t */
2633 goto v0057;
2634 }
2635
2636
2637
2638 /* Code for !:zerop */
2639
CC_Tzerop(Lisp_Object env,Lisp_Object v0000)2640 static Lisp_Object CC_Tzerop(Lisp_Object env,
2641 Lisp_Object v0000)
2642 {
2643 Lisp_Object nil = C_nil;
2644 Lisp_Object v0008, v0009, v0052;
2645 CSL_IGNORE(nil);
2646 #ifdef DEBUG
2647 if (check_env(env)) return aerror("env for :zerop");
2648 #endif
2649 if (stack >= stacklimit)
2650 {
2651 push(v0000);
2652 env = reclaim(env, "stack", GC_STACK, 0);
2653 pop(v0000);
2654 nil = C_nil;
2655 if (exception_pending()) return nil;
2656 }
2657 CSL_IGNORE(env);
2658 /* copy arguments values to proper place */
2659 v0052 = v0000;
2660 /* end of prologue */
2661 v0008 = v0052;
2662 if (v0008 == nil) goto v0055;
2663 v0009 = v0052;
2664 v0008 = (Lisp_Object)1; /* 0 */
2665 v0008 = (v0009 == v0008 ? lisp_true : nil);
2666 goto v0057;
2667
2668 v0057:
2669 if (v0008 == nil) goto v0005;
2670 v0008 = qvalue(elt(env, 1)); /* t */
2671 return onevalue(v0008);
2672
2673 v0005:
2674 v0008 = v0052;
2675 if (!consp(v0008)) goto v0062;
2676 v0008 = v0052;
2677 v0009 = qcar(v0008);
2678 v0008 = elt(env, 3); /* zerop */
2679 v0008 = get(v0009, v0008);
2680 v0009 = v0052;
2681 return Lapply1(nil, v0008, v0009);
2682
2683 v0062:
2684 v0008 = qvalue(elt(env, 2)); /* nil */
2685 return onevalue(v0008);
2686
2687 v0055:
2688 v0008 = qvalue(elt(env, 1)); /* t */
2689 goto v0057;
2690 }
2691
2692
2693
2694 /* Code for retimes */
2695
CC_retimes(Lisp_Object env,Lisp_Object v0000)2696 static Lisp_Object CC_retimes(Lisp_Object env,
2697 Lisp_Object v0000)
2698 {
2699 Lisp_Object nil = C_nil;
2700 Lisp_Object v0008, v0009;
2701 Lisp_Object fn;
2702 CSL_IGNORE(nil);
2703 #ifdef DEBUG
2704 if (check_env(env)) return aerror("env for retimes");
2705 #endif
2706 if (stack >= stacklimit)
2707 {
2708 push(v0000);
2709 env = reclaim(env, "stack", GC_STACK, 0);
2710 pop(v0000);
2711 nil = C_nil;
2712 if (exception_pending()) return nil;
2713 }
2714 push(env);
2715 /* space for vars preserved across procedure calls */
2716 push(nil);
2717 /* copy arguments values to proper place */
2718 v0008 = v0000;
2719 /* end of prologue */
2720 stack[0] = qvalue(elt(env, 1)); /* !*bool */
2721 qvalue(elt(env, 1)) = nil; /* !*bool */
2722 fn = elt(env, 4); /* retimes1 */
2723 v0008 = (*qfn1(fn))(qenv(fn), v0008);
2724 nil = C_nil;
2725 if (exception_pending()) goto v0042;
2726 env = stack[-1];
2727 v0009 = v0008;
2728 if (v0009 == nil) goto v0064;
2729 v0009 = v0008;
2730 v0009 = qcdr(v0009);
2731 if (v0009 == nil) goto v0053;
2732 v0009 = elt(env, 2); /* times */
2733 v0008 = cons(v0009, v0008);
2734 nil = C_nil;
2735 if (exception_pending()) goto v0042;
2736 env = stack[-1];
2737 goto v0055;
2738
2739 v0055:
2740 v0009 = qvalue(elt(env, 1)); /* !*bool */
2741 if (v0009 == nil) goto v0006;
2742 v0009 = elt(env, 3); /* minus */
2743 v0008 = list2(v0009, v0008);
2744 nil = C_nil;
2745 if (exception_pending()) goto v0042;
2746 env = stack[-1];
2747 goto v0006;
2748
2749 v0006:
2750 qvalue(elt(env, 1)) = stack[0]; /* !*bool */
2751 { popv(2); return onevalue(v0008); }
2752
2753 v0053:
2754 v0008 = qcar(v0008);
2755 goto v0055;
2756
2757 v0064:
2758 v0008 = (Lisp_Object)17; /* 1 */
2759 goto v0055;
2760 /* error exit handlers */
2761 v0042:
2762 env = stack[-1];
2763 qvalue(elt(env, 1)) = stack[0]; /* !*bool */
2764 popv(2);
2765 return nil;
2766 }
2767
2768
2769
2770 /* Code for bczero!? */
2771
CC_bczeroW(Lisp_Object env,Lisp_Object v0000)2772 static Lisp_Object CC_bczeroW(Lisp_Object env,
2773 Lisp_Object v0000)
2774 {
2775 Lisp_Object nil = C_nil;
2776 Lisp_Object v0061, v0065;
2777 CSL_IGNORE(nil);
2778 #ifdef DEBUG
2779 if (check_env(env)) return aerror("env for bczero?");
2780 #endif
2781 CSL_IGNORE(env);
2782 /* copy arguments values to proper place */
2783 v0061 = v0000;
2784 /* end of prologue */
2785 v0065 = qvalue(elt(env, 1)); /* !*grmod!* */
2786 if (v0065 == nil) goto v0066;
2787 v0065 = v0061;
2788 v0061 = (Lisp_Object)1; /* 0 */
2789 return Leqn(nil, v0065, v0061);
2790
2791 v0066:
2792 v0061 = qcar(v0061);
2793 v0061 = (v0061 == nil ? lisp_true : nil);
2794 return onevalue(v0061);
2795 }
2796
2797
2798
2799 /* Code for rd!:zerop */
2800
CC_rdTzerop(Lisp_Object env,Lisp_Object v0000)2801 static Lisp_Object CC_rdTzerop(Lisp_Object env,
2802 Lisp_Object v0000)
2803 {
2804 Lisp_Object nil = C_nil;
2805 Lisp_Object v0062, v0051;
2806 CSL_IGNORE(nil);
2807 #ifdef DEBUG
2808 if (check_env(env)) return aerror("env for rd:zerop");
2809 #endif
2810 CSL_IGNORE(env);
2811 /* copy arguments values to proper place */
2812 v0062 = v0000;
2813 /* end of prologue */
2814 v0051 = v0062;
2815 v0051 = qcdr(v0051);
2816 if (!consp(v0051)) goto v0006;
2817 v0062 = qcdr(v0062);
2818 v0051 = qcar(v0062);
2819 v0062 = (Lisp_Object)1; /* 0 */
2820 v0062 = (v0051 == v0062 ? lisp_true : nil);
2821 return onevalue(v0062);
2822
2823 v0006:
2824 v0062 = qcdr(v0062);
2825 return Lzerop(nil, v0062);
2826 }
2827
2828
2829
2830 /* Code for evzero!? */
2831
CC_evzeroW(Lisp_Object env,Lisp_Object v0000)2832 static Lisp_Object CC_evzeroW(Lisp_Object env,
2833 Lisp_Object v0000)
2834 {
2835 Lisp_Object nil = C_nil;
2836 Lisp_Object v0067, v0047, v0068;
2837 CSL_IGNORE(nil);
2838 #ifdef DEBUG
2839 if (check_env(env)) return aerror("env for evzero?");
2840 #endif
2841 CSL_IGNORE(env);
2842 /* copy arguments values to proper place */
2843 v0047 = v0000;
2844 /* end of prologue */
2845
2846 v0069:
2847 v0067 = v0047;
2848 if (v0067 == nil) goto v0006;
2849 v0067 = v0047;
2850 v0068 = qcar(v0067);
2851 v0067 = (Lisp_Object)1; /* 0 */
2852 if (v0068 == v0067) goto v0015;
2853 v0067 = qvalue(elt(env, 2)); /* nil */
2854 return onevalue(v0067);
2855
2856 v0015:
2857 v0067 = v0047;
2858 v0067 = qcdr(v0067);
2859 v0047 = v0067;
2860 goto v0069;
2861
2862 v0006:
2863 v0067 = qvalue(elt(env, 1)); /* t */
2864 return onevalue(v0067);
2865 }
2866
2867
2868
2869 /* Code for factorordp */
2870
CC_factorordp(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)2871 static Lisp_Object CC_factorordp(Lisp_Object env,
2872 Lisp_Object v0000, Lisp_Object v0001)
2873 {
2874 Lisp_Object nil = C_nil;
2875 Lisp_Object v0053, v0050, v0022, v0067;
2876 Lisp_Object fn;
2877 CSL_IGNORE(nil);
2878 #ifdef DEBUG
2879 if (check_env(env)) return aerror("env for factorordp");
2880 #endif
2881 CSL_IGNORE(env);
2882 /* copy arguments values to proper place */
2883 v0022 = v0001;
2884 v0067 = v0000;
2885 /* end of prologue */
2886 v0050 = v0067;
2887 v0053 = v0022;
2888 if (v0050 == v0053) goto v0005;
2889 v0053 = v0067;
2890 v0050 = v0022;
2891 {
2892 fn = elt(env, 2); /* worderp */
2893 return (*qfn2(fn))(qenv(fn), v0053, v0050);
2894 }
2895
2896 v0005:
2897 v0053 = qvalue(elt(env, 1)); /* nil */
2898 return onevalue(v0053);
2899 }
2900
2901
2902
2903 /* Code for mtchp */
2904
CC_mtchp(Lisp_Object env,int nargs,Lisp_Object v0000,Lisp_Object v0001,Lisp_Object v0019,Lisp_Object v0007,Lisp_Object v0006,...)2905 static Lisp_Object MS_CDECL CC_mtchp(Lisp_Object env, int nargs,
2906 Lisp_Object v0000, Lisp_Object v0001,
2907 Lisp_Object v0019, Lisp_Object v0007,
2908 Lisp_Object v0006, ...)
2909 {
2910 Lisp_Object nil = C_nil;
2911 Lisp_Object v0081, v0082, v0083, v0084;
2912 Lisp_Object fn;
2913 CSL_IGNORE(nil);
2914 argcheck(nargs, 5, "mtchp");
2915 #ifdef DEBUG
2916 if (check_env(env)) return aerror("env for mtchp");
2917 #endif
2918 if (stack >= stacklimit)
2919 {
2920 push5(v0006,v0007,v0019,v0001,v0000);
2921 env = reclaim(env, "stack", GC_STACK, 0);
2922 pop5(v0000,v0001,v0019,v0007,v0006);
2923 nil = C_nil;
2924 if (exception_pending()) return nil;
2925 }
2926 push(env);
2927 /* space for vars preserved across procedure calls */
2928 push5(nil, nil, nil, nil, nil);
2929 /* copy arguments values to proper place */
2930 stack[0] = v0006;
2931 v0081 = v0007;
2932 stack[-1] = v0019;
2933 stack[-2] = v0001;
2934 stack[-3] = v0000;
2935 /* end of prologue */
2936 v0084 = stack[-3];
2937 v0083 = stack[-2];
2938 v0082 = v0081;
2939 v0081 = stack[0];
2940 fn = elt(env, 2); /* mtchp1 */
2941 v0081 = (*qfnn(fn))(qenv(fn), 4, v0084, v0083, v0082, v0081);
2942 nil = C_nil;
2943 if (exception_pending()) goto v0085;
2944 env = stack[-5];
2945 stack[-4] = v0081;
2946 goto v0064;
2947
2948 v0064:
2949 v0081 = stack[-4];
2950 if (v0081 == nil) goto v0022;
2951 v0081 = stack[-4];
2952 v0082 = qcar(v0081);
2953 v0081 = stack[0];
2954 v0081 = Lsubla(nil, v0082, v0081);
2955 nil = C_nil;
2956 if (exception_pending()) goto v0085;
2957 env = stack[-5];
2958 fn = elt(env, 3); /* eval */
2959 v0081 = (*qfn1(fn))(qenv(fn), v0081);
2960 nil = C_nil;
2961 if (exception_pending()) goto v0085;
2962 env = stack[-5];
2963 if (v0081 == nil) goto v0050;
2964 v0081 = stack[-3];
2965 stack[0] = qcdr(v0081);
2966 v0081 = stack[-4];
2967 v0082 = qcar(v0081);
2968 v0081 = stack[-2];
2969 v0081 = qcdr(v0081);
2970 v0081 = Lsubla(nil, v0082, v0081);
2971 nil = C_nil;
2972 if (exception_pending()) goto v0085;
2973 env = stack[-5];
2974 v0081 = Ldivide(nil, stack[0], v0081);
2975 nil = C_nil;
2976 if (exception_pending()) goto v0085;
2977 env = stack[-5];
2978 stack[-2] = v0081;
2979 v0081 = stack[-4];
2980 v0082 = qcar(v0081);
2981 v0081 = stack[-1];
2982 v0081 = Lsubla(nil, v0082, v0081);
2983 nil = C_nil;
2984 if (exception_pending()) goto v0085;
2985 env = stack[-5];
2986 fn = elt(env, 4); /* simp */
2987 v0082 = (*qfn1(fn))(qenv(fn), v0081);
2988 nil = C_nil;
2989 if (exception_pending()) goto v0085;
2990 env = stack[-5];
2991 v0081 = stack[-2];
2992 v0081 = qcar(v0081);
2993 fn = elt(env, 5); /* exptsq */
2994 v0081 = (*qfn2(fn))(qenv(fn), v0082, v0081);
2995 nil = C_nil;
2996 if (exception_pending()) goto v0085;
2997 env = stack[-5];
2998 stack[-1] = v0081;
2999 v0081 = stack[-2];
3000 v0082 = qcdr(v0081);
3001 v0081 = (Lisp_Object)1; /* 0 */
3002 if (v0082 == v0081) { Lisp_Object res = stack[-1]; popv(6); return onevalue(res); }
3003 v0081 = stack[-3];
3004 v0083 = qcar(v0081);
3005 v0081 = stack[-2];
3006 v0082 = qcdr(v0081);
3007 v0081 = (Lisp_Object)17; /* 1 */
3008 v0081 = acons(v0083, v0082, v0081);
3009 nil = C_nil;
3010 if (exception_pending()) goto v0085;
3011 env = stack[-5];
3012 v0082 = ncons(v0081);
3013 nil = C_nil;
3014 if (exception_pending()) goto v0085;
3015 env = stack[-5];
3016 v0081 = (Lisp_Object)17; /* 1 */
3017 v0082 = cons(v0082, v0081);
3018 nil = C_nil;
3019 if (exception_pending()) goto v0085;
3020 env = stack[-5];
3021 v0081 = stack[-1];
3022 fn = elt(env, 6); /* multsq */
3023 v0081 = (*qfn2(fn))(qenv(fn), v0082, v0081);
3024 nil = C_nil;
3025 if (exception_pending()) goto v0085;
3026 stack[-1] = v0081;
3027 { Lisp_Object res = stack[-1]; popv(6); return onevalue(res); }
3028
3029 v0050:
3030 v0081 = stack[-4];
3031 v0081 = qcdr(v0081);
3032 stack[-4] = v0081;
3033 goto v0064;
3034
3035 v0022:
3036 v0081 = qvalue(elt(env, 1)); /* nil */
3037 { popv(6); return onevalue(v0081); }
3038 /* error exit handlers */
3039 v0085:
3040 popv(6);
3041 return nil;
3042 }
3043
3044
3045
3046 /* Code for collectindices_reversed */
3047
CC_collectindices_reversed(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)3048 static Lisp_Object CC_collectindices_reversed(Lisp_Object env,
3049 Lisp_Object v0000, Lisp_Object v0001)
3050 {
3051 Lisp_Object nil = C_nil;
3052 Lisp_Object v0042, v0054;
3053 Lisp_Object fn;
3054 CSL_IGNORE(nil);
3055 #ifdef DEBUG
3056 if (check_env(env)) return aerror("env for collectindices_reversed");
3057 #endif
3058 if (stack >= stacklimit)
3059 {
3060 push2(v0001,v0000);
3061 env = reclaim(env, "stack", GC_STACK, 0);
3062 pop2(v0000,v0001);
3063 nil = C_nil;
3064 if (exception_pending()) return nil;
3065 }
3066 push(env);
3067 /* space for vars preserved across procedure calls */
3068 push2(nil, nil);
3069 /* copy arguments values to proper place */
3070 stack[0] = v0001;
3071 stack[-1] = v0000;
3072 /* end of prologue */
3073 v0042 = stack[-1];
3074 if (!(!consp(v0042))) goto v0047;
3075 v0042 = stack[-1];
3076 fn = elt(env, 2); /* isanindex */
3077 v0042 = (*qfn1(fn))(qenv(fn), v0042);
3078 nil = C_nil;
3079 if (exception_pending()) goto v0049;
3080 if (v0042 == nil) { Lisp_Object res = stack[0]; popv(3); return onevalue(res); }
3081 v0054 = stack[-1];
3082 v0042 = stack[0];
3083 popv(3);
3084 return cons(v0054, v0042);
3085
3086 v0047:
3087 v0042 = stack[-1];
3088 if (v0042 == nil) { Lisp_Object res = stack[0]; popv(3); return onevalue(res); }
3089 v0042 = stack[-1];
3090 v0054 = qcar(v0042);
3091 v0042 = stack[0];
3092 v0042 = CC_collectindices_reversed(env, v0054, v0042);
3093 nil = C_nil;
3094 if (exception_pending()) goto v0049;
3095 env = stack[-2];
3096 stack[0] = v0042;
3097 v0042 = stack[-1];
3098 v0042 = qcdr(v0042);
3099 stack[-1] = v0042;
3100 goto v0047;
3101 /* error exit handlers */
3102 v0049:
3103 popv(3);
3104 return nil;
3105 }
3106
3107
3108
3109 /* Code for getrmacro */
3110
CC_getrmacro(Lisp_Object env,Lisp_Object v0000)3111 static Lisp_Object CC_getrmacro(Lisp_Object env,
3112 Lisp_Object v0000)
3113 {
3114 Lisp_Object nil = C_nil;
3115 Lisp_Object v0052, v0042, v0054;
3116 Lisp_Object fn;
3117 CSL_IGNORE(nil);
3118 #ifdef DEBUG
3119 if (check_env(env)) return aerror("env for getrmacro");
3120 #endif
3121 if (stack >= stacklimit)
3122 {
3123 push(v0000);
3124 env = reclaim(env, "stack", GC_STACK, 0);
3125 pop(v0000);
3126 nil = C_nil;
3127 if (exception_pending()) return nil;
3128 }
3129 push(env);
3130 /* space for vars preserved across procedure calls */
3131 push(nil);
3132 /* copy arguments values to proper place */
3133 stack[0] = v0000;
3134 /* end of prologue */
3135 v0052 = stack[0];
3136 if (symbolp(v0052)) goto v0055;
3137 v0052 = qvalue(elt(env, 1)); /* nil */
3138 { popv(2); return onevalue(v0052); }
3139
3140 v0055:
3141 v0052 = stack[0];
3142 fn = elt(env, 4); /* getd */
3143 v0052 = (*qfn1(fn))(qenv(fn), v0052);
3144 nil = C_nil;
3145 if (exception_pending()) goto v0017;
3146 env = stack[-1];
3147 v0054 = v0052;
3148 if (v0052 == nil) goto v0047;
3149 v0052 = v0054;
3150 v0042 = qcar(v0052);
3151 v0052 = elt(env, 2); /* macro */
3152 if (v0042 == v0052) { popv(2); return onevalue(v0054); }
3153 else goto v0047;
3154
3155 v0047:
3156 v0042 = stack[0];
3157 v0052 = elt(env, 3); /* smacro */
3158 v0052 = get(v0042, v0052);
3159 env = stack[-1];
3160 v0054 = v0052;
3161 if (v0052 == nil) goto v0058;
3162 v0052 = elt(env, 3); /* smacro */
3163 v0042 = v0054;
3164 popv(2);
3165 return cons(v0052, v0042);
3166
3167 v0058:
3168 v0052 = qvalue(elt(env, 1)); /* nil */
3169 { popv(2); return onevalue(v0052); }
3170 /* error exit handlers */
3171 v0017:
3172 popv(2);
3173 return nil;
3174 }
3175
3176
3177
3178 /* Code for reval_without_mod */
3179
CC_reval_without_mod(Lisp_Object env,Lisp_Object v0000)3180 static Lisp_Object CC_reval_without_mod(Lisp_Object env,
3181 Lisp_Object v0000)
3182 {
3183 Lisp_Object nil = C_nil;
3184 Lisp_Object v0065, v0080, v0062;
3185 Lisp_Object fn;
3186 CSL_IGNORE(nil);
3187 #ifdef DEBUG
3188 if (check_env(env)) return aerror("env for reval_without_mod");
3189 #endif
3190 if (stack >= stacklimit)
3191 {
3192 push(v0000);
3193 env = reclaim(env, "stack", GC_STACK, 0);
3194 pop(v0000);
3195 nil = C_nil;
3196 if (exception_pending()) return nil;
3197 }
3198 push(env);
3199 /* space for vars preserved across procedure calls */
3200 push(nil);
3201 /* copy arguments values to proper place */
3202 v0062 = v0000;
3203 /* end of prologue */
3204 v0080 = qvalue(elt(env, 1)); /* dmode!* */
3205 v0065 = elt(env, 2); /* !:mod!: */
3206 if (v0080 == v0065) goto v0006;
3207 v0065 = v0062;
3208 {
3209 popv(2);
3210 fn = elt(env, 4); /* reval */
3211 return (*qfn1(fn))(qenv(fn), v0065);
3212 }
3213
3214 v0006:
3215 v0065 = qvalue(elt(env, 3)); /* nil */
3216 stack[0] = qvalue(elt(env, 1)); /* dmode!* */
3217 qvalue(elt(env, 1)) = v0065; /* dmode!* */
3218 v0065 = v0062;
3219 fn = elt(env, 4); /* reval */
3220 v0065 = (*qfn1(fn))(qenv(fn), v0065);
3221 nil = C_nil;
3222 if (exception_pending()) goto v0053;
3223 env = stack[-1];
3224 qvalue(elt(env, 1)) = stack[0]; /* dmode!* */
3225 { popv(2); return onevalue(v0065); }
3226 /* error exit handlers */
3227 v0053:
3228 env = stack[-1];
3229 qvalue(elt(env, 1)) = stack[0]; /* dmode!* */
3230 popv(2);
3231 return nil;
3232 }
3233
3234
3235
3236 /* Code for adddm */
3237
CC_adddm(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)3238 static Lisp_Object CC_adddm(Lisp_Object env,
3239 Lisp_Object v0000, Lisp_Object v0001)
3240 {
3241 Lisp_Object nil = C_nil;
3242 Lisp_Object v0091, v0092, v0025;
3243 Lisp_Object fn;
3244 CSL_IGNORE(nil);
3245 #ifdef DEBUG
3246 if (check_env(env)) return aerror("env for adddm");
3247 #endif
3248 if (stack >= stacklimit)
3249 {
3250 push2(v0001,v0000);
3251 env = reclaim(env, "stack", GC_STACK, 0);
3252 pop2(v0000,v0001);
3253 nil = C_nil;
3254 if (exception_pending()) return nil;
3255 }
3256 push(env);
3257 /* copy arguments values to proper place */
3258 v0092 = v0001;
3259 v0025 = v0000;
3260 /* end of prologue */
3261 v0091 = v0025;
3262 if (!consp(v0091)) goto v0064;
3263 v0091 = qvalue(elt(env, 1)); /* nil */
3264 goto v0055;
3265
3266 v0055:
3267 if (v0091 == nil) goto v0093;
3268 v0091 = v0025;
3269 v0091 = plus2(v0091, v0092);
3270 nil = C_nil;
3271 if (exception_pending()) goto v0023;
3272 env = stack[0];
3273 v0025 = v0091;
3274 v0091 = qvalue(elt(env, 2)); /* dmode!* */
3275 if (v0091 == nil) goto v0026;
3276 v0092 = qvalue(elt(env, 2)); /* dmode!* */
3277 v0091 = elt(env, 4); /* convert */
3278 v0091 = Lflagp(nil, v0092, v0091);
3279 env = stack[0];
3280 v0091 = (v0091 == nil ? lisp_true : nil);
3281 goto v0094;
3282
3283 v0094:
3284 if (v0091 == nil) goto v0095;
3285 v0091 = v0025;
3286 v0091 = (Lisp_Object)zerop(v0091);
3287 v0091 = v0091 ? lisp_true : nil;
3288 env = stack[0];
3289 if (v0091 == nil) { popv(1); return onevalue(v0025); }
3290 v0091 = qvalue(elt(env, 1)); /* nil */
3291 { popv(1); return onevalue(v0091); }
3292
3293 v0095:
3294 v0092 = qvalue(elt(env, 2)); /* dmode!* */
3295 v0091 = elt(env, 5); /* i2d */
3296 v0091 = get(v0092, v0091);
3297 env = stack[0];
3298 v0092 = v0025;
3299 v0091 = Lapply1(nil, v0091, v0092);
3300 nil = C_nil;
3301 if (exception_pending()) goto v0023;
3302 env = stack[0];
3303 {
3304 popv(1);
3305 fn = elt(env, 7); /* int!-equiv!-chk */
3306 return (*qfn1(fn))(qenv(fn), v0091);
3307 }
3308
3309 v0026:
3310 v0091 = qvalue(elt(env, 3)); /* t */
3311 goto v0094;
3312
3313 v0093:
3314 v0091 = elt(env, 6); /* plus */
3315 {
3316 popv(1);
3317 fn = elt(env, 8); /* dcombine */
3318 return (*qfnn(fn))(qenv(fn), 3, v0025, v0092, v0091);
3319 }
3320
3321 v0064:
3322 v0091 = v0092;
3323 v0091 = (consp(v0091) ? nil : lisp_true);
3324 goto v0055;
3325 /* error exit handlers */
3326 v0023:
3327 popv(1);
3328 return nil;
3329 }
3330
3331
3332
3333 /* Code for multf */
3334
CC_multf(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)3335 static Lisp_Object CC_multf(Lisp_Object env,
3336 Lisp_Object v0000, Lisp_Object v0001)
3337 {
3338 Lisp_Object nil = C_nil;
3339 Lisp_Object v0149, v0150, v0151;
3340 Lisp_Object fn;
3341 CSL_IGNORE(nil);
3342 #ifdef DEBUG
3343 if (check_env(env)) return aerror("env for multf");
3344 #endif
3345 if (stack >= stacklimit)
3346 {
3347 push2(v0001,v0000);
3348 env = reclaim(env, "stack", GC_STACK, 0);
3349 pop2(v0000,v0001);
3350 nil = C_nil;
3351 if (exception_pending()) return nil;
3352 }
3353 push(env);
3354 /* space for vars preserved across procedure calls */
3355 push4(nil, nil, nil, nil);
3356 /* copy arguments values to proper place */
3357 stack[-1] = v0001;
3358 stack[-2] = v0000;
3359 /* end of prologue */
3360 stack[-3] = nil;
3361 goto v0057;
3362
3363 v0057:
3364 v0149 = stack[-2];
3365 if (v0149 == nil) goto v0034;
3366 v0149 = stack[-1];
3367 v0149 = (v0149 == nil ? lisp_true : nil);
3368 goto v0014;
3369
3370 v0014:
3371 if (v0149 == nil) goto v0053;
3372 v0149 = qvalue(elt(env, 2)); /* nil */
3373 { popv(5); return onevalue(v0149); }
3374
3375 v0053:
3376 v0150 = stack[-2];
3377 v0149 = (Lisp_Object)17; /* 1 */
3378 if (v0150 == v0149) { Lisp_Object res = stack[-1]; popv(5); return onevalue(res); }
3379 v0150 = stack[-1];
3380 v0149 = (Lisp_Object)17; /* 1 */
3381 if (v0150 == v0149) { Lisp_Object res = stack[-2]; popv(5); return onevalue(res); }
3382 v0149 = stack[-2];
3383 if (!consp(v0149)) goto v0052;
3384 v0149 = stack[-2];
3385 v0149 = qcar(v0149);
3386 v0149 = (consp(v0149) ? nil : lisp_true);
3387 goto v0009;
3388
3389 v0009:
3390 if (v0149 == nil) goto v0058;
3391 v0150 = stack[-2];
3392 v0149 = stack[-1];
3393 {
3394 popv(5);
3395 fn = elt(env, 11); /* multd */
3396 return (*qfn2(fn))(qenv(fn), v0150, v0149);
3397 }
3398
3399 v0058:
3400 v0149 = stack[-1];
3401 if (!consp(v0149)) goto v0152;
3402 v0149 = stack[-1];
3403 v0149 = qcar(v0149);
3404 v0149 = (consp(v0149) ? nil : lisp_true);
3405 goto v0095;
3406
3407 v0095:
3408 if (v0149 == nil) goto v0003;
3409 v0150 = stack[-1];
3410 v0149 = stack[-2];
3411 {
3412 popv(5);
3413 fn = elt(env, 11); /* multd */
3414 return (*qfn2(fn))(qenv(fn), v0150, v0149);
3415 }
3416
3417 v0003:
3418 v0149 = qvalue(elt(env, 3)); /* !*exp */
3419 if (!(v0149 == nil)) goto v0064;
3420 v0149 = qvalue(elt(env, 4)); /* ncmp!* */
3421 if (!(v0149 == nil)) goto v0064;
3422 v0149 = qvalue(elt(env, 5)); /* wtl!* */
3423 if (!(v0149 == nil)) goto v0064;
3424 v0149 = stack[-3];
3425 if (!(v0149 == nil)) goto v0064;
3426 v0149 = stack[-2];
3427 fn = elt(env, 12); /* mkprod */
3428 v0149 = (*qfn1(fn))(qenv(fn), v0149);
3429 nil = C_nil;
3430 if (exception_pending()) goto v0153;
3431 env = stack[-4];
3432 stack[-2] = v0149;
3433 v0149 = stack[-1];
3434 fn = elt(env, 12); /* mkprod */
3435 v0149 = (*qfn1(fn))(qenv(fn), v0149);
3436 nil = C_nil;
3437 if (exception_pending()) goto v0153;
3438 env = stack[-4];
3439 stack[-1] = v0149;
3440 v0149 = qvalue(elt(env, 1)); /* t */
3441 stack[-3] = v0149;
3442 goto v0057;
3443
3444 v0064:
3445 v0149 = stack[-2];
3446 v0149 = qcar(v0149);
3447 v0149 = qcar(v0149);
3448 v0149 = qcar(v0149);
3449 stack[-3] = v0149;
3450 v0149 = stack[-1];
3451 v0149 = qcar(v0149);
3452 v0149 = qcar(v0149);
3453 v0149 = qcar(v0149);
3454 stack[0] = v0149;
3455 v0149 = qvalue(elt(env, 6)); /* !*ncmp */
3456 if (v0149 == nil) goto v0154;
3457 v0149 = stack[-1];
3458 fn = elt(env, 13); /* noncomfp1 */
3459 v0149 = (*qfn1(fn))(qenv(fn), v0149);
3460 nil = C_nil;
3461 if (exception_pending()) goto v0153;
3462 env = stack[-4];
3463 if (v0149 == nil) goto v0154;
3464 v0149 = qvalue(elt(env, 6)); /* !*ncmp */
3465 if (v0149 == nil) goto v0155;
3466 v0149 = stack[-3];
3467 fn = elt(env, 14); /* noncomp1 */
3468 v0149 = (*qfn1(fn))(qenv(fn), v0149);
3469 nil = C_nil;
3470 if (exception_pending()) goto v0153;
3471 env = stack[-4];
3472 if (!(v0149 == nil)) goto v0156;
3473
3474 v0155:
3475 v0149 = qvalue(elt(env, 7)); /* !*!*processed */
3476 if (!(v0149 == nil)) goto v0154;
3477
3478 v0156:
3479 v0150 = stack[-2];
3480 v0149 = stack[-1];
3481 {
3482 popv(5);
3483 fn = elt(env, 15); /* multfnc */
3484 return (*qfn2(fn))(qenv(fn), v0150, v0149);
3485 }
3486
3487 v0154:
3488 v0150 = stack[-3];
3489 v0149 = stack[0];
3490 if (v0150 == v0149) goto v0157;
3491 v0150 = stack[-3];
3492 v0149 = stack[0];
3493 fn = elt(env, 16); /* ordop */
3494 v0149 = (*qfn2(fn))(qenv(fn), v0150, v0149);
3495 nil = C_nil;
3496 if (exception_pending()) goto v0153;
3497 env = stack[-4];
3498 if (v0149 == nil) goto v0158;
3499 v0149 = stack[-2];
3500 v0149 = qcar(v0149);
3501 v0150 = qcdr(v0149);
3502 v0149 = stack[-1];
3503 v0149 = CC_multf(env, v0150, v0149);
3504 nil = C_nil;
3505 if (exception_pending()) goto v0153;
3506 env = stack[-4];
3507 stack[-3] = v0149;
3508 v0149 = stack[-2];
3509 v0150 = qcdr(v0149);
3510 v0149 = stack[-1];
3511 v0149 = CC_multf(env, v0150, v0149);
3512 nil = C_nil;
3513 if (exception_pending()) goto v0153;
3514 stack[0] = v0149;
3515 v0149 = stack[-3];
3516 if (v0149 == nil) { Lisp_Object res = stack[0]; popv(5); return onevalue(res); }
3517 v0149 = stack[-2];
3518 v0149 = qcar(v0149);
3519 v0151 = qcar(v0149);
3520 v0150 = stack[-3];
3521 v0149 = stack[0];
3522 popv(5);
3523 return acons(v0151, v0150, v0149);
3524
3525 v0158:
3526 v0150 = stack[-2];
3527 v0149 = stack[-1];
3528 v0149 = qcar(v0149);
3529 v0149 = qcdr(v0149);
3530 v0149 = CC_multf(env, v0150, v0149);
3531 nil = C_nil;
3532 if (exception_pending()) goto v0153;
3533 env = stack[-4];
3534 stack[-3] = v0149;
3535 v0150 = stack[-2];
3536 v0149 = stack[-1];
3537 v0149 = qcdr(v0149);
3538 v0149 = CC_multf(env, v0150, v0149);
3539 nil = C_nil;
3540 if (exception_pending()) goto v0153;
3541 stack[0] = v0149;
3542 v0149 = stack[-3];
3543 if (v0149 == nil) { Lisp_Object res = stack[0]; popv(5); return onevalue(res); }
3544 v0149 = stack[-1];
3545 v0149 = qcar(v0149);
3546 v0151 = qcar(v0149);
3547 v0150 = stack[-3];
3548 v0149 = stack[0];
3549 popv(5);
3550 return acons(v0151, v0150, v0149);
3551
3552 v0157:
3553 v0149 = stack[-2];
3554 v0149 = qcar(v0149);
3555 v0149 = qcar(v0149);
3556 v0149 = qcdr(v0149);
3557 v0149 = integerp(v0149);
3558 if (v0149 == nil) goto v0159;
3559 v0149 = stack[-1];
3560 v0149 = qcar(v0149);
3561 v0149 = qcar(v0149);
3562 v0149 = qcdr(v0149);
3563 v0149 = integerp(v0149);
3564 v0149 = (v0149 == nil ? lisp_true : nil);
3565 goto v0160;
3566
3567 v0160:
3568 if (v0149 == nil) goto v0161;
3569 stack[0] = stack[-3];
3570 v0151 = elt(env, 8); /* plus */
3571 v0149 = stack[-2];
3572 v0149 = qcar(v0149);
3573 v0149 = qcar(v0149);
3574 v0150 = qcdr(v0149);
3575 v0149 = stack[-1];
3576 v0149 = qcar(v0149);
3577 v0149 = qcar(v0149);
3578 v0149 = qcdr(v0149);
3579 v0149 = list3(v0151, v0150, v0149);
3580 nil = C_nil;
3581 if (exception_pending()) goto v0153;
3582 env = stack[-4];
3583 fn = elt(env, 17); /* reval */
3584 v0149 = (*qfn1(fn))(qenv(fn), v0149);
3585 nil = C_nil;
3586 if (exception_pending()) goto v0153;
3587 env = stack[-4];
3588 v0149 = cons(stack[0], v0149);
3589 nil = C_nil;
3590 if (exception_pending()) goto v0153;
3591 env = stack[-4];
3592 stack[-3] = v0149;
3593 goto v0162;
3594
3595 v0162:
3596 v0149 = stack[-2];
3597 v0150 = qcdr(v0149);
3598 v0149 = stack[-1];
3599 stack[0] = CC_multf(env, v0150, v0149);
3600 nil = C_nil;
3601 if (exception_pending()) goto v0153;
3602 env = stack[-4];
3603 v0149 = stack[-2];
3604 v0149 = qcar(v0149);
3605 v0150 = ncons(v0149);
3606 nil = C_nil;
3607 if (exception_pending()) goto v0153;
3608 env = stack[-4];
3609 v0149 = stack[-1];
3610 v0149 = qcdr(v0149);
3611 v0149 = CC_multf(env, v0150, v0149);
3612 nil = C_nil;
3613 if (exception_pending()) goto v0153;
3614 env = stack[-4];
3615 fn = elt(env, 18); /* addf */
3616 v0149 = (*qfn2(fn))(qenv(fn), stack[0], v0149);
3617 nil = C_nil;
3618 if (exception_pending()) goto v0153;
3619 env = stack[-4];
3620 stack[0] = v0149;
3621 v0149 = stack[-3];
3622 if (v0149 == nil) goto v0163;
3623 v0149 = stack[-2];
3624 v0149 = qcar(v0149);
3625 v0150 = qcdr(v0149);
3626 v0149 = stack[-1];
3627 v0149 = qcar(v0149);
3628 v0149 = qcdr(v0149);
3629 v0149 = CC_multf(env, v0150, v0149);
3630 nil = C_nil;
3631 if (exception_pending()) goto v0153;
3632 env = stack[-4];
3633 stack[-2] = v0149;
3634 v0149 = (v0149 == nil ? lisp_true : nil);
3635 goto v0164;
3636
3637 v0164:
3638 if (v0149 == nil) goto v0165;
3639 v0149 = qvalue(elt(env, 1)); /* t */
3640 qvalue(elt(env, 9)) = v0149; /* !*asymp!* */
3641 { Lisp_Object res = stack[0]; popv(5); return onevalue(res); }
3642
3643 v0165:
3644 v0150 = stack[-3];
3645 v0149 = (Lisp_Object)17; /* 1 */
3646 if (v0150 == v0149) goto v0166;
3647 v0149 = qvalue(elt(env, 10)); /* !*mcd */
3648 if (v0149 == nil) goto v0167;
3649 v0151 = stack[-3];
3650 v0150 = stack[-2];
3651 v0149 = stack[0];
3652 popv(5);
3653 return acons(v0151, v0150, v0149);
3654
3655 v0167:
3656 v0150 = stack[-3];
3657 v0149 = stack[-2];
3658 v0149 = cons(v0150, v0149);
3659 nil = C_nil;
3660 if (exception_pending()) goto v0153;
3661 env = stack[-4];
3662 v0150 = ncons(v0149);
3663 nil = C_nil;
3664 if (exception_pending()) goto v0153;
3665 env = stack[-4];
3666 v0149 = stack[0];
3667 {
3668 popv(5);
3669 fn = elt(env, 18); /* addf */
3670 return (*qfn2(fn))(qenv(fn), v0150, v0149);
3671 }
3672
3673 v0166:
3674 v0150 = stack[-2];
3675 v0149 = stack[0];
3676 {
3677 popv(5);
3678 fn = elt(env, 18); /* addf */
3679 return (*qfn2(fn))(qenv(fn), v0150, v0149);
3680 }
3681
3682 v0163:
3683 v0149 = qvalue(elt(env, 1)); /* t */
3684 goto v0164;
3685
3686 v0161:
3687 stack[0] = stack[-3];
3688 v0149 = stack[-2];
3689 v0149 = qcar(v0149);
3690 v0149 = qcar(v0149);
3691 v0150 = qcdr(v0149);
3692 v0149 = stack[-1];
3693 v0149 = qcar(v0149);
3694 v0149 = qcar(v0149);
3695 v0149 = qcdr(v0149);
3696 v0149 = plus2(v0150, v0149);
3697 nil = C_nil;
3698 if (exception_pending()) goto v0153;
3699 env = stack[-4];
3700 fn = elt(env, 19); /* mkspm */
3701 v0149 = (*qfn2(fn))(qenv(fn), stack[0], v0149);
3702 nil = C_nil;
3703 if (exception_pending()) goto v0153;
3704 env = stack[-4];
3705 stack[-3] = v0149;
3706 goto v0162;
3707
3708 v0159:
3709 v0149 = qvalue(elt(env, 1)); /* t */
3710 goto v0160;
3711
3712 v0152:
3713 v0149 = qvalue(elt(env, 1)); /* t */
3714 goto v0095;
3715
3716 v0052:
3717 v0149 = qvalue(elt(env, 1)); /* t */
3718 goto v0009;
3719
3720 v0034:
3721 v0149 = qvalue(elt(env, 1)); /* t */
3722 goto v0014;
3723 /* error exit handlers */
3724 v0153:
3725 popv(5);
3726 return nil;
3727 }
3728
3729
3730
3731 /* Code for ring_ecart */
3732
CC_ring_ecart(Lisp_Object env,Lisp_Object v0000)3733 static Lisp_Object CC_ring_ecart(Lisp_Object env,
3734 Lisp_Object v0000)
3735 {
3736 Lisp_Object nil = C_nil;
3737 Lisp_Object v0086, v0015;
3738 Lisp_Object fn;
3739 CSL_IGNORE(nil);
3740 #ifdef DEBUG
3741 if (check_env(env)) return aerror("env for ring_ecart");
3742 #endif
3743 if (stack >= stacklimit)
3744 {
3745 push(v0000);
3746 env = reclaim(env, "stack", GC_STACK, 0);
3747 pop(v0000);
3748 nil = C_nil;
3749 if (exception_pending()) return nil;
3750 }
3751 CSL_IGNORE(env);
3752 /* copy arguments values to proper place */
3753 v0086 = v0000;
3754 /* end of prologue */
3755 v0015 = v0086;
3756 v0086 = (Lisp_Object)81; /* 5 */
3757 fn = elt(env, 1); /* pnth */
3758 v0086 = (*qfn2(fn))(qenv(fn), v0015, v0086);
3759 errexit();
3760 v0086 = qcar(v0086);
3761 return onevalue(v0086);
3762 }
3763
3764
3765
3766 /* Code for reduce_pv */
3767
CC_reduce_pv(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)3768 static Lisp_Object CC_reduce_pv(Lisp_Object env,
3769 Lisp_Object v0000, Lisp_Object v0001)
3770 {
3771 Lisp_Object nil = C_nil;
3772 Lisp_Object v0034, v0066, v0040;
3773 Lisp_Object fn;
3774 CSL_IGNORE(nil);
3775 #ifdef DEBUG
3776 if (check_env(env)) return aerror("env for reduce_pv");
3777 #endif
3778 CSL_IGNORE(env);
3779 /* copy arguments values to proper place */
3780 v0034 = v0001;
3781 v0066 = v0000;
3782 /* end of prologue */
3783 v0040 = v0066;
3784 v0066 = v0034;
3785 v0034 = qvalue(elt(env, 1)); /* t */
3786 {
3787 fn = elt(env, 2); /* reduce_pv0 */
3788 return (*qfnn(fn))(qenv(fn), 3, v0040, v0066, v0034);
3789 }
3790 }
3791
3792
3793
3794 /* Code for rnonep!: */
3795
CC_rnonepT(Lisp_Object env,Lisp_Object v0000)3796 static Lisp_Object CC_rnonepT(Lisp_Object env,
3797 Lisp_Object v0000)
3798 {
3799 Lisp_Object nil = C_nil;
3800 Lisp_Object v0067, v0047, v0068;
3801 CSL_IGNORE(nil);
3802 #ifdef DEBUG
3803 if (check_env(env)) return aerror("env for rnonep:");
3804 #endif
3805 CSL_IGNORE(env);
3806 /* copy arguments values to proper place */
3807 v0068 = v0000;
3808 /* end of prologue */
3809 v0067 = v0068;
3810 v0067 = qcdr(v0067);
3811 v0047 = qcar(v0067);
3812 v0067 = (Lisp_Object)17; /* 1 */
3813 if (v0047 == v0067) goto v0066;
3814 v0067 = qvalue(elt(env, 1)); /* nil */
3815 return onevalue(v0067);
3816
3817 v0066:
3818 v0067 = v0068;
3819 v0067 = qcdr(v0067);
3820 v0047 = qcdr(v0067);
3821 v0067 = (Lisp_Object)17; /* 1 */
3822 v0067 = (v0047 == v0067 ? lisp_true : nil);
3823 return onevalue(v0067);
3824 }
3825
3826
3827
3828 /* Code for general!-modular!-plus */
3829
CC_generalKmodularKplus(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)3830 static Lisp_Object CC_generalKmodularKplus(Lisp_Object env,
3831 Lisp_Object v0000, Lisp_Object v0001)
3832 {
3833 Lisp_Object nil = C_nil;
3834 Lisp_Object v0056, v0010;
3835 CSL_IGNORE(nil);
3836 #ifdef DEBUG
3837 if (check_env(env)) return aerror("env for general-modular-plus");
3838 #endif
3839 if (stack >= stacklimit)
3840 {
3841 push2(v0001,v0000);
3842 env = reclaim(env, "stack", GC_STACK, 0);
3843 pop2(v0000,v0001);
3844 nil = C_nil;
3845 if (exception_pending()) return nil;
3846 }
3847 push(env);
3848 /* space for vars preserved across procedure calls */
3849 push(nil);
3850 /* copy arguments values to proper place */
3851 v0056 = v0001;
3852 v0010 = v0000;
3853 /* end of prologue */
3854 v0056 = plus2(v0010, v0056);
3855 nil = C_nil;
3856 if (exception_pending()) goto v0168;
3857 env = stack[-1];
3858 stack[0] = v0056;
3859 v0010 = stack[0];
3860 v0056 = qvalue(elt(env, 1)); /* current!-modulus */
3861 v0056 = (Lisp_Object)geq2(v0010, v0056);
3862 nil = C_nil;
3863 if (exception_pending()) goto v0168;
3864 v0056 = v0056 ? lisp_true : nil;
3865 env = stack[-1];
3866 if (v0056 == nil) { Lisp_Object res = stack[0]; popv(2); return onevalue(res); }
3867 v0010 = stack[0];
3868 v0056 = qvalue(elt(env, 1)); /* current!-modulus */
3869 v0056 = difference2(v0010, v0056);
3870 nil = C_nil;
3871 if (exception_pending()) goto v0168;
3872 stack[0] = v0056;
3873 { Lisp_Object res = stack[0]; popv(2); return onevalue(res); }
3874 /* error exit handlers */
3875 v0168:
3876 popv(2);
3877 return nil;
3878 }
3879
3880
3881
3882 /* Code for !*d2n */
3883
CC_Hd2n(Lisp_Object env,Lisp_Object v0000)3884 static Lisp_Object CC_Hd2n(Lisp_Object env,
3885 Lisp_Object v0000)
3886 {
3887 Lisp_Object nil = C_nil;
3888 Lisp_Object v0086, v0015;
3889 CSL_IGNORE(nil);
3890 #ifdef DEBUG
3891 if (check_env(env)) return aerror("env for *d2n");
3892 #endif
3893 CSL_IGNORE(env);
3894 /* copy arguments values to proper place */
3895 v0086 = v0000;
3896 /* end of prologue */
3897 v0015 = v0086;
3898 if (!(v0015 == nil)) return onevalue(v0086);
3899 v0086 = (Lisp_Object)1; /* 0 */
3900 return onevalue(v0086);
3901 }
3902
3903
3904
3905 /* Code for add2calls */
3906
CC_add2calls(Lisp_Object env,Lisp_Object v0000)3907 static Lisp_Object CC_add2calls(Lisp_Object env,
3908 Lisp_Object v0000)
3909 {
3910 Lisp_Object nil = C_nil;
3911 Lisp_Object v0031, v0169;
3912 CSL_IGNORE(nil);
3913 #ifdef DEBUG
3914 if (check_env(env)) return aerror("env for add2calls");
3915 #endif
3916 if (stack >= stacklimit)
3917 {
3918 push(v0000);
3919 env = reclaim(env, "stack", GC_STACK, 0);
3920 pop(v0000);
3921 nil = C_nil;
3922 if (exception_pending()) return nil;
3923 }
3924 push(env);
3925 /* space for vars preserved across procedure calls */
3926 push(nil);
3927 /* copy arguments values to proper place */
3928 stack[0] = v0000;
3929 /* end of prologue */
3930 v0169 = stack[0];
3931 v0031 = elt(env, 1); /* cinthis */
3932 v0031 = Lflagp(nil, v0169, v0031);
3933 env = stack[-1];
3934 if (v0031 == nil) goto v0060;
3935 v0031 = qvalue(elt(env, 5)); /* nil */
3936 { popv(2); return onevalue(v0031); }
3937
3938 v0060:
3939 v0169 = stack[0];
3940 v0031 = elt(env, 2); /* nolist */
3941 v0031 = Lflagp(nil, v0169, v0031);
3942 env = stack[-1];
3943 if (v0031 == nil) goto v0011;
3944 v0169 = stack[0];
3945 v0031 = qvalue(elt(env, 3)); /* xseen!* */
3946 v0031 = cons(v0169, v0031);
3947 nil = C_nil;
3948 if (exception_pending()) goto v0170;
3949 env = stack[-1];
3950 qvalue(elt(env, 3)) = v0031; /* xseen!* */
3951 goto v0008;
3952
3953 v0008:
3954 v0031 = stack[0];
3955 v0031 = ncons(v0031);
3956 nil = C_nil;
3957 if (exception_pending()) goto v0170;
3958 env = stack[-1];
3959 v0169 = elt(env, 1); /* cinthis */
3960 popv(2);
3961 return Lflag(nil, v0031, v0169);
3962
3963 v0011:
3964 v0169 = stack[0];
3965 v0031 = qvalue(elt(env, 4)); /* calls!* */
3966 v0031 = cons(v0169, v0031);
3967 nil = C_nil;
3968 if (exception_pending()) goto v0170;
3969 env = stack[-1];
3970 qvalue(elt(env, 4)) = v0031; /* calls!* */
3971 goto v0008;
3972 /* error exit handlers */
3973 v0170:
3974 popv(2);
3975 return nil;
3976 }
3977
3978
3979
3980 /* Code for cl_atmlc */
3981
CC_cl_atmlc(Lisp_Object env,Lisp_Object v0000)3982 static Lisp_Object CC_cl_atmlc(Lisp_Object env,
3983 Lisp_Object v0000)
3984 {
3985 Lisp_Object nil = C_nil;
3986 Lisp_Object v0086, v0015;
3987 CSL_IGNORE(nil);
3988 #ifdef DEBUG
3989 if (check_env(env)) return aerror("env for cl_atmlc");
3990 #endif
3991 if (stack >= stacklimit)
3992 {
3993 push(v0000);
3994 env = reclaim(env, "stack", GC_STACK, 0);
3995 pop(v0000);
3996 nil = C_nil;
3997 if (exception_pending()) return nil;
3998 }
3999 CSL_IGNORE(env);
4000 /* copy arguments values to proper place */
4001 v0086 = v0000;
4002 /* end of prologue */
4003 v0015 = v0086;
4004 v0086 = (Lisp_Object)17; /* 1 */
4005 v0086 = cons(v0015, v0086);
4006 errexit();
4007 return ncons(v0086);
4008 }
4009
4010
4011
4012 /* Code for monomisdivisibleby */
4013
CC_monomisdivisibleby(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)4014 static Lisp_Object CC_monomisdivisibleby(Lisp_Object env,
4015 Lisp_Object v0000, Lisp_Object v0001)
4016 {
4017 Lisp_Object nil = C_nil;
4018 Lisp_Object v0027, v0016, v0173;
4019 CSL_IGNORE(nil);
4020 #ifdef DEBUG
4021 if (check_env(env)) return aerror("env for monomisdivisibleby");
4022 #endif
4023 if (stack >= stacklimit)
4024 {
4025 push2(v0001,v0000);
4026 env = reclaim(env, "stack", GC_STACK, 0);
4027 pop2(v0000,v0001);
4028 nil = C_nil;
4029 if (exception_pending()) return nil;
4030 }
4031 push(env);
4032 /* space for vars preserved across procedure calls */
4033 push2(nil, nil);
4034 /* copy arguments values to proper place */
4035 v0173 = v0001;
4036 v0027 = v0000;
4037 /* end of prologue */
4038 v0016 = v0027;
4039 v0027 = (Lisp_Object)17; /* 1 */
4040 v0027 = *(Lisp_Object *)((char *)v0016 + (CELL-TAG_VECTOR) + ((int32_t)v0027/(16/CELL)));
4041 stack[-1] = v0027;
4042 v0016 = v0173;
4043 v0027 = (Lisp_Object)17; /* 1 */
4044 v0027 = *(Lisp_Object *)((char *)v0016 + (CELL-TAG_VECTOR) + ((int32_t)v0027/(16/CELL)));
4045 stack[0] = v0027;
4046 goto v0053;
4047
4048 v0053:
4049 v0027 = stack[-1];
4050 v0027 = qcar(v0027);
4051 if (v0027 == nil) goto v0051;
4052 v0027 = stack[0];
4053 v0027 = qcar(v0027);
4054 if (v0027 == nil) goto v0051;
4055 v0027 = stack[-1];
4056 v0016 = qcar(v0027);
4057 v0027 = stack[0];
4058 v0027 = qcar(v0027);
4059 if (equal(v0016, v0027)) goto v0174;
4060 v0027 = stack[-1];
4061 v0016 = qcar(v0027);
4062 v0027 = stack[0];
4063 v0027 = qcar(v0027);
4064 v0027 = (Lisp_Object)greaterp2(v0016, v0027);
4065 nil = C_nil;
4066 if (exception_pending()) goto v0147;
4067 v0027 = v0027 ? lisp_true : nil;
4068 env = stack[-2];
4069 if (v0027 == nil) goto v0029;
4070 v0027 = stack[-1];
4071 v0027 = qcdr(v0027);
4072 stack[-1] = v0027;
4073 goto v0053;
4074
4075 v0029:
4076 v0027 = qvalue(elt(env, 1)); /* nil */
4077 v0027 = ncons(v0027);
4078 nil = C_nil;
4079 if (exception_pending()) goto v0147;
4080 env = stack[-2];
4081 stack[-1] = v0027;
4082 goto v0053;
4083
4084 v0174:
4085 v0027 = stack[-1];
4086 v0027 = qcdr(v0027);
4087 stack[-1] = v0027;
4088 v0027 = stack[0];
4089 v0027 = qcdr(v0027);
4090 stack[0] = v0027;
4091 goto v0053;
4092
4093 v0051:
4094 v0027 = stack[0];
4095 v0027 = qcar(v0027);
4096 v0027 = (v0027 == nil ? lisp_true : nil);
4097 { popv(3); return onevalue(v0027); }
4098 /* error exit handlers */
4099 v0147:
4100 popv(3);
4101 return nil;
4102 }
4103
4104
4105
4106 /* Code for split_form */
4107
CC_split_form(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)4108 static Lisp_Object CC_split_form(Lisp_Object env,
4109 Lisp_Object v0000, Lisp_Object v0001)
4110 {
4111 Lisp_Object nil = C_nil;
4112 Lisp_Object v0175, v0060;
4113 Lisp_Object fn;
4114 CSL_IGNORE(nil);
4115 #ifdef DEBUG
4116 if (check_env(env)) return aerror("env for split_form");
4117 #endif
4118 if (stack >= stacklimit)
4119 {
4120 push2(v0001,v0000);
4121 env = reclaim(env, "stack", GC_STACK, 0);
4122 pop2(v0000,v0001);
4123 nil = C_nil;
4124 if (exception_pending()) return nil;
4125 }
4126 push(env);
4127 /* space for vars preserved across procedure calls */
4128 push3(nil, nil, nil);
4129 /* copy arguments values to proper place */
4130 v0175 = v0001;
4131 v0060 = v0000;
4132 /* end of prologue */
4133 stack[-2] = v0060;
4134 stack[-1] = v0175;
4135 stack[0] = (Lisp_Object)17; /* 1 */
4136 v0175 = qvalue(elt(env, 1)); /* nil */
4137 v0175 = ncons(v0175);
4138 nil = C_nil;
4139 if (exception_pending()) goto v0062;
4140 env = stack[-3];
4141 {
4142 Lisp_Object v0051 = stack[-2];
4143 Lisp_Object v0053 = stack[-1];
4144 Lisp_Object v0050 = stack[0];
4145 popv(4);
4146 fn = elt(env, 2); /* split_f */
4147 return (*qfnn(fn))(qenv(fn), 4, v0051, v0053, v0050, v0175);
4148 }
4149 /* error exit handlers */
4150 v0062:
4151 popv(4);
4152 return nil;
4153 }
4154
4155
4156
4157 /* Code for ofsf_posdefp */
4158
CC_ofsf_posdefp(Lisp_Object env,Lisp_Object v0000)4159 static Lisp_Object CC_ofsf_posdefp(Lisp_Object env,
4160 Lisp_Object v0000)
4161 {
4162 Lisp_Object nil = C_nil;
4163 Lisp_Object v0014, v0034;
4164 Lisp_Object fn;
4165 CSL_IGNORE(nil);
4166 #ifdef DEBUG
4167 if (check_env(env)) return aerror("env for ofsf_posdefp");
4168 #endif
4169 CSL_IGNORE(env);
4170 /* copy arguments values to proper place */
4171 v0034 = v0000;
4172 /* end of prologue */
4173 v0014 = qvalue(elt(env, 1)); /* !*rlpos */
4174 if (v0014 == nil) goto v0064;
4175 v0014 = v0034;
4176 {
4177 fn = elt(env, 2); /* ofsf_posdefp!-pos */
4178 return (*qfn1(fn))(qenv(fn), v0014);
4179 }
4180
4181 v0064:
4182 v0014 = v0034;
4183 {
4184 fn = elt(env, 3); /* sfto_tsqsumf */
4185 return (*qfn1(fn))(qenv(fn), v0014);
4186 }
4187 }
4188
4189
4190
4191 /* Code for tayexp!-greaterp */
4192
CC_tayexpKgreaterp(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)4193 static Lisp_Object CC_tayexpKgreaterp(Lisp_Object env,
4194 Lisp_Object v0000, Lisp_Object v0001)
4195 {
4196 Lisp_Object nil = C_nil;
4197 Lisp_Object v0086, v0015;
4198 Lisp_Object fn;
4199 CSL_IGNORE(nil);
4200 #ifdef DEBUG
4201 if (check_env(env)) return aerror("env for tayexp-greaterp");
4202 #endif
4203 CSL_IGNORE(env);
4204 /* copy arguments values to proper place */
4205 v0015 = v0001;
4206 v0086 = v0000;
4207 /* end of prologue */
4208 {
4209 fn = elt(env, 1); /* tayexp!-lessp */
4210 return (*qfn2(fn))(qenv(fn), v0015, v0086);
4211 }
4212 }
4213
4214
4215
4216 /* Code for mri_floorp */
4217
CC_mri_floorp(Lisp_Object env,Lisp_Object v0000)4218 static Lisp_Object CC_mri_floorp(Lisp_Object env,
4219 Lisp_Object v0000)
4220 {
4221 Lisp_Object nil = C_nil;
4222 Lisp_Object v0047, v0068, v0094;
4223 CSL_IGNORE(nil);
4224 #ifdef DEBUG
4225 if (check_env(env)) return aerror("env for mri_floorp");
4226 #endif
4227 CSL_IGNORE(env);
4228 /* copy arguments values to proper place */
4229 v0068 = v0000;
4230 /* end of prologue */
4231
4232 v0069:
4233 v0047 = v0068;
4234 if (v0047 == nil) goto v0006;
4235 v0047 = v0068;
4236 v0094 = qcar(v0047);
4237 v0047 = elt(env, 2); /* floor */
4238 if (!consp(v0094)) goto v0051;
4239 v0094 = qcar(v0094);
4240 if (!(v0094 == v0047)) goto v0051;
4241 v0047 = qvalue(elt(env, 3)); /* t */
4242 return onevalue(v0047);
4243
4244 v0051:
4245 v0047 = v0068;
4246 v0047 = qcdr(v0047);
4247 v0068 = v0047;
4248 goto v0069;
4249
4250 v0006:
4251 v0047 = qvalue(elt(env, 1)); /* nil */
4252 return onevalue(v0047);
4253 }
4254
4255
4256
4257 /* Code for qqe_qopaddp */
4258
CC_qqe_qopaddp(Lisp_Object env,Lisp_Object v0000)4259 static Lisp_Object CC_qqe_qopaddp(Lisp_Object env,
4260 Lisp_Object v0000)
4261 {
4262 Lisp_Object nil = C_nil;
4263 Lisp_Object v0066, v0040;
4264 CSL_IGNORE(nil);
4265 #ifdef DEBUG
4266 if (check_env(env)) return aerror("env for qqe_qopaddp");
4267 #endif
4268 CSL_IGNORE(env);
4269 /* copy arguments values to proper place */
4270 v0066 = v0000;
4271 /* end of prologue */
4272 v0040 = v0066;
4273 v0066 = elt(env, 1); /* (ladd radd) */
4274 v0066 = Lmemq(nil, v0040, v0066);
4275 if (v0066 == nil) goto v0005;
4276 v0066 = qvalue(elt(env, 2)); /* t */
4277 return onevalue(v0066);
4278
4279 v0005:
4280 v0066 = nil;
4281 return onevalue(v0066);
4282 }
4283
4284
4285
4286 /* Code for sort */
4287
CC_sort(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)4288 static Lisp_Object CC_sort(Lisp_Object env,
4289 Lisp_Object v0000, Lisp_Object v0001)
4290 {
4291 Lisp_Object nil = C_nil;
4292 Lisp_Object v0175, v0060;
4293 Lisp_Object fn;
4294 CSL_IGNORE(nil);
4295 #ifdef DEBUG
4296 if (check_env(env)) return aerror("env for sort");
4297 #endif
4298 if (stack >= stacklimit)
4299 {
4300 push2(v0001,v0000);
4301 env = reclaim(env, "stack", GC_STACK, 0);
4302 pop2(v0000,v0001);
4303 nil = C_nil;
4304 if (exception_pending()) return nil;
4305 }
4306 push(env);
4307 /* space for vars preserved across procedure calls */
4308 push(nil);
4309 /* copy arguments values to proper place */
4310 stack[0] = v0001;
4311 v0175 = v0000;
4312 /* end of prologue */
4313 v0060 = v0175;
4314 v0175 = qvalue(elt(env, 1)); /* nil */
4315 v0060 = Lappend(nil, v0060, v0175);
4316 nil = C_nil;
4317 if (exception_pending()) goto v0065;
4318 env = stack[-1];
4319 v0175 = stack[0];
4320 {
4321 popv(2);
4322 fn = elt(env, 2); /* stable!-sortip */
4323 return (*qfn2(fn))(qenv(fn), v0060, v0175);
4324 }
4325 /* error exit handlers */
4326 v0065:
4327 popv(2);
4328 return nil;
4329 }
4330
4331
4332
4333 /* Code for ibalp_cequal */
4334
CC_ibalp_cequal(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)4335 static Lisp_Object CC_ibalp_cequal(Lisp_Object env,
4336 Lisp_Object v0000, Lisp_Object v0001)
4337 {
4338 Lisp_Object nil = C_nil;
4339 Lisp_Object v0185, v0186;
4340 Lisp_Object fn;
4341 CSL_IGNORE(nil);
4342 #ifdef DEBUG
4343 if (check_env(env)) return aerror("env for ibalp_cequal");
4344 #endif
4345 if (stack >= stacklimit)
4346 {
4347 push2(v0001,v0000);
4348 env = reclaim(env, "stack", GC_STACK, 0);
4349 pop2(v0000,v0001);
4350 nil = C_nil;
4351 if (exception_pending()) return nil;
4352 }
4353 push(env);
4354 /* space for vars preserved across procedure calls */
4355 push5(nil, nil, nil, nil, nil);
4356 push2(nil, nil);
4357 /* copy arguments values to proper place */
4358 stack[-4] = v0001;
4359 stack[-5] = v0000;
4360 /* end of prologue */
4361 v0185 = stack[-5];
4362 v0185 = qcar(v0185);
4363 stack[-3] = v0185;
4364 v0185 = stack[-3];
4365 if (v0185 == nil) goto v0060;
4366 v0185 = stack[-3];
4367 v0185 = qcar(v0185);
4368 v0185 = qcar(v0185);
4369 v0185 = ncons(v0185);
4370 nil = C_nil;
4371 if (exception_pending()) goto v0187;
4372 env = stack[-7];
4373 stack[-1] = v0185;
4374 stack[-2] = v0185;
4375 goto v0034;
4376
4377 v0034:
4378 v0185 = stack[-3];
4379 v0185 = qcdr(v0185);
4380 stack[-3] = v0185;
4381 v0185 = stack[-3];
4382 if (v0185 == nil) goto v0044;
4383 stack[0] = stack[-1];
4384 v0185 = stack[-3];
4385 v0185 = qcar(v0185);
4386 v0185 = qcar(v0185);
4387 v0185 = ncons(v0185);
4388 nil = C_nil;
4389 if (exception_pending()) goto v0187;
4390 env = stack[-7];
4391 v0185 = Lrplacd(nil, stack[0], v0185);
4392 nil = C_nil;
4393 if (exception_pending()) goto v0187;
4394 env = stack[-7];
4395 v0185 = stack[-1];
4396 v0185 = qcdr(v0185);
4397 stack[-1] = v0185;
4398 goto v0034;
4399
4400 v0044:
4401 v0185 = stack[-2];
4402 goto v0014;
4403
4404 v0014:
4405 stack[-6] = v0185;
4406 v0185 = stack[-4];
4407 v0185 = qcar(v0185);
4408 stack[-3] = v0185;
4409 v0185 = stack[-3];
4410 if (v0185 == nil) goto v0043;
4411 v0185 = stack[-3];
4412 v0185 = qcar(v0185);
4413 v0185 = qcar(v0185);
4414 v0185 = ncons(v0185);
4415 nil = C_nil;
4416 if (exception_pending()) goto v0187;
4417 env = stack[-7];
4418 stack[-1] = v0185;
4419 stack[-2] = v0185;
4420 goto v0169;
4421
4422 v0169:
4423 v0185 = stack[-3];
4424 v0185 = qcdr(v0185);
4425 stack[-3] = v0185;
4426 v0185 = stack[-3];
4427 if (v0185 == nil) goto v0188;
4428 stack[0] = stack[-1];
4429 v0185 = stack[-3];
4430 v0185 = qcar(v0185);
4431 v0185 = qcar(v0185);
4432 v0185 = ncons(v0185);
4433 nil = C_nil;
4434 if (exception_pending()) goto v0187;
4435 env = stack[-7];
4436 v0185 = Lrplacd(nil, stack[0], v0185);
4437 nil = C_nil;
4438 if (exception_pending()) goto v0187;
4439 env = stack[-7];
4440 v0185 = stack[-1];
4441 v0185 = qcdr(v0185);
4442 stack[-1] = v0185;
4443 goto v0169;
4444
4445 v0188:
4446 v0185 = stack[-2];
4447 goto v0189;
4448
4449 v0189:
4450 v0186 = stack[-6];
4451 fn = elt(env, 2); /* lto_setequalq */
4452 v0185 = (*qfn2(fn))(qenv(fn), v0186, v0185);
4453 nil = C_nil;
4454 if (exception_pending()) goto v0187;
4455 env = stack[-7];
4456 if (v0185 == nil) goto v0190;
4457 v0185 = stack[-5];
4458 v0185 = qcdr(v0185);
4459 v0185 = qcar(v0185);
4460 stack[-3] = v0185;
4461 v0185 = stack[-3];
4462 if (v0185 == nil) goto v0073;
4463 v0185 = stack[-3];
4464 v0185 = qcar(v0185);
4465 v0185 = qcar(v0185);
4466 v0185 = ncons(v0185);
4467 nil = C_nil;
4468 if (exception_pending()) goto v0187;
4469 env = stack[-7];
4470 stack[-1] = v0185;
4471 stack[-2] = v0185;
4472 goto v0191;
4473
4474 v0191:
4475 v0185 = stack[-3];
4476 v0185 = qcdr(v0185);
4477 stack[-3] = v0185;
4478 v0185 = stack[-3];
4479 if (v0185 == nil) goto v0192;
4480 stack[0] = stack[-1];
4481 v0185 = stack[-3];
4482 v0185 = qcar(v0185);
4483 v0185 = qcar(v0185);
4484 v0185 = ncons(v0185);
4485 nil = C_nil;
4486 if (exception_pending()) goto v0187;
4487 env = stack[-7];
4488 v0185 = Lrplacd(nil, stack[0], v0185);
4489 nil = C_nil;
4490 if (exception_pending()) goto v0187;
4491 env = stack[-7];
4492 v0185 = stack[-1];
4493 v0185 = qcdr(v0185);
4494 stack[-1] = v0185;
4495 goto v0191;
4496
4497 v0192:
4498 v0185 = stack[-2];
4499 goto v0038;
4500
4501 v0038:
4502 stack[-3] = v0185;
4503 v0185 = stack[-4];
4504 v0185 = qcdr(v0185);
4505 v0185 = qcar(v0185);
4506 stack[-4] = v0185;
4507 v0185 = stack[-4];
4508 if (v0185 == nil) goto v0193;
4509 v0185 = stack[-4];
4510 v0185 = qcar(v0185);
4511 v0185 = qcar(v0185);
4512 v0185 = ncons(v0185);
4513 nil = C_nil;
4514 if (exception_pending()) goto v0187;
4515 env = stack[-7];
4516 stack[-1] = v0185;
4517 stack[-2] = v0185;
4518 goto v0194;
4519
4520 v0194:
4521 v0185 = stack[-4];
4522 v0185 = qcdr(v0185);
4523 stack[-4] = v0185;
4524 v0185 = stack[-4];
4525 if (v0185 == nil) goto v0195;
4526 stack[0] = stack[-1];
4527 v0185 = stack[-4];
4528 v0185 = qcar(v0185);
4529 v0185 = qcar(v0185);
4530 v0185 = ncons(v0185);
4531 nil = C_nil;
4532 if (exception_pending()) goto v0187;
4533 env = stack[-7];
4534 v0185 = Lrplacd(nil, stack[0], v0185);
4535 nil = C_nil;
4536 if (exception_pending()) goto v0187;
4537 env = stack[-7];
4538 v0185 = stack[-1];
4539 v0185 = qcdr(v0185);
4540 stack[-1] = v0185;
4541 goto v0194;
4542
4543 v0195:
4544 v0185 = stack[-2];
4545 goto v0196;
4546
4547 v0196:
4548 v0186 = stack[-3];
4549 {
4550 popv(8);
4551 fn = elt(env, 2); /* lto_setequalq */
4552 return (*qfn2(fn))(qenv(fn), v0186, v0185);
4553 }
4554
4555 v0193:
4556 v0185 = qvalue(elt(env, 1)); /* nil */
4557 goto v0196;
4558
4559 v0073:
4560 v0185 = qvalue(elt(env, 1)); /* nil */
4561 goto v0038;
4562
4563 v0190:
4564 v0185 = qvalue(elt(env, 1)); /* nil */
4565 { popv(8); return onevalue(v0185); }
4566
4567 v0043:
4568 v0185 = qvalue(elt(env, 1)); /* nil */
4569 goto v0189;
4570
4571 v0060:
4572 v0185 = qvalue(elt(env, 1)); /* nil */
4573 goto v0014;
4574 /* error exit handlers */
4575 v0187:
4576 popv(8);
4577 return nil;
4578 }
4579
4580
4581
4582 /* Code for get_token */
4583
CC_get_token(Lisp_Object env,int nargs,...)4584 static Lisp_Object MS_CDECL CC_get_token(Lisp_Object env, int nargs, ...)
4585 {
4586 Lisp_Object nil = C_nil;
4587 Lisp_Object v0010, v0011;
4588 CSL_IGNORE(nil);
4589 argcheck(nargs, 0, "get_token");
4590 #ifdef DEBUG
4591 if (check_env(env)) return aerror("env for get_token");
4592 #endif
4593 if (stack >= stacklimit)
4594 {
4595 env = reclaim(env, "stack", GC_STACK, 0);
4596 nil = C_nil;
4597 if (exception_pending()) return nil;
4598 }
4599 push(env);
4600 /* space for vars preserved across procedure calls */
4601 push(nil);
4602 /* end of prologue */
4603 v0010 = qvalue(elt(env, 1)); /* nil */
4604 stack[0] = v0010;
4605 goto v0015;
4606
4607 v0015:
4608 v0011 = Lreadch(nil, 0);
4609 nil = C_nil;
4610 if (exception_pending()) goto v0174;
4611 env = stack[-1];
4612 qvalue(elt(env, 2)) = v0011; /* ch */
4613 v0010 = elt(env, 3); /* !> */
4614 if (v0011 == v0010) goto v0047;
4615 v0011 = qvalue(elt(env, 2)); /* ch */
4616 v0010 = stack[0];
4617 v0010 = cons(v0011, v0010);
4618 nil = C_nil;
4619 if (exception_pending()) goto v0174;
4620 env = stack[-1];
4621 stack[0] = v0010;
4622 goto v0015;
4623
4624 v0047:
4625 v0011 = elt(env, 4); /* !$ */
4626 v0010 = stack[0];
4627 popv(2);
4628 return cons(v0011, v0010);
4629 /* error exit handlers */
4630 v0174:
4631 popv(2);
4632 return nil;
4633 }
4634
4635
4636
4637 /* Code for ps!:last!-term */
4638
CC_psTlastKterm(Lisp_Object env,Lisp_Object v0000)4639 static Lisp_Object CC_psTlastKterm(Lisp_Object env,
4640 Lisp_Object v0000)
4641 {
4642 Lisp_Object nil = C_nil;
4643 Lisp_Object v0054, v0048, v0017;
4644 Lisp_Object fn;
4645 CSL_IGNORE(nil);
4646 #ifdef DEBUG
4647 if (check_env(env)) return aerror("env for ps:last-term");
4648 #endif
4649 if (stack >= stacklimit)
4650 {
4651 push(v0000);
4652 env = reclaim(env, "stack", GC_STACK, 0);
4653 pop(v0000);
4654 nil = C_nil;
4655 if (exception_pending()) return nil;
4656 }
4657 push(env);
4658 /* copy arguments values to proper place */
4659 v0048 = v0000;
4660 /* end of prologue */
4661 v0054 = v0048;
4662 if (!consp(v0054)) goto v0055;
4663 v0054 = v0048;
4664 v0017 = qcar(v0054);
4665 v0054 = elt(env, 2); /* !:ps!: */
4666 if (v0017 == v0054) goto v0056;
4667 v0054 = v0048;
4668 v0017 = qcar(v0054);
4669 v0054 = elt(env, 3); /* dname */
4670 v0054 = get(v0017, v0054);
4671 env = stack[0];
4672 goto v0057;
4673
4674 v0057:
4675 if (v0054 == nil) goto v0058;
4676 v0054 = qvalue(elt(env, 5)); /* ps!:max!-order */
4677 { popv(1); return onevalue(v0054); }
4678
4679 v0058:
4680 v0054 = (Lisp_Object)17; /* 1 */
4681 {
4682 popv(1);
4683 fn = elt(env, 6); /* ps!:getv */
4684 return (*qfn2(fn))(qenv(fn), v0048, v0054);
4685 }
4686
4687 v0056:
4688 v0054 = qvalue(elt(env, 4)); /* nil */
4689 goto v0057;
4690
4691 v0055:
4692 v0054 = qvalue(elt(env, 1)); /* t */
4693 goto v0057;
4694 }
4695
4696
4697
4698 /* Code for dm!-abs */
4699
CC_dmKabs(Lisp_Object env,Lisp_Object v0000)4700 static Lisp_Object CC_dmKabs(Lisp_Object env,
4701 Lisp_Object v0000)
4702 {
4703 Lisp_Object nil = C_nil;
4704 Lisp_Object v0010, v0011;
4705 Lisp_Object fn;
4706 CSL_IGNORE(nil);
4707 #ifdef DEBUG
4708 if (check_env(env)) return aerror("env for dm-abs");
4709 #endif
4710 if (stack >= stacklimit)
4711 {
4712 push(v0000);
4713 env = reclaim(env, "stack", GC_STACK, 0);
4714 pop(v0000);
4715 nil = C_nil;
4716 if (exception_pending()) return nil;
4717 }
4718 push(env);
4719 /* space for vars preserved across procedure calls */
4720 push(nil);
4721 /* copy arguments values to proper place */
4722 stack[0] = v0000;
4723 /* end of prologue */
4724 v0010 = stack[0];
4725 if (!consp(v0010)) goto v0055;
4726 v0010 = stack[0];
4727 v0011 = qcar(v0010);
4728 v0010 = elt(env, 1); /* minusp */
4729 v0011 = get(v0011, v0010);
4730 env = stack[-1];
4731 v0010 = stack[0];
4732 v0010 = Lapply1(nil, v0011, v0010);
4733 nil = C_nil;
4734 if (exception_pending()) goto v0174;
4735 env = stack[-1];
4736 goto v0057;
4737
4738 v0057:
4739 if (v0010 == nil) { Lisp_Object res = stack[0]; popv(2); return onevalue(res); }
4740 v0010 = stack[0];
4741 {
4742 popv(2);
4743 fn = elt(env, 2); /* dm!-minus */
4744 return (*qfn1(fn))(qenv(fn), v0010);
4745 }
4746
4747 v0055:
4748 v0010 = stack[0];
4749 v0010 = Lminusp(nil, v0010);
4750 env = stack[-1];
4751 goto v0057;
4752 /* error exit handlers */
4753 v0174:
4754 popv(2);
4755 return nil;
4756 }
4757
4758
4759
4760 /* Code for mval */
4761
CC_mval(Lisp_Object env,Lisp_Object v0000)4762 static Lisp_Object CC_mval(Lisp_Object env,
4763 Lisp_Object v0000)
4764 {
4765 Lisp_Object v0007;
4766 #ifdef DEBUG
4767 if (check_env(env)) return aerror("env for mval");
4768 #endif
4769 CSL_IGNORE(env);
4770 /* copy arguments values to proper place */
4771 v0007 = v0000;
4772 /* end of prologue */
4773 return onevalue(v0007);
4774 }
4775
4776
4777
4778 /* Code for bcprod */
4779
CC_bcprod(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)4780 static Lisp_Object CC_bcprod(Lisp_Object env,
4781 Lisp_Object v0000, Lisp_Object v0001)
4782 {
4783 Lisp_Object nil = C_nil;
4784 Lisp_Object v0033, v0059, v0058;
4785 Lisp_Object fn;
4786 CSL_IGNORE(nil);
4787 #ifdef DEBUG
4788 if (check_env(env)) return aerror("env for bcprod");
4789 #endif
4790 if (stack >= stacklimit)
4791 {
4792 push2(v0001,v0000);
4793 env = reclaim(env, "stack", GC_STACK, 0);
4794 pop2(v0000,v0001);
4795 nil = C_nil;
4796 if (exception_pending()) return nil;
4797 }
4798 push(env);
4799 /* space for vars preserved across procedure calls */
4800 push2(nil, nil);
4801 /* copy arguments values to proper place */
4802 stack[0] = v0001;
4803 stack[-1] = v0000;
4804 /* end of prologue */
4805 v0033 = qvalue(elt(env, 1)); /* !*grmod!* */
4806 if (v0033 == nil) goto v0062;
4807 v0059 = stack[-1];
4808 v0033 = stack[0];
4809 v0033 = times2(v0059, v0033);
4810 nil = C_nil;
4811 if (exception_pending()) goto v0052;
4812 env = stack[-2];
4813 {
4814 popv(3);
4815 fn = elt(env, 3); /* bcfi */
4816 return (*qfn1(fn))(qenv(fn), v0033);
4817 }
4818
4819 v0062:
4820 v0058 = stack[-1];
4821 v0059 = stack[0];
4822 v0033 = elt(env, 2); /* times */
4823 fn = elt(env, 4); /* bcint2op */
4824 v0033 = (*qfnn(fn))(qenv(fn), 3, v0058, v0059, v0033);
4825 nil = C_nil;
4826 if (exception_pending()) goto v0052;
4827 env = stack[-2];
4828 if (!(v0033 == nil)) { popv(3); return onevalue(v0033); }
4829 v0059 = stack[-1];
4830 v0033 = stack[0];
4831 fn = elt(env, 5); /* multsq */
4832 v0033 = (*qfn2(fn))(qenv(fn), v0059, v0033);
4833 nil = C_nil;
4834 if (exception_pending()) goto v0052;
4835 env = stack[-2];
4836 {
4837 popv(3);
4838 fn = elt(env, 6); /* bccheckz */
4839 return (*qfn1(fn))(qenv(fn), v0033);
4840 }
4841 /* error exit handlers */
4842 v0052:
4843 popv(3);
4844 return nil;
4845 }
4846
4847
4848
4849 /* Code for wedgepf2 */
4850
CC_wedgepf2(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)4851 static Lisp_Object CC_wedgepf2(Lisp_Object env,
4852 Lisp_Object v0000, Lisp_Object v0001)
4853 {
4854 Lisp_Object nil = C_nil;
4855 Lisp_Object v0043, v0148;
4856 Lisp_Object fn;
4857 CSL_IGNORE(nil);
4858 #ifdef DEBUG
4859 if (check_env(env)) return aerror("env for wedgepf2");
4860 #endif
4861 if (stack >= stacklimit)
4862 {
4863 push2(v0001,v0000);
4864 env = reclaim(env, "stack", GC_STACK, 0);
4865 pop2(v0000,v0001);
4866 nil = C_nil;
4867 if (exception_pending()) return nil;
4868 }
4869 push(env);
4870 /* space for vars preserved across procedure calls */
4871 push4(nil, nil, nil, nil);
4872 /* copy arguments values to proper place */
4873 stack[-1] = v0001;
4874 stack[-2] = v0000;
4875 /* end of prologue */
4876 v0043 = stack[-2];
4877 if (v0043 == nil) goto v0064;
4878 v0043 = stack[-1];
4879 v0043 = (v0043 == nil ? lisp_true : nil);
4880 goto v0055;
4881
4882 v0055:
4883 if (v0043 == nil) goto v0022;
4884 v0043 = qvalue(elt(env, 2)); /* nil */
4885 { popv(5); return onevalue(v0043); }
4886
4887 v0022:
4888 v0043 = stack[-2];
4889 v0148 = qcar(v0043);
4890 v0043 = stack[-1];
4891 v0043 = qcar(v0043);
4892 fn = elt(env, 3); /* wedget2 */
4893 stack[-3] = (*qfn2(fn))(qenv(fn), v0148, v0043);
4894 nil = C_nil;
4895 if (exception_pending()) goto v0152;
4896 env = stack[-4];
4897 v0043 = stack[-2];
4898 v0043 = qcar(v0043);
4899 v0148 = ncons(v0043);
4900 nil = C_nil;
4901 if (exception_pending()) goto v0152;
4902 env = stack[-4];
4903 v0043 = stack[-1];
4904 v0043 = qcdr(v0043);
4905 stack[0] = CC_wedgepf2(env, v0148, v0043);
4906 nil = C_nil;
4907 if (exception_pending()) goto v0152;
4908 env = stack[-4];
4909 v0043 = stack[-2];
4910 v0148 = qcdr(v0043);
4911 v0043 = stack[-1];
4912 v0043 = CC_wedgepf2(env, v0148, v0043);
4913 nil = C_nil;
4914 if (exception_pending()) goto v0152;
4915 env = stack[-4];
4916 fn = elt(env, 4); /* addpf */
4917 v0043 = (*qfn2(fn))(qenv(fn), stack[0], v0043);
4918 nil = C_nil;
4919 if (exception_pending()) goto v0152;
4920 env = stack[-4];
4921 {
4922 Lisp_Object v0028 = stack[-3];
4923 popv(5);
4924 fn = elt(env, 4); /* addpf */
4925 return (*qfn2(fn))(qenv(fn), v0028, v0043);
4926 }
4927
4928 v0064:
4929 v0043 = qvalue(elt(env, 1)); /* t */
4930 goto v0055;
4931 /* error exit handlers */
4932 v0152:
4933 popv(5);
4934 return nil;
4935 }
4936
4937
4938
4939 /* Code for !:plus */
4940
CC_Tplus(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)4941 static Lisp_Object CC_Tplus(Lisp_Object env,
4942 Lisp_Object v0000, Lisp_Object v0001)
4943 {
4944 Lisp_Object nil = C_nil;
4945 Lisp_Object v0043, v0148, v0172;
4946 Lisp_Object fn;
4947 CSL_IGNORE(nil);
4948 #ifdef DEBUG
4949 if (check_env(env)) return aerror("env for :plus");
4950 #endif
4951 if (stack >= stacklimit)
4952 {
4953 push2(v0001,v0000);
4954 env = reclaim(env, "stack", GC_STACK, 0);
4955 pop2(v0000,v0001);
4956 nil = C_nil;
4957 if (exception_pending()) return nil;
4958 }
4959 push(env);
4960 /* copy arguments values to proper place */
4961 v0148 = v0001;
4962 v0172 = v0000;
4963 /* end of prologue */
4964 v0043 = v0172;
4965 if (v0043 == nil) { popv(1); return onevalue(v0148); }
4966 v0043 = v0148;
4967 if (v0043 == nil) { popv(1); return onevalue(v0172); }
4968 v0043 = v0172;
4969 if (!consp(v0043)) goto v0039;
4970 v0043 = qvalue(elt(env, 1)); /* nil */
4971 goto v0040;
4972
4973 v0040:
4974 if (v0043 == nil) goto v0031;
4975 v0043 = v0172;
4976 v0043 = plus2(v0043, v0148);
4977 nil = C_nil;
4978 if (exception_pending()) goto v0003;
4979 env = stack[0];
4980 v0172 = v0043;
4981 v0148 = v0172;
4982 v0043 = (Lisp_Object)1; /* 0 */
4983 if (!(v0148 == v0043)) { popv(1); return onevalue(v0172); }
4984 v0043 = qvalue(elt(env, 1)); /* nil */
4985 { popv(1); return onevalue(v0043); }
4986
4987 v0031:
4988 v0043 = elt(env, 2); /* plus */
4989 {
4990 popv(1);
4991 fn = elt(env, 3); /* dcombine */
4992 return (*qfnn(fn))(qenv(fn), 3, v0172, v0148, v0043);
4993 }
4994
4995 v0039:
4996 v0043 = v0148;
4997 v0043 = (consp(v0043) ? nil : lisp_true);
4998 goto v0040;
4999 /* error exit handlers */
5000 v0003:
5001 popv(1);
5002 return nil;
5003 }
5004
5005
5006
5007 /* Code for idlistp */
5008
CC_idlistp(Lisp_Object env,Lisp_Object v0000)5009 static Lisp_Object CC_idlistp(Lisp_Object env,
5010 Lisp_Object v0000)
5011 {
5012 Lisp_Object nil = C_nil;
5013 Lisp_Object v0068, v0094;
5014 CSL_IGNORE(nil);
5015 #ifdef DEBUG
5016 if (check_env(env)) return aerror("env for idlistp");
5017 #endif
5018 CSL_IGNORE(env);
5019 /* copy arguments values to proper place */
5020 v0068 = v0000;
5021 /* end of prologue */
5022
5023 v0069:
5024 v0094 = v0068;
5025 if (v0094 == nil) goto v0006;
5026 v0094 = v0068;
5027 if (!consp(v0094)) goto v0022;
5028 v0094 = v0068;
5029 v0094 = qcar(v0094);
5030 if (symbolp(v0094)) goto v0080;
5031 v0068 = qvalue(elt(env, 2)); /* nil */
5032 return onevalue(v0068);
5033
5034 v0080:
5035 v0068 = qcdr(v0068);
5036 goto v0069;
5037
5038 v0022:
5039 v0068 = qvalue(elt(env, 2)); /* nil */
5040 return onevalue(v0068);
5041
5042 v0006:
5043 v0068 = qvalue(elt(env, 1)); /* t */
5044 return onevalue(v0068);
5045 }
5046
5047
5048
5049 /* Code for macrochk */
5050
CC_macrochk(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)5051 static Lisp_Object CC_macrochk(Lisp_Object env,
5052 Lisp_Object v0000, Lisp_Object v0001)
5053 {
5054 Lisp_Object nil = C_nil;
5055 Lisp_Object v0027, v0016, v0173, v0093;
5056 Lisp_Object fn;
5057 CSL_IGNORE(nil);
5058 #ifdef DEBUG
5059 if (check_env(env)) return aerror("env for macrochk");
5060 #endif
5061 if (stack >= stacklimit)
5062 {
5063 push2(v0001,v0000);
5064 env = reclaim(env, "stack", GC_STACK, 0);
5065 pop2(v0000,v0001);
5066 nil = C_nil;
5067 if (exception_pending()) return nil;
5068 }
5069 push(env);
5070 /* space for vars preserved across procedure calls */
5071 push2(nil, nil);
5072 /* copy arguments values to proper place */
5073 stack[0] = v0001;
5074 stack[-1] = v0000;
5075 /* end of prologue */
5076 v0027 = stack[-1];
5077 if (!consp(v0027)) { Lisp_Object res = stack[-1]; popv(3); return onevalue(res); }
5078 v0027 = stack[-1];
5079 v0027 = qcar(v0027);
5080 fn = elt(env, 6); /* expdrmacro */
5081 v0027 = (*qfn1(fn))(qenv(fn), v0027);
5082 nil = C_nil;
5083 if (exception_pending()) goto v0087;
5084 env = stack[-2];
5085 v0016 = v0027;
5086 if (v0027 == nil) { Lisp_Object res = stack[-1]; popv(3); return onevalue(res); }
5087 v0173 = stack[0];
5088 v0027 = elt(env, 1); /* symbolic */
5089 if (v0173 == v0027) goto v0065;
5090 v0027 = stack[-1];
5091 v0027 = qcar(v0027);
5092 if (symbolp(v0027)) goto v0059;
5093 v0027 = qvalue(elt(env, 3)); /* nil */
5094 goto v0061;
5095
5096 v0061:
5097 if (v0027 == nil) { Lisp_Object res = stack[-1]; popv(3); return onevalue(res); }
5098 v0027 = v0016;
5099 v0173 = qcar(v0027);
5100 v0027 = elt(env, 5); /* macrofn */
5101 v0093 = get(v0173, v0027);
5102 v0027 = v0016;
5103 v0173 = qcdr(v0027);
5104 v0027 = stack[-1];
5105 v0016 = qcdr(v0027);
5106 v0027 = stack[-1];
5107 v0027 = qcar(v0027);
5108 popv(3);
5109 return Lapply3(nil, 4, v0093, v0173, v0016, v0027);
5110
5111 v0059:
5112 v0027 = stack[-1];
5113 v0173 = qcar(v0027);
5114 v0027 = elt(env, 4); /* opfn */
5115 v0027 = Lflagp(nil, v0173, v0027);
5116 env = stack[-2];
5117 goto v0061;
5118
5119 v0065:
5120 v0027 = qvalue(elt(env, 2)); /* t */
5121 goto v0061;
5122 /* error exit handlers */
5123 v0087:
5124 popv(3);
5125 return nil;
5126 }
5127
5128
5129
5130 /* Code for mo!=sprod */
5131
CC_moMsprod(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)5132 static Lisp_Object CC_moMsprod(Lisp_Object env,
5133 Lisp_Object v0000, Lisp_Object v0001)
5134 {
5135 Lisp_Object nil = C_nil;
5136 Lisp_Object v0148, v0172, v0003;
5137 CSL_IGNORE(nil);
5138 #ifdef DEBUG
5139 if (check_env(env)) return aerror("env for mo=sprod");
5140 #endif
5141 if (stack >= stacklimit)
5142 {
5143 push2(v0001,v0000);
5144 env = reclaim(env, "stack", GC_STACK, 0);
5145 pop2(v0000,v0001);
5146 nil = C_nil;
5147 if (exception_pending()) return nil;
5148 }
5149 push(env);
5150 /* space for vars preserved across procedure calls */
5151 push2(nil, nil);
5152 /* copy arguments values to proper place */
5153 stack[0] = v0001;
5154 stack[-1] = v0000;
5155 /* end of prologue */
5156 v0003 = nil;
5157 goto v0057;
5158
5159 v0057:
5160 v0148 = stack[-1];
5161 if (v0148 == nil) goto v0040;
5162 v0148 = stack[0];
5163 v0148 = (v0148 == nil ? lisp_true : nil);
5164 goto v0066;
5165
5166 v0066:
5167 if (v0148 == nil) goto v0068;
5168 v0148 = (Lisp_Object)1; /* 0 */
5169 goto v0064;
5170
5171 v0064:
5172 v0172 = v0003;
5173 if (v0172 == nil) { popv(3); return onevalue(v0148); }
5174 v0172 = v0003;
5175 v0172 = qcar(v0172);
5176 v0148 = (Lisp_Object)(int32_t)((int32_t)v0172 + (int32_t)v0148 - TAG_FIXNUM);
5177 v0172 = v0003;
5178 v0172 = qcdr(v0172);
5179 v0003 = v0172;
5180 goto v0064;
5181
5182 v0068:
5183 v0148 = stack[-1];
5184 v0172 = qcar(v0148);
5185 v0148 = stack[0];
5186 v0148 = qcar(v0148);
5187 v0148 = fixnum_of_int((int32_t)(int_of_fixnum(v0172) * int_of_fixnum(v0148)));
5188 v0172 = v0003;
5189 v0148 = cons(v0148, v0172);
5190 nil = C_nil;
5191 if (exception_pending()) goto v0152;
5192 env = stack[-2];
5193 v0003 = v0148;
5194 v0148 = stack[-1];
5195 v0148 = qcdr(v0148);
5196 stack[-1] = v0148;
5197 v0148 = stack[0];
5198 v0148 = qcdr(v0148);
5199 stack[0] = v0148;
5200 goto v0057;
5201
5202 v0040:
5203 v0148 = qvalue(elt(env, 1)); /* t */
5204 goto v0066;
5205 /* error exit handlers */
5206 v0152:
5207 popv(3);
5208 return nil;
5209 }
5210
5211
5212
5213 /* Code for hasonevector */
5214
CC_hasonevector(Lisp_Object env,Lisp_Object v0000)5215 static Lisp_Object CC_hasonevector(Lisp_Object env,
5216 Lisp_Object v0000)
5217 {
5218 Lisp_Object nil = C_nil;
5219 Lisp_Object v0060;
5220 Lisp_Object fn;
5221 CSL_IGNORE(nil);
5222 #ifdef DEBUG
5223 if (check_env(env)) return aerror("env for hasonevector");
5224 #endif
5225 if (stack >= stacklimit)
5226 {
5227 push(v0000);
5228 env = reclaim(env, "stack", GC_STACK, 0);
5229 pop(v0000);
5230 nil = C_nil;
5231 if (exception_pending()) return nil;
5232 }
5233 push(env);
5234 /* space for vars preserved across procedure calls */
5235 push(nil);
5236 /* copy arguments values to proper place */
5237 stack[0] = v0000;
5238 /* end of prologue */
5239
5240 v0069:
5241 v0060 = stack[0];
5242 if (v0060 == nil) goto v0006;
5243 v0060 = stack[0];
5244 v0060 = qcar(v0060);
5245 fn = elt(env, 2); /* vecp */
5246 v0060 = (*qfn1(fn))(qenv(fn), v0060);
5247 nil = C_nil;
5248 if (exception_pending()) goto v0065;
5249 env = stack[-1];
5250 if (!(v0060 == nil)) { popv(2); return onevalue(v0060); }
5251 v0060 = stack[0];
5252 v0060 = qcdr(v0060);
5253 stack[0] = v0060;
5254 goto v0069;
5255
5256 v0006:
5257 v0060 = qvalue(elt(env, 1)); /* nil */
5258 { popv(2); return onevalue(v0060); }
5259 /* error exit handlers */
5260 v0065:
5261 popv(2);
5262 return nil;
5263 }
5264
5265
5266
5267 /* Code for sieve_pv */
5268
CC_sieve_pv(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)5269 static Lisp_Object CC_sieve_pv(Lisp_Object env,
5270 Lisp_Object v0000, Lisp_Object v0001)
5271 {
5272 Lisp_Object nil = C_nil;
5273 Lisp_Object v0034, v0066, v0040;
5274 Lisp_Object fn;
5275 CSL_IGNORE(nil);
5276 #ifdef DEBUG
5277 if (check_env(env)) return aerror("env for sieve_pv");
5278 #endif
5279 CSL_IGNORE(env);
5280 /* copy arguments values to proper place */
5281 v0034 = v0001;
5282 v0066 = v0000;
5283 /* end of prologue */
5284 v0040 = v0066;
5285 v0066 = v0034;
5286 v0034 = qvalue(elt(env, 1)); /* t */
5287 {
5288 fn = elt(env, 2); /* sieve_pv0 */
5289 return (*qfnn(fn))(qenv(fn), 3, v0040, v0066, v0034);
5290 }
5291 }
5292
5293
5294
5295 /* Code for modtimes!: */
5296
CC_modtimesT(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)5297 static Lisp_Object CC_modtimesT(Lisp_Object env,
5298 Lisp_Object v0000, Lisp_Object v0001)
5299 {
5300 Lisp_Object nil = C_nil;
5301 Lisp_Object v0034, v0066;
5302 Lisp_Object fn;
5303 CSL_IGNORE(nil);
5304 #ifdef DEBUG
5305 if (check_env(env)) return aerror("env for modtimes:");
5306 #endif
5307 if (stack >= stacklimit)
5308 {
5309 push2(v0001,v0000);
5310 env = reclaim(env, "stack", GC_STACK, 0);
5311 pop2(v0000,v0001);
5312 nil = C_nil;
5313 if (exception_pending()) return nil;
5314 }
5315 push(env);
5316 /* copy arguments values to proper place */
5317 v0034 = v0001;
5318 v0066 = v0000;
5319 /* end of prologue */
5320 v0066 = qcdr(v0066);
5321 v0034 = qcdr(v0034);
5322 fn = elt(env, 1); /* general!-modular!-times */
5323 v0034 = (*qfn2(fn))(qenv(fn), v0066, v0034);
5324 nil = C_nil;
5325 if (exception_pending()) goto v0040;
5326 env = stack[0];
5327 {
5328 popv(1);
5329 fn = elt(env, 2); /* !*modular2f */
5330 return (*qfn1(fn))(qenv(fn), v0034);
5331 }
5332 /* error exit handlers */
5333 v0040:
5334 popv(1);
5335 return nil;
5336 }
5337
5338
5339
5340 /* Code for plus!-mod!-p */
5341
CC_plusKmodKp(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)5342 static Lisp_Object CC_plusKmodKp(Lisp_Object env,
5343 Lisp_Object v0000, Lisp_Object v0001)
5344 {
5345 Lisp_Object nil = C_nil;
5346 Lisp_Object v0165, v0221, v0222;
5347 Lisp_Object fn;
5348 CSL_IGNORE(nil);
5349 #ifdef DEBUG
5350 if (check_env(env)) return aerror("env for plus-mod-p");
5351 #endif
5352 if (stack >= stacklimit)
5353 {
5354 push2(v0001,v0000);
5355 env = reclaim(env, "stack", GC_STACK, 0);
5356 pop2(v0000,v0001);
5357 nil = C_nil;
5358 if (exception_pending()) return nil;
5359 }
5360 push(env);
5361 /* space for vars preserved across procedure calls */
5362 push5(nil, nil, nil, nil, nil);
5363 /* copy arguments values to proper place */
5364 stack[-2] = v0001;
5365 stack[-3] = v0000;
5366 /* end of prologue */
5367 stack[0] = nil;
5368 goto v0004;
5369
5370 v0004:
5371 v0165 = stack[-3];
5372 if (v0165 == nil) goto v0014;
5373 v0165 = stack[-2];
5374 if (v0165 == nil) goto v0051;
5375 v0165 = stack[-3];
5376 if (!consp(v0165)) goto v0056;
5377 v0165 = stack[-3];
5378 v0165 = qcar(v0165);
5379 v0165 = (consp(v0165) ? nil : lisp_true);
5380 goto v0041;
5381
5382 v0041:
5383 if (v0165 == nil) goto v0026;
5384 v0165 = stack[-2];
5385 if (!consp(v0165)) goto v0048;
5386 v0165 = stack[-2];
5387 v0165 = qcar(v0165);
5388 v0165 = (consp(v0165) ? nil : lisp_true);
5389 goto v0054;
5390
5391 v0054:
5392 if (v0165 == nil) goto v0091;
5393 v0222 = stack[0];
5394 v0221 = stack[-3];
5395 v0165 = stack[-2];
5396 { int32_t w = int_of_fixnum(v0221) + int_of_fixnum(v0165);
5397 if (w >= current_modulus) w -= current_modulus;
5398 v0165 = fixnum_of_int(w);
5399 }
5400 v0221 = v0165;
5401 v0165 = v0221;
5402 v0165 = (Lisp_Object)zerop(v0165);
5403 v0165 = v0165 ? lisp_true : nil;
5404 env = stack[-5];
5405 if (v0165 == nil) goto v0093;
5406 v0165 = qvalue(elt(env, 2)); /* nil */
5407 goto v0148;
5408
5409 v0148:
5410 {
5411 popv(6);
5412 fn = elt(env, 3); /* nreverse */
5413 return (*qfn2(fn))(qenv(fn), v0222, v0165);
5414 }
5415
5416 v0093:
5417 v0165 = v0221;
5418 goto v0148;
5419
5420 v0091:
5421 v0165 = stack[-2];
5422 v0221 = qcar(v0165);
5423 v0165 = stack[0];
5424 v0165 = cons(v0221, v0165);
5425 nil = C_nil;
5426 if (exception_pending()) goto v0166;
5427 env = stack[-5];
5428 stack[0] = v0165;
5429 v0165 = stack[-2];
5430 v0165 = qcdr(v0165);
5431 stack[-2] = v0165;
5432 goto v0004;
5433
5434 v0048:
5435 v0165 = qvalue(elt(env, 1)); /* t */
5436 goto v0054;
5437
5438 v0026:
5439 v0165 = stack[-2];
5440 if (!consp(v0165)) goto v0021;
5441 v0165 = stack[-2];
5442 v0165 = qcar(v0165);
5443 v0165 = (consp(v0165) ? nil : lisp_true);
5444 goto v0020;
5445
5446 v0020:
5447 if (v0165 == nil) goto v0083;
5448 v0165 = stack[-3];
5449 v0221 = qcar(v0165);
5450 v0165 = stack[0];
5451 v0165 = cons(v0221, v0165);
5452 nil = C_nil;
5453 if (exception_pending()) goto v0166;
5454 env = stack[-5];
5455 stack[0] = v0165;
5456 v0165 = stack[-3];
5457 v0165 = qcdr(v0165);
5458 stack[-3] = v0165;
5459 goto v0004;
5460
5461 v0083:
5462 v0165 = stack[-3];
5463 v0165 = qcar(v0165);
5464 v0221 = qcar(v0165);
5465 v0165 = stack[-2];
5466 v0165 = qcar(v0165);
5467 v0165 = qcar(v0165);
5468 if (equal(v0221, v0165)) goto v0145;
5469 v0165 = stack[-3];
5470 v0165 = qcar(v0165);
5471 v0165 = qcar(v0165);
5472 v0221 = qcar(v0165);
5473 v0165 = stack[-2];
5474 v0165 = qcar(v0165);
5475 v0165 = qcar(v0165);
5476 v0165 = qcar(v0165);
5477 if (equal(v0221, v0165)) goto v0223;
5478 v0165 = qvalue(elt(env, 2)); /* nil */
5479 goto v0224;
5480
5481 v0224:
5482 if (!(v0165 == nil)) goto v0163;
5483 v0165 = stack[-3];
5484 v0165 = qcar(v0165);
5485 v0165 = qcar(v0165);
5486 v0221 = qcar(v0165);
5487 v0165 = stack[-2];
5488 v0165 = qcar(v0165);
5489 v0165 = qcar(v0165);
5490 v0165 = qcar(v0165);
5491 if (equal(v0221, v0165)) goto v0225;
5492 v0165 = stack[-3];
5493 v0165 = qcar(v0165);
5494 v0165 = qcar(v0165);
5495 v0221 = qcar(v0165);
5496 v0165 = stack[-2];
5497 v0165 = qcar(v0165);
5498 v0165 = qcar(v0165);
5499 v0165 = qcar(v0165);
5500 fn = elt(env, 4); /* ordop */
5501 v0165 = (*qfn2(fn))(qenv(fn), v0221, v0165);
5502 nil = C_nil;
5503 if (exception_pending()) goto v0166;
5504 env = stack[-5];
5505 goto v0226;
5506
5507 v0226:
5508 if (!(v0165 == nil)) goto v0163;
5509 v0165 = stack[-2];
5510 v0221 = qcar(v0165);
5511 v0165 = stack[0];
5512 v0165 = cons(v0221, v0165);
5513 nil = C_nil;
5514 if (exception_pending()) goto v0166;
5515 env = stack[-5];
5516 stack[0] = v0165;
5517 v0165 = stack[-2];
5518 v0165 = qcdr(v0165);
5519 stack[-2] = v0165;
5520 goto v0004;
5521
5522 v0163:
5523 v0165 = stack[-3];
5524 v0221 = qcar(v0165);
5525 v0165 = stack[0];
5526 v0165 = cons(v0221, v0165);
5527 nil = C_nil;
5528 if (exception_pending()) goto v0166;
5529 env = stack[-5];
5530 stack[0] = v0165;
5531 v0165 = stack[-3];
5532 v0165 = qcdr(v0165);
5533 stack[-3] = v0165;
5534 goto v0004;
5535
5536 v0225:
5537 v0165 = qvalue(elt(env, 2)); /* nil */
5538 goto v0226;
5539
5540 v0223:
5541 v0165 = stack[-3];
5542 v0165 = qcar(v0165);
5543 v0165 = qcar(v0165);
5544 v0221 = qcdr(v0165);
5545 v0165 = stack[-2];
5546 v0165 = qcar(v0165);
5547 v0165 = qcar(v0165);
5548 v0165 = qcdr(v0165);
5549 v0165 = ((intptr_t)v0221 > (intptr_t)v0165) ? lisp_true : nil;
5550 goto v0224;
5551
5552 v0145:
5553 stack[-4] = stack[0];
5554 v0165 = stack[-3];
5555 v0165 = qcar(v0165);
5556 stack[-1] = qcar(v0165);
5557 v0165 = stack[-3];
5558 v0165 = qcar(v0165);
5559 v0221 = qcdr(v0165);
5560 v0165 = stack[-2];
5561 v0165 = qcar(v0165);
5562 v0165 = qcdr(v0165);
5563 stack[0] = CC_plusKmodKp(env, v0221, v0165);
5564 nil = C_nil;
5565 if (exception_pending()) goto v0166;
5566 env = stack[-5];
5567 v0165 = stack[-3];
5568 v0221 = qcdr(v0165);
5569 v0165 = stack[-2];
5570 v0165 = qcdr(v0165);
5571 v0165 = CC_plusKmodKp(env, v0221, v0165);
5572 nil = C_nil;
5573 if (exception_pending()) goto v0166;
5574 env = stack[-5];
5575 fn = elt(env, 5); /* adjoin!-term */
5576 v0165 = (*qfnn(fn))(qenv(fn), 3, stack[-1], stack[0], v0165);
5577 nil = C_nil;
5578 if (exception_pending()) goto v0166;
5579 env = stack[-5];
5580 {
5581 Lisp_Object v0227 = stack[-4];
5582 popv(6);
5583 fn = elt(env, 3); /* nreverse */
5584 return (*qfn2(fn))(qenv(fn), v0227, v0165);
5585 }
5586
5587 v0021:
5588 v0165 = qvalue(elt(env, 1)); /* t */
5589 goto v0020;
5590
5591 v0056:
5592 v0165 = qvalue(elt(env, 1)); /* t */
5593 goto v0041;
5594
5595 v0051:
5596 v0221 = stack[0];
5597 v0165 = stack[-3];
5598 {
5599 popv(6);
5600 fn = elt(env, 3); /* nreverse */
5601 return (*qfn2(fn))(qenv(fn), v0221, v0165);
5602 }
5603
5604 v0014:
5605 v0221 = stack[0];
5606 v0165 = stack[-2];
5607 {
5608 popv(6);
5609 fn = elt(env, 3); /* nreverse */
5610 return (*qfn2(fn))(qenv(fn), v0221, v0165);
5611 }
5612 /* error exit handlers */
5613 v0166:
5614 popv(6);
5615 return nil;
5616 }
5617
5618
5619
5620 /* Code for monomclone */
5621
CC_monomclone(Lisp_Object env,Lisp_Object v0000)5622 static Lisp_Object CC_monomclone(Lisp_Object env,
5623 Lisp_Object v0000)
5624 {
5625 Lisp_Object nil = C_nil;
5626 Lisp_Object v0199, v0188, v0077, v0078;
5627 CSL_IGNORE(nil);
5628 #ifdef DEBUG
5629 if (check_env(env)) return aerror("env for monomclone");
5630 #endif
5631 if (stack >= stacklimit)
5632 {
5633 push(v0000);
5634 env = reclaim(env, "stack", GC_STACK, 0);
5635 pop(v0000);
5636 nil = C_nil;
5637 if (exception_pending()) return nil;
5638 }
5639 push(env);
5640 /* space for vars preserved across procedure calls */
5641 push4(nil, nil, nil, nil);
5642 /* copy arguments values to proper place */
5643 stack[0] = v0000;
5644 /* end of prologue */
5645 v0199 = stack[0];
5646 if (v0199 == nil) goto v0006;
5647 stack[-2] = nil;
5648 v0199 = (Lisp_Object)17; /* 1 */
5649 v0199 = Lmkvect(nil, v0199);
5650 nil = C_nil;
5651 if (exception_pending()) goto v0146;
5652 env = stack[-4];
5653 stack[-3] = v0199;
5654 v0078 = stack[-3];
5655 v0077 = (Lisp_Object)1; /* 0 */
5656 v0188 = stack[0];
5657 v0199 = (Lisp_Object)1; /* 0 */
5658 v0199 = *(Lisp_Object *)((char *)v0188 + (CELL-TAG_VECTOR) + ((int32_t)v0199/(16/CELL)));
5659 *(Lisp_Object *)((char *)v0078 + (CELL-TAG_VECTOR) + ((int32_t)v0077/(16/CELL))) = v0199;
5660 v0188 = stack[0];
5661 v0199 = (Lisp_Object)17; /* 1 */
5662 v0199 = *(Lisp_Object *)((char *)v0188 + (CELL-TAG_VECTOR) + ((int32_t)v0199/(16/CELL)));
5663 stack[0] = v0199;
5664 goto v0058;
5665
5666 v0058:
5667 v0199 = stack[0];
5668 if (v0199 == nil) goto v0148;
5669 v0199 = stack[0];
5670 v0188 = qcar(v0199);
5671 v0199 = stack[-2];
5672 v0199 = cons(v0188, v0199);
5673 nil = C_nil;
5674 if (exception_pending()) goto v0146;
5675 env = stack[-4];
5676 stack[-2] = v0199;
5677 v0199 = stack[0];
5678 v0199 = qcdr(v0199);
5679 stack[0] = v0199;
5680 goto v0058;
5681
5682 v0148:
5683 stack[-1] = stack[-3];
5684 stack[0] = (Lisp_Object)17; /* 1 */
5685 v0199 = stack[-2];
5686 v0199 = Lreverse(nil, v0199);
5687 nil = C_nil;
5688 if (exception_pending()) goto v0146;
5689 *(Lisp_Object *)((char *)stack[-1] + (CELL-TAG_VECTOR) + ((int32_t)stack[0]/(16/CELL))) = v0199;
5690 { Lisp_Object res = stack[-3]; popv(5); return onevalue(res); }
5691
5692 v0006:
5693 v0199 = qvalue(elt(env, 1)); /* nil */
5694 { popv(5); return onevalue(v0199); }
5695 /* error exit handlers */
5696 v0146:
5697 popv(5);
5698 return nil;
5699 }
5700
5701
5702
5703 /* Code for symbollessp */
5704
CC_symbollessp(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)5705 static Lisp_Object CC_symbollessp(Lisp_Object env,
5706 Lisp_Object v0000, Lisp_Object v0001)
5707 {
5708 Lisp_Object nil = C_nil;
5709 Lisp_Object v0056, v0010, v0011;
5710 Lisp_Object fn;
5711 CSL_IGNORE(nil);
5712 #ifdef DEBUG
5713 if (check_env(env)) return aerror("env for symbollessp");
5714 #endif
5715 if (stack >= stacklimit)
5716 {
5717 push2(v0001,v0000);
5718 env = reclaim(env, "stack", GC_STACK, 0);
5719 pop2(v0000,v0001);
5720 nil = C_nil;
5721 if (exception_pending()) return nil;
5722 }
5723 CSL_IGNORE(env);
5724 /* copy arguments values to proper place */
5725 v0010 = v0001;
5726 v0011 = v0000;
5727 /* end of prologue */
5728 v0056 = v0010;
5729 if (v0056 == nil) goto v0005;
5730 v0056 = v0011;
5731 if (v0056 == nil) goto v0064;
5732 v0056 = qvalue(elt(env, 3)); /* wukord!* */
5733 if (v0056 == nil) goto v0022;
5734 v0056 = v0011;
5735 {
5736 fn = elt(env, 4); /* wuorderp */
5737 return (*qfn2(fn))(qenv(fn), v0056, v0010);
5738 }
5739
5740 v0022:
5741 v0056 = v0011;
5742 v0056 = Lorderp(nil, v0056, v0010);
5743 errexit();
5744 v0056 = (v0056 == nil ? lisp_true : nil);
5745 return onevalue(v0056);
5746
5747 v0064:
5748 v0056 = qvalue(elt(env, 2)); /* t */
5749 return onevalue(v0056);
5750
5751 v0005:
5752 v0056 = qvalue(elt(env, 1)); /* nil */
5753 return onevalue(v0056);
5754 }
5755
5756
5757
5758 /* Code for rank */
5759
CC_rank(Lisp_Object env,Lisp_Object v0000)5760 static Lisp_Object CC_rank(Lisp_Object env,
5761 Lisp_Object v0000)
5762 {
5763 Lisp_Object nil = C_nil;
5764 Lisp_Object v0183, v0228;
5765 Lisp_Object fn;
5766 CSL_IGNORE(nil);
5767 #ifdef DEBUG
5768 if (check_env(env)) return aerror("env for rank");
5769 #endif
5770 if (stack >= stacklimit)
5771 {
5772 push(v0000);
5773 env = reclaim(env, "stack", GC_STACK, 0);
5774 pop(v0000);
5775 nil = C_nil;
5776 if (exception_pending()) return nil;
5777 }
5778 push(env);
5779 /* space for vars preserved across procedure calls */
5780 push4(nil, nil, nil, nil);
5781 /* copy arguments values to proper place */
5782 stack[-2] = v0000;
5783 /* end of prologue */
5784 v0183 = qvalue(elt(env, 1)); /* !*mcd */
5785 if (v0183 == nil) goto v0086;
5786 v0183 = stack[-2];
5787 v0183 = qcar(v0183);
5788 v0183 = qcar(v0183);
5789 v0183 = qcdr(v0183);
5790 { popv(5); return onevalue(v0183); }
5791
5792 v0086:
5793 v0183 = stack[-2];
5794 v0183 = qcar(v0183);
5795 v0183 = qcar(v0183);
5796 v0183 = qcdr(v0183);
5797 stack[-1] = v0183;
5798 v0183 = stack[-2];
5799 v0183 = qcar(v0183);
5800 v0183 = qcar(v0183);
5801 v0183 = qcar(v0183);
5802 stack[0] = v0183;
5803 goto v0175;
5804
5805 v0175:
5806 v0183 = stack[-2];
5807 v0183 = qcar(v0183);
5808 v0183 = qcar(v0183);
5809 v0183 = qcdr(v0183);
5810 stack[-3] = v0183;
5811 v0183 = stack[-2];
5812 v0183 = qcdr(v0183);
5813 if (v0183 == nil) goto v0063;
5814 v0183 = stack[-2];
5815 v0183 = qcdr(v0183);
5816 stack[-2] = v0183;
5817 v0228 = stack[-2];
5818 v0183 = stack[0];
5819 fn = elt(env, 2); /* degr */
5820 v0228 = (*qfn2(fn))(qenv(fn), v0228, v0183);
5821 nil = C_nil;
5822 if (exception_pending()) goto v0038;
5823 env = stack[-4];
5824 v0183 = (Lisp_Object)1; /* 0 */
5825 if (!(v0228 == v0183)) goto v0175;
5826 v0228 = stack[-3];
5827 v0183 = (Lisp_Object)1; /* 0 */
5828 v0183 = (Lisp_Object)lessp2(v0228, v0183);
5829 nil = C_nil;
5830 if (exception_pending()) goto v0038;
5831 v0183 = v0183 ? lisp_true : nil;
5832 env = stack[-4];
5833 if (v0183 == nil) { Lisp_Object res = stack[-1]; popv(5); return onevalue(res); }
5834 v0228 = stack[-1];
5835 v0183 = (Lisp_Object)1; /* 0 */
5836 v0183 = (Lisp_Object)lessp2(v0228, v0183);
5837 nil = C_nil;
5838 if (exception_pending()) goto v0038;
5839 v0183 = v0183 ? lisp_true : nil;
5840 if (v0183 == nil) goto v0045;
5841 v0183 = stack[-3];
5842 popv(5);
5843 return negate(v0183);
5844
5845 v0045:
5846 v0228 = stack[-1];
5847 v0183 = stack[-3];
5848 popv(5);
5849 return difference2(v0228, v0183);
5850
5851 v0063:
5852 v0228 = stack[-1];
5853 v0183 = stack[-3];
5854 popv(5);
5855 return difference2(v0228, v0183);
5856 /* error exit handlers */
5857 v0038:
5858 popv(5);
5859 return nil;
5860 }
5861
5862
5863
5864 /* Code for remove!-free!-vars */
5865
CC_removeKfreeKvars(Lisp_Object env,Lisp_Object v0000)5866 static Lisp_Object CC_removeKfreeKvars(Lisp_Object env,
5867 Lisp_Object v0000)
5868 {
5869 Lisp_Object nil = C_nil;
5870 Lisp_Object v0224, v0234, v0235;
5871 Lisp_Object fn;
5872 CSL_IGNORE(nil);
5873 #ifdef DEBUG
5874 if (check_env(env)) return aerror("env for remove-free-vars");
5875 #endif
5876 if (stack >= stacklimit)
5877 {
5878 push(v0000);
5879 env = reclaim(env, "stack", GC_STACK, 0);
5880 pop(v0000);
5881 nil = C_nil;
5882 if (exception_pending()) return nil;
5883 }
5884 push(env);
5885 /* space for vars preserved across procedure calls */
5886 push2(nil, nil);
5887 /* copy arguments values to proper place */
5888 stack[0] = v0000;
5889 /* end of prologue */
5890 v0224 = stack[0];
5891 if (!consp(v0224)) { Lisp_Object res = stack[0]; popv(3); return onevalue(res); }
5892 v0224 = stack[0];
5893 v0234 = qcar(v0224);
5894 v0224 = elt(env, 1); /* !~ */
5895 if (v0234 == v0224) goto v0015;
5896 v0224 = stack[0];
5897 {
5898 popv(3);
5899 fn = elt(env, 7); /* remove!-free!-vars!-l */
5900 return (*qfn1(fn))(qenv(fn), v0224);
5901 }
5902
5903 v0015:
5904 v0224 = qvalue(elt(env, 2)); /* !*!*noremove!*!* */
5905 if (v0224 == nil) goto v0053;
5906 v0224 = stack[0];
5907 v0224 = qcdr(v0224);
5908 v0234 = qcar(v0224);
5909 v0224 = qvalue(elt(env, 3)); /* frasc!* */
5910 v0224 = Latsoc(nil, v0234, v0224);
5911 v0235 = v0224;
5912 if (!(v0224 == nil)) goto v0047;
5913 v0224 = stack[0];
5914 v0224 = qcdr(v0224);
5915 v0234 = qcar(v0224);
5916 v0224 = elt(env, 1); /* !~ */
5917 if (!consp(v0234)) goto v0028;
5918 v0234 = qcar(v0234);
5919 if (!(v0234 == v0224)) goto v0028;
5920 v0224 = stack[0];
5921 v0224 = qcdr(v0224);
5922 v0224 = qcar(v0224);
5923 v0224 = qcdr(v0224);
5924 v0224 = qcar(v0224);
5925 v0234 = qvalue(elt(env, 3)); /* frasc!* */
5926 v0224 = Latsoc(nil, v0224, v0234);
5927 v0235 = v0224;
5928 goto v0058;
5929
5930 v0058:
5931 if (v0224 == nil) { Lisp_Object res = stack[0]; popv(3); return onevalue(res); }
5932 else goto v0047;
5933
5934 v0047:
5935 v0224 = v0235;
5936 v0224 = qcdr(v0224);
5937 { popv(3); return onevalue(v0224); }
5938
5939 v0028:
5940 v0224 = qvalue(elt(env, 4)); /* nil */
5941 goto v0058;
5942
5943 v0053:
5944 v0224 = stack[0];
5945 v0224 = qcdr(v0224);
5946 if (!consp(v0224)) goto v0093;
5947 v0224 = stack[0];
5948 v0224 = qcdr(v0224);
5949 v0224 = qcar(v0224);
5950 stack[-1] = v0224;
5951 if (is_number(v0224)) { Lisp_Object res = stack[0]; popv(3); return onevalue(res); }
5952 v0224 = stack[-1];
5953 if (symbolp(v0224)) goto v0073;
5954 v0234 = stack[-1];
5955 v0224 = elt(env, 1); /* !~ */
5956 if (!consp(v0234)) goto v0076;
5957 v0234 = qcar(v0234);
5958 if (!(v0234 == v0224)) goto v0076;
5959 v0224 = stack[-1];
5960 v0224 = qcdr(v0224);
5961 v0224 = qcar(v0224);
5962 stack[-1] = v0224;
5963 goto v0020;
5964
5965 v0020:
5966 if (!(v0224 == nil)) goto v0073;
5967 v0224 = stack[0];
5968 v0224 = qcdr(v0224);
5969 v0224 = qcar(v0224);
5970 v0224 = qcar(v0224);
5971 if (symbolp(v0224)) goto v0236;
5972 v0234 = stack[0];
5973 v0224 = elt(env, 5); /* "free variable" */
5974 {
5975 popv(3);
5976 fn = elt(env, 8); /* typerr */
5977 return (*qfn2(fn))(qenv(fn), v0234, v0224);
5978 }
5979
5980 v0236:
5981 v0224 = stack[0];
5982 v0224 = qcdr(v0224);
5983 v0224 = qcar(v0224);
5984 v0224 = qcar(v0224);
5985 fn = elt(env, 9); /* get!-free!-form */
5986 v0224 = (*qfn1(fn))(qenv(fn), v0224);
5987 nil = C_nil;
5988 if (exception_pending()) goto v0140;
5989 env = stack[-2];
5990 v0234 = ncons(v0224);
5991 nil = C_nil;
5992 if (exception_pending()) goto v0140;
5993 env = stack[-2];
5994 v0224 = qvalue(elt(env, 6)); /* frlis!* */
5995 fn = elt(env, 10); /* union */
5996 v0224 = (*qfn2(fn))(qenv(fn), v0234, v0224);
5997 nil = C_nil;
5998 if (exception_pending()) goto v0140;
5999 env = stack[-2];
6000 qvalue(elt(env, 6)) = v0224; /* frlis!* */
6001 v0224 = stack[0];
6002 v0224 = qcdr(v0224);
6003 v0224 = qcar(v0224);
6004 stack[-1] = qcar(v0224);
6005 v0224 = stack[0];
6006 v0224 = qcdr(v0224);
6007 v0224 = qcar(v0224);
6008 v0224 = qcdr(v0224);
6009 fn = elt(env, 7); /* remove!-free!-vars!-l */
6010 v0224 = (*qfn1(fn))(qenv(fn), v0224);
6011 nil = C_nil;
6012 if (exception_pending()) goto v0140;
6013 {
6014 Lisp_Object v0237 = stack[-1];
6015 popv(3);
6016 return cons(v0237, v0224);
6017 }
6018
6019 v0073:
6020 v0224 = stack[0];
6021 v0224 = qcdr(v0224);
6022 v0224 = qcar(v0224);
6023 fn = elt(env, 9); /* get!-free!-form */
6024 v0224 = (*qfn1(fn))(qenv(fn), v0224);
6025 nil = C_nil;
6026 if (exception_pending()) goto v0140;
6027 env = stack[-2];
6028 v0234 = ncons(v0224);
6029 nil = C_nil;
6030 if (exception_pending()) goto v0140;
6031 env = stack[-2];
6032 v0224 = qvalue(elt(env, 6)); /* frlis!* */
6033 fn = elt(env, 10); /* union */
6034 v0224 = (*qfn2(fn))(qenv(fn), v0234, v0224);
6035 nil = C_nil;
6036 if (exception_pending()) goto v0140;
6037 env = stack[-2];
6038 qvalue(elt(env, 6)) = v0224; /* frlis!* */
6039 { Lisp_Object res = stack[-1]; popv(3); return onevalue(res); }
6040
6041 v0076:
6042 v0224 = qvalue(elt(env, 4)); /* nil */
6043 goto v0020;
6044
6045 v0093:
6046 v0234 = stack[0];
6047 v0224 = elt(env, 5); /* "free variable" */
6048 {
6049 popv(3);
6050 fn = elt(env, 8); /* typerr */
6051 return (*qfn2(fn))(qenv(fn), v0234, v0224);
6052 }
6053 /* error exit handlers */
6054 v0140:
6055 popv(3);
6056 return nil;
6057 }
6058
6059
6060
6061 /* Code for nocp */
6062
CC_nocp(Lisp_Object env,Lisp_Object v0000)6063 static Lisp_Object CC_nocp(Lisp_Object env,
6064 Lisp_Object v0000)
6065 {
6066 Lisp_Object nil = C_nil;
6067 Lisp_Object v0022;
6068 Lisp_Object fn;
6069 CSL_IGNORE(nil);
6070 #ifdef DEBUG
6071 if (check_env(env)) return aerror("env for nocp");
6072 #endif
6073 if (stack >= stacklimit)
6074 {
6075 push(v0000);
6076 env = reclaim(env, "stack", GC_STACK, 0);
6077 pop(v0000);
6078 nil = C_nil;
6079 if (exception_pending()) return nil;
6080 }
6081 push(env);
6082 /* space for vars preserved across procedure calls */
6083 push(nil);
6084 /* copy arguments values to proper place */
6085 stack[0] = v0000;
6086 /* end of prologue */
6087
6088 v0069:
6089 v0022 = stack[0];
6090 if (v0022 == nil) goto v0006;
6091 v0022 = qvalue(elt(env, 2)); /* !*ncmp */
6092 if (v0022 == nil) goto v0015;
6093 v0022 = stack[0];
6094 v0022 = qcar(v0022);
6095 v0022 = qcar(v0022);
6096 fn = elt(env, 4); /* noncomp1 */
6097 v0022 = (*qfn1(fn))(qenv(fn), v0022);
6098 nil = C_nil;
6099 if (exception_pending()) goto v0047;
6100 env = stack[-1];
6101 if (v0022 == nil) goto v0015;
6102 v0022 = stack[0];
6103 v0022 = qcdr(v0022);
6104 stack[0] = v0022;
6105 goto v0069;
6106
6107 v0015:
6108 v0022 = qvalue(elt(env, 3)); /* nil */
6109 { popv(2); return onevalue(v0022); }
6110
6111 v0006:
6112 v0022 = qvalue(elt(env, 1)); /* t */
6113 { popv(2); return onevalue(v0022); }
6114 /* error exit handlers */
6115 v0047:
6116 popv(2);
6117 return nil;
6118 }
6119
6120
6121
6122 /* Code for get!+row!+nr */
6123
CC_getLrowLnr(Lisp_Object env,Lisp_Object v0000)6124 static Lisp_Object CC_getLrowLnr(Lisp_Object env,
6125 Lisp_Object v0000)
6126 {
6127 Lisp_Object nil = C_nil;
6128 Lisp_Object v0004;
6129 CSL_IGNORE(nil);
6130 #ifdef DEBUG
6131 if (check_env(env)) return aerror("env for get+row+nr");
6132 #endif
6133 CSL_IGNORE(env);
6134 /* copy arguments values to proper place */
6135 v0004 = v0000;
6136 /* end of prologue */
6137 return Llength(nil, v0004);
6138 }
6139
6140
6141
6142 /* Code for setcar */
6143
CC_setcar(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)6144 static Lisp_Object CC_setcar(Lisp_Object env,
6145 Lisp_Object v0000, Lisp_Object v0001)
6146 {
6147 Lisp_Object nil = C_nil;
6148 Lisp_Object v0015, v0014;
6149 CSL_IGNORE(nil);
6150 #ifdef DEBUG
6151 if (check_env(env)) return aerror("env for setcar");
6152 #endif
6153 if (stack >= stacklimit)
6154 {
6155 push2(v0001,v0000);
6156 env = reclaim(env, "stack", GC_STACK, 0);
6157 pop2(v0000,v0001);
6158 nil = C_nil;
6159 if (exception_pending()) return nil;
6160 }
6161 CSL_IGNORE(env);
6162 /* space for vars preserved across procedure calls */
6163 push(nil);
6164 /* copy arguments values to proper place */
6165 stack[0] = v0001;
6166 v0015 = v0000;
6167 /* end of prologue */
6168 v0014 = v0015;
6169 v0015 = stack[0];
6170 v0015 = Lrplaca(nil, v0014, v0015);
6171 nil = C_nil;
6172 if (exception_pending()) goto v0066;
6173 { Lisp_Object res = stack[0]; popv(1); return onevalue(res); }
6174 /* error exit handlers */
6175 v0066:
6176 popv(1);
6177 return nil;
6178 }
6179
6180
6181
6182 /* Code for notstring */
6183
CC_notstring(Lisp_Object env,Lisp_Object v0000)6184 static Lisp_Object CC_notstring(Lisp_Object env,
6185 Lisp_Object v0000)
6186 {
6187 Lisp_Object nil = C_nil;
6188 Lisp_Object v0009, v0052, v0042;
6189 Lisp_Object fn;
6190 CSL_IGNORE(nil);
6191 #ifdef DEBUG
6192 if (check_env(env)) return aerror("env for notstring");
6193 #endif
6194 if (stack >= stacklimit)
6195 {
6196 push(v0000);
6197 env = reclaim(env, "stack", GC_STACK, 0);
6198 pop(v0000);
6199 nil = C_nil;
6200 if (exception_pending()) return nil;
6201 }
6202 push(env);
6203 /* copy arguments values to proper place */
6204 v0009 = v0000;
6205 /* end of prologue */
6206 v0052 = elt(env, 1); /* ! */
6207 fn = elt(env, 5); /* delall */
6208 v0009 = (*qfn2(fn))(qenv(fn), v0052, v0009);
6209 nil = C_nil;
6210 if (exception_pending()) goto v0054;
6211 env = stack[0];
6212 v0042 = v0009;
6213 v0009 = v0042;
6214 v0052 = qcar(v0009);
6215 v0009 = elt(env, 2); /* !" */
6216 if (v0052 == v0009) goto v0174;
6217 v0009 = v0042;
6218 v0009 = Lreverse(nil, v0009);
6219 nil = C_nil;
6220 if (exception_pending()) goto v0054;
6221 env = stack[0];
6222 v0052 = qcar(v0009);
6223 v0009 = elt(env, 2); /* !" */
6224 v0009 = Lneq(nil, v0052, v0009);
6225 nil = C_nil;
6226 if (exception_pending()) goto v0054;
6227 env = stack[0];
6228 goto v0175;
6229
6230 v0175:
6231 if (v0009 == nil) goto v0059;
6232 v0009 = qvalue(elt(env, 4)); /* t */
6233 { popv(1); return onevalue(v0009); }
6234
6235 v0059:
6236 v0009 = qvalue(elt(env, 3)); /* nil */
6237 { popv(1); return onevalue(v0009); }
6238
6239 v0174:
6240 v0009 = qvalue(elt(env, 3)); /* nil */
6241 goto v0175;
6242 /* error exit handlers */
6243 v0054:
6244 popv(1);
6245 return nil;
6246 }
6247
6248
6249
6250 /* Code for rd!:onep */
6251
CC_rdTonep(Lisp_Object env,Lisp_Object v0000)6252 static Lisp_Object CC_rdTonep(Lisp_Object env,
6253 Lisp_Object v0000)
6254 {
6255 Lisp_Object nil = C_nil;
6256 Lisp_Object v0048, v0017;
6257 Lisp_Object fn;
6258 CSL_IGNORE(nil);
6259 #ifdef DEBUG
6260 if (check_env(env)) return aerror("env for rd:onep");
6261 #endif
6262 if (stack >= stacklimit)
6263 {
6264 push(v0000);
6265 env = reclaim(env, "stack", GC_STACK, 0);
6266 pop(v0000);
6267 nil = C_nil;
6268 if (exception_pending()) return nil;
6269 }
6270 push(env);
6271 /* space for vars preserved across procedure calls */
6272 push2(nil, nil);
6273 /* copy arguments values to proper place */
6274 v0048 = v0000;
6275 /* end of prologue */
6276 v0017 = v0048;
6277 v0017 = qcdr(v0017);
6278 if (!consp(v0017)) goto v0040;
6279 stack[-1] = qvalue(elt(env, 3)); /* bfone!* */
6280 stack[0] = v0048;
6281 v0017 = qvalue(elt(env, 4)); /* !:bprec!: */
6282 v0048 = (Lisp_Object)49; /* 3 */
6283 v0048 = difference2(v0017, v0048);
6284 nil = C_nil;
6285 if (exception_pending()) goto v0184;
6286 env = stack[-2];
6287 fn = elt(env, 5); /* round!:mt */
6288 v0048 = (*qfn2(fn))(qenv(fn), stack[0], v0048);
6289 nil = C_nil;
6290 if (exception_pending()) goto v0184;
6291 env = stack[-2];
6292 fn = elt(env, 6); /* csl_normbf */
6293 v0048 = (*qfn1(fn))(qenv(fn), v0048);
6294 nil = C_nil;
6295 if (exception_pending()) goto v0184;
6296 env = stack[-2];
6297 {
6298 Lisp_Object v0030 = stack[-1];
6299 popv(3);
6300 fn = elt(env, 7); /* equal!: */
6301 return (*qfn2(fn))(qenv(fn), v0030, v0048);
6302 }
6303
6304 v0040:
6305 v0017 = elt(env, 1); /* 1.0 */
6306 v0048 = qcdr(v0048);
6307 v0048 = difference2(v0017, v0048);
6308 nil = C_nil;
6309 if (exception_pending()) goto v0184;
6310 env = stack[-2];
6311 v0048 = Labsval(nil, v0048);
6312 nil = C_nil;
6313 if (exception_pending()) goto v0184;
6314 env = stack[-2];
6315 v0017 = qvalue(elt(env, 2)); /* !!fleps1 */
6316 popv(3);
6317 return Llessp(nil, v0048, v0017);
6318 /* error exit handlers */
6319 v0184:
6320 popv(3);
6321 return nil;
6322 }
6323
6324
6325
6326 /* Code for subs2!* */
6327
CC_subs2H(Lisp_Object env,Lisp_Object v0000)6328 static Lisp_Object CC_subs2H(Lisp_Object env,
6329 Lisp_Object v0000)
6330 {
6331 Lisp_Object nil = C_nil;
6332 Lisp_Object v0004, v0057;
6333 Lisp_Object fn;
6334 CSL_IGNORE(nil);
6335 #ifdef DEBUG
6336 if (check_env(env)) return aerror("env for subs2*");
6337 #endif
6338 if (stack >= stacklimit)
6339 {
6340 push(v0000);
6341 env = reclaim(env, "stack", GC_STACK, 0);
6342 pop(v0000);
6343 nil = C_nil;
6344 if (exception_pending()) return nil;
6345 }
6346 push(env);
6347 /* space for vars preserved across procedure calls */
6348 push(nil);
6349 /* copy arguments values to proper place */
6350 v0057 = v0000;
6351 /* end of prologue */
6352 v0004 = qvalue(elt(env, 1)); /* !*sub2 */
6353 stack[0] = qvalue(elt(env, 1)); /* !*sub2 */
6354 qvalue(elt(env, 1)) = v0004; /* !*sub2 */
6355 v0004 = v0057;
6356 fn = elt(env, 2); /* subs2 */
6357 v0004 = (*qfn1(fn))(qenv(fn), v0004);
6358 nil = C_nil;
6359 if (exception_pending()) goto v0064;
6360 env = stack[-1];
6361 qvalue(elt(env, 1)) = stack[0]; /* !*sub2 */
6362 { popv(2); return onevalue(v0004); }
6363 /* error exit handlers */
6364 v0064:
6365 env = stack[-1];
6366 qvalue(elt(env, 1)) = stack[0]; /* !*sub2 */
6367 popv(2);
6368 return nil;
6369 }
6370
6371
6372
6373 /* Code for mgenp */
6374
CC_mgenp(Lisp_Object env,Lisp_Object v0000)6375 static Lisp_Object CC_mgenp(Lisp_Object env,
6376 Lisp_Object v0000)
6377 {
6378 Lisp_Object nil = C_nil;
6379 Lisp_Object v0175, v0060;
6380 CSL_IGNORE(nil);
6381 #ifdef DEBUG
6382 if (check_env(env)) return aerror("env for mgenp");
6383 #endif
6384 CSL_IGNORE(env);
6385 /* copy arguments values to proper place */
6386 v0060 = v0000;
6387 /* end of prologue */
6388 v0175 = v0060;
6389 if (!consp(v0175)) goto v0055;
6390 v0175 = qvalue(elt(env, 2)); /* nil */
6391 return onevalue(v0175);
6392
6393 v0055:
6394 v0175 = v0060;
6395 v0060 = elt(env, 1); /* mgen */
6396 return get(v0175, v0060);
6397 }
6398
6399
6400
6401 /* Code for evlexcomp */
6402
CC_evlexcomp(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)6403 static Lisp_Object CC_evlexcomp(Lisp_Object env,
6404 Lisp_Object v0000, Lisp_Object v0001)
6405 {
6406 Lisp_Object nil = C_nil;
6407 Lisp_Object v0052, v0042;
6408 CSL_IGNORE(nil);
6409 #ifdef DEBUG
6410 if (check_env(env)) return aerror("env for evlexcomp");
6411 #endif
6412 if (stack >= stacklimit)
6413 {
6414 push2(v0001,v0000);
6415 env = reclaim(env, "stack", GC_STACK, 0);
6416 pop2(v0000,v0001);
6417 nil = C_nil;
6418 if (exception_pending()) return nil;
6419 }
6420 push(env);
6421 /* space for vars preserved across procedure calls */
6422 push2(nil, nil);
6423 /* copy arguments values to proper place */
6424 stack[0] = v0001;
6425 stack[-1] = v0000;
6426 /* end of prologue */
6427
6428 v0005:
6429 v0052 = stack[-1];
6430 if (v0052 == nil) goto v0055;
6431 v0052 = stack[0];
6432 if (v0052 == nil) goto v0015;
6433 v0052 = stack[-1];
6434 v0042 = qcar(v0052);
6435 v0052 = stack[0];
6436 v0052 = qcar(v0052);
6437 v0052 = Leqn(nil, v0042, v0052);
6438 nil = C_nil;
6439 if (exception_pending()) goto v0017;
6440 env = stack[-2];
6441 if (v0052 == nil) goto v0041;
6442 v0052 = stack[-1];
6443 v0052 = qcdr(v0052);
6444 stack[-1] = v0052;
6445 v0052 = stack[0];
6446 v0052 = qcdr(v0052);
6447 stack[0] = v0052;
6448 goto v0005;
6449
6450 v0041:
6451 v0052 = stack[-1];
6452 v0042 = qcar(v0052);
6453 v0052 = stack[0];
6454 v0052 = qcar(v0052);
6455 if (((int32_t)(v0042)) > ((int32_t)(v0052))) goto v0026;
6456 v0052 = (Lisp_Object)-15; /* -1 */
6457 { popv(3); return onevalue(v0052); }
6458
6459 v0026:
6460 v0052 = (Lisp_Object)17; /* 1 */
6461 { popv(3); return onevalue(v0052); }
6462
6463 v0015:
6464 v0052 = elt(env, 1); /* (0) */
6465 stack[0] = v0052;
6466 goto v0005;
6467
6468 v0055:
6469 v0052 = (Lisp_Object)1; /* 0 */
6470 { popv(3); return onevalue(v0052); }
6471 /* error exit handlers */
6472 v0017:
6473 popv(3);
6474 return nil;
6475 }
6476
6477
6478
6479 /* Code for subs2f */
6480
CC_subs2f(Lisp_Object env,Lisp_Object v0000)6481 static Lisp_Object CC_subs2f(Lisp_Object env,
6482 Lisp_Object v0000)
6483 {
6484 Lisp_Object nil = C_nil;
6485 Lisp_Object v0146, v0147;
6486 Lisp_Object fn;
6487 CSL_IGNORE(nil);
6488 #ifdef DEBUG
6489 if (check_env(env)) return aerror("env for subs2f");
6490 #endif
6491 if (stack >= stacklimit)
6492 {
6493 push(v0000);
6494 env = reclaim(env, "stack", GC_STACK, 0);
6495 pop(v0000);
6496 nil = C_nil;
6497 if (exception_pending()) return nil;
6498 }
6499 push(env);
6500 /* space for vars preserved across procedure calls */
6501 push2(nil, nil);
6502 /* copy arguments values to proper place */
6503 stack[0] = v0000;
6504 /* end of prologue */
6505 v0147 = qvalue(elt(env, 1)); /* simpcount!* */
6506 v0146 = qvalue(elt(env, 2)); /* simplimit!* */
6507 v0146 = (Lisp_Object)greaterp2(v0147, v0146);
6508 nil = C_nil;
6509 if (exception_pending()) goto v0089;
6510 v0146 = v0146 ? lisp_true : nil;
6511 env = stack[-2];
6512 if (v0146 == nil) goto v0004;
6513 v0146 = (Lisp_Object)1; /* 0 */
6514 qvalue(elt(env, 1)) = v0146; /* simpcount!* */
6515 v0146 = elt(env, 3); /* "Simplification recursion too deep" */
6516 v0147 = v0146;
6517 v0146 = v0147;
6518 qvalue(elt(env, 4)) = v0146; /* errmsg!* */
6519 v0146 = qvalue(elt(env, 5)); /* !*protfg */
6520 if (!(v0146 == nil)) goto v0051;
6521 v0146 = v0147;
6522 fn = elt(env, 10); /* lprie */
6523 v0146 = (*qfn1(fn))(qenv(fn), v0146);
6524 nil = C_nil;
6525 if (exception_pending()) goto v0089;
6526 env = stack[-2];
6527 goto v0051;
6528
6529 v0051:
6530 v0146 = Lerror0(nil, 0);
6531 nil = C_nil;
6532 if (exception_pending()) goto v0089;
6533 env = stack[-2];
6534 goto v0004;
6535
6536 v0004:
6537 v0146 = qvalue(elt(env, 1)); /* simpcount!* */
6538 v0146 = add1(v0146);
6539 nil = C_nil;
6540 if (exception_pending()) goto v0089;
6541 env = stack[-2];
6542 qvalue(elt(env, 1)) = v0146; /* simpcount!* */
6543 v0146 = qvalue(elt(env, 6)); /* nil */
6544 qvalue(elt(env, 7)) = v0146; /* !*sub2 */
6545 v0146 = stack[0];
6546 fn = elt(env, 11); /* subs2f1 */
6547 v0146 = (*qfn1(fn))(qenv(fn), v0146);
6548 nil = C_nil;
6549 if (exception_pending()) goto v0089;
6550 env = stack[-2];
6551 stack[-1] = v0146;
6552 v0146 = qvalue(elt(env, 7)); /* !*sub2 */
6553 if (!(v0146 == nil)) goto v0063;
6554 v0146 = qvalue(elt(env, 8)); /* powlis1!* */
6555 if (!(v0146 == nil)) goto v0063;
6556
6557 v0011:
6558 v0146 = qvalue(elt(env, 1)); /* simpcount!* */
6559 v0146 = sub1(v0146);
6560 nil = C_nil;
6561 if (exception_pending()) goto v0089;
6562 env = stack[-2];
6563 qvalue(elt(env, 1)) = v0146; /* simpcount!* */
6564 { Lisp_Object res = stack[-1]; popv(3); return onevalue(res); }
6565
6566 v0063:
6567 v0146 = qvalue(elt(env, 9)); /* !*resubs */
6568 if (v0146 == nil) goto v0011;
6569 v0146 = stack[-1];
6570 v0147 = qcar(v0146);
6571 v0146 = stack[0];
6572 if (equal(v0147, v0146)) goto v0148;
6573 v0146 = qvalue(elt(env, 6)); /* nil */
6574 goto v0049;
6575
6576 v0049:
6577 if (v0146 == nil) goto v0188;
6578 v0146 = qvalue(elt(env, 6)); /* nil */
6579 qvalue(elt(env, 7)) = v0146; /* !*sub2 */
6580 goto v0011;
6581
6582 v0188:
6583 v0146 = stack[-1];
6584 fn = elt(env, 12); /* subs2q */
6585 v0146 = (*qfn1(fn))(qenv(fn), v0146);
6586 nil = C_nil;
6587 if (exception_pending()) goto v0089;
6588 env = stack[-2];
6589 stack[-1] = v0146;
6590 goto v0011;
6591
6592 v0148:
6593 v0146 = stack[-1];
6594 v0147 = qcdr(v0146);
6595 v0146 = (Lisp_Object)17; /* 1 */
6596 v0146 = (v0147 == v0146 ? lisp_true : nil);
6597 goto v0049;
6598 /* error exit handlers */
6599 v0089:
6600 popv(3);
6601 return nil;
6602 }
6603
6604
6605
6606 /* Code for ordpp */
6607
CC_ordpp(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)6608 static Lisp_Object CC_ordpp(Lisp_Object env,
6609 Lisp_Object v0000, Lisp_Object v0001)
6610 {
6611 Lisp_Object nil = C_nil;
6612 Lisp_Object v0090, v0012, v0013, v0199, v0188;
6613 Lisp_Object fn;
6614 CSL_IGNORE(nil);
6615 #ifdef DEBUG
6616 if (check_env(env)) return aerror("env for ordpp");
6617 #endif
6618 CSL_IGNORE(env);
6619 /* copy arguments values to proper place */
6620 v0013 = v0001;
6621 v0199 = v0000;
6622 /* end of prologue */
6623 v0090 = v0199;
6624 v0012 = qcar(v0090);
6625 v0090 = v0013;
6626 v0090 = qcar(v0090);
6627 if (v0012 == v0090) goto v0065;
6628 v0090 = qvalue(elt(env, 1)); /* kord!* */
6629 v0188 = v0090;
6630 v0090 = v0199;
6631 v0090 = qcar(v0090);
6632 v0199 = v0090;
6633 v0090 = v0013;
6634 v0090 = qcar(v0090);
6635 v0013 = v0090;
6636 goto v0004;
6637
6638 v0004:
6639 v0090 = v0188;
6640 if (v0090 == nil) goto v0032;
6641 v0012 = v0199;
6642 v0090 = v0188;
6643 v0090 = qcar(v0090);
6644 if (v0012 == v0090) goto v0042;
6645 v0012 = v0013;
6646 v0090 = v0188;
6647 v0090 = qcar(v0090);
6648 if (v0012 == v0090) goto v0170;
6649 v0090 = v0188;
6650 v0090 = qcdr(v0090);
6651 v0188 = v0090;
6652 goto v0004;
6653
6654 v0170:
6655 v0090 = qvalue(elt(env, 3)); /* nil */
6656 return onevalue(v0090);
6657
6658 v0042:
6659 v0090 = qvalue(elt(env, 2)); /* t */
6660 return onevalue(v0090);
6661
6662 v0032:
6663 v0090 = v0199;
6664 v0012 = v0013;
6665 {
6666 fn = elt(env, 4); /* ordpa */
6667 return (*qfn2(fn))(qenv(fn), v0090, v0012);
6668 }
6669
6670 v0065:
6671 v0090 = v0199;
6672 v0090 = qcdr(v0090);
6673 v0012 = v0013;
6674 v0012 = qcdr(v0012);
6675 return Lgreaterp(nil, v0090, v0012);
6676 }
6677
6678
6679
6680 /* Code for !:minusp */
6681
CC_Tminusp(Lisp_Object env,Lisp_Object v0000)6682 static Lisp_Object CC_Tminusp(Lisp_Object env,
6683 Lisp_Object v0000)
6684 {
6685 Lisp_Object nil = C_nil;
6686 Lisp_Object v0022, v0067, v0047;
6687 CSL_IGNORE(nil);
6688 #ifdef DEBUG
6689 if (check_env(env)) return aerror("env for :minusp");
6690 #endif
6691 if (stack >= stacklimit)
6692 {
6693 push(v0000);
6694 env = reclaim(env, "stack", GC_STACK, 0);
6695 pop(v0000);
6696 nil = C_nil;
6697 if (exception_pending()) return nil;
6698 }
6699 CSL_IGNORE(env);
6700 /* copy arguments values to proper place */
6701 v0047 = v0000;
6702 /* end of prologue */
6703 v0022 = v0047;
6704 if (!consp(v0022)) goto v0006;
6705 v0022 = v0047;
6706 v0067 = qcar(v0022);
6707 v0022 = elt(env, 1); /* minusp */
6708 v0022 = get(v0067, v0022);
6709 v0067 = v0047;
6710 return Lapply1(nil, v0022, v0067);
6711
6712 v0006:
6713 v0022 = v0047;
6714 return Lminusp(nil, v0022);
6715 }
6716
6717
6718
6719 /* Code for fprin2 */
6720
CC_fprin2(Lisp_Object env,Lisp_Object v0000)6721 static Lisp_Object CC_fprin2(Lisp_Object env,
6722 Lisp_Object v0000)
6723 {
6724 Lisp_Object nil = C_nil;
6725 Lisp_Object v0066, v0040;
6726 Lisp_Object fn;
6727 CSL_IGNORE(nil);
6728 #ifdef DEBUG
6729 if (check_env(env)) return aerror("env for fprin2");
6730 #endif
6731 if (stack >= stacklimit)
6732 {
6733 push(v0000);
6734 env = reclaim(env, "stack", GC_STACK, 0);
6735 pop(v0000);
6736 nil = C_nil;
6737 if (exception_pending()) return nil;
6738 }
6739 push(env);
6740 /* space for vars preserved across procedure calls */
6741 push(nil);
6742 /* copy arguments values to proper place */
6743 v0040 = v0000;
6744 /* end of prologue */
6745 v0066 = qvalue(elt(env, 1)); /* nil */
6746 stack[0] = qvalue(elt(env, 2)); /* !*lower */
6747 qvalue(elt(env, 2)) = v0066; /* !*lower */
6748 v0066 = qvalue(elt(env, 3)); /* !*fortupper */
6749 if (v0066 == nil) goto v0086;
6750 v0066 = v0040;
6751 fn = elt(env, 4); /* prin2!-upcase */
6752 v0066 = (*qfn1(fn))(qenv(fn), v0066);
6753 nil = C_nil;
6754 if (exception_pending()) goto v0175;
6755 env = stack[-1];
6756 goto v0005;
6757
6758 v0005:
6759 qvalue(elt(env, 2)) = stack[0]; /* !*lower */
6760 { popv(2); return onevalue(v0066); }
6761
6762 v0086:
6763 v0066 = v0040;
6764 fn = elt(env, 5); /* prin2!-downcase */
6765 v0066 = (*qfn1(fn))(qenv(fn), v0066);
6766 nil = C_nil;
6767 if (exception_pending()) goto v0175;
6768 env = stack[-1];
6769 goto v0005;
6770 /* error exit handlers */
6771 v0175:
6772 env = stack[-1];
6773 qvalue(elt(env, 2)) = stack[0]; /* !*lower */
6774 popv(2);
6775 return nil;
6776 }
6777
6778
6779
6780 /* Code for reordop */
6781
CC_reordop(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)6782 static Lisp_Object CC_reordop(Lisp_Object env,
6783 Lisp_Object v0000, Lisp_Object v0001)
6784 {
6785 Lisp_Object nil = C_nil;
6786 Lisp_Object v0044, v0041;
6787 Lisp_Object fn;
6788 CSL_IGNORE(nil);
6789 #ifdef DEBUG
6790 if (check_env(env)) return aerror("env for reordop");
6791 #endif
6792 if (stack >= stacklimit)
6793 {
6794 push2(v0001,v0000);
6795 env = reclaim(env, "stack", GC_STACK, 0);
6796 pop2(v0000,v0001);
6797 nil = C_nil;
6798 if (exception_pending()) return nil;
6799 }
6800 push(env);
6801 /* space for vars preserved across procedure calls */
6802 push2(nil, nil);
6803 /* copy arguments values to proper place */
6804 stack[0] = v0001;
6805 stack[-1] = v0000;
6806 /* end of prologue */
6807 v0044 = qvalue(elt(env, 1)); /* !*ncmp */
6808 if (v0044 == nil) goto v0055;
6809 v0044 = stack[-1];
6810 fn = elt(env, 3); /* noncomp1 */
6811 v0044 = (*qfn1(fn))(qenv(fn), v0044);
6812 nil = C_nil;
6813 if (exception_pending()) goto v0011;
6814 env = stack[-2];
6815 if (v0044 == nil) goto v0040;
6816 v0044 = stack[0];
6817 fn = elt(env, 3); /* noncomp1 */
6818 v0044 = (*qfn1(fn))(qenv(fn), v0044);
6819 nil = C_nil;
6820 if (exception_pending()) goto v0011;
6821 env = stack[-2];
6822 goto v0057;
6823
6824 v0057:
6825 if (!(v0044 == nil)) { popv(3); return onevalue(v0044); }
6826 v0041 = stack[-1];
6827 v0044 = stack[0];
6828 {
6829 popv(3);
6830 fn = elt(env, 4); /* ordop */
6831 return (*qfn2(fn))(qenv(fn), v0041, v0044);
6832 }
6833
6834 v0040:
6835 v0044 = qvalue(elt(env, 2)); /* nil */
6836 goto v0057;
6837
6838 v0055:
6839 v0044 = qvalue(elt(env, 2)); /* nil */
6840 goto v0057;
6841 /* error exit handlers */
6842 v0011:
6843 popv(3);
6844 return nil;
6845 }
6846
6847
6848
6849 /* Code for !*collectphysops_reversed */
6850
CC_Hcollectphysops_reversed(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)6851 static Lisp_Object CC_Hcollectphysops_reversed(Lisp_Object env,
6852 Lisp_Object v0000, Lisp_Object v0001)
6853 {
6854 Lisp_Object nil = C_nil;
6855 Lisp_Object v0063, v0032;
6856 Lisp_Object fn;
6857 CSL_IGNORE(nil);
6858 #ifdef DEBUG
6859 if (check_env(env)) return aerror("env for *collectphysops_reversed");
6860 #endif
6861 if (stack >= stacklimit)
6862 {
6863 push2(v0001,v0000);
6864 env = reclaim(env, "stack", GC_STACK, 0);
6865 pop2(v0000,v0001);
6866 nil = C_nil;
6867 if (exception_pending()) return nil;
6868 }
6869 push(env);
6870 /* space for vars preserved across procedure calls */
6871 push2(nil, nil);
6872 /* copy arguments values to proper place */
6873 stack[0] = v0001;
6874 stack[-1] = v0000;
6875 /* end of prologue */
6876 v0063 = stack[-1];
6877 fn = elt(env, 2); /* physopp */
6878 v0063 = (*qfn1(fn))(qenv(fn), v0063);
6879 nil = C_nil;
6880 if (exception_pending()) goto v0058;
6881 env = stack[-2];
6882 if (v0063 == nil) goto v0065;
6883 v0032 = stack[-1];
6884 v0063 = stack[0];
6885 popv(3);
6886 return cons(v0032, v0063);
6887
6888 v0065:
6889 v0063 = stack[-1];
6890 if (!consp(v0063)) { Lisp_Object res = stack[0]; popv(3); return onevalue(res); }
6891 v0063 = stack[-1];
6892 v0032 = qcar(v0063);
6893 v0063 = stack[0];
6894 v0063 = CC_Hcollectphysops_reversed(env, v0032, v0063);
6895 nil = C_nil;
6896 if (exception_pending()) goto v0058;
6897 env = stack[-2];
6898 stack[0] = v0063;
6899 v0063 = stack[-1];
6900 v0063 = qcdr(v0063);
6901 stack[-1] = v0063;
6902 goto v0065;
6903 /* error exit handlers */
6904 v0058:
6905 popv(3);
6906 return nil;
6907 }
6908
6909
6910
6911 /* Code for constimes */
6912
CC_constimes(Lisp_Object env,Lisp_Object v0000)6913 static Lisp_Object CC_constimes(Lisp_Object env,
6914 Lisp_Object v0000)
6915 {
6916 Lisp_Object nil = C_nil;
6917 Lisp_Object v0171, v0086;
6918 Lisp_Object fn;
6919 CSL_IGNORE(nil);
6920 #ifdef DEBUG
6921 if (check_env(env)) return aerror("env for constimes");
6922 #endif
6923 CSL_IGNORE(env);
6924 /* copy arguments values to proper place */
6925 v0171 = v0000;
6926 /* end of prologue */
6927 v0086 = v0171;
6928 v0171 = qvalue(elt(env, 1)); /* nil */
6929 {
6930 fn = elt(env, 2); /* cstimes */
6931 return (*qfn2(fn))(qenv(fn), v0086, v0171);
6932 }
6933 }
6934
6935
6936
6937 /* Code for angles!-equal */
6938
CC_anglesKequal(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)6939 static Lisp_Object CC_anglesKequal(Lisp_Object env,
6940 Lisp_Object v0000, Lisp_Object v0001)
6941 {
6942 Lisp_Object nil = C_nil;
6943 Lisp_Object v0054, v0048, v0017;
6944 CSL_IGNORE(nil);
6945 #ifdef DEBUG
6946 if (check_env(env)) return aerror("env for angles-equal");
6947 #endif
6948 if (stack >= stacklimit)
6949 {
6950 push2(v0001,v0000);
6951 env = reclaim(env, "stack", GC_STACK, 0);
6952 pop2(v0000,v0001);
6953 nil = C_nil;
6954 if (exception_pending()) return nil;
6955 }
6956 push(env);
6957 /* space for vars preserved across procedure calls */
6958 push3(nil, nil, nil);
6959 /* copy arguments values to proper place */
6960 stack[0] = v0001;
6961 stack[-1] = v0000;
6962 /* end of prologue */
6963 v0054 = (Lisp_Object)1; /* 0 */
6964 stack[-2] = v0054;
6965 goto v0039;
6966
6967 v0039:
6968 v0048 = stack[-1];
6969 v0054 = stack[-2];
6970 v0017 = *(Lisp_Object *)((char *)v0048 + (CELL-TAG_VECTOR) + ((int32_t)v0054/(16/CELL)));
6971 v0048 = stack[0];
6972 v0054 = stack[-2];
6973 v0054 = *(Lisp_Object *)((char *)v0048 + (CELL-TAG_VECTOR) + ((int32_t)v0054/(16/CELL)));
6974 if (equal(v0017, v0054)) goto v0064;
6975 v0054 = qvalue(elt(env, 1)); /* nil */
6976 { popv(4); return onevalue(v0054); }
6977
6978 v0064:
6979 v0054 = stack[-2];
6980 v0054 = add1(v0054);
6981 nil = C_nil;
6982 if (exception_pending()) goto v0030;
6983 env = stack[-3];
6984 stack[-2] = v0054;
6985 v0048 = stack[-2];
6986 v0054 = (Lisp_Object)129; /* 8 */
6987 v0054 = (Lisp_Object)lessp2(v0048, v0054);
6988 nil = C_nil;
6989 if (exception_pending()) goto v0030;
6990 v0054 = v0054 ? lisp_true : nil;
6991 env = stack[-3];
6992 if (!(v0054 == nil)) goto v0039;
6993 v0054 = qvalue(elt(env, 2)); /* t */
6994 { popv(4); return onevalue(v0054); }
6995 /* error exit handlers */
6996 v0030:
6997 popv(4);
6998 return nil;
6999 }
7000
7001
7002
7003 /* Code for mo_vdivides!? */
7004
CC_mo_vdividesW(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)7005 static Lisp_Object CC_mo_vdividesW(Lisp_Object env,
7006 Lisp_Object v0000, Lisp_Object v0001)
7007 {
7008 Lisp_Object nil = C_nil;
7009 Lisp_Object v0067, v0047;
7010 Lisp_Object fn;
7011 CSL_IGNORE(nil);
7012 #ifdef DEBUG
7013 if (check_env(env)) return aerror("env for mo_vdivides?");
7014 #endif
7015 if (stack >= stacklimit)
7016 {
7017 push2(v0001,v0000);
7018 env = reclaim(env, "stack", GC_STACK, 0);
7019 pop2(v0000,v0001);
7020 nil = C_nil;
7021 if (exception_pending()) return nil;
7022 }
7023 push(env);
7024 /* space for vars preserved across procedure calls */
7025 push3(nil, nil, nil);
7026 /* copy arguments values to proper place */
7027 stack[0] = v0001;
7028 stack[-1] = v0000;
7029 /* end of prologue */
7030 v0067 = stack[-1];
7031 fn = elt(env, 2); /* mo_comp */
7032 stack[-2] = (*qfn1(fn))(qenv(fn), v0067);
7033 nil = C_nil;
7034 if (exception_pending()) goto v0044;
7035 env = stack[-3];
7036 v0067 = stack[0];
7037 fn = elt(env, 2); /* mo_comp */
7038 v0067 = (*qfn1(fn))(qenv(fn), v0067);
7039 nil = C_nil;
7040 if (exception_pending()) goto v0044;
7041 env = stack[-3];
7042 v0067 = Leqn(nil, stack[-2], v0067);
7043 nil = C_nil;
7044 if (exception_pending()) goto v0044;
7045 env = stack[-3];
7046 if (v0067 == nil) goto v0005;
7047 v0047 = stack[-1];
7048 v0067 = stack[0];
7049 {
7050 popv(4);
7051 fn = elt(env, 3); /* mo_divides!? */
7052 return (*qfn2(fn))(qenv(fn), v0047, v0067);
7053 }
7054
7055 v0005:
7056 v0067 = qvalue(elt(env, 1)); /* nil */
7057 { popv(4); return onevalue(v0067); }
7058 /* error exit handlers */
7059 v0044:
7060 popv(4);
7061 return nil;
7062 }
7063
7064
7065
7066 /* Code for dless */
7067
CC_dless(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)7068 static Lisp_Object CC_dless(Lisp_Object env,
7069 Lisp_Object v0000, Lisp_Object v0001)
7070 {
7071 Lisp_Object nil = C_nil;
7072 Lisp_Object v0088, v0089, v0091;
7073 Lisp_Object fn;
7074 CSL_IGNORE(nil);
7075 #ifdef DEBUG
7076 if (check_env(env)) return aerror("env for dless");
7077 #endif
7078 if (stack >= stacklimit)
7079 {
7080 push2(v0001,v0000);
7081 env = reclaim(env, "stack", GC_STACK, 0);
7082 pop2(v0000,v0001);
7083 nil = C_nil;
7084 if (exception_pending()) return nil;
7085 }
7086 push(env);
7087 /* space for vars preserved across procedure calls */
7088 push2(nil, nil);
7089 /* copy arguments values to proper place */
7090 v0091 = v0001;
7091 stack[0] = v0000;
7092 /* end of prologue */
7093 v0089 = qvalue(elt(env, 1)); /* ordering */
7094 v0088 = elt(env, 2); /* lex */
7095 if (v0089 == v0088) goto v0066;
7096 v0088 = stack[0];
7097 v0089 = qcar(v0088);
7098 v0088 = v0091;
7099 v0088 = qcar(v0088);
7100 if (((int32_t)(v0089)) < ((int32_t)(v0088))) goto v0080;
7101 v0088 = stack[0];
7102 v0089 = qcar(v0088);
7103 v0088 = v0091;
7104 v0088 = qcar(v0088);
7105 if (((int32_t)(v0089)) > ((int32_t)(v0088))) goto v0041;
7106 v0089 = qvalue(elt(env, 1)); /* ordering */
7107 v0088 = elt(env, 5); /* glex */
7108 if (v0089 == v0088) goto v0031;
7109 v0089 = qvalue(elt(env, 1)); /* ordering */
7110 v0088 = elt(env, 6); /* grev */
7111 if (v0089 == v0088) goto v0199;
7112 v0088 = nil;
7113 { popv(3); return onevalue(v0088); }
7114
7115 v0199:
7116 v0088 = v0091;
7117 v0088 = qcdr(v0088);
7118 stack[-1] = Lreverse(nil, v0088);
7119 nil = C_nil;
7120 if (exception_pending()) goto v0023;
7121 env = stack[-2];
7122 v0088 = stack[0];
7123 v0088 = qcdr(v0088);
7124 v0088 = Lreverse(nil, v0088);
7125 nil = C_nil;
7126 if (exception_pending()) goto v0023;
7127 env = stack[-2];
7128 {
7129 Lisp_Object v0024 = stack[-1];
7130 popv(3);
7131 fn = elt(env, 7); /* dlesslex */
7132 return (*qfn2(fn))(qenv(fn), v0024, v0088);
7133 }
7134
7135 v0031:
7136 v0088 = stack[0];
7137 v0088 = qcdr(v0088);
7138 v0089 = v0091;
7139 v0089 = qcdr(v0089);
7140 {
7141 popv(3);
7142 fn = elt(env, 7); /* dlesslex */
7143 return (*qfn2(fn))(qenv(fn), v0088, v0089);
7144 }
7145
7146 v0041:
7147 v0088 = qvalue(elt(env, 4)); /* nil */
7148 { popv(3); return onevalue(v0088); }
7149
7150 v0080:
7151 v0088 = qvalue(elt(env, 3)); /* t */
7152 { popv(3); return onevalue(v0088); }
7153
7154 v0066:
7155 v0088 = stack[0];
7156 v0089 = v0091;
7157 {
7158 popv(3);
7159 fn = elt(env, 7); /* dlesslex */
7160 return (*qfn2(fn))(qenv(fn), v0088, v0089);
7161 }
7162 /* error exit handlers */
7163 v0023:
7164 popv(3);
7165 return nil;
7166 }
7167
7168
7169
7170 /* Code for pappl0 */
7171
CC_pappl0(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)7172 static Lisp_Object CC_pappl0(Lisp_Object env,
7173 Lisp_Object v0000, Lisp_Object v0001)
7174 {
7175 Lisp_Object nil = C_nil;
7176 Lisp_Object v0014, v0034;
7177 Lisp_Object fn;
7178 CSL_IGNORE(nil);
7179 #ifdef DEBUG
7180 if (check_env(env)) return aerror("env for pappl0");
7181 #endif
7182 if (stack >= stacklimit)
7183 {
7184 push2(v0001,v0000);
7185 env = reclaim(env, "stack", GC_STACK, 0);
7186 pop2(v0000,v0001);
7187 nil = C_nil;
7188 if (exception_pending()) return nil;
7189 }
7190 push(env);
7191 /* space for vars preserved across procedure calls */
7192 push(nil);
7193 /* copy arguments values to proper place */
7194 v0014 = v0001;
7195 v0034 = v0000;
7196 /* end of prologue */
7197 stack[0] = v0034;
7198 fn = elt(env, 1); /* unpkp */
7199 v0014 = (*qfn1(fn))(qenv(fn), v0014);
7200 nil = C_nil;
7201 if (exception_pending()) goto v0040;
7202 env = stack[-1];
7203 fn = elt(env, 2); /* pappl */
7204 v0014 = (*qfn2(fn))(qenv(fn), stack[0], v0014);
7205 nil = C_nil;
7206 if (exception_pending()) goto v0040;
7207 env = stack[-1];
7208 {
7209 popv(2);
7210 fn = elt(env, 3); /* pkp */
7211 return (*qfn1(fn))(qenv(fn), v0014);
7212 }
7213 /* error exit handlers */
7214 v0040:
7215 popv(2);
7216 return nil;
7217 }
7218
7219
7220
7221 /* Code for checkargcount */
7222
CC_checkargcount(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)7223 static Lisp_Object CC_checkargcount(Lisp_Object env,
7224 Lisp_Object v0000, Lisp_Object v0001)
7225 {
7226 Lisp_Object nil = C_nil;
7227 Lisp_Object v0002, v0095, v0152, v0028, v0029;
7228 Lisp_Object fn;
7229 CSL_IGNORE(nil);
7230 #ifdef DEBUG
7231 if (check_env(env)) return aerror("env for checkargcount");
7232 #endif
7233 if (stack >= stacklimit)
7234 {
7235 push2(v0001,v0000);
7236 env = reclaim(env, "stack", GC_STACK, 0);
7237 pop2(v0000,v0001);
7238 nil = C_nil;
7239 if (exception_pending()) return nil;
7240 }
7241 push(env);
7242 /* space for vars preserved across procedure calls */
7243 push3(nil, nil, nil);
7244 /* copy arguments values to proper place */
7245 v0152 = v0001;
7246 v0028 = v0000;
7247 /* end of prologue */
7248 v0095 = v0028;
7249 v0002 = elt(env, 1); /* naryargs */
7250 v0002 = Lflagp(nil, v0095, v0002);
7251 env = stack[-3];
7252 if (v0002 == nil) goto v0061;
7253 v0002 = qvalue(elt(env, 2)); /* nil */
7254 { popv(4); return onevalue(v0002); }
7255
7256 v0061:
7257 v0095 = v0028;
7258 v0002 = elt(env, 3); /* number!-of!-args */
7259 v0002 = get(v0095, v0002);
7260 env = stack[-3];
7261 v0029 = v0002;
7262 v0002 = v0029;
7263 if (v0002 == nil) goto v0044;
7264 v0095 = v0029;
7265 v0002 = v0152;
7266 if (equal(v0095, v0002)) goto v0032;
7267 stack[-2] = v0028;
7268 stack[-1] = v0029;
7269 stack[0] = v0152;
7270 v0002 = qvalue(elt(env, 4)); /* curfun!* */
7271 v0002 = ncons(v0002);
7272 nil = C_nil;
7273 if (exception_pending()) goto v0013;
7274 env = stack[-3];
7275 fn = elt(env, 5); /* instdof */
7276 v0002 = (*qfnn(fn))(qenv(fn), 4, stack[-2], stack[-1], stack[0], v0002);
7277 nil = C_nil;
7278 if (exception_pending()) goto v0013;
7279 goto v0032;
7280
7281 v0032:
7282 v0002 = nil;
7283 { popv(4); return onevalue(v0002); }
7284
7285 v0044:
7286 v0002 = v0028;
7287 v0095 = v0152;
7288 {
7289 popv(4);
7290 fn = elt(env, 6); /* hasarg */
7291 return (*qfn2(fn))(qenv(fn), v0002, v0095);
7292 }
7293 /* error exit handlers */
7294 v0013:
7295 popv(4);
7296 return nil;
7297 }
7298
7299
7300
7301 /* Code for sfto_dcontentf */
7302
CC_sfto_dcontentf(Lisp_Object env,Lisp_Object v0000)7303 static Lisp_Object CC_sfto_dcontentf(Lisp_Object env,
7304 Lisp_Object v0000)
7305 {
7306 Lisp_Object nil = C_nil;
7307 Lisp_Object v0171, v0086;
7308 Lisp_Object fn;
7309 CSL_IGNORE(nil);
7310 #ifdef DEBUG
7311 if (check_env(env)) return aerror("env for sfto_dcontentf");
7312 #endif
7313 CSL_IGNORE(env);
7314 /* copy arguments values to proper place */
7315 v0171 = v0000;
7316 /* end of prologue */
7317 v0086 = v0171;
7318 v0171 = qvalue(elt(env, 1)); /* nil */
7319 {
7320 fn = elt(env, 2); /* sfto_dcontentf1 */
7321 return (*qfn2(fn))(qenv(fn), v0086, v0171);
7322 }
7323 }
7324
7325
7326
7327 /* Code for lt!* */
7328
CC_ltH(Lisp_Object env,Lisp_Object v0000)7329 static Lisp_Object CC_ltH(Lisp_Object env,
7330 Lisp_Object v0000)
7331 {
7332 Lisp_Object nil = C_nil;
7333 Lisp_Object v0029, v0198, v0090;
7334 Lisp_Object fn;
7335 CSL_IGNORE(nil);
7336 #ifdef DEBUG
7337 if (check_env(env)) return aerror("env for lt*");
7338 #endif
7339 if (stack >= stacklimit)
7340 {
7341 push(v0000);
7342 env = reclaim(env, "stack", GC_STACK, 0);
7343 pop(v0000);
7344 nil = C_nil;
7345 if (exception_pending()) return nil;
7346 }
7347 push(env);
7348 /* space for vars preserved across procedure calls */
7349 push3(nil, nil, nil);
7350 /* copy arguments values to proper place */
7351 stack[-1] = v0000;
7352 /* end of prologue */
7353 v0029 = qvalue(elt(env, 1)); /* !*mcd */
7354 if (!(v0029 == nil)) goto v0006;
7355 v0029 = stack[-1];
7356 v0029 = qcar(v0029);
7357 v0029 = qcar(v0029);
7358 v0198 = qcdr(v0029);
7359 v0029 = (Lisp_Object)1; /* 0 */
7360 v0029 = (Lisp_Object)greaterp2(v0198, v0029);
7361 nil = C_nil;
7362 if (exception_pending()) goto v0188;
7363 v0029 = v0029 ? lisp_true : nil;
7364 env = stack[-3];
7365 if (!(v0029 == nil)) goto v0006;
7366 v0029 = stack[-1];
7367 v0029 = qcar(v0029);
7368 stack[-2] = v0029;
7369 v0029 = stack[-1];
7370 v0029 = qcar(v0029);
7371 v0029 = qcar(v0029);
7372 v0029 = qcar(v0029);
7373 stack[0] = v0029;
7374 goto v0067;
7375
7376 v0067:
7377 v0029 = stack[-1];
7378 v0029 = qcdr(v0029);
7379 stack[-1] = v0029;
7380 v0029 = stack[-1];
7381 if (v0029 == nil) { Lisp_Object res = stack[-2]; popv(4); return onevalue(res); }
7382 v0198 = stack[-1];
7383 v0029 = stack[0];
7384 fn = elt(env, 2); /* degr */
7385 v0198 = (*qfn2(fn))(qenv(fn), v0198, v0029);
7386 nil = C_nil;
7387 if (exception_pending()) goto v0188;
7388 env = stack[-3];
7389 v0029 = (Lisp_Object)1; /* 0 */
7390 if (!(v0198 == v0029)) goto v0067;
7391 v0090 = stack[0];
7392 v0198 = (Lisp_Object)1; /* 0 */
7393 v0029 = stack[-1];
7394 popv(4);
7395 return acons(v0090, v0198, v0029);
7396
7397 v0006:
7398 v0029 = stack[-1];
7399 v0029 = qcar(v0029);
7400 { popv(4); return onevalue(v0029); }
7401 /* error exit handlers */
7402 v0188:
7403 popv(4);
7404 return nil;
7405 }
7406
7407
7408
7409 /* Code for mtchk */
7410
CC_mtchk(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)7411 static Lisp_Object CC_mtchk(Lisp_Object env,
7412 Lisp_Object v0000, Lisp_Object v0001)
7413 {
7414 Lisp_Object nil = C_nil;
7415 Lisp_Object v0126, v0162, v0245, v0207;
7416 Lisp_Object fn;
7417 CSL_IGNORE(nil);
7418 #ifdef DEBUG
7419 if (check_env(env)) return aerror("env for mtchk");
7420 #endif
7421 if (stack >= stacklimit)
7422 {
7423 push2(v0001,v0000);
7424 env = reclaim(env, "stack", GC_STACK, 0);
7425 pop2(v0000,v0001);
7426 nil = C_nil;
7427 if (exception_pending()) return nil;
7428 }
7429 push(env);
7430 /* space for vars preserved across procedure calls */
7431 push5(nil, nil, nil, nil, nil);
7432 push5(nil, nil, nil, nil, nil);
7433 push(nil);
7434 /* copy arguments values to proper place */
7435 stack[-8] = v0001;
7436 stack[-9] = v0000;
7437 /* end of prologue */
7438 stack[-4] = nil;
7439 stack[-3] = nil;
7440 v0126 = qvalue(elt(env, 1)); /* !*ncmp */
7441 if (v0126 == nil) goto v0061;
7442 v0126 = stack[-9];
7443 v0126 = qcar(v0126);
7444 fn = elt(env, 3); /* noncomp1 */
7445 v0126 = (*qfn1(fn))(qenv(fn), v0126);
7446 nil = C_nil;
7447 if (exception_pending()) goto v0128;
7448 env = stack[-11];
7449 goto v0060;
7450
7451 v0060:
7452 stack[-10] = v0126;
7453 goto v0015;
7454
7455 v0015:
7456 v0126 = stack[-8];
7457 if (v0126 == nil) { Lisp_Object res = stack[-4]; popv(12); return onevalue(res); }
7458 v0126 = stack[-8];
7459 v0126 = qcar(v0126);
7460 stack[-7] = v0126;
7461 v0126 = stack[-7];
7462 v0126 = qcar(v0126);
7463 stack[-6] = v0126;
7464 goto v0014;
7465
7466 v0014:
7467 v0126 = stack[-6];
7468 if (v0126 == nil) goto v0040;
7469 v0207 = stack[-9];
7470 v0126 = stack[-6];
7471 v0245 = qcar(v0126);
7472 v0126 = stack[-7];
7473 v0126 = qcdr(v0126);
7474 v0126 = qcar(v0126);
7475 v0162 = qcar(v0126);
7476 v0126 = stack[-7];
7477 v0126 = qcdr(v0126);
7478 v0126 = qcar(v0126);
7479 v0126 = qcdr(v0126);
7480 fn = elt(env, 4); /* mtchp1 */
7481 v0126 = (*qfnn(fn))(qenv(fn), 4, v0207, v0245, v0162, v0126);
7482 nil = C_nil;
7483 if (exception_pending()) goto v0128;
7484 env = stack[-11];
7485 stack[-5] = v0126;
7486 goto v0034;
7487
7488 v0034:
7489 v0126 = stack[-5];
7490 if (v0126 == nil) goto v0066;
7491 v0126 = stack[-5];
7492 stack[0] = qcar(v0126);
7493 v0126 = stack[-6];
7494 v0162 = qcar(v0126);
7495 v0126 = stack[-7];
7496 v0126 = qcar(v0126);
7497 v0126 = Ldelete(nil, v0162, v0126);
7498 nil = C_nil;
7499 if (exception_pending()) goto v0128;
7500 env = stack[-11];
7501 stack[-2] = Lsubla(nil, stack[0], v0126);
7502 nil = C_nil;
7503 if (exception_pending()) goto v0128;
7504 env = stack[-11];
7505 v0126 = stack[-5];
7506 v0162 = qcar(v0126);
7507 v0126 = stack[-7];
7508 v0126 = qcdr(v0126);
7509 v0126 = qcar(v0126);
7510 stack[-1] = Lsubla(nil, v0162, v0126);
7511 nil = C_nil;
7512 if (exception_pending()) goto v0128;
7513 env = stack[-11];
7514 v0126 = stack[-5];
7515 v0162 = qcar(v0126);
7516 v0126 = stack[-7];
7517 v0126 = qcdr(v0126);
7518 v0126 = qcdr(v0126);
7519 v0126 = qcar(v0126);
7520 stack[0] = Lsubla(nil, v0162, v0126);
7521 nil = C_nil;
7522 if (exception_pending()) goto v0128;
7523 env = stack[-11];
7524 v0126 = stack[-5];
7525 v0162 = qcar(v0126);
7526 v0126 = stack[-6];
7527 v0126 = qcar(v0126);
7528 v0162 = Lsubla(nil, v0162, v0126);
7529 nil = C_nil;
7530 if (exception_pending()) goto v0128;
7531 env = stack[-11];
7532 v0126 = stack[-7];
7533 v0126 = qcdr(v0126);
7534 v0126 = qcdr(v0126);
7535 v0126 = qcdr(v0126);
7536 v0126 = qcar(v0126);
7537 v0126 = cons(v0162, v0126);
7538 nil = C_nil;
7539 if (exception_pending()) goto v0128;
7540 env = stack[-11];
7541 v0126 = list2(stack[0], v0126);
7542 nil = C_nil;
7543 if (exception_pending()) goto v0128;
7544 env = stack[-11];
7545 v0126 = list2star(stack[-2], stack[-1], v0126);
7546 nil = C_nil;
7547 if (exception_pending()) goto v0128;
7548 env = stack[-11];
7549 stack[0] = v0126;
7550 v0126 = qcar(v0126);
7551 if (v0126 == nil) goto v0246;
7552 v0162 = stack[0];
7553 v0126 = stack[-4];
7554 v0126 = cons(v0162, v0126);
7555 nil = C_nil;
7556 if (exception_pending()) goto v0128;
7557 env = stack[-11];
7558 stack[-4] = v0126;
7559 v0126 = stack[-3];
7560 if (!(v0126 == nil)) goto v0002;
7561 v0126 = stack[-4];
7562 stack[-3] = v0126;
7563 goto v0002;
7564
7565 v0002:
7566 v0126 = stack[-5];
7567 v0126 = qcdr(v0126);
7568 stack[-5] = v0126;
7569 goto v0034;
7570
7571 v0246:
7572 v0126 = stack[-5];
7573 v0162 = qcar(v0126);
7574 v0126 = stack[-7];
7575 v0126 = qcdr(v0126);
7576 v0126 = qcar(v0126);
7577 v0126 = qcdr(v0126);
7578 v0126 = Lsubla(nil, v0162, v0126);
7579 nil = C_nil;
7580 if (exception_pending()) goto v0128;
7581 env = stack[-11];
7582 fn = elt(env, 5); /* eval */
7583 v0126 = (*qfn1(fn))(qenv(fn), v0126);
7584 nil = C_nil;
7585 if (exception_pending()) goto v0128;
7586 env = stack[-11];
7587 if (v0126 == nil) goto v0002;
7588 v0126 = stack[0];
7589 popv(12);
7590 return ncons(v0126);
7591
7592 v0066:
7593 v0126 = stack[-10];
7594 if (v0126 == nil) goto v0140;
7595 v0126 = stack[-7];
7596 v0126 = qcdr(v0126);
7597 v0126 = qcdr(v0126);
7598 v0126 = qcdr(v0126);
7599 v0126 = qcar(v0126);
7600 if (v0126 == nil) goto v0040;
7601 v0126 = stack[-6];
7602 fn = elt(env, 6); /* nocp */
7603 v0126 = (*qfn1(fn))(qenv(fn), v0126);
7604 nil = C_nil;
7605 if (exception_pending()) goto v0128;
7606 env = stack[-11];
7607 if (!(v0126 == nil)) goto v0039;
7608
7609 v0040:
7610 v0126 = stack[-4];
7611 if (v0126 == nil) goto v0133;
7612 stack[0] = stack[-3];
7613 v0126 = stack[-7];
7614 v0126 = ncons(v0126);
7615 nil = C_nil;
7616 if (exception_pending()) goto v0128;
7617 env = stack[-11];
7618 v0126 = Lrplacd(nil, stack[0], v0126);
7619 nil = C_nil;
7620 if (exception_pending()) goto v0128;
7621 env = stack[-11];
7622 v0126 = stack[-3];
7623 v0126 = qcdr(v0126);
7624 stack[-3] = v0126;
7625 goto v0039;
7626
7627 v0039:
7628 v0126 = stack[-8];
7629 v0126 = qcdr(v0126);
7630 stack[-8] = v0126;
7631 goto v0015;
7632
7633 v0133:
7634 v0126 = stack[-7];
7635 v0126 = ncons(v0126);
7636 nil = C_nil;
7637 if (exception_pending()) goto v0128;
7638 env = stack[-11];
7639 stack[-3] = v0126;
7640 stack[-4] = v0126;
7641 goto v0039;
7642
7643 v0140:
7644 v0126 = stack[-6];
7645 v0126 = qcdr(v0126);
7646 stack[-6] = v0126;
7647 goto v0014;
7648
7649 v0061:
7650 v0126 = qvalue(elt(env, 2)); /* nil */
7651 goto v0060;
7652 /* error exit handlers */
7653 v0128:
7654 popv(12);
7655 return nil;
7656 }
7657
7658
7659
7660 /* Code for tayexp!-lessp */
7661
CC_tayexpKlessp(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)7662 static Lisp_Object CC_tayexpKlessp(Lisp_Object env,
7663 Lisp_Object v0000, Lisp_Object v0001)
7664 {
7665 Lisp_Object nil = C_nil;
7666 Lisp_Object v0197, v0043, v0148;
7667 Lisp_Object fn;
7668 CSL_IGNORE(nil);
7669 #ifdef DEBUG
7670 if (check_env(env)) return aerror("env for tayexp-lessp");
7671 #endif
7672 if (stack >= stacklimit)
7673 {
7674 push2(v0001,v0000);
7675 env = reclaim(env, "stack", GC_STACK, 0);
7676 pop2(v0000,v0001);
7677 nil = C_nil;
7678 if (exception_pending()) return nil;
7679 }
7680 push(env);
7681 /* copy arguments values to proper place */
7682 v0043 = v0001;
7683 v0148 = v0000;
7684 /* end of prologue */
7685 v0197 = v0148;
7686 if (!consp(v0197)) goto v0064;
7687 v0197 = qvalue(elt(env, 1)); /* nil */
7688 goto v0055;
7689
7690 v0055:
7691 if (v0197 == nil) goto v0067;
7692 v0197 = v0148;
7693 popv(1);
7694 return Llessp(nil, v0197, v0043);
7695
7696 v0067:
7697 v0197 = v0148;
7698 fn = elt(env, 3); /* tayexp!-difference */
7699 v0197 = (*qfn2(fn))(qenv(fn), v0197, v0043);
7700 nil = C_nil;
7701 if (exception_pending()) goto v0172;
7702 env = stack[0];
7703 v0148 = v0197;
7704 v0197 = v0148;
7705 if (!consp(v0197)) goto v0168;
7706 v0197 = v0148;
7707 v0043 = qcar(v0197);
7708 v0197 = elt(env, 2); /* minusp */
7709 v0197 = get(v0043, v0197);
7710 v0043 = v0148;
7711 popv(1);
7712 return Lapply1(nil, v0197, v0043);
7713
7714 v0168:
7715 v0197 = v0148;
7716 popv(1);
7717 return Lminusp(nil, v0197);
7718
7719 v0064:
7720 v0197 = v0043;
7721 v0197 = (consp(v0197) ? nil : lisp_true);
7722 goto v0055;
7723 /* error exit handlers */
7724 v0172:
7725 popv(1);
7726 return nil;
7727 }
7728
7729
7730
7731 /* Code for get!+vec!+entry */
7732
CC_getLvecLentry(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)7733 static Lisp_Object CC_getLvecLentry(Lisp_Object env,
7734 Lisp_Object v0000, Lisp_Object v0001)
7735 {
7736 Lisp_Object nil = C_nil;
7737 Lisp_Object v0034, v0066;
7738 Lisp_Object fn;
7739 CSL_IGNORE(nil);
7740 #ifdef DEBUG
7741 if (check_env(env)) return aerror("env for get+vec+entry");
7742 #endif
7743 if (stack >= stacklimit)
7744 {
7745 push2(v0001,v0000);
7746 env = reclaim(env, "stack", GC_STACK, 0);
7747 pop2(v0000,v0001);
7748 nil = C_nil;
7749 if (exception_pending()) return nil;
7750 }
7751 CSL_IGNORE(env);
7752 /* copy arguments values to proper place */
7753 v0034 = v0001;
7754 v0066 = v0000;
7755 /* end of prologue */
7756 fn = elt(env, 1); /* pnth */
7757 v0034 = (*qfn2(fn))(qenv(fn), v0066, v0034);
7758 errexit();
7759 v0034 = qcar(v0034);
7760 return onevalue(v0034);
7761 }
7762
7763
7764
7765 /* Code for qqe_qopheadp */
7766
CC_qqe_qopheadp(Lisp_Object env,Lisp_Object v0000)7767 static Lisp_Object CC_qqe_qopheadp(Lisp_Object env,
7768 Lisp_Object v0000)
7769 {
7770 Lisp_Object nil = C_nil;
7771 Lisp_Object v0171, v0086;
7772 CSL_IGNORE(nil);
7773 #ifdef DEBUG
7774 if (check_env(env)) return aerror("env for qqe_qopheadp");
7775 #endif
7776 CSL_IGNORE(env);
7777 /* copy arguments values to proper place */
7778 v0171 = v0000;
7779 /* end of prologue */
7780 v0086 = elt(env, 1); /* (lhead rhead) */
7781 v0171 = Lmemq(nil, v0171, v0086);
7782 return onevalue(v0171);
7783 }
7784
7785
7786
7787 /* Code for ibalp_cec */
7788
CC_ibalp_cec(Lisp_Object env,Lisp_Object v0000)7789 static Lisp_Object CC_ibalp_cec(Lisp_Object env,
7790 Lisp_Object v0000)
7791 {
7792 Lisp_Object nil = C_nil;
7793 Lisp_Object v0080;
7794 Lisp_Object fn;
7795 CSL_IGNORE(nil);
7796 #ifdef DEBUG
7797 if (check_env(env)) return aerror("env for ibalp_cec");
7798 #endif
7799 if (stack >= stacklimit)
7800 {
7801 push(v0000);
7802 env = reclaim(env, "stack", GC_STACK, 0);
7803 pop(v0000);
7804 nil = C_nil;
7805 if (exception_pending()) return nil;
7806 }
7807 push(env);
7808 /* space for vars preserved across procedure calls */
7809 push(nil);
7810 /* copy arguments values to proper place */
7811 stack[0] = v0000;
7812 /* end of prologue */
7813
7814 v0006:
7815 v0080 = stack[0];
7816 if (v0080 == nil) goto v0057;
7817 v0080 = stack[0];
7818 v0080 = qcar(v0080);
7819 fn = elt(env, 2); /* ibalp_emptyclausep */
7820 v0080 = (*qfn1(fn))(qenv(fn), v0080);
7821 nil = C_nil;
7822 if (exception_pending()) goto v0051;
7823 env = stack[-1];
7824 if (v0080 == nil) goto v0175;
7825 v0080 = stack[0];
7826 v0080 = qcar(v0080);
7827 { popv(2); return onevalue(v0080); }
7828
7829 v0175:
7830 v0080 = stack[0];
7831 v0080 = qcdr(v0080);
7832 stack[0] = v0080;
7833 goto v0006;
7834
7835 v0057:
7836 v0080 = qvalue(elt(env, 1)); /* nil */
7837 { popv(2); return onevalue(v0080); }
7838 /* error exit handlers */
7839 v0051:
7840 popv(2);
7841 return nil;
7842 }
7843
7844
7845
7846 /* Code for ctx_fromial */
7847
CC_ctx_fromial(Lisp_Object env,Lisp_Object v0000)7848 static Lisp_Object CC_ctx_fromial(Lisp_Object env,
7849 Lisp_Object v0000)
7850 {
7851 Lisp_Object nil = C_nil;
7852 Lisp_Object v0171, v0086;
7853 CSL_IGNORE(nil);
7854 #ifdef DEBUG
7855 if (check_env(env)) return aerror("env for ctx_fromial");
7856 #endif
7857 CSL_IGNORE(env);
7858 /* copy arguments values to proper place */
7859 v0171 = v0000;
7860 /* end of prologue */
7861 v0086 = elt(env, 1); /* ctx */
7862 return list2(v0086, v0171);
7863 }
7864
7865
7866
7867 /* Code for rmultpf */
7868
CC_rmultpf(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)7869 static Lisp_Object CC_rmultpf(Lisp_Object env,
7870 Lisp_Object v0000, Lisp_Object v0001)
7871 {
7872 Lisp_Object nil = C_nil;
7873 Lisp_Object v0091, v0092;
7874 Lisp_Object fn;
7875 CSL_IGNORE(nil);
7876 #ifdef DEBUG
7877 if (check_env(env)) return aerror("env for rmultpf");
7878 #endif
7879 if (stack >= stacklimit)
7880 {
7881 push2(v0001,v0000);
7882 env = reclaim(env, "stack", GC_STACK, 0);
7883 pop2(v0000,v0001);
7884 nil = C_nil;
7885 if (exception_pending()) return nil;
7886 }
7887 push(env);
7888 /* space for vars preserved across procedure calls */
7889 push4(nil, nil, nil, nil);
7890 /* copy arguments values to proper place */
7891 stack[-1] = v0001;
7892 stack[-2] = v0000;
7893 /* end of prologue */
7894 stack[-3] = nil;
7895 goto v0004;
7896
7897 v0004:
7898 v0091 = stack[-1];
7899 if (v0091 == nil) goto v0064;
7900 v0091 = stack[-1];
7901 if (!consp(v0091)) goto v0080;
7902 v0091 = stack[-1];
7903 v0091 = qcar(v0091);
7904 v0091 = (consp(v0091) ? nil : lisp_true);
7905 goto v0065;
7906
7907 v0065:
7908 if (v0091 == nil) goto v0056;
7909 v0091 = qvalue(elt(env, 1)); /* t */
7910 goto v0039;
7911
7912 v0039:
7913 if (v0091 == nil) goto v0003;
7914 stack[0] = stack[-3];
7915 v0092 = stack[-2];
7916 v0091 = stack[-1];
7917 v0091 = cons(v0092, v0091);
7918 nil = C_nil;
7919 if (exception_pending()) goto v0219;
7920 env = stack[-4];
7921 v0091 = ncons(v0091);
7922 nil = C_nil;
7923 if (exception_pending()) goto v0219;
7924 env = stack[-4];
7925 {
7926 Lisp_Object v0220 = stack[0];
7927 popv(5);
7928 fn = elt(env, 2); /* nreverse */
7929 return (*qfn2(fn))(qenv(fn), v0220, v0091);
7930 }
7931
7932 v0003:
7933 v0091 = stack[-1];
7934 v0091 = qcar(v0091);
7935 stack[0] = qcar(v0091);
7936 v0092 = stack[-2];
7937 v0091 = stack[-1];
7938 v0091 = qcar(v0091);
7939 v0091 = qcdr(v0091);
7940 v0092 = CC_rmultpf(env, v0092, v0091);
7941 nil = C_nil;
7942 if (exception_pending()) goto v0219;
7943 env = stack[-4];
7944 v0091 = stack[-3];
7945 v0091 = acons(stack[0], v0092, v0091);
7946 nil = C_nil;
7947 if (exception_pending()) goto v0219;
7948 env = stack[-4];
7949 stack[-3] = v0091;
7950 v0091 = stack[-1];
7951 v0091 = qcdr(v0091);
7952 stack[-1] = v0091;
7953 goto v0004;
7954
7955 v0056:
7956 v0091 = stack[-2];
7957 v0092 = qcar(v0091);
7958 v0091 = stack[-1];
7959 v0091 = qcar(v0091);
7960 v0091 = qcar(v0091);
7961 v0091 = qcar(v0091);
7962 fn = elt(env, 3); /* reordop */
7963 v0091 = (*qfn2(fn))(qenv(fn), v0092, v0091);
7964 nil = C_nil;
7965 if (exception_pending()) goto v0219;
7966 env = stack[-4];
7967 goto v0039;
7968
7969 v0080:
7970 v0091 = qvalue(elt(env, 1)); /* t */
7971 goto v0065;
7972
7973 v0064:
7974 v0091 = stack[-3];
7975 {
7976 popv(5);
7977 fn = elt(env, 2); /* nreverse */
7978 return (*qfn1(fn))(qenv(fn), v0091);
7979 }
7980 /* error exit handlers */
7981 v0219:
7982 popv(5);
7983 return nil;
7984 }
7985
7986
7987
7988 /* Code for multi_isarb_compl */
7989
CC_multi_isarb_compl(Lisp_Object env,Lisp_Object v0000)7990 static Lisp_Object CC_multi_isarb_compl(Lisp_Object env,
7991 Lisp_Object v0000)
7992 {
7993 Lisp_Object nil = C_nil;
7994 Lisp_Object v0053;
7995 Lisp_Object fn;
7996 CSL_IGNORE(nil);
7997 #ifdef DEBUG
7998 if (check_env(env)) return aerror("env for multi_isarb_compl");
7999 #endif
8000 if (stack >= stacklimit)
8001 {
8002 push(v0000);
8003 env = reclaim(env, "stack", GC_STACK, 0);
8004 pop(v0000);
8005 nil = C_nil;
8006 if (exception_pending()) return nil;
8007 }
8008 push(env);
8009 /* space for vars preserved across procedure calls */
8010 push(nil);
8011 /* copy arguments values to proper place */
8012 stack[0] = v0000;
8013 /* end of prologue */
8014 v0053 = stack[0];
8015 v0053 = Lconsp(nil, v0053);
8016 env = stack[-1];
8017 if (v0053 == nil) goto v0005;
8018 v0053 = stack[0];
8019 if (v0053 == nil) goto v0005;
8020 v0053 = stack[0];
8021 v0053 = qcar(v0053);
8022 fn = elt(env, 2); /* isarb_compl */
8023 v0053 = (*qfn1(fn))(qenv(fn), v0053);
8024 nil = C_nil;
8025 if (exception_pending()) goto v0022;
8026 env = stack[-1];
8027 v0053 = stack[0];
8028 v0053 = qcdr(v0053);
8029 v0053 = CC_multi_isarb_compl(env, v0053);
8030 nil = C_nil;
8031 if (exception_pending()) goto v0022;
8032 goto v0005;
8033
8034 v0005:
8035 v0053 = nil;
8036 { popv(2); return onevalue(v0053); }
8037 /* error exit handlers */
8038 v0022:
8039 popv(2);
8040 return nil;
8041 }
8042
8043
8044
8045 /* Code for dm!-times */
8046
CC_dmKtimes(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0001)8047 static Lisp_Object CC_dmKtimes(Lisp_Object env,
8048 Lisp_Object v0000, Lisp_Object v0001)
8049 {
8050 Lisp_Object nil = C_nil;
8051 Lisp_Object v0034;
8052 Lisp_Object fn;
8053 CSL_IGNORE(nil);
8054 #ifdef DEBUG
8055 if (check_env(env)) return aerror("env for dm-times");
8056 #endif
8057 if (stack >= stacklimit)
8058 {
8059 push2(v0001,v0000);
8060 env = reclaim(env, "stack", GC_STACK, 0);
8061 pop2(v0000,v0001);
8062 nil = C_nil;
8063 if (exception_pending()) return nil;
8064 }
8065 push(env);
8066 /* space for vars preserved across procedure calls */
8067 push2(nil, nil);
8068 /* copy arguments values to proper place */
8069 stack[0] = v0001;
8070 v0034 = v0000;
8071 /* end of prologue */
8072 fn = elt(env, 1); /* zero2nil */
8073 stack[-1] = (*qfn1(fn))(qenv(fn), v0034);
8074 nil = C_nil;
8075 if (exception_pending()) goto v0039;
8076 env = stack[-2];
8077 v0034 = stack[0];
8078 fn = elt(env, 1); /* zero2nil */
8079 v0034 = (*qfn1(fn))(qenv(fn), v0034);
8080 nil = C_nil;
8081 if (exception_pending()) goto v0039;
8082 env = stack[-2];
8083 fn = elt(env, 2); /* !:times */
8084 v0034 = (*qfn2(fn))(qenv(fn), stack[-1], v0034);
8085 nil = C_nil;
8086 if (exception_pending()) goto v0039;
8087 env = stack[-2];
8088 {
8089 popv(3);
8090 fn = elt(env, 3); /* nil2zero */
8091 return (*qfn1(fn))(qenv(fn), v0034);
8092 }
8093 /* error exit handlers */
8094 v0039:
8095 popv(3);
8096 return nil;
8097 }
8098
8099
8100
8101 /* Code for sqchk */
8102
CC_sqchk(Lisp_Object env,Lisp_Object v0000)8103 static Lisp_Object CC_sqchk(Lisp_Object env,
8104 Lisp_Object v0000)
8105 {
8106 Lisp_Object nil = C_nil;
8107 Lisp_Object v0033, v0059, v0058;
8108 Lisp_Object fn;
8109 CSL_IGNORE(nil);
8110 #ifdef DEBUG
8111 if (check_env(env)) return aerror("env for sqchk");
8112 #endif
8113 if (stack >= stacklimit)
8114 {
8115 push(v0000);
8116 env = reclaim(env, "stack", GC_STACK, 0);
8117 pop(v0000);
8118 nil = C_nil;
8119 if (exception_pending()) return nil;
8120 }
8121 push(env);
8122 /* copy arguments values to proper place */
8123 v0059 = v0000;
8124 /* end of prologue */
8125 v0033 = v0059;
8126 if (!consp(v0033)) { popv(1); return onevalue(v0059); }
8127 v0033 = v0059;
8128 v0058 = qcar(v0033);
8129 v0033 = elt(env, 1); /* prepfn2 */
8130 v0033 = get(v0058, v0033);
8131 env = stack[0];
8132 v0058 = v0033;
8133 v0033 = v0058;
8134 if (v0033 == nil) goto v0062;
8135 v0033 = v0058;
8136 popv(1);
8137 return Lapply1(nil, v0033, v0059);
8138
8139 v0062:
8140 v0033 = v0059;
8141 v0033 = qcar(v0033);
8142 if (!consp(v0033)) { popv(1); return onevalue(v0059); }
8143 v0033 = v0059;
8144 {
8145 popv(1);
8146 fn = elt(env, 2); /* prepf */
8147 return (*qfn1(fn))(qenv(fn), v0033);
8148 }
8149 }
8150
8151
8152
8153 /* Code for exptchk */
8154
CC_exptchk(Lisp_Object env,Lisp_Object v0000)8155 static Lisp_Object CC_exptchk(Lisp_Object env,
8156 Lisp_Object v0000)
8157 {
8158 Lisp_Object nil = C_nil;
8159 Lisp_Object v0029, v0198, v0090;
8160 Lisp_Object fn;
8161 CSL_IGNORE(nil);
8162 #ifdef DEBUG
8163 if (check_env(env)) return aerror("env for exptchk");
8164 #endif
8165 if (stack >= stacklimit)
8166 {
8167 push(v0000);
8168 env = reclaim(env, "stack", GC_STACK, 0);
8169 pop(v0000);
8170 nil = C_nil;
8171 if (exception_pending()) return nil;
8172 }
8173 push(env);
8174 /* space for vars preserved across procedure calls */
8175 push2(nil, nil);
8176 /* copy arguments values to proper place */
8177 stack[0] = v0000;
8178 /* end of prologue */
8179 v0029 = stack[0];
8180 if (!consp(v0029)) goto v0055;
8181 v0029 = stack[0];
8182 v0029 = qcar(v0029);
8183 v0029 = (consp(v0029) ? nil : lisp_true);
8184 goto v0057;
8185
8186 v0057:
8187 if (v0029 == nil) goto v0067;
8188 v0198 = stack[0];
8189 v0029 = (Lisp_Object)17; /* 1 */
8190 popv(3);
8191 return cons(v0198, v0029);
8192
8193 v0067:
8194 v0198 = stack[0];
8195 v0029 = qvalue(elt(env, 2)); /* nil */
8196 fn = elt(env, 3); /* comm_kernels1 */
8197 v0029 = (*qfn2(fn))(qenv(fn), v0198, v0029);
8198 nil = C_nil;
8199 if (exception_pending()) goto v0199;
8200 env = stack[-2];
8201 stack[-1] = v0029;
8202 v0029 = stack[-1];
8203 v0198 = Llength(nil, v0029);
8204 nil = C_nil;
8205 if (exception_pending()) goto v0199;
8206 env = stack[-2];
8207 v0029 = (Lisp_Object)33; /* 2 */
8208 v0029 = (Lisp_Object)lessp2(v0198, v0029);
8209 nil = C_nil;
8210 if (exception_pending()) goto v0199;
8211 v0029 = v0029 ? lisp_true : nil;
8212 env = stack[-2];
8213 if (v0029 == nil) goto v0018;
8214 v0198 = stack[0];
8215 v0029 = (Lisp_Object)17; /* 1 */
8216 popv(3);
8217 return cons(v0198, v0029);
8218
8219 v0018:
8220 v0090 = stack[0];
8221 v0198 = qvalue(elt(env, 2)); /* nil */
8222 v0029 = stack[-1];
8223 {
8224 popv(3);
8225 fn = elt(env, 4); /* exptchk0 */
8226 return (*qfnn(fn))(qenv(fn), 3, v0090, v0198, v0029);
8227 }
8228
8229 v0055:
8230 v0029 = qvalue(elt(env, 1)); /* t */
8231 goto v0057;
8232 /* error exit handlers */
8233 v0199:
8234 popv(3);
8235 return nil;
8236 }
8237
8238
8239
8240 /* Code for quotematrix */
8241
CC_quotematrix(Lisp_Object env,Lisp_Object v0000)8242 static Lisp_Object CC_quotematrix(Lisp_Object env,
8243 Lisp_Object v0000)
8244 {
8245 Lisp_Object v0007;
8246 #ifdef DEBUG
8247 if (check_env(env)) return aerror("env for quotematrix");
8248 #endif
8249 CSL_IGNORE(env);
8250 /* copy arguments values to proper place */
8251 v0007 = v0000;
8252 /* end of prologue */
8253 v0007 = elt(env, 1); /* matrix */
8254 return onevalue(v0007);
8255 }
8256
8257
8258
8259 setup_type const u02_setup[] =
8260 {
8261 {"lto_hashequalq", too_few_2, CC_lto_hashequalq,wrong_no_2},
8262 {"compress*", CC_compressH, too_many_1, wrong_no_1},
8263 {"noncomp1", CC_noncomp1, too_many_1, wrong_no_1},
8264 {"ps:order", CC_psTorder, too_many_1, wrong_no_1},
8265 {":zerop", CC_Tzerop, too_many_1, wrong_no_1},
8266 {"retimes", CC_retimes, too_many_1, wrong_no_1},
8267 {"bczero?", CC_bczeroW, too_many_1, wrong_no_1},
8268 {"rd:zerop", CC_rdTzerop, too_many_1, wrong_no_1},
8269 {"evzero?", CC_evzeroW, too_many_1, wrong_no_1},
8270 {"factorordp", too_few_2, CC_factorordp, wrong_no_2},
8271 {"mtchp", wrong_no_na, wrong_no_nb, (n_args *)CC_mtchp},
8272 {"collectindices_reversed", too_few_2, CC_collectindices_reversed,wrong_no_2},
8273 {"getrmacro", CC_getrmacro, too_many_1, wrong_no_1},
8274 {"reval_without_mod", CC_reval_without_mod,too_many_1,wrong_no_1},
8275 {"adddm", too_few_2, CC_adddm, wrong_no_2},
8276 {"multf", too_few_2, CC_multf, wrong_no_2},
8277 {"ring_ecart", CC_ring_ecart, too_many_1, wrong_no_1},
8278 {"reduce_pv", too_few_2, CC_reduce_pv, wrong_no_2},
8279 {"rnonep:", CC_rnonepT, too_many_1, wrong_no_1},
8280 {"general-modular-plus", too_few_2, CC_generalKmodularKplus,wrong_no_2},
8281 {"*d2n", CC_Hd2n, too_many_1, wrong_no_1},
8282 {"add2calls", CC_add2calls, too_many_1, wrong_no_1},
8283 {"cl_atmlc", CC_cl_atmlc, too_many_1, wrong_no_1},
8284 {"monomisdivisibleby", too_few_2, CC_monomisdivisibleby,wrong_no_2},
8285 {"split_form", too_few_2, CC_split_form, wrong_no_2},
8286 {"ofsf_posdefp", CC_ofsf_posdefp,too_many_1, wrong_no_1},
8287 {"tayexp-greaterp", too_few_2, CC_tayexpKgreaterp,wrong_no_2},
8288 {"mri_floorp", CC_mri_floorp, too_many_1, wrong_no_1},
8289 {"qqe_qopaddp", CC_qqe_qopaddp, too_many_1, wrong_no_1},
8290 {"sort", too_few_2, CC_sort, wrong_no_2},
8291 {"ibalp_cequal", too_few_2, CC_ibalp_cequal,wrong_no_2},
8292 {"get_token", wrong_no_na, wrong_no_nb, (n_args *)CC_get_token},
8293 {"ps:last-term", CC_psTlastKterm,too_many_1, wrong_no_1},
8294 {"dm-abs", CC_dmKabs, too_many_1, wrong_no_1},
8295 {"mval", CC_mval, too_many_1, wrong_no_1},
8296 {"bcprod", too_few_2, CC_bcprod, wrong_no_2},
8297 {"wedgepf2", too_few_2, CC_wedgepf2, wrong_no_2},
8298 {":plus", too_few_2, CC_Tplus, wrong_no_2},
8299 {"idlistp", CC_idlistp, too_many_1, wrong_no_1},
8300 {"macrochk", too_few_2, CC_macrochk, wrong_no_2},
8301 {"mo=sprod", too_few_2, CC_moMsprod, wrong_no_2},
8302 {"hasonevector", CC_hasonevector,too_many_1, wrong_no_1},
8303 {"sieve_pv", too_few_2, CC_sieve_pv, wrong_no_2},
8304 {"modtimes:", too_few_2, CC_modtimesT, wrong_no_2},
8305 {"plus-mod-p", too_few_2, CC_plusKmodKp, wrong_no_2},
8306 {"monomclone", CC_monomclone, too_many_1, wrong_no_1},
8307 {"symbollessp", too_few_2, CC_symbollessp,wrong_no_2},
8308 {"rank", CC_rank, too_many_1, wrong_no_1},
8309 {"remove-free-vars", CC_removeKfreeKvars,too_many_1,wrong_no_1},
8310 {"nocp", CC_nocp, too_many_1, wrong_no_1},
8311 {"get+row+nr", CC_getLrowLnr, too_many_1, wrong_no_1},
8312 {"setcar", too_few_2, CC_setcar, wrong_no_2},
8313 {"notstring", CC_notstring, too_many_1, wrong_no_1},
8314 {"rd:onep", CC_rdTonep, too_many_1, wrong_no_1},
8315 {"subs2*", CC_subs2H, too_many_1, wrong_no_1},
8316 {"mgenp", CC_mgenp, too_many_1, wrong_no_1},
8317 {"evlexcomp", too_few_2, CC_evlexcomp, wrong_no_2},
8318 {"subs2f", CC_subs2f, too_many_1, wrong_no_1},
8319 {"ordpp", too_few_2, CC_ordpp, wrong_no_2},
8320 {":minusp", CC_Tminusp, too_many_1, wrong_no_1},
8321 {"fprin2", CC_fprin2, too_many_1, wrong_no_1},
8322 {"reordop", too_few_2, CC_reordop, wrong_no_2},
8323 {"*collectphysops_reversed",too_few_2, CC_Hcollectphysops_reversed,wrong_no_2},
8324 {"constimes", CC_constimes, too_many_1, wrong_no_1},
8325 {"angles-equal", too_few_2, CC_anglesKequal,wrong_no_2},
8326 {"mo_vdivides?", too_few_2, CC_mo_vdividesW,wrong_no_2},
8327 {"dless", too_few_2, CC_dless, wrong_no_2},
8328 {"pappl0", too_few_2, CC_pappl0, wrong_no_2},
8329 {"checkargcount", too_few_2, CC_checkargcount,wrong_no_2},
8330 {"sfto_dcontentf", CC_sfto_dcontentf,too_many_1, wrong_no_1},
8331 {"lt*", CC_ltH, too_many_1, wrong_no_1},
8332 {"mtchk", too_few_2, CC_mtchk, wrong_no_2},
8333 {"tayexp-lessp", too_few_2, CC_tayexpKlessp,wrong_no_2},
8334 {"get+vec+entry", too_few_2, CC_getLvecLentry,wrong_no_2},
8335 {"qqe_qopheadp", CC_qqe_qopheadp,too_many_1, wrong_no_1},
8336 {"ibalp_cec", CC_ibalp_cec, too_many_1, wrong_no_1},
8337 {"ctx_fromial", CC_ctx_fromial, too_many_1, wrong_no_1},
8338 {"rmultpf", too_few_2, CC_rmultpf, wrong_no_2},
8339 {"multi_isarb_compl", CC_multi_isarb_compl,too_many_1,wrong_no_1},
8340 {"dm-times", too_few_2, CC_dmKtimes, wrong_no_2},
8341 {"sqchk", CC_sqchk, too_many_1, wrong_no_1},
8342 {"exptchk", CC_exptchk, too_many_1, wrong_no_1},
8343 {"quotematrix", CC_quotematrix, too_many_1, wrong_no_1},
8344 {NULL, (one_args *)"u02", (two_args *)"6831 8489523 5386027", 0}
8345 };
8346
8347 /* end of generated code */
8348