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