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