1
2 /* $destdir\u13.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 guesspftype */
2280
CC_guesspftype(Lisp_Object env,Lisp_Object v0000)2281 static Lisp_Object CC_guesspftype(Lisp_Object env,
2282 Lisp_Object v0000)
2283 {
2284 Lisp_Object nil = C_nil;
2285 Lisp_Object v0007, v0008, v0009;
2286 Lisp_Object fn;
2287 CSL_IGNORE(nil);
2288 #ifdef DEBUG
2289 if (check_env(env)) return aerror("env for guesspftype");
2290 #endif
2291 if (stack >= stacklimit)
2292 {
2293 push(v0000);
2294 env = reclaim(env, "stack", GC_STACK, 0);
2295 pop(v0000);
2296 nil = C_nil;
2297 if (exception_pending()) return nil;
2298 }
2299 push(env);
2300 /* space for vars preserved across procedure calls */
2301 push(nil);
2302 /* copy arguments values to proper place */
2303 stack[0] = v0000;
2304 /* end of prologue */
2305 v0007 = stack[0];
2306 if (!consp(v0007)) { Lisp_Object res = stack[0]; popv(2); return onevalue(res); }
2307 v0007 = stack[0];
2308 v0008 = qcar(v0007);
2309 v0007 = elt(env, 1); /* (wedge d partdf hodge innerprod liedf) */
2310 v0007 = Lmemq(nil, v0008, v0007);
2311 if (!(v0007 == nil)) { Lisp_Object res = stack[0]; popv(2); return onevalue(res); }
2312 v0007 = stack[0];
2313 v0007 = qcdr(v0007);
2314 v0009 = Llength(nil, v0007);
2315 nil = C_nil;
2316 if (exception_pending()) goto v0010;
2317 env = stack[-1];
2318 v0007 = stack[0];
2319 v0008 = qcar(v0007);
2320 v0007 = elt(env, 2); /* ifdegree */
2321 v0007 = get(v0008, v0007);
2322 env = stack[-1];
2323 v0007 = Lassoc(nil, v0009, v0007);
2324 if (v0007 == nil) goto v0011;
2325 v0007 = stack[0];
2326 v0007 = qcdr(v0007);
2327 fn = elt(env, 3); /* xvarlistp */
2328 v0007 = (*qfn1(fn))(qenv(fn), v0007);
2329 nil = C_nil;
2330 if (exception_pending()) goto v0010;
2331 env = stack[-1];
2332 if (v0007 == nil) { Lisp_Object res = stack[0]; popv(2); return onevalue(res); }
2333 else goto v0011;
2334
2335 v0011:
2336 v0007 = stack[0];
2337 {
2338 popv(2);
2339 fn = elt(env, 4); /* mknwedge */
2340 return (*qfn1(fn))(qenv(fn), v0007);
2341 }
2342 /* error exit handlers */
2343 v0010:
2344 popv(2);
2345 return nil;
2346 }
2347
2348
2349
2350 /* Code for equalreplaceby */
2351
CC_equalreplaceby(Lisp_Object env,Lisp_Object v0000)2352 static Lisp_Object CC_equalreplaceby(Lisp_Object env,
2353 Lisp_Object v0000)
2354 {
2355 Lisp_Object nil = C_nil;
2356 Lisp_Object v0014, v0015;
2357 CSL_IGNORE(nil);
2358 #ifdef DEBUG
2359 if (check_env(env)) return aerror("env for equalreplaceby");
2360 #endif
2361 CSL_IGNORE(env);
2362 /* copy arguments values to proper place */
2363 v0014 = v0000;
2364 /* end of prologue */
2365 v0015 = elt(env, 1); /* replaceby */
2366 return cons(v0015, v0014);
2367 }
2368
2369
2370
2371 /* Code for inttovec */
2372
CC_inttovec(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)2373 static Lisp_Object CC_inttovec(Lisp_Object env,
2374 Lisp_Object v0000, Lisp_Object v0016)
2375 {
2376 Lisp_Object nil = C_nil;
2377 Lisp_Object v0017, v0018;
2378 Lisp_Object fn;
2379 CSL_IGNORE(nil);
2380 #ifdef DEBUG
2381 if (check_env(env)) return aerror("env for inttovec");
2382 #endif
2383 if (stack >= stacklimit)
2384 {
2385 push2(v0016,v0000);
2386 env = reclaim(env, "stack", GC_STACK, 0);
2387 pop2(v0000,v0016);
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 v0018 = v0016;
2396 v0017 = v0000;
2397 /* end of prologue */
2398 stack[0] = v0018;
2399 fn = elt(env, 1); /* inttovec!-solve */
2400 v0017 = (*qfn2(fn))(qenv(fn), v0018, v0017);
2401 nil = C_nil;
2402 if (exception_pending()) goto v0019;
2403 env = stack[-1];
2404 {
2405 Lisp_Object v0020 = stack[0];
2406 popv(2);
2407 fn = elt(env, 2); /* inttovec1 */
2408 return (*qfn2(fn))(qenv(fn), v0020, v0017);
2409 }
2410 /* error exit handlers */
2411 v0019:
2412 popv(2);
2413 return nil;
2414 }
2415
2416
2417
2418 /* Code for assert_uninstall_all */
2419
CC_assert_uninstall_all(Lisp_Object env,int nargs,...)2420 static Lisp_Object MS_CDECL CC_assert_uninstall_all(Lisp_Object env, int nargs, ...)
2421 {
2422 Lisp_Object nil = C_nil;
2423 Lisp_Object v0013;
2424 Lisp_Object fn;
2425 CSL_IGNORE(nil);
2426 argcheck(nargs, 0, "assert_uninstall_all");
2427 #ifdef DEBUG
2428 if (check_env(env)) return aerror("env for assert_uninstall_all");
2429 #endif
2430 CSL_IGNORE(env);
2431 /* end of prologue */
2432 v0013 = qvalue(elt(env, 1)); /* !*assert */
2433 if (v0013 == nil) goto v0021;
2434 v0013 = qvalue(elt(env, 2)); /* assert_functionl!* */
2435 {
2436 fn = elt(env, 3); /* assert_uninstall */
2437 return (*qfn1(fn))(qenv(fn), v0013);
2438 }
2439
2440 v0021:
2441 v0013 = nil;
2442 return onevalue(v0013);
2443 }
2444
2445
2446
2447 /* Code for eqdummy */
2448
CC_eqdummy(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)2449 static Lisp_Object CC_eqdummy(Lisp_Object env,
2450 Lisp_Object v0000, Lisp_Object v0016)
2451 {
2452 Lisp_Object nil = C_nil;
2453 Lisp_Object v0026, v0027, v0028;
2454 CSL_IGNORE(nil);
2455 #ifdef DEBUG
2456 if (check_env(env)) return aerror("env for eqdummy");
2457 #endif
2458 if (stack >= stacklimit)
2459 {
2460 push2(v0016,v0000);
2461 env = reclaim(env, "stack", GC_STACK, 0);
2462 pop2(v0000,v0016);
2463 nil = C_nil;
2464 if (exception_pending()) return nil;
2465 }
2466 push(env);
2467 /* copy arguments values to proper place */
2468 v0026 = v0016;
2469 v0028 = v0000;
2470 /* end of prologue */
2471 v0027 = v0028;
2472 if (v0027 == nil) goto v0029;
2473 v0027 = elt(env, 2); /* dummy */
2474 v0027 = get(v0028, v0027);
2475 env = stack[0];
2476 v0028 = qcar(v0027);
2477 v0027 = v0026;
2478 v0026 = elt(env, 2); /* dummy */
2479 v0026 = get(v0027, v0026);
2480 v0026 = qcar(v0026);
2481 v0026 = (v0028 == v0026 ? lisp_true : nil);
2482 { popv(1); return onevalue(v0026); }
2483
2484 v0029:
2485 v0026 = qvalue(elt(env, 1)); /* nil */
2486 { popv(1); return onevalue(v0026); }
2487 }
2488
2489
2490
2491 /* Code for numlist_ordp */
2492
CC_numlist_ordp(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)2493 static Lisp_Object CC_numlist_ordp(Lisp_Object env,
2494 Lisp_Object v0000, Lisp_Object v0016)
2495 {
2496 Lisp_Object nil = C_nil;
2497 Lisp_Object v0032, v0033, v0005;
2498 Lisp_Object fn;
2499 CSL_IGNORE(nil);
2500 #ifdef DEBUG
2501 if (check_env(env)) return aerror("env for numlist_ordp");
2502 #endif
2503 CSL_IGNORE(env);
2504 /* copy arguments values to proper place */
2505 v0032 = v0016;
2506 v0033 = v0000;
2507 /* end of prologue */
2508 v0005 = v0033;
2509 v0033 = v0032;
2510 v0032 = elt(env, 1); /* lambda_ls8o1j_2 */
2511 {
2512 fn = elt(env, 2); /* cons_ordp */
2513 return (*qfnn(fn))(qenv(fn), 3, v0005, v0033, v0032);
2514 }
2515 }
2516
2517
2518
2519 /* Code for lambda_ls8o1j_2 */
2520
CC_lambda_ls8o1j_2(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)2521 static Lisp_Object CC_lambda_ls8o1j_2(Lisp_Object env,
2522 Lisp_Object v0000, Lisp_Object v0016)
2523 {
2524 Lisp_Object nil = C_nil;
2525 Lisp_Object v0015, v0030;
2526 CSL_IGNORE(nil);
2527 #ifdef DEBUG
2528 if (check_env(env)) return aerror("env for lambda_ls8o1j_2");
2529 #endif
2530 CSL_IGNORE(env);
2531 /* copy arguments values to proper place */
2532 v0015 = v0016;
2533 v0030 = v0000;
2534 /* end of prologue */
2535 return Lleq(nil, v0030, v0015);
2536 }
2537
2538
2539
2540 /* Code for extmult */
2541
CC_extmult(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)2542 static Lisp_Object CC_extmult(Lisp_Object env,
2543 Lisp_Object v0000, Lisp_Object v0016)
2544 {
2545 Lisp_Object nil = C_nil;
2546 Lisp_Object v0055, v0056;
2547 Lisp_Object fn;
2548 CSL_IGNORE(nil);
2549 #ifdef DEBUG
2550 if (check_env(env)) return aerror("env for extmult");
2551 #endif
2552 if (stack >= stacklimit)
2553 {
2554 push2(v0016,v0000);
2555 env = reclaim(env, "stack", GC_STACK, 0);
2556 pop2(v0000,v0016);
2557 nil = C_nil;
2558 if (exception_pending()) return nil;
2559 }
2560 push(env);
2561 /* space for vars preserved across procedure calls */
2562 push5(nil, nil, nil, nil, nil);
2563 /* copy arguments values to proper place */
2564 stack[-2] = v0016;
2565 stack[-3] = v0000;
2566 /* end of prologue */
2567 v0055 = stack[-3];
2568 if (v0055 == nil) goto v0012;
2569 v0055 = stack[-2];
2570 v0055 = (v0055 == nil ? lisp_true : nil);
2571 goto v0013;
2572
2573 v0013:
2574 if (v0055 == nil) goto v0019;
2575 v0055 = qvalue(elt(env, 2)); /* nil */
2576 { popv(6); return onevalue(v0055); }
2577
2578 v0019:
2579 v0055 = stack[-3];
2580 v0055 = qcar(v0055);
2581 v0055 = qcar(v0055);
2582 v0056 = qcar(v0055);
2583 v0055 = stack[-2];
2584 v0055 = qcar(v0055);
2585 v0055 = qcar(v0055);
2586 fn = elt(env, 3); /* ordexn */
2587 v0055 = (*qfn2(fn))(qenv(fn), v0056, v0055);
2588 nil = C_nil;
2589 if (exception_pending()) goto v0057;
2590 env = stack[-5];
2591 v0056 = v0055;
2592 v0055 = v0056;
2593 if (v0055 == nil) goto v0058;
2594 v0055 = v0056;
2595 stack[-4] = qcdr(v0055);
2596 v0055 = v0056;
2597 v0055 = qcar(v0055);
2598 if (v0055 == nil) goto v0059;
2599 v0055 = stack[-3];
2600 v0055 = qcar(v0055);
2601 v0056 = qcdr(v0055);
2602 v0055 = stack[-2];
2603 v0055 = qcar(v0055);
2604 v0055 = qcdr(v0055);
2605 fn = elt(env, 4); /* c!:subs2multf */
2606 v0055 = (*qfn2(fn))(qenv(fn), v0056, v0055);
2607 nil = C_nil;
2608 if (exception_pending()) goto v0057;
2609 env = stack[-5];
2610 fn = elt(env, 5); /* negf */
2611 v0055 = (*qfn1(fn))(qenv(fn), v0055);
2612 nil = C_nil;
2613 if (exception_pending()) goto v0057;
2614 env = stack[-5];
2615 stack[-1] = v0055;
2616 goto v0060;
2617
2618 v0060:
2619 v0055 = stack[-3];
2620 v0055 = qcar(v0055);
2621 v0056 = ncons(v0055);
2622 nil = C_nil;
2623 if (exception_pending()) goto v0057;
2624 env = stack[-5];
2625 v0055 = stack[-2];
2626 v0055 = qcdr(v0055);
2627 stack[0] = CC_extmult(env, v0056, v0055);
2628 nil = C_nil;
2629 if (exception_pending()) goto v0057;
2630 env = stack[-5];
2631 v0055 = stack[-3];
2632 v0056 = qcdr(v0055);
2633 v0055 = stack[-2];
2634 v0055 = CC_extmult(env, v0056, v0055);
2635 nil = C_nil;
2636 if (exception_pending()) goto v0057;
2637 env = stack[-5];
2638 fn = elt(env, 6); /* extadd */
2639 v0055 = (*qfn2(fn))(qenv(fn), stack[0], v0055);
2640 nil = C_nil;
2641 if (exception_pending()) goto v0057;
2642 {
2643 Lisp_Object v0061 = stack[-4];
2644 Lisp_Object v0062 = stack[-1];
2645 popv(6);
2646 return acons(v0061, v0062, v0055);
2647 }
2648
2649 v0059:
2650 v0055 = stack[-3];
2651 v0055 = qcar(v0055);
2652 v0056 = qcdr(v0055);
2653 v0055 = stack[-2];
2654 v0055 = qcar(v0055);
2655 v0055 = qcdr(v0055);
2656 fn = elt(env, 4); /* c!:subs2multf */
2657 v0055 = (*qfn2(fn))(qenv(fn), v0056, v0055);
2658 nil = C_nil;
2659 if (exception_pending()) goto v0057;
2660 env = stack[-5];
2661 stack[-1] = v0055;
2662 goto v0060;
2663
2664 v0058:
2665 v0055 = stack[-3];
2666 v0056 = qcdr(v0055);
2667 v0055 = stack[-2];
2668 stack[0] = CC_extmult(env, v0056, v0055);
2669 nil = C_nil;
2670 if (exception_pending()) goto v0057;
2671 env = stack[-5];
2672 v0055 = stack[-3];
2673 v0055 = qcar(v0055);
2674 v0056 = ncons(v0055);
2675 nil = C_nil;
2676 if (exception_pending()) goto v0057;
2677 env = stack[-5];
2678 v0055 = stack[-2];
2679 v0055 = qcdr(v0055);
2680 v0055 = CC_extmult(env, v0056, v0055);
2681 nil = C_nil;
2682 if (exception_pending()) goto v0057;
2683 env = stack[-5];
2684 {
2685 Lisp_Object v0063 = stack[0];
2686 popv(6);
2687 fn = elt(env, 6); /* extadd */
2688 return (*qfn2(fn))(qenv(fn), v0063, v0055);
2689 }
2690
2691 v0012:
2692 v0055 = qvalue(elt(env, 1)); /* t */
2693 goto v0013;
2694 /* error exit handlers */
2695 v0057:
2696 popv(6);
2697 return nil;
2698 }
2699
2700
2701
2702 /* Code for simp!*sq */
2703
CC_simpHsq(Lisp_Object env,Lisp_Object v0000)2704 static Lisp_Object CC_simpHsq(Lisp_Object env,
2705 Lisp_Object v0000)
2706 {
2707 Lisp_Object nil = C_nil;
2708 Lisp_Object v0018, v0064;
2709 Lisp_Object fn;
2710 CSL_IGNORE(nil);
2711 #ifdef DEBUG
2712 if (check_env(env)) return aerror("env for simp*sq");
2713 #endif
2714 CSL_IGNORE(env);
2715 /* copy arguments values to proper place */
2716 v0064 = v0000;
2717 /* end of prologue */
2718 v0018 = v0064;
2719 v0018 = qcdr(v0018);
2720 v0018 = qcar(v0018);
2721 if (v0018 == nil) goto v0032;
2722 v0018 = qvalue(elt(env, 1)); /* !*resimp */
2723 if (!(v0018 == nil)) goto v0032;
2724 v0018 = v0064;
2725 v0018 = qcar(v0018);
2726 return onevalue(v0018);
2727
2728 v0032:
2729 v0018 = v0064;
2730 v0018 = qcar(v0018);
2731 {
2732 fn = elt(env, 2); /* resimp1 */
2733 return (*qfn1(fn))(qenv(fn), v0018);
2734 }
2735 }
2736
2737
2738
2739 /* Code for mkzl */
2740
CC_mkzl(Lisp_Object env,Lisp_Object v0000)2741 static Lisp_Object CC_mkzl(Lisp_Object env,
2742 Lisp_Object v0000)
2743 {
2744 Lisp_Object nil = C_nil;
2745 Lisp_Object v0002, v0024;
2746 Lisp_Object fn;
2747 CSL_IGNORE(nil);
2748 #ifdef DEBUG
2749 if (check_env(env)) return aerror("env for mkzl");
2750 #endif
2751 if (stack >= stacklimit)
2752 {
2753 push(v0000);
2754 env = reclaim(env, "stack", GC_STACK, 0);
2755 pop(v0000);
2756 nil = C_nil;
2757 if (exception_pending()) return nil;
2758 }
2759 push(env);
2760 /* space for vars preserved across procedure calls */
2761 push2(nil, nil);
2762 /* copy arguments values to proper place */
2763 stack[0] = v0000;
2764 /* end of prologue */
2765 stack[-1] = nil;
2766 goto v0014;
2767
2768 v0014:
2769 v0024 = stack[0];
2770 v0002 = (Lisp_Object)17; /* 1 */
2771 if (v0024 == v0002) goto v0013;
2772 v0024 = (Lisp_Object)1; /* 0 */
2773 v0002 = stack[-1];
2774 v0002 = cons(v0024, v0002);
2775 nil = C_nil;
2776 if (exception_pending()) goto v0026;
2777 env = stack[-2];
2778 stack[-1] = v0002;
2779 v0002 = stack[0];
2780 v0002 = sub1(v0002);
2781 nil = C_nil;
2782 if (exception_pending()) goto v0026;
2783 env = stack[-2];
2784 stack[0] = v0002;
2785 goto v0014;
2786
2787 v0013:
2788 v0002 = stack[-1];
2789 {
2790 popv(3);
2791 fn = elt(env, 1); /* nreverse */
2792 return (*qfn1(fn))(qenv(fn), v0002);
2793 }
2794 /* error exit handlers */
2795 v0026:
2796 popv(3);
2797 return nil;
2798 }
2799
2800
2801
2802 /* Code for ibalp_clausep */
2803
CC_ibalp_clausep(Lisp_Object env,Lisp_Object v0000)2804 static Lisp_Object CC_ibalp_clausep(Lisp_Object env,
2805 Lisp_Object v0000)
2806 {
2807 Lisp_Object nil = C_nil;
2808 Lisp_Object v0022, v0068;
2809 Lisp_Object fn;
2810 CSL_IGNORE(nil);
2811 #ifdef DEBUG
2812 if (check_env(env)) return aerror("env for ibalp_clausep");
2813 #endif
2814 if (stack >= stacklimit)
2815 {
2816 push(v0000);
2817 env = reclaim(env, "stack", GC_STACK, 0);
2818 pop(v0000);
2819 nil = C_nil;
2820 if (exception_pending()) return nil;
2821 }
2822 push(env);
2823 /* space for vars preserved across procedure calls */
2824 push(nil);
2825 /* copy arguments values to proper place */
2826 stack[0] = v0000;
2827 /* end of prologue */
2828 v0022 = stack[0];
2829 fn = elt(env, 3); /* ibalp_litp */
2830 v0022 = (*qfn1(fn))(qenv(fn), v0022);
2831 nil = C_nil;
2832 if (exception_pending()) goto v0027;
2833 env = stack[-1];
2834 if (!(v0022 == nil)) { popv(2); return onevalue(v0022); }
2835 v0022 = stack[0];
2836 if (!consp(v0022)) goto v0017;
2837 v0022 = stack[0];
2838 v0022 = qcar(v0022);
2839 v0068 = v0022;
2840 goto v0031;
2841
2842 v0031:
2843 v0022 = elt(env, 1); /* or */
2844 if (v0068 == v0022) goto v0012;
2845 v0022 = qvalue(elt(env, 2)); /* nil */
2846 { popv(2); return onevalue(v0022); }
2847
2848 v0012:
2849 v0022 = stack[0];
2850 v0022 = qcdr(v0022);
2851 {
2852 popv(2);
2853 fn = elt(env, 4); /* ibalp_litlp */
2854 return (*qfn1(fn))(qenv(fn), v0022);
2855 }
2856
2857 v0017:
2858 v0022 = stack[0];
2859 v0068 = v0022;
2860 goto v0031;
2861 /* error exit handlers */
2862 v0027:
2863 popv(2);
2864 return nil;
2865 }
2866
2867
2868
2869 /* Code for aex_mvaroccurtest */
2870
CC_aex_mvaroccurtest(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)2871 static Lisp_Object CC_aex_mvaroccurtest(Lisp_Object env,
2872 Lisp_Object v0000, Lisp_Object v0016)
2873 {
2874 Lisp_Object nil = C_nil;
2875 Lisp_Object v0030, v0031;
2876 Lisp_Object fn;
2877 CSL_IGNORE(nil);
2878 #ifdef DEBUG
2879 if (check_env(env)) return aerror("env for aex_mvaroccurtest");
2880 #endif
2881 if (stack >= stacklimit)
2882 {
2883 push2(v0016,v0000);
2884 env = reclaim(env, "stack", GC_STACK, 0);
2885 pop2(v0000,v0016);
2886 nil = C_nil;
2887 if (exception_pending()) return nil;
2888 }
2889 push(env);
2890 /* space for vars preserved across procedure calls */
2891 push(nil);
2892 /* copy arguments values to proper place */
2893 stack[0] = v0016;
2894 v0030 = v0000;
2895 /* end of prologue */
2896 fn = elt(env, 1); /* aex_ex */
2897 v0031 = (*qfn1(fn))(qenv(fn), v0030);
2898 nil = C_nil;
2899 if (exception_pending()) goto v0033;
2900 env = stack[-1];
2901 v0030 = stack[0];
2902 {
2903 popv(2);
2904 fn = elt(env, 2); /* ratpoly_mvartest */
2905 return (*qfn2(fn))(qenv(fn), v0031, v0030);
2906 }
2907 /* error exit handlers */
2908 v0033:
2909 popv(2);
2910 return nil;
2911 }
2912
2913
2914
2915 /* Code for ofsf_sacatlp */
2916
CC_ofsf_sacatlp(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)2917 static Lisp_Object CC_ofsf_sacatlp(Lisp_Object env,
2918 Lisp_Object v0000, Lisp_Object v0016)
2919 {
2920 Lisp_Object nil = C_nil;
2921 Lisp_Object v0028, v0003, v0004, v0069;
2922 Lisp_Object fn;
2923 CSL_IGNORE(nil);
2924 #ifdef DEBUG
2925 if (check_env(env)) return aerror("env for ofsf_sacatlp");
2926 #endif
2927 if (stack >= stacklimit)
2928 {
2929 push2(v0016,v0000);
2930 env = reclaim(env, "stack", GC_STACK, 0);
2931 pop2(v0000,v0016);
2932 nil = C_nil;
2933 if (exception_pending()) return nil;
2934 }
2935 CSL_IGNORE(env);
2936 /* copy arguments values to proper place */
2937 v0028 = v0016;
2938 v0069 = v0000;
2939 /* end of prologue */
2940 v0028 = qcar(v0028);
2941 v0004 = v0028;
2942 v0028 = v0069;
2943 v0028 = qcdr(v0028);
2944 v0003 = qcar(v0028);
2945 v0028 = v0004;
2946 v0028 = qcdr(v0028);
2947 v0028 = qcar(v0028);
2948 if (equal(v0003, v0028)) goto v0022;
2949 v0028 = v0069;
2950 v0028 = qcdr(v0028);
2951 v0028 = qcar(v0028);
2952 v0003 = v0004;
2953 v0003 = qcdr(v0003);
2954 v0003 = qcar(v0003);
2955 fn = elt(env, 2); /* ordp */
2956 v0028 = (*qfn2(fn))(qenv(fn), v0028, v0003);
2957 errexit();
2958 goto v0054;
2959
2960 v0054:
2961 v0028 = (v0028 == nil ? lisp_true : nil);
2962 return onevalue(v0028);
2963
2964 v0022:
2965 v0028 = qvalue(elt(env, 1)); /* nil */
2966 goto v0054;
2967 }
2968
2969
2970
2971 /* Code for cr!:prep */
2972
CC_crTprep(Lisp_Object env,Lisp_Object v0000)2973 static Lisp_Object CC_crTprep(Lisp_Object env,
2974 Lisp_Object v0000)
2975 {
2976 Lisp_Object nil = C_nil;
2977 Lisp_Object v0002, v0024;
2978 Lisp_Object fn;
2979 CSL_IGNORE(nil);
2980 #ifdef DEBUG
2981 if (check_env(env)) return aerror("env for cr:prep");
2982 #endif
2983 if (stack >= stacklimit)
2984 {
2985 push(v0000);
2986 env = reclaim(env, "stack", GC_STACK, 0);
2987 pop(v0000);
2988 nil = C_nil;
2989 if (exception_pending()) return nil;
2990 }
2991 push(env);
2992 /* space for vars preserved across procedure calls */
2993 push2(nil, nil);
2994 /* copy arguments values to proper place */
2995 stack[0] = v0000;
2996 /* end of prologue */
2997 v0024 = elt(env, 1); /* !:rd!: */
2998 v0002 = stack[0];
2999 v0002 = qcdr(v0002);
3000 v0002 = qcar(v0002);
3001 v0002 = cons(v0024, v0002);
3002 nil = C_nil;
3003 if (exception_pending()) goto v0026;
3004 env = stack[-2];
3005 fn = elt(env, 2); /* rd!:prep */
3006 stack[-1] = (*qfn1(fn))(qenv(fn), v0002);
3007 nil = C_nil;
3008 if (exception_pending()) goto v0026;
3009 env = stack[-2];
3010 v0024 = elt(env, 1); /* !:rd!: */
3011 v0002 = stack[0];
3012 v0002 = qcdr(v0002);
3013 v0002 = qcdr(v0002);
3014 v0002 = cons(v0024, v0002);
3015 nil = C_nil;
3016 if (exception_pending()) goto v0026;
3017 env = stack[-2];
3018 fn = elt(env, 2); /* rd!:prep */
3019 v0002 = (*qfn1(fn))(qenv(fn), v0002);
3020 nil = C_nil;
3021 if (exception_pending()) goto v0026;
3022 env = stack[-2];
3023 v0002 = cons(stack[-1], v0002);
3024 nil = C_nil;
3025 if (exception_pending()) goto v0026;
3026 env = stack[-2];
3027 {
3028 popv(3);
3029 fn = elt(env, 3); /* crprep1 */
3030 return (*qfn1(fn))(qenv(fn), v0002);
3031 }
3032 /* error exit handlers */
3033 v0026:
3034 popv(3);
3035 return nil;
3036 }
3037
3038
3039
3040 /* Code for initwght */
3041
CC_initwght(Lisp_Object env,Lisp_Object v0000)3042 static Lisp_Object CC_initwght(Lisp_Object env,
3043 Lisp_Object v0000)
3044 {
3045 Lisp_Object nil = C_nil;
3046 Lisp_Object v0096, v0097, v0098;
3047 Lisp_Object fn;
3048 CSL_IGNORE(nil);
3049 #ifdef DEBUG
3050 if (check_env(env)) return aerror("env for initwght");
3051 #endif
3052 if (stack >= stacklimit)
3053 {
3054 push(v0000);
3055 env = reclaim(env, "stack", GC_STACK, 0);
3056 pop(v0000);
3057 nil = C_nil;
3058 if (exception_pending()) return nil;
3059 }
3060 push(env);
3061 /* space for vars preserved across procedure calls */
3062 push5(nil, nil, nil, nil, nil);
3063 push(nil);
3064 /* copy arguments values to proper place */
3065 stack[-3] = v0000;
3066 /* end of prologue */
3067 v0096 = (Lisp_Object)1; /* 0 */
3068 stack[-5] = v0096;
3069 stack[0] = v0096;
3070 stack[-1] = qvalue(elt(env, 1)); /* codmat */
3071 v0097 = qvalue(elt(env, 2)); /* maxvar */
3072 v0096 = stack[-3];
3073 v0096 = plus2(v0097, v0096);
3074 nil = C_nil;
3075 if (exception_pending()) goto v0099;
3076 env = stack[-6];
3077 v0097 = *(Lisp_Object *)((char *)stack[-1] + (CELL-TAG_VECTOR) + ((int32_t)v0096/(16/CELL)));
3078 v0096 = (Lisp_Object)65; /* 4 */
3079 v0096 = *(Lisp_Object *)((char *)v0097 + (CELL-TAG_VECTOR) + ((int32_t)v0096/(16/CELL)));
3080 stack[-4] = v0096;
3081 goto v0014;
3082
3083 v0014:
3084 v0096 = stack[-4];
3085 if (v0096 == nil) goto v0034;
3086 v0096 = stack[-4];
3087 v0096 = qcar(v0096);
3088 stack[-2] = v0096;
3089 stack[-1] = qvalue(elt(env, 1)); /* codmat */
3090 v0097 = qvalue(elt(env, 2)); /* maxvar */
3091 v0096 = stack[-2];
3092 v0096 = qcar(v0096);
3093 v0096 = plus2(v0097, v0096);
3094 nil = C_nil;
3095 if (exception_pending()) goto v0099;
3096 env = stack[-6];
3097 v0097 = *(Lisp_Object *)((char *)stack[-1] + (CELL-TAG_VECTOR) + ((int32_t)v0096/(16/CELL)));
3098 v0096 = (Lisp_Object)1; /* 0 */
3099 v0096 = *(Lisp_Object *)((char *)v0097 + (CELL-TAG_VECTOR) + ((int32_t)v0096/(16/CELL)));
3100 if (v0096 == nil) goto v0100;
3101 v0096 = stack[-2];
3102 v0096 = qcdr(v0096);
3103 v0096 = qcar(v0096);
3104 fn = elt(env, 5); /* dm!-abs */
3105 v0096 = (*qfn1(fn))(qenv(fn), v0096);
3106 nil = C_nil;
3107 if (exception_pending()) goto v0099;
3108 env = stack[-6];
3109 v0098 = v0096;
3110 v0096 = v0098;
3111 if (!consp(v0096)) goto v0101;
3112 v0096 = v0098;
3113 v0097 = qcar(v0096);
3114 v0096 = elt(env, 4); /* onep */
3115 v0096 = get(v0097, v0096);
3116 env = stack[-6];
3117 v0097 = v0098;
3118 v0096 = Lapply1(nil, v0096, v0097);
3119 nil = C_nil;
3120 if (exception_pending()) goto v0099;
3121 env = stack[-6];
3122 goto v0102;
3123
3124 v0102:
3125 if (!(v0096 == nil)) goto v0103;
3126 v0096 = stack[-5];
3127 v0096 = add1(v0096);
3128 nil = C_nil;
3129 if (exception_pending()) goto v0099;
3130 env = stack[-6];
3131 stack[-5] = v0096;
3132 goto v0103;
3133
3134 v0103:
3135 v0096 = stack[0];
3136 v0096 = add1(v0096);
3137 nil = C_nil;
3138 if (exception_pending()) goto v0099;
3139 env = stack[-6];
3140 stack[0] = v0096;
3141 goto v0100;
3142
3143 v0100:
3144 v0096 = stack[-4];
3145 v0096 = qcdr(v0096);
3146 stack[-4] = v0096;
3147 goto v0014;
3148
3149 v0101:
3150 v0096 = v0098;
3151 v0096 = Lonep(nil, v0096);
3152 env = stack[-6];
3153 goto v0102;
3154
3155 v0034:
3156 stack[-1] = qvalue(elt(env, 1)); /* codmat */
3157 v0097 = qvalue(elt(env, 2)); /* maxvar */
3158 v0096 = stack[-3];
3159 v0096 = plus2(v0097, v0096);
3160 nil = C_nil;
3161 if (exception_pending()) goto v0099;
3162 env = stack[-6];
3163 stack[-4] = *(Lisp_Object *)((char *)stack[-1] + (CELL-TAG_VECTOR) + ((int32_t)v0096/(16/CELL)));
3164 stack[-3] = (Lisp_Object)17; /* 1 */
3165 stack[-2] = stack[0];
3166 stack[-1] = stack[-5];
3167 v0097 = (Lisp_Object)49; /* 3 */
3168 v0096 = stack[-5];
3169 v0096 = times2(v0097, v0096);
3170 nil = C_nil;
3171 if (exception_pending()) goto v0099;
3172 env = stack[-6];
3173 v0096 = plus2(stack[0], v0096);
3174 nil = C_nil;
3175 if (exception_pending()) goto v0099;
3176 env = stack[-6];
3177 v0096 = acons(stack[-2], stack[-1], v0096);
3178 nil = C_nil;
3179 if (exception_pending()) goto v0099;
3180 *(Lisp_Object *)((char *)stack[-4] + (CELL-TAG_VECTOR) + ((int32_t)stack[-3]/(16/CELL))) = v0096;
3181 v0096 = nil;
3182 { popv(7); return onevalue(v0096); }
3183 /* error exit handlers */
3184 v0099:
3185 popv(7);
3186 return nil;
3187 }
3188
3189
3190
3191 /* Code for bcplus!? */
3192
CC_bcplusW(Lisp_Object env,Lisp_Object v0000)3193 static Lisp_Object CC_bcplusW(Lisp_Object env,
3194 Lisp_Object v0000)
3195 {
3196 Lisp_Object nil = C_nil;
3197 Lisp_Object v0019, v0020;
3198 CSL_IGNORE(nil);
3199 #ifdef DEBUG
3200 if (check_env(env)) return aerror("env for bcplus?");
3201 #endif
3202 CSL_IGNORE(env);
3203 /* copy arguments values to proper place */
3204 v0019 = v0000;
3205 /* end of prologue */
3206 v0019 = qcar(v0019);
3207 v0020 = v0019;
3208 v0019 = v0020;
3209 if (is_number(v0019)) goto v0005;
3210 v0019 = qvalue(elt(env, 1)); /* nil */
3211 return onevalue(v0019);
3212
3213 v0005:
3214 v0019 = (Lisp_Object)1; /* 0 */
3215 return Lgreaterp(nil, v0020, v0019);
3216 }
3217
3218
3219
3220 /* Code for vevmaptozero1 */
3221
CC_vevmaptozero1(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)3222 static Lisp_Object CC_vevmaptozero1(Lisp_Object env,
3223 Lisp_Object v0000, Lisp_Object v0016)
3224 {
3225 Lisp_Object nil = C_nil;
3226 Lisp_Object v0023, v0104;
3227 CSL_IGNORE(nil);
3228 #ifdef DEBUG
3229 if (check_env(env)) return aerror("env for vevmaptozero1");
3230 #endif
3231 if (stack >= stacklimit)
3232 {
3233 push2(v0016,v0000);
3234 env = reclaim(env, "stack", GC_STACK, 0);
3235 pop2(v0000,v0016);
3236 nil = C_nil;
3237 if (exception_pending()) return nil;
3238 }
3239 push(env);
3240 /* space for vars preserved across procedure calls */
3241 push(nil);
3242 /* copy arguments values to proper place */
3243 v0023 = v0016;
3244 stack[0] = v0000;
3245 /* end of prologue */
3246
3247 v0029:
3248 v0104 = stack[0];
3249 if (v0104 == nil) { popv(2); return onevalue(v0023); }
3250 v0104 = stack[0];
3251 v0104 = qcdr(v0104);
3252 stack[0] = v0104;
3253 v0104 = (Lisp_Object)1; /* 0 */
3254 v0023 = cons(v0104, v0023);
3255 nil = C_nil;
3256 if (exception_pending()) goto v0065;
3257 env = stack[-1];
3258 goto v0029;
3259 /* error exit handlers */
3260 v0065:
3261 popv(2);
3262 return nil;
3263 }
3264
3265
3266
3267 /* Code for physopaeval */
3268
CC_physopaeval(Lisp_Object env,Lisp_Object v0000)3269 static Lisp_Object CC_physopaeval(Lisp_Object env,
3270 Lisp_Object v0000)
3271 {
3272 Lisp_Object nil = C_nil;
3273 Lisp_Object v0071, v0112, v0113;
3274 Lisp_Object fn;
3275 CSL_IGNORE(nil);
3276 #ifdef DEBUG
3277 if (check_env(env)) return aerror("env for physopaeval");
3278 #endif
3279 if (stack >= stacklimit)
3280 {
3281 push(v0000);
3282 env = reclaim(env, "stack", GC_STACK, 0);
3283 pop(v0000);
3284 nil = C_nil;
3285 if (exception_pending()) return nil;
3286 }
3287 push(env);
3288 /* space for vars preserved across procedure calls */
3289 push(nil);
3290 /* copy arguments values to proper place */
3291 stack[0] = v0000;
3292 /* end of prologue */
3293 v0071 = stack[0];
3294 fn = elt(env, 7); /* physopp */
3295 v0071 = (*qfn1(fn))(qenv(fn), v0071);
3296 nil = C_nil;
3297 if (exception_pending()) goto v0055;
3298 env = stack[-1];
3299 if (v0071 == nil) goto v0013;
3300 v0112 = stack[0];
3301 v0071 = elt(env, 1); /* rvalue */
3302 v0071 = get(v0112, v0071);
3303 env = stack[-1];
3304 v0113 = v0071;
3305 if (v0071 == nil) goto v0032;
3306 v0071 = v0113;
3307 v0112 = qcar(v0071);
3308 v0071 = elt(env, 2); /* !*sq */
3309 if (!(v0112 == v0071)) { popv(2); return onevalue(v0113); }
3310 v0071 = qvalue(elt(env, 3)); /* !*nosq */
3311 if (v0071 == nil) goto v0028;
3312 v0071 = v0113;
3313 v0071 = qcdr(v0071);
3314 v0071 = qcar(v0071);
3315 {
3316 popv(2);
3317 fn = elt(env, 8); /* prepsqxx */
3318 return (*qfn1(fn))(qenv(fn), v0071);
3319 }
3320
3321 v0028:
3322 v0071 = v0113;
3323 v0071 = qcdr(v0071);
3324 v0071 = qcar(v0071);
3325 {
3326 popv(2);
3327 fn = elt(env, 9); /* mk!*sq */
3328 return (*qfn1(fn))(qenv(fn), v0071);
3329 }
3330
3331 v0032:
3332 v0071 = stack[0];
3333 if (!consp(v0071)) { Lisp_Object res = stack[0]; popv(2); return onevalue(res); }
3334 v0071 = stack[0];
3335 v0112 = qcar(v0071);
3336 v0071 = elt(env, 4); /* psimpfn */
3337 v0071 = get(v0112, v0071);
3338 env = stack[-1];
3339 v0113 = v0071;
3340 if (v0071 == nil) goto v0101;
3341 v0112 = v0113;
3342 v0071 = stack[0];
3343 popv(2);
3344 return Lapply1(nil, v0112, v0071);
3345
3346 v0101:
3347 v0071 = stack[0];
3348 v0112 = qcar(v0071);
3349 v0071 = elt(env, 5); /* opmtch */
3350 v0071 = get(v0112, v0071);
3351 env = stack[-1];
3352 if (v0071 == nil) { Lisp_Object res = stack[0]; popv(2); return onevalue(res); }
3353 v0071 = stack[0];
3354 fn = elt(env, 10); /* opmtch!* */
3355 v0071 = (*qfn1(fn))(qenv(fn), v0071);
3356 nil = C_nil;
3357 if (exception_pending()) goto v0055;
3358 v0113 = v0071;
3359 if (v0071 == nil) { Lisp_Object res = stack[0]; popv(2); return onevalue(res); }
3360 else { popv(2); return onevalue(v0113); }
3361
3362 v0013:
3363 v0071 = stack[0];
3364 if (!consp(v0071)) goto v0114;
3365 v0071 = stack[0];
3366 v0112 = qcar(v0071);
3367 v0071 = elt(env, 2); /* !*sq */
3368 v0071 = (v0112 == v0071 ? lisp_true : nil);
3369 goto v0048;
3370
3371 v0048:
3372 if (v0071 == nil) { Lisp_Object res = stack[0]; popv(2); return onevalue(res); }
3373 v0071 = qvalue(elt(env, 3)); /* !*nosq */
3374 if (v0071 == nil) goto v0034;
3375 v0071 = stack[0];
3376 v0071 = qcdr(v0071);
3377 v0071 = qcar(v0071);
3378 {
3379 popv(2);
3380 fn = elt(env, 8); /* prepsqxx */
3381 return (*qfn1(fn))(qenv(fn), v0071);
3382 }
3383
3384 v0034:
3385 v0071 = stack[0];
3386 v0071 = qcdr(v0071);
3387 v0071 = qcar(v0071);
3388 {
3389 popv(2);
3390 fn = elt(env, 9); /* mk!*sq */
3391 return (*qfn1(fn))(qenv(fn), v0071);
3392 }
3393
3394 v0114:
3395 v0071 = qvalue(elt(env, 6)); /* nil */
3396 goto v0048;
3397 /* error exit handlers */
3398 v0055:
3399 popv(2);
3400 return nil;
3401 }
3402
3403
3404
3405 /* Code for zero!-roads */
3406
CC_zeroKroads(Lisp_Object env,Lisp_Object v0000)3407 static Lisp_Object CC_zeroKroads(Lisp_Object env,
3408 Lisp_Object v0000)
3409 {
3410 Lisp_Object nil = C_nil;
3411 Lisp_Object v0068, v0026;
3412 Lisp_Object fn;
3413 CSL_IGNORE(nil);
3414 #ifdef DEBUG
3415 if (check_env(env)) return aerror("env for zero-roads");
3416 #endif
3417 if (stack >= stacklimit)
3418 {
3419 push(v0000);
3420 env = reclaim(env, "stack", GC_STACK, 0);
3421 pop(v0000);
3422 nil = C_nil;
3423 if (exception_pending()) return nil;
3424 }
3425 push(env);
3426 /* space for vars preserved across procedure calls */
3427 push2(nil, nil);
3428 /* copy arguments values to proper place */
3429 stack[0] = v0000;
3430 /* end of prologue */
3431
3432 v0115:
3433 v0068 = stack[0];
3434 if (v0068 == nil) goto v0021;
3435 v0068 = stack[0];
3436 v0068 = qcar(v0068);
3437 fn = elt(env, 2); /* z!-roads */
3438 v0068 = (*qfn1(fn))(qenv(fn), v0068);
3439 nil = C_nil;
3440 if (exception_pending()) goto v0003;
3441 env = stack[-2];
3442 v0026 = v0068;
3443 v0068 = v0026;
3444 if (v0068 == nil) goto v0053;
3445 stack[-1] = v0026;
3446 v0068 = stack[0];
3447 v0068 = qcdr(v0068);
3448 v0068 = CC_zeroKroads(env, v0068);
3449 nil = C_nil;
3450 if (exception_pending()) goto v0003;
3451 {
3452 Lisp_Object v0004 = stack[-1];
3453 popv(3);
3454 return cons(v0004, v0068);
3455 }
3456
3457 v0053:
3458 v0068 = stack[0];
3459 v0068 = qcdr(v0068);
3460 stack[0] = v0068;
3461 goto v0115;
3462
3463 v0021:
3464 v0068 = qvalue(elt(env, 1)); /* nil */
3465 { popv(3); return onevalue(v0068); }
3466 /* error exit handlers */
3467 v0003:
3468 popv(3);
3469 return nil;
3470 }
3471
3472
3473
3474 /* Code for assert_install */
3475
CC_assert_install(Lisp_Object env,Lisp_Object v0000)3476 static Lisp_Object CC_assert_install(Lisp_Object env,
3477 Lisp_Object v0000)
3478 {
3479 Lisp_Object nil = C_nil;
3480 Lisp_Object v0104, v0067;
3481 Lisp_Object fn;
3482 CSL_IGNORE(nil);
3483 #ifdef DEBUG
3484 if (check_env(env)) return aerror("env for assert_install");
3485 #endif
3486 if (stack >= stacklimit)
3487 {
3488 push(v0000);
3489 env = reclaim(env, "stack", GC_STACK, 0);
3490 pop(v0000);
3491 nil = C_nil;
3492 if (exception_pending()) return nil;
3493 }
3494 push(env);
3495 /* space for vars preserved across procedure calls */
3496 push(nil);
3497 /* copy arguments values to proper place */
3498 v0067 = v0000;
3499 /* end of prologue */
3500 v0104 = qvalue(elt(env, 1)); /* !*assert */
3501 if (v0104 == nil) goto v0029;
3502 v0104 = v0067;
3503 stack[0] = v0104;
3504 goto v0014;
3505
3506 v0014:
3507 v0104 = stack[0];
3508 if (v0104 == nil) goto v0032;
3509 v0104 = stack[0];
3510 v0104 = qcar(v0104);
3511 fn = elt(env, 3); /* assert_install1 */
3512 v0104 = (*qfn1(fn))(qenv(fn), v0104);
3513 nil = C_nil;
3514 if (exception_pending()) goto v0001;
3515 env = stack[-1];
3516 v0104 = stack[0];
3517 v0104 = qcdr(v0104);
3518 stack[0] = v0104;
3519 goto v0014;
3520
3521 v0032:
3522 v0104 = qvalue(elt(env, 2)); /* nil */
3523 { popv(2); return onevalue(v0104); }
3524
3525 v0029:
3526 v0104 = nil;
3527 { popv(2); return onevalue(v0104); }
3528 /* error exit handlers */
3529 v0001:
3530 popv(2);
3531 return nil;
3532 }
3533
3534
3535
3536 /* Code for mo!=revlexcomp */
3537
CC_moMrevlexcomp(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)3538 static Lisp_Object CC_moMrevlexcomp(Lisp_Object env,
3539 Lisp_Object v0000, Lisp_Object v0016)
3540 {
3541 Lisp_Object nil = C_nil;
3542 Lisp_Object v0116;
3543 Lisp_Object fn;
3544 CSL_IGNORE(nil);
3545 #ifdef DEBUG
3546 if (check_env(env)) return aerror("env for mo=revlexcomp");
3547 #endif
3548 if (stack >= stacklimit)
3549 {
3550 push2(v0016,v0000);
3551 env = reclaim(env, "stack", GC_STACK, 0);
3552 pop2(v0000,v0016);
3553 nil = C_nil;
3554 if (exception_pending()) return nil;
3555 }
3556 push(env);
3557 /* space for vars preserved across procedure calls */
3558 push3(nil, nil, nil);
3559 /* copy arguments values to proper place */
3560 stack[0] = v0016;
3561 stack[-1] = v0000;
3562 /* end of prologue */
3563 v0116 = stack[-1];
3564 stack[-2] = Llength(nil, v0116);
3565 nil = C_nil;
3566 if (exception_pending()) goto v0011;
3567 env = stack[-3];
3568 v0116 = stack[0];
3569 v0116 = Llength(nil, v0116);
3570 nil = C_nil;
3571 if (exception_pending()) goto v0011;
3572 env = stack[-3];
3573 if (((int32_t)(stack[-2])) > ((int32_t)(v0116))) goto v0029;
3574 v0116 = stack[0];
3575 stack[-2] = Llength(nil, v0116);
3576 nil = C_nil;
3577 if (exception_pending()) goto v0011;
3578 env = stack[-3];
3579 v0116 = stack[-1];
3580 v0116 = Llength(nil, v0116);
3581 nil = C_nil;
3582 if (exception_pending()) goto v0011;
3583 env = stack[-3];
3584 if (((int32_t)(stack[-2])) > ((int32_t)(v0116))) goto v0006;
3585 v0116 = stack[-1];
3586 stack[-1] = Lreverse(nil, v0116);
3587 nil = C_nil;
3588 if (exception_pending()) goto v0011;
3589 env = stack[-3];
3590 v0116 = stack[0];
3591 v0116 = Lreverse(nil, v0116);
3592 nil = C_nil;
3593 if (exception_pending()) goto v0011;
3594 env = stack[-3];
3595 fn = elt(env, 1); /* mo!=degcomp */
3596 v0116 = (*qfn2(fn))(qenv(fn), stack[-1], v0116);
3597 nil = C_nil;
3598 if (exception_pending()) goto v0011;
3599 popv(4);
3600 return negate(v0116);
3601
3602 v0006:
3603 v0116 = (Lisp_Object)17; /* 1 */
3604 { popv(4); return onevalue(v0116); }
3605
3606 v0029:
3607 v0116 = (Lisp_Object)-15; /* -1 */
3608 { popv(4); return onevalue(v0116); }
3609 /* error exit handlers */
3610 v0011:
3611 popv(4);
3612 return nil;
3613 }
3614
3615
3616
3617 /* Code for dv_cambhead */
3618
CC_dv_cambhead(Lisp_Object env,Lisp_Object v0000)3619 static Lisp_Object CC_dv_cambhead(Lisp_Object env,
3620 Lisp_Object v0000)
3621 {
3622 Lisp_Object nil = C_nil;
3623 Lisp_Object v0100, v0117;
3624 Lisp_Object fn;
3625 CSL_IGNORE(nil);
3626 #ifdef DEBUG
3627 if (check_env(env)) return aerror("env for dv_cambhead");
3628 #endif
3629 if (stack >= stacklimit)
3630 {
3631 push(v0000);
3632 env = reclaim(env, "stack", GC_STACK, 0);
3633 pop(v0000);
3634 nil = C_nil;
3635 if (exception_pending()) return nil;
3636 }
3637 push(env);
3638 /* space for vars preserved across procedure calls */
3639 push2(nil, nil);
3640 /* copy arguments values to proper place */
3641 stack[0] = v0000;
3642 /* end of prologue */
3643
3644 v0115:
3645 v0100 = stack[0];
3646 fn = elt(env, 4); /* listp */
3647 v0100 = (*qfn1(fn))(qenv(fn), v0100);
3648 nil = C_nil;
3649 if (exception_pending()) goto v0118;
3650 env = stack[-2];
3651 if (v0100 == nil) goto v0029;
3652 v0100 = stack[0];
3653 stack[-1] = qcar(v0100);
3654 v0117 = elt(env, 1); /* expt */
3655 v0100 = elt(env, 2); /* minus */
3656 v0100 = list2(v0117, v0100);
3657 nil = C_nil;
3658 if (exception_pending()) goto v0118;
3659 env = stack[-2];
3660 v0100 = Lmember(nil, stack[-1], v0100);
3661 if (v0100 == nil) goto v0015;
3662 v0100 = stack[0];
3663 v0100 = qcdr(v0100);
3664 v0100 = qcar(v0100);
3665 stack[0] = v0100;
3666 goto v0115;
3667
3668 v0015:
3669 v0100 = stack[0];
3670 fn = elt(env, 4); /* listp */
3671 v0100 = (*qfn1(fn))(qenv(fn), v0100);
3672 nil = C_nil;
3673 if (exception_pending()) goto v0118;
3674 if (v0100 == nil) goto v0029;
3675 v0100 = stack[0];
3676 v0100 = qcar(v0100);
3677 { popv(3); return onevalue(v0100); }
3678
3679 v0029:
3680 v0100 = nil;
3681 { popv(3); return onevalue(v0100); }
3682 /* error exit handlers */
3683 v0118:
3684 popv(3);
3685 return nil;
3686 }
3687
3688
3689
3690 /* Code for expt!-mod!-p */
3691
CC_exptKmodKp(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)3692 static Lisp_Object CC_exptKmodKp(Lisp_Object env,
3693 Lisp_Object v0000, Lisp_Object v0016)
3694 {
3695 Lisp_Object nil = C_nil;
3696 Lisp_Object v0087, v0049, v0102;
3697 Lisp_Object fn;
3698 CSL_IGNORE(nil);
3699 #ifdef DEBUG
3700 if (check_env(env)) return aerror("env for expt-mod-p");
3701 #endif
3702 if (stack >= stacklimit)
3703 {
3704 push2(v0016,v0000);
3705 env = reclaim(env, "stack", GC_STACK, 0);
3706 pop2(v0000,v0016);
3707 nil = C_nil;
3708 if (exception_pending()) return nil;
3709 }
3710 push(env);
3711 /* space for vars preserved across procedure calls */
3712 push2(nil, nil);
3713 /* copy arguments values to proper place */
3714 v0102 = v0016;
3715 stack[0] = v0000;
3716 /* end of prologue */
3717 v0049 = v0102;
3718 v0087 = (Lisp_Object)1; /* 0 */
3719 if (v0049 == v0087) goto v0029;
3720 v0049 = v0102;
3721 v0087 = (Lisp_Object)17; /* 1 */
3722 if (v0049 == v0087) { Lisp_Object res = stack[0]; popv(3); return onevalue(res); }
3723 v0049 = v0102;
3724 v0087 = (Lisp_Object)33; /* 2 */
3725 v0087 = Ldivide(nil, v0049, v0087);
3726 nil = C_nil;
3727 if (exception_pending()) goto v0042;
3728 env = stack[-2];
3729 stack[-1] = v0087;
3730 v0049 = stack[0];
3731 v0087 = stack[-1];
3732 v0087 = qcar(v0087);
3733 v0087 = CC_exptKmodKp(env, v0049, v0087);
3734 nil = C_nil;
3735 if (exception_pending()) goto v0042;
3736 env = stack[-2];
3737 v0102 = v0087;
3738 v0087 = v0102;
3739 v0049 = v0102;
3740 fn = elt(env, 1); /* times!-mod!-p */
3741 v0087 = (*qfn2(fn))(qenv(fn), v0087, v0049);
3742 nil = C_nil;
3743 if (exception_pending()) goto v0042;
3744 env = stack[-2];
3745 v0102 = v0087;
3746 v0087 = stack[-1];
3747 v0049 = qcdr(v0087);
3748 v0087 = (Lisp_Object)1; /* 0 */
3749 if (v0049 == v0087) { popv(3); return onevalue(v0102); }
3750 v0049 = v0102;
3751 v0087 = stack[0];
3752 fn = elt(env, 1); /* times!-mod!-p */
3753 v0087 = (*qfn2(fn))(qenv(fn), v0049, v0087);
3754 nil = C_nil;
3755 if (exception_pending()) goto v0042;
3756 v0102 = v0087;
3757 { popv(3); return onevalue(v0102); }
3758
3759 v0029:
3760 v0087 = (Lisp_Object)17; /* 1 */
3761 { popv(3); return onevalue(v0087); }
3762 /* error exit handlers */
3763 v0042:
3764 popv(3);
3765 return nil;
3766 }
3767
3768
3769
3770 /* Code for get_group_in */
3771
CC_get_group_in(Lisp_Object env,Lisp_Object v0000)3772 static Lisp_Object CC_get_group_in(Lisp_Object env,
3773 Lisp_Object v0000)
3774 {
3775 Lisp_Object v0121;
3776 #ifdef DEBUG
3777 if (check_env(env)) return aerror("env for get_group_in");
3778 #endif
3779 CSL_IGNORE(env);
3780 /* copy arguments values to proper place */
3781 v0121 = v0000;
3782 /* end of prologue */
3783 v0121 = qcar(v0121);
3784 return onevalue(v0121);
3785 }
3786
3787
3788
3789 /* Code for qqe_ofsf_simplat1 */
3790
CC_qqe_ofsf_simplat1(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)3791 static Lisp_Object CC_qqe_ofsf_simplat1(Lisp_Object env,
3792 Lisp_Object v0000, Lisp_Object v0016)
3793 {
3794 Lisp_Object nil = C_nil;
3795 Lisp_Object v0069, v0090;
3796 Lisp_Object fn;
3797 CSL_IGNORE(nil);
3798 #ifdef DEBUG
3799 if (check_env(env)) return aerror("env for qqe_ofsf_simplat1");
3800 #endif
3801 if (stack >= stacklimit)
3802 {
3803 push2(v0016,v0000);
3804 env = reclaim(env, "stack", GC_STACK, 0);
3805 pop2(v0000,v0016);
3806 nil = C_nil;
3807 if (exception_pending()) return nil;
3808 }
3809 push(env);
3810 /* space for vars preserved across procedure calls */
3811 push3(nil, nil, nil);
3812 /* copy arguments values to proper place */
3813 stack[0] = v0016;
3814 stack[-1] = v0000;
3815 /* end of prologue */
3816 v0090 = stack[-1];
3817 v0069 = stack[0];
3818 fn = elt(env, 2); /* qqe_simplat1 */
3819 v0069 = (*qfn2(fn))(qenv(fn), v0090, v0069);
3820 nil = C_nil;
3821 if (exception_pending()) goto v0120;
3822 env = stack[-3];
3823 stack[-2] = v0069;
3824 v0090 = stack[-2];
3825 v0069 = elt(env, 1); /* (true false) */
3826 v0069 = Lmemq(nil, v0090, v0069);
3827 if (!(v0069 == nil)) { Lisp_Object res = stack[-2]; popv(4); return onevalue(res); }
3828 v0069 = stack[-1];
3829 fn = elt(env, 3); /* qqe_op */
3830 v0069 = (*qfn1(fn))(qenv(fn), v0069);
3831 nil = C_nil;
3832 if (exception_pending()) goto v0120;
3833 env = stack[-3];
3834 fn = elt(env, 4); /* qqe_rqopp */
3835 v0069 = (*qfn1(fn))(qenv(fn), v0069);
3836 nil = C_nil;
3837 if (exception_pending()) goto v0120;
3838 env = stack[-3];
3839 if (!(v0069 == nil)) { Lisp_Object res = stack[-2]; popv(4); return onevalue(res); }
3840 v0090 = stack[-2];
3841 v0069 = stack[0];
3842 {
3843 popv(4);
3844 fn = elt(env, 5); /* ofsf_simplat1 */
3845 return (*qfn2(fn))(qenv(fn), v0090, v0069);
3846 }
3847 /* error exit handlers */
3848 v0120:
3849 popv(4);
3850 return nil;
3851 }
3852
3853
3854
3855 /* Code for rl_negateat */
3856
CC_rl_negateat(Lisp_Object env,Lisp_Object v0000)3857 static Lisp_Object CC_rl_negateat(Lisp_Object env,
3858 Lisp_Object v0000)
3859 {
3860 Lisp_Object nil = C_nil;
3861 Lisp_Object v0015;
3862 Lisp_Object fn;
3863 CSL_IGNORE(nil);
3864 #ifdef DEBUG
3865 if (check_env(env)) return aerror("env for rl_negateat");
3866 #endif
3867 if (stack >= stacklimit)
3868 {
3869 push(v0000);
3870 env = reclaim(env, "stack", GC_STACK, 0);
3871 pop(v0000);
3872 nil = C_nil;
3873 if (exception_pending()) return nil;
3874 }
3875 push(env);
3876 /* space for vars preserved across procedure calls */
3877 push(nil);
3878 /* copy arguments values to proper place */
3879 v0015 = v0000;
3880 /* end of prologue */
3881 stack[0] = qvalue(elt(env, 1)); /* rl_negateat!* */
3882 v0015 = ncons(v0015);
3883 nil = C_nil;
3884 if (exception_pending()) goto v0031;
3885 env = stack[-1];
3886 {
3887 Lisp_Object v0032 = stack[0];
3888 popv(2);
3889 fn = elt(env, 2); /* apply */
3890 return (*qfn2(fn))(qenv(fn), v0032, v0015);
3891 }
3892 /* error exit handlers */
3893 v0031:
3894 popv(2);
3895 return nil;
3896 }
3897
3898
3899
3900 /* Code for ibalp_redclause */
3901
CC_ibalp_redclause(Lisp_Object env,Lisp_Object v0000)3902 static Lisp_Object CC_ibalp_redclause(Lisp_Object env,
3903 Lisp_Object v0000)
3904 {
3905 Lisp_Object nil = C_nil;
3906 Lisp_Object v0004, v0069;
3907 Lisp_Object fn;
3908 CSL_IGNORE(nil);
3909 #ifdef DEBUG
3910 if (check_env(env)) return aerror("env for ibalp_redclause");
3911 #endif
3912 if (stack >= stacklimit)
3913 {
3914 push(v0000);
3915 env = reclaim(env, "stack", GC_STACK, 0);
3916 pop(v0000);
3917 nil = C_nil;
3918 if (exception_pending()) return nil;
3919 }
3920 push(env);
3921 /* space for vars preserved across procedure calls */
3922 push3(nil, nil, nil);
3923 /* copy arguments values to proper place */
3924 stack[-1] = v0000;
3925 /* end of prologue */
3926 stack[0] = nil;
3927 v0004 = stack[-1];
3928 v0004 = qcar(v0004);
3929 stack[-2] = v0004;
3930 goto v0014;
3931
3932 v0014:
3933 v0004 = stack[-2];
3934 if (v0004 == nil) { Lisp_Object res = stack[0]; popv(4); return onevalue(res); }
3935 v0004 = stack[0];
3936 if (!(v0004 == nil)) { Lisp_Object res = stack[0]; popv(4); return onevalue(res); }
3937 v0004 = stack[-2];
3938 v0069 = qcar(v0004);
3939 v0004 = stack[-1];
3940 v0004 = qcdr(v0004);
3941 v0004 = qcar(v0004);
3942 fn = elt(env, 3); /* ibalp_vmember */
3943 v0004 = (*qfn2(fn))(qenv(fn), v0069, v0004);
3944 nil = C_nil;
3945 if (exception_pending()) goto v0117;
3946 env = stack[-3];
3947 if (v0004 == nil) goto v0019;
3948 v0004 = qvalue(elt(env, 2)); /* t */
3949 stack[0] = v0004;
3950 goto v0019;
3951
3952 v0019:
3953 v0004 = stack[-2];
3954 v0004 = qcdr(v0004);
3955 stack[-2] = v0004;
3956 goto v0014;
3957 /* error exit handlers */
3958 v0117:
3959 popv(4);
3960 return nil;
3961 }
3962
3963
3964
3965 /* Code for aex_simplenullp */
3966
CC_aex_simplenullp(Lisp_Object env,Lisp_Object v0000)3967 static Lisp_Object CC_aex_simplenullp(Lisp_Object env,
3968 Lisp_Object v0000)
3969 {
3970 Lisp_Object nil = C_nil;
3971 Lisp_Object v0029;
3972 Lisp_Object fn;
3973 CSL_IGNORE(nil);
3974 #ifdef DEBUG
3975 if (check_env(env)) return aerror("env for aex_simplenullp");
3976 #endif
3977 if (stack >= stacklimit)
3978 {
3979 push(v0000);
3980 env = reclaim(env, "stack", GC_STACK, 0);
3981 pop(v0000);
3982 nil = C_nil;
3983 if (exception_pending()) return nil;
3984 }
3985 push(env);
3986 /* copy arguments values to proper place */
3987 v0029 = v0000;
3988 /* end of prologue */
3989 fn = elt(env, 1); /* aex_ex */
3990 v0029 = (*qfn1(fn))(qenv(fn), v0029);
3991 nil = C_nil;
3992 if (exception_pending()) goto v0121;
3993 env = stack[0];
3994 {
3995 popv(1);
3996 fn = elt(env, 2); /* ratpoly_nullp */
3997 return (*qfn1(fn))(qenv(fn), v0029);
3998 }
3999 /* error exit handlers */
4000 v0121:
4001 popv(1);
4002 return nil;
4003 }
4004
4005
4006
4007 /* Code for variablesir */
4008
CC_variablesir(Lisp_Object env,int nargs,...)4009 static Lisp_Object MS_CDECL CC_variablesir(Lisp_Object env, int nargs, ...)
4010 {
4011 Lisp_Object nil = C_nil;
4012 Lisp_Object v0100, v0117;
4013 Lisp_Object fn;
4014 CSL_IGNORE(nil);
4015 argcheck(nargs, 0, "variablesir");
4016 #ifdef DEBUG
4017 if (check_env(env)) return aerror("env for variablesir");
4018 #endif
4019 if (stack >= stacklimit)
4020 {
4021 env = reclaim(env, "stack", GC_STACK, 0);
4022 nil = C_nil;
4023 if (exception_pending()) return nil;
4024 }
4025 push(env);
4026 /* space for vars preserved across procedure calls */
4027 push(nil);
4028 /* end of prologue */
4029 v0117 = qvalue(elt(env, 1)); /* char */
4030 v0100 = elt(env, 2); /* (!/ o m b v a r) */
4031 if (equal(v0117, v0100)) goto v0121;
4032 fn = elt(env, 4); /* omvir */
4033 v0100 = (*qfnn(fn))(qenv(fn), 0);
4034 nil = C_nil;
4035 if (exception_pending()) goto v0011;
4036 env = stack[-1];
4037 stack[0] = v0100;
4038 fn = elt(env, 5); /* lex */
4039 v0100 = (*qfnn(fn))(qenv(fn), 0);
4040 nil = C_nil;
4041 if (exception_pending()) goto v0011;
4042 env = stack[-1];
4043 v0100 = CC_variablesir(env, 0);
4044 nil = C_nil;
4045 if (exception_pending()) goto v0011;
4046 v0117 = stack[0];
4047 if (v0117 == nil) goto v0104;
4048 v0117 = stack[0];
4049 popv(2);
4050 return cons(v0117, v0100);
4051
4052 v0104:
4053 v0117 = stack[0];
4054 popv(2);
4055 return Lappend(nil, v0117, v0100);
4056
4057 v0121:
4058 v0100 = nil;
4059 { popv(2); return onevalue(v0100); }
4060 /* error exit handlers */
4061 v0011:
4062 popv(2);
4063 return nil;
4064 }
4065
4066
4067
4068 /* Code for lid */
4069
CC_lid(Lisp_Object env,Lisp_Object v0000)4070 static Lisp_Object CC_lid(Lisp_Object env,
4071 Lisp_Object v0000)
4072 {
4073 Lisp_Object nil = C_nil;
4074 Lisp_Object v0030, v0031;
4075 CSL_IGNORE(nil);
4076 #ifdef DEBUG
4077 if (check_env(env)) return aerror("env for lid");
4078 #endif
4079 CSL_IGNORE(env);
4080 /* copy arguments values to proper place */
4081 v0030 = v0000;
4082 /* end of prologue */
4083 v0031 = v0030;
4084 if (!consp(v0031)) return onevalue(v0030);
4085 v0030 = qcar(v0030);
4086 return onevalue(v0030);
4087 }
4088
4089
4090
4091 /* Code for invp */
4092
CC_invp(Lisp_Object env,Lisp_Object v0000)4093 static Lisp_Object CC_invp(Lisp_Object env,
4094 Lisp_Object v0000)
4095 {
4096 Lisp_Object nil = C_nil;
4097 Lisp_Object v0091, v0052, v0123;
4098 CSL_IGNORE(nil);
4099 #ifdef DEBUG
4100 if (check_env(env)) return aerror("env for invp");
4101 #endif
4102 if (stack >= stacklimit)
4103 {
4104 push(v0000);
4105 env = reclaim(env, "stack", GC_STACK, 0);
4106 pop(v0000);
4107 nil = C_nil;
4108 if (exception_pending()) return nil;
4109 }
4110 CSL_IGNORE(env);
4111 /* copy arguments values to proper place */
4112 v0123 = v0000;
4113 /* end of prologue */
4114 v0052 = v0123;
4115 v0091 = elt(env, 1); /* unit */
4116 if (v0052 == v0091) return onevalue(v0123);
4117 v0091 = v0123;
4118 if (!consp(v0091)) goto v0017;
4119 v0091 = v0123;
4120 v0052 = qcar(v0091);
4121 v0091 = elt(env, 3); /* (comm anticomm) */
4122 v0091 = Lmember(nil, v0052, v0091);
4123 if (v0091 == nil) goto v0092;
4124 v0052 = elt(env, 4); /* quotient */
4125 v0091 = (Lisp_Object)17; /* 1 */
4126 return list3(v0052, v0091, v0123);
4127
4128 v0092:
4129 v0091 = v0123;
4130 v0052 = qcar(v0091);
4131 v0091 = elt(env, 2); /* inverse */
4132 v0091 = get(v0052, v0091);
4133 v0052 = v0123;
4134 v0052 = qcdr(v0052);
4135 return cons(v0091, v0052);
4136
4137 v0017:
4138 v0091 = v0123;
4139 v0052 = elt(env, 2); /* inverse */
4140 return get(v0091, v0052);
4141 }
4142
4143
4144
4145 /* Code for formcond1 */
4146
CC_formcond1(Lisp_Object env,int nargs,Lisp_Object v0000,Lisp_Object v0016,Lisp_Object v0066,...)4147 static Lisp_Object MS_CDECL CC_formcond1(Lisp_Object env, int nargs,
4148 Lisp_Object v0000, Lisp_Object v0016,
4149 Lisp_Object v0066, ...)
4150 {
4151 Lisp_Object nil = C_nil;
4152 Lisp_Object v0125, v0126, v0127;
4153 Lisp_Object fn;
4154 CSL_IGNORE(nil);
4155 argcheck(nargs, 3, "formcond1");
4156 #ifdef DEBUG
4157 if (check_env(env)) return aerror("env for formcond1");
4158 #endif
4159 if (stack >= stacklimit)
4160 {
4161 push3(v0066,v0016,v0000);
4162 env = reclaim(env, "stack", GC_STACK, 0);
4163 pop3(v0000,v0016,v0066);
4164 nil = C_nil;
4165 if (exception_pending()) return nil;
4166 }
4167 push(env);
4168 /* space for vars preserved across procedure calls */
4169 push5(nil, nil, nil, nil, nil);
4170 /* copy arguments values to proper place */
4171 stack[-1] = v0066;
4172 stack[-2] = v0016;
4173 stack[-3] = v0000;
4174 /* end of prologue */
4175 stack[-4] = nil;
4176 goto v0054;
4177
4178 v0054:
4179 v0125 = stack[-3];
4180 if (v0125 == nil) goto v0014;
4181 v0125 = stack[-3];
4182 v0125 = qcar(v0125);
4183 v0127 = qcar(v0125);
4184 v0126 = stack[-2];
4185 v0125 = stack[-1];
4186 fn = elt(env, 1); /* formbool */
4187 stack[0] = (*qfnn(fn))(qenv(fn), 3, v0127, v0126, v0125);
4188 nil = C_nil;
4189 if (exception_pending()) goto v0052;
4190 env = stack[-5];
4191 v0125 = stack[-3];
4192 v0125 = qcar(v0125);
4193 v0125 = qcdr(v0125);
4194 v0127 = qcar(v0125);
4195 v0126 = stack[-2];
4196 v0125 = stack[-1];
4197 fn = elt(env, 2); /* formc */
4198 v0125 = (*qfnn(fn))(qenv(fn), 3, v0127, v0126, v0125);
4199 nil = C_nil;
4200 if (exception_pending()) goto v0052;
4201 env = stack[-5];
4202 v0126 = list2(stack[0], v0125);
4203 nil = C_nil;
4204 if (exception_pending()) goto v0052;
4205 env = stack[-5];
4206 v0125 = stack[-4];
4207 v0125 = cons(v0126, v0125);
4208 nil = C_nil;
4209 if (exception_pending()) goto v0052;
4210 env = stack[-5];
4211 stack[-4] = v0125;
4212 v0125 = stack[-3];
4213 v0125 = qcdr(v0125);
4214 stack[-3] = v0125;
4215 goto v0054;
4216
4217 v0014:
4218 v0125 = stack[-4];
4219 {
4220 popv(6);
4221 fn = elt(env, 3); /* nreverse */
4222 return (*qfn1(fn))(qenv(fn), v0125);
4223 }
4224 /* error exit handlers */
4225 v0052:
4226 popv(6);
4227 return nil;
4228 }
4229
4230
4231
4232 /* Code for mkarray1 */
4233
CC_mkarray1(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)4234 static Lisp_Object CC_mkarray1(Lisp_Object env,
4235 Lisp_Object v0000, Lisp_Object v0016)
4236 {
4237 Lisp_Object nil = C_nil;
4238 Lisp_Object v0110, v0128;
4239 CSL_IGNORE(nil);
4240 #ifdef DEBUG
4241 if (check_env(env)) return aerror("env for mkarray1");
4242 #endif
4243 if (stack >= stacklimit)
4244 {
4245 push2(v0016,v0000);
4246 env = reclaim(env, "stack", GC_STACK, 0);
4247 pop2(v0000,v0016);
4248 nil = C_nil;
4249 if (exception_pending()) return nil;
4250 }
4251 push(env);
4252 /* space for vars preserved across procedure calls */
4253 push5(nil, nil, nil, nil, nil);
4254 push2(nil, nil);
4255 /* copy arguments values to proper place */
4256 stack[-4] = v0016;
4257 stack[-5] = v0000;
4258 /* end of prologue */
4259 v0110 = stack[-5];
4260 if (v0110 == nil) goto v0030;
4261 v0110 = stack[-5];
4262 v0110 = qcar(v0110);
4263 v0110 = sub1(v0110);
4264 nil = C_nil;
4265 if (exception_pending()) goto v0129;
4266 env = stack[-7];
4267 stack[-6] = v0110;
4268 v0110 = stack[-6];
4269 v0110 = Lmkvect(nil, v0110);
4270 nil = C_nil;
4271 if (exception_pending()) goto v0129;
4272 env = stack[-7];
4273 stack[-3] = v0110;
4274 v0110 = (Lisp_Object)1; /* 0 */
4275 stack[-2] = v0110;
4276 goto v0011;
4277
4278 v0011:
4279 v0128 = stack[-6];
4280 v0110 = stack[-2];
4281 v0110 = difference2(v0128, v0110);
4282 nil = C_nil;
4283 if (exception_pending()) goto v0129;
4284 env = stack[-7];
4285 v0110 = Lminusp(nil, v0110);
4286 env = stack[-7];
4287 if (!(v0110 == nil)) { Lisp_Object res = stack[-3]; popv(8); return onevalue(res); }
4288 stack[-1] = stack[-3];
4289 stack[0] = stack[-2];
4290 v0110 = stack[-5];
4291 v0128 = qcdr(v0110);
4292 v0110 = stack[-4];
4293 v0110 = CC_mkarray1(env, v0128, v0110);
4294 nil = C_nil;
4295 if (exception_pending()) goto v0129;
4296 env = stack[-7];
4297 *(Lisp_Object *)((char *)stack[-1] + (CELL-TAG_VECTOR) + ((int32_t)stack[0]/(16/CELL))) = v0110;
4298 v0110 = stack[-2];
4299 v0110 = add1(v0110);
4300 nil = C_nil;
4301 if (exception_pending()) goto v0129;
4302 env = stack[-7];
4303 stack[-2] = v0110;
4304 goto v0011;
4305
4306 v0030:
4307 v0128 = stack[-4];
4308 v0110 = elt(env, 1); /* symbolic */
4309 if (v0128 == v0110) goto v0014;
4310 v0110 = (Lisp_Object)1; /* 0 */
4311 { popv(8); return onevalue(v0110); }
4312
4313 v0014:
4314 v0110 = qvalue(elt(env, 2)); /* nil */
4315 { popv(8); return onevalue(v0110); }
4316 /* error exit handlers */
4317 v0129:
4318 popv(8);
4319 return nil;
4320 }
4321
4322
4323
4324 /* Code for !:divide */
4325
CC_Tdivide(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)4326 static Lisp_Object CC_Tdivide(Lisp_Object env,
4327 Lisp_Object v0000, Lisp_Object v0016)
4328 {
4329 Lisp_Object nil = C_nil;
4330 Lisp_Object v0125, v0126, v0127;
4331 Lisp_Object fn;
4332 CSL_IGNORE(nil);
4333 #ifdef DEBUG
4334 if (check_env(env)) return aerror("env for :divide");
4335 #endif
4336 if (stack >= stacklimit)
4337 {
4338 push2(v0016,v0000);
4339 env = reclaim(env, "stack", GC_STACK, 0);
4340 pop2(v0000,v0016);
4341 nil = C_nil;
4342 if (exception_pending()) return nil;
4343 }
4344 push(env);
4345 /* copy arguments values to proper place */
4346 v0126 = v0016;
4347 v0127 = v0000;
4348 /* end of prologue */
4349 v0125 = v0127;
4350 if (v0125 == nil) goto v0029;
4351 v0125 = v0126;
4352 if (v0125 == nil) goto v0014;
4353 v0125 = v0127;
4354 if (!consp(v0125)) goto v0070;
4355 v0125 = qvalue(elt(env, 1)); /* nil */
4356 goto v0053;
4357
4358 v0053:
4359 if (v0125 == nil) goto v0124;
4360 v0125 = v0127;
4361 {
4362 popv(1);
4363 fn = elt(env, 6); /* dividef */
4364 return (*qfn2(fn))(qenv(fn), v0125, v0126);
4365 }
4366
4367 v0124:
4368 v0125 = elt(env, 5); /* divide */
4369 {
4370 popv(1);
4371 fn = elt(env, 7); /* dcombine */
4372 return (*qfnn(fn))(qenv(fn), 3, v0127, v0126, v0125);
4373 }
4374
4375 v0070:
4376 v0125 = v0126;
4377 v0125 = (consp(v0125) ? nil : lisp_true);
4378 goto v0053;
4379
4380 v0014:
4381 v0125 = elt(env, 2); /* "zero divisor" */
4382 v0126 = v0125;
4383 v0125 = v0126;
4384 qvalue(elt(env, 3)) = v0125; /* errmsg!* */
4385 v0125 = qvalue(elt(env, 4)); /* !*protfg */
4386 if (!(v0125 == nil)) goto v0018;
4387 v0125 = v0126;
4388 fn = elt(env, 8); /* lprie */
4389 v0125 = (*qfn1(fn))(qenv(fn), v0125);
4390 nil = C_nil;
4391 if (exception_pending()) goto v0122;
4392 env = stack[0];
4393 goto v0018;
4394
4395 v0018:
4396 v0125 = Lerror0(nil, 0);
4397 nil = C_nil;
4398 if (exception_pending()) goto v0122;
4399 v0125 = nil;
4400 { popv(1); return onevalue(v0125); }
4401
4402 v0029:
4403 v0125 = qvalue(elt(env, 1)); /* nil */
4404 popv(1);
4405 return ncons(v0125);
4406 /* error exit handlers */
4407 v0122:
4408 popv(1);
4409 return nil;
4410 }
4411
4412
4413
4414 /* Code for gperm0 */
4415
CC_gperm0(Lisp_Object env,Lisp_Object v0000)4416 static Lisp_Object CC_gperm0(Lisp_Object env,
4417 Lisp_Object v0000)
4418 {
4419 Lisp_Object nil = C_nil;
4420 Lisp_Object v0020, v0025;
4421 Lisp_Object fn;
4422 CSL_IGNORE(nil);
4423 #ifdef DEBUG
4424 if (check_env(env)) return aerror("env for gperm0");
4425 #endif
4426 if (stack >= stacklimit)
4427 {
4428 push(v0000);
4429 env = reclaim(env, "stack", GC_STACK, 0);
4430 pop(v0000);
4431 nil = C_nil;
4432 if (exception_pending()) return nil;
4433 }
4434 push(env);
4435 /* space for vars preserved across procedure calls */
4436 push(nil);
4437 /* copy arguments values to proper place */
4438 v0025 = v0000;
4439 /* end of prologue */
4440 v0020 = v0025;
4441 if (v0020 == nil) goto v0021;
4442 v0020 = v0025;
4443 stack[0] = qcdr(v0020);
4444 v0020 = v0025;
4445 v0020 = qcar(v0020);
4446 v0020 = ncons(v0020);
4447 nil = C_nil;
4448 if (exception_pending()) goto v0104;
4449 env = stack[-1];
4450 v0020 = ncons(v0020);
4451 nil = C_nil;
4452 if (exception_pending()) goto v0104;
4453 env = stack[-1];
4454 {
4455 Lisp_Object v0067 = stack[0];
4456 popv(2);
4457 fn = elt(env, 2); /* gperm3 */
4458 return (*qfn2(fn))(qenv(fn), v0067, v0020);
4459 }
4460
4461 v0021:
4462 v0020 = qvalue(elt(env, 1)); /* nil */
4463 { popv(2); return onevalue(v0020); }
4464 /* error exit handlers */
4465 v0104:
4466 popv(2);
4467 return nil;
4468 }
4469
4470
4471
4472 /* Code for freeofl */
4473
CC_freeofl(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)4474 static Lisp_Object CC_freeofl(Lisp_Object env,
4475 Lisp_Object v0000, Lisp_Object v0016)
4476 {
4477 Lisp_Object nil = C_nil;
4478 Lisp_Object v0010, v0119, v0092;
4479 Lisp_Object fn;
4480 CSL_IGNORE(nil);
4481 #ifdef DEBUG
4482 if (check_env(env)) return aerror("env for freeofl");
4483 #endif
4484 if (stack >= stacklimit)
4485 {
4486 push2(v0016,v0000);
4487 env = reclaim(env, "stack", GC_STACK, 0);
4488 pop2(v0000,v0016);
4489 nil = C_nil;
4490 if (exception_pending()) return nil;
4491 }
4492 push(env);
4493 /* space for vars preserved across procedure calls */
4494 push2(nil, nil);
4495 /* copy arguments values to proper place */
4496 stack[0] = v0016;
4497 stack[-1] = v0000;
4498 /* end of prologue */
4499
4500 v0115:
4501 v0010 = stack[0];
4502 if (v0010 == nil) goto v0029;
4503 v0010 = stack[0];
4504 v0119 = qcar(v0010);
4505 v0010 = stack[-1];
4506 fn = elt(env, 4); /* smember */
4507 v0010 = (*qfn2(fn))(qenv(fn), v0119, v0010);
4508 nil = C_nil;
4509 if (exception_pending()) goto v0125;
4510 env = stack[-2];
4511 if (!(v0010 == nil)) goto v0008;
4512 v0010 = stack[0];
4513 v0092 = qcar(v0010);
4514 v0119 = stack[-1];
4515 v0010 = qvalue(elt(env, 2)); /* depl!* */
4516 v0010 = Lassoc(nil, v0119, v0010);
4517 v0010 = Lmember(nil, v0092, v0010);
4518 if (!(v0010 == nil)) goto v0008;
4519 v0119 = stack[-1];
4520 v0010 = stack[0];
4521 v0010 = qcdr(v0010);
4522 stack[-1] = v0119;
4523 stack[0] = v0010;
4524 goto v0115;
4525
4526 v0008:
4527 v0010 = qvalue(elt(env, 3)); /* nil */
4528 { popv(3); return onevalue(v0010); }
4529
4530 v0029:
4531 v0010 = qvalue(elt(env, 1)); /* t */
4532 { popv(3); return onevalue(v0010); }
4533 /* error exit handlers */
4534 v0125:
4535 popv(3);
4536 return nil;
4537 }
4538
4539
4540
4541 /* Code for xread1 */
4542
CC_xread1(Lisp_Object env,Lisp_Object v0000)4543 static Lisp_Object CC_xread1(Lisp_Object env,
4544 Lisp_Object v0000)
4545 {
4546 Lisp_Object nil = C_nil;
4547 Lisp_Object v0361, v0362, v0363;
4548 Lisp_Object fn;
4549 CSL_IGNORE(nil);
4550 #ifdef DEBUG
4551 if (check_env(env)) return aerror("env for xread1");
4552 #endif
4553 if (stack >= stacklimit)
4554 {
4555 push(v0000);
4556 env = reclaim(env, "stack", GC_STACK, 0);
4557 pop(v0000);
4558 nil = C_nil;
4559 if (exception_pending()) return nil;
4560 }
4561 push(env);
4562 /* space for vars preserved across procedure calls */
4563 push5(nil, nil, nil, nil, nil);
4564 push4(nil, nil, nil, nil);
4565 /* copy arguments values to proper place */
4566 stack[-7] = v0000;
4567 /* end of prologue */
4568 stack[-8] = nil;
4569 stack[-6] = nil;
4570 stack[-5] = nil;
4571 stack[-4] = nil;
4572 stack[-2] = nil;
4573 stack[-1] = nil;
4574 v0361 = qvalue(elt(env, 1)); /* commentlist!* */
4575 if (v0361 == nil) goto v0030;
4576 v0361 = qvalue(elt(env, 1)); /* commentlist!* */
4577 stack[-1] = v0361;
4578 v0361 = qvalue(elt(env, 2)); /* nil */
4579 qvalue(elt(env, 1)) = v0361; /* commentlist!* */
4580 goto v0030;
4581
4582 v0030:
4583 v0361 = qvalue(elt(env, 3)); /* cursym!* */
4584 stack[-3] = v0361;
4585 goto v0031;
4586
4587 v0031:
4588 v0361 = stack[-3];
4589 if (!(symbolp(v0361))) goto v0032;
4590 v0362 = stack[-3];
4591 v0361 = elt(env, 4); /* !*lpar!* */
4592 if (v0362 == v0361) goto v0006;
4593 v0362 = stack[-3];
4594 v0361 = elt(env, 5); /* !*rpar!* */
4595 if (v0362 == v0361) goto v0018;
4596 v0362 = stack[-3];
4597 v0361 = elt(env, 6); /* infix */
4598 v0361 = get(v0362, v0361);
4599 env = stack[-9];
4600 stack[-4] = v0361;
4601 if (!(v0361 == nil)) goto v0064;
4602 v0362 = stack[-3];
4603 v0361 = elt(env, 7); /* delim */
4604 v0361 = Lflagp(nil, v0362, v0361);
4605 env = stack[-9];
4606 if (v0361 == nil) goto v0060;
4607 v0362 = qvalue(elt(env, 3)); /* cursym!* */
4608 v0361 = elt(env, 30); /* !*semicol!* */
4609 if (v0362 == v0361) goto v0364;
4610 fn = elt(env, 57); /* eolcheck */
4611 v0361 = (*qfnn(fn))(qenv(fn), 0);
4612 nil = C_nil;
4613 if (exception_pending()) goto v0365;
4614 env = stack[-9];
4615 goto v0364;
4616
4617 v0364:
4618 v0362 = stack[-3];
4619 v0361 = elt(env, 50); /* !*colon!* */
4620 if (v0362 == v0361) goto v0366;
4621 v0361 = qvalue(elt(env, 2)); /* nil */
4622 goto v0367;
4623
4624 v0367:
4625 if (!(v0361 == nil)) goto v0368;
4626 v0362 = stack[-3];
4627 v0361 = elt(env, 53); /* nodel */
4628 v0361 = Lflagp(nil, v0362, v0361);
4629 env = stack[-9];
4630 if (v0361 == nil) goto v0369;
4631 v0361 = stack[-7];
4632 if (v0361 == nil) goto v0370;
4633 v0362 = stack[-7];
4634 v0361 = elt(env, 28); /* group */
4635 if (v0362 == v0361) goto v0371;
4636 v0361 = qvalue(elt(env, 2)); /* nil */
4637 goto v0372;
4638
4639 v0372:
4640 if (!(v0361 == nil)) goto v0368;
4641 v0361 = stack[-7];
4642 if (!(symbolp(v0361))) goto v0024;
4643 v0362 = stack[-7];
4644 v0361 = elt(env, 24); /* paren */
4645 if (v0362 == v0361) goto v0373;
4646 v0362 = stack[-7];
4647 v0361 = elt(env, 23); /* struct */
4648 v0361 = Lflagp(nil, v0362, v0361);
4649 env = stack[-9];
4650 goto v0374;
4651
4652 v0374:
4653 if (v0361 == nil) goto v0024;
4654 v0362 = elt(env, 55); /* "Too few right parentheses" */
4655 v0361 = qvalue(elt(env, 2)); /* nil */
4656 fn = elt(env, 58); /* symerr */
4657 v0361 = (*qfn2(fn))(qenv(fn), v0362, v0361);
4658 nil = C_nil;
4659 if (exception_pending()) goto v0365;
4660 env = stack[-9];
4661 goto v0024;
4662
4663 v0024:
4664 v0361 = stack[-4];
4665 if (v0361 == nil) goto v0375;
4666 v0362 = elt(env, 27); /* "Improper delimiter" */
4667 v0361 = qvalue(elt(env, 2)); /* nil */
4668 fn = elt(env, 58); /* symerr */
4669 v0361 = (*qfn2(fn))(qenv(fn), v0362, v0361);
4670 nil = C_nil;
4671 if (exception_pending()) goto v0365;
4672 env = stack[-9];
4673 goto v0376;
4674
4675 v0376:
4676 v0361 = (Lisp_Object)1; /* 0 */
4677 stack[-4] = v0361;
4678 goto v0023;
4679
4680 v0023:
4681 v0361 = stack[-6];
4682 if (!(v0361 == nil)) goto v0377;
4683 v0362 = elt(env, 27); /* "Improper delimiter" */
4684 v0361 = qvalue(elt(env, 2)); /* nil */
4685 fn = elt(env, 58); /* symerr */
4686 v0361 = (*qfn2(fn))(qenv(fn), v0362, v0361);
4687 nil = C_nil;
4688 if (exception_pending()) goto v0365;
4689 env = stack[-9];
4690 goto v0377;
4691
4692 v0377:
4693 v0361 = stack[-6];
4694 v0361 = qcar(v0361);
4695 stack[0] = v0361;
4696 goto v0104;
4697
4698 v0104:
4699 v0361 = stack[-6];
4700 v0361 = qcdr(v0361);
4701 stack[-6] = v0361;
4702 v0361 = stack[-6];
4703 if (v0361 == nil) goto v0378;
4704 v0361 = stack[-6];
4705 v0361 = qcar(v0361);
4706 if (!consp(v0361)) goto v0379;
4707 v0361 = qvalue(elt(env, 2)); /* nil */
4708 goto v0380;
4709
4710 v0380:
4711 if (v0361 == nil) goto v0381;
4712 v0362 = elt(env, 34); /* "Missing operator" */
4713 v0361 = qvalue(elt(env, 2)); /* nil */
4714 fn = elt(env, 58); /* symerr */
4715 v0361 = (*qfn2(fn))(qenv(fn), v0362, v0361);
4716 nil = C_nil;
4717 if (exception_pending()) goto v0365;
4718 env = stack[-9];
4719 goto v0381;
4720
4721 v0381:
4722 v0361 = stack[-6];
4723 v0362 = qcar(v0361);
4724 v0361 = stack[0];
4725 v0361 = list2(v0362, v0361);
4726 nil = C_nil;
4727 if (exception_pending()) goto v0365;
4728 env = stack[-9];
4729 stack[0] = v0361;
4730 goto v0104;
4731
4732 v0379:
4733 v0361 = stack[-6];
4734 v0361 = qcar(v0361);
4735 v0361 = Lsymbolp(nil, v0361);
4736 env = stack[-9];
4737 v0361 = (v0361 == nil ? lisp_true : nil);
4738 goto v0380;
4739
4740 v0378:
4741 v0362 = stack[0];
4742 v0361 = stack[-8];
4743 v0361 = cons(v0362, v0361);
4744 nil = C_nil;
4745 if (exception_pending()) goto v0365;
4746 env = stack[-9];
4747 stack[-8] = v0361;
4748 goto v0065;
4749
4750 v0065:
4751 v0361 = stack[-5];
4752 if (v0361 == nil) goto v0382;
4753 v0362 = stack[-4];
4754 v0361 = stack[-5];
4755 v0361 = qcar(v0361);
4756 v0361 = qcar(v0361);
4757 v0361 = (Lisp_Object)lessp2(v0362, v0361);
4758 nil = C_nil;
4759 if (exception_pending()) goto v0365;
4760 v0361 = v0361 ? lisp_true : nil;
4761 env = stack[-9];
4762 if (!(v0361 == nil)) goto v0383;
4763 v0362 = stack[-4];
4764 v0361 = stack[-5];
4765 v0361 = qcar(v0361);
4766 v0361 = qcar(v0361);
4767 if (equal(v0362, v0361)) goto v0384;
4768 v0361 = qvalue(elt(env, 2)); /* nil */
4769 goto v0385;
4770
4771 v0385:
4772 if (!(v0361 == nil)) goto v0383;
4773
4774 v0386:
4775 v0363 = stack[-4];
4776 v0362 = stack[-3];
4777 v0361 = stack[-5];
4778 v0361 = acons(v0363, v0362, v0361);
4779 nil = C_nil;
4780 if (exception_pending()) goto v0365;
4781 env = stack[-9];
4782 stack[-5] = v0361;
4783 v0362 = stack[-3];
4784 v0361 = elt(env, 25); /* !*comma!* */
4785 if (!(v0362 == v0361)) goto v0025;
4786 v0361 = stack[-5];
4787 v0361 = qcdr(v0361);
4788 if (!(v0361 == nil)) goto v0005;
4789 v0361 = stack[-7];
4790 if (v0361 == nil) goto v0387;
4791 v0362 = stack[-7];
4792 v0361 = elt(env, 38); /* (lambda paren) */
4793 v0361 = Lmemq(nil, v0362, v0361);
4794 if (!(v0361 == nil)) goto v0388;
4795 v0362 = stack[-7];
4796 v0361 = elt(env, 23); /* struct */
4797 v0361 = Lflagp(nil, v0362, v0361);
4798 env = stack[-9];
4799 goto v0388;
4800
4801 v0388:
4802 if (!(v0361 == nil)) goto v0005;
4803
4804 v0022:
4805 v0361 = stack[-8];
4806 v0361 = qcdr(v0361);
4807 if (v0361 == nil) goto v0389;
4808 v0361 = elt(env, 56); /* "Please send hearn@rand.org your program!!"
4809 */
4810 v0361 = Lprint(nil, v0361);
4811 nil = C_nil;
4812 if (exception_pending()) goto v0365;
4813 env = stack[-9];
4814 v0362 = elt(env, 27); /* "Improper delimiter" */
4815 v0361 = qvalue(elt(env, 2)); /* nil */
4816 fn = elt(env, 58); /* symerr */
4817 v0361 = (*qfn2(fn))(qenv(fn), v0362, v0361);
4818 nil = C_nil;
4819 if (exception_pending()) goto v0365;
4820 v0361 = nil;
4821 { popv(10); return onevalue(v0361); }
4822
4823 v0389:
4824 v0361 = stack[-8];
4825 v0362 = qcar(v0361);
4826 v0361 = stack[-1];
4827 {
4828 popv(10);
4829 fn = elt(env, 59); /* xcomment */
4830 return (*qfn2(fn))(qenv(fn), v0362, v0361);
4831 }
4832
4833 v0005:
4834 fn = elt(env, 60); /* scan */
4835 v0361 = (*qfnn(fn))(qenv(fn), 0);
4836 nil = C_nil;
4837 if (exception_pending()) goto v0365;
4838 env = stack[-9];
4839 stack[-3] = v0361;
4840 goto v0031;
4841
4842 v0387:
4843 v0361 = qvalue(elt(env, 13)); /* t */
4844 goto v0388;
4845
4846 v0025:
4847 v0361 = stack[-2];
4848 stack[-3] = v0361;
4849 goto v0031;
4850
4851 v0383:
4852 v0361 = stack[-8];
4853 v0361 = qcdr(v0361);
4854 v0362 = qcar(v0361);
4855 v0361 = elt(env, 39); /* not */
4856 if (!consp(v0362)) goto v0390;
4857 v0362 = qcar(v0362);
4858 if (!(v0362 == v0361)) goto v0390;
4859 v0361 = stack[-5];
4860 v0361 = qcar(v0361);
4861 v0363 = qcar(v0361);
4862 v0362 = elt(env, 40); /* member */
4863 v0361 = elt(env, 6); /* infix */
4864 v0361 = get(v0362, v0361);
4865 env = stack[-9];
4866 v0361 = (Lisp_Object)geq2(v0363, v0361);
4867 nil = C_nil;
4868 if (exception_pending()) goto v0365;
4869 v0361 = v0361 ? lisp_true : nil;
4870 env = stack[-9];
4871 goto v0391;
4872
4873 v0391:
4874 if (v0361 == nil) goto v0392;
4875 v0362 = elt(env, 41); /* "NOT" */
4876 v0361 = elt(env, 42); /* "infix operator" */
4877 fn = elt(env, 61); /* typerr */
4878 v0361 = (*qfn2(fn))(qenv(fn), v0362, v0361);
4879 nil = C_nil;
4880 if (exception_pending()) goto v0365;
4881 env = stack[-9];
4882 goto v0392;
4883
4884 v0392:
4885 v0361 = stack[-8];
4886 v0361 = qcdr(v0361);
4887 v0362 = qcar(v0361);
4888 v0361 = elt(env, 33); /* !*!*un!*!* */
4889 if (v0362 == v0361) goto v0393;
4890 v0361 = stack[-5];
4891 v0361 = qcar(v0361);
4892 stack[0] = qcdr(v0361);
4893 v0361 = stack[-8];
4894 v0362 = qcar(v0361);
4895 v0361 = stack[-5];
4896 v0361 = qcar(v0361);
4897 v0361 = qcdr(v0361);
4898 if (!consp(v0362)) goto v0394;
4899 v0362 = qcar(v0362);
4900 if (!(v0362 == v0361)) goto v0394;
4901 v0361 = stack[-5];
4902 v0361 = qcar(v0361);
4903 v0362 = qcdr(v0361);
4904 v0361 = elt(env, 35); /* nary */
4905 v0361 = Lflagp(nil, v0362, v0361);
4906 env = stack[-9];
4907 goto v0395;
4908
4909 v0395:
4910 if (v0361 == nil) goto v0396;
4911 v0361 = stack[-8];
4912 v0361 = qcdr(v0361);
4913 v0362 = qcar(v0361);
4914 v0361 = stack[-8];
4915 v0361 = qcar(v0361);
4916 v0361 = qcdr(v0361);
4917 v0361 = cons(v0362, v0361);
4918 nil = C_nil;
4919 if (exception_pending()) goto v0365;
4920 env = stack[-9];
4921 goto v0397;
4922
4923 v0397:
4924 v0361 = cons(stack[0], v0361);
4925 nil = C_nil;
4926 if (exception_pending()) goto v0365;
4927 env = stack[-9];
4928 stack[0] = v0361;
4929 goto v0398;
4930
4931 v0398:
4932 v0361 = stack[-5];
4933 v0361 = qcdr(v0361);
4934 stack[-5] = v0361;
4935 v0362 = stack[0];
4936 v0361 = stack[-8];
4937 v0361 = qcdr(v0361);
4938 v0361 = qcdr(v0361);
4939 v0361 = cons(v0362, v0361);
4940 nil = C_nil;
4941 if (exception_pending()) goto v0365;
4942 env = stack[-9];
4943 stack[-8] = v0361;
4944 goto v0065;
4945
4946 v0396:
4947 v0361 = stack[-8];
4948 v0361 = qcdr(v0361);
4949 v0362 = qcar(v0361);
4950 v0361 = stack[-8];
4951 v0361 = qcar(v0361);
4952 v0361 = list2(v0362, v0361);
4953 nil = C_nil;
4954 if (exception_pending()) goto v0365;
4955 env = stack[-9];
4956 goto v0397;
4957
4958 v0394:
4959 v0361 = qvalue(elt(env, 2)); /* nil */
4960 goto v0395;
4961
4962 v0393:
4963 v0361 = stack[-8];
4964 v0362 = qcar(v0361);
4965 v0361 = elt(env, 33); /* !*!*un!*!* */
4966 if (v0362 == v0361) goto v0386;
4967 v0361 = stack[-5];
4968 v0361 = qcar(v0361);
4969 v0362 = qcdr(v0361);
4970 v0361 = stack[-8];
4971 v0361 = qcar(v0361);
4972 v0361 = list2(v0362, v0361);
4973 nil = C_nil;
4974 if (exception_pending()) goto v0365;
4975 env = stack[-9];
4976 stack[0] = v0361;
4977 goto v0398;
4978
4979 v0390:
4980 v0361 = qvalue(elt(env, 2)); /* nil */
4981 goto v0391;
4982
4983 v0384:
4984 v0362 = stack[-3];
4985 v0361 = stack[-5];
4986 v0361 = qcar(v0361);
4987 v0361 = qcdr(v0361);
4988 if (v0362 == v0361) goto v0399;
4989 v0361 = qvalue(elt(env, 2)); /* nil */
4990 goto v0400;
4991
4992 v0400:
4993 if (v0361 == nil) goto v0401;
4994 v0361 = qvalue(elt(env, 13)); /* t */
4995 goto v0385;
4996
4997 v0401:
4998 v0361 = stack[-5];
4999 v0361 = qcar(v0361);
5000 v0362 = qcdr(v0361);
5001 v0361 = elt(env, 37); /* alt */
5002 v0361 = get(v0362, v0361);
5003 env = stack[-9];
5004 goto v0385;
5005
5006 v0399:
5007 v0362 = stack[-3];
5008 v0361 = elt(env, 35); /* nary */
5009 v0361 = Lflagp(nil, v0362, v0361);
5010 env = stack[-9];
5011 if (v0361 == nil) goto v0402;
5012 v0361 = qvalue(elt(env, 2)); /* nil */
5013 goto v0400;
5014
5015 v0402:
5016 v0362 = stack[-3];
5017 v0361 = elt(env, 36); /* right */
5018 v0361 = Lflagp(nil, v0362, v0361);
5019 env = stack[-9];
5020 v0361 = (v0361 == nil ? lisp_true : nil);
5021 goto v0400;
5022
5023 v0382:
5024 v0362 = stack[-4];
5025 v0361 = (Lisp_Object)1; /* 0 */
5026 if (v0362 == v0361) goto v0022;
5027 else goto v0386;
5028
5029 v0375:
5030 v0361 = stack[-8];
5031 if (v0361 == nil) goto v0403;
5032 v0361 = qvalue(elt(env, 2)); /* nil */
5033 goto v0404;
5034
5035 v0404:
5036 if (v0361 == nil) goto v0376;
5037 v0362 = qvalue(elt(env, 2)); /* nil */
5038 v0361 = stack[-1];
5039 {
5040 popv(10);
5041 fn = elt(env, 59); /* xcomment */
5042 return (*qfn2(fn))(qenv(fn), v0362, v0361);
5043 }
5044
5045 v0403:
5046 v0361 = stack[-6];
5047 if (v0361 == nil) goto v0405;
5048 v0361 = qvalue(elt(env, 2)); /* nil */
5049 goto v0404;
5050
5051 v0405:
5052 v0361 = stack[-5];
5053 v0361 = (v0361 == nil ? lisp_true : nil);
5054 goto v0404;
5055
5056 v0373:
5057 v0361 = qvalue(elt(env, 13)); /* t */
5058 goto v0374;
5059
5060 v0368:
5061 v0362 = elt(env, 27); /* "Improper delimiter" */
5062 v0361 = qvalue(elt(env, 2)); /* nil */
5063 fn = elt(env, 58); /* symerr */
5064 v0361 = (*qfn2(fn))(qenv(fn), v0362, v0361);
5065 nil = C_nil;
5066 if (exception_pending()) goto v0365;
5067 env = stack[-9];
5068 goto v0024;
5069
5070 v0371:
5071 v0362 = stack[-3];
5072 v0361 = elt(env, 54); /* (!*rsqbkt!* !*rcbkt!* !*rsqb!*) */
5073 v0361 = Lmemq(nil, v0362, v0361);
5074 v0361 = (v0361 == nil ? lisp_true : nil);
5075 goto v0372;
5076
5077 v0370:
5078 v0361 = qvalue(elt(env, 13)); /* t */
5079 goto v0372;
5080
5081 v0369:
5082 v0361 = qvalue(elt(env, 2)); /* nil */
5083 goto v0372;
5084
5085 v0366:
5086 v0362 = stack[-7];
5087 v0361 = elt(env, 51); /* for */
5088 if (v0362 == v0361) goto v0406;
5089 v0361 = qvalue(elt(env, 52)); /* !*blockp */
5090 if (v0361 == nil) goto v0407;
5091 v0361 = stack[-6];
5092 if (v0361 == nil) goto v0408;
5093 v0361 = stack[-6];
5094 v0361 = qcar(v0361);
5095 if (!consp(v0361)) goto v0409;
5096 v0361 = qvalue(elt(env, 13)); /* t */
5097 goto v0367;
5098
5099 v0409:
5100 v0361 = stack[-6];
5101 v0361 = qcdr(v0361);
5102 goto v0367;
5103
5104 v0408:
5105 v0361 = qvalue(elt(env, 13)); /* t */
5106 goto v0367;
5107
5108 v0407:
5109 v0361 = qvalue(elt(env, 13)); /* t */
5110 goto v0367;
5111
5112 v0406:
5113 v0361 = qvalue(elt(env, 2)); /* nil */
5114 goto v0367;
5115
5116 v0060:
5117 v0362 = stack[-3];
5118 v0361 = elt(env, 8); /* stat */
5119 v0361 = get(v0362, v0361);
5120 env = stack[-9];
5121 stack[-4] = v0361;
5122 if (v0361 == nil) goto v0109;
5123 v0362 = stack[-4];
5124 v0361 = elt(env, 43); /* endstat */
5125 if (v0362 == v0361) goto v0410;
5126 fn = elt(env, 57); /* eolcheck */
5127 v0361 = (*qfnn(fn))(qenv(fn), 0);
5128 nil = C_nil;
5129 if (exception_pending()) goto v0365;
5130 env = stack[-9];
5131 goto v0410;
5132
5133 v0410:
5134 v0362 = stack[-3];
5135 v0361 = elt(env, 44); /* go */
5136 v0361 = Lflagp(nil, v0362, v0361);
5137 env = stack[-9];
5138 if (v0361 == nil) goto v0411;
5139 v0361 = qvalue(elt(env, 13)); /* t */
5140 goto v0412;
5141
5142 v0412:
5143 if (v0361 == nil) goto v0032;
5144 v0362 = stack[-3];
5145 v0361 = elt(env, 48); /* procedure */
5146 if (v0362 == v0361) goto v0413;
5147 v0361 = qvalue(elt(env, 2)); /* nil */
5148 goto v0414;
5149
5150 v0414:
5151 if (v0361 == nil) goto v0415;
5152 v0361 = stack[-6];
5153 if (v0361 == nil) goto v0416;
5154 v0361 = stack[-6];
5155 v0361 = qcdr(v0361);
5156 if (!(v0361 == nil)) goto v0417;
5157 v0361 = qvalue(elt(env, 9)); /* !*reduce4 */
5158 if (!(v0361 == nil)) goto v0417;
5159 v0361 = stack[-6];
5160 v0361 = qcar(v0361);
5161 fn = elt(env, 62); /* procstat1 */
5162 v0361 = (*qfn1(fn))(qenv(fn), v0361);
5163 nil = C_nil;
5164 if (exception_pending()) goto v0365;
5165 env = stack[-9];
5166 v0361 = ncons(v0361);
5167 nil = C_nil;
5168 if (exception_pending()) goto v0365;
5169 env = stack[-9];
5170 stack[-6] = v0361;
5171 goto v0418;
5172
5173 v0418:
5174 v0361 = qvalue(elt(env, 2)); /* nil */
5175 stack[-4] = v0361;
5176 goto v0030;
5177
5178 v0417:
5179 v0362 = elt(env, 49); /* "proc form" */
5180 v0361 = qvalue(elt(env, 2)); /* nil */
5181 fn = elt(env, 58); /* symerr */
5182 v0361 = (*qfn2(fn))(qenv(fn), v0362, v0361);
5183 nil = C_nil;
5184 if (exception_pending()) goto v0365;
5185 env = stack[-9];
5186 goto v0418;
5187
5188 v0416:
5189 v0361 = qvalue(elt(env, 2)); /* nil */
5190 fn = elt(env, 62); /* procstat1 */
5191 v0361 = (*qfn1(fn))(qenv(fn), v0361);
5192 nil = C_nil;
5193 if (exception_pending()) goto v0365;
5194 env = stack[-9];
5195 v0361 = ncons(v0361);
5196 nil = C_nil;
5197 if (exception_pending()) goto v0365;
5198 env = stack[-9];
5199 stack[-6] = v0361;
5200 goto v0418;
5201
5202 v0415:
5203 v0362 = stack[-4];
5204 v0361 = qvalue(elt(env, 2)); /* nil */
5205 fn = elt(env, 63); /* lispapply */
5206 v0362 = (*qfn2(fn))(qenv(fn), v0362, v0361);
5207 nil = C_nil;
5208 if (exception_pending()) goto v0365;
5209 env = stack[-9];
5210 v0361 = stack[-6];
5211 v0361 = cons(v0362, v0361);
5212 nil = C_nil;
5213 if (exception_pending()) goto v0365;
5214 env = stack[-9];
5215 stack[-6] = v0361;
5216 goto v0418;
5217
5218 v0413:
5219 v0361 = qvalue(elt(env, 9)); /* !*reduce4 */
5220 goto v0414;
5221
5222 v0032:
5223 v0361 = qvalue(elt(env, 2)); /* nil */
5224 stack[-4] = v0361;
5225 goto v0036;
5226
5227 v0036:
5228 v0362 = stack[-3];
5229 v0361 = stack[-6];
5230 v0361 = cons(v0362, v0361);
5231 nil = C_nil;
5232 if (exception_pending()) goto v0365;
5233 env = stack[-9];
5234 stack[-6] = v0361;
5235 v0361 = stack[-3];
5236 if (is_number(v0361)) goto v0419;
5237 v0362 = stack[-3];
5238 v0361 = elt(env, 12); /* !:dn!: */
5239 if (!consp(v0362)) goto v0420;
5240 v0362 = qcar(v0362);
5241 if (!(v0362 == v0361)) goto v0420;
5242 v0361 = qvalue(elt(env, 13)); /* t */
5243 goto v0421;
5244
5245 v0421:
5246 if (!(v0361 == nil)) goto v0419;
5247
5248 v0422:
5249 v0362 = stack[-7];
5250 v0361 = elt(env, 21); /* proc */
5251 if (v0362 == v0361) goto v0423;
5252 v0361 = qvalue(elt(env, 2)); /* nil */
5253 goto v0424;
5254
5255 v0424:
5256 if (v0361 == nil) goto v0005;
5257 v0362 = elt(env, 22); /* "Syntax error in procedure header" */
5258 v0361 = qvalue(elt(env, 2)); /* nil */
5259 fn = elt(env, 58); /* symerr */
5260 v0361 = (*qfn2(fn))(qenv(fn), v0362, v0361);
5261 nil = C_nil;
5262 if (exception_pending()) goto v0365;
5263 env = stack[-9];
5264 goto v0005;
5265
5266 v0423:
5267 v0361 = stack[-6];
5268 v0362 = Llength(nil, v0361);
5269 nil = C_nil;
5270 if (exception_pending()) goto v0365;
5271 env = stack[-9];
5272 v0361 = (Lisp_Object)33; /* 2 */
5273 v0361 = (Lisp_Object)greaterp2(v0362, v0361);
5274 nil = C_nil;
5275 if (exception_pending()) goto v0365;
5276 v0361 = v0361 ? lisp_true : nil;
5277 env = stack[-9];
5278 goto v0424;
5279
5280 v0419:
5281 v0362 = stack[-2];
5282 v0361 = qvalue(elt(env, 15)); /* !$eol!$ */
5283 if (v0362 == v0361) goto v0425;
5284 v0361 = qvalue(elt(env, 16)); /* nxtsym!* */
5285 fn = elt(env, 64); /* chknewnam */
5286 v0361 = (*qfn1(fn))(qenv(fn), v0361);
5287 nil = C_nil;
5288 if (exception_pending()) goto v0365;
5289 env = stack[-9];
5290 stack[-2] = v0361;
5291 if (symbolp(v0361)) goto v0426;
5292 v0361 = qvalue(elt(env, 2)); /* nil */
5293 goto v0427;
5294
5295 v0427:
5296 if (v0361 == nil) goto v0422;
5297 v0361 = elt(env, 20); /* times */
5298 qvalue(elt(env, 3)) = v0361; /* cursym!* */
5299 goto v0030;
5300
5301 v0426:
5302 v0362 = stack[-2];
5303 v0361 = elt(env, 7); /* delim */
5304 v0361 = Lflagp(nil, v0362, v0361);
5305 env = stack[-9];
5306 if (v0361 == nil) goto v0428;
5307 v0361 = qvalue(elt(env, 2)); /* nil */
5308 goto v0427;
5309
5310 v0428:
5311 v0362 = stack[-2];
5312 v0361 = elt(env, 17); /* switch!* */
5313 v0361 = get(v0362, v0361);
5314 env = stack[-9];
5315 if (v0361 == nil) goto v0429;
5316 v0362 = stack[-2];
5317 v0361 = elt(env, 18); /* !( */
5318 if (v0362 == v0361) goto v0429;
5319 v0361 = qvalue(elt(env, 2)); /* nil */
5320 goto v0427;
5321
5322 v0429:
5323 v0362 = stack[-2];
5324 v0361 = elt(env, 6); /* infix */
5325 v0361 = get(v0362, v0361);
5326 env = stack[-9];
5327 if (v0361 == nil) goto v0430;
5328 v0361 = qvalue(elt(env, 2)); /* nil */
5329 goto v0427;
5330
5331 v0430:
5332 v0361 = qvalue(elt(env, 19)); /* !*eoldelimp */
5333 if (v0361 == nil) goto v0431;
5334 v0362 = stack[-2];
5335 v0361 = qvalue(elt(env, 15)); /* !$eol!$ */
5336 v0361 = (v0362 == v0361 ? lisp_true : nil);
5337 goto v0432;
5338
5339 v0432:
5340 v0361 = (v0361 == nil ? lisp_true : nil);
5341 goto v0427;
5342
5343 v0431:
5344 v0361 = qvalue(elt(env, 2)); /* nil */
5345 goto v0432;
5346
5347 v0425:
5348 v0361 = qvalue(elt(env, 2)); /* nil */
5349 goto v0427;
5350
5351 v0420:
5352 v0362 = stack[-3];
5353 v0361 = elt(env, 14); /* !:int!: */
5354 v0361 = Leqcar(nil, v0362, v0361);
5355 env = stack[-9];
5356 goto v0421;
5357
5358 v0411:
5359 v0362 = stack[-7];
5360 v0361 = elt(env, 21); /* proc */
5361 if (v0362 == v0361) goto v0433;
5362 v0362 = stack[-4];
5363 v0361 = elt(env, 45); /* endstatfn */
5364 v0361 = Lflagp(nil, v0362, v0361);
5365 env = stack[-9];
5366 if (v0361 == nil) goto v0434;
5367 v0361 = qvalue(elt(env, 13)); /* t */
5368 goto v0412;
5369
5370 v0434:
5371 v0362 = qvalue(elt(env, 16)); /* nxtsym!* */
5372 v0361 = elt(env, 46); /* delchar */
5373 v0361 = Lflagp(nil, v0362, v0361);
5374 env = stack[-9];
5375 if (v0361 == nil) goto v0435;
5376 v0361 = qvalue(elt(env, 2)); /* nil */
5377 goto v0412;
5378
5379 v0435:
5380 v0362 = qvalue(elt(env, 16)); /* nxtsym!* */
5381 v0361 = elt(env, 47); /* !, */
5382 v0361 = (v0362 == v0361 ? lisp_true : nil);
5383 v0361 = (v0361 == nil ? lisp_true : nil);
5384 goto v0412;
5385
5386 v0433:
5387 v0361 = qvalue(elt(env, 2)); /* nil */
5388 goto v0412;
5389
5390 v0109:
5391 v0361 = qvalue(elt(env, 9)); /* !*reduce4 */
5392 if (v0361 == nil) goto v0436;
5393 v0361 = qvalue(elt(env, 2)); /* nil */
5394 goto v0044;
5395
5396 v0044:
5397 if (v0361 == nil) goto v0032;
5398 v0362 = elt(env, 11); /* decstat */
5399 v0361 = qvalue(elt(env, 2)); /* nil */
5400 fn = elt(env, 63); /* lispapply */
5401 v0362 = (*qfn2(fn))(qenv(fn), v0362, v0361);
5402 nil = C_nil;
5403 if (exception_pending()) goto v0365;
5404 env = stack[-9];
5405 v0361 = stack[-6];
5406 v0361 = cons(v0362, v0361);
5407 nil = C_nil;
5408 if (exception_pending()) goto v0365;
5409 env = stack[-9];
5410 stack[-6] = v0361;
5411 goto v0030;
5412
5413 v0436:
5414 v0362 = stack[-3];
5415 v0361 = elt(env, 10); /* type */
5416 v0361 = Lflagp(nil, v0362, v0361);
5417 env = stack[-9];
5418 goto v0044;
5419
5420 v0064:
5421 fn = elt(env, 57); /* eolcheck */
5422 v0361 = (*qfnn(fn))(qenv(fn), 0);
5423 nil = C_nil;
5424 if (exception_pending()) goto v0365;
5425 env = stack[-9];
5426 v0362 = stack[-3];
5427 v0361 = elt(env, 25); /* !*comma!* */
5428 if (v0362 == v0361) goto v0437;
5429 fn = elt(env, 60); /* scan */
5430 v0361 = (*qfnn(fn))(qenv(fn), 0);
5431 nil = C_nil;
5432 if (exception_pending()) goto v0365;
5433 env = stack[-9];
5434 stack[-2] = v0361;
5435 if (!consp(v0361)) goto v0438;
5436 v0361 = qvalue(elt(env, 13)); /* t */
5437 goto v0439;
5438
5439 v0439:
5440 if (!(v0361 == nil)) goto v0019;
5441 v0362 = stack[-2];
5442 v0361 = elt(env, 5); /* !*rpar!* */
5443 if (v0362 == v0361) goto v0440;
5444 v0362 = stack[-2];
5445 v0361 = elt(env, 25); /* !*comma!* */
5446 if (v0362 == v0361) goto v0441;
5447 v0362 = stack[-2];
5448 v0361 = elt(env, 7); /* delim */
5449 v0361 = Lflagp(nil, v0362, v0361);
5450 env = stack[-9];
5451 goto v0442;
5452
5453 v0442:
5454 if (v0361 == nil) goto v0443;
5455 v0361 = stack[-4];
5456 if (v0361 == nil) goto v0444;
5457 v0361 = qvalue(elt(env, 2)); /* nil */
5458 stack[-4] = v0361;
5459 goto v0444;
5460
5461 v0444:
5462 v0362 = stack[-3];
5463 v0361 = stack[-6];
5464 v0361 = cons(v0362, v0361);
5465 nil = C_nil;
5466 if (exception_pending()) goto v0365;
5467 env = stack[-9];
5468 stack[-6] = v0361;
5469 goto v0025;
5470
5471 v0443:
5472 v0362 = stack[-2];
5473 v0361 = elt(env, 4); /* !*lpar!* */
5474 if (v0362 == v0361) goto v0445;
5475 v0361 = qvalue(elt(env, 2)); /* nil */
5476 goto v0446;
5477
5478 v0446:
5479 if (!(v0361 == nil)) goto v0031;
5480
5481 v0019:
5482 v0361 = stack[-6];
5483 if (!(v0361 == nil)) goto v0023;
5484 v0362 = stack[-3];
5485 v0361 = elt(env, 31); /* unary */
5486 v0361 = get(v0362, v0361);
5487 env = stack[-9];
5488 stack[-3] = v0361;
5489 if (!(v0361 == nil)) goto v0447;
5490 v0362 = elt(env, 32); /* "Redundant operator" */
5491 v0361 = qvalue(elt(env, 2)); /* nil */
5492 fn = elt(env, 58); /* symerr */
5493 v0361 = (*qfn2(fn))(qenv(fn), v0362, v0361);
5494 nil = C_nil;
5495 if (exception_pending()) goto v0365;
5496 env = stack[-9];
5497 goto v0447;
5498
5499 v0447:
5500 v0362 = elt(env, 33); /* !*!*un!*!* */
5501 v0361 = stack[-8];
5502 v0361 = cons(v0362, v0361);
5503 nil = C_nil;
5504 if (exception_pending()) goto v0365;
5505 env = stack[-9];
5506 stack[-8] = v0361;
5507 goto v0386;
5508
5509 v0445:
5510 fn = elt(env, 57); /* eolcheck */
5511 v0361 = (*qfnn(fn))(qenv(fn), 0);
5512 nil = C_nil;
5513 if (exception_pending()) goto v0365;
5514 env = stack[-9];
5515 if (v0361 == nil) goto v0448;
5516 v0361 = qvalue(elt(env, 2)); /* nil */
5517 goto v0446;
5518
5519 v0448:
5520 fn = elt(env, 60); /* scan */
5521 v0361 = (*qfnn(fn))(qenv(fn), 0);
5522 nil = C_nil;
5523 if (exception_pending()) goto v0365;
5524 env = stack[-9];
5525 v0361 = qvalue(elt(env, 19)); /* !*eoldelimp */
5526 if (v0361 == nil) goto v0449;
5527 v0362 = qvalue(elt(env, 3)); /* cursym!* */
5528 v0361 = elt(env, 30); /* !*semicol!* */
5529 if (v0362 == v0361) goto v0448;
5530 else goto v0449;
5531
5532 v0449:
5533 v0361 = elt(env, 24); /* paren */
5534 v0361 = CC_xread1(env, v0361);
5535 nil = C_nil;
5536 if (exception_pending()) goto v0365;
5537 env = stack[-9];
5538 stack[-2] = v0361;
5539 if (!consp(v0361)) goto v0450;
5540 v0361 = stack[-2];
5541 v0362 = qcar(v0361);
5542 v0361 = elt(env, 25); /* !*comma!* */
5543 if (v0362 == v0361) goto v0451;
5544 v0361 = qvalue(elt(env, 2)); /* nil */
5545 goto v0446;
5546
5547 v0451:
5548 v0362 = stack[-3];
5549 v0361 = stack[-2];
5550 v0361 = qcdr(v0361);
5551 v0361 = cons(v0362, v0361);
5552 nil = C_nil;
5553 if (exception_pending()) goto v0365;
5554 env = stack[-9];
5555 stack[-3] = v0361;
5556 goto v0446;
5557
5558 v0450:
5559 v0361 = qvalue(elt(env, 2)); /* nil */
5560 goto v0446;
5561
5562 v0441:
5563 v0361 = qvalue(elt(env, 13)); /* t */
5564 goto v0442;
5565
5566 v0440:
5567 v0361 = qvalue(elt(env, 13)); /* t */
5568 goto v0442;
5569
5570 v0438:
5571 v0361 = stack[-2];
5572 v0361 = (is_number(v0361) ? lisp_true : nil);
5573 if (!(v0361 == nil)) goto v0439;
5574 v0362 = stack[-2];
5575 v0361 = elt(env, 12); /* !:dn!: */
5576 if (!consp(v0362)) goto v0452;
5577 v0362 = qcar(v0362);
5578 if (!(v0362 == v0361)) goto v0452;
5579 v0361 = qvalue(elt(env, 13)); /* t */
5580 goto v0439;
5581
5582 v0452:
5583 v0362 = stack[-2];
5584 v0361 = elt(env, 14); /* !:int!: */
5585 v0361 = Leqcar(nil, v0362, v0361);
5586 env = stack[-9];
5587 goto v0439;
5588
5589 v0437:
5590 v0361 = qvalue(elt(env, 13)); /* t */
5591 goto v0439;
5592
5593 v0018:
5594 v0361 = stack[-7];
5595 if (v0361 == nil) goto v0453;
5596 v0362 = stack[-7];
5597 v0361 = elt(env, 28); /* group */
5598 if (v0362 == v0361) goto v0454;
5599 v0362 = stack[-7];
5600 v0361 = elt(env, 21); /* proc */
5601 v0361 = (v0362 == v0361 ? lisp_true : nil);
5602 goto v0455;
5603
5604 v0455:
5605 if (v0361 == nil) goto v0024;
5606 v0362 = elt(env, 29); /* "Too many right parentheses" */
5607 v0361 = qvalue(elt(env, 2)); /* nil */
5608 fn = elt(env, 58); /* symerr */
5609 v0361 = (*qfn2(fn))(qenv(fn), v0362, v0361);
5610 nil = C_nil;
5611 if (exception_pending()) goto v0365;
5612 env = stack[-9];
5613 goto v0064;
5614
5615 v0454:
5616 v0361 = qvalue(elt(env, 13)); /* t */
5617 goto v0455;
5618
5619 v0453:
5620 v0361 = qvalue(elt(env, 13)); /* t */
5621 goto v0455;
5622
5623 v0006:
5624 fn = elt(env, 57); /* eolcheck */
5625 v0361 = (*qfnn(fn))(qenv(fn), 0);
5626 nil = C_nil;
5627 if (exception_pending()) goto v0365;
5628 env = stack[-9];
5629 v0361 = qvalue(elt(env, 2)); /* nil */
5630 stack[-4] = v0361;
5631 fn = elt(env, 60); /* scan */
5632 v0362 = (*qfnn(fn))(qenv(fn), 0);
5633 nil = C_nil;
5634 if (exception_pending()) goto v0365;
5635 env = stack[-9];
5636 v0361 = elt(env, 5); /* !*rpar!* */
5637 if (v0362 == v0361) goto v0017;
5638 v0362 = stack[-6];
5639 v0361 = elt(env, 23); /* struct */
5640 v0361 = Lflagpcar(nil, v0362, v0361);
5641 env = stack[-9];
5642 if (v0361 == nil) goto v0456;
5643 v0361 = stack[-6];
5644 v0361 = qcar(v0361);
5645 v0361 = CC_xread1(env, v0361);
5646 nil = C_nil;
5647 if (exception_pending()) goto v0365;
5648 env = stack[-9];
5649 stack[-3] = v0361;
5650 goto v0457;
5651
5652 v0457:
5653 v0362 = stack[-7];
5654 v0361 = elt(env, 23); /* struct */
5655 v0361 = Lflagp(nil, v0362, v0361);
5656 env = stack[-9];
5657 if (v0361 == nil) goto v0458;
5658 v0362 = stack[-3];
5659 v0361 = elt(env, 25); /* !*comma!* */
5660 if (!consp(v0362)) goto v0459;
5661 v0362 = qcar(v0362);
5662 if (!(v0362 == v0361)) goto v0459;
5663 v0361 = stack[-3];
5664 v0361 = qcdr(v0361);
5665 goto v0460;
5666
5667 v0460:
5668 stack[-3] = v0361;
5669 goto v0036;
5670
5671 v0459:
5672 v0361 = stack[-3];
5673 v0361 = ncons(v0361);
5674 nil = C_nil;
5675 if (exception_pending()) goto v0365;
5676 env = stack[-9];
5677 goto v0460;
5678
5679 v0458:
5680 v0362 = stack[-3];
5681 v0361 = elt(env, 25); /* !*comma!* */
5682 if (!consp(v0362)) goto v0036;
5683 v0362 = qcar(v0362);
5684 if (!(v0362 == v0361)) goto v0036;
5685 v0361 = stack[-6];
5686 if (v0361 == nil) goto v0461;
5687 v0361 = stack[-6];
5688 v0363 = qcar(v0361);
5689 v0361 = stack[-3];
5690 v0362 = qcdr(v0361);
5691 v0361 = stack[-6];
5692 v0361 = qcdr(v0361);
5693 v0361 = acons(v0363, v0362, v0361);
5694 nil = C_nil;
5695 if (exception_pending()) goto v0365;
5696 env = stack[-9];
5697 stack[-6] = v0361;
5698 goto v0005;
5699
5700 v0461:
5701 v0362 = stack[-7];
5702 v0361 = elt(env, 26); /* lambda */
5703 if (v0362 == v0361) goto v0036;
5704 v0362 = elt(env, 27); /* "Improper delimiter" */
5705 v0361 = qvalue(elt(env, 2)); /* nil */
5706 fn = elt(env, 58); /* symerr */
5707 v0361 = (*qfn2(fn))(qenv(fn), v0362, v0361);
5708 nil = C_nil;
5709 if (exception_pending()) goto v0365;
5710 env = stack[-9];
5711 goto v0005;
5712
5713 v0456:
5714 v0361 = elt(env, 24); /* paren */
5715 v0361 = CC_xread1(env, v0361);
5716 nil = C_nil;
5717 if (exception_pending()) goto v0365;
5718 env = stack[-9];
5719 stack[-3] = v0361;
5720 goto v0457;
5721
5722 v0017:
5723 v0361 = stack[-6];
5724 if (v0361 == nil) goto v0005;
5725 v0361 = stack[-6];
5726 v0361 = qcar(v0361);
5727 v0362 = ncons(v0361);
5728 nil = C_nil;
5729 if (exception_pending()) goto v0365;
5730 env = stack[-9];
5731 v0361 = stack[-6];
5732 v0361 = qcdr(v0361);
5733 v0361 = cons(v0362, v0361);
5734 nil = C_nil;
5735 if (exception_pending()) goto v0365;
5736 env = stack[-9];
5737 stack[-6] = v0361;
5738 goto v0005;
5739 /* error exit handlers */
5740 v0365:
5741 popv(10);
5742 return nil;
5743 }
5744
5745
5746
5747 /* Code for cl_atfp */
5748
CC_cl_atfp(Lisp_Object env,Lisp_Object v0000)5749 static Lisp_Object CC_cl_atfp(Lisp_Object env,
5750 Lisp_Object v0000)
5751 {
5752 Lisp_Object nil = C_nil;
5753 Lisp_Object v0472, v0473, v0474;
5754 CSL_IGNORE(nil);
5755 #ifdef DEBUG
5756 if (check_env(env)) return aerror("env for cl_atfp");
5757 #endif
5758 if (stack >= stacklimit)
5759 {
5760 push(v0000);
5761 env = reclaim(env, "stack", GC_STACK, 0);
5762 pop(v0000);
5763 nil = C_nil;
5764 if (exception_pending()) return nil;
5765 }
5766 CSL_IGNORE(env);
5767 /* copy arguments values to proper place */
5768 v0473 = v0000;
5769 /* end of prologue */
5770 v0472 = v0473;
5771 if (!consp(v0472)) goto v0021;
5772 v0472 = v0473;
5773 v0472 = qcar(v0472);
5774 goto v0080;
5775
5776 v0080:
5777 v0474 = v0472;
5778 v0473 = v0474;
5779 v0472 = elt(env, 1); /* true */
5780 if (v0473 == v0472) goto v0018;
5781 v0473 = v0474;
5782 v0472 = elt(env, 3); /* false */
5783 v0472 = (v0473 == v0472 ? lisp_true : nil);
5784 goto v0017;
5785
5786 v0017:
5787 if (v0472 == nil) goto v0130;
5788 v0472 = qvalue(elt(env, 2)); /* t */
5789 goto v0032;
5790
5791 v0032:
5792 v0472 = (v0472 == nil ? lisp_true : nil);
5793 return onevalue(v0472);
5794
5795 v0130:
5796 v0473 = v0474;
5797 v0472 = elt(env, 4); /* or */
5798 if (v0473 == v0472) goto v0092;
5799 v0473 = v0474;
5800 v0472 = elt(env, 5); /* and */
5801 v0472 = (v0473 == v0472 ? lisp_true : nil);
5802 goto v0119;
5803
5804 v0119:
5805 if (v0472 == nil) goto v0102;
5806 v0472 = qvalue(elt(env, 2)); /* t */
5807 goto v0008;
5808
5809 v0008:
5810 if (v0472 == nil) goto v0047;
5811 v0472 = qvalue(elt(env, 2)); /* t */
5812 goto v0118;
5813
5814 v0118:
5815 if (v0472 == nil) goto v0056;
5816 v0472 = qvalue(elt(env, 2)); /* t */
5817 goto v0032;
5818
5819 v0056:
5820 v0473 = v0474;
5821 v0472 = elt(env, 10); /* ex */
5822 if (v0473 == v0472) goto v0037;
5823 v0473 = v0474;
5824 v0472 = elt(env, 11); /* all */
5825 v0472 = (v0473 == v0472 ? lisp_true : nil);
5826 goto v0113;
5827
5828 v0113:
5829 if (v0472 == nil) goto v0099;
5830 v0472 = qvalue(elt(env, 2)); /* t */
5831 goto v0032;
5832
5833 v0099:
5834 v0473 = v0474;
5835 v0472 = elt(env, 12); /* bex */
5836 if (v0473 == v0472) goto v0475;
5837 v0473 = v0474;
5838 v0472 = elt(env, 13); /* ball */
5839 v0472 = (v0473 == v0472 ? lisp_true : nil);
5840 goto v0476;
5841
5842 v0476:
5843 if (v0472 == nil) goto v0477;
5844 v0472 = qvalue(elt(env, 2)); /* t */
5845 goto v0032;
5846
5847 v0477:
5848 v0473 = v0474;
5849 v0472 = elt(env, 14); /* rl_external */
5850 v0472 = get(v0473, v0472);
5851 goto v0032;
5852
5853 v0475:
5854 v0472 = qvalue(elt(env, 2)); /* t */
5855 goto v0476;
5856
5857 v0037:
5858 v0472 = qvalue(elt(env, 2)); /* t */
5859 goto v0113;
5860
5861 v0047:
5862 v0473 = v0474;
5863 v0472 = elt(env, 7); /* impl */
5864 if (v0473 == v0472) goto v0478;
5865 v0473 = v0474;
5866 v0472 = elt(env, 8); /* repl */
5867 if (v0473 == v0472) goto v0045;
5868 v0473 = v0474;
5869 v0472 = elt(env, 9); /* equiv */
5870 v0472 = (v0473 == v0472 ? lisp_true : nil);
5871 goto v0118;
5872
5873 v0045:
5874 v0472 = qvalue(elt(env, 2)); /* t */
5875 goto v0118;
5876
5877 v0478:
5878 v0472 = qvalue(elt(env, 2)); /* t */
5879 goto v0118;
5880
5881 v0102:
5882 v0473 = v0474;
5883 v0472 = elt(env, 6); /* not */
5884 v0472 = (v0473 == v0472 ? lisp_true : nil);
5885 goto v0008;
5886
5887 v0092:
5888 v0472 = qvalue(elt(env, 2)); /* t */
5889 goto v0119;
5890
5891 v0018:
5892 v0472 = qvalue(elt(env, 2)); /* t */
5893 goto v0017;
5894
5895 v0021:
5896 v0472 = v0473;
5897 goto v0080;
5898 }
5899
5900
5901
5902 /* Code for ibalp_lenisone */
5903
CC_ibalp_lenisone(Lisp_Object env,Lisp_Object v0000)5904 static Lisp_Object CC_ibalp_lenisone(Lisp_Object env,
5905 Lisp_Object v0000)
5906 {
5907 Lisp_Object nil = C_nil;
5908 Lisp_Object v0031, v0032;
5909 CSL_IGNORE(nil);
5910 #ifdef DEBUG
5911 if (check_env(env)) return aerror("env for ibalp_lenisone");
5912 #endif
5913 CSL_IGNORE(env);
5914 /* copy arguments values to proper place */
5915 v0032 = v0000;
5916 /* end of prologue */
5917 v0031 = v0032;
5918 if (v0031 == nil) goto v0021;
5919 v0031 = v0032;
5920 v0031 = qcdr(v0031);
5921 v0031 = (v0031 == nil ? lisp_true : nil);
5922 return onevalue(v0031);
5923
5924 v0021:
5925 v0031 = qvalue(elt(env, 1)); /* nil */
5926 return onevalue(v0031);
5927 }
5928
5929
5930
5931 /* Code for numpoly_nullp */
5932
CC_numpoly_nullp(Lisp_Object env,Lisp_Object v0000)5933 static Lisp_Object CC_numpoly_nullp(Lisp_Object env,
5934 Lisp_Object v0000)
5935 {
5936 Lisp_Object nil = C_nil;
5937 Lisp_Object v0017, v0018;
5938 CSL_IGNORE(nil);
5939 #ifdef DEBUG
5940 if (check_env(env)) return aerror("env for numpoly_nullp");
5941 #endif
5942 CSL_IGNORE(env);
5943 /* copy arguments values to proper place */
5944 v0018 = v0000;
5945 /* end of prologue */
5946 v0017 = v0018;
5947 if (v0017 == nil) goto v0021;
5948 v0017 = (Lisp_Object)1; /* 0 */
5949 v0017 = (v0018 == v0017 ? lisp_true : nil);
5950 return onevalue(v0017);
5951
5952 v0021:
5953 v0017 = qvalue(elt(env, 1)); /* t */
5954 return onevalue(v0017);
5955 }
5956
5957
5958
5959 /* Code for inshisto */
5960
CC_inshisto(Lisp_Object env,Lisp_Object v0000)5961 static Lisp_Object CC_inshisto(Lisp_Object env,
5962 Lisp_Object v0000)
5963 {
5964 Lisp_Object nil = C_nil;
5965 Lisp_Object v0475, v0481, v0099;
5966 Lisp_Object fn;
5967 CSL_IGNORE(nil);
5968 #ifdef DEBUG
5969 if (check_env(env)) return aerror("env for inshisto");
5970 #endif
5971 if (stack >= stacklimit)
5972 {
5973 push(v0000);
5974 env = reclaim(env, "stack", GC_STACK, 0);
5975 pop(v0000);
5976 nil = C_nil;
5977 if (exception_pending()) return nil;
5978 }
5979 push(env);
5980 /* space for vars preserved across procedure calls */
5981 push5(nil, nil, nil, nil, nil);
5982 /* copy arguments values to proper place */
5983 stack[-3] = v0000;
5984 /* end of prologue */
5985 stack[0] = qvalue(elt(env, 1)); /* codmat */
5986 v0481 = qvalue(elt(env, 2)); /* maxvar */
5987 v0475 = stack[-3];
5988 v0475 = plus2(v0481, v0475);
5989 nil = C_nil;
5990 if (exception_pending()) goto v0465;
5991 env = stack[-5];
5992 v0481 = *(Lisp_Object *)((char *)stack[0] + (CELL-TAG_VECTOR) + ((int32_t)v0475/(16/CELL)));
5993 v0475 = (Lisp_Object)1; /* 0 */
5994 v0475 = *(Lisp_Object *)((char *)v0481 + (CELL-TAG_VECTOR) + ((int32_t)v0475/(16/CELL)));
5995 if (v0475 == nil) goto v0029;
5996 v0481 = stack[-3];
5997 v0475 = (Lisp_Object)1; /* 0 */
5998 v0475 = (Lisp_Object)geq2(v0481, v0475);
5999 nil = C_nil;
6000 if (exception_pending()) goto v0465;
6001 v0475 = v0475 ? lisp_true : nil;
6002 env = stack[-5];
6003 if (v0475 == nil) goto v0029;
6004 stack[0] = qvalue(elt(env, 3)); /* codhisto */
6005 stack[-1] = qvalue(elt(env, 1)); /* codmat */
6006 v0481 = qvalue(elt(env, 2)); /* maxvar */
6007 v0475 = stack[-3];
6008 v0475 = plus2(v0481, v0475);
6009 nil = C_nil;
6010 if (exception_pending()) goto v0465;
6011 env = stack[-5];
6012 v0481 = *(Lisp_Object *)((char *)stack[-1] + (CELL-TAG_VECTOR) + ((int32_t)v0475/(16/CELL)));
6013 v0475 = (Lisp_Object)17; /* 1 */
6014 v0475 = *(Lisp_Object *)((char *)v0481 + (CELL-TAG_VECTOR) + ((int32_t)v0475/(16/CELL)));
6015 v0481 = qcdr(v0475);
6016 v0475 = (Lisp_Object)3201; /* 200 */
6017 fn = elt(env, 6); /* min */
6018 v0475 = (*qfn2(fn))(qenv(fn), v0481, v0475);
6019 nil = C_nil;
6020 if (exception_pending()) goto v0465;
6021 env = stack[-5];
6022 stack[-2] = v0475;
6023 v0475 = *(Lisp_Object *)((char *)stack[0] + (CELL-TAG_VECTOR) + ((int32_t)v0475/(16/CELL)));
6024 stack[-4] = v0475;
6025 if (v0475 == nil) goto v0482;
6026 stack[0] = qvalue(elt(env, 1)); /* codmat */
6027 v0481 = qvalue(elt(env, 2)); /* maxvar */
6028 v0475 = stack[-4];
6029 v0475 = plus2(v0481, v0475);
6030 nil = C_nil;
6031 if (exception_pending()) goto v0465;
6032 env = stack[-5];
6033 v0481 = *(Lisp_Object *)((char *)stack[0] + (CELL-TAG_VECTOR) + ((int32_t)v0475/(16/CELL)));
6034 v0475 = (Lisp_Object)113; /* 7 */
6035 v0481 = *(Lisp_Object *)((char *)v0481 + (CELL-TAG_VECTOR) + ((int32_t)v0475/(16/CELL)));
6036 v0475 = stack[-3];
6037 v0475 = Lrplaca(nil, v0481, v0475);
6038 nil = C_nil;
6039 if (exception_pending()) goto v0465;
6040 env = stack[-5];
6041 goto v0072;
6042
6043 v0072:
6044 stack[0] = qvalue(elt(env, 1)); /* codmat */
6045 v0481 = qvalue(elt(env, 2)); /* maxvar */
6046 v0475 = stack[-3];
6047 v0475 = plus2(v0481, v0475);
6048 nil = C_nil;
6049 if (exception_pending()) goto v0465;
6050 env = stack[-5];
6051 stack[-1] = *(Lisp_Object *)((char *)stack[0] + (CELL-TAG_VECTOR) + ((int32_t)v0475/(16/CELL)));
6052 stack[0] = (Lisp_Object)113; /* 7 */
6053 v0481 = qvalue(elt(env, 5)); /* nil */
6054 v0475 = stack[-4];
6055 v0475 = cons(v0481, v0475);
6056 nil = C_nil;
6057 if (exception_pending()) goto v0465;
6058 env = stack[-5];
6059 *(Lisp_Object *)((char *)stack[-1] + (CELL-TAG_VECTOR) + ((int32_t)stack[0]/(16/CELL))) = v0475;
6060 v0099 = qvalue(elt(env, 3)); /* codhisto */
6061 v0481 = stack[-2];
6062 v0475 = stack[-3];
6063 *(Lisp_Object *)((char *)v0099 + (CELL-TAG_VECTOR) + ((int32_t)v0481/(16/CELL))) = v0475;
6064 v0475 = nil;
6065 { popv(6); return onevalue(v0475); }
6066
6067 v0482:
6068 v0481 = stack[-2];
6069 v0475 = qvalue(elt(env, 4)); /* headhisto */
6070 v0475 = (Lisp_Object)greaterp2(v0481, v0475);
6071 nil = C_nil;
6072 if (exception_pending()) goto v0465;
6073 v0475 = v0475 ? lisp_true : nil;
6074 env = stack[-5];
6075 if (v0475 == nil) goto v0072;
6076 v0475 = stack[-2];
6077 qvalue(elt(env, 4)) = v0475; /* headhisto */
6078 goto v0072;
6079
6080 v0029:
6081 v0475 = nil;
6082 { popv(6); return onevalue(v0475); }
6083 /* error exit handlers */
6084 v0465:
6085 popv(6);
6086 return nil;
6087 }
6088
6089
6090
6091 /* Code for evenfree */
6092
CC_evenfree(Lisp_Object env,Lisp_Object v0000)6093 static Lisp_Object CC_evenfree(Lisp_Object env,
6094 Lisp_Object v0000)
6095 {
6096 Lisp_Object nil = C_nil;
6097 Lisp_Object v0091, v0052;
6098 Lisp_Object fn;
6099 CSL_IGNORE(nil);
6100 #ifdef DEBUG
6101 if (check_env(env)) return aerror("env for evenfree");
6102 #endif
6103 if (stack >= stacklimit)
6104 {
6105 push(v0000);
6106 env = reclaim(env, "stack", GC_STACK, 0);
6107 pop(v0000);
6108 nil = C_nil;
6109 if (exception_pending()) return nil;
6110 }
6111 push(env);
6112 /* space for vars preserved across procedure calls */
6113 push2(nil, nil);
6114 /* copy arguments values to proper place */
6115 stack[0] = v0000;
6116 /* end of prologue */
6117 v0091 = stack[0];
6118 if (v0091 == nil) goto v0021;
6119 v0091 = stack[0];
6120 if (is_number(v0091)) goto v0030;
6121 v0091 = stack[0];
6122 v0091 = qcar(v0091);
6123 v0052 = ncons(v0091);
6124 nil = C_nil;
6125 if (exception_pending()) goto v0103;
6126 env = stack[-2];
6127 v0091 = (Lisp_Object)33; /* 2 */
6128 fn = elt(env, 2); /* qremd */
6129 v0091 = (*qfn2(fn))(qenv(fn), v0052, v0091);
6130 nil = C_nil;
6131 if (exception_pending()) goto v0103;
6132 env = stack[-2];
6133 v0091 = qcdr(v0091);
6134 stack[-1] = v0091;
6135 v0091 = stack[-1];
6136 fn = elt(env, 3); /* minusf */
6137 v0091 = (*qfn1(fn))(qenv(fn), v0091);
6138 nil = C_nil;
6139 if (exception_pending()) goto v0103;
6140 env = stack[-2];
6141 if (v0091 == nil) goto v0126;
6142 v0091 = stack[-1];
6143 fn = elt(env, 4); /* negf */
6144 v0091 = (*qfn1(fn))(qenv(fn), v0091);
6145 nil = C_nil;
6146 if (exception_pending()) goto v0103;
6147 env = stack[-2];
6148 stack[-1] = v0091;
6149 goto v0028;
6150
6151 v0028:
6152 v0091 = stack[0];
6153 v0091 = qcdr(v0091);
6154 v0091 = CC_evenfree(env, v0091);
6155 nil = C_nil;
6156 if (exception_pending()) goto v0103;
6157 env = stack[-2];
6158 {
6159 Lisp_Object v0059 = stack[-1];
6160 popv(3);
6161 fn = elt(env, 5); /* addf */
6162 return (*qfn2(fn))(qenv(fn), v0059, v0091);
6163 }
6164
6165 v0126:
6166 v0091 = stack[-1];
6167 stack[-1] = v0091;
6168 goto v0028;
6169
6170 v0030:
6171 v0052 = stack[0];
6172 v0091 = (Lisp_Object)33; /* 2 */
6173 fn = elt(env, 2); /* qremd */
6174 v0091 = (*qfn2(fn))(qenv(fn), v0052, v0091);
6175 nil = C_nil;
6176 if (exception_pending()) goto v0103;
6177 env = stack[-2];
6178 v0091 = qcdr(v0091);
6179 stack[0] = v0091;
6180 v0091 = stack[0];
6181 fn = elt(env, 3); /* minusf */
6182 v0091 = (*qfn1(fn))(qenv(fn), v0091);
6183 nil = C_nil;
6184 if (exception_pending()) goto v0103;
6185 env = stack[-2];
6186 if (v0091 == nil) { Lisp_Object res = stack[0]; popv(3); return onevalue(res); }
6187 v0091 = stack[0];
6188 {
6189 popv(3);
6190 fn = elt(env, 4); /* negf */
6191 return (*qfn1(fn))(qenv(fn), v0091);
6192 }
6193
6194 v0021:
6195 v0091 = qvalue(elt(env, 1)); /* nil */
6196 { popv(3); return onevalue(v0091); }
6197 /* error exit handlers */
6198 v0103:
6199 popv(3);
6200 return nil;
6201 }
6202
6203
6204
6205 /* Code for revalind */
6206
CC_revalind(Lisp_Object env,Lisp_Object v0000)6207 static Lisp_Object CC_revalind(Lisp_Object env,
6208 Lisp_Object v0000)
6209 {
6210 Lisp_Object nil = C_nil;
6211 Lisp_Object v0117, v0120, v0011;
6212 Lisp_Object fn;
6213 CSL_IGNORE(nil);
6214 #ifdef DEBUG
6215 if (check_env(env)) return aerror("env for revalind");
6216 #endif
6217 if (stack >= stacklimit)
6218 {
6219 push(v0000);
6220 env = reclaim(env, "stack", GC_STACK, 0);
6221 pop(v0000);
6222 nil = C_nil;
6223 if (exception_pending()) return nil;
6224 }
6225 push(env);
6226 /* space for vars preserved across procedure calls */
6227 push3(nil, nil, nil);
6228 /* copy arguments values to proper place */
6229 stack[-1] = v0000;
6230 /* end of prologue */
6231 stack[0] = qvalue(elt(env, 1)); /* alglist!* */
6232 qvalue(elt(env, 1)) = nil; /* alglist!* */
6233 v0117 = qvalue(elt(env, 2)); /* nil */
6234 v0117 = ncons(v0117);
6235 nil = C_nil;
6236 if (exception_pending()) goto v0007;
6237 env = stack[-3];
6238 qvalue(elt(env, 1)) = v0117; /* alglist!* */
6239 v0117 = qvalue(elt(env, 3)); /* subfg!* */
6240 stack[-2] = v0117;
6241 v0117 = qvalue(elt(env, 2)); /* nil */
6242 qvalue(elt(env, 3)) = v0117; /* subfg!* */
6243 v0011 = elt(env, 4); /* !0 */
6244 v0120 = (Lisp_Object)1; /* 0 */
6245 v0117 = stack[-1];
6246 v0117 = Lsubst(nil, 3, v0011, v0120, v0117);
6247 nil = C_nil;
6248 if (exception_pending()) goto v0007;
6249 env = stack[-3];
6250 stack[-1] = v0117;
6251 v0117 = stack[-1];
6252 fn = elt(env, 6); /* simp */
6253 v0117 = (*qfn1(fn))(qenv(fn), v0117);
6254 nil = C_nil;
6255 if (exception_pending()) goto v0007;
6256 env = stack[-3];
6257 v0120 = v0117;
6258 v0117 = v0120;
6259 v0117 = qcar(v0117);
6260 if (v0117 == nil) goto v0065;
6261 v0117 = elt(env, 5); /* prepf */
6262 fn = elt(env, 7); /* sqform */
6263 v0117 = (*qfn2(fn))(qenv(fn), v0120, v0117);
6264 nil = C_nil;
6265 if (exception_pending()) goto v0007;
6266 env = stack[-3];
6267 goto v0067;
6268
6269 v0067:
6270 v0120 = v0117;
6271 v0117 = stack[-2];
6272 qvalue(elt(env, 3)) = v0117; /* subfg!* */
6273 v0117 = v0120;
6274 qvalue(elt(env, 1)) = stack[0]; /* alglist!* */
6275 { popv(4); return onevalue(v0117); }
6276
6277 v0065:
6278 v0117 = (Lisp_Object)1; /* 0 */
6279 goto v0067;
6280 /* error exit handlers */
6281 v0007:
6282 env = stack[-3];
6283 qvalue(elt(env, 1)) = stack[0]; /* alglist!* */
6284 popv(4);
6285 return nil;
6286 }
6287
6288
6289
6290 /* Code for all_defined_vertex */
6291
CC_all_defined_vertex(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)6292 static Lisp_Object CC_all_defined_vertex(Lisp_Object env,
6293 Lisp_Object v0000, Lisp_Object v0016)
6294 {
6295 Lisp_Object nil = C_nil;
6296 Lisp_Object v0006, v0017, v0018, v0064;
6297 Lisp_Object fn;
6298 CSL_IGNORE(nil);
6299 #ifdef DEBUG
6300 if (check_env(env)) return aerror("env for all_defined_vertex");
6301 #endif
6302 CSL_IGNORE(env);
6303 /* copy arguments values to proper place */
6304 v0006 = v0016;
6305 v0017 = v0000;
6306 /* end of prologue */
6307 v0064 = v0017;
6308 v0018 = qvalue(elt(env, 1)); /* nil */
6309 v0017 = qvalue(elt(env, 1)); /* nil */
6310 {
6311 fn = elt(env, 2); /* al1_defined_vertex */
6312 return (*qfnn(fn))(qenv(fn), 4, v0064, v0018, v0017, v0006);
6313 }
6314 }
6315
6316
6317
6318 /* Code for getmatelem */
6319
CC_getmatelem(Lisp_Object env,Lisp_Object v0000)6320 static Lisp_Object CC_getmatelem(Lisp_Object env,
6321 Lisp_Object v0000)
6322 {
6323 Lisp_Object nil = C_nil;
6324 Lisp_Object v0491, v0492, v0493;
6325 Lisp_Object fn;
6326 CSL_IGNORE(nil);
6327 #ifdef DEBUG
6328 if (check_env(env)) return aerror("env for getmatelem");
6329 #endif
6330 if (stack >= stacklimit)
6331 {
6332 push(v0000);
6333 env = reclaim(env, "stack", GC_STACK, 0);
6334 pop(v0000);
6335 nil = C_nil;
6336 if (exception_pending()) return nil;
6337 }
6338 push(env);
6339 /* space for vars preserved across procedure calls */
6340 push3(nil, nil, nil);
6341 /* copy arguments values to proper place */
6342 stack[-1] = v0000;
6343 /* end of prologue */
6344
6345 v0014:
6346 v0491 = stack[-1];
6347 v0492 = Llength(nil, v0491);
6348 nil = C_nil;
6349 if (exception_pending()) goto v0494;
6350 env = stack[-3];
6351 v0491 = (Lisp_Object)49; /* 3 */
6352 if (v0492 == v0491) goto v0065;
6353 v0492 = stack[-1];
6354 v0491 = elt(env, 1); /* "matrix element" */
6355 fn = elt(env, 12); /* typerr */
6356 v0491 = (*qfn2(fn))(qenv(fn), v0492, v0491);
6357 nil = C_nil;
6358 if (exception_pending()) goto v0494;
6359 env = stack[-3];
6360 goto v0065;
6361
6362 v0065:
6363 v0491 = stack[-1];
6364 v0492 = qcar(v0491);
6365 v0491 = elt(env, 2); /* avalue */
6366 v0491 = get(v0492, v0491);
6367 env = stack[-3];
6368 stack[-2] = v0491;
6369 v0491 = stack[-2];
6370 if (v0491 == nil) goto v0090;
6371 v0491 = stack[-2];
6372 v0492 = qcar(v0491);
6373 v0491 = elt(env, 4); /* matrix */
6374 v0491 = (v0492 == v0491 ? lisp_true : nil);
6375 v0491 = (v0491 == nil ? lisp_true : nil);
6376 goto v0069;
6377
6378 v0069:
6379 if (v0491 == nil) goto v0480;
6380 v0491 = stack[-1];
6381 v0492 = qcar(v0491);
6382 v0491 = elt(env, 5); /* "matrix" */
6383 fn = elt(env, 12); /* typerr */
6384 v0491 = (*qfn2(fn))(qenv(fn), v0492, v0491);
6385 nil = C_nil;
6386 if (exception_pending()) goto v0494;
6387 env = stack[-3];
6388 goto v0027;
6389
6390 v0027:
6391 v0491 = stack[-1];
6392 v0491 = qcdr(v0491);
6393 v0491 = qcar(v0491);
6394 fn = elt(env, 13); /* reval_without_mod */
6395 v0491 = (*qfn1(fn))(qenv(fn), v0491);
6396 nil = C_nil;
6397 if (exception_pending()) goto v0494;
6398 env = stack[-3];
6399 stack[0] = v0491;
6400 v0491 = stack[0];
6401 v0491 = integerp(v0491);
6402 if (v0491 == nil) goto v0084;
6403 v0492 = stack[0];
6404 v0491 = (Lisp_Object)1; /* 0 */
6405 v0491 = (Lisp_Object)lesseq2(v0492, v0491);
6406 nil = C_nil;
6407 if (exception_pending()) goto v0494;
6408 v0491 = v0491 ? lisp_true : nil;
6409 env = stack[-3];
6410 goto v0083;
6411
6412 v0083:
6413 if (v0491 == nil) goto v0467;
6414 v0492 = stack[0];
6415 v0491 = elt(env, 11); /* "positive integer" */
6416 fn = elt(env, 12); /* typerr */
6417 v0491 = (*qfn2(fn))(qenv(fn), v0492, v0491);
6418 nil = C_nil;
6419 if (exception_pending()) goto v0494;
6420 env = stack[-3];
6421 goto v0467;
6422
6423 v0467:
6424 v0491 = stack[-2];
6425 v0492 = qcdr(v0491);
6426 v0491 = stack[0];
6427 fn = elt(env, 14); /* pnth */
6428 v0491 = (*qfn2(fn))(qenv(fn), v0492, v0491);
6429 nil = C_nil;
6430 if (exception_pending()) goto v0494;
6431 env = stack[-3];
6432 v0491 = qcar(v0491);
6433 stack[-2] = v0491;
6434 v0491 = stack[-1];
6435 v0491 = qcdr(v0491);
6436 v0491 = qcdr(v0491);
6437 v0491 = qcar(v0491);
6438 fn = elt(env, 13); /* reval_without_mod */
6439 v0491 = (*qfn1(fn))(qenv(fn), v0491);
6440 nil = C_nil;
6441 if (exception_pending()) goto v0494;
6442 env = stack[-3];
6443 stack[0] = v0491;
6444 v0491 = stack[0];
6445 v0491 = integerp(v0491);
6446 if (v0491 == nil) goto v0495;
6447 v0492 = stack[0];
6448 v0491 = (Lisp_Object)1; /* 0 */
6449 v0491 = (Lisp_Object)lesseq2(v0492, v0491);
6450 nil = C_nil;
6451 if (exception_pending()) goto v0494;
6452 v0491 = v0491 ? lisp_true : nil;
6453 env = stack[-3];
6454 goto v0465;
6455
6456 v0465:
6457 if (v0491 == nil) goto v0473;
6458 v0492 = stack[0];
6459 v0491 = elt(env, 11); /* "positive integer" */
6460 fn = elt(env, 12); /* typerr */
6461 v0491 = (*qfn2(fn))(qenv(fn), v0492, v0491);
6462 nil = C_nil;
6463 if (exception_pending()) goto v0494;
6464 env = stack[-3];
6465 goto v0473;
6466
6467 v0473:
6468 v0492 = stack[-2];
6469 v0491 = stack[0];
6470 fn = elt(env, 14); /* pnth */
6471 v0491 = (*qfn2(fn))(qenv(fn), v0492, v0491);
6472 nil = C_nil;
6473 if (exception_pending()) goto v0494;
6474 v0491 = qcar(v0491);
6475 { popv(4); return onevalue(v0491); }
6476
6477 v0495:
6478 v0491 = qvalue(elt(env, 3)); /* t */
6479 goto v0465;
6480
6481 v0084:
6482 v0491 = qvalue(elt(env, 3)); /* t */
6483 goto v0083;
6484
6485 v0480:
6486 v0491 = stack[-2];
6487 v0491 = qcdr(v0491);
6488 v0492 = qcar(v0491);
6489 stack[-2] = v0492;
6490 v0491 = elt(env, 6); /* mat */
6491 if (!consp(v0492)) goto v0091;
6492 v0492 = qcar(v0492);
6493 if (v0492 == v0491) goto v0027;
6494 else goto v0091;
6495
6496 v0091:
6497 v0491 = stack[-2];
6498 if (symbolp(v0491)) goto v0359;
6499 v0493 = elt(env, 7); /* "Matrix" */
6500 v0491 = stack[-1];
6501 v0492 = qcar(v0491);
6502 v0491 = elt(env, 8); /* "not set" */
6503 v0491 = list3(v0493, v0492, v0491);
6504 nil = C_nil;
6505 if (exception_pending()) goto v0494;
6506 env = stack[-3];
6507 v0492 = v0491;
6508 v0491 = v0492;
6509 qvalue(elt(env, 9)) = v0491; /* errmsg!* */
6510 v0491 = qvalue(elt(env, 10)); /* !*protfg */
6511 if (!(v0491 == nil)) goto v0496;
6512 v0491 = v0492;
6513 fn = elt(env, 15); /* lprie */
6514 v0491 = (*qfn1(fn))(qenv(fn), v0491);
6515 nil = C_nil;
6516 if (exception_pending()) goto v0494;
6517 env = stack[-3];
6518 goto v0496;
6519
6520 v0496:
6521 v0491 = Lerror0(nil, 0);
6522 nil = C_nil;
6523 if (exception_pending()) goto v0494;
6524 env = stack[-3];
6525 goto v0027;
6526
6527 v0359:
6528 v0492 = stack[-2];
6529 v0491 = stack[-1];
6530 v0491 = qcdr(v0491);
6531 v0491 = cons(v0492, v0491);
6532 nil = C_nil;
6533 if (exception_pending()) goto v0494;
6534 env = stack[-3];
6535 stack[-1] = v0491;
6536 goto v0014;
6537
6538 v0090:
6539 v0491 = qvalue(elt(env, 3)); /* t */
6540 goto v0069;
6541 /* error exit handlers */
6542 v0494:
6543 popv(4);
6544 return nil;
6545 }
6546
6547
6548
6549 /* Code for b!:extadd */
6550
CC_bTextadd(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)6551 static Lisp_Object CC_bTextadd(Lisp_Object env,
6552 Lisp_Object v0000, Lisp_Object v0016)
6553 {
6554 Lisp_Object nil = C_nil;
6555 Lisp_Object v0113, v0037, v0055;
6556 Lisp_Object fn;
6557 CSL_IGNORE(nil);
6558 #ifdef DEBUG
6559 if (check_env(env)) return aerror("env for b:extadd");
6560 #endif
6561 if (stack >= stacklimit)
6562 {
6563 push2(v0016,v0000);
6564 env = reclaim(env, "stack", GC_STACK, 0);
6565 pop2(v0000,v0016);
6566 nil = C_nil;
6567 if (exception_pending()) return nil;
6568 }
6569 push(env);
6570 /* space for vars preserved across procedure calls */
6571 push4(nil, nil, nil, nil);
6572 /* copy arguments values to proper place */
6573 stack[-1] = v0016;
6574 stack[-2] = v0000;
6575 /* end of prologue */
6576 stack[0] = nil;
6577 goto v0121;
6578
6579 v0121:
6580 v0113 = stack[-2];
6581 if (v0113 == nil) goto v0031;
6582 v0113 = stack[-1];
6583 if (v0113 == nil) goto v0023;
6584 v0113 = stack[-2];
6585 v0113 = qcar(v0113);
6586 v0037 = qcar(v0113);
6587 v0113 = stack[-1];
6588 v0113 = qcar(v0113);
6589 v0113 = qcar(v0113);
6590 if (equal(v0037, v0113)) goto v0120;
6591 v0113 = stack[-2];
6592 v0113 = qcar(v0113);
6593 v0037 = qcar(v0113);
6594 v0113 = stack[-1];
6595 v0113 = qcar(v0113);
6596 v0113 = qcar(v0113);
6597 fn = elt(env, 1); /* b!:ordexp */
6598 v0113 = (*qfn2(fn))(qenv(fn), v0037, v0113);
6599 nil = C_nil;
6600 if (exception_pending()) goto v0073;
6601 env = stack[-4];
6602 if (v0113 == nil) goto v0039;
6603 v0113 = stack[-2];
6604 v0037 = qcar(v0113);
6605 v0113 = stack[0];
6606 v0113 = cons(v0037, v0113);
6607 nil = C_nil;
6608 if (exception_pending()) goto v0073;
6609 env = stack[-4];
6610 stack[0] = v0113;
6611 v0113 = stack[-2];
6612 v0113 = qcdr(v0113);
6613 stack[-2] = v0113;
6614 goto v0121;
6615
6616 v0039:
6617 v0113 = stack[-1];
6618 v0037 = qcar(v0113);
6619 v0113 = stack[0];
6620 v0113 = cons(v0037, v0113);
6621 nil = C_nil;
6622 if (exception_pending()) goto v0073;
6623 env = stack[-4];
6624 stack[0] = v0113;
6625 v0113 = stack[-1];
6626 v0113 = qcdr(v0113);
6627 stack[-1] = v0113;
6628 goto v0121;
6629
6630 v0120:
6631 stack[-3] = stack[0];
6632 v0113 = stack[-2];
6633 v0113 = qcar(v0113);
6634 v0037 = qcdr(v0113);
6635 v0113 = stack[-1];
6636 v0113 = qcar(v0113);
6637 v0113 = qcdr(v0113);
6638 fn = elt(env, 2); /* addf */
6639 stack[0] = (*qfn2(fn))(qenv(fn), v0037, v0113);
6640 nil = C_nil;
6641 if (exception_pending()) goto v0073;
6642 env = stack[-4];
6643 v0113 = stack[-2];
6644 v0037 = qcdr(v0113);
6645 v0113 = stack[-1];
6646 v0113 = qcdr(v0113);
6647 v0113 = CC_bTextadd(env, v0037, v0113);
6648 nil = C_nil;
6649 if (exception_pending()) goto v0073;
6650 env = stack[-4];
6651 v0037 = stack[0];
6652 v0055 = v0037;
6653 if (v0055 == nil) goto v0041;
6654 v0055 = stack[-2];
6655 v0055 = qcar(v0055);
6656 v0055 = qcar(v0055);
6657 v0113 = acons(v0055, v0037, v0113);
6658 nil = C_nil;
6659 if (exception_pending()) goto v0073;
6660 env = stack[-4];
6661 goto v0041;
6662
6663 v0041:
6664 {
6665 Lisp_Object v0074 = stack[-3];
6666 popv(5);
6667 fn = elt(env, 3); /* nreverse */
6668 return (*qfn2(fn))(qenv(fn), v0074, v0113);
6669 }
6670
6671 v0023:
6672 v0037 = stack[0];
6673 v0113 = stack[-2];
6674 {
6675 popv(5);
6676 fn = elt(env, 3); /* nreverse */
6677 return (*qfn2(fn))(qenv(fn), v0037, v0113);
6678 }
6679
6680 v0031:
6681 v0037 = stack[0];
6682 v0113 = stack[-1];
6683 {
6684 popv(5);
6685 fn = elt(env, 3); /* nreverse */
6686 return (*qfn2(fn))(qenv(fn), v0037, v0113);
6687 }
6688 /* error exit handlers */
6689 v0073:
6690 popv(5);
6691 return nil;
6692 }
6693
6694
6695
6696 /* Code for negate!-term */
6697
CC_negateKterm(Lisp_Object env,Lisp_Object v0000)6698 static Lisp_Object CC_negateKterm(Lisp_Object env,
6699 Lisp_Object v0000)
6700 {
6701 Lisp_Object nil = C_nil;
6702 Lisp_Object v0031, v0032;
6703 Lisp_Object fn;
6704 CSL_IGNORE(nil);
6705 #ifdef DEBUG
6706 if (check_env(env)) return aerror("env for negate-term");
6707 #endif
6708 if (stack >= stacklimit)
6709 {
6710 push(v0000);
6711 env = reclaim(env, "stack", GC_STACK, 0);
6712 pop(v0000);
6713 nil = C_nil;
6714 if (exception_pending()) return nil;
6715 }
6716 CSL_IGNORE(env);
6717 /* space for vars preserved across procedure calls */
6718 push(nil);
6719 /* copy arguments values to proper place */
6720 v0032 = v0000;
6721 /* end of prologue */
6722 v0031 = v0032;
6723 stack[0] = qcar(v0031);
6724 v0031 = v0032;
6725 v0031 = qcdr(v0031);
6726 fn = elt(env, 1); /* minus!-mod!-p */
6727 v0031 = (*qfn1(fn))(qenv(fn), v0031);
6728 nil = C_nil;
6729 if (exception_pending()) goto v0005;
6730 {
6731 Lisp_Object v0006 = stack[0];
6732 popv(1);
6733 return cons(v0006, v0031);
6734 }
6735 /* error exit handlers */
6736 v0005:
6737 popv(1);
6738 return nil;
6739 }
6740
6741
6742
6743 /* Code for defineargs */
6744
CC_defineargs(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)6745 static Lisp_Object CC_defineargs(Lisp_Object env,
6746 Lisp_Object v0000, Lisp_Object v0016)
6747 {
6748 Lisp_Object nil = C_nil;
6749 Lisp_Object v0111, v0110, v0128, v0087;
6750 Lisp_Object fn;
6751 CSL_IGNORE(nil);
6752 #ifdef DEBUG
6753 if (check_env(env)) return aerror("env for defineargs");
6754 #endif
6755 if (stack >= stacklimit)
6756 {
6757 push2(v0016,v0000);
6758 env = reclaim(env, "stack", GC_STACK, 0);
6759 pop2(v0000,v0016);
6760 nil = C_nil;
6761 if (exception_pending()) return nil;
6762 }
6763 push(env);
6764 /* space for vars preserved across procedure calls */
6765 push2(nil, nil);
6766 /* copy arguments values to proper place */
6767 stack[0] = v0016;
6768 stack[-1] = v0000;
6769 /* end of prologue */
6770 v0110 = stack[-1];
6771 v0111 = elt(env, 1); /* number!-of!-args */
6772 v0111 = get(v0110, v0111);
6773 env = stack[-2];
6774 v0110 = v0111;
6775 v0111 = v0110;
6776 if (v0111 == nil) goto v0019;
6777 v0128 = stack[0];
6778 v0111 = v0110;
6779 if (equal(v0128, v0111)) goto v0070;
6780 v0128 = stack[-1];
6781 v0111 = elt(env, 3); /* calledby */
6782 v0128 = get(v0128, v0111);
6783 env = stack[-2];
6784 v0111 = v0128;
6785 if (v0128 == nil) goto v0052;
6786 v0087 = stack[-1];
6787 v0128 = stack[0];
6788 fn = elt(env, 4); /* instdof */
6789 v0111 = (*qfnn(fn))(qenv(fn), 4, v0087, v0128, v0110, v0111);
6790 nil = C_nil;
6791 if (exception_pending()) goto v0101;
6792 env = stack[-2];
6793 goto v0052;
6794
6795 v0052:
6796 v0110 = stack[-1];
6797 v0111 = stack[0];
6798 fn = elt(env, 5); /* hasarg */
6799 v0111 = (*qfn2(fn))(qenv(fn), v0110, v0111);
6800 nil = C_nil;
6801 if (exception_pending()) goto v0101;
6802 v0111 = nil;
6803 { popv(3); return onevalue(v0111); }
6804
6805 v0070:
6806 v0111 = qvalue(elt(env, 2)); /* nil */
6807 { popv(3); return onevalue(v0111); }
6808
6809 v0019:
6810 v0110 = stack[-1];
6811 v0111 = stack[0];
6812 {
6813 popv(3);
6814 fn = elt(env, 5); /* hasarg */
6815 return (*qfn2(fn))(qenv(fn), v0110, v0111);
6816 }
6817 /* error exit handlers */
6818 v0101:
6819 popv(3);
6820 return nil;
6821 }
6822
6823
6824
6825 /* Code for ofsf_smmkatl */
6826
CC_ofsf_smmkatl(Lisp_Object env,int nargs,Lisp_Object v0000,Lisp_Object v0016,Lisp_Object v0066,Lisp_Object v0080,...)6827 static Lisp_Object MS_CDECL CC_ofsf_smmkatl(Lisp_Object env, int nargs,
6828 Lisp_Object v0000, Lisp_Object v0016,
6829 Lisp_Object v0066, Lisp_Object v0080, ...)
6830 {
6831 Lisp_Object nil = C_nil;
6832 Lisp_Object v0069, v0090, v0116, v0100, v0117;
6833 Lisp_Object fn;
6834 CSL_IGNORE(nil);
6835 argcheck(nargs, 4, "ofsf_smmkatl");
6836 #ifdef DEBUG
6837 if (check_env(env)) return aerror("env for ofsf_smmkatl");
6838 #endif
6839 CSL_IGNORE(env);
6840 /* copy arguments values to proper place */
6841 v0116 = v0080;
6842 v0100 = v0066;
6843 v0117 = v0016;
6844 v0069 = v0000;
6845 /* end of prologue */
6846 v0090 = v0069;
6847 v0069 = elt(env, 1); /* and */
6848 if (v0090 == v0069) goto v0006;
6849 v0069 = v0117;
6850 v0090 = v0100;
6851 {
6852 fn = elt(env, 2); /* ofsf_smmkatl!-or */
6853 return (*qfnn(fn))(qenv(fn), 3, v0069, v0090, v0116);
6854 }
6855
6856 v0006:
6857 v0069 = v0117;
6858 v0090 = v0100;
6859 {
6860 fn = elt(env, 3); /* ofsf_smmkatl!-and */
6861 return (*qfnn(fn))(qenv(fn), 3, v0069, v0090, v0116);
6862 }
6863 }
6864
6865
6866
6867 /* Code for qqe_simplat1 */
6868
CC_qqe_simplat1(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)6869 static Lisp_Object CC_qqe_simplat1(Lisp_Object env,
6870 Lisp_Object v0000, Lisp_Object v0016)
6871 {
6872 Lisp_Object nil = C_nil;
6873 Lisp_Object v0124, v0010, v0119;
6874 Lisp_Object fn;
6875 CSL_IGNORE(nil);
6876 #ifdef DEBUG
6877 if (check_env(env)) return aerror("env for qqe_simplat1");
6878 #endif
6879 if (stack >= stacklimit)
6880 {
6881 push2(v0016,v0000);
6882 env = reclaim(env, "stack", GC_STACK, 0);
6883 pop2(v0000,v0016);
6884 nil = C_nil;
6885 if (exception_pending()) return nil;
6886 }
6887 push(env);
6888 /* space for vars preserved across procedure calls */
6889 push2(nil, nil);
6890 /* copy arguments values to proper place */
6891 stack[0] = v0016;
6892 stack[-1] = v0000;
6893 /* end of prologue */
6894 v0124 = stack[-1];
6895 fn = elt(env, 3); /* qqe_op */
6896 v0124 = (*qfn1(fn))(qenv(fn), v0124);
6897 nil = C_nil;
6898 if (exception_pending()) goto v0130;
6899 env = stack[-2];
6900 v0119 = v0124;
6901 v0010 = v0119;
6902 v0124 = elt(env, 1); /* (qequal qneq) */
6903 v0124 = Lmemq(nil, v0010, v0124);
6904 if (v0124 == nil) goto v0018;
6905 v0010 = v0119;
6906 v0124 = elt(env, 2); /* qequal */
6907 if (v0010 == v0124) goto v0027;
6908 v0010 = stack[-1];
6909 v0124 = stack[0];
6910 {
6911 popv(3);
6912 fn = elt(env, 4); /* qqe_simplqneq */
6913 return (*qfn2(fn))(qenv(fn), v0010, v0124);
6914 }
6915
6916 v0027:
6917 v0010 = stack[-1];
6918 v0124 = stack[0];
6919 {
6920 popv(3);
6921 fn = elt(env, 5); /* qqe_simplqequal */
6922 return (*qfn2(fn))(qenv(fn), v0010, v0124);
6923 }
6924
6925 v0018:
6926 v0010 = stack[-1];
6927 v0124 = stack[0];
6928 {
6929 popv(3);
6930 fn = elt(env, 6); /* qqe_simplbtat */
6931 return (*qfn2(fn))(qenv(fn), v0010, v0124);
6932 }
6933 /* error exit handlers */
6934 v0130:
6935 popv(3);
6936 return nil;
6937 }
6938
6939
6940
6941 /* Code for ibalp_hassimple */
6942
CC_ibalp_hassimple(Lisp_Object env,Lisp_Object v0000)6943 static Lisp_Object CC_ibalp_hassimple(Lisp_Object env,
6944 Lisp_Object v0000)
6945 {
6946 Lisp_Object nil = C_nil;
6947 Lisp_Object v0090, v0116;
6948 Lisp_Object fn;
6949 CSL_IGNORE(nil);
6950 #ifdef DEBUG
6951 if (check_env(env)) return aerror("env for ibalp_hassimple");
6952 #endif
6953 if (stack >= stacklimit)
6954 {
6955 push(v0000);
6956 env = reclaim(env, "stack", GC_STACK, 0);
6957 pop(v0000);
6958 nil = C_nil;
6959 if (exception_pending()) return nil;
6960 }
6961 push(env);
6962 /* space for vars preserved across procedure calls */
6963 push2(nil, nil);
6964 /* copy arguments values to proper place */
6965 v0090 = v0000;
6966 /* end of prologue */
6967 stack[-1] = nil;
6968 stack[0] = v0090;
6969 goto v0012;
6970
6971 v0012:
6972 v0090 = stack[0];
6973 if (v0090 == nil) { Lisp_Object res = stack[-1]; popv(3); return onevalue(res); }
6974 v0090 = stack[-1];
6975 if (!(v0090 == nil)) { Lisp_Object res = stack[-1]; popv(3); return onevalue(res); }
6976 v0090 = stack[0];
6977 v0090 = qcar(v0090);
6978 v0116 = qcar(v0090);
6979 v0090 = stack[0];
6980 v0090 = qcar(v0090);
6981 v0090 = qcdr(v0090);
6982 v0090 = qcar(v0090);
6983 fn = elt(env, 2); /* ibalp_commonlenisone */
6984 v0090 = (*qfn2(fn))(qenv(fn), v0116, v0090);
6985 nil = C_nil;
6986 if (exception_pending()) goto v0120;
6987 env = stack[-2];
6988 if (v0090 == nil) goto v0064;
6989 v0090 = stack[0];
6990 v0090 = qcar(v0090);
6991 stack[-1] = v0090;
6992 goto v0064;
6993
6994 v0064:
6995 v0090 = stack[0];
6996 v0090 = qcdr(v0090);
6997 stack[0] = v0090;
6998 goto v0012;
6999 /* error exit handlers */
7000 v0120:
7001 popv(3);
7002 return nil;
7003 }
7004
7005
7006
7007 /* Code for constsml */
7008
CC_constsml(Lisp_Object env,Lisp_Object v0000)7009 static Lisp_Object CC_constsml(Lisp_Object env,
7010 Lisp_Object v0000)
7011 {
7012 Lisp_Object nil = C_nil;
7013 Lisp_Object v0129, v0359;
7014 Lisp_Object fn;
7015 CSL_IGNORE(nil);
7016 #ifdef DEBUG
7017 if (check_env(env)) return aerror("env for constsml");
7018 #endif
7019 if (stack >= stacklimit)
7020 {
7021 push(v0000);
7022 env = reclaim(env, "stack", GC_STACK, 0);
7023 pop(v0000);
7024 nil = C_nil;
7025 if (exception_pending()) return nil;
7026 }
7027 push(env);
7028 /* space for vars preserved across procedure calls */
7029 push(nil);
7030 /* copy arguments values to proper place */
7031 stack[0] = v0000;
7032 /* end of prologue */
7033 v0129 = stack[0];
7034 if (!(is_number(v0129))) goto v0029;
7035 v0129 = elt(env, 1); /* "<cn" */
7036 fn = elt(env, 13); /* printout */
7037 v0129 = (*qfn1(fn))(qenv(fn), v0129);
7038 nil = C_nil;
7039 if (exception_pending()) goto v0109;
7040 env = stack[-1];
7041 v0129 = stack[0];
7042 v0129 = Lfloatp(nil, v0129);
7043 env = stack[-1];
7044 if (v0129 == nil) goto v0032;
7045 v0129 = elt(env, 2); /* " type=""real""> " */
7046 v0129 = Lprinc(nil, v0129);
7047 nil = C_nil;
7048 if (exception_pending()) goto v0109;
7049 env = stack[-1];
7050 goto v0030;
7051
7052 v0030:
7053 v0129 = stack[0];
7054 v0129 = Lprinc(nil, v0129);
7055 nil = C_nil;
7056 if (exception_pending()) goto v0109;
7057 env = stack[-1];
7058 v0129 = elt(env, 5); /* " </cn>" */
7059 v0129 = Lprinc(nil, v0129);
7060 nil = C_nil;
7061 if (exception_pending()) goto v0109;
7062 env = stack[-1];
7063 goto v0029;
7064
7065 v0029:
7066 v0129 = stack[0];
7067 if (!(symbolp(v0129))) goto v0068;
7068 v0129 = stack[0];
7069 v0359 = Lintern(nil, v0129);
7070 nil = C_nil;
7071 if (exception_pending()) goto v0109;
7072 env = stack[-1];
7073 v0129 = qvalue(elt(env, 6)); /* constants!* */
7074 v0129 = Lmember(nil, v0359, v0129);
7075 if (v0129 == nil) goto v0093;
7076 v0129 = elt(env, 7); /* "<cn type=""constant""> " */
7077 fn = elt(env, 13); /* printout */
7078 v0129 = (*qfn1(fn))(qenv(fn), v0129);
7079 nil = C_nil;
7080 if (exception_pending()) goto v0109;
7081 env = stack[-1];
7082 v0129 = stack[0];
7083 v0129 = Lprinc(nil, v0129);
7084 nil = C_nil;
7085 if (exception_pending()) goto v0109;
7086 env = stack[-1];
7087 v0129 = elt(env, 5); /* " </cn>" */
7088 v0129 = Lprinc(nil, v0129);
7089 nil = C_nil;
7090 if (exception_pending()) goto v0109;
7091 goto v0068;
7092
7093 v0068:
7094 v0129 = nil;
7095 { popv(2); return onevalue(v0129); }
7096
7097 v0093:
7098 v0129 = elt(env, 8); /* "<ci" */
7099 fn = elt(env, 13); /* printout */
7100 v0129 = (*qfn1(fn))(qenv(fn), v0129);
7101 nil = C_nil;
7102 if (exception_pending()) goto v0109;
7103 env = stack[-1];
7104 v0129 = stack[0];
7105 fn = elt(env, 14); /* listp */
7106 v0129 = (*qfn1(fn))(qenv(fn), v0129);
7107 nil = C_nil;
7108 if (exception_pending()) goto v0109;
7109 env = stack[-1];
7110 if (v0129 == nil) goto v0051;
7111 v0129 = elt(env, 9); /* " type=""list""> " */
7112 v0129 = Lprinc(nil, v0129);
7113 nil = C_nil;
7114 if (exception_pending()) goto v0109;
7115 env = stack[-1];
7116 goto v0122;
7117
7118 v0122:
7119 v0129 = stack[0];
7120 v0129 = Lprinc(nil, v0129);
7121 nil = C_nil;
7122 if (exception_pending()) goto v0109;
7123 env = stack[-1];
7124 v0129 = elt(env, 11); /* " </ci>" */
7125 v0129 = Lprinc(nil, v0129);
7126 nil = C_nil;
7127 if (exception_pending()) goto v0109;
7128 goto v0068;
7129
7130 v0051:
7131 v0129 = stack[0];
7132 v0129 = Lsimple_vectorp(nil, v0129);
7133 env = stack[-1];
7134 if (v0129 == nil) goto v0110;
7135 v0129 = elt(env, 10); /* " type=""vector""> " */
7136 v0129 = Lprinc(nil, v0129);
7137 nil = C_nil;
7138 if (exception_pending()) goto v0109;
7139 env = stack[-1];
7140 goto v0122;
7141
7142 v0110:
7143 v0129 = elt(env, 4); /* "> " */
7144 v0129 = Lprinc(nil, v0129);
7145 nil = C_nil;
7146 if (exception_pending()) goto v0109;
7147 env = stack[-1];
7148 goto v0122;
7149
7150 v0032:
7151 v0129 = stack[0];
7152 v0129 = integerp(v0129);
7153 if (v0129 == nil) goto v0104;
7154 v0129 = elt(env, 3); /* " type=""integer""> " */
7155 v0129 = Lprinc(nil, v0129);
7156 nil = C_nil;
7157 if (exception_pending()) goto v0109;
7158 env = stack[-1];
7159 goto v0030;
7160
7161 v0104:
7162 v0129 = elt(env, 4); /* "> " */
7163 v0129 = Lprinc(nil, v0129);
7164 nil = C_nil;
7165 if (exception_pending()) goto v0109;
7166 env = stack[-1];
7167 goto v0030;
7168 /* error exit handlers */
7169 v0109:
7170 popv(2);
7171 return nil;
7172 }
7173
7174
7175
7176 /* Code for simprecip */
7177
CC_simprecip(Lisp_Object env,Lisp_Object v0000)7178 static Lisp_Object CC_simprecip(Lisp_Object env,
7179 Lisp_Object v0000)
7180 {
7181 Lisp_Object nil = C_nil;
7182 Lisp_Object v0026, v0027;
7183 Lisp_Object fn;
7184 CSL_IGNORE(nil);
7185 #ifdef DEBUG
7186 if (check_env(env)) return aerror("env for simprecip");
7187 #endif
7188 if (stack >= stacklimit)
7189 {
7190 push(v0000);
7191 env = reclaim(env, "stack", GC_STACK, 0);
7192 pop(v0000);
7193 nil = C_nil;
7194 if (exception_pending()) return nil;
7195 }
7196 push(env);
7197 /* copy arguments values to proper place */
7198 v0027 = v0000;
7199 /* end of prologue */
7200 v0026 = qvalue(elt(env, 1)); /* !*mcd */
7201 if (v0026 == nil) goto v0006;
7202 v0026 = elt(env, 2); /* recip */
7203 fn = elt(env, 3); /* carx */
7204 v0026 = (*qfn2(fn))(qenv(fn), v0027, v0026);
7205 nil = C_nil;
7206 if (exception_pending()) goto v0028;
7207 env = stack[0];
7208 fn = elt(env, 4); /* simp */
7209 v0026 = (*qfn1(fn))(qenv(fn), v0026);
7210 nil = C_nil;
7211 if (exception_pending()) goto v0028;
7212 env = stack[0];
7213 {
7214 popv(1);
7215 fn = elt(env, 5); /* invsq */
7216 return (*qfn1(fn))(qenv(fn), v0026);
7217 }
7218
7219 v0006:
7220 v0026 = elt(env, 2); /* recip */
7221 fn = elt(env, 3); /* carx */
7222 v0027 = (*qfn2(fn))(qenv(fn), v0027, v0026);
7223 nil = C_nil;
7224 if (exception_pending()) goto v0028;
7225 env = stack[0];
7226 v0026 = (Lisp_Object)-15; /* -1 */
7227 v0026 = list2(v0027, v0026);
7228 nil = C_nil;
7229 if (exception_pending()) goto v0028;
7230 env = stack[0];
7231 {
7232 popv(1);
7233 fn = elt(env, 6); /* simpexpt */
7234 return (*qfn1(fn))(qenv(fn), v0026);
7235 }
7236 /* error exit handlers */
7237 v0028:
7238 popv(1);
7239 return nil;
7240 }
7241
7242
7243
7244 /* Code for list!-mgen */
7245
CC_listKmgen(Lisp_Object env,Lisp_Object v0000)7246 static Lisp_Object CC_listKmgen(Lisp_Object env,
7247 Lisp_Object v0000)
7248 {
7249 Lisp_Object nil = C_nil;
7250 Lisp_Object v0004, v0069;
7251 Lisp_Object fn;
7252 CSL_IGNORE(nil);
7253 #ifdef DEBUG
7254 if (check_env(env)) return aerror("env for list-mgen");
7255 #endif
7256 if (stack >= stacklimit)
7257 {
7258 push(v0000);
7259 env = reclaim(env, "stack", GC_STACK, 0);
7260 pop(v0000);
7261 nil = C_nil;
7262 if (exception_pending()) return nil;
7263 }
7264 push(env);
7265 /* space for vars preserved across procedure calls */
7266 push2(nil, nil);
7267 /* copy arguments values to proper place */
7268 v0069 = v0000;
7269 /* end of prologue */
7270 stack[-1] = qvalue(elt(env, 1)); /* i */
7271 qvalue(elt(env, 1)) = nil; /* i */
7272 v0004 = (Lisp_Object)1; /* 0 */
7273 qvalue(elt(env, 1)) = v0004; /* i */
7274 v0004 = v0069;
7275 stack[0] = v0004;
7276 goto v0012;
7277
7278 v0012:
7279 v0004 = stack[0];
7280 if (v0004 == nil) goto v0013;
7281 v0004 = stack[0];
7282 v0004 = qcar(v0004);
7283 v0069 = v0004;
7284 v0004 = v0069;
7285 if (!consp(v0004)) goto v0067;
7286 v0004 = qvalue(elt(env, 2)); /* nil */
7287 goto v0104;
7288
7289 v0104:
7290 if (v0004 == nil) goto v0019;
7291 v0004 = qvalue(elt(env, 1)); /* i */
7292 v0004 = add1(v0004);
7293 nil = C_nil;
7294 if (exception_pending()) goto v0100;
7295 env = stack[-2];
7296 qvalue(elt(env, 1)) = v0004; /* i */
7297 goto v0019;
7298
7299 v0019:
7300 v0004 = stack[0];
7301 v0004 = qcdr(v0004);
7302 stack[0] = v0004;
7303 goto v0012;
7304
7305 v0067:
7306 v0004 = v0069;
7307 fn = elt(env, 3); /* mgenp */
7308 v0004 = (*qfn1(fn))(qenv(fn), v0004);
7309 nil = C_nil;
7310 if (exception_pending()) goto v0100;
7311 env = stack[-2];
7312 goto v0104;
7313
7314 v0013:
7315 v0004 = qvalue(elt(env, 1)); /* i */
7316 qvalue(elt(env, 1)) = stack[-1]; /* i */
7317 { popv(3); return onevalue(v0004); }
7318 /* error exit handlers */
7319 v0100:
7320 env = stack[-2];
7321 qvalue(elt(env, 1)) = stack[-1]; /* i */
7322 popv(3);
7323 return nil;
7324 }
7325
7326
7327
7328 /* Code for vbcgcd */
7329
CC_vbcgcd(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)7330 static Lisp_Object CC_vbcgcd(Lisp_Object env,
7331 Lisp_Object v0000, Lisp_Object v0016)
7332 {
7333 Lisp_Object nil = C_nil;
7334 Lisp_Object v0082, v0038;
7335 Lisp_Object fn;
7336 CSL_IGNORE(nil);
7337 #ifdef DEBUG
7338 if (check_env(env)) return aerror("env for vbcgcd");
7339 #endif
7340 if (stack >= stacklimit)
7341 {
7342 push2(v0016,v0000);
7343 env = reclaim(env, "stack", GC_STACK, 0);
7344 pop2(v0000,v0016);
7345 nil = C_nil;
7346 if (exception_pending()) return nil;
7347 }
7348 push(env);
7349 /* space for vars preserved across procedure calls */
7350 push2(nil, nil);
7351 /* copy arguments values to proper place */
7352 stack[0] = v0016;
7353 stack[-1] = v0000;
7354 /* end of prologue */
7355 v0038 = stack[-1];
7356 v0082 = (Lisp_Object)-1599; /* -100 */
7357 fn = elt(env, 4); /* vbcsize */
7358 v0082 = (*qfn2(fn))(qenv(fn), v0038, v0082);
7359 nil = C_nil;
7360 if (exception_pending()) goto v0355;
7361 env = stack[-2];
7362 if (v0082 == nil) goto v0030;
7363 v0038 = stack[0];
7364 v0082 = (Lisp_Object)-1599; /* -100 */
7365 fn = elt(env, 4); /* vbcsize */
7366 v0082 = (*qfn2(fn))(qenv(fn), v0038, v0082);
7367 nil = C_nil;
7368 if (exception_pending()) goto v0355;
7369 env = stack[-2];
7370 v0082 = (v0082 == nil ? lisp_true : nil);
7371 goto v0015;
7372
7373 v0015:
7374 if (v0082 == nil) goto v0100;
7375 v0082 = elt(env, 2); /* (1 . 1) */
7376 { popv(3); return onevalue(v0082); }
7377
7378 v0100:
7379 v0082 = stack[-1];
7380 v0038 = qcdr(v0082);
7381 v0082 = (Lisp_Object)17; /* 1 */
7382 if (v0038 == v0082) goto v0008;
7383 v0082 = qvalue(elt(env, 3)); /* nil */
7384 goto v0069;
7385
7386 v0069:
7387 if (v0082 == nil) goto v0469;
7388 v0082 = stack[-1];
7389 v0082 = qcar(v0082);
7390 v0082 = integerp(v0082);
7391 if (v0082 == nil) goto v0089;
7392 v0082 = stack[0];
7393 v0082 = qcar(v0082);
7394 v0082 = integerp(v0082);
7395 if (v0082 == nil) goto v0089;
7396 v0082 = stack[-1];
7397 v0038 = qcar(v0082);
7398 v0082 = stack[0];
7399 v0082 = qcar(v0082);
7400 v0038 = Lgcd(nil, v0038, v0082);
7401 nil = C_nil;
7402 if (exception_pending()) goto v0355;
7403 v0082 = (Lisp_Object)17; /* 1 */
7404 popv(3);
7405 return cons(v0038, v0082);
7406
7407 v0089:
7408 v0082 = stack[-1];
7409 v0038 = qcar(v0082);
7410 v0082 = stack[0];
7411 v0082 = qcar(v0082);
7412 fn = elt(env, 5); /* gcdf!* */
7413 v0038 = (*qfn2(fn))(qenv(fn), v0038, v0082);
7414 nil = C_nil;
7415 if (exception_pending()) goto v0355;
7416 v0082 = (Lisp_Object)17; /* 1 */
7417 popv(3);
7418 return cons(v0038, v0082);
7419
7420 v0469:
7421 v0038 = (Lisp_Object)17; /* 1 */
7422 v0082 = (Lisp_Object)17; /* 1 */
7423 popv(3);
7424 return cons(v0038, v0082);
7425
7426 v0008:
7427 v0082 = stack[0];
7428 v0038 = qcdr(v0082);
7429 v0082 = (Lisp_Object)17; /* 1 */
7430 v0082 = (v0038 == v0082 ? lisp_true : nil);
7431 goto v0069;
7432
7433 v0030:
7434 v0082 = qvalue(elt(env, 1)); /* t */
7435 goto v0015;
7436 /* error exit handlers */
7437 v0355:
7438 popv(3);
7439 return nil;
7440 }
7441
7442
7443
7444 /* Code for groebcplistsortin */
7445
CC_groebcplistsortin(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)7446 static Lisp_Object CC_groebcplistsortin(Lisp_Object env,
7447 Lisp_Object v0000, Lisp_Object v0016)
7448 {
7449 Lisp_Object nil = C_nil;
7450 Lisp_Object v0019, v0020;
7451 Lisp_Object fn;
7452 CSL_IGNORE(nil);
7453 #ifdef DEBUG
7454 if (check_env(env)) return aerror("env for groebcplistsortin");
7455 #endif
7456 if (stack >= stacklimit)
7457 {
7458 push2(v0016,v0000);
7459 env = reclaim(env, "stack", GC_STACK, 0);
7460 pop2(v0000,v0016);
7461 nil = C_nil;
7462 if (exception_pending()) return nil;
7463 }
7464 CSL_IGNORE(env);
7465 /* space for vars preserved across procedure calls */
7466 push(nil);
7467 /* copy arguments values to proper place */
7468 stack[0] = v0016;
7469 v0020 = v0000;
7470 /* end of prologue */
7471 v0019 = stack[0];
7472 if (v0019 == nil) goto v0029;
7473 v0019 = stack[0];
7474 fn = elt(env, 1); /* groebcplistsortin1 */
7475 v0019 = (*qfn2(fn))(qenv(fn), v0020, v0019);
7476 nil = C_nil;
7477 if (exception_pending()) goto v0023;
7478 { Lisp_Object res = stack[0]; popv(1); return onevalue(res); }
7479
7480 v0029:
7481 v0019 = v0020;
7482 popv(1);
7483 return ncons(v0019);
7484 /* error exit handlers */
7485 v0023:
7486 popv(1);
7487 return nil;
7488 }
7489
7490
7491
7492 /* Code for termordp!! */
7493
CC_termordpB(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)7494 static Lisp_Object CC_termordpB(Lisp_Object env,
7495 Lisp_Object v0000, Lisp_Object v0016)
7496 {
7497 Lisp_Object nil = C_nil;
7498 Lisp_Object v0065, v0001, v0053;
7499 Lisp_Object fn;
7500 CSL_IGNORE(nil);
7501 #ifdef DEBUG
7502 if (check_env(env)) return aerror("env for termordp!");
7503 #endif
7504 if (stack >= stacklimit)
7505 {
7506 push2(v0016,v0000);
7507 env = reclaim(env, "stack", GC_STACK, 0);
7508 pop2(v0000,v0016);
7509 nil = C_nil;
7510 if (exception_pending()) return nil;
7511 }
7512 push(env);
7513 /* space for vars preserved across procedure calls */
7514 push2(nil, nil);
7515 /* copy arguments values to proper place */
7516 stack[0] = v0016;
7517 v0053 = v0000;
7518 /* end of prologue */
7519 v0001 = v0053;
7520 v0065 = stack[0];
7521 if (equal(v0001, v0065)) goto v0023;
7522 v0065 = v0053;
7523 fn = elt(env, 2); /* guesspftype */
7524 stack[-1] = (*qfn1(fn))(qenv(fn), v0065);
7525 nil = C_nil;
7526 if (exception_pending()) goto v0024;
7527 env = stack[-2];
7528 v0065 = stack[0];
7529 fn = elt(env, 2); /* guesspftype */
7530 v0065 = (*qfn1(fn))(qenv(fn), v0065);
7531 nil = C_nil;
7532 if (exception_pending()) goto v0024;
7533 env = stack[-2];
7534 {
7535 Lisp_Object v0022 = stack[-1];
7536 popv(3);
7537 fn = elt(env, 3); /* termordp */
7538 return (*qfn2(fn))(qenv(fn), v0022, v0065);
7539 }
7540
7541 v0023:
7542 v0065 = qvalue(elt(env, 1)); /* nil */
7543 { popv(3); return onevalue(v0065); }
7544 /* error exit handlers */
7545 v0024:
7546 popv(3);
7547 return nil;
7548 }
7549
7550
7551
7552 /* Code for putd */
7553
CC_putd(Lisp_Object env,int nargs,Lisp_Object v0000,Lisp_Object v0016,Lisp_Object v0066,...)7554 static Lisp_Object MS_CDECL CC_putd(Lisp_Object env, int nargs,
7555 Lisp_Object v0000, Lisp_Object v0016,
7556 Lisp_Object v0066, ...)
7557 {
7558 Lisp_Object nil = C_nil;
7559 Lisp_Object v0350, v0351, v0335;
7560 Lisp_Object fn;
7561 CSL_IGNORE(nil);
7562 argcheck(nargs, 3, "putd");
7563 #ifdef DEBUG
7564 if (check_env(env)) return aerror("env for putd");
7565 #endif
7566 if (stack >= stacklimit)
7567 {
7568 push3(v0066,v0016,v0000);
7569 env = reclaim(env, "stack", GC_STACK, 0);
7570 pop3(v0000,v0016,v0066);
7571 nil = C_nil;
7572 if (exception_pending()) return nil;
7573 }
7574 push(env);
7575 /* space for vars preserved across procedure calls */
7576 push3(nil, nil, nil);
7577 /* copy arguments values to proper place */
7578 stack[0] = v0066;
7579 stack[-1] = v0016;
7580 stack[-2] = v0000;
7581 /* end of prologue */
7582 v0351 = stack[0];
7583 v0350 = elt(env, 1); /* funarg */
7584 if (!consp(v0351)) goto v0029;
7585 v0351 = qcar(v0351);
7586 if (!(v0351 == v0350)) goto v0029;
7587 v0351 = elt(env, 2); /* lambda */
7588 v0350 = stack[0];
7589 v0350 = qcdr(v0350);
7590 v0350 = qcdr(v0350);
7591 v0350 = cons(v0351, v0350);
7592 nil = C_nil;
7593 if (exception_pending()) goto v0504;
7594 env = stack[-3];
7595 stack[0] = v0350;
7596 goto v0029;
7597
7598 v0029:
7599 v0350 = stack[-2];
7600 if (!symbolp(v0350)) v0350 = nil;
7601 else { v0350 = qfastgets(v0350);
7602 if (v0350 != nil) { v0350 = elt(v0350, 1); /* lose */
7603 #ifdef RECORD_GET
7604 if (v0350 == SPID_NOPROP)
7605 record_get(elt(fastget_names, 1), 0),
7606 v0350 = nil;
7607 else record_get(elt(fastget_names, 1), 1),
7608 v0350 = lisp_true; }
7609 else record_get(elt(fastget_names, 1), 0); }
7610 #else
7611 if (v0350 == SPID_NOPROP) v0350 = nil; else v0350 = lisp_true; }}
7612 #endif
7613 if (v0350 == nil) goto v0069;
7614 v0350 = Lterpri(nil, 0);
7615 nil = C_nil;
7616 if (exception_pending()) goto v0504;
7617 env = stack[-3];
7618 v0350 = elt(env, 3); /* "+++ " */
7619 v0350 = Lprinc(nil, v0350);
7620 nil = C_nil;
7621 if (exception_pending()) goto v0504;
7622 env = stack[-3];
7623 v0350 = stack[-2];
7624 v0350 = Lprin(nil, v0350);
7625 nil = C_nil;
7626 if (exception_pending()) goto v0504;
7627 env = stack[-3];
7628 v0350 = elt(env, 4); /* " not defined (LOSE flag)" */
7629 v0350 = Lprintc(nil, v0350);
7630 nil = C_nil;
7631 if (exception_pending()) goto v0504;
7632 env = stack[-3];
7633 v0350 = qvalue(elt(env, 5)); /* nil */
7634 { popv(4); return onevalue(v0350); }
7635
7636 v0069:
7637 v0350 = qvalue(elt(env, 6)); /* !*redefmsg */
7638 if (v0350 == nil) goto v0122;
7639 v0350 = stack[-2];
7640 fn = elt(env, 15); /* getd */
7641 v0350 = (*qfn1(fn))(qenv(fn), v0350);
7642 nil = C_nil;
7643 if (exception_pending()) goto v0504;
7644 env = stack[-3];
7645 if (v0350 == nil) goto v0122;
7646 v0350 = Lterpri(nil, 0);
7647 nil = C_nil;
7648 if (exception_pending()) goto v0504;
7649 env = stack[-3];
7650 v0350 = elt(env, 3); /* "+++ " */
7651 v0350 = Lprinc(nil, v0350);
7652 nil = C_nil;
7653 if (exception_pending()) goto v0504;
7654 env = stack[-3];
7655 v0350 = stack[-2];
7656 v0350 = Lprin(nil, v0350);
7657 nil = C_nil;
7658 if (exception_pending()) goto v0504;
7659 env = stack[-3];
7660 v0350 = elt(env, 7); /* " redefined" */
7661 v0350 = Lprintc(nil, v0350);
7662 nil = C_nil;
7663 if (exception_pending()) goto v0504;
7664 env = stack[-3];
7665 goto v0122;
7666
7667 v0122:
7668 v0351 = stack[-1];
7669 v0350 = elt(env, 8); /* expr */
7670 if (v0351 == v0350) goto v0103;
7671 v0351 = stack[-1];
7672 v0350 = elt(env, 9); /* subr */
7673 if (v0351 == v0350) goto v0109;
7674 v0351 = stack[-1];
7675 v0350 = elt(env, 10); /* macro */
7676 if (v0351 == v0350) goto v0106;
7677 v0350 = qvalue(elt(env, 5)); /* nil */
7678 goto v0105;
7679
7680 v0105:
7681 if (v0350 == nil) goto v0056;
7682 v0335 = elt(env, 11); /* dm */
7683 v0351 = stack[-2];
7684 v0350 = stack[0];
7685 v0350 = qcdr(v0350);
7686 v0350 = list2star(v0335, v0351, v0350);
7687 nil = C_nil;
7688 if (exception_pending()) goto v0504;
7689 env = stack[-3];
7690 fn = elt(env, 16); /* eval */
7691 v0350 = (*qfn1(fn))(qenv(fn), v0350);
7692 nil = C_nil;
7693 if (exception_pending()) goto v0504;
7694 { Lisp_Object res = stack[-2]; popv(4); return onevalue(res); }
7695
7696 v0056:
7697 v0351 = stack[-1];
7698 v0350 = elt(env, 12); /* fexpr */
7699 if (v0351 == v0350) goto v0062;
7700 v0350 = qvalue(elt(env, 5)); /* nil */
7701 goto v0113;
7702
7703 v0113:
7704 if (v0350 == nil) goto v0427;
7705 v0335 = elt(env, 13); /* df */
7706 v0351 = stack[-2];
7707 v0350 = stack[0];
7708 v0350 = qcdr(v0350);
7709 v0350 = list2star(v0335, v0351, v0350);
7710 nil = C_nil;
7711 if (exception_pending()) goto v0504;
7712 env = stack[-3];
7713 fn = elt(env, 16); /* eval */
7714 v0350 = (*qfn1(fn))(qenv(fn), v0350);
7715 nil = C_nil;
7716 if (exception_pending()) goto v0504;
7717 { Lisp_Object res = stack[-2]; popv(4); return onevalue(res); }
7718
7719 v0427:
7720 v0351 = elt(env, 14); /* "Bad type ~S in putd" */
7721 v0350 = stack[-1];
7722 fn = elt(env, 17); /* error */
7723 v0350 = (*qfn2(fn))(qenv(fn), v0351, v0350);
7724 nil = C_nil;
7725 if (exception_pending()) goto v0504;
7726 { Lisp_Object res = stack[-2]; popv(4); return onevalue(res); }
7727
7728 v0062:
7729 v0351 = stack[0];
7730 v0350 = elt(env, 2); /* lambda */
7731 v0350 = Leqcar(nil, v0351, v0350);
7732 env = stack[-3];
7733 goto v0113;
7734
7735 v0106:
7736 v0351 = stack[0];
7737 v0350 = elt(env, 2); /* lambda */
7738 v0350 = Leqcar(nil, v0351, v0350);
7739 env = stack[-3];
7740 goto v0105;
7741
7742 v0109:
7743 v0351 = stack[-2];
7744 v0350 = stack[0];
7745 v0350 = Lsymbol_set_definition(nil, v0351, v0350);
7746 nil = C_nil;
7747 if (exception_pending()) goto v0504;
7748 { Lisp_Object res = stack[-2]; popv(4); return onevalue(res); }
7749
7750 v0103:
7751 v0351 = stack[-2];
7752 v0350 = stack[0];
7753 v0350 = Lsymbol_set_definition(nil, v0351, v0350);
7754 nil = C_nil;
7755 if (exception_pending()) goto v0504;
7756 { Lisp_Object res = stack[-2]; popv(4); return onevalue(res); }
7757 /* error exit handlers */
7758 v0504:
7759 popv(4);
7760 return nil;
7761 }
7762
7763
7764
7765 /* Code for setel */
7766
CC_setel(Lisp_Object env,Lisp_Object v0000,Lisp_Object v0016)7767 static Lisp_Object CC_setel(Lisp_Object env,
7768 Lisp_Object v0000, Lisp_Object v0016)
7769 {
7770 Lisp_Object nil = C_nil;
7771 Lisp_Object v0052, v0123, v0480, v0103;
7772 Lisp_Object fn;
7773 CSL_IGNORE(nil);
7774 #ifdef DEBUG
7775 if (check_env(env)) return aerror("env for setel");
7776 #endif
7777 if (stack >= stacklimit)
7778 {
7779 push2(v0016,v0000);
7780 env = reclaim(env, "stack", GC_STACK, 0);
7781 pop2(v0000,v0016);
7782 nil = C_nil;
7783 if (exception_pending()) return nil;
7784 }
7785 push(env);
7786 /* space for vars preserved across procedure calls */
7787 push4(nil, nil, nil, nil);
7788 /* copy arguments values to proper place */
7789 stack[-1] = v0016;
7790 stack[-2] = v0000;
7791 /* end of prologue */
7792 v0052 = stack[-2];
7793 v0123 = qcar(v0052);
7794 v0052 = elt(env, 1); /* dimension */
7795 v0052 = get(v0123, v0052);
7796 env = stack[-4];
7797 stack[-3] = v0052;
7798 v0052 = stack[-3];
7799 stack[0] = Llength(nil, v0052);
7800 nil = C_nil;
7801 if (exception_pending()) goto v0110;
7802 env = stack[-4];
7803 v0052 = stack[-2];
7804 v0052 = qcdr(v0052);
7805 v0052 = Llength(nil, v0052);
7806 nil = C_nil;
7807 if (exception_pending()) goto v0110;
7808 env = stack[-4];
7809 if (equal(stack[0], v0052)) goto v0124;
7810 v0052 = elt(env, 2); /* "Incorrect array reference" */
7811 v0123 = v0052;
7812 v0052 = v0123;
7813 qvalue(elt(env, 3)) = v0052; /* errmsg!* */
7814 v0052 = qvalue(elt(env, 4)); /* !*protfg */
7815 if (!(v0052 == nil)) goto v0022;
7816 v0052 = v0123;
7817 fn = elt(env, 6); /* lprie */
7818 v0052 = (*qfn1(fn))(qenv(fn), v0052);
7819 nil = C_nil;
7820 if (exception_pending()) goto v0110;
7821 env = stack[-4];
7822 goto v0022;
7823
7824 v0022:
7825 v0052 = Lerror0(nil, 0);
7826 nil = C_nil;
7827 if (exception_pending()) goto v0110;
7828 v0052 = nil;
7829 { popv(5); return onevalue(v0052); }
7830
7831 v0124:
7832 v0052 = stack[-2];
7833 v0123 = qcar(v0052);
7834 v0052 = elt(env, 5); /* avalue */
7835 v0052 = get(v0123, v0052);
7836 env = stack[-4];
7837 v0052 = qcdr(v0052);
7838 v0103 = qcar(v0052);
7839 v0052 = stack[-2];
7840 v0480 = qcdr(v0052);
7841 v0123 = stack[-1];
7842 v0052 = stack[-3];
7843 {
7844 popv(5);
7845 fn = elt(env, 7); /* setel1 */
7846 return (*qfnn(fn))(qenv(fn), 4, v0103, v0480, v0123, v0052);
7847 }
7848 /* error exit handlers */
7849 v0110:
7850 popv(5);
7851 return nil;
7852 }
7853
7854
7855
7856 /* Code for mv2sf1 */
7857
CC_mv2sf1(Lisp_Object env,int nargs,Lisp_Object v0016,Lisp_Object v0066,Lisp_Object v0080,...)7858 static Lisp_Object MS_CDECL CC_mv2sf1(Lisp_Object env, int nargs,
7859 Lisp_Object v0016, Lisp_Object v0066,
7860 Lisp_Object v0080, ...)
7861 {
7862 Lisp_Object nil = C_nil;
7863 Lisp_Object v0126, v0127, v0122, v0094;
7864 CSL_IGNORE(nil);
7865 argcheck(nargs, 3, "mv2sf1");
7866 #ifdef DEBUG
7867 if (check_env(env)) return aerror("env for mv2sf1");
7868 #endif
7869 if (stack >= stacklimit)
7870 {
7871 push3(v0080,v0066,v0016);
7872 env = reclaim(env, "stack", GC_STACK, 0);
7873 pop3(v0016,v0066,v0080);
7874 nil = C_nil;
7875 if (exception_pending()) return nil;
7876 }
7877 push(env);
7878 /* space for vars preserved across procedure calls */
7879 push3(nil, nil, nil);
7880 /* copy arguments values to proper place */
7881 v0126 = v0080;
7882 v0094 = v0066;
7883 v0122 = v0016;
7884 /* end of prologue */
7885 stack[-2] = qvalue(elt(env, 1)); /* varlist */
7886 qvalue(elt(env, 1)) = nil; /* varlist */
7887 qvalue(elt(env, 1)) = v0126; /* varlist */
7888 goto v0015;
7889
7890 v0015:
7891 v0126 = v0122;
7892 if (v0126 == nil) goto v0032;
7893 v0126 = v0122;
7894 v0127 = qcar(v0126);
7895 v0126 = (Lisp_Object)1; /* 0 */
7896 if (v0127 == v0126) goto v0017;
7897 v0126 = qvalue(elt(env, 1)); /* varlist */
7898 stack[-1] = qcar(v0126);
7899 v0126 = v0122;
7900 stack[0] = qcar(v0126);
7901 v0126 = v0122;
7902 v0127 = qcdr(v0126);
7903 v0122 = v0094;
7904 v0126 = qvalue(elt(env, 1)); /* varlist */
7905 v0126 = qcdr(v0126);
7906 v0126 = CC_mv2sf1(env, 3, v0127, v0122, v0126);
7907 nil = C_nil;
7908 if (exception_pending()) goto v0052;
7909 env = stack[-3];
7910 v0126 = acons(stack[-1], stack[0], v0126);
7911 nil = C_nil;
7912 if (exception_pending()) goto v0052;
7913 env = stack[-3];
7914 v0126 = ncons(v0126);
7915 nil = C_nil;
7916 if (exception_pending()) goto v0052;
7917 env = stack[-3];
7918 goto v0054;
7919
7920 v0054:
7921 qvalue(elt(env, 1)) = stack[-2]; /* varlist */
7922 { popv(4); return onevalue(v0126); }
7923
7924 v0017:
7925 v0126 = v0122;
7926 v0126 = qcdr(v0126);
7927 v0122 = v0126;
7928 v0126 = qvalue(elt(env, 1)); /* varlist */
7929 v0126 = qcdr(v0126);
7930 qvalue(elt(env, 1)) = v0126; /* varlist */
7931 goto v0015;
7932
7933 v0032:
7934 v0126 = v0094;
7935 goto v0054;
7936 /* error exit handlers */
7937 v0052:
7938 env = stack[-3];
7939 qvalue(elt(env, 1)) = stack[-2]; /* varlist */
7940 popv(4);
7941 return nil;
7942 }
7943
7944
7945
7946 setup_type const u13_setup[] =
7947 {
7948 {"guesspftype", CC_guesspftype, too_many_1, wrong_no_1},
7949 {"equalreplaceby", CC_equalreplaceby,too_many_1, wrong_no_1},
7950 {"inttovec", too_few_2, CC_inttovec, wrong_no_2},
7951 {"assert_uninstall_all", wrong_no_na, wrong_no_nb, (n_args *)CC_assert_uninstall_all},
7952 {"eqdummy", too_few_2, CC_eqdummy, wrong_no_2},
7953 {"numlist_ordp", too_few_2, CC_numlist_ordp,wrong_no_2},
7954 {"lambda_ls8o1j_2", too_few_2, CC_lambda_ls8o1j_2,wrong_no_2},
7955 {"extmult", too_few_2, CC_extmult, wrong_no_2},
7956 {"simp*sq", CC_simpHsq, too_many_1, wrong_no_1},
7957 {"mkzl", CC_mkzl, too_many_1, wrong_no_1},
7958 {"ibalp_clausep", CC_ibalp_clausep,too_many_1, wrong_no_1},
7959 {"aex_mvaroccurtest", too_few_2, CC_aex_mvaroccurtest,wrong_no_2},
7960 {"ofsf_sacatlp", too_few_2, CC_ofsf_sacatlp,wrong_no_2},
7961 {"cr:prep", CC_crTprep, too_many_1, wrong_no_1},
7962 {"initwght", CC_initwght, too_many_1, wrong_no_1},
7963 {"bcplus?", CC_bcplusW, too_many_1, wrong_no_1},
7964 {"vevmaptozero1", too_few_2, CC_vevmaptozero1,wrong_no_2},
7965 {"physopaeval", CC_physopaeval, too_many_1, wrong_no_1},
7966 {"zero-roads", CC_zeroKroads, too_many_1, wrong_no_1},
7967 {"assert_install", CC_assert_install,too_many_1, wrong_no_1},
7968 {"mo=revlexcomp", too_few_2, CC_moMrevlexcomp,wrong_no_2},
7969 {"dv_cambhead", CC_dv_cambhead, too_many_1, wrong_no_1},
7970 {"expt-mod-p", too_few_2, CC_exptKmodKp, wrong_no_2},
7971 {"get_group_in", CC_get_group_in,too_many_1, wrong_no_1},
7972 {"qqe_ofsf_simplat1", too_few_2, CC_qqe_ofsf_simplat1,wrong_no_2},
7973 {"rl_negateat", CC_rl_negateat, too_many_1, wrong_no_1},
7974 {"ibalp_redclause", CC_ibalp_redclause,too_many_1, wrong_no_1},
7975 {"aex_simplenullp", CC_aex_simplenullp,too_many_1, wrong_no_1},
7976 {"variablesir", wrong_no_na, wrong_no_nb, (n_args *)CC_variablesir},
7977 {"lid", CC_lid, too_many_1, wrong_no_1},
7978 {"invp", CC_invp, too_many_1, wrong_no_1},
7979 {"formcond1", wrong_no_na, wrong_no_nb, (n_args *)CC_formcond1},
7980 {"mkarray1", too_few_2, CC_mkarray1, wrong_no_2},
7981 {":divide", too_few_2, CC_Tdivide, wrong_no_2},
7982 {"gperm0", CC_gperm0, too_many_1, wrong_no_1},
7983 {"freeofl", too_few_2, CC_freeofl, wrong_no_2},
7984 {"xread1", CC_xread1, too_many_1, wrong_no_1},
7985 {"cl_atfp", CC_cl_atfp, too_many_1, wrong_no_1},
7986 {"ibalp_lenisone", CC_ibalp_lenisone,too_many_1, wrong_no_1},
7987 {"numpoly_nullp", CC_numpoly_nullp,too_many_1, wrong_no_1},
7988 {"inshisto", CC_inshisto, too_many_1, wrong_no_1},
7989 {"evenfree", CC_evenfree, too_many_1, wrong_no_1},
7990 {"revalind", CC_revalind, too_many_1, wrong_no_1},
7991 {"all_defined_vertex", too_few_2, CC_all_defined_vertex,wrong_no_2},
7992 {"getmatelem", CC_getmatelem, too_many_1, wrong_no_1},
7993 {"b:extadd", too_few_2, CC_bTextadd, wrong_no_2},
7994 {"negate-term", CC_negateKterm, too_many_1, wrong_no_1},
7995 {"defineargs", too_few_2, CC_defineargs, wrong_no_2},
7996 {"ofsf_smmkatl", wrong_no_na, wrong_no_nb, (n_args *)CC_ofsf_smmkatl},
7997 {"qqe_simplat1", too_few_2, CC_qqe_simplat1,wrong_no_2},
7998 {"ibalp_hassimple", CC_ibalp_hassimple,too_many_1, wrong_no_1},
7999 {"constsml", CC_constsml, too_many_1, wrong_no_1},
8000 {"simprecip", CC_simprecip, too_many_1, wrong_no_1},
8001 {"list-mgen", CC_listKmgen, too_many_1, wrong_no_1},
8002 {"vbcgcd", too_few_2, CC_vbcgcd, wrong_no_2},
8003 {"groebcplistsortin", too_few_2, CC_groebcplistsortin,wrong_no_2},
8004 {"termordp!", too_few_2, CC_termordpB, wrong_no_2},
8005 {"putd", wrong_no_na, wrong_no_nb, (n_args *)CC_putd},
8006 {"setel", too_few_2, CC_setel, wrong_no_2},
8007 {"mv2sf1", wrong_no_na, wrong_no_nb, (n_args *)CC_mv2sf1},
8008 {NULL, (one_args *)"u13", (two_args *)"10772 5691036 2390222", 0}
8009 };
8010
8011 /* end of generated code */
8012