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