1 |
|
|
2 |
|
#include "cmpinclude.h" |
3 |
|
#include "gcl_loop.h" |
4 |
|
void init_gcl_loop(){do_init(VV);} |
5 |
|
/* macro definition for LOOP-COPYLIST* */ |
6 |
|
|
7 |
|
static void L1() |
8 |
|
{register object *base=vs_base; |
9 |
|
register object *sup=base+VM1; VC1 |
10 |
|
vs_reserve(VM1); |
11 |
|
check_arg(2); |
12 |
|
vs_top=sup; |
13 |
|
{object V1=base[0]->c.c_cdr; |
14 |
|
if(endp(V1))invalid_macro_call(); |
15 |
|
base[2]= (V1->c.c_car); |
16 |
|
V1=V1->c.c_cdr; |
17 |
|
if(!endp(V1))invalid_macro_call();} |
18 |
|
base[3]= list(2,VV[0],base[2]); |
19 |
|
vs_top=(vs_base=base+3)+1; |
20 |
|
return; |
21 |
|
} |
22 |
|
/* function definition for LOOP-GENTEMP */ |
23 |
|
|
24 |
|
static void L2() |
25 |
|
{register object *base=vs_base; |
26 |
|
register object *sup=base+VM2; VC2 |
27 |
|
vs_reserve(VM2); |
28 |
|
{object V2; |
29 |
|
if(vs_top-vs_base>1) too_many_arguments(); |
30 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1;} |
31 |
|
V2=(base[0]); |
32 |
|
vs_top=sup; |
33 |
|
goto T2; |
34 |
|
goto T1; |
35 |
|
T1:; |
36 |
|
V2= VV[1]; |
37 |
|
goto T2; |
38 |
|
T2:; |
39 |
|
if((symbol_value(VV[2]))==Cnil){ |
40 |
|
goto T5;} |
41 |
|
base[1]= coerce_to_string((V2)); |
42 |
|
vs_top=(vs_base=base+1)+1; |
43 |
|
Lgentemp(); |
44 |
|
return; |
45 |
|
goto T5; |
46 |
|
T5:; |
47 |
|
vs_base=vs_top; |
48 |
|
Lgensym(); |
49 |
|
return; |
50 |
|
} |
51 |
|
} |
52 |
|
/* function definition for LOOP-OPTIMIZATION-QUANTITIES */ |
53 |
|
|
54 |
|
static void L3() |
55 |
|
{register object *base=vs_base; |
56 |
|
register object *sup=base+VM3; VC3 |
57 |
|
vs_reserve(VM3); |
58 |
|
{object V3; |
59 |
|
check_arg(1); |
60 |
|
V3=(base[0]); |
61 |
|
vs_top=sup; |
62 |
|
goto TTL; |
63 |
|
TTL:; |
64 |
|
base[1]= small_fixnum(1); |
65 |
|
base[2]= small_fixnum(1); |
66 |
|
base[3]= small_fixnum(1); |
67 |
|
base[4]= small_fixnum(1); |
68 |
|
base[5]= small_fixnum(1); |
69 |
|
vs_top=(vs_base=base+1)+5; |
70 |
|
return; |
71 |
|
} |
72 |
|
} |
73 |
|
/* function definition for HIDE-VARIABLE-REFERENCES */ |
74 |
|
|
75 |
|
static void L4() |
76 |
|
{register object *base=vs_base; |
77 |
|
register object *sup=base+VM4; VC4 |
78 |
|
vs_reserve(VM4); |
79 |
|
{object V4; |
80 |
|
object V5; |
81 |
|
check_arg(2); |
82 |
|
V4=(base[0]); |
83 |
|
V5=(base[1]); |
84 |
|
vs_top=sup; |
85 |
|
goto TTL; |
86 |
|
TTL:; |
87 |
|
base[2]= (V5); |
88 |
|
vs_top=(vs_base=base+2)+1; |
89 |
|
return; |
90 |
|
} |
91 |
|
} |
92 |
|
/* function definition for HIDE-VARIABLE-REFERENCE */ |
93 |
|
|
94 |
|
static void L5() |
95 |
|
{register object *base=vs_base; |
96 |
|
register object *sup=base+VM5; VC5 |
97 |
|
vs_reserve(VM5); |
98 |
|
{object V6; |
99 |
|
object V7; |
100 |
|
object V8; |
101 |
|
check_arg(3); |
102 |
|
V6=(base[0]); |
103 |
|
V7=(base[1]); |
104 |
|
V8=(base[2]); |
105 |
|
vs_top=sup; |
106 |
|
goto TTL; |
107 |
|
TTL:; |
108 |
|
base[3]= (V8); |
109 |
|
vs_top=(vs_base=base+3)+1; |
110 |
|
return; |
111 |
|
} |
112 |
|
} |
113 |
|
/* macro definition for WITH-LOOP-LIST-COLLECTION-HEAD */ |
114 |
|
|
115 |
|
static void L6() |
116 |
|
{register object *base=vs_base; |
117 |
|
register object *sup=base+VM6; VC6 |
118 |
|
vs_reserve(VM6); |
119 |
|
check_arg(2); |
120 |
|
vs_top=sup; |
121 |
|
{object V9=base[0]->c.c_cdr; |
122 |
|
if(endp(V9))invalid_macro_call(); |
123 |
|
{object V10= (V9->c.c_car); |
124 |
|
if(endp(V10))invalid_macro_call(); |
125 |
|
base[2]= (V10->c.c_car); |
126 |
|
V10=V10->c.c_cdr; |
127 |
|
if(endp(V10))invalid_macro_call(); |
128 |
|
base[3]= (V10->c.c_car); |
129 |
|
V10=V10->c.c_cdr; |
130 |
|
if(endp(V10)){ |
131 |
|
base[4]= Cnil; |
132 |
|
} else { |
133 |
|
base[4]= (V10->c.c_car); |
134 |
|
V10=V10->c.c_cdr;} |
135 |
|
if(!endp(V10))invalid_macro_call();} |
136 |
|
V9=V9->c.c_cdr; |
137 |
|
base[5]= V9;} |
138 |
|
{object V11; |
139 |
|
if(base[4]==Cnil){ |
140 |
|
V11= Cnil; |
141 |
|
goto T14;} |
142 |
|
V12= list(2,base[4],Cnil); |
143 |
|
V11= make_cons(/* INLINE-ARGS */V12,Cnil); |
144 |
|
goto T14; |
145 |
|
T14:; |
146 |
|
V13= list(2,base[2],VV[4]); |
147 |
|
base[6]= listA(3,VV[3],listA(3,/* INLINE-ARGS */V13,list(2,base[3],base[2]),(V11)),base[5]); |
148 |
|
vs_top=(vs_base=base+6)+1; |
149 |
|
return;} |
150 |
|
} |
151 |
|
/* macro definition for LOOP-COLLECT-RPLACD */ |
152 |
|
|
153 |
|
static void L7() |
154 |
|
{register object *base=vs_base; |
155 |
|
register object *sup=base+VM7; VC7 |
156 |
|
vs_reserve(VM7); |
157 |
|
check_arg(2); |
158 |
|
vs_top=sup; |
159 |
|
{object V14=base[0]->c.c_cdr; |
160 |
|
if(endp(V14))invalid_macro_call(); |
161 |
|
{object V15= (V14->c.c_car); |
162 |
|
if(endp(V15))invalid_macro_call(); |
163 |
|
base[2]= (V15->c.c_car); |
164 |
|
V15=V15->c.c_cdr; |
165 |
|
if(endp(V15))invalid_macro_call(); |
166 |
|
base[3]= (V15->c.c_car); |
167 |
|
V15=V15->c.c_cdr; |
168 |
|
if(endp(V15)){ |
169 |
|
base[4]= Cnil; |
170 |
|
} else { |
171 |
|
base[4]= (V15->c.c_car); |
172 |
|
V15=V15->c.c_cdr;} |
173 |
|
if(!endp(V15))invalid_macro_call();} |
174 |
|
V14=V14->c.c_cdr; |
175 |
|
if(endp(V14))invalid_macro_call(); |
176 |
|
base[5]= (V14->c.c_car); |
177 |
|
V14=V14->c.c_cdr; |
178 |
|
if(!endp(V14))invalid_macro_call();} |
179 |
|
base[6]= base[5]; |
180 |
|
base[7]= base[1]; |
181 |
|
vs_top=(vs_base=base+6)+2; |
182 |
|
Lmacroexpand(); |
183 |
|
vs_top=sup; |
184 |
|
base[5]= vs_base[0]; |
185 |
|
{register object V17; |
186 |
|
V17= Cnil; |
187 |
|
if(!(type_of(base[5])==t_cons)){ |
188 |
|
goto T20;} |
189 |
|
if(!((car(base[5]))==(VV[5]))){ |
190 |
|
goto T24;} |
191 |
|
V18 = make_fixnum((long)length(cdr(base[5]))); |
192 |
|
V17= one_minus(V18); |
193 |
|
goto T20; |
194 |
|
goto T24; |
195 |
|
T24:; |
196 |
|
{register object x= car(base[5]),V19= VV[6]; |
197 |
|
while(!endp(V19)) |
198 |
|
if(eql(x,V19->c.c_car)){ |
199 |
|
goto T28; |
200 |
|
}else V19=V19->c.c_cdr; |
201 |
|
goto T20;} |
202 |
|
goto T28; |
203 |
|
T28:; |
204 |
|
if((cddr(base[5]))==Cnil){ |
205 |
|
goto T20;} |
206 |
|
base[6]= base[5]; |
207 |
|
vs_top=(vs_base=base+6)+1; |
208 |
|
Llast(); |
209 |
|
vs_top=sup; |
210 |
|
V21= vs_base[0]; |
211 |
|
{register object x= car(V21),V20= VV[7]; |
212 |
|
while(!endp(V20)) |
213 |
|
if(eql(x,V20->c.c_car)){ |
214 |
|
goto T32; |
215 |
|
}else V20=V20->c.c_cdr; |
216 |
|
goto T20;} |
217 |
|
goto T32; |
218 |
|
T32:; |
219 |
|
V22 = make_fixnum((long)length(cdr(base[5]))); |
220 |
|
V17= number_minus(V22,small_fixnum(2)); |
221 |
|
goto T20; |
222 |
|
T20:; |
223 |
|
{object V23; |
224 |
|
if(((V17))!=Cnil){ |
225 |
|
goto T38;} |
226 |
|
V24= list(3,VV[9],list(2,VV[10],base[3]),base[5]); |
227 |
|
V23= list(3,VV[8],/* INLINE-ARGS */V24,list(3,VV[11],base[3],list(2,VV[12],list(2,VV[10],base[3])))); |
228 |
|
goto T36; |
229 |
|
goto T38; |
230 |
|
T38:; |
231 |
|
if(!(number_compare((V17),small_fixnum(0))<0)){ |
232 |
|
goto T41;} |
233 |
|
base[6]= Cnil; |
234 |
|
vs_top=(vs_base=base+6)+1; |
235 |
|
return; |
236 |
|
goto T41; |
237 |
|
T41:; |
238 |
|
if(!(number_compare((V17),small_fixnum(0))==0)){ |
239 |
|
goto T44;} |
240 |
|
V23= list(3,VV[13],base[3],list(3,VV[11],base[3],base[5])); |
241 |
|
goto T36; |
242 |
|
goto T44; |
243 |
|
T44:; |
244 |
|
base[6]= list(3,VV[9],list(2,VV[10],base[3]),base[5]); |
245 |
|
base[7]= (V17); |
246 |
|
vs_top=(vs_base=base+6)+2; |
247 |
|
L8(base); |
248 |
|
vs_top=sup; |
249 |
|
V25= vs_base[0]; |
250 |
|
V23= list(3,VV[11],base[3],V25); |
251 |
|
goto T36; |
252 |
|
T36:; |
253 |
|
if((base[4])==Cnil){ |
254 |
|
goto T49;} |
255 |
|
V23= list(3,VV[14],(V23),list(3,VV[11],base[4],list(2,VV[10],base[2]))); |
256 |
|
goto T49; |
257 |
|
T49:; |
258 |
|
base[6]= (V23); |
259 |
|
vs_top=(vs_base=base+6)+1; |
260 |
|
return;}} |
261 |
|
} |
262 |
|
/* macro definition for LOOP-COLLECT-ANSWER */ |
263 |
|
|
264 |
|
static void L9() |
265 |
|
{register object *base=vs_base; |
266 |
|
register object *sup=base+VM8; VC8 |
267 |
|
vs_reserve(VM8); |
268 |
|
check_arg(2); |
269 |
|
vs_top=sup; |
270 |
|
{object V26=base[0]->c.c_cdr; |
271 |
|
if(endp(V26))invalid_macro_call(); |
272 |
|
base[2]= (V26->c.c_car); |
273 |
|
V26=V26->c.c_cdr; |
274 |
|
if(endp(V26)){ |
275 |
|
base[3]= Cnil; |
276 |
|
} else { |
277 |
|
base[3]= (V26->c.c_car); |
278 |
|
V26=V26->c.c_cdr;} |
279 |
|
if(!endp(V26))invalid_macro_call();} |
280 |
|
if(base[3]!=Cnil){ |
281 |
|
vs_top=(vs_base=base+3)+1; |
282 |
|
return;} |
283 |
|
base[4]= list(2,VV[10],base[2]); |
284 |
|
vs_top=(vs_base=base+4)+1; |
285 |
|
return; |
286 |
|
} |
287 |
|
/* function definition for MAKE-LOOP-MINIMAX-INTERNAL */ |
288 |
|
|
289 |
|
static void L10() |
290 |
|
{register object *base=vs_base; |
291 |
|
register object *sup=base+VM9; VC9 |
292 |
|
vs_reserve(VM9); |
293 |
|
{object V27; |
294 |
|
object V28; |
295 |
|
object V29; |
296 |
|
object V30; |
297 |
|
object V31; |
298 |
|
object V32; |
299 |
|
parse_key(vs_base,FALSE,FALSE,6,VV[21],VV[22],VV[23],VV[25],VV[27],VV[28]); |
300 |
|
vs_top=sup; |
301 |
|
V27=(base[0]); |
302 |
|
V28=(base[1]); |
303 |
|
V29=(base[2]); |
304 |
|
V30=(base[3]); |
305 |
|
V31=(base[4]); |
306 |
|
V32=(base[5]); |
307 |
|
base[12]= VV[18]; |
308 |
|
base[13]= (V27); |
309 |
|
base[14]= (V28); |
310 |
|
base[15]= (V29); |
311 |
|
base[16]= (V30); |
312 |
|
base[17]= (V31); |
313 |
|
base[18]= (V32); |
314 |
|
vs_top=(vs_base=base+12)+7; |
315 |
|
siLmake_structure(); |
316 |
|
return; |
317 |
|
} |
318 |
|
} |
319 |
|
/* function definition for MAKE-LOOP-MINIMAX */ |
320 |
|
|
321 |
|
static void L11() |
322 |
|
{register object *base=vs_base; |
323 |
|
register object *sup=base+VM10; VC10 |
324 |
|
vs_reserve(VM10); |
325 |
|
{object V33; |
326 |
|
object V34; |
327 |
|
check_arg(2); |
328 |
|
V33=(base[0]); |
329 |
|
V34=(base[1]); |
330 |
|
vs_top=sup; |
331 |
|
goto TTL; |
332 |
|
TTL:; |
333 |
|
{object V35; |
334 |
|
base[2]= (V34); |
335 |
|
base[3]= symbol_value(VV[19]); |
336 |
|
base[4]= VV[20]; |
337 |
|
base[5]= symbol_function(VV[326]); |
338 |
|
vs_top=(vs_base=base+2)+4; |
339 |
|
Lassoc(); |
340 |
|
vs_top=sup; |
341 |
|
V36= vs_base[0]; |
342 |
|
V35= cdr(V36); |
343 |
|
base[2]= VV[21]; |
344 |
|
base[3]= (V33); |
345 |
|
base[4]= VV[22]; |
346 |
|
base[5]= (V34); |
347 |
|
base[6]= VV[23]; |
348 |
|
base[8]= VV[24]; |
349 |
|
vs_top=(vs_base=base+8)+1; |
350 |
|
(void) (*Lnk327)(); |
351 |
|
vs_top=sup; |
352 |
|
base[7]= vs_base[0]; |
353 |
|
base[8]= VV[25]; |
354 |
|
if(((V35))==Cnil){ |
355 |
|
goto T76;} |
356 |
|
base[9]= Cnil; |
357 |
|
goto T75; |
358 |
|
goto T76; |
359 |
|
T76:; |
360 |
|
base[10]= VV[26]; |
361 |
|
vs_top=(vs_base=base+10)+1; |
362 |
|
(void) (*Lnk327)(); |
363 |
|
vs_top=sup; |
364 |
|
base[9]= vs_base[0]; |
365 |
|
goto T75; |
366 |
|
T75:; |
367 |
|
base[10]= VV[27]; |
368 |
|
base[11]= Cnil; |
369 |
|
base[12]= VV[28]; |
370 |
|
base[13]= (V35); |
371 |
|
vs_top=(vs_base=base+2)+12; |
372 |
|
(void) (*Lnk328)(); |
373 |
|
return;} |
374 |
|
} |
375 |
|
} |
376 |
|
/* function definition for LOOP-NOTE-MINIMAX-OPERATION */ |
377 |
|
|
378 |
|
static void L12() |
379 |
|
{register object *base=vs_base; |
380 |
|
register object *sup=base+VM11; VC11 |
381 |
|
vs_reserve(VM11); |
382 |
|
{object V37; |
383 |
|
register object V38; |
384 |
|
check_arg(2); |
385 |
|
V37=(base[0]); |
386 |
|
V38=(base[1]); |
387 |
|
vs_top=sup; |
388 |
|
goto TTL; |
389 |
|
TTL:; |
390 |
|
{object V41; |
391 |
|
base[3]= V37; |
392 |
|
base[4]= structure_ref(V38,VV[18],4); |
393 |
|
vs_top=(vs_base=base+3)+2; |
394 |
|
Ladjoin(); |
395 |
|
vs_top=sup; |
396 |
|
V41= vs_base[0]; |
397 |
|
(void)(structure_set(V38,VV[18],4,(V41)));} |
398 |
|
V42= structure_ref((V38),VV[18],4); |
399 |
|
if((cdr(/* INLINE-ARGS */V42))==Cnil){ |
400 |
|
goto T87;} |
401 |
|
if((structure_ref((V38),VV[18],3))!=Cnil){ |
402 |
|
goto T87;} |
403 |
|
base[2]= VV[26]; |
404 |
|
vs_top=(vs_base=base+2)+1; |
405 |
|
(void) (*Lnk327)(); |
406 |
|
vs_top=sup; |
407 |
|
V43= vs_base[0]; |
408 |
|
(void)(structure_set((V38),VV[18],3,V43)); |
409 |
|
goto T87; |
410 |
|
T87:; |
411 |
|
base[2]= (V37); |
412 |
|
vs_top=(vs_base=base+2)+1; |
413 |
|
return; |
414 |
|
} |
415 |
|
} |
416 |
|
/* macro definition for WITH-MINIMAX-VALUE */ |
417 |
|
|
418 |
|
static void L13() |
419 |
|
{register object *base=vs_base; |
420 |
|
register object *sup=base+VM12; VC12 |
421 |
|
vs_reserve(VM12); |
422 |
|
check_arg(2); |
423 |
|
vs_top=sup; |
424 |
|
{object V44=base[0]->c.c_cdr; |
425 |
|
if(endp(V44))invalid_macro_call(); |
426 |
|
base[2]= (V44->c.c_car); |
427 |
|
V44=V44->c.c_cdr; |
428 |
|
base[3]= V44;} |
429 |
|
{object V45; |
430 |
|
object V46; |
431 |
|
object V47; |
432 |
|
register object V48; |
433 |
|
register object V49; |
434 |
|
object V50; |
435 |
|
object V51; |
436 |
|
base[4]= structure_ref(base[2],VV[18],1); |
437 |
|
vs_top=(vs_base=base+4)+1; |
438 |
|
(void) (*Lnk329)(); |
439 |
|
vs_top=sup; |
440 |
|
V45= vs_base[0]; |
441 |
|
V52= structure_ref(base[2],VV[18],4); |
442 |
|
V46= car(/* INLINE-ARGS */V52); |
443 |
|
V47= structure_ref(base[2],VV[18],5); |
444 |
|
V48= structure_ref(base[2],VV[18],0); |
445 |
|
V49= structure_ref(base[2],VV[18],2); |
446 |
|
V50= structure_ref(base[2],VV[18],3); |
447 |
|
V51= structure_ref(base[2],VV[18],1); |
448 |
|
if(((V50))==Cnil){ |
449 |
|
goto T103;} |
450 |
|
V53= list(2,(V48),(V45)); |
451 |
|
V54= list(2,(V49),(V45)); |
452 |
|
V55= list(3,/* INLINE-ARGS */V53,/* INLINE-ARGS */V54,list(2,(V50),Cnil)); |
453 |
|
base[4]= listA(4,VV[29],/* INLINE-ARGS */V55,list(2,VV[30],list(4,VV[31],(V51),(V48),(V49))),base[3]); |
454 |
|
vs_top=(vs_base=base+4)+1; |
455 |
|
return; |
456 |
|
goto T103; |
457 |
|
T103:; |
458 |
|
if(!(((V46))==(VV[32]))){ |
459 |
|
goto T107;} |
460 |
|
V56= car((V47)); |
461 |
|
goto T105; |
462 |
|
goto T107; |
463 |
|
T107:; |
464 |
|
V56= cadr((V47)); |
465 |
|
goto T105; |
466 |
|
T105:; |
467 |
|
V57= list(2,(V48),V56); |
468 |
|
V58= list(2,/* INLINE-ARGS */V57,list(2,(V49),(V45))); |
469 |
|
base[4]= listA(4,VV[29],/* INLINE-ARGS */V58,list(2,VV[30],list(4,VV[31],(V51),(V48),(V49))),base[3]); |
470 |
|
vs_top=(vs_base=base+4)+1; |
471 |
|
return;} |
472 |
|
} |
473 |
|
/* macro definition for LOOP-ACCUMULATE-MINIMAX-VALUE */ |
474 |
|
|
475 |
|
static void L14() |
476 |
|
{register object *base=vs_base; |
477 |
|
register object *sup=base+VM13; VC13 |
478 |
|
vs_reserve(VM13); |
479 |
|
check_arg(2); |
480 |
|
vs_top=sup; |
481 |
|
{object V59=base[0]->c.c_cdr; |
482 |
|
if(endp(V59))invalid_macro_call(); |
483 |
|
base[2]= (V59->c.c_car); |
484 |
|
V59=V59->c.c_cdr; |
485 |
|
if(endp(V59))invalid_macro_call(); |
486 |
|
base[3]= (V59->c.c_car); |
487 |
|
V59=V59->c.c_cdr; |
488 |
|
if(endp(V59))invalid_macro_call(); |
489 |
|
base[4]= (V59->c.c_car); |
490 |
|
V59=V59->c.c_cdr; |
491 |
|
if(!endp(V59))invalid_macro_call();} |
492 |
|
{object V60; |
493 |
|
object V61; |
494 |
|
register object V62; |
495 |
|
object V63; |
496 |
|
V60= structure_ref(base[2],VV[18],0); |
497 |
|
V61= structure_ref(base[2],VV[18],2); |
498 |
|
V62= structure_ref(base[2],VV[18],3); |
499 |
|
base[9]= Ct; |
500 |
|
base[10]= structure_ref(base[2],VV[18],0); |
501 |
|
{object V65= base[3]; |
502 |
|
if((V65!= VV[32]))goto T117; |
503 |
|
V64= VV[33]; |
504 |
|
goto T116; |
505 |
|
goto T117; |
506 |
|
T117:; |
507 |
|
if((V65!= VV[330]))goto T118; |
508 |
|
V64= VV[34]; |
509 |
|
goto T116; |
510 |
|
goto T118; |
511 |
|
T118:; |
512 |
|
FEerror("The ECASE key value ~s is illegal.",1,V65); |
513 |
|
V64= Cnil; |
514 |
|
goto T116;} |
515 |
|
goto T116; |
516 |
|
T116:; |
517 |
|
base[11]= list(3,V64,(V61),(V60)); |
518 |
|
vs_top=(vs_base=base+9)+3; |
519 |
|
(void) (*Lnk331)(); |
520 |
|
vs_top=sup; |
521 |
|
V63= vs_base[0]; |
522 |
|
V66= list(3,VV[11],(V61),base[4]); |
523 |
|
if(((V62))==Cnil){ |
524 |
|
goto T121;} |
525 |
|
V67= list(3,VV[35],list(2,VV[36],(V62)),(V63)); |
526 |
|
goto T119; |
527 |
|
goto T121; |
528 |
|
T121:; |
529 |
|
V67= (V63); |
530 |
|
goto T119; |
531 |
|
T119:; |
532 |
|
if((V62)==Cnil){ |
533 |
|
V68= Cnil; |
534 |
|
goto T123;} |
535 |
|
V68= list(2,(V62),Ct); |
536 |
|
goto T123; |
537 |
|
T123:; |
538 |
|
V69= list(2,(V60),(V61)); |
539 |
|
V70= append(V68,/* INLINE-ARGS */V69); |
540 |
|
base[9]= list(3,VV[14],/* INLINE-ARGS */V66,list(3,VV[8],V67,make_cons(VV[11],/* INLINE-ARGS */V70))); |
541 |
|
vs_top=(vs_base=base+9)+1; |
542 |
|
return;} |
543 |
|
} |
544 |
|
/* function definition for LOOP-TEQUAL */ |
545 |
|
|
546 |
|
static void L15() |
547 |
|
{register object *base=vs_base; |
548 |
|
register object *sup=base+VM14; VC14 |
549 |
|
vs_reserve(VM14); |
550 |
|
{object V71; |
551 |
|
object V72; |
552 |
|
check_arg(2); |
553 |
|
V71=(base[0]); |
554 |
|
V72=(base[1]); |
555 |
|
vs_top=sup; |
556 |
|
goto TTL; |
557 |
|
TTL:; |
558 |
|
if(type_of((V71))==t_symbol){ |
559 |
|
goto T124;} |
560 |
|
base[2]= Cnil; |
561 |
|
vs_top=(vs_base=base+2)+1; |
562 |
|
return; |
563 |
|
goto T124; |
564 |
|
T124:; |
565 |
|
base[2]= (V71); |
566 |
|
base[3]= (V72); |
567 |
|
vs_top=(vs_base=base+2)+2; |
568 |
|
Lstring_eq(); |
569 |
|
return; |
570 |
|
} |
571 |
|
} |
572 |
|
/* function definition for LOOP-TASSOC */ |
573 |
|
|
574 |
|
static void L16() |
575 |
|
{register object *base=vs_base; |
576 |
|
register object *sup=base+VM15; VC15 |
577 |
|
vs_reserve(VM15); |
578 |
|
{object V73; |
579 |
|
object V74; |
580 |
|
check_arg(2); |
581 |
|
V73=(base[0]); |
582 |
|
V74=(base[1]); |
583 |
|
vs_top=sup; |
584 |
|
goto TTL; |
585 |
|
TTL:; |
586 |
|
if(type_of((V73))==t_symbol){ |
587 |
|
goto T128;} |
588 |
|
base[2]= Cnil; |
589 |
|
vs_top=(vs_base=base+2)+1; |
590 |
|
return; |
591 |
|
goto T128; |
592 |
|
T128:; |
593 |
|
base[2]= (V73); |
594 |
|
base[3]= (V74); |
595 |
|
base[4]= VV[20]; |
596 |
|
base[5]= symbol_function(VV[332]); |
597 |
|
vs_top=(vs_base=base+2)+4; |
598 |
|
Lassoc(); |
599 |
|
return; |
600 |
|
} |
601 |
|
} |
602 |
|
/* function definition for LOOP-TMEMBER */ |
603 |
|
|
604 |
|
static void L17() |
605 |
|
{register object *base=vs_base; |
606 |
|
register object *sup=base+VM16; VC16 |
607 |
|
vs_reserve(VM16); |
608 |
|
{object V75; |
609 |
|
object V76; |
610 |
|
check_arg(2); |
611 |
|
V75=(base[0]); |
612 |
|
V76=(base[1]); |
613 |
|
vs_top=sup; |
614 |
|
goto TTL; |
615 |
|
TTL:; |
616 |
|
if(type_of((V75))==t_symbol){ |
617 |
|
goto T134;} |
618 |
|
base[2]= Cnil; |
619 |
|
vs_top=(vs_base=base+2)+1; |
620 |
|
return; |
621 |
|
goto T134; |
622 |
|
T134:; |
623 |
|
base[2]= (V75); |
624 |
|
base[3]= (V76); |
625 |
|
base[4]= VV[20]; |
626 |
|
base[5]= symbol_function(VV[332]); |
627 |
|
vs_top=(vs_base=base+2)+4; |
628 |
|
Lmember(); |
629 |
|
return; |
630 |
|
} |
631 |
|
} |
632 |
|
/* function definition for LOOP-LOOKUP-KEYWORD */ |
633 |
|
|
634 |
|
static void L18() |
635 |
|
{register object *base=vs_base; |
636 |
|
register object *sup=base+VM17; VC17 |
637 |
|
vs_reserve(VM17); |
638 |
|
{object V77; |
639 |
|
object V78; |
640 |
|
check_arg(2); |
641 |
|
V77=(base[0]); |
642 |
|
V78=(base[1]); |
643 |
|
vs_top=sup; |
644 |
|
goto TTL; |
645 |
|
TTL:; |
646 |
|
if(type_of((V77))==t_symbol){ |
647 |
|
goto T140;} |
648 |
|
base[2]= Cnil; |
649 |
|
vs_top=(vs_base=base+2)+1; |
650 |
|
return; |
651 |
|
goto T140; |
652 |
|
T140:; |
653 |
|
base[3]= symbol_name((V77)); |
654 |
|
base[4]= (V78); |
655 |
|
vs_top=(vs_base=base+3)+2; |
656 |
|
Lgethash(); |
657 |
|
vs_top=sup; |
658 |
|
base[2]= vs_base[0]; |
659 |
|
vs_top=(vs_base=base+2)+1; |
660 |
|
return; |
661 |
|
} |
662 |
|
} |
663 |
|
/* macro definition for LOOP-STORE-TABLE-DATA */ |
664 |
|
|
665 |
|
static void L19() |
666 |
|
{register object *base=vs_base; |
667 |
|
register object *sup=base+VM18; VC18 |
668 |
|
vs_reserve(VM18); |
669 |
|
check_arg(2); |
670 |
|
vs_top=sup; |
671 |
|
{object V79=base[0]->c.c_cdr; |
672 |
|
if(endp(V79))invalid_macro_call(); |
673 |
|
base[2]= (V79->c.c_car); |
674 |
|
V79=V79->c.c_cdr; |
675 |
|
if(endp(V79))invalid_macro_call(); |
676 |
|
base[3]= (V79->c.c_car); |
677 |
|
V79=V79->c.c_cdr; |
678 |
|
if(endp(V79))invalid_macro_call(); |
679 |
|
base[4]= (V79->c.c_car); |
680 |
|
V79=V79->c.c_cdr; |
681 |
|
if(!endp(V79))invalid_macro_call();} |
682 |
|
base[5]= list(3,VV[9],list(3,VV[37],list(2,VV[38],base[2]),base[3]),base[4]); |
683 |
|
vs_top=(vs_base=base+5)+1; |
684 |
|
return; |
685 |
|
} |
686 |
|
/* function definition for MAKE-LOOP-UNIVERSE */ |
687 |
|
|
688 |
|
static void L20() |
689 |
|
{register object *base=vs_base; |
690 |
|
register object *sup=base+VM19; VC19 |
691 |
|
vs_reserve(VM19); |
692 |
|
{object V80; |
693 |
|
object V81; |
694 |
|
object V82; |
695 |
|
object V83; |
696 |
|
object V84; |
697 |
|
object V85; |
698 |
|
object V86; |
699 |
|
object V87; |
700 |
|
parse_key(vs_base,FALSE,FALSE,8,VV[53],VV[55],VV[54],VV[56],VV[60],VV[59],VV[57],VV[58]); |
701 |
|
vs_top=sup; |
702 |
|
V80=(base[0]); |
703 |
|
V81=(base[1]); |
704 |
|
V82=(base[2]); |
705 |
|
V83=(base[3]); |
706 |
|
V84=(base[4]); |
707 |
|
V85=(base[5]); |
708 |
|
V86=(base[6]); |
709 |
|
V87=(base[7]); |
710 |
|
base[16]= VV[39]; |
711 |
|
base[17]= (V80); |
712 |
|
base[18]= (V81); |
713 |
|
base[19]= (V82); |
714 |
|
base[20]= (V83); |
715 |
|
base[21]= (V84); |
716 |
|
base[22]= (V85); |
717 |
|
base[23]= (V86); |
718 |
|
base[24]= (V87); |
719 |
|
vs_top=(vs_base=base+16)+9; |
720 |
|
siLmake_structure(); |
721 |
|
return; |
722 |
|
} |
723 |
|
} |
724 |
|
/* function definition for PRINT-LOOP-UNIVERSE */ |
725 |
|
|
726 |
|
static void L21() |
727 |
|
{register object *base=vs_base; |
728 |
|
register object *sup=base+VM20; VC20 |
729 |
|
vs_reserve(VM20); |
730 |
|
{object V88; |
731 |
|
object V89; |
732 |
|
object V90; |
733 |
|
check_arg(3); |
734 |
|
V88=(base[0]); |
735 |
|
V89=(base[1]); |
736 |
|
V90=(base[2]); |
737 |
|
vs_top=sup; |
738 |
|
goto TTL; |
739 |
|
TTL:; |
740 |
|
{object V91; |
741 |
|
V93= structure_ref((V88),VV[39],6); |
742 |
|
{object V92= /* INLINE-ARGS */V93; |
743 |
|
if((V92!= Cnil))goto T155; |
744 |
|
V91= VV[40]; |
745 |
|
goto T154; |
746 |
|
goto T155; |
747 |
|
T155:; |
748 |
|
if((V92!= Ct))goto T156; |
749 |
|
V91= VV[41]; |
750 |
|
goto T154; |
751 |
|
goto T156; |
752 |
|
T156:; |
753 |
|
if((V92!= VV[307]))goto T157; |
754 |
|
V91= VV[42]; |
755 |
|
goto T154; |
756 |
|
goto T157; |
757 |
|
T157:; |
758 |
|
V91= structure_ref((V88),VV[39],6);} |
759 |
|
goto T154; |
760 |
|
T154:; |
761 |
|
base[3]= (V89); |
762 |
|
base[4]= VV[43]; |
763 |
|
base[6]= (V88); |
764 |
|
vs_top=(vs_base=base+6)+1; |
765 |
|
Ltype_of(); |
766 |
|
vs_top=sup; |
767 |
|
base[5]= vs_base[0]; |
768 |
|
base[6]= (V91); |
769 |
|
vs_top=(vs_base=base+3)+4; |
770 |
|
Lformat(); |
771 |
|
return;} |
772 |
|
} |
773 |
|
} |
774 |
|
/* function definition for MAKE-STANDARD-LOOP-UNIVERSE */ |
775 |
|
|
776 |
|
static void L22() |
777 |
|
{register object *base=vs_base; |
778 |
|
register object *sup=base+VM21; VC21 |
779 |
|
vs_reserve(VM21); |
780 |
|
bds_check; |
781 |
|
{object V94; |
782 |
|
object V95; |
783 |
|
object V96; |
784 |
|
object V97; |
785 |
|
object V98; |
786 |
|
object V99; |
787 |
|
register object V100; |
788 |
|
parse_key(vs_base,FALSE,FALSE,7,VV[53],VV[54],VV[55],VV[56],VV[59],VV[60],VV[57]); |
789 |
|
vs_top=sup; |
790 |
|
V94=(base[0]); |
791 |
|
V95=(base[1]); |
792 |
|
V96=(base[2]); |
793 |
|
V97=(base[3]); |
794 |
|
V98=(base[4]); |
795 |
|
V99=(base[5]); |
796 |
|
V100=(base[6]); |
797 |
|
bds_bind(VV[44],small_fixnum(4)); |
798 |
|
bds_bind(VV[45],small_fixnum(4)); |
799 |
|
goto T165; |
800 |
|
T165:; |
801 |
|
base[16]= (V100); |
802 |
|
base[17]= VV[46]; |
803 |
|
vs_top=(vs_base=base+16)+2; |
804 |
|
(void) (*Lnk333)(); |
805 |
|
vs_top=sup; |
806 |
|
if((vs_base[0])==Cnil){ |
807 |
|
goto T166;} |
808 |
|
bds_unwind1; |
809 |
|
bds_unwind1; |
810 |
|
goto T163; |
811 |
|
goto T166; |
812 |
|
T166:; |
813 |
|
base[16]= VV[47]; |
814 |
|
base[17]= VV[48]; |
815 |
|
base[18]= VV[49]; |
816 |
|
base[19]= (V100); |
817 |
|
base[20]= VV[46]; |
818 |
|
vs_top=(vs_base=base+16)+5; |
819 |
|
Lcerror(); |
820 |
|
vs_top=sup; |
821 |
|
base[16]= symbol_value(VV[50]); |
822 |
|
base[17]= VV[51]; |
823 |
|
base[18]= VV[49]; |
824 |
|
vs_top=(vs_base=base+16)+3; |
825 |
|
Lformat(); |
826 |
|
vs_top=sup; |
827 |
|
base[16]= symbol_value(VV[50]); |
828 |
|
vs_top=(vs_base=base+16)+1; |
829 |
|
Lfinish_output(); |
830 |
|
vs_top=sup; |
831 |
|
vs_base=vs_top; |
832 |
|
Lread(); |
833 |
|
vs_top=sup; |
834 |
|
V100= vs_base[0]; |
835 |
|
base[16]= symbol_value(VV[50]); |
836 |
|
base[17]= VV[52]; |
837 |
|
vs_top=(vs_base=base+16)+2; |
838 |
|
Lformat(); |
839 |
|
vs_top=sup; |
840 |
|
goto T165; |
841 |
|
goto T163; |
842 |
|
T163:; |
843 |
|
base[14]= VV[53]; |
844 |
|
base[16]= (V94); |
845 |
|
vs_top=(vs_base=base+16)+1; |
846 |
|
L23(base); |
847 |
|
vs_top=sup; |
848 |
|
base[15]= vs_base[0]; |
849 |
|
base[16]= VV[54]; |
850 |
|
base[18]= (V95); |
851 |
|
vs_top=(vs_base=base+18)+1; |
852 |
|
L23(base); |
853 |
|
vs_top=sup; |
854 |
|
base[17]= vs_base[0]; |
855 |
|
base[18]= VV[55]; |
856 |
|
base[20]= (V96); |
857 |
|
vs_top=(vs_base=base+20)+1; |
858 |
|
L23(base); |
859 |
|
vs_top=sup; |
860 |
|
base[19]= vs_base[0]; |
861 |
|
base[20]= VV[56]; |
862 |
|
base[22]= (V97); |
863 |
|
vs_top=(vs_base=base+22)+1; |
864 |
|
L23(base); |
865 |
|
vs_top=sup; |
866 |
|
base[21]= vs_base[0]; |
867 |
|
base[22]= VV[57]; |
868 |
|
base[23]= (V100); |
869 |
|
base[24]= VV[58]; |
870 |
|
base[25]= (((((V100))==Cnil?Ct:Cnil))==Cnil?Ct:Cnil); |
871 |
|
base[26]= VV[59]; |
872 |
|
base[28]= (V98); |
873 |
|
vs_top=(vs_base=base+28)+1; |
874 |
|
L23(base); |
875 |
|
vs_top=sup; |
876 |
|
base[27]= vs_base[0]; |
877 |
|
base[28]= VV[60]; |
878 |
|
{object V101; |
879 |
|
object V102; |
880 |
|
V101= make_fixnum((long)length((V99))); |
881 |
|
base[32]= VV[61]; |
882 |
|
if(!(number_compare((V101),small_fixnum(10))<0)){ |
883 |
|
goto T217;} |
884 |
|
base[33]= small_fixnum(10); |
885 |
|
goto T215; |
886 |
|
goto T217; |
887 |
|
T217:; |
888 |
|
base[33]= (V101); |
889 |
|
goto T215; |
890 |
|
T215:; |
891 |
|
base[34]= VV[20]; |
892 |
|
base[35]= symbol_function(VV[334]); |
893 |
|
vs_top=(vs_base=base+32)+4; |
894 |
|
Lmake_hash_table(); |
895 |
|
vs_top=sup; |
896 |
|
V102= vs_base[0]; |
897 |
|
{register object V103; |
898 |
|
register object V104; |
899 |
|
V103= (V99); |
900 |
|
V104= car((V103)); |
901 |
|
goto T225; |
902 |
|
T225:; |
903 |
|
if(!(endp_prop((V103)))){ |
904 |
|
goto T226;} |
905 |
|
goto T221; |
906 |
|
goto T226; |
907 |
|
T226:; |
908 |
|
if(!(type_of((V104))!=t_cons)){ |
909 |
|
goto T232;} |
910 |
|
base[33]= V104; |
911 |
|
base[34]= V102; |
912 |
|
base[35]= V104; |
913 |
|
vs_top=(vs_base=base+33)+3; |
914 |
|
siLhash_set(); |
915 |
|
vs_top=sup; |
916 |
|
goto T230; |
917 |
|
goto T232; |
918 |
|
T232:; |
919 |
|
{object V108; |
920 |
|
object V110; |
921 |
|
V108= car((V104)); |
922 |
|
V110= cadr((V104)); |
923 |
|
base[35]= (V108); |
924 |
|
base[36]= V102; |
925 |
|
base[37]= (V110); |
926 |
|
vs_top=(vs_base=base+35)+3; |
927 |
|
siLhash_set(); |
928 |
|
vs_top=sup;} |
929 |
|
goto T230; |
930 |
|
T230:; |
931 |
|
V103= cdr((V103)); |
932 |
|
V104= car((V103)); |
933 |
|
goto T225;} |
934 |
|
goto T221; |
935 |
|
T221:; |
936 |
|
base[29]= (V102);} |
937 |
|
vs_top=(vs_base=base+14)+16; |
938 |
|
(void) (*Lnk335)(); |
939 |
|
return; |
940 |
|
} |
941 |
|
} |
942 |
|
/* function definition for LOOP-MAKE-PSETQ */ |
943 |
|
|
944 |
|
static void L24() |
945 |
|
{register object *base=vs_base; |
946 |
|
register object *sup=base+VM22; VC22 |
947 |
|
vs_reserve(VM22); |
948 |
|
{register object V111; |
949 |
|
check_arg(1); |
950 |
|
V111=(base[0]); |
951 |
|
vs_top=sup; |
952 |
|
goto TTL; |
953 |
|
TTL:; |
954 |
|
if((V111)==Cnil){ |
955 |
|
base[1]= Cnil; |
956 |
|
vs_top=(vs_base=base+1)+1; |
957 |
|
return;} |
958 |
|
V112= car((V111)); |
959 |
|
if((cddr((V111)))!=Cnil){ |
960 |
|
goto T250;} |
961 |
|
V113= cadr((V111)); |
962 |
|
goto T248; |
963 |
|
goto T250; |
964 |
|
T250:; |
965 |
|
V114= cadr((V111)); |
966 |
|
base[2]= cddr((V111)); |
967 |
|
vs_top=(vs_base=base+2)+1; |
968 |
|
(void) (*Lnk336)(); |
969 |
|
vs_top=sup; |
970 |
|
V115= vs_base[0]; |
971 |
|
V113= list(3,VV[62],/* INLINE-ARGS */V114,V115); |
972 |
|
goto T248; |
973 |
|
T248:; |
974 |
|
base[1]= list(2,/* INLINE-ARGS */V112,V113); |
975 |
|
vs_top=(vs_base=base+1)+1; |
976 |
|
(void) (*Lnk337)(); |
977 |
|
return; |
978 |
|
} |
979 |
|
} |
980 |
|
/* function definition for LOOP-MAKE-DESETQ */ |
981 |
|
|
982 |
|
static void L25() |
983 |
|
{register object *base=vs_base; |
984 |
|
register object *sup=base+VM23; VC23 |
985 |
|
vs_reserve(VM23); |
986 |
|
{object V116; |
987 |
|
check_arg(1); |
988 |
|
V116=(base[0]); |
989 |
|
vs_top=sup; |
990 |
|
goto TTL; |
991 |
|
TTL:; |
992 |
|
if(((V116))!=Cnil){ |
993 |
|
goto T255;} |
994 |
|
base[1]= Cnil; |
995 |
|
vs_top=(vs_base=base+1)+1; |
996 |
|
return; |
997 |
|
goto T255; |
998 |
|
T255:; |
999 |
|
if((symbol_value(VV[63]))==Cnil){ |
1000 |
|
goto T259;} |
1001 |
|
V117= cadr(symbol_value(VV[63])); |
1002 |
|
goto T257; |
1003 |
|
goto T259; |
1004 |
|
T259:; |
1005 |
|
V117= VV[64]; |
1006 |
|
goto T257; |
1007 |
|
T257:; |
1008 |
|
base[1]= make_cons(V117,(V116)); |
1009 |
|
vs_top=(vs_base=base+1)+1; |
1010 |
|
return; |
1011 |
|
} |
1012 |
|
} |
1013 |
|
/* macro definition for LOOP-REALLY-DESETQ */ |
1014 |
|
|
1015 |
|
static void L26() |
1016 |
|
{register object *base=vs_base; |
1017 |
|
register object *sup=base+VM24; VC24 |
1018 |
|
vs_reserve(VM24); |
1019 |
|
check_arg(2); |
1020 |
|
vs_top=sup; |
1021 |
|
{object V118=base[0]->c.c_cdr; |
1022 |
|
base[2]= V118;} |
1023 |
|
{register object V119; |
1024 |
|
V119= Cnil; |
1025 |
|
goto T262; |
1026 |
|
T262:; |
1027 |
|
if((base[2])!=Cnil){ |
1028 |
|
goto T263;} |
1029 |
|
if((cdr((V119)))!=Cnil){ |
1030 |
|
goto T267;} |
1031 |
|
base[3]= car((V119)); |
1032 |
|
vs_top=(vs_base=base+3)+1; |
1033 |
|
return; |
1034 |
|
goto T267; |
1035 |
|
T267:; |
1036 |
|
V120= nreverse((V119)); |
1037 |
|
base[3]= make_cons(VV[14],/* INLINE-ARGS */V120); |
1038 |
|
vs_top=(vs_base=base+3)+1; |
1039 |
|
return; |
1040 |
|
goto T263; |
1041 |
|
T263:; |
1042 |
|
{register object V121; |
1043 |
|
V121= car(base[2]); |
1044 |
|
base[2]= cdr(base[2]); |
1045 |
|
base[4]= (V121);} |
1046 |
|
{register object V122; |
1047 |
|
V122= car(base[2]); |
1048 |
|
base[2]= cdr(base[2]); |
1049 |
|
base[5]= (V122);} |
1050 |
|
vs_top=(vs_base=base+4)+2; |
1051 |
|
L28(base); |
1052 |
|
vs_top=sup; |
1053 |
|
base[3]= vs_base[0]; |
1054 |
|
base[4]= (V119); |
1055 |
|
vs_top=(vs_base=base+3)+2; |
1056 |
|
Lrevappend(); |
1057 |
|
vs_top=sup; |
1058 |
|
V119= vs_base[0]; |
1059 |
|
goto T262;} |
1060 |
|
} |
1061 |
|
/* function definition for LOOP-CONSTANT-FOLD-IF-POSSIBLE */ |
1062 |
|
|
1063 |
|
static void L29() |
1064 |
|
{register object *base=vs_base; |
1065 |
|
register object *sup=base+VM25; VC25 |
1066 |
|
vs_reserve(VM25); |
1067 |
|
{object V123; |
1068 |
|
object V124; |
1069 |
|
if(vs_top-vs_base<1) too_few_arguments(); |
1070 |
|
if(vs_top-vs_base>2) too_many_arguments(); |
1071 |
|
V123=(base[0]); |
1072 |
|
vs_base=vs_base+1; |
1073 |
|
if(vs_base>=vs_top){vs_top=sup;goto T284;} |
1074 |
|
V124=(base[1]); |
1075 |
|
vs_top=sup; |
1076 |
|
goto T285; |
1077 |
|
goto T284; |
1078 |
|
T284:; |
1079 |
|
V124= Cnil; |
1080 |
|
goto T285; |
1081 |
|
T285:; |
1082 |
|
{register object V126; |
1083 |
|
register object V127; |
1084 |
|
V126= Cnil; |
1085 |
|
V127= Cnil; |
1086 |
|
base[2]= V123; |
1087 |
|
vs_top=(vs_base=base+2)+1; |
1088 |
|
Lconstantp(); |
1089 |
|
vs_top=sup; |
1090 |
|
V126= vs_base[0]; |
1091 |
|
if(((V126))==Cnil){ |
1092 |
|
goto T287;} |
1093 |
|
base[2]= V123; |
1094 |
|
vs_top=(vs_base=base+2)+1; |
1095 |
|
Leval(); |
1096 |
|
vs_top=sup; |
1097 |
|
V127= vs_base[0]; |
1098 |
|
goto T287; |
1099 |
|
T287:; |
1100 |
|
if(((V126))==Cnil){ |
1101 |
|
goto T294;} |
1102 |
|
if(((V124))==Cnil){ |
1103 |
|
goto T294;} |
1104 |
|
base[2]= (V127); |
1105 |
|
base[3]= (V124); |
1106 |
|
vs_top=(vs_base=base+2)+2; |
1107 |
|
(void) (*Lnk333)(); |
1108 |
|
vs_top=sup; |
1109 |
|
if((vs_base[0])!=Cnil){ |
1110 |
|
goto T294;} |
1111 |
|
base[2]= VV[67]; |
1112 |
|
base[3]= (V123); |
1113 |
|
base[4]= (V127); |
1114 |
|
base[5]= (V124); |
1115 |
|
vs_top=(vs_base=base+2)+4; |
1116 |
|
(void) (*Lnk338)(); |
1117 |
|
vs_top=sup; |
1118 |
|
V126= Cnil; |
1119 |
|
V127= Cnil; |
1120 |
|
goto T294; |
1121 |
|
T294:; |
1122 |
|
base[2]= V123; |
1123 |
|
base[3]= (V126); |
1124 |
|
base[4]= (V127); |
1125 |
|
vs_top=(vs_base=base+2)+3; |
1126 |
|
return;} |
1127 |
|
} |
1128 |
|
} |
1129 |
|
/* function definition for LOOP-CONSTANTP */ |
1130 |
|
|
1131 |
|
static void L30() |
1132 |
|
{register object *base=vs_base; |
1133 |
|
register object *sup=base+VM26; VC26 |
1134 |
|
vs_reserve(VM26); |
1135 |
|
{object V128; |
1136 |
|
check_arg(1); |
1137 |
|
V128=(base[0]); |
1138 |
|
vs_top=sup; |
1139 |
|
goto TTL; |
1140 |
|
TTL:; |
1141 |
|
base[1]= (V128); |
1142 |
|
vs_top=(vs_base=base+1)+1; |
1143 |
|
Lconstantp(); |
1144 |
|
return; |
1145 |
|
} |
1146 |
|
} |
1147 |
|
/* function definition for LOOP-CODE-DUPLICATION-THRESHOLD */ |
1148 |
|
|
1149 |
|
static void L31() |
1150 |
|
{register object *base=vs_base; |
1151 |
|
register object *sup=base+VM27; VC27 |
1152 |
|
vs_reserve(VM27); |
1153 |
|
{object V129; |
1154 |
|
check_arg(1); |
1155 |
|
V129=(base[0]); |
1156 |
|
vs_top=sup; |
1157 |
|
goto TTL; |
1158 |
|
TTL:; |
1159 |
|
{object V130; |
1160 |
|
object V131; |
1161 |
|
base[1]= (V129); |
1162 |
|
vs_top=(vs_base=base+1)+1; |
1163 |
|
(void) (*Lnk339)(); |
1164 |
|
if(vs_base>=vs_top){vs_top=sup;goto T317;} |
1165 |
|
V130= vs_base[0]; |
1166 |
|
vs_base++; |
1167 |
|
if(vs_base>=vs_top){vs_top=sup;goto T318;} |
1168 |
|
V131= vs_base[0]; |
1169 |
|
vs_top=sup; |
1170 |
|
goto T319; |
1171 |
|
goto T317; |
1172 |
|
T317:; |
1173 |
|
V130= Cnil; |
1174 |
|
goto T318; |
1175 |
|
T318:; |
1176 |
|
V131= Cnil; |
1177 |
|
goto T319; |
1178 |
|
T319:; |
1179 |
|
V132= number_minus((V130),(V131)); |
1180 |
|
V133= number_times(/* INLINE-ARGS */V132,small_fixnum(10)); |
1181 |
|
base[1]= number_plus(small_fixnum(40),/* INLINE-ARGS */V133); |
1182 |
|
vs_top=(vs_base=base+1)+1; |
1183 |
|
return;} |
1184 |
|
} |
1185 |
|
} |
1186 |
|
/* macro definition for LOOP-BODY */ |
1187 |
|
|
1188 |
|
static void L32() |
1189 |
|
{register object *base=vs_base; |
1190 |
|
register object *sup=base+VM28; VC28 |
1191 |
|
vs_reserve(VM28); |
1192 |
|
check_arg(2); |
1193 |
|
vs_top=sup; |
1194 |
|
{object V134=base[0]->c.c_cdr; |
1195 |
|
if(endp(V134))invalid_macro_call(); |
1196 |
|
base[2]= (V134->c.c_car); |
1197 |
|
V134=V134->c.c_cdr; |
1198 |
|
if(endp(V134))invalid_macro_call(); |
1199 |
|
base[3]= (V134->c.c_car); |
1200 |
|
V134=V134->c.c_cdr; |
1201 |
|
if(endp(V134))invalid_macro_call(); |
1202 |
|
base[4]= (V134->c.c_car); |
1203 |
|
V134=V134->c.c_cdr; |
1204 |
|
if(endp(V134))invalid_macro_call(); |
1205 |
|
base[5]= (V134->c.c_car); |
1206 |
|
V134=V134->c.c_cdr; |
1207 |
|
if(endp(V134))invalid_macro_call(); |
1208 |
|
base[6]= (V134->c.c_car); |
1209 |
|
V134=V134->c.c_cdr; |
1210 |
|
if(!endp(V134))invalid_macro_call(); |
1211 |
|
base[7]= Cnil; |
1212 |
|
base[8]= Cnil; |
1213 |
|
base[9]= Cnil;} |
1214 |
|
if(((long)length(base[3]))==((long)length(base[5]))){ |
1215 |
|
goto T323;} |
1216 |
|
base[10]= VV[68]; |
1217 |
|
vs_top=(vs_base=base+10)+1; |
1218 |
|
Lerror(); |
1219 |
|
vs_top=sup; |
1220 |
|
goto T323; |
1221 |
|
T323:; |
1222 |
|
base[7]= reverse(base[3]); |
1223 |
|
base[8]= reverse(base[5]); |
1224 |
|
if((symbol_value(VV[69]))!=Cnil){ |
1225 |
|
goto T332;} |
1226 |
|
if((base[7])!=Cnil){ |
1227 |
|
goto T331;} |
1228 |
|
goto T332; |
1229 |
|
T332:; |
1230 |
|
vs_base=vs_top; |
1231 |
|
L35(base); |
1232 |
|
return; |
1233 |
|
goto T331; |
1234 |
|
T331:; |
1235 |
|
{register long V135; |
1236 |
|
base[10]= base[1]; |
1237 |
|
vs_top=(vs_base=base+10)+1; |
1238 |
|
(void) (*Lnk340)(); |
1239 |
|
vs_top=sup; |
1240 |
|
V135= fix(vs_base[0]); |
1241 |
|
goto T339; |
1242 |
|
T339:; |
1243 |
|
goto T344; |
1244 |
|
T344:; |
1245 |
|
if((base[7])==Cnil){ |
1246 |
|
goto T346;} |
1247 |
|
if(equal(car(base[7]),car(base[8]))){ |
1248 |
|
goto T345;} |
1249 |
|
goto T346; |
1250 |
|
T346:; |
1251 |
|
goto T342; |
1252 |
|
goto T345; |
1253 |
|
T345:; |
1254 |
|
{register object V136; |
1255 |
|
{register object V137; |
1256 |
|
V137= car(base[7]); |
1257 |
|
base[7]= cdr(base[7]); |
1258 |
|
V136= (V137);} |
1259 |
|
base[4]= make_cons((V136),base[4]);} |
1260 |
|
{register object V138; |
1261 |
|
V138= car(base[8]); |
1262 |
|
base[8]= cdr(base[8]);} |
1263 |
|
goto T344; |
1264 |
|
goto T342; |
1265 |
|
T342:; |
1266 |
|
if((base[7])!=Cnil){ |
1267 |
|
goto T363;} |
1268 |
|
vs_base=vs_top; |
1269 |
|
L35(base); |
1270 |
|
return; |
1271 |
|
goto T363; |
1272 |
|
T363:; |
1273 |
|
{register object V139; |
1274 |
|
register object V140; |
1275 |
|
register object V141; |
1276 |
|
register object V142; |
1277 |
|
register object V143; |
1278 |
|
V139= base[7]; |
1279 |
|
V140= base[8]; |
1280 |
|
V141= Cnil; |
1281 |
|
V142= small_fixnum(0); |
1282 |
|
V143= Cnil; |
1283 |
|
goto T368; |
1284 |
|
T368:; |
1285 |
|
if(((V139))!=Cnil){ |
1286 |
|
goto T369;} |
1287 |
|
vs_base=vs_top; |
1288 |
|
L35(base); |
1289 |
|
return; |
1290 |
|
goto T369; |
1291 |
|
T369:; |
1292 |
|
if(equal(car((V139)),car((V140)))){ |
1293 |
|
goto T375;} |
1294 |
|
V141= (V139); |
1295 |
|
V142= small_fixnum(0); |
1296 |
|
goto T373; |
1297 |
|
goto T375; |
1298 |
|
T375:; |
1299 |
|
base[10]= car((V139)); |
1300 |
|
base[11]= base[1]; |
1301 |
|
vs_top=(vs_base=base+10)+2; |
1302 |
|
(void) (*Lnk77)(); |
1303 |
|
vs_top=sup; |
1304 |
|
V143= vs_base[0]; |
1305 |
|
if(((V143))==Cnil){ |
1306 |
|
goto T380;} |
1307 |
|
V142= number_plus((V142),(V143)); |
1308 |
|
V144 = make_fixnum(V135); |
1309 |
|
if(!(number_compare((V142),V144)>0)){ |
1310 |
|
goto T373;} |
1311 |
|
goto T380; |
1312 |
|
T380:; |
1313 |
|
{register object V145; |
1314 |
|
register object V146; |
1315 |
|
V145= Cnil; |
1316 |
|
V146= Cnil; |
1317 |
|
goto T391; |
1318 |
|
T391:; |
1319 |
|
{register object V147; |
1320 |
|
{register object V148; |
1321 |
|
V148= car(base[7]); |
1322 |
|
base[7]= cdr(base[7]); |
1323 |
|
V147= (V148);} |
1324 |
|
V146= make_cons((V147),(V146));} |
1325 |
|
{register object V149; |
1326 |
|
{register object V150; |
1327 |
|
V150= car(base[8]); |
1328 |
|
base[8]= cdr(base[8]); |
1329 |
|
V149= (V150);} |
1330 |
|
V145= make_cons((V149),(V145));} |
1331 |
|
if(!((base[7])==(cdr((V141))))){ |
1332 |
|
goto T406;} |
1333 |
|
goto T389; |
1334 |
|
goto T406; |
1335 |
|
T406:; |
1336 |
|
goto T391; |
1337 |
|
goto T389; |
1338 |
|
T389:; |
1339 |
|
if((base[9])!=Cnil){ |
1340 |
|
goto T411;} |
1341 |
|
{register object V151; |
1342 |
|
base[9]= symbol_value(VV[70]); |
1343 |
|
V151= list(3,VV[11],base[9],Ct); |
1344 |
|
V146= make_cons((V151),(V146));} |
1345 |
|
goto T411; |
1346 |
|
T411:; |
1347 |
|
{register object V152; |
1348 |
|
base[12]= (V145); |
1349 |
|
vs_top=(vs_base=base+12)+1; |
1350 |
|
L33(base); |
1351 |
|
vs_top=sup; |
1352 |
|
base[11]= vs_base[0]; |
1353 |
|
vs_top=(vs_base=base+11)+1; |
1354 |
|
L34(base); |
1355 |
|
vs_top=sup; |
1356 |
|
V153= vs_base[0]; |
1357 |
|
base[12]= (V146); |
1358 |
|
vs_top=(vs_base=base+12)+1; |
1359 |
|
L33(base); |
1360 |
|
vs_top=sup; |
1361 |
|
base[11]= vs_base[0]; |
1362 |
|
vs_top=(vs_base=base+11)+1; |
1363 |
|
L34(base); |
1364 |
|
vs_top=sup; |
1365 |
|
V154= vs_base[0]; |
1366 |
|
V152= list(4,VV[71],base[9],V153,V154); |
1367 |
|
base[4]= make_cons((V152),base[4]);}} |
1368 |
|
goto T427; |
1369 |
|
T427:; |
1370 |
|
{register object V155; |
1371 |
|
V155= car(base[8]); |
1372 |
|
base[8]= cdr(base[8]);} |
1373 |
|
{register object V156; |
1374 |
|
{register object V157; |
1375 |
|
V157= car(base[7]); |
1376 |
|
base[7]= cdr(base[7]); |
1377 |
|
V156= (V157);} |
1378 |
|
base[4]= make_cons((V156),base[4]);} |
1379 |
|
if(!((base[7])==(cdr((V139))))){ |
1380 |
|
goto T440;} |
1381 |
|
goto T425; |
1382 |
|
goto T440; |
1383 |
|
T440:; |
1384 |
|
goto T427; |
1385 |
|
goto T425; |
1386 |
|
T425:; |
1387 |
|
goto T366; |
1388 |
|
goto T373; |
1389 |
|
T373:; |
1390 |
|
V139= cdr((V139)); |
1391 |
|
V140= cdr((V140)); |
1392 |
|
goto T368;} |
1393 |
|
goto T366; |
1394 |
|
T366:; |
1395 |
|
goto T339;} |
1396 |
|
} |
1397 |
|
/* function definition for DUPLICATABLE-CODE-P */ |
1398 |
|
|
1399 |
|
static void L36() |
1400 |
|
{register object *base=vs_base; |
1401 |
|
register object *sup=base+VM29; VC29 |
1402 |
|
vs_reserve(VM29); |
1403 |
|
{object V158; |
1404 |
|
object V159; |
1405 |
|
check_arg(2); |
1406 |
|
V158=(base[0]); |
1407 |
|
V159=(base[1]); |
1408 |
|
vs_top=sup; |
1409 |
|
goto TTL; |
1410 |
|
TTL:; |
1411 |
|
if(((V158))!=Cnil){ |
1412 |
|
goto T452;} |
1413 |
|
base[2]= small_fixnum(0); |
1414 |
|
vs_top=(vs_base=base+2)+1; |
1415 |
|
return; |
1416 |
|
goto T452; |
1417 |
|
T452:; |
1418 |
|
{long V160; |
1419 |
|
base[2]= (V158); |
1420 |
|
base[3]= (V159); |
1421 |
|
vs_top=(vs_base=base+2)+2; |
1422 |
|
(void) (*Lnk77)(); |
1423 |
|
vs_top=sup; |
1424 |
|
V160= fix(vs_base[0]); |
1425 |
|
base[2]= make_fixnum(V160); |
1426 |
|
vs_top=(vs_base=base+2)+1; |
1427 |
|
return;} |
1428 |
|
} |
1429 |
|
} |
1430 |
|
/* function definition for DESTRUCTURING-SIZE */ |
1431 |
|
|
1432 |
|
static void L37() |
1433 |
|
{register object *base=vs_base; |
1434 |
|
register object *sup=base+VM30; VC30 |
1435 |
|
vs_reserve(VM30); |
1436 |
|
{object V161; |
1437 |
|
check_arg(1); |
1438 |
|
V161=(base[0]); |
1439 |
|
vs_top=sup; |
1440 |
|
goto TTL; |
1441 |
|
TTL:; |
1442 |
|
{register object V162; |
1443 |
|
register object V163; |
1444 |
|
V162= (V161); |
1445 |
|
V163= small_fixnum(0); |
1446 |
|
goto T458; |
1447 |
|
T458:; |
1448 |
|
if(!(type_of((V162))!=t_cons)){ |
1449 |
|
goto T459;} |
1450 |
|
if(((V162))!=Cnil){ |
1451 |
|
goto T464;} |
1452 |
|
V164= small_fixnum(0); |
1453 |
|
goto T462; |
1454 |
|
goto T464; |
1455 |
|
T464:; |
1456 |
|
V164= small_fixnum(1); |
1457 |
|
goto T462; |
1458 |
|
T462:; |
1459 |
|
base[1]= number_plus((V163),V164); |
1460 |
|
vs_top=(vs_base=base+1)+1; |
1461 |
|
return; |
1462 |
|
goto T459; |
1463 |
|
T459:; |
1464 |
|
{object V165; |
1465 |
|
V165= cdr((V162)); |
1466 |
|
base[1]= car((V162)); |
1467 |
|
vs_top=(vs_base=base+1)+1; |
1468 |
|
(void) (*Lnk341)(); |
1469 |
|
vs_top=sup; |
1470 |
|
V166= vs_base[0]; |
1471 |
|
V163= number_plus(V166,(V163)); |
1472 |
|
V162= (V165);} |
1473 |
|
goto T458;} |
1474 |
|
} |
1475 |
|
} |
1476 |
|
/* function definition for ESTIMATE-CODE-SIZE */ |
1477 |
|
|
1478 |
|
static void L38() |
1479 |
|
{register object *VOL base=vs_base; |
1480 |
|
register object *VOL sup=base+VM31; VC31 |
1481 |
|
vs_reserve(VM31); |
1482 |
|
{VOL object V167; |
1483 |
|
VOL object V168; |
1484 |
|
check_arg(2); |
1485 |
|
V167=(base[0]); |
1486 |
|
V168=(base[1]); |
1487 |
|
vs_top=sup; |
1488 |
|
goto TTL; |
1489 |
|
TTL:; |
1490 |
|
frs_push(FRS_CATCH,VV[77]); |
1491 |
|
if(nlj_active) |
1492 |
|
{nlj_active=FALSE;frs_pop(); |
1493 |
|
return;} |
1494 |
|
else{ |
1495 |
|
base[2]= (V167); |
1496 |
|
base[3]= (V168); |
1497 |
|
vs_top=(vs_base=base+2)+2; |
1498 |
|
(void) (*Lnk342)(); |
1499 |
|
frs_pop(); |
1500 |
|
return;} |
1501 |
|
} |
1502 |
|
} |
1503 |
|
/* function definition for ESTIMATE-CODE-SIZE-1 */ |
1504 |
|
|
1505 |
|
static void L39() |
1506 |
|
{register object *base=vs_base; |
1507 |
|
register object *sup=base+VM32; VC32 |
1508 |
|
vs_reserve(VM32); |
1509 |
|
{object V169; |
1510 |
|
check_arg(2); |
1511 |
|
V169=(base[0]); |
1512 |
|
vs_top=sup; |
1513 |
|
goto TTL; |
1514 |
|
TTL:; |
1515 |
|
base[2]= (V169); |
1516 |
|
vs_top=(vs_base=base+2)+1; |
1517 |
|
Lconstantp(); |
1518 |
|
vs_top=sup; |
1519 |
|
if((vs_base[0])==Cnil){ |
1520 |
|
goto T477;} |
1521 |
|
base[2]= small_fixnum(1); |
1522 |
|
vs_top=(vs_base=base+2)+1; |
1523 |
|
return; |
1524 |
|
goto T477; |
1525 |
|
T477:; |
1526 |
|
if(!(type_of((V169))==t_symbol)){ |
1527 |
|
goto T481;} |
1528 |
|
{object V170; |
1529 |
|
object V171; |
1530 |
|
base[2]= (V169); |
1531 |
|
base[3]= base[1]; |
1532 |
|
vs_top=(vs_base=base+2)+2; |
1533 |
|
Lmacroexpand_1(); |
1534 |
|
if(vs_base>=vs_top){vs_top=sup;goto T486;} |
1535 |
|
V170= vs_base[0]; |
1536 |
|
vs_base++; |
1537 |
|
if(vs_base>=vs_top){vs_top=sup;goto T487;} |
1538 |
|
V171= vs_base[0]; |
1539 |
|
vs_top=sup; |
1540 |
|
goto T488; |
1541 |
|
goto T486; |
1542 |
|
T486:; |
1543 |
|
V170= Cnil; |
1544 |
|
goto T487; |
1545 |
|
T487:; |
1546 |
|
V171= Cnil; |
1547 |
|
goto T488; |
1548 |
|
T488:; |
1549 |
|
if(((V171))==Cnil){ |
1550 |
|
goto T490;} |
1551 |
|
V169= (V170); |
1552 |
|
goto TTL; |
1553 |
|
goto T490; |
1554 |
|
T490:; |
1555 |
|
base[2]= small_fixnum(1); |
1556 |
|
vs_top=(vs_base=base+2)+1; |
1557 |
|
return;} |
1558 |
|
goto T481; |
1559 |
|
T481:; |
1560 |
|
if(!(type_of((V169))!=t_cons)){ |
1561 |
|
goto T496;} |
1562 |
|
base[2]= small_fixnum(1); |
1563 |
|
vs_top=(vs_base=base+2)+1; |
1564 |
|
return; |
1565 |
|
goto T496; |
1566 |
|
T496:; |
1567 |
|
if(!(type_of(car((V169)))==t_symbol)){ |
1568 |
|
goto T499;} |
1569 |
|
{object V172; |
1570 |
|
object V173; |
1571 |
|
register long V174; |
1572 |
|
V172= car((V169)); |
1573 |
|
V174= 0; |
1574 |
|
V173= Cnil; |
1575 |
|
V173= get((V172),VV[77],Cnil); |
1576 |
|
if(((V173))==Cnil){ |
1577 |
|
goto T504;} |
1578 |
|
if(!(type_of(V173)==t_fixnum)){ |
1579 |
|
goto T508;} |
1580 |
|
base[2]= cdr((V169)); |
1581 |
|
vs_top=(vs_base=base+2)+1; |
1582 |
|
L40(base); |
1583 |
|
vs_top=sup; |
1584 |
|
V176= fix(vs_base[0]); |
1585 |
|
base[2]= make_fixnum((long)(fix((V173)))+(V176)); |
1586 |
|
vs_top=(vs_base=base+2)+1; |
1587 |
|
return; |
1588 |
|
goto T508; |
1589 |
|
T508:; |
1590 |
|
base[2]= (V169); |
1591 |
|
base[3]= base[1]; |
1592 |
|
vs_top=(vs_base=base+2)+2; |
1593 |
|
super_funcall_no_event((V173)); |
1594 |
|
return; |
1595 |
|
goto T504; |
1596 |
|
T504:; |
1597 |
|
{register object x= (V172),V177= symbol_value(VV[78]); |
1598 |
|
while(!endp(V177)) |
1599 |
|
if(type_of(V177->c.c_car)==t_cons &&eql(x,V177->c.c_car->c.c_car)){ |
1600 |
|
V173= (V177->c.c_car); |
1601 |
|
goto T517; |
1602 |
|
}else V177=V177->c.c_cdr; |
1603 |
|
V173= Cnil;} |
1604 |
|
goto T517; |
1605 |
|
T517:; |
1606 |
|
if(((V173))==Cnil){ |
1607 |
|
goto T515;} |
1608 |
|
{long V178= fix(cadr((V173))); |
1609 |
|
base[2]= cdr((V169)); |
1610 |
|
vs_top=(vs_base=base+2)+1; |
1611 |
|
L40(base); |
1612 |
|
vs_top=sup; |
1613 |
|
V179= fix(vs_base[0]); |
1614 |
|
base[2]= make_fixnum((long)(/* INLINE-ARGS */V178)+(V179)); |
1615 |
|
vs_top=(vs_base=base+2)+1; |
1616 |
|
return;} |
1617 |
|
goto T515; |
1618 |
|
T515:; |
1619 |
|
if(!(((V172))==(VV[79]))){ |
1620 |
|
goto T521;} |
1621 |
|
{register object V180; |
1622 |
|
object V181; |
1623 |
|
V180= cdr((V169)); |
1624 |
|
V181= car((V180)); |
1625 |
|
goto T526; |
1626 |
|
T526:; |
1627 |
|
if(!(endp_prop((V180)))){ |
1628 |
|
goto T527;} |
1629 |
|
base[4]= make_fixnum(V174); |
1630 |
|
vs_top=(vs_base=base+4)+1; |
1631 |
|
return; |
1632 |
|
goto T527; |
1633 |
|
T527:; |
1634 |
|
V182 = make_fixnum(V174); |
1635 |
|
base[4]= (V181); |
1636 |
|
vs_top=(vs_base=base+4)+1; |
1637 |
|
L40(base); |
1638 |
|
vs_top=sup; |
1639 |
|
V183= vs_base[0]; |
1640 |
|
V174= fix(number_plus(V182,V183)); |
1641 |
|
V174= (long)(V174)+(1); |
1642 |
|
V180= cdr((V180)); |
1643 |
|
V181= car((V180)); |
1644 |
|
goto T526;} |
1645 |
|
goto T521; |
1646 |
|
T521:; |
1647 |
|
if(!(((V172))==(VV[80]))){ |
1648 |
|
goto T543;} |
1649 |
|
{register object V184; |
1650 |
|
V184= cdr((V169)); |
1651 |
|
goto T547; |
1652 |
|
T547:; |
1653 |
|
if(((V184))!=Cnil){ |
1654 |
|
goto T548;} |
1655 |
|
base[2]= make_fixnum(V174); |
1656 |
|
vs_top=(vs_base=base+2)+1; |
1657 |
|
return; |
1658 |
|
goto T548; |
1659 |
|
T548:; |
1660 |
|
base[2]= make_fixnum(V174); |
1661 |
|
base[4]= car((V184)); |
1662 |
|
vs_top=(vs_base=base+4)+1; |
1663 |
|
(void) (*Lnk341)(); |
1664 |
|
vs_top=sup; |
1665 |
|
base[3]= vs_base[0]; |
1666 |
|
base[5]= cadr((V184)); |
1667 |
|
base[6]= base[1]; |
1668 |
|
vs_top=(vs_base=base+5)+2; |
1669 |
|
(void) (*Lnk342)(); |
1670 |
|
vs_top=sup; |
1671 |
|
base[4]= vs_base[0]; |
1672 |
|
vs_top=(vs_base=base+2)+3; |
1673 |
|
Lplus(); |
1674 |
|
vs_top=sup; |
1675 |
|
V174= fix(vs_base[0]); |
1676 |
|
V184= cdr((V184)); |
1677 |
|
goto T547;} |
1678 |
|
goto T543; |
1679 |
|
T543:; |
1680 |
|
{register object x= (V172),V185= VV[81]; |
1681 |
|
while(!endp(V185)) |
1682 |
|
if(eql(x,V185->c.c_car)){ |
1683 |
|
goto T565; |
1684 |
|
}else V185=V185->c.c_cdr; |
1685 |
|
goto T564;} |
1686 |
|
goto T565; |
1687 |
|
T565:; |
1688 |
|
{register object V186; |
1689 |
|
V186= cdr((V169)); |
1690 |
|
goto T568; |
1691 |
|
T568:; |
1692 |
|
if(((V186))!=Cnil){ |
1693 |
|
goto T569;} |
1694 |
|
base[2]= make_fixnum(V174); |
1695 |
|
vs_top=(vs_base=base+2)+1; |
1696 |
|
return; |
1697 |
|
goto T569; |
1698 |
|
T569:; |
1699 |
|
base[2]= make_fixnum(V174); |
1700 |
|
base[4]= cadr((V186)); |
1701 |
|
base[5]= base[1]; |
1702 |
|
vs_top=(vs_base=base+4)+2; |
1703 |
|
(void) (*Lnk342)(); |
1704 |
|
vs_top=sup; |
1705 |
|
base[3]= vs_base[0]; |
1706 |
|
base[4]= small_fixnum(1); |
1707 |
|
vs_top=(vs_base=base+2)+3; |
1708 |
|
Lplus(); |
1709 |
|
vs_top=sup; |
1710 |
|
V174= fix(vs_base[0]); |
1711 |
|
V186= cdr((V186)); |
1712 |
|
goto T568;} |
1713 |
|
goto T564; |
1714 |
|
T564:; |
1715 |
|
if(!(((V172))==(VV[82]))){ |
1716 |
|
goto T584;} |
1717 |
|
base[2]= small_fixnum(1); |
1718 |
|
vs_top=(vs_base=base+2)+1; |
1719 |
|
return; |
1720 |
|
goto T584; |
1721 |
|
T584:; |
1722 |
|
if(!(((V172))==(VV[83]))){ |
1723 |
|
goto T587;} |
1724 |
|
if(type_of(cadr((V169)))==t_symbol){ |
1725 |
|
goto T589;} |
1726 |
|
if(!(type_of(cadr((V169)))==t_cons)){ |
1727 |
|
goto T590;} |
1728 |
|
if(!((caadr((V169)))==(VV[9]))){ |
1729 |
|
goto T590;} |
1730 |
|
goto T589; |
1731 |
|
T589:; |
1732 |
|
base[2]= small_fixnum(1); |
1733 |
|
vs_top=(vs_base=base+2)+1; |
1734 |
|
return; |
1735 |
|
goto T590; |
1736 |
|
T590:; |
1737 |
|
{frame_ptr fr; |
1738 |
|
fr=frs_sch_catch(VV[84]); |
1739 |
|
if(fr==NULL) FEerror("The tag ~s is undefined.",1,VV[84]); |
1740 |
|
base[2]= Cnil; |
1741 |
|
vs_top=(vs_base=base+2)+1; |
1742 |
|
unwind(fr,VV[84]);} |
1743 |
|
goto T587; |
1744 |
|
T587:; |
1745 |
|
if(!(((V172))==(VV[85]))){ |
1746 |
|
goto T598;} |
1747 |
|
{long V187= (long)length(cadr((V169))); |
1748 |
|
base[2]= cddr((V169)); |
1749 |
|
vs_top=(vs_base=base+2)+1; |
1750 |
|
L40(base); |
1751 |
|
vs_top=sup; |
1752 |
|
V188= fix(vs_base[0]); |
1753 |
|
base[2]= make_fixnum((long)(/* INLINE-ARGS */V187)+(V188)); |
1754 |
|
vs_top=(vs_base=base+2)+1; |
1755 |
|
return;} |
1756 |
|
goto T598; |
1757 |
|
T598:; |
1758 |
|
if(!(((V172))==(VV[86]))){ |
1759 |
|
goto T603;} |
1760 |
|
base[2]= caddr((V169)); |
1761 |
|
base[3]= base[1]; |
1762 |
|
vs_top=(vs_base=base+2)+2; |
1763 |
|
(void) (*Lnk342)(); |
1764 |
|
vs_top=sup; |
1765 |
|
V189= vs_base[0]; |
1766 |
|
base[2]= one_plus(V189); |
1767 |
|
vs_top=(vs_base=base+2)+1; |
1768 |
|
return; |
1769 |
|
goto T603; |
1770 |
|
T603:; |
1771 |
|
base[2]= (V172); |
1772 |
|
vs_top=(vs_base=base+2)+1; |
1773 |
|
(void) (*Lnk343)(); |
1774 |
|
vs_top=sup; |
1775 |
|
if((vs_base[0])!=Cnil){ |
1776 |
|
goto T608;} |
1777 |
|
{register object x= (V172),V190= symbol_value(VV[87]); |
1778 |
|
while(!endp(V190)) |
1779 |
|
if(eql(x,V190->c.c_car)){ |
1780 |
|
goto T613; |
1781 |
|
}else V190=V190->c.c_cdr; |
1782 |
|
goto T609;} |
1783 |
|
goto T613; |
1784 |
|
T613:; |
1785 |
|
goto T608; |
1786 |
|
T608:; |
1787 |
|
{frame_ptr fr; |
1788 |
|
fr=frs_sch_catch(VV[77]); |
1789 |
|
if(fr==NULL) FEerror("The tag ~s is undefined.",1,VV[77]); |
1790 |
|
base[2]= Cnil; |
1791 |
|
vs_top=(vs_base=base+2)+1; |
1792 |
|
unwind(fr,VV[77]);} |
1793 |
|
goto T609; |
1794 |
|
T609:; |
1795 |
|
{object V191; |
1796 |
|
object V192; |
1797 |
|
base[2]= (V169); |
1798 |
|
base[3]= base[1]; |
1799 |
|
vs_top=(vs_base=base+2)+2; |
1800 |
|
Lmacroexpand_1(); |
1801 |
|
if(vs_base>=vs_top){vs_top=sup;goto T618;} |
1802 |
|
V191= vs_base[0]; |
1803 |
|
vs_base++; |
1804 |
|
if(vs_base>=vs_top){vs_top=sup;goto T619;} |
1805 |
|
V192= vs_base[0]; |
1806 |
|
vs_top=sup; |
1807 |
|
goto T620; |
1808 |
|
goto T618; |
1809 |
|
T618:; |
1810 |
|
V191= Cnil; |
1811 |
|
goto T619; |
1812 |
|
T619:; |
1813 |
|
V192= Cnil; |
1814 |
|
goto T620; |
1815 |
|
T620:; |
1816 |
|
if(((V192))==Cnil){ |
1817 |
|
goto T622;} |
1818 |
|
V169= (V191); |
1819 |
|
goto TTL; |
1820 |
|
goto T622; |
1821 |
|
T622:; |
1822 |
|
base[2]= cdr((V169)); |
1823 |
|
vs_top=(vs_base=base+2)+1; |
1824 |
|
L40(base); |
1825 |
|
vs_top=sup; |
1826 |
|
V193= fix(vs_base[0]); |
1827 |
|
base[2]= make_fixnum((long)(3)+(V193)); |
1828 |
|
vs_top=(vs_base=base+2)+1; |
1829 |
|
return;}} |
1830 |
|
goto T499; |
1831 |
|
T499:; |
1832 |
|
{frame_ptr fr; |
1833 |
|
fr=frs_sch_catch(VV[77]); |
1834 |
|
if(fr==NULL) FEerror("The tag ~s is undefined.",1,VV[77]); |
1835 |
|
base[2]= Cnil; |
1836 |
|
vs_top=(vs_base=base+2)+1; |
1837 |
|
unwind(fr,VV[77]);} |
1838 |
|
} |
1839 |
|
} |
1840 |
|
/* function definition for LOOP-CONTEXT */ |
1841 |
|
|
1842 |
|
static void L41() |
1843 |
|
{register object *base=vs_base; |
1844 |
|
register object *sup=base+VM33; VC33 |
1845 |
|
vs_reserve(VM33); |
1846 |
|
check_arg(0); |
1847 |
|
vs_top=sup; |
1848 |
|
goto TTL; |
1849 |
|
TTL:; |
1850 |
|
{register object V194; |
1851 |
|
register object V195; |
1852 |
|
V194= symbol_value(VV[88]); |
1853 |
|
V195= Cnil; |
1854 |
|
goto T631; |
1855 |
|
T631:; |
1856 |
|
if(!(((V194))==(cdr(symbol_value(VV[89]))))){ |
1857 |
|
goto T632;} |
1858 |
|
base[0]= nreverse((V195)); |
1859 |
|
vs_top=(vs_base=base+0)+1; |
1860 |
|
return; |
1861 |
|
goto T632; |
1862 |
|
T632:; |
1863 |
|
{object V196; |
1864 |
|
V196= cdr((V194)); |
1865 |
|
V195= make_cons(car((V194)),(V195)); |
1866 |
|
V194= (V196);} |
1867 |
|
goto T631;} |
1868 |
|
} |
1869 |
|
/* function definition for LOOP-ERROR */ |
1870 |
|
|
1871 |
|
static void L42() |
1872 |
|
{register object *base=vs_base; |
1873 |
|
register object *sup=base+VM34; VC34 |
1874 |
|
vs_reserve(VM34); |
1875 |
|
{object V197; |
1876 |
|
object V198; |
1877 |
|
if(vs_top-vs_base<1) too_few_arguments(); |
1878 |
|
V197=(base[0]); |
1879 |
|
vs_base=vs_base+1; |
1880 |
|
vs_top[0]=Cnil; |
1881 |
|
{object *p=vs_top; |
1882 |
|
for(;p>vs_base;p--)p[-1]=MMcons(p[-1],p[0]);} |
1883 |
|
V198=(base[1]); |
1884 |
|
vs_top=sup; |
1885 |
|
base[2]= VV[90]; |
1886 |
|
base[3]= VV[91]; |
1887 |
|
base[4]= (V197); |
1888 |
|
base[5]= (V198); |
1889 |
|
vs_base=vs_top; |
1890 |
|
(void) (*Lnk344)(); |
1891 |
|
vs_top=sup; |
1892 |
|
base[6]= vs_base[0]; |
1893 |
|
vs_top=(vs_base=base+2)+5; |
1894 |
|
(void) (*Lnk345)(); |
1895 |
|
return; |
1896 |
|
} |
1897 |
|
} |
1898 |
|
/* function definition for LOOP-WARN */ |
1899 |
|
|
1900 |
|
static void L43() |
1901 |
|
{register object *base=vs_base; |
1902 |
|
register object *sup=base+VM35; VC35 |
1903 |
|
vs_reserve(VM35); |
1904 |
|
{object V199; |
1905 |
|
object V200; |
1906 |
|
if(vs_top-vs_base<1) too_few_arguments(); |
1907 |
|
V199=(base[0]); |
1908 |
|
vs_base=vs_base+1; |
1909 |
|
vs_top[0]=Cnil; |
1910 |
|
{object *p=vs_top; |
1911 |
|
for(;p>vs_base;p--)p[-1]=MMcons(p[-1],p[0]);} |
1912 |
|
V200=(base[1]); |
1913 |
|
vs_top=sup; |
1914 |
|
vs_base=vs_top; |
1915 |
|
(void) (*Lnk344)(); |
1916 |
|
vs_top=sup; |
1917 |
|
V201= vs_base[0]; |
1918 |
|
base[2]= (VFUN_NARGS=4,(*(LnkLI346))(VV[92],(V199),(V200),V201)); |
1919 |
|
vs_top=(vs_base=base+2)+1; |
1920 |
|
return; |
1921 |
|
} |
1922 |
|
} |
1923 |
|
/* function definition for LOOP-CHECK-DATA-TYPE */ |
1924 |
|
|
1925 |
|
static void L44() |
1926 |
|
{register object *base=vs_base; |
1927 |
|
register object *sup=base+VM36; VC36 |
1928 |
|
vs_reserve(VM36); |
1929 |
|
{register object V202; |
1930 |
|
register object V203; |
1931 |
|
object V204; |
1932 |
|
if(vs_top-vs_base<2) too_few_arguments(); |
1933 |
|
if(vs_top-vs_base>3) too_many_arguments(); |
1934 |
|
V202=(base[0]); |
1935 |
|
V203=(base[1]); |
1936 |
|
vs_base=vs_base+2; |
1937 |
|
if(vs_base>=vs_top){vs_top=sup;goto T646;} |
1938 |
|
V204=(base[2]); |
1939 |
|
vs_top=sup; |
1940 |
|
goto T647; |
1941 |
|
goto T646; |
1942 |
|
T646:; |
1943 |
|
V204= (V203); |
1944 |
|
goto T647; |
1945 |
|
T647:; |
1946 |
|
if(((V202))!=Cnil){ |
1947 |
|
goto T650;} |
1948 |
|
base[3]= (V204); |
1949 |
|
vs_top=(vs_base=base+3)+1; |
1950 |
|
return; |
1951 |
|
goto T650; |
1952 |
|
T650:; |
1953 |
|
{object V205; |
1954 |
|
object V206; |
1955 |
|
base[3]= (V202); |
1956 |
|
base[4]= (V203); |
1957 |
|
vs_top=(vs_base=base+3)+2; |
1958 |
|
(void) (*Lnk326)(); |
1959 |
|
if(vs_base>=vs_top){vs_top=sup;goto T655;} |
1960 |
|
V205= vs_base[0]; |
1961 |
|
vs_base++; |
1962 |
|
if(vs_base>=vs_top){vs_top=sup;goto T656;} |
1963 |
|
V206= vs_base[0]; |
1964 |
|
vs_top=sup; |
1965 |
|
goto T657; |
1966 |
|
goto T655; |
1967 |
|
T655:; |
1968 |
|
V205= Cnil; |
1969 |
|
goto T656; |
1970 |
|
T656:; |
1971 |
|
V206= Cnil; |
1972 |
|
goto T657; |
1973 |
|
T657:; |
1974 |
|
if(((V206))!=Cnil){ |
1975 |
|
goto T660;} |
1976 |
|
base[3]= VV[93]; |
1977 |
|
base[4]= (V202); |
1978 |
|
base[5]= (V203); |
1979 |
|
vs_top=(vs_base=base+3)+3; |
1980 |
|
(void) (*Lnk338)(); |
1981 |
|
vs_top=sup; |
1982 |
|
goto T658; |
1983 |
|
goto T660; |
1984 |
|
T660:; |
1985 |
|
if(((V205))!=Cnil){ |
1986 |
|
goto T658;} |
1987 |
|
base[3]= VV[94]; |
1988 |
|
base[4]= (V202); |
1989 |
|
base[5]= (V203); |
1990 |
|
vs_top=(vs_base=base+3)+3; |
1991 |
|
(void) (*Lnk347)(); |
1992 |
|
vs_top=sup; |
1993 |
|
goto T658; |
1994 |
|
T658:; |
1995 |
|
base[3]= (V202); |
1996 |
|
vs_top=(vs_base=base+3)+1; |
1997 |
|
return;} |
1998 |
|
} |
1999 |
|
} |
2000 |
|
/* macro definition for LOOP-FINISH */ |
2001 |
|
|
2002 |
|
static void L45() |
2003 |
|
{register object *base=vs_base; |
2004 |
|
register object *sup=base+VM37; VC37 |
2005 |
|
vs_reserve(VM37); |
2006 |
|
check_arg(2); |
2007 |
|
vs_top=sup; |
2008 |
|
{object V207=base[0]->c.c_cdr; |
2009 |
|
if(!endp(V207))invalid_macro_call();} |
2010 |
|
base[2]= VV[95]; |
2011 |
|
vs_top=(vs_base=base+2)+1; |
2012 |
|
return; |
2013 |
|
} |
2014 |
|
/* function definition for LOOP-TRANSLATE */ |
2015 |
|
|
2016 |
|
static void L46() |
2017 |
|
{register object *base=vs_base; |
2018 |
|
register object *sup=base+VM38; VC38 |
2019 |
|
vs_reserve(VM38); |
2020 |
|
bds_check; |
2021 |
|
check_arg(3); |
2022 |
|
bds_bind(VV[89],base[0]); |
2023 |
|
bds_bind(VV[96],base[1]); |
2024 |
|
bds_bind(VV[97],base[2]); |
2025 |
|
vs_top=sup; |
2026 |
|
goto TTL; |
2027 |
|
TTL:; |
2028 |
|
bds_bind(VV[98],(VV[89]->s.s_dbind)); |
2029 |
|
bds_bind(VV[88],Cnil); |
2030 |
|
bds_bind(VV[99],Cnil); |
2031 |
|
bds_bind(VV[100],Cnil); |
2032 |
|
bds_bind(VV[101],Cnil); |
2033 |
|
bds_bind(VV[102],Cnil); |
2034 |
|
bds_bind(VV[103],Cnil); |
2035 |
|
bds_bind(VV[104],Cnil); |
2036 |
|
bds_bind(VV[105],Cnil); |
2037 |
|
bds_bind(VV[106],Cnil); |
2038 |
|
bds_bind(VV[107],Cnil); |
2039 |
|
bds_bind(VV[108],Cnil); |
2040 |
|
bds_bind(VV[109],Cnil); |
2041 |
|
bds_bind(VV[110],Cnil); |
2042 |
|
bds_bind(VV[111],Cnil); |
2043 |
|
bds_bind(VV[112],Cnil); |
2044 |
|
bds_bind(VV[113],Cnil); |
2045 |
|
bds_bind(VV[114],Cnil); |
2046 |
|
bds_bind(VV[115],Cnil); |
2047 |
|
bds_bind(VV[116],Cnil); |
2048 |
|
bds_bind(VV[117],Cnil); |
2049 |
|
bds_bind(VV[118],Cnil); |
2050 |
|
bds_bind(VV[119],Cnil); |
2051 |
|
bds_bind(VV[120],Cnil); |
2052 |
|
vs_base=vs_top; |
2053 |
|
(void) (*Lnk348)(); |
2054 |
|
vs_top=sup; |
2055 |
|
vs_base=vs_top; |
2056 |
|
(void) (*Lnk349)(); |
2057 |
|
vs_top=sup; |
2058 |
|
{register object V208; |
2059 |
|
V209= nreverse((VV[106]->s.s_dbind)); |
2060 |
|
V210= nreverse((VV[108]->s.s_dbind)); |
2061 |
|
V211= nreverse((VV[109]->s.s_dbind)); |
2062 |
|
V212= nreverse((VV[111]->s.s_dbind)); |
2063 |
|
base[27]= (VV[112]->s.s_dbind); |
2064 |
|
base[28]= nreverse((VV[113]->s.s_dbind)); |
2065 |
|
vs_top=(vs_base=base+27)+2; |
2066 |
|
Lreconc(); |
2067 |
|
vs_top=sup; |
2068 |
|
V213= vs_base[0]; |
2069 |
|
V208= list(6,VV[121],/* INLINE-ARGS */V209,/* INLINE-ARGS */V210,/* INLINE-ARGS */V211,/* INLINE-ARGS */V212,V213); |
2070 |
|
{register object V214; |
2071 |
|
register object V215; |
2072 |
|
V214= (VV[105]->s.s_dbind); |
2073 |
|
V215= car((V214)); |
2074 |
|
goto T680; |
2075 |
|
T680:; |
2076 |
|
if(!(endp_prop((V214)))){ |
2077 |
|
goto T681;} |
2078 |
|
goto T676; |
2079 |
|
goto T681; |
2080 |
|
T681:; |
2081 |
|
{object V216; |
2082 |
|
object V217; |
2083 |
|
object V218; |
2084 |
|
object V219; |
2085 |
|
V216= car((V215)); |
2086 |
|
V217= cadr((V215)); |
2087 |
|
V218= caddr((V215)); |
2088 |
|
V219= cadddr((V215)); |
2089 |
|
{register object V220; |
2090 |
|
register object V221; |
2091 |
|
V220= (V219); |
2092 |
|
V221= car((V220)); |
2093 |
|
goto T694; |
2094 |
|
T694:; |
2095 |
|
if(!(endp_prop((V220)))){ |
2096 |
|
goto T695;} |
2097 |
|
goto T690; |
2098 |
|
goto T695; |
2099 |
|
T695:; |
2100 |
|
V222= make_cons((V208),Cnil); |
2101 |
|
V208= append((V221),/* INLINE-ARGS */V222); |
2102 |
|
V220= cdr((V220)); |
2103 |
|
V221= car((V220)); |
2104 |
|
goto T694;} |
2105 |
|
goto T690; |
2106 |
|
T690:; |
2107 |
|
if(((V216))!=Cnil){ |
2108 |
|
goto T706;} |
2109 |
|
if(((V217))!=Cnil){ |
2110 |
|
goto T706;} |
2111 |
|
if(((V218))==Cnil){ |
2112 |
|
goto T685;} |
2113 |
|
goto T706; |
2114 |
|
T706:; |
2115 |
|
{register object V223; |
2116 |
|
V223= make_cons((V208),Cnil); |
2117 |
|
if(((V217))==Cnil){ |
2118 |
|
goto T713;} |
2119 |
|
{object V224; |
2120 |
|
V224= make_cons(VV[30],(V217)); |
2121 |
|
V223= make_cons((V224),(V223));} |
2122 |
|
goto T713; |
2123 |
|
T713:; |
2124 |
|
if(((V216))!=Cnil){ |
2125 |
|
goto T721;} |
2126 |
|
V225= VV[122]; |
2127 |
|
goto T719; |
2128 |
|
goto T721; |
2129 |
|
T721:; |
2130 |
|
if((symbol_value(VV[63]))==Cnil){ |
2131 |
|
goto T724;} |
2132 |
|
V225= car(symbol_value(VV[63])); |
2133 |
|
goto T719; |
2134 |
|
goto T724; |
2135 |
|
T724:; |
2136 |
|
V225= VV[29]; |
2137 |
|
goto T719; |
2138 |
|
T719:; |
2139 |
|
if(((V218))==Cnil){ |
2140 |
|
goto T728;} |
2141 |
|
V227= append((V218),(V223)); |
2142 |
|
V228= make_cons(VV[123],/* INLINE-ARGS */V227); |
2143 |
|
V226= make_cons(/* INLINE-ARGS */V228,Cnil); |
2144 |
|
goto T726; |
2145 |
|
goto T728; |
2146 |
|
T728:; |
2147 |
|
V226= (V223); |
2148 |
|
goto T726; |
2149 |
|
T726:; |
2150 |
|
V208= listA(3,V225,(V216),V226);}} |
2151 |
|
goto T685; |
2152 |
|
T685:; |
2153 |
|
V214= cdr((V214)); |
2154 |
|
V215= car((V214)); |
2155 |
|
goto T680;} |
2156 |
|
goto T676; |
2157 |
|
T676:; |
2158 |
|
V208= list(3,VV[124],car((VV[118]->s.s_dbind)),(V208)); |
2159 |
|
base[27]= (V208); |
2160 |
|
vs_top=(vs_base=base+27)+1; |
2161 |
|
bds_unwind1; |
2162 |
|
bds_unwind1; |
2163 |
|
bds_unwind1; |
2164 |
|
bds_unwind1; |
2165 |
|
bds_unwind1; |
2166 |
|
bds_unwind1; |
2167 |
|
bds_unwind1; |
2168 |
|
bds_unwind1; |
2169 |
|
bds_unwind1; |
2170 |
|
bds_unwind1; |
2171 |
|
bds_unwind1; |
2172 |
|
bds_unwind1; |
2173 |
|
bds_unwind1; |
2174 |
|
bds_unwind1; |
2175 |
|
bds_unwind1; |
2176 |
|
bds_unwind1; |
2177 |
|
bds_unwind1; |
2178 |
|
bds_unwind1; |
2179 |
|
bds_unwind1; |
2180 |
|
bds_unwind1; |
2181 |
|
bds_unwind1; |
2182 |
|
bds_unwind1; |
2183 |
|
bds_unwind1; |
2184 |
|
bds_unwind1; |
2185 |
|
bds_unwind1; |
2186 |
|
bds_unwind1; |
2187 |
|
bds_unwind1; |
2188 |
|
return;} |
2189 |
|
} |
2190 |
|
/* function definition for LOOP-ITERATION-DRIVER */ |
2191 |
|
|
2192 |
|
static void L47() |
2193 |
|
{register object *base=vs_base; |
2194 |
|
register object *sup=base+VM39; VC39 |
2195 |
|
vs_reserve(VM39); |
2196 |
|
check_arg(0); |
2197 |
|
vs_top=sup; |
2198 |
|
goto TTL; |
2199 |
|
TTL:; |
2200 |
|
goto T738; |
2201 |
|
T738:; |
2202 |
|
if((symbol_value(VV[89]))!=Cnil){ |
2203 |
|
goto T739;} |
2204 |
|
base[0]= Cnil; |
2205 |
|
vs_top=(vs_base=base+0)+1; |
2206 |
|
return; |
2207 |
|
goto T739; |
2208 |
|
T739:; |
2209 |
|
{register object V229; |
2210 |
|
register object V230; |
2211 |
|
V229= car(symbol_value(VV[89])); |
2212 |
|
V230= Cnil; |
2213 |
|
if(type_of((V229))==t_symbol){ |
2214 |
|
goto T746;} |
2215 |
|
base[0]= VV[125]; |
2216 |
|
base[1]= (V229); |
2217 |
|
vs_top=(vs_base=base+0)+2; |
2218 |
|
(void) (*Lnk347)(); |
2219 |
|
vs_top=sup; |
2220 |
|
goto T743; |
2221 |
|
goto T746; |
2222 |
|
T746:; |
2223 |
|
setq(VV[88],symbol_value(VV[89])); |
2224 |
|
vs_base=vs_top; |
2225 |
|
(void) (*Lnk350)(); |
2226 |
|
vs_top=sup; |
2227 |
|
base[0]= (V229); |
2228 |
|
base[1]= structure_ref(symbol_value(VV[97]),VV[39],0); |
2229 |
|
vs_top=(vs_base=base+0)+2; |
2230 |
|
(void) (*Lnk351)(); |
2231 |
|
vs_top=sup; |
2232 |
|
V230= vs_base[0]; |
2233 |
|
if(((V230))==Cnil){ |
2234 |
|
goto T754;} |
2235 |
|
base[1]= car((V230)); |
2236 |
|
vs_top=(vs_base=base+1)+1; |
2237 |
|
Lsymbol_function(); |
2238 |
|
vs_top=sup; |
2239 |
|
base[0]= vs_base[0]; |
2240 |
|
{object V231; |
2241 |
|
V231= cdr((V230)); |
2242 |
|
vs_top=base+1; |
2243 |
|
while(!endp(V231)) |
2244 |
|
{vs_push(car(V231));V231=cdr(V231);} |
2245 |
|
vs_base=base+1;} |
2246 |
|
super_funcall_no_event(base[0]); |
2247 |
|
vs_top=sup; |
2248 |
|
goto T743; |
2249 |
|
goto T754; |
2250 |
|
T754:; |
2251 |
|
base[0]= (V229); |
2252 |
|
base[1]= structure_ref(symbol_value(VV[97]),VV[39],1); |
2253 |
|
vs_top=(vs_base=base+0)+2; |
2254 |
|
(void) (*Lnk351)(); |
2255 |
|
vs_top=sup; |
2256 |
|
V230= vs_base[0]; |
2257 |
|
if(((V230))==Cnil){ |
2258 |
|
goto T763;} |
2259 |
|
base[0]= (V230); |
2260 |
|
vs_top=(vs_base=base+0)+1; |
2261 |
|
(void) (*Lnk352)(); |
2262 |
|
vs_top=sup; |
2263 |
|
goto T743; |
2264 |
|
goto T763; |
2265 |
|
T763:; |
2266 |
|
base[0]= (V229); |
2267 |
|
base[1]= VV[126]; |
2268 |
|
vs_top=(vs_base=base+0)+2; |
2269 |
|
(void) (*Lnk353)(); |
2270 |
|
vs_top=sup; |
2271 |
|
if((vs_base[0])==Cnil){ |
2272 |
|
goto T770;} |
2273 |
|
base[0]= VV[127]; |
2274 |
|
base[1]= (V229); |
2275 |
|
base[2]= car(symbol_value(VV[89])); |
2276 |
|
base[3]= cadr(symbol_value(VV[89])); |
2277 |
|
vs_top=(vs_base=base+0)+4; |
2278 |
|
(void) (*Lnk347)(); |
2279 |
|
vs_top=sup; |
2280 |
|
goto T743; |
2281 |
|
goto T770; |
2282 |
|
T770:; |
2283 |
|
base[0]= VV[128]; |
2284 |
|
base[1]= (V229); |
2285 |
|
vs_top=(vs_base=base+0)+2; |
2286 |
|
(void) (*Lnk347)(); |
2287 |
|
vs_top=sup;} |
2288 |
|
goto T743; |
2289 |
|
T743:; |
2290 |
|
goto T738; |
2291 |
|
} |
2292 |
|
/* function definition for LOOP-POP-SOURCE */ |
2293 |
|
|
2294 |
|
static void L48() |
2295 |
|
{register object *base=vs_base; |
2296 |
|
register object *sup=base+VM40; VC40 |
2297 |
|
vs_reserve(VM40); |
2298 |
|
check_arg(0); |
2299 |
|
vs_top=sup; |
2300 |
|
goto TTL; |
2301 |
|
TTL:; |
2302 |
|
if((symbol_value(VV[89]))==Cnil){ |
2303 |
|
goto T783;} |
2304 |
|
{object V232; |
2305 |
|
V232= car(symbol_value(VV[89])); |
2306 |
|
setq(VV[89],cdr(symbol_value(VV[89]))); |
2307 |
|
base[0]= (V232); |
2308 |
|
vs_top=(vs_base=base+0)+1; |
2309 |
|
return;} |
2310 |
|
goto T783; |
2311 |
|
T783:; |
2312 |
|
base[0]= VV[129]; |
2313 |
|
vs_top=(vs_base=base+0)+1; |
2314 |
|
(void) (*Lnk347)(); |
2315 |
|
return; |
2316 |
|
} |
2317 |
|
/* function definition for LOOP-GET-PROGN */ |
2318 |
|
|
2319 |
|
static void L49() |
2320 |
|
{register object *base=vs_base; |
2321 |
|
register object *sup=base+VM41; VC41 |
2322 |
|
vs_reserve(VM41); |
2323 |
|
check_arg(0); |
2324 |
|
vs_top=sup; |
2325 |
|
goto TTL; |
2326 |
|
TTL:; |
2327 |
|
{register object V233; |
2328 |
|
register object V234; |
2329 |
|
vs_base=vs_top; |
2330 |
|
(void) (*Lnk350)(); |
2331 |
|
vs_top=sup; |
2332 |
|
V235= vs_base[0]; |
2333 |
|
V233= make_cons(V235,Cnil); |
2334 |
|
V234= car(symbol_value(VV[89])); |
2335 |
|
goto T793; |
2336 |
|
T793:; |
2337 |
|
if(!(type_of((V234))!=t_cons)){ |
2338 |
|
goto T794;} |
2339 |
|
if((cdr((V233)))!=Cnil){ |
2340 |
|
goto T798;} |
2341 |
|
base[0]= car((V233)); |
2342 |
|
vs_top=(vs_base=base+0)+1; |
2343 |
|
return; |
2344 |
|
goto T798; |
2345 |
|
T798:; |
2346 |
|
V236= nreverse((V233)); |
2347 |
|
base[0]= make_cons(VV[14],/* INLINE-ARGS */V236); |
2348 |
|
vs_top=(vs_base=base+0)+1; |
2349 |
|
return; |
2350 |
|
goto T794; |
2351 |
|
T794:; |
2352 |
|
vs_base=vs_top; |
2353 |
|
(void) (*Lnk350)(); |
2354 |
|
vs_top=sup; |
2355 |
|
V237= vs_base[0]; |
2356 |
|
V233= make_cons(V237,(V233)); |
2357 |
|
V234= car(symbol_value(VV[89])); |
2358 |
|
goto T793;} |
2359 |
|
} |
2360 |
|
/* function definition for LOOP-GET-FORM */ |
2361 |
|
|
2362 |
|
static void L50() |
2363 |
|
{register object *base=vs_base; |
2364 |
|
register object *sup=base+VM42; VC42 |
2365 |
|
vs_reserve(VM42); |
2366 |
|
check_arg(0); |
2367 |
|
vs_top=sup; |
2368 |
|
goto TTL; |
2369 |
|
TTL:; |
2370 |
|
if((symbol_value(VV[89]))==Cnil){ |
2371 |
|
goto T807;} |
2372 |
|
vs_base=vs_top; |
2373 |
|
(void) (*Lnk350)(); |
2374 |
|
return; |
2375 |
|
goto T807; |
2376 |
|
T807:; |
2377 |
|
base[0]= VV[130]; |
2378 |
|
vs_top=(vs_base=base+0)+1; |
2379 |
|
(void) (*Lnk347)(); |
2380 |
|
return; |
2381 |
|
} |
2382 |
|
/* function definition for LOOP-CONSTRUCT-RETURN */ |
2383 |
|
|
2384 |
|
static void L51() |
2385 |
|
{register object *base=vs_base; |
2386 |
|
register object *sup=base+VM43; VC43 |
2387 |
|
vs_reserve(VM43); |
2388 |
|
{object V238; |
2389 |
|
check_arg(1); |
2390 |
|
V238=(base[0]); |
2391 |
|
vs_top=sup; |
2392 |
|
goto TTL; |
2393 |
|
TTL:; |
2394 |
|
base[1]= list(3,VV[86],car(symbol_value(VV[118])),(V238)); |
2395 |
|
vs_top=(vs_base=base+1)+1; |
2396 |
|
return; |
2397 |
|
} |
2398 |
|
} |
2399 |
|
/* function definition for LOOP-PSEUDO-BODY */ |
2400 |
|
|
2401 |
|
static void L52() |
2402 |
|
{register object *base=vs_base; |
2403 |
|
register object *sup=base+VM44; VC44 |
2404 |
|
vs_reserve(VM44); |
2405 |
|
{object V239; |
2406 |
|
check_arg(1); |
2407 |
|
V239=(base[0]); |
2408 |
|
vs_top=sup; |
2409 |
|
goto TTL; |
2410 |
|
TTL:; |
2411 |
|
if((symbol_value(VV[110]))!=Cnil){ |
2412 |
|
goto T810;} |
2413 |
|
if((symbol_value(VV[115]))==Cnil){ |
2414 |
|
goto T811;} |
2415 |
|
goto T810; |
2416 |
|
T810:; |
2417 |
|
setq(VV[109],make_cons(V239,symbol_value(VV[109]))); |
2418 |
|
base[1]= symbol_value(VV[109]); |
2419 |
|
vs_top=(vs_base=base+1)+1; |
2420 |
|
return; |
2421 |
|
goto T811; |
2422 |
|
T811:; |
2423 |
|
setq(VV[108],make_cons(V239,symbol_value(VV[108]))); |
2424 |
|
setq(VV[111],make_cons(V239,symbol_value(VV[111]))); |
2425 |
|
base[1]= symbol_value(VV[111]); |
2426 |
|
vs_top=(vs_base=base+1)+1; |
2427 |
|
return; |
2428 |
|
} |
2429 |
|
} |
2430 |
|
/* function definition for LOOP-EMIT-BODY */ |
2431 |
|
|
2432 |
|
static void L53() |
2433 |
|
{register object *base=vs_base; |
2434 |
|
register object *sup=base+VM45; VC45 |
2435 |
|
vs_reserve(VM45); |
2436 |
|
{object V243; |
2437 |
|
check_arg(1); |
2438 |
|
V243=(base[0]); |
2439 |
|
vs_top=sup; |
2440 |
|
goto TTL; |
2441 |
|
TTL:; |
2442 |
|
setq(VV[110],Ct); |
2443 |
|
base[1]= (V243); |
2444 |
|
vs_top=(vs_base=base+1)+1; |
2445 |
|
(void) (*Lnk354)(); |
2446 |
|
return; |
2447 |
|
} |
2448 |
|
} |
2449 |
|
/* function definition for LOOP-EMIT-FINAL-VALUE */ |
2450 |
|
|
2451 |
|
static void L54() |
2452 |
|
{register object *base=vs_base; |
2453 |
|
register object *sup=base+VM46; VC46 |
2454 |
|
vs_reserve(VM46); |
2455 |
|
{object V244; |
2456 |
|
check_arg(1); |
2457 |
|
V244=(base[0]); |
2458 |
|
vs_top=sup; |
2459 |
|
goto TTL; |
2460 |
|
TTL:; |
2461 |
|
{object V245; |
2462 |
|
base[2]= (V244); |
2463 |
|
vs_top=(vs_base=base+2)+1; |
2464 |
|
(void) (*Lnk355)(); |
2465 |
|
vs_top=sup; |
2466 |
|
V245= vs_base[0]; |
2467 |
|
setq(VV[113],make_cons((V245),symbol_value(VV[113])));} |
2468 |
|
if((symbol_value(VV[114]))==Cnil){ |
2469 |
|
goto T826;} |
2470 |
|
if((symbol_value(VV[119]))==Cnil){ |
2471 |
|
goto T830;} |
2472 |
|
base[1]= VV[90]; |
2473 |
|
base[2]= VV[131]; |
2474 |
|
base[3]= symbol_value(VV[114]); |
2475 |
|
vs_top=(vs_base=base+1)+3; |
2476 |
|
(void) (*Lnk345)(); |
2477 |
|
vs_top=sup; |
2478 |
|
goto T826; |
2479 |
|
goto T830; |
2480 |
|
T830:; |
2481 |
|
base[1]= VV[132]; |
2482 |
|
base[2]= symbol_value(VV[114]); |
2483 |
|
vs_top=(vs_base=base+1)+2; |
2484 |
|
(void) (*Lnk338)(); |
2485 |
|
vs_top=sup; |
2486 |
|
goto T826; |
2487 |
|
T826:; |
2488 |
|
setq(VV[114],car(symbol_value(VV[88]))); |
2489 |
|
base[1]= symbol_value(VV[114]); |
2490 |
|
vs_top=(vs_base=base+1)+1; |
2491 |
|
return; |
2492 |
|
} |
2493 |
|
} |
2494 |
|
/* function definition for LOOP-DISALLOW-CONDITIONAL */ |
2495 |
|
|
2496 |
|
static void L55() |
2497 |
|
{register object *base=vs_base; |
2498 |
|
register object *sup=base+VM47; VC47 |
2499 |
|
vs_reserve(VM47); |
2500 |
|
{object V246; |
2501 |
|
if(vs_top-vs_base>1) too_many_arguments(); |
2502 |
|
if(vs_base>=vs_top){vs_top=sup;goto T838;} |
2503 |
|
V246=(base[0]); |
2504 |
|
vs_top=sup; |
2505 |
|
goto T839; |
2506 |
|
goto T838; |
2507 |
|
T838:; |
2508 |
|
V246= Cnil; |
2509 |
|
goto T839; |
2510 |
|
T839:; |
2511 |
|
if((symbol_value(VV[115]))==Cnil){ |
2512 |
|
goto T842;} |
2513 |
|
base[1]= VV[133]; |
2514 |
|
base[2]= (V246); |
2515 |
|
vs_top=(vs_base=base+1)+2; |
2516 |
|
(void) (*Lnk347)(); |
2517 |
|
return; |
2518 |
|
goto T842; |
2519 |
|
T842:; |
2520 |
|
base[1]= Cnil; |
2521 |
|
vs_top=(vs_base=base+1)+1; |
2522 |
|
return; |
2523 |
|
} |
2524 |
|
} |
2525 |
|
/* function definition for LOOP-TYPED-INIT */ |
2526 |
|
|
2527 |
|
static void L56() |
2528 |
|
{register object *base=vs_base; |
2529 |
|
register object *sup=base+VM48; VC48 |
2530 |
|
vs_reserve(VM48); |
2531 |
|
{register object V247; |
2532 |
|
check_arg(1); |
2533 |
|
V247=(base[0]); |
2534 |
|
vs_top=sup; |
2535 |
|
goto TTL; |
2536 |
|
TTL:; |
2537 |
|
if(((V247))==Cnil){ |
2538 |
|
goto T847;} |
2539 |
|
base[1]= (V247); |
2540 |
|
base[2]= VV[134]; |
2541 |
|
vs_top=(vs_base=base+1)+2; |
2542 |
|
(void) (*Lnk326)(); |
2543 |
|
vs_top=sup; |
2544 |
|
if((vs_base[0])==Cnil){ |
2545 |
|
goto T847;} |
2546 |
|
base[1]= (V247); |
2547 |
|
base[2]= VV[135]; |
2548 |
|
vs_top=(vs_base=base+1)+2; |
2549 |
|
(void) (*Lnk326)(); |
2550 |
|
vs_top=sup; |
2551 |
|
if((vs_base[0])!=Cnil){ |
2552 |
|
goto T853;} |
2553 |
|
base[1]= (V247); |
2554 |
|
base[2]= VV[136]; |
2555 |
|
vs_top=(vs_base=base+1)+2; |
2556 |
|
(void) (*Lnk326)(); |
2557 |
|
vs_top=sup; |
2558 |
|
if((vs_base[0])==Cnil){ |
2559 |
|
goto T854;} |
2560 |
|
goto T853; |
2561 |
|
T853:; |
2562 |
|
base[1]= (*(LnkLI356))(small_fixnum(0),(V247)); |
2563 |
|
vs_top=(vs_base=base+1)+1; |
2564 |
|
return; |
2565 |
|
goto T854; |
2566 |
|
T854:; |
2567 |
|
base[1]= small_fixnum(0); |
2568 |
|
vs_top=(vs_base=base+1)+1; |
2569 |
|
return; |
2570 |
|
goto T847; |
2571 |
|
T847:; |
2572 |
|
base[1]= Cnil; |
2573 |
|
vs_top=(vs_base=base+1)+1; |
2574 |
|
return; |
2575 |
|
} |
2576 |
|
} |
2577 |
|
/* function definition for LOOP-OPTIONAL-TYPE */ |
2578 |
|
|
2579 |
|
static void L57() |
2580 |
|
{register object *base=vs_base; |
2581 |
|
register object *sup=base+VM49; VC49 |
2582 |
|
vs_reserve(VM49); |
2583 |
|
if(vs_top-vs_base>1) too_many_arguments(); |
2584 |
|
if(vs_base>=vs_top){vs_top=sup;goto T862;} |
2585 |
|
vs_top=sup; |
2586 |
|
goto T863; |
2587 |
|
goto T862; |
2588 |
|
T862:; |
2589 |
|
base[0]= Cnil; |
2590 |
|
goto T863; |
2591 |
|
T863:; |
2592 |
|
if(symbol_value(VV[89])==Cnil){ |
2593 |
|
base[1]= Cnil; |
2594 |
|
vs_top=(vs_base=base+1)+1; |
2595 |
|
return;} |
2596 |
|
base[1]= car(symbol_value(VV[89])); |
2597 |
|
base[2]= base[1]; |
2598 |
|
base[3]= VV[137]; |
2599 |
|
vs_top=(vs_base=base+2)+2; |
2600 |
|
(void) (*Lnk357)(); |
2601 |
|
vs_top=sup; |
2602 |
|
if((vs_base[0])==Cnil){ |
2603 |
|
goto T867;} |
2604 |
|
vs_base=vs_top; |
2605 |
|
(void) (*Lnk350)(); |
2606 |
|
vs_top=sup; |
2607 |
|
vs_base=vs_top; |
2608 |
|
(void) (*Lnk350)(); |
2609 |
|
return; |
2610 |
|
goto T867; |
2611 |
|
T867:; |
2612 |
|
if(!(type_of(base[1])==t_symbol)){ |
2613 |
|
goto T873;} |
2614 |
|
{object V248;{object V249; |
2615 |
|
base[2]= base[1]; |
2616 |
|
base[3]= structure_ref(symbol_value(VV[97]),VV[39],4); |
2617 |
|
vs_top=(vs_base=base+2)+2; |
2618 |
|
Lgethash(); |
2619 |
|
vs_top=sup; |
2620 |
|
V249= vs_base[0]; |
2621 |
|
if(V249==Cnil)goto T876; |
2622 |
|
V248= V249; |
2623 |
|
goto T875; |
2624 |
|
goto T876; |
2625 |
|
T876:;} |
2626 |
|
base[2]= symbol_name(base[1]); |
2627 |
|
base[3]= structure_ref(symbol_value(VV[97]),VV[39],5); |
2628 |
|
vs_top=(vs_base=base+2)+2; |
2629 |
|
Lgethash(); |
2630 |
|
vs_top=sup; |
2631 |
|
V248= vs_base[0]; |
2632 |
|
goto T875; |
2633 |
|
T875:; |
2634 |
|
if(((V248))==Cnil){ |
2635 |
|
goto T883;} |
2636 |
|
vs_base=vs_top; |
2637 |
|
(void) (*Lnk350)(); |
2638 |
|
vs_top=sup; |
2639 |
|
base[2]= (V248); |
2640 |
|
vs_top=(vs_base=base+2)+1; |
2641 |
|
return; |
2642 |
|
goto T883; |
2643 |
|
T883:; |
2644 |
|
base[2]= Cnil; |
2645 |
|
vs_top=(vs_base=base+2)+1; |
2646 |
|
return;} |
2647 |
|
goto T873; |
2648 |
|
T873:; |
2649 |
|
if(!(type_of(base[0])==t_cons)){ |
2650 |
|
goto T888;} |
2651 |
|
if(type_of(base[1])==t_cons){ |
2652 |
|
goto T886;} |
2653 |
|
base[2]= VV[138]; |
2654 |
|
base[3]= base[1]; |
2655 |
|
vs_top=(vs_base=base+2)+2; |
2656 |
|
(void) (*Lnk347)(); |
2657 |
|
vs_top=sup; |
2658 |
|
goto T886; |
2659 |
|
goto T888; |
2660 |
|
T888:; |
2661 |
|
base[2]= VV[139]; |
2662 |
|
base[3]= base[1]; |
2663 |
|
vs_top=(vs_base=base+2)+2; |
2664 |
|
(void) (*Lnk347)(); |
2665 |
|
vs_top=sup; |
2666 |
|
goto T886; |
2667 |
|
T886:; |
2668 |
|
vs_base=vs_top; |
2669 |
|
(void) (*Lnk350)(); |
2670 |
|
vs_top=sup; |
2671 |
|
base[2]= base[1]; |
2672 |
|
base[3]= base[0]; |
2673 |
|
vs_top=(vs_base=base+2)+2; |
2674 |
|
L58(base); |
2675 |
|
return; |
2676 |
|
} |
2677 |
|
/* function definition for LOOP-BIND-BLOCK */ |
2678 |
|
|
2679 |
|
static void L60() |
2680 |
|
{register object *base=vs_base; |
2681 |
|
register object *sup=base+VM50; VC50 |
2682 |
|
vs_reserve(VM50); |
2683 |
|
check_arg(0); |
2684 |
|
vs_top=sup; |
2685 |
|
goto TTL; |
2686 |
|
TTL:; |
2687 |
|
if((symbol_value(VV[100]))!=Cnil){ |
2688 |
|
goto T899;} |
2689 |
|
if((symbol_value(VV[103]))!=Cnil){ |
2690 |
|
goto T899;} |
2691 |
|
if((symbol_value(VV[107]))==Cnil){ |
2692 |
|
goto T900;} |
2693 |
|
goto T899; |
2694 |
|
T899:; |
2695 |
|
{object V250; |
2696 |
|
V251= nreverse(symbol_value(VV[100])); |
2697 |
|
V250= list(4,/* INLINE-ARGS */V251,symbol_value(VV[103]),symbol_value(VV[104]),symbol_value(VV[107])); |
2698 |
|
setq(VV[105],make_cons((V250),symbol_value(VV[105])));} |
2699 |
|
setq(VV[100],Cnil); |
2700 |
|
setq(VV[103],Cnil); |
2701 |
|
setq(VV[104],Cnil); |
2702 |
|
setq(VV[107],Cnil); |
2703 |
|
base[0]= Cnil; |
2704 |
|
vs_top=(vs_base=base+0)+1; |
2705 |
|
return; |
2706 |
|
goto T900; |
2707 |
|
T900:; |
2708 |
|
base[0]= Cnil; |
2709 |
|
vs_top=(vs_base=base+0)+1; |
2710 |
|
return; |
2711 |
|
} |
2712 |
|
/* function definition for LOOP-MAKE-VARIABLE */ |
2713 |
|
|
2714 |
|
static void L61() |
2715 |
|
{register object *base=vs_base; |
2716 |
|
register object *sup=base+VM51; VC51 |
2717 |
|
vs_reserve(VM51); |
2718 |
|
{register object V252; |
2719 |
|
register object V253; |
2720 |
|
register object V254; |
2721 |
|
object V255; |
2722 |
|
if(vs_top-vs_base<3) too_few_arguments(); |
2723 |
|
if(vs_top-vs_base>4) too_many_arguments(); |
2724 |
|
V252=(base[0]); |
2725 |
|
V253=(base[1]); |
2726 |
|
V254=(base[2]); |
2727 |
|
vs_base=vs_base+3; |
2728 |
|
if(vs_base>=vs_top){vs_top=sup;goto T916;} |
2729 |
|
V255=(base[3]); |
2730 |
|
vs_top=sup; |
2731 |
|
goto T917; |
2732 |
|
goto T916; |
2733 |
|
T916:; |
2734 |
|
V255= Cnil; |
2735 |
|
goto T917; |
2736 |
|
T917:; |
2737 |
|
if(((V252))!=Cnil){ |
2738 |
|
goto T921;} |
2739 |
|
if(((V253))==Cnil){ |
2740 |
|
goto T919;} |
2741 |
|
{object V256; |
2742 |
|
base[5]= VV[142]; |
2743 |
|
vs_top=(vs_base=base+5)+1; |
2744 |
|
(void) (*Lnk327)(); |
2745 |
|
vs_top=sup; |
2746 |
|
V252= vs_base[0]; |
2747 |
|
V256= list(2,(V252),(V253)); |
2748 |
|
setq(VV[100],make_cons((V256),symbol_value(VV[100])));} |
2749 |
|
{object V257; |
2750 |
|
V257= list(2,VV[143],(V252)); |
2751 |
|
setq(VV[103],make_cons((V257),symbol_value(VV[103]))); |
2752 |
|
goto T919;} |
2753 |
|
goto T921; |
2754 |
|
T921:; |
2755 |
|
if(!(type_of((V252))!=t_cons)){ |
2756 |
|
goto T933;} |
2757 |
|
if(((V255))==Cnil){ |
2758 |
|
goto T937;} |
2759 |
|
{register object x= (V252),V258= symbol_value(VV[99]); |
2760 |
|
while(!endp(V258)) |
2761 |
|
if(eql(x,V258->c.c_car)){ |
2762 |
|
goto T941; |
2763 |
|
}else V258=V258->c.c_cdr; |
2764 |
|
goto T940;} |
2765 |
|
goto T941; |
2766 |
|
T941:; |
2767 |
|
base[4]= VV[144]; |
2768 |
|
base[5]= (V252); |
2769 |
|
vs_top=(vs_base=base+4)+2; |
2770 |
|
(void) (*Lnk347)(); |
2771 |
|
vs_top=sup; |
2772 |
|
goto T935; |
2773 |
|
goto T940; |
2774 |
|
T940:; |
2775 |
|
setq(VV[99],make_cons(V252,symbol_value(VV[99]))); |
2776 |
|
goto T935; |
2777 |
|
goto T937; |
2778 |
|
T937:; |
2779 |
|
{register object x= (V252),V260= symbol_value(VV[100]); |
2780 |
|
while(!endp(V260)) |
2781 |
|
if(type_of(V260->c.c_car)==t_cons &&eql(x,V260->c.c_car->c.c_car)){ |
2782 |
|
goto T946; |
2783 |
|
}else V260=V260->c.c_cdr; |
2784 |
|
goto T935;} |
2785 |
|
goto T946; |
2786 |
|
T946:; |
2787 |
|
base[4]= VV[145]; |
2788 |
|
base[5]= (V252); |
2789 |
|
vs_top=(vs_base=base+4)+2; |
2790 |
|
(void) (*Lnk347)(); |
2791 |
|
vs_top=sup; |
2792 |
|
goto T935; |
2793 |
|
T935:; |
2794 |
|
if(type_of((V252))==t_symbol){ |
2795 |
|
goto T949;} |
2796 |
|
base[4]= VV[146]; |
2797 |
|
base[5]= (V252); |
2798 |
|
vs_top=(vs_base=base+4)+2; |
2799 |
|
(void) (*Lnk347)(); |
2800 |
|
vs_top=sup; |
2801 |
|
goto T949; |
2802 |
|
T949:; |
2803 |
|
base[4]= (V252); |
2804 |
|
base[5]= (V254); |
2805 |
|
vs_top=(vs_base=base+4)+2; |
2806 |
|
(void) (*Lnk358)(); |
2807 |
|
vs_top=sup; |
2808 |
|
{object V261; |
2809 |
|
if((V253)!=Cnil){ |
2810 |
|
V262= (V253); |
2811 |
|
goto T958;} |
2812 |
|
base[5]= (V254); |
2813 |
|
vs_top=(vs_base=base+5)+1; |
2814 |
|
(void) (*Lnk329)(); |
2815 |
|
vs_top=sup; |
2816 |
|
V262= vs_base[0]; |
2817 |
|
goto T958; |
2818 |
|
T958:; |
2819 |
|
V261= list(2,(V252),V262); |
2820 |
|
setq(VV[100],make_cons((V261),symbol_value(VV[100]))); |
2821 |
|
goto T919;} |
2822 |
|
goto T933; |
2823 |
|
T933:; |
2824 |
|
if(((V253))==Cnil){ |
2825 |
|
goto T962;} |
2826 |
|
if((symbol_value(VV[63]))==Cnil){ |
2827 |
|
goto T965;} |
2828 |
|
base[4]= (V252); |
2829 |
|
base[5]= (V254); |
2830 |
|
vs_top=(vs_base=base+4)+2; |
2831 |
|
(void) (*Lnk358)(); |
2832 |
|
vs_top=sup; |
2833 |
|
{object V263; |
2834 |
|
V263= list(2,(V252),(V253)); |
2835 |
|
setq(VV[100],make_cons((V263),symbol_value(VV[100]))); |
2836 |
|
goto T919;} |
2837 |
|
goto T965; |
2838 |
|
T965:; |
2839 |
|
{object V264; |
2840 |
|
base[4]= VV[147]; |
2841 |
|
vs_top=(vs_base=base+4)+1; |
2842 |
|
(void) (*Lnk327)(); |
2843 |
|
vs_top=sup; |
2844 |
|
V264= vs_base[0]; |
2845 |
|
{object V265; |
2846 |
|
V265= list(2,(V264),(V253)); |
2847 |
|
setq(VV[100],make_cons((V265),symbol_value(VV[100])));} |
2848 |
|
setq(VV[104],listA(3,(V252),(V264),symbol_value(VV[104]))); |
2849 |
|
goto T919;} |
2850 |
|
goto T962; |
2851 |
|
T962:; |
2852 |
|
{object V266; |
2853 |
|
object V267; |
2854 |
|
V266= Cnil; |
2855 |
|
V267= Cnil; |
2856 |
|
if(!(type_of((V254))!=t_cons)){ |
2857 |
|
goto T980;} |
2858 |
|
V267= (V254); |
2859 |
|
V266= (V267); |
2860 |
|
goto T978; |
2861 |
|
goto T980; |
2862 |
|
T980:; |
2863 |
|
V266= car((V254)); |
2864 |
|
V267= cdr((V254)); |
2865 |
|
goto T978; |
2866 |
|
T978:; |
2867 |
|
base[4]= car((V252)); |
2868 |
|
base[5]= Cnil; |
2869 |
|
base[6]= (V266); |
2870 |
|
base[7]= (V255); |
2871 |
|
vs_top=(vs_base=base+4)+4; |
2872 |
|
(void) (*Lnk359)(); |
2873 |
|
vs_top=sup; |
2874 |
|
base[4]= cdr((V252)); |
2875 |
|
base[5]= Cnil; |
2876 |
|
base[6]= (V267); |
2877 |
|
base[7]= (V255); |
2878 |
|
vs_top=(vs_base=base+4)+4; |
2879 |
|
(void) (*Lnk359)(); |
2880 |
|
vs_top=sup;} |
2881 |
|
goto T919; |
2882 |
|
T919:; |
2883 |
|
base[4]= (V252); |
2884 |
|
vs_top=(vs_base=base+4)+1; |
2885 |
|
return; |
2886 |
|
} |
2887 |
|
} |
2888 |
|
/* function definition for LOOP-MAKE-ITERATION-VARIABLE */ |
2889 |
|
|
2890 |
|
static void L62() |
2891 |
|
{register object *base=vs_base; |
2892 |
|
register object *sup=base+VM52; VC52 |
2893 |
|
vs_reserve(VM52); |
2894 |
|
{object V268; |
2895 |
|
object V269; |
2896 |
|
object V270; |
2897 |
|
check_arg(3); |
2898 |
|
V268=(base[0]); |
2899 |
|
V269=(base[1]); |
2900 |
|
V270=(base[2]); |
2901 |
|
vs_top=sup; |
2902 |
|
goto TTL; |
2903 |
|
TTL:; |
2904 |
|
base[3]= (V268); |
2905 |
|
base[4]= (V269); |
2906 |
|
base[5]= (V270); |
2907 |
|
base[6]= Ct; |
2908 |
|
vs_top=(vs_base=base+3)+4; |
2909 |
|
(void) (*Lnk359)(); |
2910 |
|
return; |
2911 |
|
} |
2912 |
|
} |
2913 |
|
/* function definition for LOOP-DECLARE-VARIABLE */ |
2914 |
|
|
2915 |
|
static void L63() |
2916 |
|
{register object *base=vs_base; |
2917 |
|
register object *sup=base+VM53; VC53 |
2918 |
|
vs_reserve(VM53); |
2919 |
|
{register object V271; |
2920 |
|
register object V272; |
2921 |
|
check_arg(2); |
2922 |
|
V271=(base[0]); |
2923 |
|
V272=(base[1]); |
2924 |
|
vs_top=sup; |
2925 |
|
goto TTL; |
2926 |
|
TTL:; |
2927 |
|
if(((V271))==Cnil){ |
2928 |
|
goto T1000;} |
2929 |
|
if(((V272))==Cnil){ |
2930 |
|
goto T1000;} |
2931 |
|
if(!(((V272))==(Ct))){ |
2932 |
|
goto T1001;} |
2933 |
|
goto T1000; |
2934 |
|
T1000:; |
2935 |
|
base[2]= Cnil; |
2936 |
|
vs_top=(vs_base=base+2)+1; |
2937 |
|
return; |
2938 |
|
goto T1001; |
2939 |
|
T1001:; |
2940 |
|
if(!(type_of((V271))==t_symbol)){ |
2941 |
|
goto T1008;} |
2942 |
|
if(((V272))==(Ct)){ |
2943 |
|
goto T1011;} |
2944 |
|
{register object x= (V271),V273= symbol_value(VV[101]); |
2945 |
|
while(!endp(V273)) |
2946 |
|
if(eql(x,V273->c.c_car)){ |
2947 |
|
goto T1011; |
2948 |
|
}else V273=V273->c.c_cdr;} |
2949 |
|
{object V275; |
2950 |
|
V275= list(3,VV[31],V272,(V271)); |
2951 |
|
setq(VV[103],make_cons((V275),symbol_value(VV[103]))); |
2952 |
|
base[3]= symbol_value(VV[103]); |
2953 |
|
vs_top=(vs_base=base+3)+1; |
2954 |
|
return;} |
2955 |
|
goto T1011; |
2956 |
|
T1011:; |
2957 |
|
base[2]= Cnil; |
2958 |
|
vs_top=(vs_base=base+2)+1; |
2959 |
|
return; |
2960 |
|
goto T1008; |
2961 |
|
T1008:; |
2962 |
|
if(!(type_of((V271))==t_cons)){ |
2963 |
|
goto T1018;} |
2964 |
|
if(!(type_of((V272))==t_cons)){ |
2965 |
|
goto T1021;} |
2966 |
|
base[2]= car((V271)); |
2967 |
|
base[3]= car((V272)); |
2968 |
|
vs_top=(vs_base=base+2)+2; |
2969 |
|
(void) (*Lnk358)(); |
2970 |
|
vs_top=sup; |
2971 |
|
V271= cdr((V271)); |
2972 |
|
V272= cdr((V272)); |
2973 |
|
goto TTL; |
2974 |
|
goto T1021; |
2975 |
|
T1021:; |
2976 |
|
base[2]= car((V271)); |
2977 |
|
base[3]= (V272); |
2978 |
|
vs_top=(vs_base=base+2)+2; |
2979 |
|
(void) (*Lnk358)(); |
2980 |
|
vs_top=sup; |
2981 |
|
V271= cdr((V271)); |
2982 |
|
goto TTL; |
2983 |
|
goto T1018; |
2984 |
|
T1018:; |
2985 |
|
base[2]= VV[148]; |
2986 |
|
base[3]= (V271); |
2987 |
|
vs_top=(vs_base=base+2)+2; |
2988 |
|
Lerror(); |
2989 |
|
return; |
2990 |
|
} |
2991 |
|
} |
2992 |
|
/* function definition for LOOP-MAYBE-BIND-FORM */ |
2993 |
|
|
2994 |
|
static void L64() |
2995 |
|
{register object *base=vs_base; |
2996 |
|
register object *sup=base+VM54; VC54 |
2997 |
|
vs_reserve(VM54); |
2998 |
|
{object V276; |
2999 |
|
object V277; |
3000 |
|
check_arg(2); |
3001 |
|
V276=(base[0]); |
3002 |
|
V277=(base[1]); |
3003 |
|
vs_top=sup; |
3004 |
|
goto TTL; |
3005 |
|
TTL:; |
3006 |
|
base[2]= (V276); |
3007 |
|
vs_top=(vs_base=base+2)+1; |
3008 |
|
(void) (*Lnk360)(); |
3009 |
|
vs_top=sup; |
3010 |
|
if((vs_base[0])==Cnil){ |
3011 |
|
goto T1038;} |
3012 |
|
base[2]= (V276); |
3013 |
|
vs_top=(vs_base=base+2)+1; |
3014 |
|
return; |
3015 |
|
goto T1038; |
3016 |
|
T1038:; |
3017 |
|
base[3]= VV[149]; |
3018 |
|
vs_top=(vs_base=base+3)+1; |
3019 |
|
(void) (*Lnk327)(); |
3020 |
|
vs_top=sup; |
3021 |
|
base[2]= vs_base[0]; |
3022 |
|
base[3]= (V276); |
3023 |
|
base[4]= (V277); |
3024 |
|
vs_top=(vs_base=base+2)+3; |
3025 |
|
(void) (*Lnk359)(); |
3026 |
|
return; |
3027 |
|
} |
3028 |
|
} |
3029 |
|
/* function definition for LOOP-DO-IF */ |
3030 |
|
|
3031 |
|
static void L65() |
3032 |
|
{register object *base=vs_base; |
3033 |
|
register object *sup=base+VM55; VC55 |
3034 |
|
vs_reserve(VM55); |
3035 |
|
bds_check; |
3036 |
|
{object V278; |
3037 |
|
object V279; |
3038 |
|
check_arg(2); |
3039 |
|
V278=(base[0]); |
3040 |
|
V279=(base[1]); |
3041 |
|
vs_top=sup; |
3042 |
|
goto TTL; |
3043 |
|
TTL:; |
3044 |
|
{object V280; |
3045 |
|
vs_base=vs_top; |
3046 |
|
(void) (*Lnk361)(); |
3047 |
|
vs_top=sup; |
3048 |
|
V280= vs_base[0]; |
3049 |
|
bds_bind(VV[115],Ct); |
3050 |
|
base[3]= Cnil; |
3051 |
|
{object V281; |
3052 |
|
object V282; |
3053 |
|
base[4]= (V278); |
3054 |
|
vs_top=(vs_base=base+4)+1; |
3055 |
|
L66(base); |
3056 |
|
vs_top=sup; |
3057 |
|
V281= vs_base[0]; |
3058 |
|
base[4]= car(symbol_value(VV[89])); |
3059 |
|
base[5]= VV[150]; |
3060 |
|
vs_top=(vs_base=base+4)+2; |
3061 |
|
(void) (*Lnk357)(); |
3062 |
|
vs_top=sup; |
3063 |
|
if((vs_base[0])==Cnil){ |
3064 |
|
goto T1050;} |
3065 |
|
vs_base=vs_top; |
3066 |
|
(void) (*Lnk350)(); |
3067 |
|
vs_top=sup; |
3068 |
|
base[4]= VV[150]; |
3069 |
|
vs_top=(vs_base=base+4)+1; |
3070 |
|
L66(base); |
3071 |
|
vs_top=sup; |
3072 |
|
V283= vs_base[0]; |
3073 |
|
V282= make_cons(V283,Cnil); |
3074 |
|
goto T1048; |
3075 |
|
goto T1050; |
3076 |
|
T1050:; |
3077 |
|
V282= Cnil; |
3078 |
|
goto T1048; |
3079 |
|
T1048:; |
3080 |
|
base[4]= car(symbol_value(VV[89])); |
3081 |
|
base[5]= VV[151]; |
3082 |
|
vs_top=(vs_base=base+4)+2; |
3083 |
|
(void) (*Lnk357)(); |
3084 |
|
vs_top=sup; |
3085 |
|
if((vs_base[0])==Cnil){ |
3086 |
|
goto T1057;} |
3087 |
|
vs_base=vs_top; |
3088 |
|
(void) (*Lnk350)(); |
3089 |
|
vs_top=sup; |
3090 |
|
goto T1057; |
3091 |
|
T1057:; |
3092 |
|
if((base[3])==Cnil){ |
3093 |
|
goto T1062;} |
3094 |
|
V280= list(3,VV[11],base[3],(V280)); |
3095 |
|
goto T1062; |
3096 |
|
T1062:; |
3097 |
|
if(((V279))==Cnil){ |
3098 |
|
goto T1069;} |
3099 |
|
V284= list(2,VV[36],(V280)); |
3100 |
|
goto T1067; |
3101 |
|
goto T1069; |
3102 |
|
T1069:; |
3103 |
|
V284= (V280); |
3104 |
|
goto T1067; |
3105 |
|
T1067:; |
3106 |
|
base[4]= listA(4,VV[71],V284,(V281),(V282)); |
3107 |
|
vs_top=(vs_base=base+4)+1; |
3108 |
|
(void) (*Lnk354)(); |
3109 |
|
bds_unwind1; |
3110 |
|
return;}} |
3111 |
|
} |
3112 |
|
} |
3113 |
|
/* function definition for LOOP-DO-INITIALLY */ |
3114 |
|
|
3115 |
|
static void L67() |
3116 |
|
{register object *base=vs_base; |
3117 |
|
register object *sup=base+VM56; VC56 |
3118 |
|
vs_reserve(VM56); |
3119 |
|
check_arg(0); |
3120 |
|
vs_top=sup; |
3121 |
|
goto TTL; |
3122 |
|
TTL:; |
3123 |
|
base[0]= VV[156]; |
3124 |
|
vs_top=(vs_base=base+0)+1; |
3125 |
|
(void) (*Lnk362)(); |
3126 |
|
vs_top=sup; |
3127 |
|
{object V285; |
3128 |
|
vs_base=vs_top; |
3129 |
|
(void) (*Lnk363)(); |
3130 |
|
vs_top=sup; |
3131 |
|
V285= vs_base[0]; |
3132 |
|
setq(VV[106],make_cons((V285),symbol_value(VV[106]))); |
3133 |
|
base[1]= symbol_value(VV[106]); |
3134 |
|
vs_top=(vs_base=base+1)+1; |
3135 |
|
return;} |
3136 |
|
} |
3137 |
|
/* function definition for LOOP-DO-FINALLY */ |
3138 |
|
|
3139 |
|
static void L68() |
3140 |
|
{register object *base=vs_base; |
3141 |
|
register object *sup=base+VM57; VC57 |
3142 |
|
vs_reserve(VM57); |
3143 |
|
check_arg(0); |
3144 |
|
vs_top=sup; |
3145 |
|
goto TTL; |
3146 |
|
TTL:; |
3147 |
|
base[0]= VV[157]; |
3148 |
|
vs_top=(vs_base=base+0)+1; |
3149 |
|
(void) (*Lnk362)(); |
3150 |
|
vs_top=sup; |
3151 |
|
{object V286; |
3152 |
|
vs_base=vs_top; |
3153 |
|
(void) (*Lnk363)(); |
3154 |
|
vs_top=sup; |
3155 |
|
V286= vs_base[0]; |
3156 |
|
setq(VV[112],make_cons((V286),symbol_value(VV[112]))); |
3157 |
|
base[1]= symbol_value(VV[112]); |
3158 |
|
vs_top=(vs_base=base+1)+1; |
3159 |
|
return;} |
3160 |
|
} |
3161 |
|
/* function definition for LOOP-DO-DO */ |
3162 |
|
|
3163 |
|
static void L69() |
3164 |
|
{register object *base=vs_base; |
3165 |
|
register object *sup=base+VM58; VC58 |
3166 |
|
vs_reserve(VM58); |
3167 |
|
check_arg(0); |
3168 |
|
vs_top=sup; |
3169 |
|
goto TTL; |
3170 |
|
TTL:; |
3171 |
|
vs_base=vs_top; |
3172 |
|
(void) (*Lnk363)(); |
3173 |
|
vs_top=sup; |
3174 |
|
base[0]= vs_base[0]; |
3175 |
|
vs_top=(vs_base=base+0)+1; |
3176 |
|
(void) (*Lnk364)(); |
3177 |
|
return; |
3178 |
|
} |
3179 |
|
/* function definition for LOOP-DO-NAMED */ |
3180 |
|
|
3181 |
|
static void L70() |
3182 |
|
{register object *base=vs_base; |
3183 |
|
register object *sup=base+VM59; VC59 |
3184 |
|
vs_reserve(VM59); |
3185 |
|
check_arg(0); |
3186 |
|
vs_top=sup; |
3187 |
|
goto TTL; |
3188 |
|
TTL:; |
3189 |
|
{register object V287; |
3190 |
|
vs_base=vs_top; |
3191 |
|
(void) (*Lnk350)(); |
3192 |
|
vs_top=sup; |
3193 |
|
V287= vs_base[0]; |
3194 |
|
if(type_of((V287))==t_symbol){ |
3195 |
|
goto T1081;} |
3196 |
|
base[0]= VV[158]; |
3197 |
|
base[1]= (V287); |
3198 |
|
vs_top=(vs_base=base+0)+2; |
3199 |
|
(void) (*Lnk347)(); |
3200 |
|
vs_top=sup; |
3201 |
|
goto T1081; |
3202 |
|
T1081:; |
3203 |
|
if((symbol_value(VV[108]))!=Cnil){ |
3204 |
|
goto T1087;} |
3205 |
|
if((symbol_value(VV[109]))!=Cnil){ |
3206 |
|
goto T1087;} |
3207 |
|
if((symbol_value(VV[113]))!=Cnil){ |
3208 |
|
goto T1087;} |
3209 |
|
if((symbol_value(VV[115]))==Cnil){ |
3210 |
|
goto T1086;} |
3211 |
|
goto T1087; |
3212 |
|
T1087:; |
3213 |
|
base[0]= VV[159]; |
3214 |
|
base[1]= (V287); |
3215 |
|
vs_top=(vs_base=base+0)+2; |
3216 |
|
(void) (*Lnk347)(); |
3217 |
|
vs_top=sup; |
3218 |
|
goto T1086; |
3219 |
|
T1086:; |
3220 |
|
if((symbol_value(VV[118]))==Cnil){ |
3221 |
|
goto T1097;} |
3222 |
|
base[0]= VV[160]; |
3223 |
|
base[1]= car(symbol_value(VV[118])); |
3224 |
|
base[2]= (V287); |
3225 |
|
vs_top=(vs_base=base+0)+3; |
3226 |
|
(void) (*Lnk347)(); |
3227 |
|
vs_top=sup; |
3228 |
|
goto T1097; |
3229 |
|
T1097:; |
3230 |
|
setq(VV[118],list(2,(V287),Cnil)); |
3231 |
|
base[0]= symbol_value(VV[118]); |
3232 |
|
vs_top=(vs_base=base+0)+1; |
3233 |
|
return;} |
3234 |
|
} |
3235 |
|
/* function definition for LOOP-DO-RETURN */ |
3236 |
|
|
3237 |
|
static void L71() |
3238 |
|
{register object *base=vs_base; |
3239 |
|
register object *sup=base+VM60; VC60 |
3240 |
|
vs_reserve(VM60); |
3241 |
|
check_arg(0); |
3242 |
|
vs_top=sup; |
3243 |
|
goto TTL; |
3244 |
|
TTL:; |
3245 |
|
vs_base=vs_top; |
3246 |
|
(void) (*Lnk361)(); |
3247 |
|
vs_top=sup; |
3248 |
|
base[1]= vs_base[0]; |
3249 |
|
vs_top=(vs_base=base+1)+1; |
3250 |
|
(void) (*Lnk355)(); |
3251 |
|
vs_top=sup; |
3252 |
|
base[0]= vs_base[0]; |
3253 |
|
vs_top=(vs_base=base+0)+1; |
3254 |
|
(void) (*Lnk354)(); |
3255 |
|
return; |
3256 |
|
} |
3257 |
|
/* function definition for MAKE-LOOP-COLLECTOR */ |
3258 |
|
|
3259 |
|
static void L72() |
3260 |
|
{register object *base=vs_base; |
3261 |
|
register object *sup=base+VM61; VC61 |
3262 |
|
vs_reserve(VM61); |
3263 |
|
{object V288; |
3264 |
|
object V289; |
3265 |
|
object V290; |
3266 |
|
object V291; |
3267 |
|
object V292; |
3268 |
|
object V293; |
3269 |
|
parse_key(vs_base,FALSE,FALSE,6,VV[165],VV[166],VV[167],VV[365],VV[168],VV[366]); |
3270 |
|
vs_top=sup; |
3271 |
|
V288=(base[0]); |
3272 |
|
V289=(base[1]); |
3273 |
|
V290=(base[2]); |
3274 |
|
V291=(base[3]); |
3275 |
|
V292=(base[4]); |
3276 |
|
V293=(base[5]); |
3277 |
|
base[12]= VV[161]; |
3278 |
|
base[13]= (V288); |
3279 |
|
base[14]= (V289); |
3280 |
|
base[15]= (V290); |
3281 |
|
base[16]= (V291); |
3282 |
|
base[17]= (V292); |
3283 |
|
base[18]= (V293); |
3284 |
|
vs_top=(vs_base=base+12)+7; |
3285 |
|
siLmake_structure(); |
3286 |
|
return; |
3287 |
|
} |
3288 |
|
} |
3289 |
|
/* function definition for LOOP-GET-COLLECTION-INFO */ |
3290 |
|
|
3291 |
|
static void L73() |
3292 |
|
{register object *base=vs_base; |
3293 |
|
register object *sup=base+VM62; VC62 |
3294 |
|
vs_reserve(VM62); |
3295 |
|
{object V294; |
3296 |
|
object V295; |
3297 |
|
object V296; |
3298 |
|
check_arg(3); |
3299 |
|
V294=(base[0]); |
3300 |
|
V295=(base[1]); |
3301 |
|
V296=(base[2]); |
3302 |
|
vs_top=sup; |
3303 |
|
goto TTL; |
3304 |
|
TTL:; |
3305 |
|
base[3]= car(symbol_value(VV[89])); |
3306 |
|
base[4]= VV[162]; |
3307 |
|
vs_top=(vs_base=base+3)+2; |
3308 |
|
(void) (*Lnk357)(); |
3309 |
|
vs_top=sup; |
3310 |
|
if((vs_base[0])!=Cnil){ |
3311 |
|
goto T1113;} |
3312 |
|
setq(VV[119],Ct); |
3313 |
|
goto T1113; |
3314 |
|
T1113:; |
3315 |
|
{object V297; |
3316 |
|
register object V298; |
3317 |
|
register object V299; |
3318 |
|
vs_base=vs_top; |
3319 |
|
(void) (*Lnk361)(); |
3320 |
|
vs_top=sup; |
3321 |
|
V297= vs_base[0]; |
3322 |
|
V300= structure_ref(symbol_value(VV[97]),VV[39],6); |
3323 |
|
if((/* INLINE-ARGS */V300)==Cnil){ |
3324 |
|
goto T1121;} |
3325 |
|
V298= Cnil; |
3326 |
|
goto T1120; |
3327 |
|
goto T1121; |
3328 |
|
T1121:; |
3329 |
|
vs_base=vs_top; |
3330 |
|
(void) (*Lnk367)(); |
3331 |
|
vs_top=sup; |
3332 |
|
V298= vs_base[0]; |
3333 |
|
goto T1120; |
3334 |
|
T1120:; |
3335 |
|
base[3]= car(symbol_value(VV[89])); |
3336 |
|
base[4]= VV[162]; |
3337 |
|
vs_top=(vs_base=base+3)+2; |
3338 |
|
(void) (*Lnk357)(); |
3339 |
|
vs_top=sup; |
3340 |
|
if((vs_base[0])==Cnil){ |
3341 |
|
goto T1125;} |
3342 |
|
vs_base=vs_top; |
3343 |
|
(void) (*Lnk350)(); |
3344 |
|
vs_top=sup; |
3345 |
|
vs_base=vs_top; |
3346 |
|
(void) (*Lnk350)(); |
3347 |
|
vs_top=sup; |
3348 |
|
V299= vs_base[0]; |
3349 |
|
goto T1123; |
3350 |
|
goto T1125; |
3351 |
|
T1125:; |
3352 |
|
V299= Cnil; |
3353 |
|
goto T1123; |
3354 |
|
T1123:; |
3355 |
|
if(type_of((V299))==t_symbol){ |
3356 |
|
goto T1130;} |
3357 |
|
base[3]= VV[163]; |
3358 |
|
base[4]= (V299); |
3359 |
|
vs_top=(vs_base=base+3)+2; |
3360 |
|
(void) (*Lnk347)(); |
3361 |
|
vs_top=sup; |
3362 |
|
goto T1130; |
3363 |
|
T1130:; |
3364 |
|
if(((V298))!=Cnil){ |
3365 |
|
goto T1135;}{object V301; |
3366 |
|
vs_base=vs_top; |
3367 |
|
(void) (*Lnk367)(); |
3368 |
|
vs_top=sup; |
3369 |
|
V301= vs_base[0]; |
3370 |
|
if(V301==Cnil)goto T1139; |
3371 |
|
V298= V301; |
3372 |
|
goto T1138; |
3373 |
|
goto T1139; |
3374 |
|
T1139:;} |
3375 |
|
V298= (V296); |
3376 |
|
goto T1138; |
3377 |
|
T1138:; |
3378 |
|
goto T1135; |
3379 |
|
T1135:; |
3380 |
|
{register object V302;{object V303; |
3381 |
|
V303= symbol_value(VV[120]); |
3382 |
|
V304= symbol_function(VV[369]); |
3383 |
|
V302= (VFUN_NARGS=4,(*(LnkLI368))((V299),V303,VV[164],V304));} |
3384 |
|
if(((V302))!=Cnil){ |
3385 |
|
goto T1145;} |
3386 |
|
{object V305; |
3387 |
|
base[4]= VV[165]; |
3388 |
|
base[5]= (V299); |
3389 |
|
base[6]= VV[166]; |
3390 |
|
base[7]= (V295); |
3391 |
|
base[8]= VV[167]; |
3392 |
|
base[9]= make_cons((V294),Cnil); |
3393 |
|
base[10]= VV[168]; |
3394 |
|
base[11]= (V298); |
3395 |
|
vs_top=(vs_base=base+4)+8; |
3396 |
|
(void) (*Lnk370)(); |
3397 |
|
vs_top=sup; |
3398 |
|
V302= vs_base[0]; |
3399 |
|
V305= (V302); |
3400 |
|
setq(VV[120],make_cons((V305),symbol_value(VV[120]))); |
3401 |
|
goto T1143;} |
3402 |
|
goto T1145; |
3403 |
|
T1145:; |
3404 |
|
V306= structure_ref((V302),VV[161],1); |
3405 |
|
if((/* INLINE-ARGS */V306)==((V295))){ |
3406 |
|
goto T1158;} |
3407 |
|
base[3]= VV[169]; |
3408 |
|
base[4]= (V299); |
3409 |
|
V307= structure_ref((V302),VV[161],2); |
3410 |
|
base[5]= car(/* INLINE-ARGS */V307); |
3411 |
|
base[6]= (V294); |
3412 |
|
vs_top=(vs_base=base+3)+4; |
3413 |
|
(void) (*Lnk347)(); |
3414 |
|
vs_top=sup; |
3415 |
|
goto T1158; |
3416 |
|
T1158:; |
3417 |
|
V308= structure_ref((V302),VV[161],4); |
3418 |
|
if(equal((V298),/* INLINE-ARGS */V308)){ |
3419 |
|
goto T1165;} |
3420 |
|
base[3]= VV[170]; |
3421 |
|
base[4]= (V299); |
3422 |
|
base[5]= (V298); |
3423 |
|
base[6]= structure_ref((V302),VV[161],4); |
3424 |
|
vs_top=(vs_base=base+3)+4; |
3425 |
|
(void) (*Lnk338)(); |
3426 |
|
vs_top=sup; |
3427 |
|
V309= structure_ref((V302),VV[161],4); |
3428 |
|
if(!((/* INLINE-ARGS */V309)==(Ct))){ |
3429 |
|
goto T1165;} |
3430 |
|
(void)(structure_set((V302),VV[161],4,(V298))); |
3431 |
|
goto T1165; |
3432 |
|
T1165:; |
3433 |
|
{object V312; |
3434 |
|
V313= structure_ref(V302,VV[161],2); |
3435 |
|
V312= make_cons(V294,/* INLINE-ARGS */V313); |
3436 |
|
(void)(structure_set(V302,VV[161],2,(V312)));} |
3437 |
|
goto T1143; |
3438 |
|
T1143:; |
3439 |
|
base[3]= (V302); |
3440 |
|
base[4]= (V297); |
3441 |
|
vs_top=(vs_base=base+3)+2; |
3442 |
|
return;}} |
3443 |
|
} |
3444 |
|
} |
3445 |
|
/* function definition for LOOP-LIST-COLLECTION */ |
3446 |
|
|
3447 |
|
static void L74() |
3448 |
|
{register object *base=vs_base; |
3449 |
|
register object *sup=base+VM63; VC63 |
3450 |
|
vs_reserve(VM63); |
3451 |
|
{object V314; |
3452 |
|
check_arg(1); |
3453 |
|
V314=(base[0]); |
3454 |
|
vs_top=sup; |
3455 |
|
goto TTL; |
3456 |
|
TTL:; |
3457 |
|
{register object V315; |
3458 |
|
register object V316; |
3459 |
|
base[1]= (V314); |
3460 |
|
base[2]= VV[5]; |
3461 |
|
base[3]= VV[5]; |
3462 |
|
vs_top=(vs_base=base+1)+3; |
3463 |
|
(void) (*Lnk371)(); |
3464 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1182;} |
3465 |
|
V315= vs_base[0]; |
3466 |
|
vs_base++; |
3467 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1183;} |
3468 |
|
V316= vs_base[0]; |
3469 |
|
vs_top=sup; |
3470 |
|
goto T1184; |
3471 |
|
goto T1182; |
3472 |
|
T1182:; |
3473 |
|
V315= Cnil; |
3474 |
|
goto T1183; |
3475 |
|
T1183:; |
3476 |
|
V316= Cnil; |
3477 |
|
goto T1184; |
3478 |
|
T1184:; |
3479 |
|
{register object V317; |
3480 |
|
V317= structure_ref((V315),VV[161],3); |
3481 |
|
if(((V317))!=Cnil){ |
3482 |
|
goto T1186;} |
3483 |
|
base[1]= VV[171]; |
3484 |
|
vs_top=(vs_base=base+1)+1; |
3485 |
|
(void) (*Lnk327)(); |
3486 |
|
vs_top=sup; |
3487 |
|
V318= vs_base[0]; |
3488 |
|
base[1]= VV[172]; |
3489 |
|
vs_top=(vs_base=base+1)+1; |
3490 |
|
(void) (*Lnk327)(); |
3491 |
|
vs_top=sup; |
3492 |
|
V319= vs_base[0]; |
3493 |
|
if((structure_ref((V315),VV[161],0))!=Cnil){ |
3494 |
|
goto T1196;} |
3495 |
|
V320= Cnil; |
3496 |
|
goto T1195; |
3497 |
|
goto T1196; |
3498 |
|
T1196:; |
3499 |
|
V321= structure_ref((V315),VV[161],0); |
3500 |
|
V320= make_cons(/* INLINE-ARGS */V321,Cnil); |
3501 |
|
goto T1195; |
3502 |
|
T1195:; |
3503 |
|
V317= listA(3,V318,V319,V320); |
3504 |
|
(void)(structure_set((V315),VV[161],3,(V317))); |
3505 |
|
{object V322; |
3506 |
|
V322= list(2,VV[173],(V317)); |
3507 |
|
setq(VV[107],make_cons((V322),symbol_value(VV[107])));} |
3508 |
|
if((structure_ref((V315),VV[161],0))!=Cnil){ |
3509 |
|
goto T1186;} |
3510 |
|
base[1]= listA(3,VV[174],car((V317)),cddr((V317))); |
3511 |
|
vs_top=(vs_base=base+1)+1; |
3512 |
|
(void) (*Lnk372)(); |
3513 |
|
vs_top=sup; |
3514 |
|
goto T1186; |
3515 |
|
T1186:; |
3516 |
|
{object V323= (V314); |
3517 |
|
if((V323!= VV[5]))goto T1205; |
3518 |
|
V316= list(2,VV[5],(V316)); |
3519 |
|
goto T1204; |
3520 |
|
goto T1205; |
3521 |
|
T1205:; |
3522 |
|
if((V323!= VV[373]))goto T1207; |
3523 |
|
goto T1204; |
3524 |
|
goto T1207; |
3525 |
|
T1207:; |
3526 |
|
if((V323!= VV[374]))goto T1208; |
3527 |
|
if(!(type_of((V316))==t_cons)){ |
3528 |
|
goto T1209;} |
3529 |
|
if((car((V316)))==(VV[5])){ |
3530 |
|
goto T1204;} |
3531 |
|
goto T1209; |
3532 |
|
T1209:; |
3533 |
|
V316= list(2,VV[175],(V316)); |
3534 |
|
goto T1204; |
3535 |
|
goto T1208; |
3536 |
|
T1208:; |
3537 |
|
FEerror("The ECASE key value ~s is illegal.",1,V323); |
3538 |
|
goto T1204;} |
3539 |
|
goto T1204; |
3540 |
|
T1204:; |
3541 |
|
base[1]= list(3,VV[176],(V317),(V316)); |
3542 |
|
vs_top=(vs_base=base+1)+1; |
3543 |
|
(void) (*Lnk364)(); |
3544 |
|
return;}} |
3545 |
|
} |
3546 |
|
} |
3547 |
|
/* function definition for LOOP-SUM-COLLECTION */ |
3548 |
|
|
3549 |
|
static void L75() |
3550 |
|
{register object *base=vs_base; |
3551 |
|
register object *sup=base+VM64; VC64 |
3552 |
|
vs_reserve(VM64); |
3553 |
|
{object V324; |
3554 |
|
object V325; |
3555 |
|
object V326; |
3556 |
|
check_arg(3); |
3557 |
|
V324=(base[0]); |
3558 |
|
V325=(base[1]); |
3559 |
|
V326=(base[2]); |
3560 |
|
vs_top=sup; |
3561 |
|
goto TTL; |
3562 |
|
TTL:; |
3563 |
|
{register object V327; |
3564 |
|
object V328; |
3565 |
|
base[3]= (V324); |
3566 |
|
base[4]= VV[177]; |
3567 |
|
base[5]= (V326); |
3568 |
|
vs_top=(vs_base=base+3)+3; |
3569 |
|
(void) (*Lnk371)(); |
3570 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1219;} |
3571 |
|
V327= vs_base[0]; |
3572 |
|
vs_base++; |
3573 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1220;} |
3574 |
|
V328= vs_base[0]; |
3575 |
|
vs_top=sup; |
3576 |
|
goto T1221; |
3577 |
|
goto T1219; |
3578 |
|
T1219:; |
3579 |
|
V327= Cnil; |
3580 |
|
goto T1220; |
3581 |
|
T1220:; |
3582 |
|
V328= Cnil; |
3583 |
|
goto T1221; |
3584 |
|
T1221:; |
3585 |
|
base[3]= structure_ref((V327),VV[161],4); |
3586 |
|
base[4]= (V325); |
3587 |
|
vs_top=(vs_base=base+3)+2; |
3588 |
|
(void) (*Lnk375)(); |
3589 |
|
vs_top=sup; |
3590 |
|
{register object V329; |
3591 |
|
V329= structure_ref((V327),VV[161],3); |
3592 |
|
if(((V329))!=Cnil){ |
3593 |
|
goto T1226;}{object V331; |
3594 |
|
V331= structure_ref((V327),VV[161],0); |
3595 |
|
if(V331==Cnil)goto T1233; |
3596 |
|
base[3]= V331; |
3597 |
|
goto T1232; |
3598 |
|
goto T1233; |
3599 |
|
T1233:;} |
3600 |
|
base[4]= VV[178]; |
3601 |
|
vs_top=(vs_base=base+4)+1; |
3602 |
|
(void) (*Lnk327)(); |
3603 |
|
vs_top=sup; |
3604 |
|
base[3]= vs_base[0]; |
3605 |
|
goto T1232; |
3606 |
|
T1232:; |
3607 |
|
base[4]= Cnil; |
3608 |
|
base[5]= structure_ref((V327),VV[161],4); |
3609 |
|
vs_top=(vs_base=base+3)+3; |
3610 |
|
(void) (*Lnk359)(); |
3611 |
|
vs_top=sup; |
3612 |
|
V330= vs_base[0]; |
3613 |
|
V329= make_cons(V330,Cnil); |
3614 |
|
(void)(structure_set((V327),VV[161],3,(V329))); |
3615 |
|
if((structure_ref((V327),VV[161],0))!=Cnil){ |
3616 |
|
goto T1226;} |
3617 |
|
V332= structure_ref((V327),VV[161],3); |
3618 |
|
base[3]= car(/* INLINE-ARGS */V332); |
3619 |
|
vs_top=(vs_base=base+3)+1; |
3620 |
|
(void) (*Lnk372)(); |
3621 |
|
vs_top=sup; |
3622 |
|
goto T1226; |
3623 |
|
T1226:; |
3624 |
|
if(!(((V324))==(VV[179]))){ |
3625 |
|
goto T1243;} |
3626 |
|
V333= car((V329)); |
3627 |
|
base[4]= Ct; |
3628 |
|
base[5]= car((V329)); |
3629 |
|
base[6]= list(2,VV[180],car((V329))); |
3630 |
|
vs_top=(vs_base=base+4)+3; |
3631 |
|
(void) (*Lnk331)(); |
3632 |
|
vs_top=sup; |
3633 |
|
V334= vs_base[0]; |
3634 |
|
base[3]= list(3,VV[8],(V328),list(3,VV[11],/* INLINE-ARGS */V333,V334)); |
3635 |
|
goto T1241; |
3636 |
|
goto T1243; |
3637 |
|
T1243:; |
3638 |
|
V335= car((V329)); |
3639 |
|
base[4]= Ct; |
3640 |
|
base[5]= car((V329)); |
3641 |
|
base[6]= car((V329)); |
3642 |
|
vs_top=(vs_base=base+4)+3; |
3643 |
|
(void) (*Lnk331)(); |
3644 |
|
vs_top=sup; |
3645 |
|
V336= vs_base[0]; |
3646 |
|
base[3]= list(3,VV[11],/* INLINE-ARGS */V335,list(3,VV[181],V336,(V328))); |
3647 |
|
goto T1241; |
3648 |
|
T1241:; |
3649 |
|
vs_top=(vs_base=base+3)+1; |
3650 |
|
(void) (*Lnk364)(); |
3651 |
|
return;}} |
3652 |
|
} |
3653 |
|
} |
3654 |
|
/* function definition for LOOP-MAXMIN-COLLECTION */ |
3655 |
|
|
3656 |
|
static void L76() |
3657 |
|
{register object *base=vs_base; |
3658 |
|
register object *sup=base+VM65; VC65 |
3659 |
|
vs_reserve(VM65); |
3660 |
|
{object V337; |
3661 |
|
check_arg(1); |
3662 |
|
V337=(base[0]); |
3663 |
|
vs_top=sup; |
3664 |
|
goto TTL; |
3665 |
|
TTL:; |
3666 |
|
{register object V338; |
3667 |
|
object V339; |
3668 |
|
base[1]= (V337); |
3669 |
|
base[2]= VV[182]; |
3670 |
|
base[3]= symbol_value(VV[183]); |
3671 |
|
vs_top=(vs_base=base+1)+3; |
3672 |
|
(void) (*Lnk371)(); |
3673 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1257;} |
3674 |
|
V338= vs_base[0]; |
3675 |
|
vs_base++; |
3676 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1258;} |
3677 |
|
V339= vs_base[0]; |
3678 |
|
vs_top=sup; |
3679 |
|
goto T1259; |
3680 |
|
goto T1257; |
3681 |
|
T1257:; |
3682 |
|
V338= Cnil; |
3683 |
|
goto T1258; |
3684 |
|
T1258:; |
3685 |
|
V339= Cnil; |
3686 |
|
goto T1259; |
3687 |
|
T1259:; |
3688 |
|
base[1]= structure_ref((V338),VV[161],4); |
3689 |
|
base[2]= symbol_value(VV[183]); |
3690 |
|
vs_top=(vs_base=base+1)+2; |
3691 |
|
(void) (*Lnk375)(); |
3692 |
|
vs_top=sup; |
3693 |
|
{register object V340; |
3694 |
|
V340= structure_ref((V338),VV[161],5); |
3695 |
|
if(((V340))!=Cnil){ |
3696 |
|
goto T1264;}{object V341; |
3697 |
|
V341= structure_ref((V338),VV[161],0); |
3698 |
|
if(V341==Cnil)goto T1270; |
3699 |
|
base[1]= V341; |
3700 |
|
goto T1269; |
3701 |
|
goto T1270; |
3702 |
|
T1270:;} |
3703 |
|
base[2]= VV[184]; |
3704 |
|
vs_top=(vs_base=base+2)+1; |
3705 |
|
(void) (*Lnk327)(); |
3706 |
|
vs_top=sup; |
3707 |
|
base[1]= vs_base[0]; |
3708 |
|
goto T1269; |
3709 |
|
T1269:; |
3710 |
|
base[2]= structure_ref((V338),VV[161],4); |
3711 |
|
vs_top=(vs_base=base+1)+2; |
3712 |
|
(void) (*Lnk376)(); |
3713 |
|
vs_top=sup; |
3714 |
|
V340= vs_base[0]; |
3715 |
|
(void)(structure_set((V338),VV[161],5,(V340))); |
3716 |
|
if((structure_ref((V338),VV[161],0))!=Cnil){ |
3717 |
|
goto T1264;} |
3718 |
|
base[1]= structure_ref((V340),VV[18],0); |
3719 |
|
vs_top=(vs_base=base+1)+1; |
3720 |
|
(void) (*Lnk372)(); |
3721 |
|
vs_top=sup; |
3722 |
|
goto T1264; |
3723 |
|
T1264:; |
3724 |
|
base[1]= (V337); |
3725 |
|
base[2]= (V340); |
3726 |
|
vs_top=(vs_base=base+1)+2; |
3727 |
|
(void) (*Lnk377)(); |
3728 |
|
vs_top=sup; |
3729 |
|
{object V342; |
3730 |
|
V342= list(2,VV[185],(V340)); |
3731 |
|
setq(VV[107],make_cons((V342),symbol_value(VV[107])));} |
3732 |
|
base[1]= list(4,VV[186],(V340),(V337),(V339)); |
3733 |
|
vs_top=(vs_base=base+1)+1; |
3734 |
|
(void) (*Lnk364)(); |
3735 |
|
return;}} |
3736 |
|
} |
3737 |
|
} |
3738 |
|
/* function definition for LOOP-DO-ALWAYS */ |
3739 |
|
|
3740 |
|
static void L77() |
3741 |
|
{register object *base=vs_base; |
3742 |
|
register object *sup=base+VM66; VC66 |
3743 |
|
vs_reserve(VM66); |
3744 |
|
{object V343; |
3745 |
|
object V344; |
3746 |
|
check_arg(2); |
3747 |
|
V343=(base[0]); |
3748 |
|
V344=(base[1]); |
3749 |
|
vs_top=sup; |
3750 |
|
goto TTL; |
3751 |
|
TTL:; |
3752 |
|
{object V345; |
3753 |
|
vs_base=vs_top; |
3754 |
|
(void) (*Lnk361)(); |
3755 |
|
vs_top=sup; |
3756 |
|
V345= vs_base[0]; |
3757 |
|
if(((V343))==Cnil){ |
3758 |
|
goto T1285;} |
3759 |
|
vs_base=vs_top; |
3760 |
|
(void) (*Lnk362)(); |
3761 |
|
vs_top=sup; |
3762 |
|
goto T1285; |
3763 |
|
T1285:; |
3764 |
|
if(((V344))==Cnil){ |
3765 |
|
goto T1292;} |
3766 |
|
V346= VV[8]; |
3767 |
|
goto T1290; |
3768 |
|
goto T1292; |
3769 |
|
T1292:; |
3770 |
|
V346= VV[187]; |
3771 |
|
goto T1290; |
3772 |
|
T1290:; |
3773 |
|
base[3]= Cnil; |
3774 |
|
vs_top=(vs_base=base+3)+1; |
3775 |
|
(void) (*Lnk355)(); |
3776 |
|
vs_top=sup; |
3777 |
|
V347= vs_base[0]; |
3778 |
|
base[2]= list(3,V346,(V345),V347); |
3779 |
|
vs_top=(vs_base=base+2)+1; |
3780 |
|
(void) (*Lnk364)(); |
3781 |
|
vs_top=sup; |
3782 |
|
base[2]= Ct; |
3783 |
|
vs_top=(vs_base=base+2)+1; |
3784 |
|
(void) (*Lnk372)(); |
3785 |
|
return;} |
3786 |
|
} |
3787 |
|
} |
3788 |
|
/* function definition for LOOP-DO-THEREIS */ |
3789 |
|
|
3790 |
|
static void L78() |
3791 |
|
{register object *base=vs_base; |
3792 |
|
register object *sup=base+VM67; VC67 |
3793 |
|
vs_reserve(VM67); |
3794 |
|
{object V348; |
3795 |
|
check_arg(1); |
3796 |
|
V348=(base[0]); |
3797 |
|
vs_top=sup; |
3798 |
|
goto TTL; |
3799 |
|
TTL:; |
3800 |
|
if(((V348))==Cnil){ |
3801 |
|
goto T1297;} |
3802 |
|
vs_base=vs_top; |
3803 |
|
(void) (*Lnk362)(); |
3804 |
|
vs_top=sup; |
3805 |
|
goto T1297; |
3806 |
|
T1297:; |
3807 |
|
vs_base=vs_top; |
3808 |
|
(void) (*Lnk378)(); |
3809 |
|
vs_top=sup; |
3810 |
|
V349= vs_base[0]; |
3811 |
|
vs_base=vs_top; |
3812 |
|
(void) (*Lnk361)(); |
3813 |
|
vs_top=sup; |
3814 |
|
V350= vs_base[0]; |
3815 |
|
V351= list(3,VV[11],V349,V350); |
3816 |
|
base[2]= symbol_value(VV[116]); |
3817 |
|
vs_top=(vs_base=base+2)+1; |
3818 |
|
(void) (*Lnk355)(); |
3819 |
|
vs_top=sup; |
3820 |
|
V352= vs_base[0]; |
3821 |
|
base[1]= list(3,VV[8],/* INLINE-ARGS */V351,V352); |
3822 |
|
vs_top=(vs_base=base+1)+1; |
3823 |
|
(void) (*Lnk364)(); |
3824 |
|
vs_top=sup; |
3825 |
|
base[1]= Cnil; |
3826 |
|
vs_top=(vs_base=base+1)+1; |
3827 |
|
(void) (*Lnk372)(); |
3828 |
|
return; |
3829 |
|
} |
3830 |
|
} |
3831 |
|
/* function definition for LOOP-DO-WHILE */ |
3832 |
|
|
3833 |
|
static void L79() |
3834 |
|
{register object *base=vs_base; |
3835 |
|
register object *sup=base+VM68; VC68 |
3836 |
|
vs_reserve(VM68); |
3837 |
|
{object V353; |
3838 |
|
object V354; |
3839 |
|
check_arg(2); |
3840 |
|
V353=(base[0]); |
3841 |
|
V354=(base[1]); |
3842 |
|
vs_top=sup; |
3843 |
|
goto TTL; |
3844 |
|
TTL:; |
3845 |
|
{object V355; |
3846 |
|
vs_base=vs_top; |
3847 |
|
(void) (*Lnk361)(); |
3848 |
|
vs_top=sup; |
3849 |
|
V355= vs_base[0]; |
3850 |
|
base[3]= (V354); |
3851 |
|
vs_top=(vs_base=base+3)+1; |
3852 |
|
(void) (*Lnk362)(); |
3853 |
|
vs_top=sup; |
3854 |
|
if(((V353))==Cnil){ |
3855 |
|
goto T1313;} |
3856 |
|
V356= VV[8]; |
3857 |
|
goto T1311; |
3858 |
|
goto T1313; |
3859 |
|
T1313:; |
3860 |
|
V356= VV[187]; |
3861 |
|
goto T1311; |
3862 |
|
T1311:; |
3863 |
|
base[3]= list(3,V356,(V355),VV[188]); |
3864 |
|
vs_top=(vs_base=base+3)+1; |
3865 |
|
(void) (*Lnk354)(); |
3866 |
|
return;} |
3867 |
|
} |
3868 |
|
} |
3869 |
|
/* function definition for LOOP-DO-WITH */ |
3870 |
|
|
3871 |
|
static void L80() |
3872 |
|
{register object *base=vs_base; |
3873 |
|
register object *sup=base+VM69; VC69 |
3874 |
|
vs_reserve(VM69); |
3875 |
|
check_arg(0); |
3876 |
|
vs_top=sup; |
3877 |
|
goto TTL; |
3878 |
|
TTL:; |
3879 |
|
base[0]= VV[189]; |
3880 |
|
vs_top=(vs_base=base+0)+1; |
3881 |
|
(void) (*Lnk362)(); |
3882 |
|
vs_top=sup; |
3883 |
|
{register object V357; |
3884 |
|
register object V358; |
3885 |
|
register object V359; |
3886 |
|
V357= Cnil; |
3887 |
|
V358= Cnil; |
3888 |
|
V359= Cnil; |
3889 |
|
goto T1318; |
3890 |
|
T1318:; |
3891 |
|
vs_base=vs_top; |
3892 |
|
(void) (*Lnk350)(); |
3893 |
|
vs_top=sup; |
3894 |
|
V357= vs_base[0]; |
3895 |
|
base[0]= (V357); |
3896 |
|
vs_top=(vs_base=base+0)+1; |
3897 |
|
(void) (*Lnk367)(); |
3898 |
|
vs_top=sup; |
3899 |
|
V359= vs_base[0]; |
3900 |
|
base[0]= car(symbol_value(VV[89])); |
3901 |
|
base[1]= VV[190]; |
3902 |
|
vs_top=(vs_base=base+0)+2; |
3903 |
|
(void) (*Lnk357)(); |
3904 |
|
vs_top=sup; |
3905 |
|
if((vs_base[0])==Cnil){ |
3906 |
|
goto T1329;} |
3907 |
|
vs_base=vs_top; |
3908 |
|
(void) (*Lnk350)(); |
3909 |
|
vs_top=sup; |
3910 |
|
vs_base=vs_top; |
3911 |
|
(void) (*Lnk361)(); |
3912 |
|
vs_top=sup; |
3913 |
|
V358= vs_base[0]; |
3914 |
|
goto T1327; |
3915 |
|
goto T1329; |
3916 |
|
T1329:; |
3917 |
|
V358= Cnil; |
3918 |
|
goto T1327; |
3919 |
|
T1327:; |
3920 |
|
base[0]= (V357); |
3921 |
|
base[1]= (V358); |
3922 |
|
base[2]= (V359); |
3923 |
|
vs_top=(vs_base=base+0)+3; |
3924 |
|
(void) (*Lnk359)(); |
3925 |
|
vs_top=sup; |
3926 |
|
base[0]= car(symbol_value(VV[89])); |
3927 |
|
base[1]= VV[155]; |
3928 |
|
vs_top=(vs_base=base+0)+2; |
3929 |
|
(void) (*Lnk357)(); |
3930 |
|
vs_top=sup; |
3931 |
|
if((vs_base[0])==Cnil){ |
3932 |
|
goto T1340;} |
3933 |
|
vs_base=vs_top; |
3934 |
|
(void) (*Lnk350)(); |
3935 |
|
vs_top=sup; |
3936 |
|
goto T1338; |
3937 |
|
goto T1340; |
3938 |
|
T1340:; |
3939 |
|
vs_base=vs_top; |
3940 |
|
(void) (*Lnk349)(); |
3941 |
|
return; |
3942 |
|
goto T1338; |
3943 |
|
T1338:; |
3944 |
|
goto T1318;} |
3945 |
|
} |
3946 |
|
/* function definition for LOOP-HACK-ITERATION */ |
3947 |
|
|
3948 |
|
static void L81() |
3949 |
|
{register object *base=vs_base; |
3950 |
|
register object *sup=base+VM70; VC70 |
3951 |
|
vs_reserve(VM70); |
3952 |
|
{register object V360; |
3953 |
|
check_arg(1); |
3954 |
|
V360=(base[0]); |
3955 |
|
vs_top=sup; |
3956 |
|
goto TTL; |
3957 |
|
TTL:; |
3958 |
|
{register object V361; |
3959 |
|
register object V362; |
3960 |
|
register object V363; |
3961 |
|
register object V364; |
3962 |
|
register object V365; |
3963 |
|
register object V366; |
3964 |
|
register object V367; |
3965 |
|
register object V368; |
3966 |
|
register object V369; |
3967 |
|
object V370; |
3968 |
|
V361= Cnil; |
3969 |
|
V362= Cnil; |
3970 |
|
V363= Cnil; |
3971 |
|
V364= Cnil; |
3972 |
|
V365= Cnil; |
3973 |
|
V366= Cnil; |
3974 |
|
V367= Cnil; |
3975 |
|
V368= Cnil; |
3976 |
|
V369= Cnil; |
3977 |
|
V370= Cnil; |
3978 |
|
goto T1347; |
3979 |
|
T1347:; |
3980 |
|
base[2]= car((V360)); |
3981 |
|
vs_top=(vs_base=base+2)+1; |
3982 |
|
Lsymbol_function(); |
3983 |
|
vs_top=sup; |
3984 |
|
base[1]= vs_base[0]; |
3985 |
|
{object V371; |
3986 |
|
V371= cdr((V360)); |
3987 |
|
vs_top=base+2; |
3988 |
|
while(!endp(V371)) |
3989 |
|
{vs_push(car(V371));V371=cdr(V371);} |
3990 |
|
vs_base=base+2;} |
3991 |
|
super_funcall_no_event(base[1]); |
3992 |
|
vs_top=sup; |
3993 |
|
V370= vs_base[0]; |
3994 |
|
V369= (V370); |
3995 |
|
if((car((V369)))!=Cnil){ |
3996 |
|
goto T1357;} |
3997 |
|
goto T1356; |
3998 |
|
goto T1357; |
3999 |
|
T1357:; |
4000 |
|
{object V372; |
4001 |
|
V372= car((V369)); |
4002 |
|
V361= make_cons((V372),(V361));} |
4003 |
|
goto T1356; |
4004 |
|
T1356:; |
4005 |
|
V369= cdr((V369)); |
4006 |
|
base[1]= car((V369)); |
4007 |
|
vs_top=(vs_base=base+1)+1; |
4008 |
|
Lcopy_list(); |
4009 |
|
vs_top=sup; |
4010 |
|
V373= vs_base[0]; |
4011 |
|
V362= nconc((V362),V373); |
4012 |
|
V369= cdr((V369)); |
4013 |
|
if((car((V369)))!=Cnil){ |
4014 |
|
goto T1367;} |
4015 |
|
goto T1366; |
4016 |
|
goto T1367; |
4017 |
|
T1367:; |
4018 |
|
{object V374; |
4019 |
|
V374= car((V369)); |
4020 |
|
V363= make_cons((V374),(V363));} |
4021 |
|
goto T1366; |
4022 |
|
T1366:; |
4023 |
|
V369= cdr((V369)); |
4024 |
|
base[1]= car((V369)); |
4025 |
|
vs_top=(vs_base=base+1)+1; |
4026 |
|
Lcopy_list(); |
4027 |
|
vs_top=sup; |
4028 |
|
V375= vs_base[0]; |
4029 |
|
V364= nconc((V364),V375); |
4030 |
|
V369= cdr((V369)); |
4031 |
|
if((symbol_value(VV[110]))==Cnil){ |
4032 |
|
goto T1379;} |
4033 |
|
base[1]= VV[191]; |
4034 |
|
vs_top=(vs_base=base+1)+1; |
4035 |
|
(void) (*Lnk347)(); |
4036 |
|
vs_top=sup; |
4037 |
|
goto T1379; |
4038 |
|
T1379:; |
4039 |
|
if(((V369))!=Cnil){ |
4040 |
|
goto T1383;} |
4041 |
|
V369= (V370); |
4042 |
|
goto T1383; |
4043 |
|
T1383:; |
4044 |
|
if((car((V369)))==Cnil){ |
4045 |
|
goto T1387;} |
4046 |
|
{object V376; |
4047 |
|
V376= car((V369)); |
4048 |
|
V365= make_cons((V376),(V365));} |
4049 |
|
goto T1387; |
4050 |
|
T1387:; |
4051 |
|
V369= cdr((V369)); |
4052 |
|
base[1]= car((V369)); |
4053 |
|
vs_top=(vs_base=base+1)+1; |
4054 |
|
Lcopy_list(); |
4055 |
|
vs_top=sup; |
4056 |
|
V377= vs_base[0]; |
4057 |
|
V366= nconc((V366),V377); |
4058 |
|
V369= cdr((V369)); |
4059 |
|
if((car((V369)))==Cnil){ |
4060 |
|
goto T1397;} |
4061 |
|
{object V378; |
4062 |
|
V378= car((V369)); |
4063 |
|
V367= make_cons((V378),(V367));} |
4064 |
|
goto T1397; |
4065 |
|
T1397:; |
4066 |
|
base[1]= cadr((V369)); |
4067 |
|
vs_top=(vs_base=base+1)+1; |
4068 |
|
Lcopy_list(); |
4069 |
|
vs_top=sup; |
4070 |
|
V379= vs_base[0]; |
4071 |
|
V368= nconc((V368),V379); |
4072 |
|
base[1]= car(symbol_value(VV[89])); |
4073 |
|
base[2]= VV[155]; |
4074 |
|
vs_top=(vs_base=base+1)+2; |
4075 |
|
(void) (*Lnk357)(); |
4076 |
|
vs_top=sup; |
4077 |
|
if((vs_base[0])!=Cnil){ |
4078 |
|
goto T1407;} |
4079 |
|
base[1]= (V368); |
4080 |
|
vs_top=(vs_base=base+1)+1; |
4081 |
|
(void) (*Lnk337)(); |
4082 |
|
vs_top=sup; |
4083 |
|
V380= vs_base[0]; |
4084 |
|
base[1]= (V367); |
4085 |
|
vs_top=(vs_base=base+1)+1; |
4086 |
|
L82(base); |
4087 |
|
vs_top=sup; |
4088 |
|
V381= vs_base[0]; |
4089 |
|
base[1]= (V366); |
4090 |
|
vs_top=(vs_base=base+1)+1; |
4091 |
|
(void) (*Lnk336)(); |
4092 |
|
vs_top=sup; |
4093 |
|
V382= vs_base[0]; |
4094 |
|
base[1]= (V365); |
4095 |
|
vs_top=(vs_base=base+1)+1; |
4096 |
|
L82(base); |
4097 |
|
vs_top=sup; |
4098 |
|
V383= vs_base[0]; |
4099 |
|
setq(VV[108],listA(5,V380,V381,V382,V383,symbol_value(VV[108]))); |
4100 |
|
base[1]= (V364); |
4101 |
|
vs_top=(vs_base=base+1)+1; |
4102 |
|
(void) (*Lnk337)(); |
4103 |
|
vs_top=sup; |
4104 |
|
V384= vs_base[0]; |
4105 |
|
base[1]= (V363); |
4106 |
|
vs_top=(vs_base=base+1)+1; |
4107 |
|
L82(base); |
4108 |
|
vs_top=sup; |
4109 |
|
V385= vs_base[0]; |
4110 |
|
base[1]= (V362); |
4111 |
|
vs_top=(vs_base=base+1)+1; |
4112 |
|
(void) (*Lnk336)(); |
4113 |
|
vs_top=sup; |
4114 |
|
V386= vs_base[0]; |
4115 |
|
base[1]= (V361); |
4116 |
|
vs_top=(vs_base=base+1)+1; |
4117 |
|
L82(base); |
4118 |
|
vs_top=sup; |
4119 |
|
V387= vs_base[0]; |
4120 |
|
setq(VV[111],listA(5,V384,V385,V386,V387,symbol_value(VV[111]))); |
4121 |
|
vs_base=vs_top; |
4122 |
|
(void) (*Lnk349)(); |
4123 |
|
vs_top=sup; |
4124 |
|
base[1]= Cnil; |
4125 |
|
vs_top=(vs_base=base+1)+1; |
4126 |
|
return; |
4127 |
|
goto T1407; |
4128 |
|
T1407:; |
4129 |
|
vs_base=vs_top; |
4130 |
|
(void) (*Lnk350)(); |
4131 |
|
vs_top=sup; |
4132 |
|
if((structure_ref(symbol_value(VV[97]),VV[39],7))!=Cnil){ |
4133 |
|
goto T1434;} |
4134 |
|
base[1]= car(symbol_value(VV[89])); |
4135 |
|
base[2]= structure_ref(symbol_value(VV[97]),VV[39],1); |
4136 |
|
vs_top=(vs_base=base+1)+2; |
4137 |
|
(void) (*Lnk351)(); |
4138 |
|
vs_top=sup; |
4139 |
|
V369= vs_base[0]; |
4140 |
|
if(((V369))==Cnil){ |
4141 |
|
goto T1434;} |
4142 |
|
vs_base=vs_top; |
4143 |
|
(void) (*Lnk350)(); |
4144 |
|
vs_top=sup; |
4145 |
|
V360= (V369); |
4146 |
|
goto T1434; |
4147 |
|
T1434:; |
4148 |
|
goto T1347;} |
4149 |
|
} |
4150 |
|
} |
4151 |
|
/* function definition for LOOP-DO-FOR */ |
4152 |
|
|
4153 |
|
static void L83() |
4154 |
|
{register object *base=vs_base; |
4155 |
|
register object *sup=base+VM71; VC71 |
4156 |
|
vs_reserve(VM71); |
4157 |
|
check_arg(0); |
4158 |
|
vs_top=sup; |
4159 |
|
goto TTL; |
4160 |
|
TTL:; |
4161 |
|
{object V388; |
4162 |
|
object V389; |
4163 |
|
object V390; |
4164 |
|
object V391; |
4165 |
|
object V392; |
4166 |
|
vs_base=vs_top; |
4167 |
|
(void) (*Lnk350)(); |
4168 |
|
vs_top=sup; |
4169 |
|
V388= vs_base[0]; |
4170 |
|
base[3]= (V388); |
4171 |
|
vs_top=(vs_base=base+3)+1; |
4172 |
|
(void) (*Lnk367)(); |
4173 |
|
vs_top=sup; |
4174 |
|
V389= vs_base[0]; |
4175 |
|
vs_base=vs_top; |
4176 |
|
(void) (*Lnk350)(); |
4177 |
|
vs_top=sup; |
4178 |
|
V390= vs_base[0]; |
4179 |
|
V391= Cnil; |
4180 |
|
V392= Cnil; |
4181 |
|
vs_base=vs_top; |
4182 |
|
(void) (*Lnk361)(); |
4183 |
|
vs_top=sup; |
4184 |
|
V391= vs_base[0]; |
4185 |
|
if(!(type_of((V390))==t_symbol)){ |
4186 |
|
goto T1455;} |
4187 |
|
base[3]= (V390); |
4188 |
|
base[4]= structure_ref(symbol_value(VV[97]),VV[39],2); |
4189 |
|
vs_top=(vs_base=base+3)+2; |
4190 |
|
(void) (*Lnk351)(); |
4191 |
|
vs_top=sup; |
4192 |
|
V392= vs_base[0]; |
4193 |
|
if(((V392))!=Cnil){ |
4194 |
|
goto T1454;} |
4195 |
|
goto T1455; |
4196 |
|
T1455:; |
4197 |
|
base[3]= VV[194]; |
4198 |
|
base[4]= (V390); |
4199 |
|
vs_top=(vs_base=base+3)+2; |
4200 |
|
(void) (*Lnk347)(); |
4201 |
|
vs_top=sup; |
4202 |
|
goto T1454; |
4203 |
|
T1454:; |
4204 |
|
base[3]= car((V392)); |
4205 |
|
base[4]= (V388); |
4206 |
|
base[5]= (V391); |
4207 |
|
base[6]= (V389); |
4208 |
|
{object V393; |
4209 |
|
V393= cdr((V392)); |
4210 |
|
vs_top=base+7; |
4211 |
|
while(!endp(V393)) |
4212 |
|
{vs_push(car(V393));V393=cdr(V393);} |
4213 |
|
vs_base=base+4;} |
4214 |
|
super_funcall_no_event(base[3]); |
4215 |
|
return;} |
4216 |
|
} |
4217 |
|
/* function definition for LOOP-DO-REPEAT */ |
4218 |
|
|
4219 |
|
static void L84() |
4220 |
|
{register object *base=vs_base; |
4221 |
|
register object *sup=base+VM72; VC72 |
4222 |
|
vs_reserve(VM72); |
4223 |
|
check_arg(0); |
4224 |
|
vs_top=sup; |
4225 |
|
goto TTL; |
4226 |
|
TTL:; |
4227 |
|
{register object V394; |
4228 |
|
register object V395; |
4229 |
|
vs_base=vs_top; |
4230 |
|
(void) (*Lnk361)(); |
4231 |
|
vs_top=sup; |
4232 |
|
V394= vs_base[0]; |
4233 |
|
vs_base=vs_top; |
4234 |
|
(void) (*Lnk367)(); |
4235 |
|
vs_top=sup; |
4236 |
|
base[0]= vs_base[0]; |
4237 |
|
base[1]= symbol_value(VV[183]); |
4238 |
|
vs_top=(vs_base=base+0)+2; |
4239 |
|
(void) (*Lnk375)(); |
4240 |
|
vs_top=sup; |
4241 |
|
V395= vs_base[0]; |
4242 |
|
if(!(type_of((V394))==t_cons)){ |
4243 |
|
goto T1473;} |
4244 |
|
if(!((car((V394)))==(VV[195]))){ |
4245 |
|
goto T1473;} |
4246 |
|
base[0]= cadr((V394)); |
4247 |
|
base[1]= (V395); |
4248 |
|
vs_top=(vs_base=base+0)+2; |
4249 |
|
(void) (*Lnk326)(); |
4250 |
|
vs_top=sup; |
4251 |
|
if((vs_base[0])==Cnil){ |
4252 |
|
goto T1473;} |
4253 |
|
V395= cadr((V394)); |
4254 |
|
goto T1473; |
4255 |
|
T1473:; |
4256 |
|
{object V396; |
4257 |
|
object V397; |
4258 |
|
object V398; |
4259 |
|
base[0]= (V394); |
4260 |
|
base[1]= (V395); |
4261 |
|
vs_top=(vs_base=base+0)+2; |
4262 |
|
(void) (*Lnk379)(); |
4263 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1486;} |
4264 |
|
V396= vs_base[0]; |
4265 |
|
vs_base++; |
4266 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1487;} |
4267 |
|
V397= vs_base[0]; |
4268 |
|
vs_base++; |
4269 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1488;} |
4270 |
|
V398= vs_base[0]; |
4271 |
|
vs_top=sup; |
4272 |
|
goto T1489; |
4273 |
|
goto T1486; |
4274 |
|
T1486:; |
4275 |
|
V396= Cnil; |
4276 |
|
goto T1487; |
4277 |
|
T1487:; |
4278 |
|
V397= Cnil; |
4279 |
|
goto T1488; |
4280 |
|
T1488:; |
4281 |
|
V398= Cnil; |
4282 |
|
goto T1489; |
4283 |
|
T1489:; |
4284 |
|
if(((V397))==Cnil){ |
4285 |
|
goto T1491;} |
4286 |
|
if(!(number_compare((V398),small_fixnum(1))<=0)){ |
4287 |
|
goto T1491;} |
4288 |
|
base[0]= listA(6,Ct,Cnil,Cnil,Cnil,(number_compare((V398),small_fixnum(0))<=0?Ct:Cnil),VV[196]); |
4289 |
|
vs_top=(vs_base=base+0)+1; |
4290 |
|
return; |
4291 |
|
goto T1491; |
4292 |
|
T1491:; |
4293 |
|
{register object V399; |
4294 |
|
base[1]= VV[197]; |
4295 |
|
vs_top=(vs_base=base+1)+1; |
4296 |
|
(void) (*Lnk327)(); |
4297 |
|
vs_top=sup; |
4298 |
|
base[0]= vs_base[0]; |
4299 |
|
base[1]= (V396); |
4300 |
|
base[2]= (V395); |
4301 |
|
vs_top=(vs_base=base+0)+3; |
4302 |
|
(void) (*Lnk359)(); |
4303 |
|
vs_top=sup; |
4304 |
|
V399= vs_base[0]; |
4305 |
|
if(((V397))==Cnil){ |
4306 |
|
goto T1501;} |
4307 |
|
V400= list(2,VV[36],list(2,VV[198],list(3,VV[11],(V399),list(2,VV[199],(V399))))); |
4308 |
|
base[0]= make_cons(/* INLINE-ARGS */V400,VV[200]); |
4309 |
|
vs_top=(vs_base=base+0)+1; |
4310 |
|
return; |
4311 |
|
goto T1501; |
4312 |
|
T1501:; |
4313 |
|
V401= list(2,VV[201],list(3,VV[11],(V399),list(2,VV[199],(V399)))); |
4314 |
|
base[0]= make_cons(/* INLINE-ARGS */V401,VV[202]); |
4315 |
|
vs_top=(vs_base=base+0)+1; |
4316 |
|
return;}}} |
4317 |
|
} |
4318 |
|
/* function definition for LOOP-WHEN-IT-VARIABLE */ |
4319 |
|
|
4320 |
|
static void L85() |
4321 |
|
{register object *base=vs_base; |
4322 |
|
register object *sup=base+VM73; VC73 |
4323 |
|
vs_reserve(VM73); |
4324 |
|
check_arg(0); |
4325 |
|
vs_top=sup; |
4326 |
|
goto TTL; |
4327 |
|
TTL:; |
4328 |
|
if(symbol_value(VV[116])!=Cnil){ |
4329 |
|
base[0]= symbol_value(VV[116]); |
4330 |
|
vs_top=(vs_base=base+0)+1; |
4331 |
|
return;} |
4332 |
|
base[1]= VV[203]; |
4333 |
|
vs_top=(vs_base=base+1)+1; |
4334 |
|
(void) (*Lnk327)(); |
4335 |
|
vs_top=sup; |
4336 |
|
base[0]= vs_base[0]; |
4337 |
|
base[1]= Cnil; |
4338 |
|
base[2]= Cnil; |
4339 |
|
vs_top=(vs_base=base+0)+3; |
4340 |
|
(void) (*Lnk359)(); |
4341 |
|
vs_top=sup; |
4342 |
|
setq(VV[116],vs_base[0]); |
4343 |
|
base[0]= symbol_value(VV[116]); |
4344 |
|
vs_top=(vs_base=base+0)+1; |
4345 |
|
return; |
4346 |
|
} |
4347 |
|
/* function definition for LOOP-ANSI-FOR-EQUALS */ |
4348 |
|
|
4349 |
|
static void L86() |
4350 |
|
{register object *base=vs_base; |
4351 |
|
register object *sup=base+VM74; VC74 |
4352 |
|
vs_reserve(VM74); |
4353 |
|
{register object V402; |
4354 |
|
object V403; |
4355 |
|
object V404; |
4356 |
|
check_arg(3); |
4357 |
|
V402=(base[0]); |
4358 |
|
V403=(base[1]); |
4359 |
|
V404=(base[2]); |
4360 |
|
vs_top=sup; |
4361 |
|
goto TTL; |
4362 |
|
TTL:; |
4363 |
|
base[3]= (V402); |
4364 |
|
base[4]= Cnil; |
4365 |
|
base[5]= (V404); |
4366 |
|
vs_top=(vs_base=base+3)+3; |
4367 |
|
(void) (*Lnk380)(); |
4368 |
|
vs_top=sup; |
4369 |
|
base[3]= car(symbol_value(VV[89])); |
4370 |
|
base[4]= VV[204]; |
4371 |
|
vs_top=(vs_base=base+3)+2; |
4372 |
|
(void) (*Lnk357)(); |
4373 |
|
vs_top=sup; |
4374 |
|
if((vs_base[0])==Cnil){ |
4375 |
|
goto T1513;} |
4376 |
|
vs_base=vs_top; |
4377 |
|
(void) (*Lnk350)(); |
4378 |
|
vs_top=sup; |
4379 |
|
vs_base=vs_top; |
4380 |
|
(void) (*Lnk361)(); |
4381 |
|
vs_top=sup; |
4382 |
|
V405= vs_base[0]; |
4383 |
|
V406= list(2,(V402),V405); |
4384 |
|
base[3]= listA(7,Cnil,/* INLINE-ARGS */V406,Cnil,Cnil,Cnil,list(2,(V402),(V403)),VV[205]); |
4385 |
|
vs_top=(vs_base=base+3)+1; |
4386 |
|
return; |
4387 |
|
goto T1513; |
4388 |
|
T1513:; |
4389 |
|
base[3]= listA(3,Cnil,list(2,(V402),(V403)),VV[206]); |
4390 |
|
vs_top=(vs_base=base+3)+1; |
4391 |
|
return; |
4392 |
|
} |
4393 |
|
} |
4394 |
|
/* function definition for LOOP-FOR-ACROSS */ |
4395 |
|
|
4396 |
|
static void L87() |
4397 |
|
{register object *base=vs_base; |
4398 |
|
register object *sup=base+VM75; VC75 |
4399 |
|
vs_reserve(VM75); |
4400 |
|
{object V407; |
4401 |
|
object V408; |
4402 |
|
object V409; |
4403 |
|
check_arg(3); |
4404 |
|
V407=(base[0]); |
4405 |
|
V408=(base[1]); |
4406 |
|
V409=(base[2]); |
4407 |
|
vs_top=sup; |
4408 |
|
goto TTL; |
4409 |
|
TTL:; |
4410 |
|
base[3]= (V407); |
4411 |
|
base[4]= Cnil; |
4412 |
|
base[5]= (V409); |
4413 |
|
vs_top=(vs_base=base+3)+3; |
4414 |
|
(void) (*Lnk380)(); |
4415 |
|
vs_top=sup; |
4416 |
|
{object V410; |
4417 |
|
register object V411; |
4418 |
|
base[3]= VV[207]; |
4419 |
|
vs_top=(vs_base=base+3)+1; |
4420 |
|
(void) (*Lnk327)(); |
4421 |
|
vs_top=sup; |
4422 |
|
V410= vs_base[0]; |
4423 |
|
base[3]= VV[208]; |
4424 |
|
vs_top=(vs_base=base+3)+1; |
4425 |
|
(void) (*Lnk327)(); |
4426 |
|
vs_top=sup; |
4427 |
|
V411= vs_base[0]; |
4428 |
|
{register object V412; |
4429 |
|
object V413; |
4430 |
|
object V414; |
4431 |
|
base[3]= (V408); |
4432 |
|
base[4]= VV[209]; |
4433 |
|
vs_top=(vs_base=base+3)+2; |
4434 |
|
(void) (*Lnk379)(); |
4435 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1530;} |
4436 |
|
V412= vs_base[0]; |
4437 |
|
vs_base++; |
4438 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1531;} |
4439 |
|
V413= vs_base[0]; |
4440 |
|
vs_base++; |
4441 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1532;} |
4442 |
|
V414= vs_base[0]; |
4443 |
|
vs_top=sup; |
4444 |
|
goto T1533; |
4445 |
|
goto T1530; |
4446 |
|
T1530:; |
4447 |
|
V412= Cnil; |
4448 |
|
goto T1531; |
4449 |
|
T1531:; |
4450 |
|
V413= Cnil; |
4451 |
|
goto T1532; |
4452 |
|
T1532:; |
4453 |
|
V414= Cnil; |
4454 |
|
goto T1533; |
4455 |
|
T1533:; |
4456 |
|
base[3]= (V410); |
4457 |
|
base[4]= (V412); |
4458 |
|
if(!(type_of((V412))==t_cons)){ |
4459 |
|
goto T1539;} |
4460 |
|
if(!((car((V412)))==(VV[195]))){ |
4461 |
|
goto T1539;} |
4462 |
|
base[5]= cadr((V412)); |
4463 |
|
goto T1537; |
4464 |
|
goto T1539; |
4465 |
|
T1539:; |
4466 |
|
base[5]= VV[209]; |
4467 |
|
goto T1537; |
4468 |
|
T1537:; |
4469 |
|
vs_top=(vs_base=base+3)+3; |
4470 |
|
(void) (*Lnk359)(); |
4471 |
|
vs_top=sup; |
4472 |
|
base[3]= (V411); |
4473 |
|
base[4]= small_fixnum(0); |
4474 |
|
base[5]= VV[210]; |
4475 |
|
vs_top=(vs_base=base+3)+3; |
4476 |
|
(void) (*Lnk359)(); |
4477 |
|
vs_top=sup; |
4478 |
|
{long V415; |
4479 |
|
object V416; |
4480 |
|
register object V417; |
4481 |
|
object V418; |
4482 |
|
object V419; |
4483 |
|
object V420; |
4484 |
|
V415= 0; |
4485 |
|
if(((V413))!=Cnil){ |
4486 |
|
goto T1550;} |
4487 |
|
{object V421; |
4488 |
|
base[7]= VV[211]; |
4489 |
|
vs_top=(vs_base=base+7)+1; |
4490 |
|
(void) (*Lnk327)(); |
4491 |
|
vs_top=sup; |
4492 |
|
V421= vs_base[0]; |
4493 |
|
{object V422; |
4494 |
|
V422= list(3,VV[11],(V421),list(2,VV[212],(V410))); |
4495 |
|
setq(VV[106],make_cons((V422),symbol_value(VV[106])));} |
4496 |
|
base[7]= (V421); |
4497 |
|
base[8]= small_fixnum(0); |
4498 |
|
base[9]= VV[210]; |
4499 |
|
vs_top=(vs_base=base+7)+3; |
4500 |
|
(void) (*Lnk359)(); |
4501 |
|
vs_top=sup; |
4502 |
|
V416= vs_base[0]; |
4503 |
|
goto T1548;} |
4504 |
|
goto T1550; |
4505 |
|
T1550:; |
4506 |
|
V415= (long)length((V414)); |
4507 |
|
V416= make_fixnum(V415); |
4508 |
|
goto T1548; |
4509 |
|
T1548:; |
4510 |
|
V417= list(3,VV[213],(V411),(V416)); |
4511 |
|
V418= (V417); |
4512 |
|
V419= list(2,(V407),list(3,VV[214],(V410),(V411))); |
4513 |
|
V420= list(2,(V411),list(2,VV[180],(V411))); |
4514 |
|
if(((V413))==Cnil){ |
4515 |
|
goto T1565;} |
4516 |
|
V417= ((V415)==(0)?Ct:Cnil); |
4517 |
|
if(!((V415)<=(1))){ |
4518 |
|
goto T1565;} |
4519 |
|
V418= Ct; |
4520 |
|
goto T1565; |
4521 |
|
T1565:; |
4522 |
|
if(((((V417))==((V418))?Ct:Cnil))==Cnil){ |
4523 |
|
goto T1574;} |
4524 |
|
V423= Cnil; |
4525 |
|
goto T1573; |
4526 |
|
goto T1574; |
4527 |
|
T1574:; |
4528 |
|
V423= list(4,(V417),(V419),Cnil,(V420)); |
4529 |
|
goto T1573; |
4530 |
|
T1573:; |
4531 |
|
base[7]= listA(5,(V418),(V419),Cnil,(V420),V423); |
4532 |
|
vs_top=(vs_base=base+7)+1; |
4533 |
|
return;}}} |
4534 |
|
} |
4535 |
|
} |
4536 |
|
/* function definition for LOOP-LIST-STEP */ |
4537 |
|
|
4538 |
|
static void L88() |
4539 |
|
{register object *base=vs_base; |
4540 |
|
register object *sup=base+VM76; VC76 |
4541 |
|
vs_reserve(VM76); |
4542 |
|
{object V424; |
4543 |
|
check_arg(1); |
4544 |
|
V424=(base[0]); |
4545 |
|
vs_top=sup; |
4546 |
|
goto TTL; |
4547 |
|
TTL:; |
4548 |
|
{register object V425; |
4549 |
|
base[1]= car(symbol_value(VV[89])); |
4550 |
|
base[2]= VV[215]; |
4551 |
|
vs_top=(vs_base=base+1)+2; |
4552 |
|
(void) (*Lnk357)(); |
4553 |
|
vs_top=sup; |
4554 |
|
if((vs_base[0])==Cnil){ |
4555 |
|
goto T1578;} |
4556 |
|
vs_base=vs_top; |
4557 |
|
(void) (*Lnk350)(); |
4558 |
|
vs_top=sup; |
4559 |
|
vs_base=vs_top; |
4560 |
|
(void) (*Lnk361)(); |
4561 |
|
vs_top=sup; |
4562 |
|
V425= vs_base[0]; |
4563 |
|
goto T1576; |
4564 |
|
goto T1578; |
4565 |
|
T1578:; |
4566 |
|
V425= VV[216]; |
4567 |
|
goto T1576; |
4568 |
|
T1576:; |
4569 |
|
if(!(type_of((V425))==t_cons)){ |
4570 |
|
goto T1584;} |
4571 |
|
if(!((car((V425)))==(VV[217]))){ |
4572 |
|
goto T1584;} |
4573 |
|
base[1]= VV[218]; |
4574 |
|
vs_top=(vs_base=base+1)+1; |
4575 |
|
(void) (*Lnk338)(); |
4576 |
|
vs_top=sup; |
4577 |
|
base[1]= list(3,VV[219],(V425),(V424)); |
4578 |
|
base[2]= Cnil; |
4579 |
|
vs_top=(vs_base=base+1)+2; |
4580 |
|
return; |
4581 |
|
goto T1584; |
4582 |
|
T1584:; |
4583 |
|
if(!(type_of((V425))==t_cons)){ |
4584 |
|
goto T1593;} |
4585 |
|
if(!((car((V425)))==(VV[83]))){ |
4586 |
|
goto T1593;} |
4587 |
|
base[1]= list(2,cadr((V425)),(V424)); |
4588 |
|
base[2]= cadr((V425)); |
4589 |
|
vs_top=(vs_base=base+1)+2; |
4590 |
|
return; |
4591 |
|
goto T1593; |
4592 |
|
T1593:; |
4593 |
|
base[3]= VV[220]; |
4594 |
|
vs_top=(vs_base=base+3)+1; |
4595 |
|
(void) (*Lnk327)(); |
4596 |
|
vs_top=sup; |
4597 |
|
base[2]= vs_base[0]; |
4598 |
|
base[3]= (V425); |
4599 |
|
base[4]= VV[83]; |
4600 |
|
vs_top=(vs_base=base+2)+3; |
4601 |
|
(void) (*Lnk359)(); |
4602 |
|
vs_top=sup; |
4603 |
|
V426= vs_base[0]; |
4604 |
|
base[1]= list(3,VV[219],V426,(V424)); |
4605 |
|
base[2]= Cnil; |
4606 |
|
vs_top=(vs_base=base+1)+2; |
4607 |
|
return;} |
4608 |
|
} |
4609 |
|
} |
4610 |
|
/* function definition for LOOP-FOR-ON */ |
4611 |
|
|
4612 |
|
static void L89() |
4613 |
|
{register object *base=vs_base; |
4614 |
|
register object *sup=base+VM77; VC77 |
4615 |
|
vs_reserve(VM77); |
4616 |
|
{register object V427; |
4617 |
|
object V428; |
4618 |
|
object V429; |
4619 |
|
check_arg(3); |
4620 |
|
V427=(base[0]); |
4621 |
|
V428=(base[1]); |
4622 |
|
V429=(base[2]); |
4623 |
|
vs_top=sup; |
4624 |
|
goto TTL; |
4625 |
|
TTL:; |
4626 |
|
{object V430; |
4627 |
|
object V431; |
4628 |
|
object V432; |
4629 |
|
base[3]= (V428); |
4630 |
|
vs_top=(vs_base=base+3)+1; |
4631 |
|
(void) (*Lnk379)(); |
4632 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1608;} |
4633 |
|
V430= vs_base[0]; |
4634 |
|
vs_base++; |
4635 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1609;} |
4636 |
|
V431= vs_base[0]; |
4637 |
|
vs_base++; |
4638 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1610;} |
4639 |
|
V432= vs_base[0]; |
4640 |
|
vs_top=sup; |
4641 |
|
goto T1611; |
4642 |
|
goto T1608; |
4643 |
|
T1608:; |
4644 |
|
V430= Cnil; |
4645 |
|
goto T1609; |
4646 |
|
T1609:; |
4647 |
|
V431= Cnil; |
4648 |
|
goto T1610; |
4649 |
|
T1610:; |
4650 |
|
V432= Cnil; |
4651 |
|
goto T1611; |
4652 |
|
T1611:; |
4653 |
|
{register object V433; |
4654 |
|
V433= (V427); |
4655 |
|
if(((V427))==Cnil){ |
4656 |
|
goto T1614;} |
4657 |
|
if(!(type_of((V427))==t_symbol)){ |
4658 |
|
goto T1614;} |
4659 |
|
base[3]= (V427); |
4660 |
|
base[4]= (V430); |
4661 |
|
base[5]= (V429); |
4662 |
|
vs_top=(vs_base=base+3)+3; |
4663 |
|
(void) (*Lnk380)(); |
4664 |
|
vs_top=sup; |
4665 |
|
goto T1612; |
4666 |
|
goto T1614; |
4667 |
|
T1614:; |
4668 |
|
vs_base=vs_top; |
4669 |
|
(void) (*Lnk327)(); |
4670 |
|
vs_top=sup; |
4671 |
|
V433= vs_base[0]; |
4672 |
|
base[3]= (V433); |
4673 |
|
base[4]= (V430); |
4674 |
|
base[5]= VV[5]; |
4675 |
|
vs_top=(vs_base=base+3)+3; |
4676 |
|
(void) (*Lnk359)(); |
4677 |
|
vs_top=sup; |
4678 |
|
base[3]= (V427); |
4679 |
|
base[4]= Cnil; |
4680 |
|
base[5]= (V429); |
4681 |
|
vs_top=(vs_base=base+3)+3; |
4682 |
|
(void) (*Lnk380)(); |
4683 |
|
vs_top=sup; |
4684 |
|
goto T1612; |
4685 |
|
T1612:; |
4686 |
|
{object V434; |
4687 |
|
object V435; |
4688 |
|
base[3]= (V433); |
4689 |
|
vs_top=(vs_base=base+3)+1; |
4690 |
|
(void) (*Lnk381)(); |
4691 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1631;} |
4692 |
|
V434= vs_base[0]; |
4693 |
|
vs_base++; |
4694 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1632;} |
4695 |
|
V435= vs_base[0]; |
4696 |
|
vs_top=sup; |
4697 |
|
goto T1633; |
4698 |
|
goto T1631; |
4699 |
|
T1631:; |
4700 |
|
V434= Cnil; |
4701 |
|
goto T1632; |
4702 |
|
T1632:; |
4703 |
|
V435= Cnil; |
4704 |
|
goto T1633; |
4705 |
|
T1633:; |
4706 |
|
{register object V436; |
4707 |
|
object V437; |
4708 |
|
base[4]= (((V427))==((V433))?Ct:Cnil); |
4709 |
|
base[5]= (V433); |
4710 |
|
base[6]= list(2,VV[221],(V433)); |
4711 |
|
vs_top=(vs_base=base+4)+3; |
4712 |
|
(void) (*Lnk331)(); |
4713 |
|
vs_top=sup; |
4714 |
|
V436= vs_base[0]; |
4715 |
|
V437= (V436); |
4716 |
|
if(((V431))==Cnil){ |
4717 |
|
goto T1639;} |
4718 |
|
if(!(type_of((V432))==t_cons||((V432))==Cnil)){ |
4719 |
|
goto T1639;} |
4720 |
|
V436= (((V432))==Cnil?Ct:Cnil); |
4721 |
|
goto T1639; |
4722 |
|
T1639:; |
4723 |
|
if(!(((V427))==((V433)))){ |
4724 |
|
goto T1646;} |
4725 |
|
base[4]= Ct; |
4726 |
|
base[5]= (V433); |
4727 |
|
base[6]= (V434); |
4728 |
|
vs_top=(vs_base=base+4)+3; |
4729 |
|
(void) (*Lnk331)(); |
4730 |
|
vs_top=sup; |
4731 |
|
V438= vs_base[0]; |
4732 |
|
base[4]= list(8,Cnil,list(2,(V433),V438),(V437),Cnil,Cnil,Cnil,(V436),Cnil); |
4733 |
|
vs_top=(vs_base=base+4)+1; |
4734 |
|
return; |
4735 |
|
goto T1646; |
4736 |
|
T1646:; |
4737 |
|
{object V439; |
4738 |
|
object V440; |
4739 |
|
V439= list(2,(V427),(V433)); |
4740 |
|
V440= list(2,(V433),(V434)); |
4741 |
|
if(((((V436))==((V437))?Ct:Cnil))==Cnil){ |
4742 |
|
goto T1655;} |
4743 |
|
V441= Cnil; |
4744 |
|
goto T1654; |
4745 |
|
goto T1655; |
4746 |
|
T1655:; |
4747 |
|
V441= list(4,(V436),(V439),Cnil,(V440)); |
4748 |
|
goto T1654; |
4749 |
|
T1654:; |
4750 |
|
base[4]= listA(5,(V437),(V439),Cnil,(V440),V441); |
4751 |
|
vs_top=(vs_base=base+4)+1; |
4752 |
|
return;}}}}} |
4753 |
|
} |
4754 |
|
} |
4755 |
|
/* function definition for LOOP-FOR-IN */ |
4756 |
|
|
4757 |
|
static void L90() |
4758 |
|
{register object *base=vs_base; |
4759 |
|
register object *sup=base+VM78; VC78 |
4760 |
|
vs_reserve(VM78); |
4761 |
|
{object V442; |
4762 |
|
object V443; |
4763 |
|
object V444; |
4764 |
|
check_arg(3); |
4765 |
|
V442=(base[0]); |
4766 |
|
V443=(base[1]); |
4767 |
|
V444=(base[2]); |
4768 |
|
vs_top=sup; |
4769 |
|
goto TTL; |
4770 |
|
TTL:; |
4771 |
|
{object V445; |
4772 |
|
object V446; |
4773 |
|
object V447; |
4774 |
|
base[3]= (V443); |
4775 |
|
vs_top=(vs_base=base+3)+1; |
4776 |
|
(void) (*Lnk379)(); |
4777 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1659;} |
4778 |
|
V445= vs_base[0]; |
4779 |
|
vs_base++; |
4780 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1660;} |
4781 |
|
V446= vs_base[0]; |
4782 |
|
vs_base++; |
4783 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1661;} |
4784 |
|
V447= vs_base[0]; |
4785 |
|
vs_top=sup; |
4786 |
|
goto T1662; |
4787 |
|
goto T1659; |
4788 |
|
T1659:; |
4789 |
|
V445= Cnil; |
4790 |
|
goto T1660; |
4791 |
|
T1660:; |
4792 |
|
V446= Cnil; |
4793 |
|
goto T1661; |
4794 |
|
T1661:; |
4795 |
|
V447= Cnil; |
4796 |
|
goto T1662; |
4797 |
|
T1662:; |
4798 |
|
{register object V448; |
4799 |
|
base[3]= VV[222]; |
4800 |
|
vs_top=(vs_base=base+3)+1; |
4801 |
|
(void) (*Lnk327)(); |
4802 |
|
vs_top=sup; |
4803 |
|
V448= vs_base[0]; |
4804 |
|
base[3]= (V442); |
4805 |
|
base[4]= Cnil; |
4806 |
|
base[5]= (V444); |
4807 |
|
vs_top=(vs_base=base+3)+3; |
4808 |
|
(void) (*Lnk380)(); |
4809 |
|
vs_top=sup; |
4810 |
|
base[3]= (V448); |
4811 |
|
base[4]= (V445); |
4812 |
|
base[5]= VV[5]; |
4813 |
|
vs_top=(vs_base=base+3)+3; |
4814 |
|
(void) (*Lnk359)(); |
4815 |
|
vs_top=sup; |
4816 |
|
{object V449; |
4817 |
|
object V450; |
4818 |
|
base[3]= (V448); |
4819 |
|
vs_top=(vs_base=base+3)+1; |
4820 |
|
(void) (*Lnk381)(); |
4821 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1675;} |
4822 |
|
V449= vs_base[0]; |
4823 |
|
vs_base++; |
4824 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1676;} |
4825 |
|
V450= vs_base[0]; |
4826 |
|
vs_top=sup; |
4827 |
|
goto T1677; |
4828 |
|
goto T1675; |
4829 |
|
T1675:; |
4830 |
|
V449= Cnil; |
4831 |
|
goto T1676; |
4832 |
|
T1676:; |
4833 |
|
V450= Cnil; |
4834 |
|
goto T1677; |
4835 |
|
T1677:; |
4836 |
|
{register object V451; |
4837 |
|
object V452; |
4838 |
|
object V453; |
4839 |
|
object V454; |
4840 |
|
V451= list(2,VV[223],(V448)); |
4841 |
|
V452= (V451); |
4842 |
|
V453= list(2,(V442),list(2,VV[65],(V448))); |
4843 |
|
V454= list(2,(V448),(V449)); |
4844 |
|
if(((V446))==Cnil){ |
4845 |
|
goto T1682;} |
4846 |
|
if(!(type_of((V447))==t_cons||((V447))==Cnil)){ |
4847 |
|
goto T1682;} |
4848 |
|
V451= (((V447))==Cnil?Ct:Cnil); |
4849 |
|
goto T1682; |
4850 |
|
T1682:; |
4851 |
|
if(((((V451))==((V452))?Ct:Cnil))==Cnil){ |
4852 |
|
goto T1689;} |
4853 |
|
V455= Cnil; |
4854 |
|
goto T1688; |
4855 |
|
goto T1689; |
4856 |
|
T1689:; |
4857 |
|
V455= list(4,(V451),(V453),Cnil,(V454)); |
4858 |
|
goto T1688; |
4859 |
|
T1688:; |
4860 |
|
base[6]= listA(5,(V452),(V453),Cnil,(V454),V455); |
4861 |
|
vs_top=(vs_base=base+6)+1; |
4862 |
|
return;}}}} |
4863 |
|
} |
4864 |
|
} |
4865 |
|
/* function definition for MAKE-LOOP-PATH */ |
4866 |
|
|
4867 |
|
static void L91() |
4868 |
|
{register object *base=vs_base; |
4869 |
|
register object *sup=base+VM79; VC79 |
4870 |
|
vs_reserve(VM79); |
4871 |
|
{object V456; |
4872 |
|
object V457; |
4873 |
|
object V458; |
4874 |
|
object V459; |
4875 |
|
object V460; |
4876 |
|
parse_key(vs_base,FALSE,FALSE,5,VV[226],VV[229],VV[230],VV[227],VV[228]); |
4877 |
|
vs_top=sup; |
4878 |
|
V456=(base[0]); |
4879 |
|
V457=(base[1]); |
4880 |
|
V458=(base[2]); |
4881 |
|
V459=(base[3]); |
4882 |
|
V460=(base[4]); |
4883 |
|
base[10]= VV[224]; |
4884 |
|
base[11]= (V456); |
4885 |
|
base[12]= (V457); |
4886 |
|
base[13]= (V458); |
4887 |
|
base[14]= (V459); |
4888 |
|
base[15]= (V460); |
4889 |
|
vs_top=(vs_base=base+10)+6; |
4890 |
|
siLmake_structure(); |
4891 |
|
return; |
4892 |
|
} |
4893 |
|
} |
4894 |
|
/* function definition for ADD-LOOP-PATH */ |
4895 |
|
|
4896 |
|
static void L92() |
4897 |
|
{register object *base=vs_base; |
4898 |
|
register object *sup=base+VM80; VC80 |
4899 |
|
vs_reserve(VM80); |
4900 |
|
bds_check; |
4901 |
|
{object V461; |
4902 |
|
object V462; |
4903 |
|
register object V463; |
4904 |
|
object V464; |
4905 |
|
object V465; |
4906 |
|
object V466; |
4907 |
|
if(vs_top-vs_base<3) too_few_arguments(); |
4908 |
|
parse_key(vs_base+3,FALSE,FALSE,3,VV[229],VV[230],VV[228]); |
4909 |
|
V461=(base[0]); |
4910 |
|
V462=(base[1]); |
4911 |
|
V463=(base[2]); |
4912 |
|
vs_top=sup; |
4913 |
|
V464=(base[3]); |
4914 |
|
V465=(base[4]); |
4915 |
|
V466=(base[5]); |
4916 |
|
if(type_of((V461))==t_cons||((V461))==Cnil){ |
4917 |
|
goto T1697;} |
4918 |
|
V461= make_cons((V461),Cnil); |
4919 |
|
goto T1697; |
4920 |
|
T1697:; |
4921 |
|
bds_bind(VV[44],small_fixnum(4)); |
4922 |
|
bds_bind(VV[45],small_fixnum(4)); |
4923 |
|
goto T1703; |
4924 |
|
T1703:; |
4925 |
|
base[11]= (V463); |
4926 |
|
base[12]= VV[39]; |
4927 |
|
vs_top=(vs_base=base+11)+2; |
4928 |
|
(void) (*Lnk382)(); |
4929 |
|
vs_top=sup; |
4930 |
|
if((vs_base[0])==Cnil){ |
4931 |
|
goto T1704;} |
4932 |
|
bds_unwind1; |
4933 |
|
bds_unwind1; |
4934 |
|
goto T1701; |
4935 |
|
goto T1704; |
4936 |
|
T1704:; |
4937 |
|
base[11]= VV[47]; |
4938 |
|
base[12]= VV[48]; |
4939 |
|
base[13]= VV[225]; |
4940 |
|
base[14]= (V463); |
4941 |
|
base[15]= VV[39]; |
4942 |
|
vs_top=(vs_base=base+11)+5; |
4943 |
|
Lcerror(); |
4944 |
|
vs_top=sup; |
4945 |
|
base[11]= symbol_value(VV[50]); |
4946 |
|
base[12]= VV[51]; |
4947 |
|
base[13]= VV[225]; |
4948 |
|
vs_top=(vs_base=base+11)+3; |
4949 |
|
Lformat(); |
4950 |
|
vs_top=sup; |
4951 |
|
base[11]= symbol_value(VV[50]); |
4952 |
|
vs_top=(vs_base=base+11)+1; |
4953 |
|
Lfinish_output(); |
4954 |
|
vs_top=sup; |
4955 |
|
vs_base=vs_top; |
4956 |
|
Lread(); |
4957 |
|
vs_top=sup; |
4958 |
|
V463= vs_base[0]; |
4959 |
|
base[11]= symbol_value(VV[50]); |
4960 |
|
base[12]= VV[52]; |
4961 |
|
vs_top=(vs_base=base+11)+2; |
4962 |
|
Lformat(); |
4963 |
|
vs_top=sup; |
4964 |
|
goto T1703; |
4965 |
|
goto T1701; |
4966 |
|
T1701:; |
4967 |
|
{object V467; |
4968 |
|
object V468; |
4969 |
|
V467= structure_ref((V463),VV[39],3); |
4970 |
|
base[9]= VV[226]; |
4971 |
|
{object V469; |
4972 |
|
object V470= (V461); |
4973 |
|
if(endp(V470)){ |
4974 |
|
base[10]= Cnil; |
4975 |
|
goto T1732;} |
4976 |
|
base[11]=V469=MMcons(Cnil,Cnil); |
4977 |
|
goto T1733; |
4978 |
|
T1733:; |
4979 |
|
(V469->c.c_car)= symbol_name((V470->c.c_car)); |
4980 |
|
V470=MMcdr(V470); |
4981 |
|
if(endp(V470)){ |
4982 |
|
base[10]= base[11]; |
4983 |
|
goto T1732;} |
4984 |
|
V469=MMcdr(V469)=MMcons(Cnil,Cnil); |
4985 |
|
goto T1733;} |
4986 |
|
goto T1732; |
4987 |
|
T1732:; |
4988 |
|
base[11]= VV[227]; |
4989 |
|
base[12]= (V462); |
4990 |
|
base[13]= VV[228]; |
4991 |
|
base[14]= (V466); |
4992 |
|
base[15]= VV[229]; |
4993 |
|
{object V471; |
4994 |
|
object V472= (V464); |
4995 |
|
if(endp(V472)){ |
4996 |
|
base[16]= Cnil; |
4997 |
|
goto T1740;} |
4998 |
|
base[17]=V471=MMcons(Cnil,Cnil); |
4999 |
|
goto T1741; |
5000 |
|
T1741:; |
5001 |
|
if(!(type_of((V472->c.c_car))==t_cons||((V472->c.c_car))==Cnil)){ |
5002 |
|
goto T1744;} |
5003 |
|
(V471->c.c_car)= (V472->c.c_car); |
5004 |
|
goto T1742; |
5005 |
|
goto T1744; |
5006 |
|
T1744:; |
5007 |
|
(V471->c.c_car)= make_cons((V472->c.c_car),Cnil); |
5008 |
|
goto T1742; |
5009 |
|
T1742:; |
5010 |
|
V472=MMcdr(V472); |
5011 |
|
if(endp(V472)){ |
5012 |
|
base[16]= base[17]; |
5013 |
|
goto T1740;} |
5014 |
|
V471=MMcdr(V471)=MMcons(Cnil,Cnil); |
5015 |
|
goto T1741;} |
5016 |
|
goto T1740; |
5017 |
|
T1740:; |
5018 |
|
base[17]= VV[230]; |
5019 |
|
base[18]= (V465); |
5020 |
|
vs_top=(vs_base=base+9)+10; |
5021 |
|
(void) (*Lnk383)(); |
5022 |
|
vs_top=sup; |
5023 |
|
V468= vs_base[0]; |
5024 |
|
{register object V474; |
5025 |
|
register object V475; |
5026 |
|
V474= (V461); |
5027 |
|
V475= car((V474)); |
5028 |
|
goto T1752; |
5029 |
|
T1752:; |
5030 |
|
if(!(endp_prop((V474)))){ |
5031 |
|
goto T1753;} |
5032 |
|
goto T1748; |
5033 |
|
goto T1753; |
5034 |
|
T1753:; |
5035 |
|
{register object V476; |
5036 |
|
register object V477; |
5037 |
|
register object V478; |
5038 |
|
V476= symbol_name((V475)); |
5039 |
|
V477= (V467); |
5040 |
|
V478= (V468); |
5041 |
|
base[11]= (V476); |
5042 |
|
base[12]= (V477); |
5043 |
|
base[13]= (V478); |
5044 |
|
vs_top=(vs_base=base+11)+3; |
5045 |
|
siLhash_set(); |
5046 |
|
vs_top=sup;} |
5047 |
|
V474= cdr((V474)); |
5048 |
|
V475= car((V474)); |
5049 |
|
goto T1752;} |
5050 |
|
goto T1748; |
5051 |
|
T1748:; |
5052 |
|
base[9]= (V468); |
5053 |
|
vs_top=(vs_base=base+9)+1; |
5054 |
|
return;} |
5055 |
|
} |
5056 |
|
} |
5057 |
|
/* function definition for LOOP-FOR-BEING */ |
5058 |
|
|
5059 |
|
static void L93() |
5060 |
|
{register object *base=vs_base; |
5061 |
|
register object *sup=base+VM81; VC81 |
5062 |
|
vs_reserve(VM81); |
5063 |
|
{object V479; |
5064 |
|
object V480; |
5065 |
|
object V481; |
5066 |
|
check_arg(3); |
5067 |
|
V479=(base[0]); |
5068 |
|
V480=(base[1]); |
5069 |
|
V481=(base[2]); |
5070 |
|
vs_top=sup; |
5071 |
|
goto TTL; |
5072 |
|
TTL:; |
5073 |
|
{register object V482; |
5074 |
|
object V483; |
5075 |
|
object V484; |
5076 |
|
object V485; |
5077 |
|
object V486; |
5078 |
|
V482= Cnil; |
5079 |
|
V483= Cnil; |
5080 |
|
V484= Cnil; |
5081 |
|
V485= Cnil; |
5082 |
|
V486= Cnil; |
5083 |
|
base[3]= (V480); |
5084 |
|
base[4]= VV[231]; |
5085 |
|
vs_top=(vs_base=base+3)+2; |
5086 |
|
(void) (*Lnk353)(); |
5087 |
|
vs_top=sup; |
5088 |
|
if((vs_base[0])==Cnil){ |
5089 |
|
goto T1771;} |
5090 |
|
vs_base=vs_top; |
5091 |
|
(void) (*Lnk350)(); |
5092 |
|
vs_top=sup; |
5093 |
|
V482= vs_base[0]; |
5094 |
|
goto T1769; |
5095 |
|
goto T1771; |
5096 |
|
T1771:; |
5097 |
|
base[3]= car(symbol_value(VV[89])); |
5098 |
|
base[4]= VV[155]; |
5099 |
|
vs_top=(vs_base=base+3)+2; |
5100 |
|
(void) (*Lnk357)(); |
5101 |
|
vs_top=sup; |
5102 |
|
if((vs_base[0])==Cnil){ |
5103 |
|
goto T1777;} |
5104 |
|
vs_base=vs_top; |
5105 |
|
(void) (*Lnk350)(); |
5106 |
|
vs_top=sup; |
5107 |
|
V484= Ct; |
5108 |
|
base[3]= car(symbol_value(VV[89])); |
5109 |
|
base[4]= VV[232]; |
5110 |
|
vs_top=(vs_base=base+3)+2; |
5111 |
|
(void) (*Lnk353)(); |
5112 |
|
vs_top=sup; |
5113 |
|
if((vs_base[0])!=Cnil){ |
5114 |
|
goto T1784;} |
5115 |
|
base[3]= VV[233]; |
5116 |
|
base[4]= car(symbol_value(VV[89])); |
5117 |
|
vs_top=(vs_base=base+3)+2; |
5118 |
|
(void) (*Lnk347)(); |
5119 |
|
vs_top=sup; |
5120 |
|
goto T1784; |
5121 |
|
T1784:; |
5122 |
|
vs_base=vs_top; |
5123 |
|
(void) (*Lnk350)(); |
5124 |
|
vs_top=sup; |
5125 |
|
vs_base=vs_top; |
5126 |
|
(void) (*Lnk350)(); |
5127 |
|
vs_top=sup; |
5128 |
|
V482= vs_base[0]; |
5129 |
|
V487= list(2,VV[234],(V480)); |
5130 |
|
V486= make_cons(/* INLINE-ARGS */V487,Cnil); |
5131 |
|
goto T1769; |
5132 |
|
goto T1777; |
5133 |
|
T1777:; |
5134 |
|
base[3]= VV[235]; |
5135 |
|
vs_top=(vs_base=base+3)+1; |
5136 |
|
(void) (*Lnk347)(); |
5137 |
|
vs_top=sup; |
5138 |
|
goto T1769; |
5139 |
|
T1769:; |
5140 |
|
if(type_of((V482))==t_symbol){ |
5141 |
|
goto T1798;} |
5142 |
|
base[3]= VV[236]; |
5143 |
|
base[4]= (V482); |
5144 |
|
vs_top=(vs_base=base+3)+2; |
5145 |
|
(void) (*Lnk347)(); |
5146 |
|
vs_top=sup; |
5147 |
|
goto T1796; |
5148 |
|
goto T1798; |
5149 |
|
T1798:; |
5150 |
|
base[3]= (V482); |
5151 |
|
base[4]= structure_ref(symbol_value(VV[97]),VV[39],3); |
5152 |
|
vs_top=(vs_base=base+3)+2; |
5153 |
|
(void) (*Lnk351)(); |
5154 |
|
vs_top=sup; |
5155 |
|
V483= vs_base[0]; |
5156 |
|
if(((V483))!=Cnil){ |
5157 |
|
goto T1803;} |
5158 |
|
base[3]= VV[237]; |
5159 |
|
base[4]= (V482); |
5160 |
|
vs_top=(vs_base=base+3)+2; |
5161 |
|
(void) (*Lnk347)(); |
5162 |
|
vs_top=sup; |
5163 |
|
goto T1796; |
5164 |
|
goto T1803; |
5165 |
|
T1803:; |
5166 |
|
if(((V484))==Cnil){ |
5167 |
|
goto T1796;} |
5168 |
|
if((structure_ref((V483),VV[224],2))!=Cnil){ |
5169 |
|
goto T1796;} |
5170 |
|
base[3]= VV[238]; |
5171 |
|
base[4]= (V482); |
5172 |
|
vs_top=(vs_base=base+3)+2; |
5173 |
|
(void) (*Lnk347)(); |
5174 |
|
vs_top=sup; |
5175 |
|
goto T1796; |
5176 |
|
T1796:; |
5177 |
|
{object V488; |
5178 |
|
object V489; |
5179 |
|
object V490; |
5180 |
|
V488= structure_ref((V483),VV[224],3); |
5181 |
|
base[3]= structure_ref((V483),VV[224],1); |
5182 |
|
base[4]= Ct; |
5183 |
|
vs_top=(vs_base=base+3)+2; |
5184 |
|
(void) (*Lnk384)(); |
5185 |
|
vs_top=sup; |
5186 |
|
V491= vs_base[0]; |
5187 |
|
V489= nconc((V486),V491); |
5188 |
|
V490= structure_ref((V483),VV[224],4); |
5189 |
|
if(!(type_of((V488))==t_symbol)){ |
5190 |
|
goto T1823;} |
5191 |
|
base[3]= (V488); |
5192 |
|
vs_top=(vs_base=base+3)+1; |
5193 |
|
Lsymbol_function(); |
5194 |
|
vs_top=sup; |
5195 |
|
V488= vs_base[0]; |
5196 |
|
goto T1823; |
5197 |
|
T1823:; |
5198 |
|
if(((V484))==Cnil){ |
5199 |
|
goto T1830;} |
5200 |
|
base[3]= (V488); |
5201 |
|
base[4]= (V479); |
5202 |
|
base[5]= (V481); |
5203 |
|
base[6]= (V489); |
5204 |
|
base[7]= VV[239]; |
5205 |
|
base[8]= Ct; |
5206 |
|
{object V492; |
5207 |
|
V492= (V490); |
5208 |
|
vs_top=base+9; |
5209 |
|
while(!endp(V492)) |
5210 |
|
{vs_push(car(V492));V492=cdr(V492);} |
5211 |
|
vs_base=base+4;} |
5212 |
|
super_funcall_no_event(base[3]); |
5213 |
|
vs_top=sup; |
5214 |
|
V485= vs_base[0]; |
5215 |
|
goto T1828; |
5216 |
|
goto T1830; |
5217 |
|
T1830:; |
5218 |
|
base[3]= (V488); |
5219 |
|
base[4]= (V479); |
5220 |
|
base[5]= (V481); |
5221 |
|
base[6]= (V489); |
5222 |
|
{object V493; |
5223 |
|
V493= (V490); |
5224 |
|
vs_top=base+7; |
5225 |
|
while(!endp(V493)) |
5226 |
|
{vs_push(car(V493));V493=cdr(V493);} |
5227 |
|
vs_base=base+4;} |
5228 |
|
super_funcall_no_event(base[3]); |
5229 |
|
vs_top=sup; |
5230 |
|
V485= vs_base[0]; |
5231 |
|
goto T1828; |
5232 |
|
T1828:;} |
5233 |
|
if((symbol_value(VV[102]))==Cnil){ |
5234 |
|
goto T1844;} |
5235 |
|
base[3]= VV[240]; |
5236 |
|
base[4]= symbol_value(VV[102]); |
5237 |
|
vs_top=(vs_base=base+3)+2; |
5238 |
|
(void) (*Lnk347)(); |
5239 |
|
vs_top=sup; |
5240 |
|
goto T1844; |
5241 |
|
T1844:; |
5242 |
|
V495 = make_fixnum((long)length((V485))); |
5243 |
|
{register object x= V495,V494= VV[241]; |
5244 |
|
while(!endp(V494)) |
5245 |
|
if(eql(x,V494->c.c_car)){ |
5246 |
|
goto T1849; |
5247 |
|
}else V494=V494->c.c_cdr;} |
5248 |
|
base[3]= VV[242]; |
5249 |
|
base[4]= (V482); |
5250 |
|
vs_top=(vs_base=base+3)+2; |
5251 |
|
(void) (*Lnk347)(); |
5252 |
|
vs_top=sup; |
5253 |
|
goto T1849; |
5254 |
|
T1849:; |
5255 |
|
{register object V496; |
5256 |
|
register object V497; |
5257 |
|
V496= car((V485)); |
5258 |
|
V497= Cnil; |
5259 |
|
goto T1857; |
5260 |
|
T1857:; |
5261 |
|
if(((V496))!=Cnil){ |
5262 |
|
goto T1858;} |
5263 |
|
goto T1854; |
5264 |
|
goto T1858; |
5265 |
|
T1858:; |
5266 |
|
V497= car((V496)); |
5267 |
|
if(!(type_of((V497))!=t_cons)){ |
5268 |
|
goto T1864;} |
5269 |
|
base[3]= (V497); |
5270 |
|
base[4]= Cnil; |
5271 |
|
base[5]= Cnil; |
5272 |
|
vs_top=(vs_base=base+3)+3; |
5273 |
|
(void) (*Lnk380)(); |
5274 |
|
vs_top=sup; |
5275 |
|
goto T1862; |
5276 |
|
goto T1864; |
5277 |
|
T1864:; |
5278 |
|
base[3]= car((V497)); |
5279 |
|
base[4]= cadr((V497)); |
5280 |
|
base[5]= caddr((V497)); |
5281 |
|
vs_top=(vs_base=base+3)+3; |
5282 |
|
(void) (*Lnk380)(); |
5283 |
|
vs_top=sup; |
5284 |
|
goto T1862; |
5285 |
|
T1862:; |
5286 |
|
V496= cdr((V496)); |
5287 |
|
goto T1857;} |
5288 |
|
goto T1854; |
5289 |
|
T1854:; |
5290 |
|
V498= reverse(cadr((V485))); |
5291 |
|
setq(VV[106],nconc(/* INLINE-ARGS */V498,symbol_value(VV[106]))); |
5292 |
|
base[3]= cddr((V485)); |
5293 |
|
vs_top=(vs_base=base+3)+1; |
5294 |
|
return;} |
5295 |
|
} |
5296 |
|
} |
5297 |
|
/* function definition for NAMED-VARIABLE */ |
5298 |
|
|
5299 |
|
static void L94() |
5300 |
|
{register object *base=vs_base; |
5301 |
|
register object *sup=base+VM82; VC82 |
5302 |
|
vs_reserve(VM82); |
5303 |
|
{object V499; |
5304 |
|
check_arg(1); |
5305 |
|
V499=(base[0]); |
5306 |
|
vs_top=sup; |
5307 |
|
goto TTL; |
5308 |
|
TTL:; |
5309 |
|
{object V500; |
5310 |
|
base[1]= (V499); |
5311 |
|
base[2]= symbol_value(VV[102]); |
5312 |
|
vs_top=(vs_base=base+1)+2; |
5313 |
|
(void) (*Lnk385)(); |
5314 |
|
vs_top=sup; |
5315 |
|
V500= vs_base[0]; |
5316 |
|
if(((V500))!=Cnil){ |
5317 |
|
goto T1882;} |
5318 |
|
vs_base=vs_top; |
5319 |
|
(void) (*Lnk327)(); |
5320 |
|
vs_top=sup; |
5321 |
|
base[1]= vs_base[0]; |
5322 |
|
base[2]= Cnil; |
5323 |
|
vs_top=(vs_base=base+1)+2; |
5324 |
|
return; |
5325 |
|
goto T1882; |
5326 |
|
T1882:; |
5327 |
|
setq(VV[102],(VFUN_NARGS=2,(*(LnkLI386))((V500),symbol_value(VV[102])))); |
5328 |
|
base[1]= cdr((V500)); |
5329 |
|
base[2]= Ct; |
5330 |
|
vs_top=(vs_base=base+1)+2; |
5331 |
|
return;} |
5332 |
|
} |
5333 |
|
} |
5334 |
|
/* function definition for LOOP-COLLECT-PREPOSITIONAL-PHRASES */ |
5335 |
|
|
5336 |
|
static void L95() |
5337 |
|
{register object *base=vs_base; |
5338 |
|
register object *sup=base+VM83; VC83 |
5339 |
|
vs_reserve(VM83); |
5340 |
|
{object V501; |
5341 |
|
object V502; |
5342 |
|
object V503; |
5343 |
|
if(vs_top-vs_base<1) too_few_arguments(); |
5344 |
|
if(vs_top-vs_base>3) too_many_arguments(); |
5345 |
|
V501=(base[0]); |
5346 |
|
vs_base=vs_base+1; |
5347 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1890;} |
5348 |
|
V502=(base[1]); |
5349 |
|
vs_base++; |
5350 |
|
if(vs_base>=vs_top){vs_top=sup;goto T1891;} |
5351 |
|
V503=(base[2]); |
5352 |
|
vs_top=sup; |
5353 |
|
goto T1892; |
5354 |
|
goto T1890; |
5355 |
|
T1890:; |
5356 |
|
V502= Cnil; |
5357 |
|
goto T1891; |
5358 |
|
T1891:; |
5359 |
|
V503= Cnil; |
5360 |
|
goto T1892; |
5361 |
|
T1892:; |
5362 |
|
base[3]=make_cclosure_new(LC96,Cnil,Cnil,Cdata); |
5363 |
|
base[3]=MMcons(base[3],Cnil); |
5364 |
|
{object V504; |
5365 |
|
object V505; |
5366 |
|
register object V506; |
5367 |
|
register object V507; |
5368 |
|
object V508; |
5369 |
|
object V509; |
5370 |
|
{object V510; |
5371 |
|
object V511= (V503); |
5372 |
|
if(endp(V511)){ |
5373 |
|
V508= Cnil; |
5374 |
|
goto T1895;} |
5375 |
|
base[4]=V510=MMcons(Cnil,Cnil); |
5376 |
|
goto T1896; |
5377 |
|
T1896:; |
5378 |
|
V513= car((V511->c.c_car)); |
5379 |
|
V514= (base[3]->c.c_car); |
5380 |
|
base[5]= (VFUN_NARGS=4,(*(LnkLI368))(/* INLINE-ARGS */V513,(V501),VV[20],V514)); |
5381 |
|
vs_top=(vs_base=base+5)+1; |
5382 |
|
Lcopy_list(); |
5383 |
|
vs_top=sup; |
5384 |
|
(V510->c.c_cdr)= vs_base[0]; |
5385 |
|
{object cdr_V510=MMcdr(V510);while(!endp(cdr_V510)) {cdr_V510=MMcdr(cdr_V510);V510=MMcdr(V510);}} |
5386 |
|
V511=MMcdr(V511); |
5387 |
|
if(endp(V511)){ |
5388 |
|
base[4]=base[4]->c.c_cdr; |
5389 |
|
V508= base[4]; |
5390 |
|
goto T1895;} |
5391 |
|
goto T1896;} |
5392 |
|
goto T1895; |
5393 |
|
T1895:; |
5394 |
|
{object V515; |
5395 |
|
object V516= (V503); |
5396 |
|
if(endp(V516)){ |
5397 |
|
V509= Cnil; |
5398 |
|
goto T1900;} |
5399 |
|
base[4]=V515=MMcons(Cnil,Cnil); |
5400 |
|
goto T1901; |
5401 |
|
T1901:; |
5402 |
|
(V515->c.c_car)= car((V516->c.c_car)); |
5403 |
|
V516=MMcdr(V516); |
5404 |
|
if(endp(V516)){ |
5405 |
|
V509= base[4]; |
5406 |
|
goto T1900;} |
5407 |
|
V515=MMcdr(V515)=MMcons(Cnil,Cnil); |
5408 |
|
goto T1901;} |
5409 |
|
goto T1900; |
5410 |
|
T1900:; |
5411 |
|
V504= Cnil; |
5412 |
|
V505= (V503); |
5413 |
|
V506= Cnil; |
5414 |
|
V507= Cnil; |
5415 |
|
goto T1904; |
5416 |
|
T1904:; |
5417 |
|
if((symbol_value(VV[89]))!=Cnil){ |
5418 |
|
goto T1905;} |
5419 |
|
base[4]= nreverse((V505)); |
5420 |
|
vs_top=(vs_base=base+4)+1; |
5421 |
|
return; |
5422 |
|
goto T1905; |
5423 |
|
T1905:; |
5424 |
|
V504= car(symbol_value(VV[89])); |
5425 |
|
{register object V517; |
5426 |
|
register object V518; |
5427 |
|
V517= (V501); |
5428 |
|
V518= car((V517)); |
5429 |
|
goto T1915; |
5430 |
|
T1915:; |
5431 |
|
if(!(endp_prop((V517)))){ |
5432 |
|
goto T1916;} |
5433 |
|
goto T1911; |
5434 |
|
goto T1916; |
5435 |
|
T1916:; |
5436 |
|
base[5]= (V504); |
5437 |
|
base[6]= (V518); |
5438 |
|
vs_top=(vs_base=base+5)+2; |
5439 |
|
L96(base); |
5440 |
|
vs_top=sup; |
5441 |
|
V507= vs_base[0]; |
5442 |
|
if(((V507))==Cnil){ |
5443 |
|
goto T1920;} |
5444 |
|
V506= (V518); |
5445 |
|
goto T1911; |
5446 |
|
goto T1920; |
5447 |
|
T1920:; |
5448 |
|
V517= cdr((V517)); |
5449 |
|
V518= car((V517)); |
5450 |
|
goto T1915;} |
5451 |
|
goto T1911; |
5452 |
|
T1911:; |
5453 |
|
if(((V506))==Cnil){ |
5454 |
|
goto T1934;} |
5455 |
|
{register object x= (V507),V519= (V508); |
5456 |
|
while(!endp(V519)) |
5457 |
|
if(eql(x,V519->c.c_car)){ |
5458 |
|
goto T1938; |
5459 |
|
}else V519=V519->c.c_cdr; |
5460 |
|
goto T1936;} |
5461 |
|
goto T1938; |
5462 |
|
T1938:; |
5463 |
|
{register object x= (V507),V520= (V509); |
5464 |
|
while(!endp(V520)) |
5465 |
|
if(eql(x,V520->c.c_car)){ |
5466 |
|
goto T1942; |
5467 |
|
}else V520=V520->c.c_cdr; |
5468 |
|
goto T1941;} |
5469 |
|
goto T1942; |
5470 |
|
T1942:; |
5471 |
|
base[4]= VV[243]; |
5472 |
|
goto T1939; |
5473 |
|
goto T1941; |
5474 |
|
T1941:; |
5475 |
|
base[4]= VV[244]; |
5476 |
|
goto T1939; |
5477 |
|
T1939:; |
5478 |
|
base[5]= (V504); |
5479 |
|
vs_top=(vs_base=base+4)+2; |
5480 |
|
(void) (*Lnk347)(); |
5481 |
|
vs_top=sup; |
5482 |
|
goto T1936; |
5483 |
|
T1936:; |
5484 |
|
if(!(type_of((V506))==t_cons||((V506))==Cnil)){ |
5485 |
|
goto T1947;} |
5486 |
|
V509= append((V506),(V509)); |
5487 |
|
goto T1945; |
5488 |
|
goto T1947; |
5489 |
|
T1947:; |
5490 |
|
V509= make_cons((V506),(V509)); |
5491 |
|
goto T1945; |
5492 |
|
T1945:; |
5493 |
|
vs_base=vs_top; |
5494 |
|
(void) (*Lnk350)(); |
5495 |
|
vs_top=sup; |
5496 |
|
{object V521; |
5497 |
|
vs_base=vs_top; |
5498 |
|
(void) (*Lnk361)(); |
5499 |
|
vs_top=sup; |
5500 |
|
V522= vs_base[0]; |
5501 |
|
V521= list(2,(V507),V522); |
5502 |
|
V505= make_cons((V521),(V505)); |
5503 |
|
goto T1932;} |
5504 |
|
goto T1934; |
5505 |
|
T1934:; |
5506 |
|
if(((V502))==Cnil){ |
5507 |
|
goto T1954;} |
5508 |
|
base[4]= (V504); |
5509 |
|
base[5]= VV[245]; |
5510 |
|
vs_top=(vs_base=base+4)+2; |
5511 |
|
(void) (*Lnk357)(); |
5512 |
|
vs_top=sup; |
5513 |
|
if((vs_base[0])==Cnil){ |
5514 |
|
goto T1954;} |
5515 |
|
vs_base=vs_top; |
5516 |
|
(void) (*Lnk350)(); |
5517 |
|
vs_top=sup; |
5518 |
|
{register object V523; |
5519 |
|
object V524; |
5520 |
|
vs_base=vs_top; |
5521 |
|
(void) (*Lnk350)(); |
5522 |
|
vs_top=sup; |
5523 |
|
V523= vs_base[0]; |
5524 |
|
V524= Cnil; |
5525 |
|
goto T1963; |
5526 |
|
T1963:; |
5527 |
|
if(type_of((V523))!=t_cons){ |
5528 |
|
goto T1967;} |
5529 |
|
if(type_of(cdr((V523)))!=t_cons){ |
5530 |
|
goto T1967;} |
5531 |
|
if((cddr((V523)))!=Cnil){ |
5532 |
|
goto T1967;} |
5533 |
|
if(!(type_of(car((V523)))==t_symbol)){ |
5534 |
|
goto T1967;} |
5535 |
|
if((cadr((V523)))==Cnil){ |
5536 |
|
goto T1966;} |
5537 |
|
if(type_of(cadr((V523)))==t_symbol){ |
5538 |
|
goto T1966;} |
5539 |
|
goto T1967; |
5540 |
|
T1967:; |
5541 |
|
base[4]= VV[246]; |
5542 |
|
base[5]= (V523); |
5543 |
|
vs_top=(vs_base=base+4)+2; |
5544 |
|
(void) (*Lnk347)(); |
5545 |
|
vs_top=sup; |
5546 |
|
goto T1966; |
5547 |
|
T1966:; |
5548 |
|
if((cadr((V523)))==Cnil){ |
5549 |
|
goto T1981;} |
5550 |
|
base[4]= car((V523)); |
5551 |
|
base[5]= symbol_value(VV[102]); |
5552 |
|
vs_top=(vs_base=base+4)+2; |
5553 |
|
(void) (*Lnk385)(); |
5554 |
|
vs_top=sup; |
5555 |
|
V524= vs_base[0]; |
5556 |
|
if(((V524))==Cnil){ |
5557 |
|
goto T1985;} |
5558 |
|
base[4]= VV[247]; |
5559 |
|
base[5]= car((V523)); |
5560 |
|
base[6]= cadr((V523)); |
5561 |
|
base[7]= cadr((V524)); |
5562 |
|
vs_top=(vs_base=base+4)+4; |
5563 |
|
(void) (*Lnk347)(); |
5564 |
|
vs_top=sup; |
5565 |
|
goto T1981; |
5566 |
|
goto T1985; |
5567 |
|
T1985:; |
5568 |
|
{object V525; |
5569 |
|
V525= make_cons(car((V523)),cadr((V523))); |
5570 |
|
setq(VV[102],make_cons((V525),symbol_value(VV[102])));} |
5571 |
|
goto T1981; |
5572 |
|
T1981:; |
5573 |
|
if((symbol_value(VV[89]))==Cnil){ |
5574 |
|
goto T1997;} |
5575 |
|
if(!(type_of(car(symbol_value(VV[89])))==t_symbol)){ |
5576 |
|
goto T1996;} |
5577 |
|
goto T1997; |
5578 |
|
T1997:; |
5579 |
|
goto T1932; |
5580 |
|
goto T1996; |
5581 |
|
T1996:; |
5582 |
|
vs_base=vs_top; |
5583 |
|
(void) (*Lnk350)(); |
5584 |
|
vs_top=sup; |
5585 |
|
V523= vs_base[0]; |
5586 |
|
goto T1963;} |
5587 |
|
goto T1954; |
5588 |
|
T1954:; |
5589 |
|
base[4]= nreverse((V505)); |
5590 |
|
vs_top=(vs_base=base+4)+1; |
5591 |
|
return; |
5592 |
|
goto T1932; |
5593 |
|
T1932:; |
5594 |
|
V506= Cnil; |
5595 |
|
V507= Cnil; |
5596 |
|
goto T1904;} |
5597 |
|
} |
5598 |
|
} |
5599 |
|
/* function definition for LOOP-SEQUENCER */ |
5600 |
|
|
5601 |
|
static void L97() |
5602 |
|
{register object *base=vs_base; |
5603 |
|
register object *sup=base+VM84; VC84 |
5604 |
|
vs_reserve(VM84); |
5605 |
|
{object V526; |
5606 |
|
register object V527; |
5607 |
|
object V528; |
5608 |
|
object V529; |
5609 |
|
object V530; |
5610 |
|
object V531; |
5611 |
|
object V532; |
5612 |
|
object V533; |
5613 |
|
object V534; |
5614 |
|
object V535; |
5615 |
|
check_arg(10); |
5616 |
|
V526=(base[0]); |
5617 |
|
V527=(base[1]); |
5618 |
|
V528=(base[2]); |
5619 |
|
V529=(base[3]); |
5620 |
|
V530=(base[4]); |
5621 |
|
V531=(base[5]); |
5622 |
|
V532=(base[6]); |
5623 |
|
V533=(base[7]); |
5624 |
|
V534=(base[8]); |
5625 |
|
V535=(base[9]); |
5626 |
|
vs_top=sup; |
5627 |
|
goto TTL; |
5628 |
|
TTL:; |
5629 |
|
{object V536; |
5630 |
|
object V537; |
5631 |
|
object V538; |
5632 |
|
object V539; |
5633 |
|
object V540; |
5634 |
|
object V541; |
5635 |
|
object V542; |
5636 |
|
register object V543; |
5637 |
|
register object V544; |
5638 |
|
object V545; |
5639 |
|
object V546; |
5640 |
|
object V547; |
5641 |
|
object V548; |
5642 |
|
object V549; |
5643 |
|
object V550;{object V552; |
5644 |
|
base[10]= (V527); |
5645 |
|
vs_top=(vs_base=base+10)+1; |
5646 |
|
(void) (*Lnk329)(); |
5647 |
|
vs_top=sup; |
5648 |
|
V552= vs_base[0]; |
5649 |
|
if(V552==Cnil)goto T2010; |
5650 |
|
V551= V552; |
5651 |
|
goto T2009; |
5652 |
|
goto T2010; |
5653 |
|
T2010:;} |
5654 |
|
V551= small_fixnum(0); |
5655 |
|
goto T2009; |
5656 |
|
T2009:; |
5657 |
|
V540= one_plus(V551); |
5658 |
|
V536= Cnil; |
5659 |
|
V537= Cnil; |
5660 |
|
V538= Cnil; |
5661 |
|
V539= Cnil; |
5662 |
|
V541= Ct; |
5663 |
|
V542= Cnil; |
5664 |
|
V543= Cnil; |
5665 |
|
V544= Cnil; |
5666 |
|
V545= Cnil; |
5667 |
|
V546= Cnil; |
5668 |
|
V547= Cnil; |
5669 |
|
V548= Cnil; |
5670 |
|
V549= Cnil; |
5671 |
|
V550= Cnil; |
5672 |
|
if(((V529))==Cnil){ |
5673 |
|
goto T2013;} |
5674 |
|
base[10]= (V529); |
5675 |
|
base[11]= Cnil; |
5676 |
|
base[12]= (V530); |
5677 |
|
vs_top=(vs_base=base+10)+3; |
5678 |
|
(void) (*Lnk380)(); |
5679 |
|
vs_top=sup; |
5680 |
|
goto T2013; |
5681 |
|
T2013:; |
5682 |
|
{register object V553; |
5683 |
|
register object V554; |
5684 |
|
register object V555; |
5685 |
|
object V556; |
5686 |
|
V553= (V535); |
5687 |
|
V554= Cnil; |
5688 |
|
V555= Cnil; |
5689 |
|
V556= Cnil; |
5690 |
|
goto T2021; |
5691 |
|
T2021:; |
5692 |
|
if(((V553))!=Cnil){ |
5693 |
|
goto T2022;} |
5694 |
|
goto T2019; |
5695 |
|
goto T2022; |
5696 |
|
T2022:; |
5697 |
|
V554= caar((V553)); |
5698 |
|
V555= cadar((V553)); |
5699 |
|
{object V557= (V554); |
5700 |
|
if((V557!= VV[387]) |
5701 |
|
&& (V557!= VV[234]))goto T2031; |
5702 |
|
V537= Ct; |
5703 |
|
base[10]= (V531); |
5704 |
|
base[11]= (V555); |
5705 |
|
base[12]= (V532); |
5706 |
|
vs_top=(vs_base=base+10)+3; |
5707 |
|
(void) (*Lnk359)(); |
5708 |
|
vs_top=sup; |
5709 |
|
goto T2030; |
5710 |
|
goto T2031; |
5711 |
|
T2031:; |
5712 |
|
if((V557!= VV[388]) |
5713 |
|
&& (V557!= VV[248]) |
5714 |
|
&& (V557!= VV[250]))goto T2037; |
5715 |
|
V545= Ct; |
5716 |
|
if(!(((V554))==(VV[248]))){ |
5717 |
|
goto T2042;} |
5718 |
|
V543= VV[249]; |
5719 |
|
goto T2040; |
5720 |
|
goto T2042; |
5721 |
|
T2042:; |
5722 |
|
if(!(((V554))==(VV[250]))){ |
5723 |
|
goto T2040;} |
5724 |
|
V543= VV[251]; |
5725 |
|
goto T2040; |
5726 |
|
T2040:; |
5727 |
|
base[10]= (V555); |
5728 |
|
base[11]= (V527); |
5729 |
|
vs_top=(vs_base=base+10)+2; |
5730 |
|
(void) (*Lnk379)(); |
5731 |
|
if(vs_base<vs_top){ |
5732 |
|
V555= vs_base[0]; |
5733 |
|
vs_base++; |
5734 |
|
}else{ |
5735 |
|
V555= Cnil;} |
5736 |
|
if(vs_base<vs_top){ |
5737 |
|
V547= vs_base[0]; |
5738 |
|
vs_base++; |
5739 |
|
}else{ |
5740 |
|
V547= Cnil;} |
5741 |
|
if(vs_base<vs_top){ |
5742 |
|
V546= vs_base[0]; |
5743 |
|
}else{ |
5744 |
|
V546= Cnil;} |
5745 |
|
vs_top=sup; |
5746 |
|
base[10]= (V526); |
5747 |
|
base[11]= (V555); |
5748 |
|
base[12]= (V527); |
5749 |
|
vs_top=(vs_base=base+10)+3; |
5750 |
|
(void) (*Lnk380)(); |
5751 |
|
vs_top=sup; |
5752 |
|
goto T2030; |
5753 |
|
goto T2037; |
5754 |
|
T2037:; |
5755 |
|
if((V557!= VV[252]) |
5756 |
|
&& (V557!= VV[253]) |
5757 |
|
&& (V557!= VV[254]) |
5758 |
|
&& (V557!= VV[255]) |
5759 |
|
&& (V557!= VV[256]))goto T2055; |
5760 |
|
base[10]= (V554); |
5761 |
|
base[11]= VV[252]; |
5762 |
|
vs_top=(vs_base=base+10)+2; |
5763 |
|
(void) (*Lnk357)(); |
5764 |
|
vs_top=sup; |
5765 |
|
if((vs_base[0])==Cnil){ |
5766 |
|
goto T2058;} |
5767 |
|
V543= VV[251]; |
5768 |
|
V544= VV[251]; |
5769 |
|
goto T2056; |
5770 |
|
goto T2058; |
5771 |
|
T2058:; |
5772 |
|
base[10]= (V554); |
5773 |
|
base[11]= VV[253]; |
5774 |
|
vs_top=(vs_base=base+10)+2; |
5775 |
|
(void) (*Lnk357)(); |
5776 |
|
vs_top=sup; |
5777 |
|
if((vs_base[0])==Cnil){ |
5778 |
|
goto T2065;} |
5779 |
|
V544= Ct; |
5780 |
|
goto T2056; |
5781 |
|
goto T2065; |
5782 |
|
T2065:; |
5783 |
|
base[10]= (V554); |
5784 |
|
base[11]= VV[254]; |
5785 |
|
vs_top=(vs_base=base+10)+2; |
5786 |
|
(void) (*Lnk357)(); |
5787 |
|
vs_top=sup; |
5788 |
|
if((vs_base[0])==Cnil){ |
5789 |
|
goto T2071;} |
5790 |
|
V543= VV[249]; |
5791 |
|
V544= VV[249]; |
5792 |
|
goto T2056; |
5793 |
|
goto T2071; |
5794 |
|
T2071:; |
5795 |
|
base[10]= (V554); |
5796 |
|
base[11]= VV[255]; |
5797 |
|
vs_top=(vs_base=base+10)+2; |
5798 |
|
(void) (*Lnk357)(); |
5799 |
|
vs_top=sup; |
5800 |
|
if((vs_base[0])==Cnil){ |
5801 |
|
goto T2078;} |
5802 |
|
V543= VV[249]; |
5803 |
|
goto T2056; |
5804 |
|
goto T2078; |
5805 |
|
T2078:; |
5806 |
|
base[10]= (V554); |
5807 |
|
base[11]= VV[256]; |
5808 |
|
vs_top=(vs_base=base+10)+2; |
5809 |
|
(void) (*Lnk357)(); |
5810 |
|
vs_top=sup; |
5811 |
|
if((vs_base[0])==Cnil){ |
5812 |
|
goto T2056;} |
5813 |
|
V543= VV[251]; |
5814 |
|
goto T2056; |
5815 |
|
T2056:; |
5816 |
|
V548= Ct; |
5817 |
|
base[10]= (V555); |
5818 |
|
base[11]= (V527); |
5819 |
|
vs_top=(vs_base=base+10)+2; |
5820 |
|
(void) (*Lnk379)(); |
5821 |
|
if(vs_base<vs_top){ |
5822 |
|
V555= vs_base[0]; |
5823 |
|
vs_base++; |
5824 |
|
}else{ |
5825 |
|
V555= Cnil;} |
5826 |
|
if(vs_base<vs_top){ |
5827 |
|
V549= vs_base[0]; |
5828 |
|
vs_base++; |
5829 |
|
}else{ |
5830 |
|
V549= Cnil;} |
5831 |
|
if(vs_base<vs_top){ |
5832 |
|
V550= vs_base[0]; |
5833 |
|
}else{ |
5834 |
|
V550= Cnil;} |
5835 |
|
vs_top=sup; |
5836 |
|
if(((V549))==Cnil){ |
5837 |
|
goto T2096;} |
5838 |
|
V536= list(2,VV[217],(V550)); |
5839 |
|
goto T2094; |
5840 |
|
goto T2096; |
5841 |
|
T2096:; |
5842 |
|
base[11]= VV[257]; |
5843 |
|
vs_top=(vs_base=base+11)+1; |
5844 |
|
(void) (*Lnk327)(); |
5845 |
|
vs_top=sup; |
5846 |
|
base[10]= vs_base[0]; |
5847 |
|
base[11]= (V555); |
5848 |
|
base[12]= (V527); |
5849 |
|
vs_top=(vs_base=base+10)+3; |
5850 |
|
(void) (*Lnk359)(); |
5851 |
|
vs_top=sup; |
5852 |
|
V536= vs_base[0]; |
5853 |
|
goto T2094; |
5854 |
|
T2094:; |
5855 |
|
goto T2030; |
5856 |
|
goto T2055; |
5857 |
|
T2055:; |
5858 |
|
if((V557!= VV[215]))goto T2102; |
5859 |
|
base[10]= (V555); |
5860 |
|
base[11]= (V527); |
5861 |
|
vs_top=(vs_base=base+10)+2; |
5862 |
|
(void) (*Lnk379)(); |
5863 |
|
if(vs_base<vs_top){ |
5864 |
|
V555= vs_base[0]; |
5865 |
|
vs_base++; |
5866 |
|
}else{ |
5867 |
|
V555= Cnil;} |
5868 |
|
if(vs_base<vs_top){ |
5869 |
|
V541= vs_base[0]; |
5870 |
|
vs_base++; |
5871 |
|
}else{ |
5872 |
|
V541= Cnil;} |
5873 |
|
if(vs_base<vs_top){ |
5874 |
|
V540= vs_base[0]; |
5875 |
|
}else{ |
5876 |
|
V540= Cnil;} |
5877 |
|
vs_top=sup; |
5878 |
|
if(((V541))!=Cnil){ |
5879 |
|
goto T2030;} |
5880 |
|
base[11]= VV[258]; |
5881 |
|
vs_top=(vs_base=base+11)+1; |
5882 |
|
(void) (*Lnk327)(); |
5883 |
|
vs_top=sup; |
5884 |
|
V540= vs_base[0]; |
5885 |
|
base[10]= (V540); |
5886 |
|
base[11]= (V555); |
5887 |
|
base[12]= (V527); |
5888 |
|
vs_top=(vs_base=base+10)+3; |
5889 |
|
(void) (*Lnk359)(); |
5890 |
|
vs_top=sup; |
5891 |
|
goto T2030; |
5892 |
|
goto T2102; |
5893 |
|
T2102:; |
5894 |
|
base[10]= VV[259]; |
5895 |
|
base[11]= (V554); |
5896 |
|
vs_top=(vs_base=base+10)+2; |
5897 |
|
(void) (*Lnk347)(); |
5898 |
|
vs_top=sup;} |
5899 |
|
goto T2030; |
5900 |
|
T2030:; |
5901 |
|
if(((V556))==Cnil){ |
5902 |
|
goto T2116;} |
5903 |
|
if(((V543))==Cnil){ |
5904 |
|
goto T2116;} |
5905 |
|
if(((V543))==((V556))){ |
5906 |
|
goto T2116;} |
5907 |
|
base[10]= VV[260]; |
5908 |
|
vs_top=(vs_base=base+10)+1; |
5909 |
|
(void) (*Lnk347)(); |
5910 |
|
vs_top=sup; |
5911 |
|
goto T2116; |
5912 |
|
T2116:; |
5913 |
|
V556= (V543); |
5914 |
|
V553= cdr((V553)); |
5915 |
|
goto T2021;} |
5916 |
|
goto T2019; |
5917 |
|
T2019:; |
5918 |
|
if(((V531))==Cnil){ |
5919 |
|
goto T2129;} |
5920 |
|
if(((V537))!=Cnil){ |
5921 |
|
goto T2129;} |
5922 |
|
base[10]= VV[261]; |
5923 |
|
vs_top=(vs_base=base+10)+1; |
5924 |
|
(void) (*Lnk347)(); |
5925 |
|
vs_top=sup; |
5926 |
|
goto T2129; |
5927 |
|
T2129:; |
5928 |
|
if(((V545))!=Cnil){ |
5929 |
|
goto T2135;} |
5930 |
|
base[10]= (V526); |
5931 |
|
V547= Ct;{object V558; |
5932 |
|
base[12]= (V527); |
5933 |
|
vs_top=(vs_base=base+12)+1; |
5934 |
|
(void) (*Lnk329)(); |
5935 |
|
vs_top=sup; |
5936 |
|
V558= vs_base[0]; |
5937 |
|
if(V558==Cnil)goto T2143; |
5938 |
|
V546= V558; |
5939 |
|
goto T2142; |
5940 |
|
goto T2143; |
5941 |
|
T2143:;} |
5942 |
|
V546= small_fixnum(0); |
5943 |
|
goto T2142; |
5944 |
|
T2142:; |
5945 |
|
base[11]= (V546); |
5946 |
|
base[12]= (V527); |
5947 |
|
vs_top=(vs_base=base+10)+3; |
5948 |
|
(void) (*Lnk380)(); |
5949 |
|
vs_top=sup; |
5950 |
|
goto T2135; |
5951 |
|
T2135:; |
5952 |
|
{register object x= (V543),V559= VV[262]; |
5953 |
|
while(!endp(V559)) |
5954 |
|
if(eql(x,V559->c.c_car)){ |
5955 |
|
goto T2150; |
5956 |
|
}else V559=V559->c.c_cdr; |
5957 |
|
goto T2149;} |
5958 |
|
goto T2150; |
5959 |
|
T2150:; |
5960 |
|
if(((V548))!=Cnil){ |
5961 |
|
goto T2152;} |
5962 |
|
if(((V534))==Cnil){ |
5963 |
|
goto T2151;} |
5964 |
|
goto T2152; |
5965 |
|
T2152:; |
5966 |
|
if(((V548))!=Cnil){ |
5967 |
|
goto T2156;} |
5968 |
|
base[11]= VV[263]; |
5969 |
|
vs_top=(vs_base=base+11)+1; |
5970 |
|
(void) (*Lnk327)(); |
5971 |
|
vs_top=sup; |
5972 |
|
V536= vs_base[0]; |
5973 |
|
base[10]= (V536); |
5974 |
|
base[11]= Cnil; |
5975 |
|
base[12]= (V527); |
5976 |
|
vs_top=(vs_base=base+10)+3; |
5977 |
|
(void) (*Lnk359)(); |
5978 |
|
vs_top=sup; |
5979 |
|
{object V560; |
5980 |
|
V560= list(3,VV[11],(V536),(V534)); |
5981 |
|
setq(VV[106],make_cons((V560),symbol_value(VV[106])));} |
5982 |
|
goto T2156; |
5983 |
|
T2156:; |
5984 |
|
if(((V544))==Cnil){ |
5985 |
|
goto T2169;} |
5986 |
|
V538= VV[34]; |
5987 |
|
goto T2167; |
5988 |
|
goto T2169; |
5989 |
|
T2169:; |
5990 |
|
V538= VV[213]; |
5991 |
|
goto T2167; |
5992 |
|
T2167:; |
5993 |
|
goto T2151; |
5994 |
|
T2151:; |
5995 |
|
if(!(eql((V540),small_fixnum(1)))){ |
5996 |
|
goto T2173;} |
5997 |
|
V542= list(2,VV[180],(V526)); |
5998 |
|
goto T2171; |
5999 |
|
goto T2173; |
6000 |
|
T2173:; |
6001 |
|
V542= list(3,VV[181],(V526),(V540)); |
6002 |
|
goto T2171; |
6003 |
|
T2171:; |
6004 |
|
goto T2147; |
6005 |
|
goto T2149; |
6006 |
|
T2149:; |
6007 |
|
if(((V545))!=Cnil){ |
6008 |
|
goto T2175;} |
6009 |
|
if(((V534))!=Cnil){ |
6010 |
|
goto T2178;} |
6011 |
|
base[10]= VV[264]; |
6012 |
|
vs_top=(vs_base=base+10)+1; |
6013 |
|
(void) (*Lnk347)(); |
6014 |
|
vs_top=sup; |
6015 |
|
goto T2178; |
6016 |
|
T2178:; |
6017 |
|
{object V561; |
6018 |
|
V561= list(3,VV[11],(V526),list(2,VV[199],(V534))); |
6019 |
|
setq(VV[106],make_cons((V561),symbol_value(VV[106])));} |
6020 |
|
goto T2175; |
6021 |
|
T2175:; |
6022 |
|
if(((V534))==Cnil){ |
6023 |
|
goto T2184;} |
6024 |
|
if(((V536))!=Cnil){ |
6025 |
|
goto T2184;} |
6026 |
|
base[10]= (V527); |
6027 |
|
vs_top=(vs_base=base+10)+1; |
6028 |
|
(void) (*Lnk329)(); |
6029 |
|
vs_top=sup; |
6030 |
|
V536= vs_base[0]; |
6031 |
|
V544= Ct; |
6032 |
|
goto T2184; |
6033 |
|
T2184:; |
6034 |
|
if(((V536))==Cnil){ |
6035 |
|
goto T2193;} |
6036 |
|
if(((V544))==Cnil){ |
6037 |
|
goto T2198;} |
6038 |
|
V538= VV[33]; |
6039 |
|
goto T2196; |
6040 |
|
goto T2198; |
6041 |
|
T2198:; |
6042 |
|
V538= VV[265]; |
6043 |
|
goto T2196; |
6044 |
|
T2196:; |
6045 |
|
goto T2193; |
6046 |
|
T2193:; |
6047 |
|
if(!(eql((V540),small_fixnum(1)))){ |
6048 |
|
goto T2202;} |
6049 |
|
V542= list(2,VV[199],(V526)); |
6050 |
|
goto T2200; |
6051 |
|
goto T2202; |
6052 |
|
T2202:; |
6053 |
|
V542= list(3,VV[266],(V526),(V540)); |
6054 |
|
goto T2200; |
6055 |
|
T2200:; |
6056 |
|
goto T2147; |
6057 |
|
T2147:; |
6058 |
|
if(((V538))==Cnil){ |
6059 |
|
goto T2204;} |
6060 |
|
base[10]= Ct; |
6061 |
|
base[11]= (V526); |
6062 |
|
base[12]= list(3,(V538),(V526),(V536)); |
6063 |
|
vs_top=(vs_base=base+10)+3; |
6064 |
|
(void) (*Lnk331)(); |
6065 |
|
vs_top=sup; |
6066 |
|
V539= vs_base[0]; |
6067 |
|
goto T2204; |
6068 |
|
T2204:; |
6069 |
|
if(((V533))==Cnil){ |
6070 |
|
goto T2211;} |
6071 |
|
base[10]= (V528); |
6072 |
|
base[11]= (V526); |
6073 |
|
base[12]= (V533); |
6074 |
|
vs_top=(vs_base=base+10)+3; |
6075 |
|
(void) (*Lnk331)(); |
6076 |
|
vs_top=sup; |
6077 |
|
V562= vs_base[0]; |
6078 |
|
V533= list(2,(V529),V562); |
6079 |
|
goto T2211; |
6080 |
|
T2211:; |
6081 |
|
{object V563; |
6082 |
|
object V564; |
6083 |
|
V563= (V539); |
6084 |
|
V564= (V539); |
6085 |
|
if(((V541))==Cnil){ |
6086 |
|
goto T2219;} |
6087 |
|
if(((V547))==Cnil){ |
6088 |
|
goto T2219;} |
6089 |
|
if(((V549))==Cnil){ |
6090 |
|
goto T2219;} |
6091 |
|
base[10]= (V538); |
6092 |
|
vs_top=(vs_base=base+10)+1; |
6093 |
|
Lsymbol_function(); |
6094 |
|
vs_top=sup; |
6095 |
|
V565= vs_base[0]; |
6096 |
|
V563= ( |
6097 |
|
V566 = V565, |
6098 |
|
(type_of(V566) == t_sfun ?(*((V566)->sfn.sfn_self)): |
6099 |
|
(fcall.fun=(V566),fcall.argd=2,fcalln))((V546),(V550))); |
6100 |
|
if(((V563))==Cnil){ |
6101 |
|
goto T2219;} |
6102 |
|
V564= Ct; |
6103 |
|
goto T2219; |
6104 |
|
T2219:; |
6105 |
|
base[10]= Ct; |
6106 |
|
base[11]= (V526); |
6107 |
|
base[12]= (V542); |
6108 |
|
vs_top=(vs_base=base+10)+3; |
6109 |
|
(void) (*Lnk331)(); |
6110 |
|
vs_top=sup; |
6111 |
|
V567= vs_base[0]; |
6112 |
|
base[10]= list(8,Cnil,list(2,(V526),V567),(V564),(V533),Cnil,Cnil,(V563),(V533)); |
6113 |
|
vs_top=(vs_base=base+10)+1; |
6114 |
|
return;}} |
6115 |
|
} |
6116 |
|
} |
6117 |
|
/* function definition for LOOP-FOR-ARITHMETIC */ |
6118 |
|
|
6119 |
|
static void L98() |
6120 |
|
{register object *base=vs_base; |
6121 |
|
register object *sup=base+VM85; VC85 |
6122 |
|
vs_reserve(VM85); |
6123 |
|
{object V568; |
6124 |
|
object V569; |
6125 |
|
object V570; |
6126 |
|
object V571; |
6127 |
|
check_arg(4); |
6128 |
|
V568=(base[0]); |
6129 |
|
V569=(base[1]); |
6130 |
|
V570=(base[2]); |
6131 |
|
V571=(base[3]); |
6132 |
|
vs_top=sup; |
6133 |
|
goto TTL; |
6134 |
|
TTL:; |
6135 |
|
base[4]= (V568); |
6136 |
|
base[6]= (V570); |
6137 |
|
base[7]= symbol_value(VV[183]); |
6138 |
|
vs_top=(vs_base=base+6)+2; |
6139 |
|
(void) (*Lnk375)(); |
6140 |
|
vs_top=sup; |
6141 |
|
base[5]= vs_base[0]; |
6142 |
|
base[6]= Ct; |
6143 |
|
base[7]= Cnil; |
6144 |
|
base[8]= Cnil; |
6145 |
|
base[9]= Cnil; |
6146 |
|
base[10]= Cnil; |
6147 |
|
base[11]= Cnil; |
6148 |
|
base[12]= Cnil; |
6149 |
|
base[14]= VV[267]; |
6150 |
|
base[15]= Cnil; |
6151 |
|
V572= list(2,(V571),(V569)); |
6152 |
|
base[16]= make_cons(/* INLINE-ARGS */V572,Cnil); |
6153 |
|
vs_top=(vs_base=base+14)+3; |
6154 |
|
(void) (*Lnk384)(); |
6155 |
|
vs_top=sup; |
6156 |
|
base[13]= vs_base[0]; |
6157 |
|
vs_top=(vs_base=base+4)+10; |
6158 |
|
(void) (*Lnk389)(); |
6159 |
|
return; |
6160 |
|
} |
6161 |
|
} |
6162 |
|
/* function definition for LOOP-SEQUENCE-ELEMENTS-PATH */ |
6163 |
|
|
6164 |
|
static void L99() |
6165 |
|
{register object *base=vs_base; |
6166 |
|
register object *sup=base+VM86; VC86 |
6167 |
|
vs_reserve(VM86); |
6168 |
|
{object V573; |
6169 |
|
object V574; |
6170 |
|
object V575; |
6171 |
|
object V576; |
6172 |
|
object V577; |
6173 |
|
object V578; |
6174 |
|
object V579; |
6175 |
|
if(vs_top-vs_base<3) too_few_arguments(); |
6176 |
|
parse_key(vs_base+3,FALSE,FALSE,4,VV[390],VV[391],VV[392],VV[393]); |
6177 |
|
V573=(base[0]); |
6178 |
|
V574=(base[1]); |
6179 |
|
V575=(base[2]); |
6180 |
|
vs_top=sup; |
6181 |
|
V576=(base[3]); |
6182 |
|
V577=(base[4]); |
6183 |
|
V578=(base[5]); |
6184 |
|
V579=(base[6]); |
6185 |
|
{object V580; |
6186 |
|
object V581; |
6187 |
|
base[11]= VV[268]; |
6188 |
|
vs_top=(vs_base=base+11)+1; |
6189 |
|
(void) (*Lnk394)(); |
6190 |
|
if(vs_base>=vs_top){vs_top=sup;goto T2253;} |
6191 |
|
V580= vs_base[0]; |
6192 |
|
vs_base++; |
6193 |
|
if(vs_base>=vs_top){vs_top=sup;goto T2254;} |
6194 |
|
V581= vs_base[0]; |
6195 |
|
vs_top=sup; |
6196 |
|
goto T2255; |
6197 |
|
goto T2253; |
6198 |
|
T2253:; |
6199 |
|
V580= Cnil; |
6200 |
|
goto T2254; |
6201 |
|
T2254:; |
6202 |
|
V581= Cnil; |
6203 |
|
goto T2255; |
6204 |
|
T2255:; |
6205 |
|
{object V582; |
6206 |
|
base[11]= VV[269]; |
6207 |
|
vs_top=(vs_base=base+11)+1; |
6208 |
|
(void) (*Lnk394)(); |
6209 |
|
vs_top=sup; |
6210 |
|
V582= vs_base[0]; |
6211 |
|
base[11]= (V580); |
6212 |
|
base[12]= VV[210]; |
6213 |
|
base[13]= (V581); |
6214 |
|
base[14]= (V573); |
6215 |
|
if((V574)!=Cnil){ |
6216 |
|
base[15]= (V574); |
6217 |
|
goto T2263;} |
6218 |
|
base[15]= (V579); |
6219 |
|
goto T2263; |
6220 |
|
T2263:; |
6221 |
|
base[16]= (V582); |
6222 |
|
base[17]= (V578); |
6223 |
|
base[18]= list(3,(V576),(V582),(V580)); |
6224 |
|
base[19]= list(2,(V577),(V582)); |
6225 |
|
base[20]= (V575); |
6226 |
|
vs_top=(vs_base=base+11)+10; |
6227 |
|
(void) (*Lnk389)(); |
6228 |
|
vs_top=sup; |
6229 |
|
V583= vs_base[0]; |
6230 |
|
base[11]= listA(3,Cnil,Cnil,V583); |
6231 |
|
vs_top=(vs_base=base+11)+1; |
6232 |
|
return;}} |
6233 |
|
} |
6234 |
|
} |
6235 |
|
/* function definition for LOOP-HASH-TABLE-ITERATION-PATH */ |
6236 |
|
|
6237 |
|
static void L100() |
6238 |
|
{register object *base=vs_base; |
6239 |
|
register object *sup=base+VM87; VC87 |
6240 |
|
vs_reserve(VM87); |
6241 |
|
bds_check; |
6242 |
|
{object V584; |
6243 |
|
object V585; |
6244 |
|
object V586; |
6245 |
|
register object V587; |
6246 |
|
if(vs_top-vs_base<3) too_few_arguments(); |
6247 |
|
parse_key(vs_base+3,FALSE,FALSE,1,VV[395]); |
6248 |
|
V584=(base[0]); |
6249 |
|
V585=(base[1]); |
6250 |
|
V586=(base[2]); |
6251 |
|
vs_top=sup; |
6252 |
|
V587=(base[3]); |
6253 |
|
bds_bind(VV[44],small_fixnum(4)); |
6254 |
|
bds_bind(VV[45],small_fixnum(4)); |
6255 |
|
goto T2271; |
6256 |
|
T2271:; |
6257 |
|
base[7]= (V587); |
6258 |
|
base[8]= VV[270]; |
6259 |
|
vs_top=(vs_base=base+7)+2; |
6260 |
|
(void) (*Lnk333)(); |
6261 |
|
vs_top=sup; |
6262 |
|
if((vs_base[0])==Cnil){ |
6263 |
|
goto T2272;} |
6264 |
|
bds_unwind1; |
6265 |
|
bds_unwind1; |
6266 |
|
goto T2269; |
6267 |
|
goto T2272; |
6268 |
|
T2272:; |
6269 |
|
base[7]= VV[47]; |
6270 |
|
base[8]= VV[48]; |
6271 |
|
base[9]= VV[271]; |
6272 |
|
base[10]= (V587); |
6273 |
|
base[11]= VV[270]; |
6274 |
|
vs_top=(vs_base=base+7)+5; |
6275 |
|
Lcerror(); |
6276 |
|
vs_top=sup; |
6277 |
|
base[7]= symbol_value(VV[50]); |
6278 |
|
base[8]= VV[51]; |
6279 |
|
base[9]= VV[271]; |
6280 |
|
vs_top=(vs_base=base+7)+3; |
6281 |
|
Lformat(); |
6282 |
|
vs_top=sup; |
6283 |
|
base[7]= symbol_value(VV[50]); |
6284 |
|
vs_top=(vs_base=base+7)+1; |
6285 |
|
Lfinish_output(); |
6286 |
|
vs_top=sup; |
6287 |
|
vs_base=vs_top; |
6288 |
|
Lread(); |
6289 |
|
vs_top=sup; |
6290 |
|
V587= vs_base[0]; |
6291 |
|
base[7]= symbol_value(VV[50]); |
6292 |
|
base[8]= VV[52]; |
6293 |
|
vs_top=(vs_base=base+7)+2; |
6294 |
|
Lformat(); |
6295 |
|
vs_top=sup; |
6296 |
|
goto T2271; |
6297 |
|
goto T2269; |
6298 |
|
T2269:; |
6299 |
|
if((cdr((V586)))!=Cnil){ |
6300 |
|
goto T2298;} |
6301 |
|
{register object x= caar((V586)),V588= VV[272]; |
6302 |
|
while(!endp(V588)) |
6303 |
|
if(eql(x,V588->c.c_car)){ |
6304 |
|
goto T2299; |
6305 |
|
}else V588=V588->c.c_cdr;} |
6306 |
|
goto T2298; |
6307 |
|
T2298:; |
6308 |
|
base[5]= VV[273]; |
6309 |
|
vs_top=(vs_base=base+5)+1; |
6310 |
|
(void) (*Lnk347)(); |
6311 |
|
vs_top=sup; |
6312 |
|
goto T2297; |
6313 |
|
goto T2299; |
6314 |
|
T2299:; |
6315 |
|
if(((V586))!=Cnil){ |
6316 |
|
goto T2297;} |
6317 |
|
base[5]= VV[274]; |
6318 |
|
vs_top=(vs_base=base+5)+1; |
6319 |
|
(void) (*Lnk347)(); |
6320 |
|
vs_top=sup; |
6321 |
|
goto T2297; |
6322 |
|
T2297:; |
6323 |
|
{object V589; |
6324 |
|
object V590; |
6325 |
|
object V591; |
6326 |
|
register object V592; |
6327 |
|
base[5]= VV[275]; |
6328 |
|
vs_top=(vs_base=base+5)+1; |
6329 |
|
(void) (*Lnk327)(); |
6330 |
|
vs_top=sup; |
6331 |
|
V589= vs_base[0]; |
6332 |
|
base[5]= VV[276]; |
6333 |
|
vs_top=(vs_base=base+5)+1; |
6334 |
|
(void) (*Lnk327)(); |
6335 |
|
vs_top=sup; |
6336 |
|
V590= vs_base[0]; |
6337 |
|
V591= Cnil; |
6338 |
|
V592= Cnil; |
6339 |
|
{object V593; |
6340 |
|
object V594; |
6341 |
|
if(!(((V587))==(VV[277]))){ |
6342 |
|
goto T2314;} |
6343 |
|
base[5]= VV[278]; |
6344 |
|
goto T2312; |
6345 |
|
goto T2314; |
6346 |
|
T2314:; |
6347 |
|
base[5]= VV[277]; |
6348 |
|
goto T2312; |
6349 |
|
T2312:; |
6350 |
|
vs_top=(vs_base=base+5)+1; |
6351 |
|
(void) (*Lnk394)(); |
6352 |
|
if(vs_base>=vs_top){vs_top=sup;goto T2316;} |
6353 |
|
V593= vs_base[0]; |
6354 |
|
vs_base++; |
6355 |
|
if(vs_base>=vs_top){vs_top=sup;goto T2317;} |
6356 |
|
V594= vs_base[0]; |
6357 |
|
vs_top=sup; |
6358 |
|
goto T2318; |
6359 |
|
goto T2316; |
6360 |
|
T2316:; |
6361 |
|
V593= Cnil; |
6362 |
|
goto T2317; |
6363 |
|
T2317:; |
6364 |
|
V594= Cnil; |
6365 |
|
goto T2318; |
6366 |
|
T2318:; |
6367 |
|
V594= Ct; |
6368 |
|
vs_base=vs_top; |
6369 |
|
(void) (*Lnk378)(); |
6370 |
|
vs_top=sup; |
6371 |
|
V591= vs_base[0]; |
6372 |
|
{register object V595; |
6373 |
|
register object V596; |
6374 |
|
register object V597; |
6375 |
|
V598= list(3,(V584),Cnil,(V585)); |
6376 |
|
V599= list(2,(V589),cadar((V586))); |
6377 |
|
if((V594)==Cnil){ |
6378 |
|
V600= Cnil; |
6379 |
|
goto T2324;} |
6380 |
|
if((V593)==Cnil){ |
6381 |
|
V600= Cnil; |
6382 |
|
goto T2324;} |
6383 |
|
V601= list(2,(V593),Cnil); |
6384 |
|
V600= make_cons(/* INLINE-ARGS */V601,Cnil); |
6385 |
|
goto T2324; |
6386 |
|
T2324:; |
6387 |
|
V597= listA(3,/* INLINE-ARGS */V598,/* INLINE-ARGS */V599,V600); |
6388 |
|
V595= Cnil; |
6389 |
|
V596= Cnil; |
6390 |
|
if(!(((V587))==(VV[277]))){ |
6391 |
|
goto T2327;} |
6392 |
|
V595= (V584); |
6393 |
|
if((V594)==Cnil){ |
6394 |
|
V596= Cnil; |
6395 |
|
goto T2331;} |
6396 |
|
V596= (V593); |
6397 |
|
goto T2331; |
6398 |
|
T2331:; |
6399 |
|
goto T2325; |
6400 |
|
goto T2327; |
6401 |
|
T2327:; |
6402 |
|
if((V594)==Cnil){ |
6403 |
|
V595= Cnil; |
6404 |
|
goto T2333;} |
6405 |
|
V595= (V593); |
6406 |
|
goto T2333; |
6407 |
|
T2333:; |
6408 |
|
V596= (V584); |
6409 |
|
goto T2325; |
6410 |
|
T2325:; |
6411 |
|
{object V602; |
6412 |
|
V602= list(2,VV[279],list(2,(V590),(V589))); |
6413 |
|
setq(VV[107],make_cons((V602),symbol_value(VV[107])));} |
6414 |
|
if(!(type_of((V595))==t_cons)){ |
6415 |
|
goto T2338;}{object V603; |
6416 |
|
V603= (V595); |
6417 |
|
base[5]= VV[280]; |
6418 |
|
vs_top=(vs_base=base+5)+1; |
6419 |
|
(void) (*Lnk327)(); |
6420 |
|
vs_top=sup; |
6421 |
|
V595= vs_base[0]; |
6422 |
|
V592= listA(3,V603,(V595),(V592));} |
6423 |
|
{object V604; |
6424 |
|
V604= list(2,(V595),Cnil); |
6425 |
|
V597= make_cons((V604),(V597));} |
6426 |
|
goto T2338; |
6427 |
|
T2338:; |
6428 |
|
if(!(type_of((V596))==t_cons)){ |
6429 |
|
goto T2347;}{object V605; |
6430 |
|
V605= (V596); |
6431 |
|
base[5]= VV[281]; |
6432 |
|
vs_top=(vs_base=base+5)+1; |
6433 |
|
(void) (*Lnk327)(); |
6434 |
|
vs_top=sup; |
6435 |
|
V596= vs_base[0]; |
6436 |
|
V592= listA(3,V605,(V596),(V592));} |
6437 |
|
{object V606; |
6438 |
|
V606= list(2,(V596),Cnil); |
6439 |
|
V597= make_cons((V606),(V597));} |
6440 |
|
goto T2347; |
6441 |
|
T2347:; |
6442 |
|
V607= list(3,(V591),(V595),(V596)); |
6443 |
|
base[5]= list(6,(V597),Cnil,Cnil,Cnil,list(2,VV[36],list(3,VV[85],/* INLINE-ARGS */V607,make_cons((V590),Cnil))),(V592)); |
6444 |
|
vs_top=(vs_base=base+5)+1; |
6445 |
|
return;}}} |
6446 |
|
} |
6447 |
|
} |
6448 |
|
/* function definition for LOOP-PACKAGE-SYMBOLS-ITERATION-PATH */ |
6449 |
|
|
6450 |
|
static void L101() |
6451 |
|
{register object *base=vs_base; |
6452 |
|
register object *sup=base+VM88; VC88 |
6453 |
|
vs_reserve(VM88); |
6454 |
|
{object V608; |
6455 |
|
object V609; |
6456 |
|
register object V610; |
6457 |
|
object V611; |
6458 |
|
if(vs_top-vs_base<3) too_few_arguments(); |
6459 |
|
parse_key(vs_base+3,FALSE,FALSE,1,VV[396]); |
6460 |
|
V608=(base[0]); |
6461 |
|
V609=(base[1]); |
6462 |
|
V610=(base[2]); |
6463 |
|
vs_top=sup; |
6464 |
|
V611=(base[3]); |
6465 |
|
if((cdr((V610)))!=Cnil){ |
6466 |
|
goto T2357;} |
6467 |
|
{register object x= caar((V610)),V612= VV[282]; |
6468 |
|
while(!endp(V612)) |
6469 |
|
if(eql(x,V612->c.c_car)){ |
6470 |
|
goto T2358; |
6471 |
|
}else V612=V612->c.c_cdr;} |
6472 |
|
goto T2357; |
6473 |
|
T2357:; |
6474 |
|
base[5]= VV[283]; |
6475 |
|
vs_top=(vs_base=base+5)+1; |
6476 |
|
(void) (*Lnk347)(); |
6477 |
|
vs_top=sup; |
6478 |
|
goto T2356; |
6479 |
|
goto T2358; |
6480 |
|
T2358:; |
6481 |
|
if(((V610))!=Cnil){ |
6482 |
|
goto T2356;} |
6483 |
|
base[5]= VV[284]; |
6484 |
|
vs_top=(vs_base=base+5)+1; |
6485 |
|
(void) (*Lnk347)(); |
6486 |
|
vs_top=sup; |
6487 |
|
goto T2356; |
6488 |
|
T2356:; |
6489 |
|
if(type_of((V608))==t_symbol){ |
6490 |
|
goto T2366;} |
6491 |
|
base[5]= VV[285]; |
6492 |
|
vs_top=(vs_base=base+5)+1; |
6493 |
|
(void) (*Lnk347)(); |
6494 |
|
vs_top=sup; |
6495 |
|
goto T2366; |
6496 |
|
T2366:; |
6497 |
|
{object V613; |
6498 |
|
object V614; |
6499 |
|
base[5]= VV[286]; |
6500 |
|
vs_top=(vs_base=base+5)+1; |
6501 |
|
(void) (*Lnk327)(); |
6502 |
|
vs_top=sup; |
6503 |
|
V613= vs_base[0]; |
6504 |
|
base[5]= VV[287]; |
6505 |
|
vs_top=(vs_base=base+5)+1; |
6506 |
|
(void) (*Lnk327)(); |
6507 |
|
vs_top=sup; |
6508 |
|
V614= vs_base[0]; |
6509 |
|
{object V615; |
6510 |
|
V615= list(2,VV[288],listA(3,(V614),(V613),(V611))); |
6511 |
|
setq(VV[107],make_cons((V615),symbol_value(VV[107])));} |
6512 |
|
V616= list(3,(V608),Cnil,(V609)); |
6513 |
|
V617= list(2,/* INLINE-ARGS */V616,list(2,(V613),cadar((V610)))); |
6514 |
|
vs_base=vs_top; |
6515 |
|
(void) (*Lnk378)(); |
6516 |
|
vs_top=sup; |
6517 |
|
V618= vs_base[0]; |
6518 |
|
V619= list(2,V618,(V608)); |
6519 |
|
base[5]= list(6,/* INLINE-ARGS */V617,Cnil,Cnil,Cnil,list(2,VV[36],list(3,VV[85],/* INLINE-ARGS */V619,make_cons((V614),Cnil))),Cnil); |
6520 |
|
vs_top=(vs_base=base+5)+1; |
6521 |
|
return;} |
6522 |
|
} |
6523 |
|
} |
6524 |
|
/* function definition for MAKE-ANSI-LOOP-UNIVERSE */ |
6525 |
|
|
6526 |
|
static void L102() |
6527 |
|
{register object *base=vs_base; |
6528 |
|
register object *sup=base+VM89; VC89 |
6529 |
|
vs_reserve(VM89); |
6530 |
|
{object V620; |
6531 |
|
check_arg(1); |
6532 |
|
V620=(base[0]); |
6533 |
|
vs_top=sup; |
6534 |
|
goto TTL; |
6535 |
|
TTL:; |
6536 |
|
{register object V621; |
6537 |
|
base[1]= VV[53]; |
6538 |
|
base[3]= VV[289]; |
6539 |
|
base[4]= VV[290]; |
6540 |
|
base[5]= VV[291]; |
6541 |
|
base[6]= VV[292]; |
6542 |
|
base[7]= VV[293]; |
6543 |
|
base[8]= VV[294]; |
6544 |
|
base[9]= VV[295]; |
6545 |
|
base[10]= VV[296]; |
6546 |
|
base[11]= VV[297]; |
6547 |
|
base[12]= VV[298]; |
6548 |
|
base[13]= VV[299]; |
6549 |
|
base[14]= VV[300]; |
6550 |
|
base[15]= list(2,VV[179],list(4,VV[301],VV[179],symbol_value(VV[183]),VV[210])); |
6551 |
|
base[16]= list(2,VV[302],list(4,VV[301],VV[179],symbol_value(VV[183]),VV[210])); |
6552 |
|
base[17]= VV[303]; |
6553 |
|
vs_top=(vs_base=base+3)+15; |
6554 |
|
LlistA(); |
6555 |
|
vs_top=sup; |
6556 |
|
base[2]= vs_base[0]; |
6557 |
|
base[3]= VV[54]; |
6558 |
|
base[4]= VV[304]; |
6559 |
|
base[5]= VV[55]; |
6560 |
|
base[6]= VV[305]; |
6561 |
|
base[7]= VV[60]; |
6562 |
|
base[8]= VV[306]; |
6563 |
|
base[9]= VV[59]; |
6564 |
|
base[10]= Cnil; |
6565 |
|
base[11]= VV[57]; |
6566 |
|
if(((V620))==Cnil){ |
6567 |
|
goto T2407;} |
6568 |
|
base[12]= VV[307]; |
6569 |
|
goto T2405; |
6570 |
|
goto T2407; |
6571 |
|
T2407:; |
6572 |
|
base[12]= Ct; |
6573 |
|
goto T2405; |
6574 |
|
T2405:; |
6575 |
|
vs_top=(vs_base=base+1)+12; |
6576 |
|
(void) (*Lnk397)(); |
6577 |
|
vs_top=sup; |
6578 |
|
V621= vs_base[0]; |
6579 |
|
base[1]= VV[308]; |
6580 |
|
base[2]= VV[309]; |
6581 |
|
base[3]= (V621); |
6582 |
|
base[4]= VV[229]; |
6583 |
|
base[5]= VV[310]; |
6584 |
|
base[6]= VV[230]; |
6585 |
|
base[7]= Cnil; |
6586 |
|
base[8]= VV[228]; |
6587 |
|
base[9]= VV[311]; |
6588 |
|
vs_top=(vs_base=base+1)+9; |
6589 |
|
(void) (*Lnk398)(); |
6590 |
|
vs_top=sup; |
6591 |
|
base[1]= VV[312]; |
6592 |
|
base[2]= VV[309]; |
6593 |
|
base[3]= (V621); |
6594 |
|
base[4]= VV[229]; |
6595 |
|
base[5]= VV[313]; |
6596 |
|
base[6]= VV[230]; |
6597 |
|
base[7]= Cnil; |
6598 |
|
base[8]= VV[228]; |
6599 |
|
base[9]= VV[314]; |
6600 |
|
vs_top=(vs_base=base+1)+9; |
6601 |
|
(void) (*Lnk398)(); |
6602 |
|
vs_top=sup; |
6603 |
|
base[1]= VV[315]; |
6604 |
|
base[2]= VV[316]; |
6605 |
|
base[3]= (V621); |
6606 |
|
base[4]= VV[229]; |
6607 |
|
base[5]= VV[317]; |
6608 |
|
base[6]= VV[230]; |
6609 |
|
base[7]= Cnil; |
6610 |
|
base[8]= VV[228]; |
6611 |
|
base[9]= VV[318]; |
6612 |
|
vs_top=(vs_base=base+1)+9; |
6613 |
|
(void) (*Lnk398)(); |
6614 |
|
vs_top=sup; |
6615 |
|
base[1]= VV[319]; |
6616 |
|
base[2]= VV[316]; |
6617 |
|
base[3]= (V621); |
6618 |
|
base[4]= VV[229]; |
6619 |
|
base[5]= VV[320]; |
6620 |
|
base[6]= VV[230]; |
6621 |
|
base[7]= Cnil; |
6622 |
|
base[8]= VV[228]; |
6623 |
|
base[9]= VV[321]; |
6624 |
|
vs_top=(vs_base=base+1)+9; |
6625 |
|
(void) (*Lnk398)(); |
6626 |
|
vs_top=sup; |
6627 |
|
base[1]= VV[322]; |
6628 |
|
base[2]= VV[316]; |
6629 |
|
base[3]= (V621); |
6630 |
|
base[4]= VV[229]; |
6631 |
|
base[5]= VV[323]; |
6632 |
|
base[6]= VV[230]; |
6633 |
|
base[7]= Cnil; |
6634 |
|
base[8]= VV[228]; |
6635 |
|
base[9]= VV[324]; |
6636 |
|
vs_top=(vs_base=base+1)+9; |
6637 |
|
(void) (*Lnk398)(); |
6638 |
|
vs_top=sup; |
6639 |
|
base[1]= (V621); |
6640 |
|
vs_top=(vs_base=base+1)+1; |
6641 |
|
return;} |
6642 |
|
} |
6643 |
|
} |
6644 |
|
/* function definition for LOOP-STANDARD-EXPANSION */ |
6645 |
|
|
6646 |
|
static void L103() |
6647 |
|
{register object *base=vs_base; |
6648 |
|
register object *sup=base+VM90; VC90 |
6649 |
|
vs_reserve(VM90); |
6650 |
|
{register object V622; |
6651 |
|
object V623; |
6652 |
|
object V624; |
6653 |
|
check_arg(3); |
6654 |
|
V622=(base[0]); |
6655 |
|
V623=(base[1]); |
6656 |
|
V624=(base[2]); |
6657 |
|
vs_top=sup; |
6658 |
|
goto TTL; |
6659 |
|
TTL:; |
6660 |
|
if(((V622))==Cnil){ |
6661 |
|
goto T2460;} |
6662 |
|
if(!(type_of(car((V622)))==t_symbol)){ |
6663 |
|
goto T2460;} |
6664 |
|
base[3]= (V622); |
6665 |
|
base[4]= (V623); |
6666 |
|
base[5]= (V624); |
6667 |
|
vs_top=(vs_base=base+3)+3; |
6668 |
|
(void) (*Lnk399)(); |
6669 |
|
return; |
6670 |
|
goto T2460; |
6671 |
|
T2460:; |
6672 |
|
{object V625; |
6673 |
|
vs_base=vs_top; |
6674 |
|
Lgensym(); |
6675 |
|
vs_top=sup; |
6676 |
|
V625= vs_base[0]; |
6677 |
|
V626= make_cons(VV[14],(V622)); |
6678 |
|
base[3]= list(3,VV[124],Cnil,list(4,VV[73],(V625),/* INLINE-ARGS */V626,list(2,VV[82],(V625)))); |
6679 |
|
vs_top=(vs_base=base+3)+1; |
6680 |
|
return;} |
6681 |
|
} |
6682 |
|
} |
6683 |
|
/* macro definition for LOOP */ |
6684 |
|
|
6685 |
|
static void L104() |
6686 |
|
{register object *base=vs_base; |
6687 |
|
register object *sup=base+VM91; VC91 |
6688 |
|
vs_reserve(VM91); |
6689 |
|
check_arg(2); |
6690 |
|
vs_top=sup; |
6691 |
|
{object V627=base[0]->c.c_cdr; |
6692 |
|
base[2]= V627;} |
6693 |
|
base[3]= base[2]; |
6694 |
|
base[4]= base[1]; |
6695 |
|
base[5]= symbol_value(VV[325]); |
6696 |
|
vs_top=(vs_base=base+3)+3; |
6697 |
|
(void) (*Lnk400)(); |
6698 |
|
return; |
6699 |
|
} |
6700 |
|
/* local function IN-GROUP-P */ |
6701 |
|
|
6702 |
|
static void LC96(base0) |
6703 |
|
register object *base0; |
6704 |
|
{ register object *base=vs_base; |
6705 |
|
register object *sup=base+VM92; VC92 |
6706 |
|
vs_reserve(VM92); |
6707 |
|
{object V628; |
6708 |
|
object V629; |
6709 |
|
check_arg(2); |
6710 |
|
V628=(base[0]); |
6711 |
|
V629=(base[1]); |
6712 |
|
vs_top=sup; |
6713 |
|
base[2]= (V628); |
6714 |
|
base[3]= (V629); |
6715 |
|
vs_top=(vs_base=base+2)+2; |
6716 |
|
(void) (*Lnk353)(); |
6717 |
|
vs_top=sup; |
6718 |
|
V630= vs_base[0]; |
6719 |
|
base[2]= car(V630); |
6720 |
|
vs_top=(vs_base=base+2)+1; |
6721 |
|
return; |
6722 |
|
} |
6723 |
|
} |
6724 |
|
/* local function IN-GROUP-P */ |
6725 |
|
|
6726 |
|
static void L96(base0) |
6727 |
|
register object *base0; |
6728 |
|
{ register object *base=vs_base; |
6729 |
|
register object *sup=base+VM93; VC93 |
6730 |
|
vs_reserve(VM93); |
6731 |
|
{object V631; |
6732 |
|
object V632; |
6733 |
|
check_arg(2); |
6734 |
|
V631=(base[0]); |
6735 |
|
V632=(base[1]); |
6736 |
|
vs_top=sup; |
6737 |
|
goto TTL; |
6738 |
|
TTL:; |
6739 |
|
base[2]= (V631); |
6740 |
|
base[3]= (V632); |
6741 |
|
vs_top=(vs_base=base+2)+2; |
6742 |
|
(void) (*Lnk353)(); |
6743 |
|
vs_top=sup; |
6744 |
|
V633= vs_base[0]; |
6745 |
|
base[2]= car(V633); |
6746 |
|
vs_top=(vs_base=base+2)+1; |
6747 |
|
return; |
6748 |
|
} |
6749 |
|
} |
6750 |
|
/* local function MAKE-ENDTEST */ |
6751 |
|
|
6752 |
|
static void L82(base0) |
6753 |
|
register object *base0; |
6754 |
|
{ register object *base=vs_base; |
6755 |
|
register object *sup=base+VM94; VC94 |
6756 |
|
vs_reserve(VM94); |
6757 |
|
{object V634; |
6758 |
|
check_arg(1); |
6759 |
|
V634=(base[0]); |
6760 |
|
vs_top=sup; |
6761 |
|
goto TTL; |
6762 |
|
TTL:; |
6763 |
|
if(((V634))!=Cnil){ |
6764 |
|
goto T2478;} |
6765 |
|
base[1]= Cnil; |
6766 |
|
vs_top=(vs_base=base+1)+1; |
6767 |
|
return; |
6768 |
|
goto T2478; |
6769 |
|
T2478:; |
6770 |
|
{register object x= Ct,V635= (V634); |
6771 |
|
while(!endp(V635)) |
6772 |
|
if(eql(x,V635->c.c_car)){ |
6773 |
|
goto T2482; |
6774 |
|
}else V635=V635->c.c_cdr; |
6775 |
|
goto T2481;} |
6776 |
|
goto T2482; |
6777 |
|
T2482:; |
6778 |
|
base[1]= VV[192]; |
6779 |
|
vs_top=(vs_base=base+1)+1; |
6780 |
|
return; |
6781 |
|
goto T2481; |
6782 |
|
T2481:; |
6783 |
|
V634= nreverse((V634)); |
6784 |
|
if((cdr((V634)))!=Cnil){ |
6785 |
|
goto T2485;} |
6786 |
|
V636= car((V634)); |
6787 |
|
goto T2483; |
6788 |
|
goto T2485; |
6789 |
|
T2485:; |
6790 |
|
V636= make_cons(VV[35],(V634)); |
6791 |
|
goto T2483; |
6792 |
|
T2483:; |
6793 |
|
base[1]= list(3,VV[8],V636,VV[193]); |
6794 |
|
vs_top=(vs_base=base+1)+1; |
6795 |
|
return; |
6796 |
|
} |
6797 |
|
} |
6798 |
|
/* local function GET-CLAUSE */ |
6799 |
|
|
6800 |
|
static void L66(base0) |
6801 |
|
register object *base0; |
6802 |
|
{ register object *base=vs_base; |
6803 |
|
register object *sup=base+VM95; VC95 |
6804 |
|
vs_reserve(VM95); |
6805 |
|
{object V637; |
6806 |
|
check_arg(1); |
6807 |
|
V637=(base[0]); |
6808 |
|
vs_top=sup; |
6809 |
|
goto TTL; |
6810 |
|
TTL:; |
6811 |
|
{register object V638; |
6812 |
|
V638= Cnil; |
6813 |
|
goto T2489; |
6814 |
|
T2489:; |
6815 |
|
{register object V639; |
6816 |
|
register object V640; |
6817 |
|
V639= car(symbol_value(VV[89])); |
6818 |
|
bds_bind(VV[109],Cnil); |
6819 |
|
V640= Cnil; |
6820 |
|
if(type_of((V639))==t_symbol){ |
6821 |
|
goto T2495;} |
6822 |
|
base[2]= VV[152]; |
6823 |
|
base[3]= (V639); |
6824 |
|
base[4]= (V637); |
6825 |
|
vs_top=(vs_base=base+2)+3; |
6826 |
|
(void) (*Lnk347)(); |
6827 |
|
vs_top=sup; |
6828 |
|
bds_unwind1; |
6829 |
|
goto T2492; |
6830 |
|
goto T2495; |
6831 |
|
T2495:; |
6832 |
|
setq(VV[88],symbol_value(VV[89])); |
6833 |
|
vs_base=vs_top; |
6834 |
|
(void) (*Lnk350)(); |
6835 |
|
vs_top=sup; |
6836 |
|
base[2]= car(symbol_value(VV[89])); |
6837 |
|
base[3]= VV[153]; |
6838 |
|
vs_top=(vs_base=base+2)+2; |
6839 |
|
(void) (*Lnk357)(); |
6840 |
|
vs_top=sup; |
6841 |
|
if((vs_base[0])==Cnil){ |
6842 |
|
goto T2503;} |
6843 |
|
if(base0[3]!=Cnil){ |
6844 |
|
V641= base0[3]; |
6845 |
|
goto T2509;} |
6846 |
|
vs_base=vs_top; |
6847 |
|
(void) (*Lnk378)(); |
6848 |
|
vs_top=sup; |
6849 |
|
base0[3]= vs_base[0]; |
6850 |
|
V641= base0[3]; |
6851 |
|
goto T2509; |
6852 |
|
T2509:; |
6853 |
|
setq(VV[89],make_cons(V641,cdr(symbol_value(VV[89])))); |
6854 |
|
goto T2503; |
6855 |
|
T2503:; |
6856 |
|
base[2]= (V639); |
6857 |
|
base[3]= structure_ref(symbol_value(VV[97]),VV[39],0); |
6858 |
|
vs_top=(vs_base=base+2)+2; |
6859 |
|
(void) (*Lnk351)(); |
6860 |
|
vs_top=sup; |
6861 |
|
V640= vs_base[0]; |
6862 |
|
if(((V640))==Cnil){ |
6863 |
|
goto T2511;} |
6864 |
|
base[3]= car((V640)); |
6865 |
|
vs_top=(vs_base=base+3)+1; |
6866 |
|
Lsymbol_function(); |
6867 |
|
vs_top=sup; |
6868 |
|
base[2]= vs_base[0]; |
6869 |
|
{object V642; |
6870 |
|
V642= cdr((V640)); |
6871 |
|
vs_top=base+3; |
6872 |
|
while(!endp(V642)) |
6873 |
|
{vs_push(car(V642));V642=cdr(V642);} |
6874 |
|
vs_base=base+3;} |
6875 |
|
super_funcall_no_event(base[2]); |
6876 |
|
vs_top=sup; |
6877 |
|
if(!(((VV[109]->s.s_dbind))==Cnil)){ |
6878 |
|
goto T2512;} |
6879 |
|
goto T2511; |
6880 |
|
T2511:; |
6881 |
|
base[2]= VV[154]; |
6882 |
|
base[3]= (V639); |
6883 |
|
base[4]= (V637); |
6884 |
|
vs_top=(vs_base=base+2)+3; |
6885 |
|
(void) (*Lnk347)(); |
6886 |
|
vs_top=sup; |
6887 |
|
bds_unwind1; |
6888 |
|
goto T2492; |
6889 |
|
goto T2512; |
6890 |
|
T2512:; |
6891 |
|
base[2]= (VV[109]->s.s_dbind); |
6892 |
|
base[3]= (V638); |
6893 |
|
vs_top=(vs_base=base+2)+2; |
6894 |
|
Lreconc(); |
6895 |
|
vs_top=sup; |
6896 |
|
V638= vs_base[0]; |
6897 |
|
bds_unwind1;} |
6898 |
|
goto T2492; |
6899 |
|
T2492:; |
6900 |
|
base[1]= car(symbol_value(VV[89])); |
6901 |
|
base[2]= VV[155]; |
6902 |
|
vs_top=(vs_base=base+1)+2; |
6903 |
|
(void) (*Lnk357)(); |
6904 |
|
vs_top=sup; |
6905 |
|
if((vs_base[0])==Cnil){ |
6906 |
|
goto T2531;} |
6907 |
|
vs_base=vs_top; |
6908 |
|
(void) (*Lnk350)(); |
6909 |
|
vs_top=sup; |
6910 |
|
goto T2529; |
6911 |
|
goto T2531; |
6912 |
|
T2531:; |
6913 |
|
if((cdr((V638)))==Cnil){ |
6914 |
|
goto T2536;} |
6915 |
|
V643= nreverse((V638)); |
6916 |
|
base[1]= make_cons(VV[14],/* INLINE-ARGS */V643); |
6917 |
|
vs_top=(vs_base=base+1)+1; |
6918 |
|
return; |
6919 |
|
goto T2536; |
6920 |
|
T2536:; |
6921 |
|
base[1]= car((V638)); |
6922 |
|
vs_top=(vs_base=base+1)+1; |
6923 |
|
return; |
6924 |
|
goto T2529; |
6925 |
|
T2529:; |
6926 |
|
goto T2489;} |
6927 |
|
} |
6928 |
|
} |
6929 |
|
/* local function REPLICATE */ |
6930 |
|
|
6931 |
|
static void L59(base0) |
6932 |
|
register object *base0; |
6933 |
|
{ register object *base=vs_base; |
6934 |
|
register object *sup=base+VM96; VC96 |
6935 |
|
vs_reserve(VM96); |
6936 |
|
{object V644; |
6937 |
|
object V645; |
6938 |
|
check_arg(2); |
6939 |
|
V644=(base[0]); |
6940 |
|
V645=(base[1]); |
6941 |
|
vs_top=sup; |
6942 |
|
goto TTL; |
6943 |
|
TTL:; |
6944 |
|
if(!(type_of((V645))!=t_cons)){ |
6945 |
|
goto T2541;} |
6946 |
|
base[2]= (V644); |
6947 |
|
vs_top=(vs_base=base+2)+1; |
6948 |
|
return; |
6949 |
|
goto T2541; |
6950 |
|
T2541:; |
6951 |
|
base[2]= (V644); |
6952 |
|
base[3]= car((V645)); |
6953 |
|
vs_top=(vs_base=base+2)+2; |
6954 |
|
L59(base0); |
6955 |
|
vs_top=sup; |
6956 |
|
V646= vs_base[0]; |
6957 |
|
base[2]= (V644); |
6958 |
|
base[3]= cdr((V645)); |
6959 |
|
vs_top=(vs_base=base+2)+2; |
6960 |
|
L59(base0); |
6961 |
|
vs_top=sup; |
6962 |
|
V647= vs_base[0]; |
6963 |
|
base[2]= make_cons(V646,V647); |
6964 |
|
vs_top=(vs_base=base+2)+1; |
6965 |
|
return; |
6966 |
|
} |
6967 |
|
} |
6968 |
|
/* local function TRANSLATE */ |
6969 |
|
|
6970 |
|
static void L58(base0) |
6971 |
|
register object *base0; |
6972 |
|
{ register object *base=vs_base; |
6973 |
|
register object *sup=base+VM97; VC97 |
6974 |
|
vs_reserve(VM97); |
6975 |
|
{register object V648; |
6976 |
|
register object V649; |
6977 |
|
check_arg(2); |
6978 |
|
V648=(base[0]); |
6979 |
|
V649=(base[1]); |
6980 |
|
vs_top=sup; |
6981 |
|
goto TTL; |
6982 |
|
TTL:; |
6983 |
|
if(((V648))!=Cnil){ |
6984 |
|
goto T2550;} |
6985 |
|
base[2]= Cnil; |
6986 |
|
vs_top=(vs_base=base+2)+1; |
6987 |
|
return; |
6988 |
|
goto T2550; |
6989 |
|
T2550:; |
6990 |
|
if(!(type_of((V648))!=t_cons)){ |
6991 |
|
goto T2553;}{object V650; |
6992 |
|
base[3]= (V648); |
6993 |
|
base[4]= structure_ref(symbol_value(VV[97]),VV[39],4); |
6994 |
|
vs_top=(vs_base=base+3)+2; |
6995 |
|
Lgethash(); |
6996 |
|
vs_top=sup; |
6997 |
|
V650= vs_base[0]; |
6998 |
|
if(V650==Cnil)goto T2556; |
6999 |
|
base[2]= V650; |
7000 |
|
goto T2555; |
7001 |
|
goto T2556; |
7002 |
|
T2556:;}{object V651; |
7003 |
|
base[3]= symbol_name((V648)); |
7004 |
|
base[4]= structure_ref(symbol_value(VV[97]),VV[39],5); |
7005 |
|
vs_top=(vs_base=base+3)+2; |
7006 |
|
Lgethash(); |
7007 |
|
vs_top=sup; |
7008 |
|
V651= vs_base[0]; |
7009 |
|
if(V651==Cnil)goto T2560; |
7010 |
|
base[2]= V651; |
7011 |
|
goto T2555; |
7012 |
|
goto T2560; |
7013 |
|
T2560:;} |
7014 |
|
base[3]= VV[140]; |
7015 |
|
base[4]= base0[1]; |
7016 |
|
base[5]= (V648); |
7017 |
|
vs_top=(vs_base=base+3)+3; |
7018 |
|
(void) (*Lnk347)(); |
7019 |
|
vs_top=sup; |
7020 |
|
base[2]= vs_base[0]; |
7021 |
|
goto T2555; |
7022 |
|
T2555:; |
7023 |
|
base[3]= (V649); |
7024 |
|
vs_top=(vs_base=base+2)+2; |
7025 |
|
L59(base0); |
7026 |
|
return; |
7027 |
|
goto T2553; |
7028 |
|
T2553:; |
7029 |
|
if(!(type_of((V649))!=t_cons)){ |
7030 |
|
goto T2569;} |
7031 |
|
base[2]= VV[141]; |
7032 |
|
base[3]= base0[1]; |
7033 |
|
base[4]= base0[0]; |
7034 |
|
vs_top=(vs_base=base+2)+3; |
7035 |
|
(void) (*Lnk347)(); |
7036 |
|
return; |
7037 |
|
goto T2569; |
7038 |
|
T2569:; |
7039 |
|
base[2]= car((V648)); |
7040 |
|
base[3]= car((V649)); |
7041 |
|
vs_top=(vs_base=base+2)+2; |
7042 |
|
L58(base0); |
7043 |
|
vs_top=sup; |
7044 |
|
V652= vs_base[0]; |
7045 |
|
base[2]= cdr((V648)); |
7046 |
|
base[3]= cdr((V649)); |
7047 |
|
vs_top=(vs_base=base+2)+2; |
7048 |
|
L58(base0); |
7049 |
|
vs_top=sup; |
7050 |
|
V653= vs_base[0]; |
7051 |
|
base[2]= make_cons(V652,V653); |
7052 |
|
vs_top=(vs_base=base+2)+1; |
7053 |
|
return; |
7054 |
|
} |
7055 |
|
} |
7056 |
|
/* local function LIST-SIZE */ |
7057 |
|
|
7058 |
|
static void L40(base0) |
7059 |
|
register object *base0; |
7060 |
|
{ register object *base=vs_base; |
7061 |
|
register object *sup=base+VM98; VC98 |
7062 |
|
vs_reserve(VM98); |
7063 |
|
{object V654; |
7064 |
|
check_arg(1); |
7065 |
|
V654=(base[0]); |
7066 |
|
vs_top=sup; |
7067 |
|
goto TTL; |
7068 |
|
TTL:; |
7069 |
|
{long V655; |
7070 |
|
V655= 0; |
7071 |
|
{register object V656; |
7072 |
|
object V657; |
7073 |
|
V656= (V654); |
7074 |
|
V657= car((V656)); |
7075 |
|
goto T2584; |
7076 |
|
T2584:; |
7077 |
|
if(!(endp_prop((V656)))){ |
7078 |
|
goto T2585;} |
7079 |
|
base[2]= make_fixnum(V655); |
7080 |
|
vs_top=(vs_base=base+2)+1; |
7081 |
|
return; |
7082 |
|
goto T2585; |
7083 |
|
T2585:; |
7084 |
|
V658 = make_fixnum(V655); |
7085 |
|
base[2]= (V657); |
7086 |
|
base[3]= base0[1]; |
7087 |
|
vs_top=(vs_base=base+2)+2; |
7088 |
|
(void) (*Lnk342)(); |
7089 |
|
vs_top=sup; |
7090 |
|
V659= vs_base[0]; |
7091 |
|
V655= fix(number_plus(V658,V659)); |
7092 |
|
V656= cdr((V656)); |
7093 |
|
V657= car((V656)); |
7094 |
|
goto T2584;}} |
7095 |
|
} |
7096 |
|
} |
7097 |
|
/* local function MAKEBODY */ |
7098 |
|
|
7099 |
|
static void L35(base0) |
7100 |
|
register object *base0; |
7101 |
|
{ register object *base=vs_base; |
7102 |
|
register object *sup=base+VM99; VC99 |
7103 |
|
vs_reserve(VM99); |
7104 |
|
check_arg(0); |
7105 |
|
vs_top=sup; |
7106 |
|
goto TTL; |
7107 |
|
TTL:; |
7108 |
|
{object V660; |
7109 |
|
V662= nreverse(base0[7]); |
7110 |
|
base[0]= append(base0[2],/* INLINE-ARGS */V662); |
7111 |
|
vs_top=(vs_base=base+0)+1; |
7112 |
|
L33(base0); |
7113 |
|
vs_top=sup; |
7114 |
|
V661= vs_base[0]; |
7115 |
|
base[1]= base0[8]; |
7116 |
|
base[2]= VV[75]; |
7117 |
|
vs_top=(vs_base=base+1)+2; |
7118 |
|
Lreconc(); |
7119 |
|
vs_top=sup; |
7120 |
|
V664= vs_base[0]; |
7121 |
|
base[0]= append(base0[4],V664); |
7122 |
|
vs_top=(vs_base=base+0)+1; |
7123 |
|
L33(base0); |
7124 |
|
vs_top=sup; |
7125 |
|
V663= vs_base[0]; |
7126 |
|
base[0]= base0[6]; |
7127 |
|
vs_top=(vs_base=base+0)+1; |
7128 |
|
L33(base0); |
7129 |
|
vs_top=sup; |
7130 |
|
V665= vs_base[0]; |
7131 |
|
V666= make_cons(VV[76],V665); |
7132 |
|
V667= append(V663,/* INLINE-ARGS */V666); |
7133 |
|
V668= make_cons(VV[74],/* INLINE-ARGS */V667); |
7134 |
|
V669= append(V661,/* INLINE-ARGS */V668); |
7135 |
|
V660= make_cons(VV[73],/* INLINE-ARGS */V669); |
7136 |
|
if((base0[9])==Cnil){ |
7137 |
|
goto T2610;} |
7138 |
|
V670= list(2,base0[9],Cnil); |
7139 |
|
base[0]= list(3,VV[29],make_cons(/* INLINE-ARGS */V670,Cnil),(V660)); |
7140 |
|
vs_top=(vs_base=base+0)+1; |
7141 |
|
return; |
7142 |
|
goto T2610; |
7143 |
|
T2610:; |
7144 |
|
base[0]= (V660); |
7145 |
|
vs_top=(vs_base=base+0)+1; |
7146 |
|
return;} |
7147 |
|
} |
7148 |
|
/* local function PIFY */ |
7149 |
|
|
7150 |
|
static void L34(base0) |
7151 |
|
register object *base0; |
7152 |
|
{ register object *base=vs_base; |
7153 |
|
register object *sup=base+VM100; VC100 |
7154 |
|
vs_reserve(VM100); |
7155 |
|
{object V671; |
7156 |
|
check_arg(1); |
7157 |
|
V671=(base[0]); |
7158 |
|
vs_top=sup; |
7159 |
|
goto TTL; |
7160 |
|
TTL:; |
7161 |
|
if((cdr((V671)))!=Cnil){ |
7162 |
|
goto T2613;} |
7163 |
|
base[1]= car((V671)); |
7164 |
|
vs_top=(vs_base=base+1)+1; |
7165 |
|
return; |
7166 |
|
goto T2613; |
7167 |
|
T2613:; |
7168 |
|
base[1]= make_cons(VV[14],(V671)); |
7169 |
|
vs_top=(vs_base=base+1)+1; |
7170 |
|
return; |
7171 |
|
} |
7172 |
|
} |
7173 |
|
/* local function PSIMP */ |
7174 |
|
|
7175 |
|
static void L33(base0) |
7176 |
|
register object *base0; |
7177 |
|
{ register object *base=vs_base; |
7178 |
|
register object *sup=base+VM101; VC101 |
7179 |
|
vs_reserve(VM101); |
7180 |
|
{object V672; |
7181 |
|
check_arg(1); |
7182 |
|
V672=(base[0]); |
7183 |
|
vs_top=sup; |
7184 |
|
goto TTL; |
7185 |
|
TTL:; |
7186 |
|
{register object V673; |
7187 |
|
V673= Cnil; |
7188 |
|
{register object V674; |
7189 |
|
register object V675; |
7190 |
|
V674= (V672); |
7191 |
|
V675= car((V674)); |
7192 |
|
goto T2619; |
7193 |
|
T2619:; |
7194 |
|
if(!(endp_prop((V674)))){ |
7195 |
|
goto T2620;} |
7196 |
|
goto T2615; |
7197 |
|
goto T2620; |
7198 |
|
T2620:; |
7199 |
|
if(((V675))==Cnil){ |
7200 |
|
goto T2624;} |
7201 |
|
{register object V676; |
7202 |
|
V676= (V675); |
7203 |
|
V673= make_cons((V676),(V673));} |
7204 |
|
if(!(type_of((V675))==t_cons)){ |
7205 |
|
goto T2624;} |
7206 |
|
{register object x= car((V675)),V677= VV[72]; |
7207 |
|
while(!endp(V677)) |
7208 |
|
if(eql(x,V677->c.c_car)){ |
7209 |
|
goto T2633; |
7210 |
|
}else V677=V677->c.c_cdr; |
7211 |
|
goto T2624;} |
7212 |
|
goto T2633; |
7213 |
|
T2633:; |
7214 |
|
goto T2615; |
7215 |
|
goto T2624; |
7216 |
|
T2624:; |
7217 |
|
V674= cdr((V674)); |
7218 |
|
V675= car((V674)); |
7219 |
|
goto T2619;} |
7220 |
|
goto T2615; |
7221 |
|
T2615:; |
7222 |
|
base[1]= nreverse((V673)); |
7223 |
|
vs_top=(vs_base=base+1)+1; |
7224 |
|
return;} |
7225 |
|
} |
7226 |
|
} |
7227 |
|
/* local function FIND-NON-NULL */ |
7228 |
|
|
7229 |
|
static void L27(base0) |
7230 |
|
register object *base0; |
7231 |
|
{ register object *base=vs_base; |
7232 |
|
register object *sup=base+VM102; VC102 |
7233 |
|
vs_reserve(VM102); |
7234 |
|
{object V678; |
7235 |
|
check_arg(1); |
7236 |
|
V678=(base[0]); |
7237 |
|
vs_top=sup; |
7238 |
|
goto TTL; |
7239 |
|
TTL:; |
7240 |
|
{register object V679; |
7241 |
|
V679= (V678); |
7242 |
|
goto T2640; |
7243 |
|
T2640:; |
7244 |
|
if(type_of((V679))==t_cons){ |
7245 |
|
goto T2641;} |
7246 |
|
base[1]= (V679); |
7247 |
|
vs_top=(vs_base=base+1)+1; |
7248 |
|
return; |
7249 |
|
goto T2641; |
7250 |
|
T2641:; |
7251 |
|
{register object V680; |
7252 |
|
V680= car((V679)); |
7253 |
|
V679= cdr((V679)); |
7254 |
|
base[1]= (V680);} |
7255 |
|
vs_top=(vs_base=base+1)+1; |
7256 |
|
L27(base0); |
7257 |
|
vs_top=sup; |
7258 |
|
if((vs_base[0])==Cnil){ |
7259 |
|
goto T2645;} |
7260 |
|
base[1]= Ct; |
7261 |
|
vs_top=(vs_base=base+1)+1; |
7262 |
|
return; |
7263 |
|
goto T2645; |
7264 |
|
T2645:; |
7265 |
|
goto T2640;} |
7266 |
|
} |
7267 |
|
} |
7268 |
|
/* local function LOOP-DESETQ-INTERNAL */ |
7269 |
|
|
7270 |
|
static void L28(base0) |
7271 |
|
register object *base0; |
7272 |
|
{ register object *base=vs_base; |
7273 |
|
register object *sup=base+VM103; VC103 |
7274 |
|
vs_reserve(VM103); |
7275 |
|
{register object V681; |
7276 |
|
register object V682; |
7277 |
|
object V683; |
7278 |
|
if(vs_top-vs_base<2) too_few_arguments(); |
7279 |
|
if(vs_top-vs_base>3) too_many_arguments(); |
7280 |
|
V681=(base[0]); |
7281 |
|
V682=(base[1]); |
7282 |
|
vs_base=vs_base+2; |
7283 |
|
if(vs_base>=vs_top){vs_top=sup;goto T2654;} |
7284 |
|
V683=(base[2]); |
7285 |
|
vs_top=sup; |
7286 |
|
goto T2655; |
7287 |
|
goto T2654; |
7288 |
|
T2654:; |
7289 |
|
V683= Cnil; |
7290 |
|
goto T2655; |
7291 |
|
T2655:; |
7292 |
|
{register object V684; |
7293 |
|
V684= (V681); |
7294 |
|
if(!(((V684))==Cnil)){ |
7295 |
|
goto T2658;} |
7296 |
|
if(!(type_of((V682))==t_cons)){ |
7297 |
|
goto T2661;} |
7298 |
|
if(!((car((V682)))==(VV[62]))){ |
7299 |
|
goto T2664;} |
7300 |
|
{object V685; |
7301 |
|
object V686= cdr((V682)); |
7302 |
|
if(endp(V686)){ |
7303 |
|
base[4]= Cnil; |
7304 |
|
vs_top=(vs_base=base+4)+1; |
7305 |
|
return;} |
7306 |
|
base[3]=V685=MMcons(Cnil,Cnil); |
7307 |
|
goto T2666; |
7308 |
|
T2666:; |
7309 |
|
{register object V687; |
7310 |
|
V687= (V686->c.c_car); |
7311 |
|
if(type_of((V687))==t_cons){ |
7312 |
|
goto T2668;} |
7313 |
|
(V685->c.c_cdr)= Cnil; |
7314 |
|
goto T2667; |
7315 |
|
goto T2668; |
7316 |
|
T2668:; |
7317 |
|
if(!((((car((V687)))==(VV[65])?Ct:Cnil))==Cnil)){ |
7318 |
|
goto T2672;} |
7319 |
|
goto T2670; |
7320 |
|
goto T2672; |
7321 |
|
T2672:; |
7322 |
|
if(!(((type_of(cadr((V687)))==t_symbol?Ct:Cnil))==Cnil)){ |
7323 |
|
goto T2674;} |
7324 |
|
goto T2670; |
7325 |
|
goto T2674; |
7326 |
|
T2674:; |
7327 |
|
base[4]= (V687); |
7328 |
|
base[5]= base0[1]; |
7329 |
|
vs_top=(vs_base=base+4)+2; |
7330 |
|
Lmacroexpand(); |
7331 |
|
vs_top=sup; |
7332 |
|
V687= vs_base[0]; |
7333 |
|
if(((type_of((V687))==t_symbol?Ct:Cnil))==Cnil){ |
7334 |
|
goto T2670;} |
7335 |
|
(V685->c.c_cdr)= Cnil; |
7336 |
|
goto T2667; |
7337 |
|
goto T2670; |
7338 |
|
T2670:; |
7339 |
|
(V685->c.c_cdr)= make_cons((V687),Cnil);} |
7340 |
|
goto T2667; |
7341 |
|
T2667:; |
7342 |
|
{object cdr_V685=MMcdr(V685);while(!endp(cdr_V685)) {cdr_V685=MMcdr(cdr_V685);V685=MMcdr(V685);}} |
7343 |
|
V686=MMcdr(V686); |
7344 |
|
if(endp(V686)){ |
7345 |
|
base[3]=base[3]->c.c_cdr; |
7346 |
|
vs_top=(vs_base=base+3)+1; |
7347 |
|
return;} |
7348 |
|
goto T2666;} |
7349 |
|
goto T2664; |
7350 |
|
T2664:; |
7351 |
|
base[3]= make_cons((V682),Cnil); |
7352 |
|
vs_top=(vs_base=base+3)+1; |
7353 |
|
return; |
7354 |
|
goto T2661; |
7355 |
|
T2661:; |
7356 |
|
base[3]= Cnil; |
7357 |
|
vs_top=(vs_base=base+3)+1; |
7358 |
|
return; |
7359 |
|
goto T2658; |
7360 |
|
T2658:; |
7361 |
|
if(!(type_of((V684))==t_cons)){ |
7362 |
|
goto T2680;} |
7363 |
|
{object V688; |
7364 |
|
object V689; |
7365 |
|
object V690; |
7366 |
|
object V691; |
7367 |
|
V688= car((V681)); |
7368 |
|
V689= cdr((V681)); |
7369 |
|
base[7]= (V688); |
7370 |
|
vs_top=(vs_base=base+7)+1; |
7371 |
|
L27(base0); |
7372 |
|
vs_top=sup; |
7373 |
|
V690= vs_base[0]; |
7374 |
|
base[7]= (V689); |
7375 |
|
vs_top=(vs_base=base+7)+1; |
7376 |
|
L27(base0); |
7377 |
|
vs_top=sup; |
7378 |
|
V691= vs_base[0]; |
7379 |
|
if(((V690))!=Cnil){ |
7380 |
|
goto T2688;} |
7381 |
|
if(((V691))==Cnil){ |
7382 |
|
goto T2689;} |
7383 |
|
goto T2688; |
7384 |
|
T2688:; |
7385 |
|
if(((V691))==Cnil){ |
7386 |
|
goto T2694;} |
7387 |
|
{register object V693; |
7388 |
|
object V694; |
7389 |
|
if((V683)!=Cnil){ |
7390 |
|
V693= (V683); |
7391 |
|
goto T2696;} |
7392 |
|
V693= symbol_value(VV[66]); |
7393 |
|
goto T2696; |
7394 |
|
T2696:; |
7395 |
|
base[9]= (V688); |
7396 |
|
base[10]= list(2,VV[65],(V693)); |
7397 |
|
vs_top=(vs_base=base+9)+2; |
7398 |
|
L28(base0); |
7399 |
|
vs_top=sup; |
7400 |
|
V695= vs_base[0]; |
7401 |
|
V696= list(3,VV[11],(V693),list(2,VV[10],(V693))); |
7402 |
|
base[9]= (V689); |
7403 |
|
base[10]= (V693); |
7404 |
|
base[11]= (V693); |
7405 |
|
vs_top=(vs_base=base+9)+3; |
7406 |
|
L28(base0); |
7407 |
|
vs_top=sup; |
7408 |
|
V697= vs_base[0]; |
7409 |
|
V698= make_cons(/* INLINE-ARGS */V696,V697); |
7410 |
|
V694= append(V695,/* INLINE-ARGS */V698); |
7411 |
|
if((V683)==Cnil){ |
7412 |
|
goto T2706;} |
7413 |
|
if(((V693))==((V682))){ |
7414 |
|
goto T2710;} |
7415 |
|
V700= list(3,VV[11],(V693),(V682)); |
7416 |
|
V699= make_cons(/* INLINE-ARGS */V700,Cnil); |
7417 |
|
goto T2708; |
7418 |
|
goto T2710; |
7419 |
|
T2710:; |
7420 |
|
V699= Cnil; |
7421 |
|
goto T2708; |
7422 |
|
T2708:; |
7423 |
|
base[9]= append(V699,(V694)); |
7424 |
|
vs_top=(vs_base=base+9)+1; |
7425 |
|
return; |
7426 |
|
goto T2706; |
7427 |
|
T2706:; |
7428 |
|
V701= list(2,(V693),(V682)); |
7429 |
|
V702= listA(3,VV[29],make_cons(/* INLINE-ARGS */V701,Cnil),(V694)); |
7430 |
|
base[9]= make_cons(/* INLINE-ARGS */V702,Cnil); |
7431 |
|
vs_top=(vs_base=base+9)+1; |
7432 |
|
return;} |
7433 |
|
goto T2694; |
7434 |
|
T2694:; |
7435 |
|
base[7]= (V688); |
7436 |
|
base[8]= list(2,VV[65],(V682)); |
7437 |
|
base[9]= (V683); |
7438 |
|
vs_top=(vs_base=base+7)+3; |
7439 |
|
L28(base0); |
7440 |
|
return; |
7441 |
|
goto T2689; |
7442 |
|
T2689:; |
7443 |
|
base[7]= Cnil; |
7444 |
|
vs_top=(vs_base=base+7)+1; |
7445 |
|
return;} |
7446 |
|
goto T2680; |
7447 |
|
T2680:; |
7448 |
|
if(((V681))==((V682))){ |
7449 |
|
goto T2716;} |
7450 |
|
V703= list(3,VV[11],(V681),(V682)); |
7451 |
|
base[3]= make_cons(/* INLINE-ARGS */V703,Cnil); |
7452 |
|
vs_top=(vs_base=base+3)+1; |
7453 |
|
return; |
7454 |
|
goto T2716; |
7455 |
|
T2716:; |
7456 |
|
base[3]= Cnil; |
7457 |
|
vs_top=(vs_base=base+3)+1; |
7458 |
|
return;} |
7459 |
|
} |
7460 |
|
} |
7461 |
|
/* local function MAKETABLE */ |
7462 |
|
|
7463 |
|
static void L23(base0) |
7464 |
|
register object *base0; |
7465 |
|
{ register object *base=vs_base; |
7466 |
|
register object *sup=base+VM104; VC104 |
7467 |
|
vs_reserve(VM104); |
7468 |
|
{object V704; |
7469 |
|
check_arg(1); |
7470 |
|
V704=(base[0]); |
7471 |
|
vs_top=sup; |
7472 |
|
goto TTL; |
7473 |
|
TTL:; |
7474 |
|
{object V705; |
7475 |
|
object V706; |
7476 |
|
V705= make_fixnum((long)length((V704))); |
7477 |
|
base[3]= VV[61]; |
7478 |
|
if(!(number_compare((V705),small_fixnum(10))<0)){ |
7479 |
|
goto T2723;} |
7480 |
|
base[4]= small_fixnum(10); |
7481 |
|
goto T2721; |
7482 |
|
goto T2723; |
7483 |
|
T2723:; |
7484 |
|
base[4]= (V705); |
7485 |
|
goto T2721; |
7486 |
|
T2721:; |
7487 |
|
base[5]= VV[20]; |
7488 |
|
base[6]= symbol_function(VV[401]); |
7489 |
|
vs_top=(vs_base=base+3)+4; |
7490 |
|
Lmake_hash_table(); |
7491 |
|
vs_top=sup; |
7492 |
|
V706= vs_base[0]; |
7493 |
|
{register object V707; |
7494 |
|
register object V708; |
7495 |
|
V707= (V704); |
7496 |
|
V708= car((V707)); |
7497 |
|
goto T2731; |
7498 |
|
T2731:; |
7499 |
|
if(!(endp_prop((V707)))){ |
7500 |
|
goto T2732;} |
7501 |
|
goto T2727; |
7502 |
|
goto T2732; |
7503 |
|
T2732:; |
7504 |
|
{object V709; |
7505 |
|
object V711; |
7506 |
|
V709= symbol_name(car((V708))); |
7507 |
|
V711= cadr((V708)); |
7508 |
|
base[6]= (V709); |
7509 |
|
base[7]= V706; |
7510 |
|
base[8]= (V711); |
7511 |
|
vs_top=(vs_base=base+6)+3; |
7512 |
|
siLhash_set(); |
7513 |
|
vs_top=sup;} |
7514 |
|
V707= cdr((V707)); |
7515 |
|
V708= car((V707)); |
7516 |
|
goto T2731;} |
7517 |
|
goto T2727; |
7518 |
|
T2727:; |
7519 |
|
base[3]= (V706); |
7520 |
|
vs_top=(vs_base=base+3)+1; |
7521 |
|
return;} |
7522 |
|
} |
7523 |
|
} |
7524 |
|
/* local function CDR-WRAP */ |
7525 |
|
|
7526 |
|
static void L8(base0) |
7527 |
|
register object *base0; |
7528 |
|
{ register object *base=vs_base; |
7529 |
|
register object *sup=base+VM105; VC105 |
7530 |
|
vs_reserve(VM105); |
7531 |
|
{register object V712; |
7532 |
|
register long V713; |
7533 |
|
check_arg(2); |
7534 |
|
V712=(base[0]); |
7535 |
|
V713=fix(base[1]); |
7536 |
|
vs_top=sup; |
7537 |
|
goto TTL; |
7538 |
|
TTL:; |
7539 |
|
goto T2748; |
7540 |
|
T2748:; |
7541 |
|
if(!((V713)<=(4))){ |
7542 |
|
goto T2749;}switch(V713){ |
7543 |
|
case 1: |
7544 |
|
goto T2755; |
7545 |
|
T2755:; |
7546 |
|
V714= VV[10]; |
7547 |
|
goto T2753; |
7548 |
|
case 2: |
7549 |
|
goto T2756; |
7550 |
|
T2756:; |
7551 |
|
V714= VV[15]; |
7552 |
|
goto T2753; |
7553 |
|
case 3: |
7554 |
|
goto T2757; |
7555 |
|
T2757:; |
7556 |
|
V714= VV[16]; |
7557 |
|
goto T2753; |
7558 |
|
case 4: |
7559 |
|
goto T2758; |
7560 |
|
T2758:; |
7561 |
|
V714= VV[17]; |
7562 |
|
goto T2753; |
7563 |
|
default: |
7564 |
|
goto T2759; |
7565 |
|
T2759:; |
7566 |
|
V714= Cnil; |
7567 |
|
goto T2753;} |
7568 |
|
V714= Cnil; |
7569 |
|
goto T2753; |
7570 |
|
T2753:; |
7571 |
|
V712= list(2,V714,(V712)); |
7572 |
|
base[2]= (V712); |
7573 |
|
vs_top=(vs_base=base+2)+1; |
7574 |
|
return; |
7575 |
|
goto T2749; |
7576 |
|
T2749:; |
7577 |
|
V712= list(2,VV[17],(V712)); |
7578 |
|
V713= (long)(V713)-(4); |
7579 |
|
goto T2748; |
7580 |
|
} |
7581 |
|
} |
7582 |
|
static void LnkT400(){ call_or_link(VV[400],(void **)(void *)&Lnk400);} /* LOOP-STANDARD-EXPANSION */ |
7583 |
|
static void LnkT399(){ call_or_link(VV[399],(void **)(void *)&Lnk399);} /* LOOP-TRANSLATE */ |
7584 |
|
static void LnkT398(){ call_or_link(VV[398],(void **)(void *)&Lnk398);} /* ADD-LOOP-PATH */ |
7585 |
|
static void LnkT397(){ call_or_link(VV[397],(void **)(void *)&Lnk397);} /* MAKE-STANDARD-LOOP-UNIVERSE */ |
7586 |
|
static void LnkT394(){ call_or_link(VV[394],(void **)(void *)&Lnk394);} /* NAMED-VARIABLE */ |
7587 |
|
static void LnkT389(){ call_or_link(VV[389],(void **)(void *)&Lnk389);} /* LOOP-SEQUENCER */ |
7588 |
|
static object LnkTLI386(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_vproc_new(VV[386],(void **)(void *)&LnkLI386,first,ap);va_end(ap);return V1;} /* DELETE */ |
7589 |
|
static void LnkT385(){ call_or_link(VV[385],(void **)(void *)&Lnk385);} /* LOOP-TASSOC */ |
7590 |
|
static void LnkT384(){ call_or_link(VV[384],(void **)(void *)&Lnk384);} /* LOOP-COLLECT-PREPOSITIONAL-PHRASES */ |
7591 |
|
static void LnkT383(){ call_or_link(VV[383],(void **)(void *)&Lnk383);} /* MAKE-LOOP-PATH */ |
7592 |
|
static void LnkT382(){ call_or_link(VV[382],(void **)(void *)&Lnk382);} /* STRUCTURE-SUBTYPE-P */ |
7593 |
|
static void LnkT381(){ call_or_link(VV[381],(void **)(void *)&Lnk381);} /* LOOP-LIST-STEP */ |
7594 |
|
static void LnkT380(){ call_or_link(VV[380],(void **)(void *)&Lnk380);} /* LOOP-MAKE-ITERATION-VARIABLE */ |
7595 |
|
static void LnkT379(){ call_or_link(VV[379],(void **)(void *)&Lnk379);} /* LOOP-CONSTANT-FOLD-IF-POSSIBLE */ |
7596 |
|
static void LnkT378(){ call_or_link(VV[378],(void **)(void *)&Lnk378);} /* LOOP-WHEN-IT-VARIABLE */ |
7597 |
|
static void LnkT377(){ call_or_link(VV[377],(void **)(void *)&Lnk377);} /* LOOP-NOTE-MINIMAX-OPERATION */ |
7598 |
|
static void LnkT376(){ call_or_link(VV[376],(void **)(void *)&Lnk376);} /* MAKE-LOOP-MINIMAX */ |
7599 |
|
static void LnkT375(){ call_or_link(VV[375],(void **)(void *)&Lnk375);} /* LOOP-CHECK-DATA-TYPE */ |
7600 |
|
static void LnkT372(){ call_or_link(VV[372],(void **)(void *)&Lnk372);} /* LOOP-EMIT-FINAL-VALUE */ |
7601 |
|
static void LnkT371(){ call_or_link(VV[371],(void **)(void *)&Lnk371);} /* LOOP-GET-COLLECTION-INFO */ |
7602 |
|
static void LnkT370(){ call_or_link(VV[370],(void **)(void *)&Lnk370);} /* MAKE-LOOP-COLLECTOR */ |
7603 |
|
static object LnkTLI368(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_vproc_new(VV[368],(void **)(void *)&LnkLI368,first,ap);va_end(ap);return V1;} /* FIND */ |
7604 |
|
static void LnkT367(){ call_or_link(VV[367],(void **)(void *)&Lnk367);} /* LOOP-OPTIONAL-TYPE */ |
7605 |
|
static void LnkT364(){ call_or_link(VV[364],(void **)(void *)&Lnk364);} /* LOOP-EMIT-BODY */ |
7606 |
|
static void LnkT363(){ call_or_link(VV[363],(void **)(void *)&Lnk363);} /* LOOP-GET-PROGN */ |
7607 |
|
static void LnkT362(){ call_or_link(VV[362],(void **)(void *)&Lnk362);} /* LOOP-DISALLOW-CONDITIONAL */ |
7608 |
|
static void LnkT361(){ call_or_link(VV[361],(void **)(void *)&Lnk361);} /* LOOP-GET-FORM */ |
7609 |
|
static void LnkT360(){ call_or_link(VV[360],(void **)(void *)&Lnk360);} /* LOOP-CONSTANTP */ |
7610 |
|
static void LnkT359(){ call_or_link(VV[359],(void **)(void *)&Lnk359);} /* LOOP-MAKE-VARIABLE */ |
7611 |
|
static void LnkT358(){ call_or_link(VV[358],(void **)(void *)&Lnk358);} /* LOOP-DECLARE-VARIABLE */ |
7612 |
|
static void LnkT357(){ call_or_link(VV[357],(void **)(void *)&Lnk357);} /* LOOP-TEQUAL */ |
7613 |
|
static object LnkTLI356(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[356],(void **)(void *)&LnkLI356,2,first,ap);va_end(ap);return V1;} /* COERCE */ |
7614 |
|
static void LnkT355(){ call_or_link(VV[355],(void **)(void *)&Lnk355);} /* LOOP-CONSTRUCT-RETURN */ |
7615 |
|
static void LnkT354(){ call_or_link(VV[354],(void **)(void *)&Lnk354);} /* LOOP-PSEUDO-BODY */ |
7616 |
|
static void LnkT353(){ call_or_link(VV[353],(void **)(void *)&Lnk353);} /* LOOP-TMEMBER */ |
7617 |
|
static void LnkT352(){ call_or_link(VV[352],(void **)(void *)&Lnk352);} /* LOOP-HACK-ITERATION */ |
7618 |
|
static void LnkT351(){ call_or_link(VV[351],(void **)(void *)&Lnk351);} /* LOOP-LOOKUP-KEYWORD */ |
7619 |
|
static void LnkT350(){ call_or_link(VV[350],(void **)(void *)&Lnk350);} /* LOOP-POP-SOURCE */ |
7620 |
|
static void LnkT349(){ call_or_link(VV[349],(void **)(void *)&Lnk349);} /* LOOP-BIND-BLOCK */ |
7621 |
|
static void LnkT348(){ call_or_link(VV[348],(void **)(void *)&Lnk348);} /* LOOP-ITERATION-DRIVER */ |
7622 |
|
static void LnkT347(){ call_or_link(VV[347],(void **)(void *)&Lnk347);} /* LOOP-ERROR */ |
7623 |
|
static void LnkT326(){ call_or_link(VV[326],(void **)(void *)&Lnk326);} /* SUBTYPEP */ |
7624 |
|
static object LnkTLI346(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_vproc_new(VV[346],(void **)(void *)&LnkLI346,first,ap);va_end(ap);return V1;} /* WARN */ |
7625 |
|
static void LnkT345(){ call_or_link(VV[345],(void **)(void *)&Lnk345);} /* SPECIFIC-ERROR */ |
7626 |
|
static void LnkT344(){ call_or_link(VV[344],(void **)(void *)&Lnk344);} /* LOOP-CONTEXT */ |
7627 |
|
static void LnkT343(){ call_or_link(VV[343],(void **)(void *)&Lnk343);} /* SPECIAL-OPERATOR-P */ |
7628 |
|
static void LnkT342(){ call_or_link(VV[342],(void **)(void *)&Lnk342);} /* ESTIMATE-CODE-SIZE-1 */ |
7629 |
|
static void LnkT341(){ call_or_link(VV[341],(void **)(void *)&Lnk341);} /* DESTRUCTURING-SIZE */ |
7630 |
|
static void LnkT77(){ call_or_link(VV[77],(void **)(void *)&Lnk77);} /* ESTIMATE-CODE-SIZE */ |
7631 |
|
static void LnkT340(){ call_or_link(VV[340],(void **)(void *)&Lnk340);} /* LOOP-CODE-DUPLICATION-THRESHOLD */ |
7632 |
|
static void LnkT339(){ call_or_link(VV[339],(void **)(void *)&Lnk339);} /* LOOP-OPTIMIZATION-QUANTITIES */ |
7633 |
|
static void LnkT338(){ call_or_link(VV[338],(void **)(void *)&Lnk338);} /* LOOP-WARN */ |
7634 |
|
static void LnkT337(){ call_or_link(VV[337],(void **)(void *)&Lnk337);} /* LOOP-MAKE-DESETQ */ |
7635 |
|
static void LnkT336(){ call_or_link(VV[336],(void **)(void *)&Lnk336);} /* LOOP-MAKE-PSETQ */ |
7636 |
|
static void LnkT335(){ call_or_link(VV[335],(void **)(void *)&Lnk335);} /* MAKE-LOOP-UNIVERSE */ |
7637 |
|
static void LnkT333(){ call_or_link(VV[333],(void **)(void *)&Lnk333);} /* TYPEP */ |
7638 |
|
static void LnkT331(){ call_or_link(VV[331],(void **)(void *)&Lnk331);} /* HIDE-VARIABLE-REFERENCE */ |
7639 |
|
static void LnkT329(){ call_or_link(VV[329],(void **)(void *)&Lnk329);} /* LOOP-TYPED-INIT */ |
7640 |
|
static void LnkT328(){ call_or_link(VV[328],(void **)(void *)&Lnk328);} /* MAKE-LOOP-MINIMAX-INTERNAL */ |
7641 |
|
static void LnkT327(){ call_or_link(VV[327],(void **)(void *)&Lnk327);} /* LOOP-GENTEMP */ |
7642 |
|
|
7643 |
|
#ifdef SYSTEM_SPECIAL_INIT |
7644 |
|
SYSTEM_SPECIAL_INIT |
7645 |
|
#endif |
7646 |
|
|