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