← Back to branch summary

~ubuntu-branches/ubuntu/quantal/gclcvs/quantal

« back to all changes in this revision

Viewing changes to pcl/c/pcl_macros.c

  • Committer: Bazaar Package Importer
  • Author(s): Camm Maguire
  • Date: 2004-06-24 15:13:46 UTC
  • Revision ID: james.westby@ubuntu.com-20040624151346-xh0xaaktyyp7aorc
Tags: 2.7.0-26
C_GC_OFFSET is 2 on m68k-linux

Show diffs side-by-side

added added

removed removed

Lines of Context:
pcl/c/pcl_macros.c
 
1
 
 
2
#include "cmpinclude.h"
 
3
#include "pcl_macros.h"
 
4
void init_pcl_macros(){do_init(VV);}
 
5
/*      macro definition for MEMQ       */
 
6
 
 
7
static void L1()
 
8
{register object *base=vs_base;
 
9
        register object *sup=base+VM1; VC1
 
10
        vs_check;
 
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]= (V1->c.c_car);
 
19
        V1=V1->c.c_cdr;
 
20
        if(!endp(V1))invalid_macro_call();}
 
21
        base[4]= listA(4,VV[0],base[2],base[3],VV[1]);
 
22
        vs_top=(vs_base=base+4)+1;
 
23
        return;
 
24
}
 
25
/*      macro definition for ASSQ       */
 
26
 
 
27
static void L2()
 
28
{register object *base=vs_base;
 
29
        register object *sup=base+VM2; VC2
 
30
        vs_check;
 
31
        check_arg(2);
 
32
        vs_top=sup;
 
33
        {object V2=base[0]->c.c_cdr;
 
34
        if(endp(V2))invalid_macro_call();
 
35
        base[2]= (V2->c.c_car);
 
36
        V2=V2->c.c_cdr;
 
37
        if(endp(V2))invalid_macro_call();
 
38
        base[3]= (V2->c.c_car);
 
39
        V2=V2->c.c_cdr;
 
40
        if(!endp(V2))invalid_macro_call();}
 
41
        base[4]= listA(4,VV[2],base[2],base[3],VV[3]);
 
42
        vs_top=(vs_base=base+4)+1;
 
43
        return;
 
44
}
 
45
/*      macro definition for RASSQ      */
 
46
 
 
47
static void L3()
 
48
{register object *base=vs_base;
 
49
        register object *sup=base+VM3; VC3
 
50
        vs_check;
 
51
        check_arg(2);
 
52
        vs_top=sup;
 
53
        {object V3=base[0]->c.c_cdr;
 
54
        if(endp(V3))invalid_macro_call();
 
55
        base[2]= (V3->c.c_car);
 
56
        V3=V3->c.c_cdr;
 
57
        if(endp(V3))invalid_macro_call();
 
58
        base[3]= (V3->c.c_car);
 
59
        V3=V3->c.c_cdr;
 
60
        if(!endp(V3))invalid_macro_call();}
 
61
        base[4]= listA(4,VV[4],base[2],base[3],VV[5]);
 
62
        vs_top=(vs_base=base+4)+1;
 
63
        return;
 
64
}
 
65
/*      macro definition for DELQ       */
 
66
 
 
67
static void L4()
 
68
{register object *base=vs_base;
 
69
        register object *sup=base+VM4; VC4
 
70
        vs_check;
 
71
        check_arg(2);
 
72
        vs_top=sup;
 
73
        {object V4=base[0]->c.c_cdr;
 
74
        if(endp(V4))invalid_macro_call();
 
75
        base[2]= (V4->c.c_car);
 
76
        V4=V4->c.c_cdr;
 
77
        if(endp(V4))invalid_macro_call();
 
78
        base[3]= (V4->c.c_car);
 
79
        V4=V4->c.c_cdr;
 
80
        if(!endp(V4))invalid_macro_call();}
 
81
        base[4]= listA(4,VV[6],base[2],base[3],VV[7]);
 
82
        vs_top=(vs_base=base+4)+1;
 
83
        return;
 
84
}
 
85
/*      macro definition for POSQ       */
 
86
 
 
87
static void L5()
 
88
{register object *base=vs_base;
 
89
        register object *sup=base+VM5; VC5
 
90
        vs_check;
 
91
        check_arg(2);
 
92
        vs_top=sup;
 
93
        {object V5=base[0]->c.c_cdr;
 
94
        if(endp(V5))invalid_macro_call();
 
95
        base[2]= (V5->c.c_car);
 
96
        V5=V5->c.c_cdr;
 
97
        if(endp(V5))invalid_macro_call();
 
98
        base[3]= (V5->c.c_car);
 
99
        V5=V5->c.c_cdr;
 
100
        if(!endp(V5))invalid_macro_call();}
 
101
        base[4]= listA(4,VV[8],base[2],base[3],VV[9]);
 
102
        vs_top=(vs_base=base+4)+1;
 
103
        return;
 
104
}
 
105
/*      macro definition for NEQ        */
 
106
 
 
107
static void L6()
 
108
{register object *base=vs_base;
 
109
        register object *sup=base+VM6; VC6
 
110
        vs_check;
 
111
        check_arg(2);
 
112
        vs_top=sup;
 
113
        {object V6=base[0]->c.c_cdr;
 
114
        if(endp(V6))invalid_macro_call();
 
115
        base[2]= (V6->c.c_car);
 
116
        V6=V6->c.c_cdr;
 
117
        if(endp(V6))invalid_macro_call();
 
118
        base[3]= (V6->c.c_car);
 
119
        V6=V6->c.c_cdr;
 
120
        if(!endp(V6))invalid_macro_call();}
 
121
        base[4]= list(2,VV[10],list(3,VV[11],base[2],base[3]));
 
122
        vs_top=(vs_base=base+4)+1;
 
123
        return;
 
124
}
 
125
/*      local entry for function MAKE-CAXR      */
 
126
 
 
127
static object LI7(V9,V10)
 
128
 
 
129
object V9;object V10;
 
130
{        VMB7 VMS7 VMV7
 
131
        goto TTL;
 
132
TTL:;
 
133
        if(!(number_compare((V9),small_fixnum(4))<0)){
 
134
        goto T2;}
 
135
        {object V11 = list(2,nth(fix((V9)),VV[12]),(V10));
 
136
        VMR7(V11)}
 
137
        goto T2;
 
138
T2:;
 
139
        V9= number_minus((V9),small_fixnum(4));
 
140
        V10= list(2,VV[13],(V10));
 
141
        goto TTL;
 
142
        return Cnil;
 
143
}
 
144
/*      local entry for function MAKE-CDXR      */
 
145
 
 
146
static object LI8(V14,V15)
 
147
 
 
148
register object V14;object V15;
 
149
{        VMB8 VMS8 VMV8
 
150
        goto TTL;
 
151
TTL:;
 
152
        if(!(number_compare(small_fixnum(0),(V14))==0)){
 
153
        goto T8;}
 
154
        {object V16 = (V15);
 
155
        VMR8(V16)}
 
156
        goto T8;
 
157
T8:;
 
158
        if(!(number_compare((V14),small_fixnum(5))<0)){
 
159
        goto T11;}
 
160
        {object V17 = list(2,nth(fix((V14)),VV[14]),(V15));
 
161
        VMR8(V17)}
 
162
        goto T11;
 
163
T11:;
 
164
        V14= number_minus((V14),small_fixnum(4));
 
165
        V15= list(2,VV[13],(V15));
 
166
        goto TTL;
 
167
        return Cnil;
 
168
}
 
169
/*      function definition for G2005   */
 
170
 
 
171
static void L9()
 
172
{register object *base=vs_base;
 
173
        register object *sup=base+VM9; VC9
 
174
        vs_check;
 
175
        check_arg(0);
 
176
        vs_top=sup;
 
177
        goto TTL;
 
178
TTL:;
 
179
        base[0]= VV[15];
 
180
        vs_top=(vs_base=base+0)+1;
 
181
        return;
 
182
}
 
183
/*      local entry for function TRUE   */
 
184
 
 
185
static object LI10(object first,...)
 
186
{       
 
187
        va_list ap;
 
188
        int narg = VFUN_NARGS; VMB10 VMS10 VMV10
 
189
        {object V18;
 
190
        va_start(ap,first);
 
191
        narg= narg - 0;
 
192
        V19 = list_vector_new(narg,first,ap);
 
193
        V18= V19;
 
194
        {object V20 = Ct;
 
195
        VMR10(V20)}
 
196
        va_end(ap);
 
197
        return Cnil;}
 
198
        }
 
199
/*      local entry for function FALSE  */
 
200
 
 
201
static object LI11(object first,...)
 
202
{       
 
203
        va_list ap;
 
204
        int narg = VFUN_NARGS; VMB11 VMS11 VMV11
 
205
        {object V21;
 
206
        va_start(ap,first);
 
207
        narg= narg - 0;
 
208
        V22 = list_vector_new(narg,first,ap);
 
209
        V21= V22;
 
210
        {object V23 = Cnil;
 
211
        VMR11(V23)}
 
212
        va_end(ap);
 
213
        return Cnil;}
 
214
        }
 
215
/*      local entry for function ZERO   */
 
216
 
 
217
static object LI12(object first,...)
 
218
{       
 
219
        va_list ap;
 
220
        int narg = VFUN_NARGS; VMB12 VMS12 VMV12
 
221
        {object V24;
 
222
        va_start(ap,first);
 
223
        narg= narg - 0;
 
224
        V25 = list_vector_new(narg,first,ap);
 
225
        V24= V25;
 
226
        {object V26 = small_fixnum(0);
 
227
        VMR12(V26)}
 
228
        va_end(ap);
 
229
        return Cnil;}
 
230
        }
 
231
/*      local entry for function MAKE-PLIST     */
 
232
 
 
233
static object LI13(V29,V30)
 
234
 
 
235
object V29;object V30;
 
236
{        VMB13 VMS13 VMV13
 
237
        goto TTL;
 
238
TTL:;
 
239
        if(((V30))!=Cnil){
 
240
        goto T17;}
 
241
        {object V31 = Cnil;
 
242
        VMR13(V31)}
 
243
        goto T17;
 
244
T17:;
 
245
        V32= CMPcar((V29));
 
246
        V33= CMPcar((V30));
 
247
        {object V34 = listA(3,/* INLINE-ARGS */V32,/* INLINE-ARGS */V33,(*(LnkLI125))(CMPcdr((V29)),CMPcdr((V30))));
 
248
        VMR13(V34)}
 
249
        return Cnil;
 
250
}
 
251
/*      local entry for function REMTAIL        */
 
252
 
 
253
static object LI14(V37,V38)
 
254
 
 
255
object V37;object V38;
 
256
{        VMB14 VMS14 VMV14
 
257
        goto TTL;
 
258
TTL:;
 
259
        if(!(((V37))==((V38)))){
 
260
        goto T20;}
 
261
        {object V39 = Cnil;
 
262
        VMR14(V39)}
 
263
        goto T20;
 
264
T20:;
 
265
        V40= CMPcar((V37));
 
266
        V41= (*(LnkLI126))(CMPcdr((V37)),(V38));
 
267
        {object V42 = make_cons(/* INLINE-ARGS */V40,/* INLINE-ARGS */V41);
 
268
        VMR14(V42)}
 
269
        return Cnil;
 
270
}
 
271
/*      macro definition for ONCE-ONLY  */
 
272
 
 
273
static void L15()
 
274
{register object *base=vs_base;
 
275
        register object *sup=base+VM15; VC15
 
276
        vs_check;
 
277
        check_arg(2);
 
278
        vs_top=sup;
 
279
        {object V43=base[0]->c.c_cdr;
 
280
        if(endp(V43))invalid_macro_call();
 
281
        base[2]= (V43->c.c_car);
 
282
        V43=V43->c.c_cdr;
 
283
        base[3]= V43;}
 
284
        {register object V44;
 
285
        register object V45;
 
286
        register object V46;
 
287
        register object V47;
 
288
        vs_base=vs_top;
 
289
        Lgensym();
 
290
        vs_top=sup;
 
291
        V44= vs_base[0];
 
292
        vs_base=vs_top;
 
293
        Lgensym();
 
294
        vs_top=sup;
 
295
        V45= vs_base[0];
 
296
        vs_base=vs_top;
 
297
        Lgensym();
 
298
        vs_top=sup;
 
299
        V46= vs_base[0];
 
300
        V47= Cnil;
 
301
        {register object V48;
 
302
        register object V49;
 
303
        V48= base[2];
 
304
        V49= CMPcar((V48));
 
305
        goto T29;
 
306
T29:;
 
307
        if(!(((V48))==Cnil)){
 
308
        goto T30;}
 
309
        goto T25;
 
310
        goto T30;
 
311
T30:;
 
312
        {register object V50;
 
313
        V51= list(2,VV[18],(V49));
 
314
        V52= list(2,VV[19],(V49));
 
315
        V53= list(2,VV[21],(V49));
 
316
        V54= list(4,VV[17],/* INLINE-ARGS */V51,/* INLINE-ARGS */V52,list(3,VV[20],/* INLINE-ARGS */V53,list(3,VV[0],list(2,VV[22],(V49)),VV[23])));
 
317
        V55= list(2,(V44),VV[25]);
 
318
        V56= make_cons(/* INLINE-ARGS */V55,Cnil);
 
319
        V57= list(3,VV[26],(V44),(V45));
 
320
        V50= list(4,VV[16],/* INLINE-ARGS */V54,(V49),list(5,VV[24],/* INLINE-ARGS */V56,/* INLINE-ARGS */V57,list(3,VV[26],(V49),(V46)),(V44)));
 
321
        V47= make_cons((V50),(V47));}
 
322
        V48= CMPcdr((V48));
 
323
        V49= CMPcar((V48));
 
324
        goto T29;}
 
325
        goto T25;
 
326
T25:;
 
327
        V62= reverse((V47));
 
328
        {object V59;
 
329
        object V60= base[2];
 
330
        object V61= /* INLINE-ARGS */V62;
 
331
        if(V60==Cnil||V61==Cnil){
 
332
        V58= Cnil;
 
333
        goto T42;}
 
334
        base[4]=V59=MMcons(Cnil,Cnil);
 
335
        goto T43;
 
336
T43:;
 
337
        (V59->c.c_car)= list(2,(V60->c.c_car),(V61->c.c_car));
 
338
        if((V60=MMcdr(V60))==Cnil||(V61=MMcdr(V61))==Cnil){
 
339
        V58= base[4];
 
340
        goto T42;}
 
341
        V59=MMcdr(V59)=MMcons(Cnil,Cnil);
 
342
        goto T43;}
 
343
        goto T42;
 
344
T42:;
 
345
        V63= list(3,(V45),(V46),list(2,VV[28],listA(3,VV[24],V58,base[3])));
 
346
        V64= list(2,VV[33],(V45));
 
347
        base[4]= list(3,VV[27],/* INLINE-ARGS */V63,list(4,VV[29],VV[30],list(4,VV[31],VV[32],/* INLINE-ARGS */V64,list(2,VV[33],(V46))),VV[28]));
 
348
        vs_top=(vs_base=base+4)+1;
 
349
        return;}
 
350
}
 
351
/*      function definition for EXTRACT-DECLARATIONS    */
 
352
 
 
353
static void L16()
 
354
{register object *base=vs_base;
 
355
        register object *sup=base+VM16; VC16
 
356
        vs_check;
 
357
        {register object V65;
 
358
        object V66;
 
359
        if(vs_top-vs_base<1) too_few_arguments();
 
360
        if(vs_top-vs_base>2) too_many_arguments();
 
361
        V65=(base[0]);
 
362
        vs_base=vs_base+1;
 
363
        if(vs_base>=vs_top){vs_top=sup;goto T45;}
 
364
        V66=(base[1]);
 
365
        vs_top=sup;
 
366
        goto T46;
 
367
        goto T45;
 
368
T45:;
 
369
        V66= Cnil;
 
370
        goto T46;
 
371
T46:;
 
372
        {object V67;
 
373
        register object V68;
 
374
        register object V69;
 
375
        V67= Cnil;
 
376
        V68= Cnil;
 
377
        V69= Cnil;
 
378
        if(!(type_of(CMPcar((V65)))==t_string)){
 
379
        goto T48;}
 
380
        if((CMPcdr((V65)))==Cnil){
 
381
        goto T48;}
 
382
        {object V70;
 
383
        V70= CMPcar((V65));
 
384
        V65= CMPcdr((V65));
 
385
        V67= (V70);}
 
386
        goto T48;
 
387
T48:;
 
388
        goto T59;
 
389
T59:;
 
390
        if(((V65))!=Cnil){
 
391
        goto T61;}
 
392
        goto T57;
 
393
        goto T61;
 
394
T61:;
 
395
        V69= CMPcar((V65));
 
396
        goto T69;
 
397
T69:;
 
398
        if(type_of((V69))==t_cons||((V69))==Cnil){
 
399
        goto T72;}
 
400
        goto T57;
 
401
        goto T72;
 
402
T72:;
 
403
        if(!((CMPcar((V69)))==(VV[34]))){
 
404
        goto T75;}
 
405
        goto T67;
 
406
        goto T75;
 
407
T75:;
 
408
        {register object V71;
 
409
        object V72;
 
410
        base[2]= (V69);
 
411
        base[3]= (V66);
 
412
        vs_top=(vs_base=base+2)+2;
 
413
        Lmacroexpand_1();
 
414
        if(vs_base>=vs_top){vs_top=sup;goto T80;}
 
415
        V71= vs_base[0];
 
416
        vs_base++;
 
417
        if(vs_base>=vs_top){vs_top=sup;goto T81;}
 
418
        V72= vs_base[0];
 
419
        vs_top=sup;
 
420
        goto T82;
 
421
        goto T80;
 
422
T80:;
 
423
        V71= Cnil;
 
424
        goto T81;
 
425
T81:;
 
426
        V72= Cnil;
 
427
        goto T82;
 
428
T82:;
 
429
        if(!(((V71))==((V69)))){
 
430
        goto T83;}
 
431
        if(((V72))==Cnil){
 
432
        goto T84;}
 
433
        goto T83;
 
434
T83:;
 
435
        V69= (V71);
 
436
        goto T70;
 
437
        goto T84;
 
438
T84:;
 
439
        goto T57;}
 
440
        goto T70;
 
441
T70:;
 
442
        goto T69;
 
443
        goto T67;
 
444
T67:;
 
445
        {object V73;
 
446
        V73= CMPcar((V65));
 
447
        V65= CMPcdr((V65));}
 
448
        {register object V74;
 
449
        register object V75;
 
450
        V74= CMPcdr((V69));
 
451
        V75= CMPcar((V74));
 
452
        goto T97;
 
453
T97:;
 
454
        if(!(((V74))==Cnil)){
 
455
        goto T98;}
 
456
        goto T60;
 
457
        goto T98;
 
458
T98:;
 
459
        V68= make_cons(V75,(V68));
 
460
        V74= CMPcdr((V74));
 
461
        V75= CMPcar((V74));
 
462
        goto T97;}
 
463
        goto T60;
 
464
T60:;
 
465
        goto T59;
 
466
        goto T57;
 
467
T57:;
 
468
        base[2]= (V67);
 
469
        if((V68)==Cnil){
 
470
        base[3]= Cnil;
 
471
        goto T111;}
 
472
        V77= nreverse((V68));
 
473
        V78= make_cons(VV[34],/* INLINE-ARGS */V77);
 
474
        base[3]= make_cons(/* INLINE-ARGS */V78,Cnil);
 
475
        goto T111;
 
476
T111:;
 
477
        base[4]= (V65);
 
478
        vs_top=(vs_base=base+2)+3;
 
479
        return;}
 
480
        }
 
481
}
 
482
/*      local entry for function GET-DECLARATION        */
 
483
 
 
484
static object LI17(object V80,object V79,object first,...)
 
485
{       
 
486
        va_list ap;
 
487
        int narg = VFUN_NARGS; VMB17 VMS17 VMV17
 
488
        {register object V81;
 
489
        object V82;
 
490
        register object V83;
 
491
        va_start(ap,first);
 
492
        if(narg <2) too_few_arguments();
 
493
        V81= V80;
 
494
        V82= V79;
 
495
        narg = narg - 2;
 
496
        if (narg <= 0) goto T113;
 
497
        else {
 
498
        V83= first;}
 
499
        --narg; goto T114;
 
500
        goto T113;
 
501
T113:;
 
502
        V83= Cnil;
 
503
        goto T114;
 
504
T114:;
 
505
        {register object V84;
 
506
        register object V85;
 
507
        V84= (V82);
 
508
        V85= CMPcar((V84));
 
509
        goto T119;
 
510
T119:;
 
511
        if(!(((V84))==Cnil)){
 
512
        goto T120;}
 
513
        {object V86 = (V83);
 
514
        VMR17(V86)}
 
515
        goto T120;
 
516
T120:;
 
517
        {register object V87;
 
518
        register object V88;
 
519
        V87= CMPcdr((V85));
 
520
        V88= CMPcar((V87));
 
521
        goto T128;
 
522
T128:;
 
523
        if(!(((V87))==Cnil)){
 
524
        goto T129;}
 
525
        goto T124;
 
526
        goto T129;
 
527
T129:;
 
528
        if(!(type_of((V88))==t_cons)){
 
529
        goto T133;}
 
530
        if(!((CMPcar((V88)))==((V81)))){
 
531
        goto T133;}
 
532
        {object V89 = CMPcdr((V88));
 
533
        VMR17(V89)}
 
534
        goto T133;
 
535
T133:;
 
536
        V87= CMPcdr((V87));
 
537
        V88= CMPcar((V87));
 
538
        goto T128;}
 
539
        goto T124;
 
540
T124:;
 
541
        V84= CMPcdr((V84));
 
542
        V85= CMPcar((V84));
 
543
        goto T119;}
 
544
        va_end(ap);
 
545
        base[0]=base[0];
 
546
        return Cnil;}
 
547
        }
 
548
/*      function definition for MAKE-KEYWORD    */
 
549
 
 
550
static void L18()
 
551
{register object *base=vs_base;
 
552
        register object *sup=base+VM18; VC18
 
553
        vs_check;
 
554
        {object V90;
 
555
        check_arg(1);
 
556
        V90=(base[0]);
 
557
        vs_top=sup;
 
558
        goto TTL;
 
559
TTL:;
 
560
        base[1]= symbol_name((V90));
 
561
        base[2]= (VV[35]->s.s_dbind);
 
562
        vs_top=(vs_base=base+1)+2;
 
563
        Lintern();
 
564
        return;
 
565
        }
 
566
}
 
567
/*      local entry for function STRING-APPEND  */
 
568
 
 
569
static object LI19(object first,...)
 
570
{       
 
571
        va_list ap;
 
572
        int narg = VFUN_NARGS; VMB19 VMS19 VMV19
 
573
        {register object V91;
 
574
        va_start(ap,first);
 
575
        narg= narg - 0;
 
576
        V92 = list_vector_new(narg,first,ap);
 
577
        V91= V92;
 
578
        base[0]= (V91);
 
579
        vs_top=(vs_base=base+0)+1;
 
580
        Lcopy_list();
 
581
        vs_top=sup;
 
582
        V91= vs_base[0];
 
583
        {register object V93;
 
584
        V93= (V91);
 
585
        goto T154;
 
586
T154:;
 
587
        if(((V93))!=Cnil){
 
588
        goto T155;}
 
589
        base[0]=VV[127]->s.s_gfdef;
 
590
        base[1]= VV[36];
 
591
        {object V94;
 
592
        V94= (V91);
 
593
         vs_top=base+2;
 
594
         while(V94!=Cnil)
 
595
         {vs_push((V94)->c.c_car);V94=(V94)->c.c_cdr;}
 
596
        vs_base=base+1;}
 
597
        (void) (*Lnk127)();
 
598
        vs_top=sup;
 
599
        {object V95 = vs_base[0];
 
600
        VMR19(V95)}
 
601
        goto T155;
 
602
T155:;
 
603
        V96= coerce_to_string(CMPcar((V93)));
 
604
        ((V93))->c.c_car = /* INLINE-ARGS */V96;
 
605
        V93= CMPcdr((V93));
 
606
        goto T154;}
 
607
        va_end(ap);
 
608
        base[0]=base[0];
 
609
        return Cnil;}
 
610
        }
 
611
/*      function definition for SYMBOL-APPEND   */
 
612
 
 
613
static void L20()
 
614
{register object *base=vs_base;
 
615
        register object *sup=base+VM20; VC20
 
616
        vs_check;
 
617
        {object V97;
 
618
        object V98;
 
619
        object V99;
 
620
        if(vs_top-vs_base<2) too_few_arguments();
 
621
        if(vs_top-vs_base>3) too_many_arguments();
 
622
        V97=(base[0]);
 
623
        V98=(base[1]);
 
624
        vs_base=vs_base+2;
 
625
        if(vs_base>=vs_top){vs_top=sup;goto T165;}
 
626
        V99=(base[2]);
 
627
        vs_top=sup;
 
628
        goto T166;
 
629
        goto T165;
 
630
T165:;
 
631
        V99= (VV[37]->s.s_dbind);
 
632
        goto T166;
 
633
T166:;
 
634
        base[3]= (VFUN_NARGS=2,(*(LnkLI128))((V97),(V98)));
 
635
        base[4]= (V99);
 
636
        vs_top=(vs_base=base+3)+2;
 
637
        Lintern();
 
638
        return;
 
639
        }
 
640
}
 
641
/*      macro definition for CHECK-MEMBER       */
 
642
 
 
643
static void L21()
 
644
{register object *base=vs_base;
 
645
        register object *sup=base+VM21; VC21
 
646
        vs_check;
 
647
        check_arg(2);
 
648
        vs_top=sup;
 
649
        {object V100=base[0]->c.c_cdr;
 
650
        if(endp(V100))invalid_macro_call();
 
651
        base[2]= (V100->c.c_car);
 
652
        V100=V100->c.c_cdr;
 
653
        if(endp(V100))invalid_macro_call();
 
654
        base[3]= (V100->c.c_car);
 
655
        V100=V100->c.c_cdr;
 
656
        {object V101=getf(V100,VV[39],OBJNULL);
 
657
        if(V101==OBJNULL){
 
658
        base[4]= (VV[129]->s.s_gfdef);} else {
 
659
        base[4]= V101;
 
660
        }}
 
661
        {object V102=getf(V100,VV[130],OBJNULL);
 
662
        if(V102==OBJNULL){
 
663
        base[5]= base[2];} else {
 
664
        base[5]= V102;
 
665
        }}
 
666
        check_other_key(V100,2,VV[39],VV[130]);}
 
667
        {register object V103;
 
668
        register object V104;
 
669
        object V105;
 
670
        V103= Cnil;
 
671
        V104= Cnil;
 
672
        {object V106;
 
673
        object V107;
 
674
        if(type_of(base[2])==t_symbol){
 
675
        goto T176;}
 
676
        if(type_of(base[2])==t_fixnum||
 
677
type_of(base[2])==t_bignum||
 
678
type_of(base[2])==t_ratio||
 
679
type_of(base[2])==t_shortfloat||
 
680
type_of(base[2])==t_longfloat||
 
681
type_of(base[2])==t_complex){
 
682
        goto T176;}
 
683
        if(!(type_of(base[2])==t_cons||(base[2])==Cnil)){
 
684
        goto T177;}
 
685
        {register object x= CMPcar(base[2]),V108= VV[38];
 
686
        while(V108!=Cnil)
 
687
        if(eql(x,V108->c.c_car)){
 
688
        goto T184;
 
689
        }else V108=V108->c.c_cdr;
 
690
        goto T177;}
 
691
        goto T184;
 
692
T184:;
 
693
        goto T176;
 
694
T176:;
 
695
        V106= base[2];
 
696
        goto T175;
 
697
        goto T177;
 
698
T177:;
 
699
        {object V109;
 
700
        vs_base=vs_top;
 
701
        Lgensym();
 
702
        vs_top=sup;
 
703
        V109= vs_base[0];
 
704
        V103= make_cons(V109,(V103));
 
705
        V104= make_cons(base[2],(V104));
 
706
        V106= (V109);}
 
707
        goto T175;
 
708
T175:;
 
709
        if(type_of(base[3])==t_symbol){
 
710
        goto T191;}
 
711
        if(type_of(base[3])==t_fixnum||
 
712
type_of(base[3])==t_bignum||
 
713
type_of(base[3])==t_ratio||
 
714
type_of(base[3])==t_shortfloat||
 
715
type_of(base[3])==t_longfloat||
 
716
type_of(base[3])==t_complex){
 
717
        goto T191;}
 
718
        if(!(type_of(base[3])==t_cons||(base[3])==Cnil)){
 
719
        goto T192;}
 
720
        {register object x= CMPcar(base[3]),V112= VV[38];
 
721
        while(V112!=Cnil)
 
722
        if(eql(x,V112->c.c_car)){
 
723
        goto T199;
 
724
        }else V112=V112->c.c_cdr;
 
725
        goto T192;}
 
726
        goto T199;
 
727
T199:;
 
728
        goto T191;
 
729
T191:;
 
730
        V107= base[3];
 
731
        goto T190;
 
732
        goto T192;
 
733
T192:;
 
734
        {object V113;
 
735
        vs_base=vs_top;
 
736
        Lgensym();
 
737
        vs_top=sup;
 
738
        V113= vs_base[0];
 
739
        V103= make_cons(V113,(V103));
 
740
        V104= make_cons(base[3],(V104));
 
741
        V107= (V113);}
 
742
        goto T190;
 
743
T190:;
 
744
        V116= list(5,VV[0],(V106),(V107),VV[39],base[4]);
 
745
        V105= list(3,VV[17],/* INLINE-ARGS */V116,list(5,VV[40],VV[41],list(2,VV[42],base[5]),(V106),(V107)));}
 
746
        V121= reverse((V103));
 
747
        V122= reverse((V104));
 
748
        {object V118;
 
749
        object V119= /* INLINE-ARGS */V121;
 
750
        object V120= /* INLINE-ARGS */V122;
 
751
        if(V119==Cnil||V120==Cnil){
 
752
        V117= Cnil;
 
753
        goto T205;}
 
754
        base[7]=V118=MMcons(Cnil,Cnil);
 
755
        goto T206;
 
756
T206:;
 
757
        (V118->c.c_car)= list(2,(V119->c.c_car),(V120->c.c_car));
 
758
        if((V119=MMcdr(V119))==Cnil||(V120=MMcdr(V120))==Cnil){
 
759
        V117= base[7];
 
760
        goto T205;}
 
761
        V118=MMcdr(V118)=MMcons(Cnil,Cnil);
 
762
        goto T206;}
 
763
        goto T205;
 
764
T205:;
 
765
        base[7]= list(3,VV[24],V117,(V105));
 
766
        vs_top=(vs_base=base+7)+1;
 
767
        return;}
 
768
}
 
769
/*      macro definition for ALIST-ENTRY        */
 
770
 
 
771
static void L22()
 
772
{register object *base=vs_base;
 
773
        register object *sup=base+VM22; VC22
 
774
        vs_check;
 
775
        check_arg(2);
 
776
        vs_top=sup;
 
777
        {object V123=base[0]->c.c_cdr;
 
778
        if(endp(V123))invalid_macro_call();
 
779
        base[2]= (V123->c.c_car);
 
780
        V123=V123->c.c_cdr;
 
781
        if(endp(V123))invalid_macro_call();
 
782
        base[3]= (V123->c.c_car);
 
783
        V123=V123->c.c_cdr;
 
784
        if(endp(V123))invalid_macro_call();
 
785
        base[4]= (V123->c.c_car);
 
786
        V123=V123->c.c_cdr;
 
787
        if(!endp(V123))invalid_macro_call();}
 
788
        {register object V124;
 
789
        register object V125;
 
790
        object V126;
 
791
        V124= Cnil;
 
792
        V125= Cnil;
 
793
        {register object V127;
 
794
        object V128;
 
795
        if(type_of(base[2])==t_symbol){
 
796
        goto T212;}
 
797
        if(type_of(base[2])==t_fixnum||
 
798
type_of(base[2])==t_bignum||
 
799
type_of(base[2])==t_ratio||
 
800
type_of(base[2])==t_shortfloat||
 
801
type_of(base[2])==t_longfloat||
 
802
type_of(base[2])==t_complex){
 
803
        goto T212;}
 
804
        if(!(type_of(base[2])==t_cons||(base[2])==Cnil)){
 
805
        goto T213;}
 
806
        {register object x= CMPcar(base[2]),V129= VV[38];
 
807
        while(V129!=Cnil)
 
808
        if(eql(x,V129->c.c_car)){
 
809
        goto T220;
 
810
        }else V129=V129->c.c_cdr;
 
811
        goto T213;}
 
812
        goto T220;
 
813
T220:;
 
814
        goto T212;
 
815
T212:;
 
816
        V127= base[2];
 
817
        goto T211;
 
818
        goto T213;
 
819
T213:;
 
820
        {object V130;
 
821
        vs_base=vs_top;
 
822
        Lgensym();
 
823
        vs_top=sup;
 
824
        V130= vs_base[0];
 
825
        V124= make_cons(V130,(V124));
 
826
        V125= make_cons(base[2],(V125));
 
827
        V127= (V130);}
 
828
        goto T211;
 
829
T211:;
 
830
        if(type_of(base[3])==t_symbol){
 
831
        goto T227;}
 
832
        if(type_of(base[3])==t_fixnum||
 
833
type_of(base[3])==t_bignum||
 
834
type_of(base[3])==t_ratio||
 
835
type_of(base[3])==t_shortfloat||
 
836
type_of(base[3])==t_longfloat||
 
837
type_of(base[3])==t_complex){
 
838
        goto T227;}
 
839
        if(!(type_of(base[3])==t_cons||(base[3])==Cnil)){
 
840
        goto T228;}
 
841
        {register object x= CMPcar(base[3]),V133= VV[38];
 
842
        while(V133!=Cnil)
 
843
        if(eql(x,V133->c.c_car)){
 
844
        goto T235;
 
845
        }else V133=V133->c.c_cdr;
 
846
        goto T228;}
 
847
        goto T235;
 
848
T235:;
 
849
        goto T227;
 
850
T227:;
 
851
        V128= base[3];
 
852
        goto T226;
 
853
        goto T228;
 
854
T228:;
 
855
        {object V134;
 
856
        vs_base=vs_top;
 
857
        Lgensym();
 
858
        vs_top=sup;
 
859
        V134= vs_base[0];
 
860
        V124= make_cons(V134,(V124));
 
861
        V125= make_cons(base[3],(V125));
 
862
        V128= (V134);}
 
863
        goto T226;
 
864
T226:;
 
865
        V137= list(3,VV[43],(V128),(V127));
 
866
        V138= list(3,VV[45],(V127),list(3,VV[46],list(2,base[4],(V128)),(V127)));
 
867
        V126= list(3,VV[17],/* INLINE-ARGS */V137,list(3,VV[44],/* INLINE-ARGS */V138,list(2,VV[22],(V127))));}
 
868
        V143= reverse((V124));
 
869
        V144= reverse((V125));
 
870
        {object V140;
 
871
        object V141= /* INLINE-ARGS */V143;
 
872
        object V142= /* INLINE-ARGS */V144;
 
873
        if(V141==Cnil||V142==Cnil){
 
874
        V139= Cnil;
 
875
        goto T241;}
 
876
        base[6]=V140=MMcons(Cnil,Cnil);
 
877
        goto T242;
 
878
T242:;
 
879
        (V140->c.c_car)= list(2,(V141->c.c_car),(V142->c.c_car));
 
880
        if((V141=MMcdr(V141))==Cnil||(V142=MMcdr(V142))==Cnil){
 
881
        V139= base[6];
 
882
        goto T241;}
 
883
        V140=MMcdr(V140)=MMcons(Cnil,Cnil);
 
884
        goto T242;}
 
885
        goto T241;
 
886
T241:;
 
887
        base[6]= list(3,VV[24],V139,(V126));
 
888
        vs_top=(vs_base=base+6)+1;
 
889
        return;}
 
890
}
 
891
/*      macro definition for PCL-DESTRUCTURING-BIND     */
 
892
 
 
893
static void L23()
 
894
{register object *base=vs_base;
 
895
        register object *sup=base+VM23; VC23
 
896
        vs_check;
 
897
        check_arg(2);
 
898
        vs_top=sup;
 
899
        {object V145=base[0]->c.c_cdr;
 
900
        if(endp(V145))invalid_macro_call();
 
901
        base[2]= (V145->c.c_car);
 
902
        V145=V145->c.c_cdr;
 
903
        if(endp(V145))invalid_macro_call();
 
904
        base[3]= (V145->c.c_car);
 
905
        V145=V145->c.c_cdr;
 
906
        base[4]= V145;}
 
907
        {object V146;
 
908
        object V147;
 
909
        object V148;
 
910
        base[5]= base[4];
 
911
        vs_top=(vs_base=base+5)+1;
 
912
        (void) (*Lnk131)();
 
913
        if(vs_base>=vs_top){vs_top=sup;goto T246;}
 
914
        V146= vs_base[0];
 
915
        vs_base++;
 
916
        if(vs_base>=vs_top){vs_top=sup;goto T247;}
 
917
        V147= vs_base[0];
 
918
        vs_base++;
 
919
        if(vs_base>=vs_top){vs_top=sup;goto T248;}
 
920
        V148= vs_base[0];
 
921
        vs_top=sup;
 
922
        goto T249;
 
923
        goto T246;
 
924
T246:;
 
925
        V146= Cnil;
 
926
        goto T247;
 
927
T247:;
 
928
        V147= Cnil;
 
929
        goto T248;
 
930
T248:;
 
931
        V148= Cnil;
 
932
        goto T249;
 
933
T249:;
 
934
        {object V149;
 
935
        object V150;
 
936
        base[5]= base[2];
 
937
        base[6]= base[3];
 
938
        vs_top=(vs_base=base+5)+2;
 
939
        (void) (*Lnk132)();
 
940
        if(vs_base>=vs_top){vs_top=sup;goto T253;}
 
941
        V149= vs_base[0];
 
942
        vs_base++;
 
943
        if(vs_base>=vs_top){vs_top=sup;goto T254;}
 
944
        V150= vs_base[0];
 
945
        vs_top=sup;
 
946
        goto T255;
 
947
        goto T253;
 
948
T253:;
 
949
        V149= Cnil;
 
950
        goto T254;
 
951
T254:;
 
952
        V150= Cnil;
 
953
        goto T255;
 
954
T255:;
 
955
        base[5]= (V147);
 
956
        base[6]= (V149);
 
957
        base[7]= make_cons(VV[47],(V148));
 
958
        vs_top=(vs_base=base+5)+3;
 
959
        Lappend();
 
960
        vs_top=sup;
 
961
        V151= vs_base[0];
 
962
        base[5]= listA(3,VV[24],(V150),V151);
 
963
        vs_top=(vs_base=base+5)+1;
 
964
        return;}}
 
965
}
 
966
/*      function definition for DESTRUCTURE     */
 
967
 
 
968
static void L24()
 
969
{register object *base=vs_base;
 
970
        register object *sup=base+VM24; VC24
 
971
        vs_check;
 
972
        bds_check;
 
973
        {object V152;
 
974
        object V153;
 
975
        check_arg(2);
 
976
        V152=(base[0]);
 
977
        V153=(base[1]);
 
978
        vs_top=sup;
 
979
        goto TTL;
 
980
TTL:;
 
981
        {object V154;
 
982
        bds_bind(VV[48],Cnil);
 
983
        V154= Cnil;
 
984
        (VV[48]->s.s_dbind)= VV[49];
 
985
        V155= list(3,VV[50],VV[51],(V153));
 
986
        V154= make_cons(/* INLINE-ARGS */V155,Cnil);
 
987
        V153= VV[51];
 
988
        V156= (*(LnkLI133))((V152),(V153));
 
989
        V157= nreverse(/* INLINE-ARGS */V156);
 
990
        base[3]= nconc((V154),/* INLINE-ARGS */V157);
 
991
        base[5]= Cnil;
 
992
        base[6]= (VV[48]->s.s_dbind);
 
993
        vs_top=(vs_base=base+5)+2;
 
994
        (void) (*Lnk6)();
 
995
        vs_top=sup;
 
996
        base[4]= vs_base[0];
 
997
        vs_top=(vs_base=base+3)+2;
 
998
        bds_unwind1;
 
999
        return;}
 
1000
        }
 
1001
}
 
1002
/*      local entry for function DESTRUCTURE-INTERNAL   */
 
1003
 
 
1004
static object LI25(V160,V161)
 
1005
 
 
1006
object V160;register object V161;
 
1007
{        VMB25 VMS25 VMV25
 
1008
        goto TTL;
 
1009
TTL:;
 
1010
        {object V162;
 
1011
        register object V163;
 
1012
        register object V164;
 
1013
        vs_base=vs_top;
 
1014
        Lgensym();
 
1015
        vs_top=sup;
 
1016
        V162= vs_base[0];
 
1017
        base[0]= small_fixnum(0);
 
1018
        V163= Cnil;
 
1019
        V164= Cnil;
 
1020
        {register object V165;
 
1021
        V165= (V160);
 
1022
        goto T273;
 
1023
T273:;
 
1024
        if(((V165))!=Cnil){
 
1025
        goto T274;}
 
1026
        goto T271;
 
1027
        goto T274;
 
1028
T274:;
 
1029
        V163= CMPcar((V165));
 
1030
        if(!(type_of((V163))==t_symbol)){
 
1031
        goto T280;}
 
1032
        {register object x= (V163),V166= VV[52];
 
1033
        while(V166!=Cnil)
 
1034
        if(x==(V166->c.c_car)){
 
1035
        goto T283;
 
1036
        }else V166=V166->c.c_cdr;}
 
1037
        (VV[48]->s.s_dbind)= make_cons(V163,(VV[48]->s.s_dbind));
 
1038
        goto T283;
 
1039
T283:;
 
1040
        if((CMPcdr((V165)))!=Cnil){
 
1041
        goto T288;}
 
1042
        {object V168;
 
1043
        base[2]= (V163);
 
1044
        base[3]= (V161);
 
1045
        base[4]= Cnil;
 
1046
        vs_top=(vs_base=base+2)+3;
 
1047
        L26(base);
 
1048
        vs_top=sup;
 
1049
        V168= vs_base[0];
 
1050
        V164= make_cons((V168),(V164));
 
1051
        goto T278;}
 
1052
        goto T288;
 
1053
T288:;
 
1054
        if(!(type_of(CMPcdr((V165)))==t_symbol)){
 
1055
        goto T296;}
 
1056
        {object V169;
 
1057
        base[2]= (V163);
 
1058
        base[3]= (V161);
 
1059
        base[4]= CMPcdr((V165));
 
1060
        vs_top=(vs_base=base+2)+3;
 
1061
        L26(base);
 
1062
        vs_top=sup;
 
1063
        V169= vs_base[0];
 
1064
        V164= make_cons((V169),(V164));}
 
1065
        {object V170;
 
1066
        V170= CMPcdr((V165));
 
1067
        (VV[48]->s.s_dbind)= make_cons((V170),(VV[48]->s.s_dbind));}
 
1068
        goto T271;
 
1069
        goto T296;
 
1070
T296:;
 
1071
        {register object x= (V163),V171= VV[53];
 
1072
        while(V171!=Cnil)
 
1073
        if(x==(V171->c.c_car)){
 
1074
        goto T309;
 
1075
        }else V171=V171->c.c_cdr;
 
1076
        goto T308;}
 
1077
        goto T309;
 
1078
T309:;
 
1079
        base[0]= number_plus(base[0],small_fixnum(1));
 
1080
        goto T278;
 
1081
        goto T308;
 
1082
T308:;
 
1083
        {register object x= CMPcadr((V165)),V172= VV[54];
 
1084
        while(V172!=Cnil)
 
1085
        if(x==(V172->c.c_car)){
 
1086
        goto T313;
 
1087
        }else V172=V172->c.c_cdr;
 
1088
        goto T312;}
 
1089
        goto T313;
 
1090
T313:;
 
1091
        {object V173;
 
1092
        base[2]= (V163);
 
1093
        base[3]= (V161);
 
1094
        base[4]= Cnil;
 
1095
        vs_top=(vs_base=base+2)+3;
 
1096
        L26(base);
 
1097
        vs_top=sup;
 
1098
        V173= vs_base[0];
 
1099
        V164= make_cons((V173),(V164));}
 
1100
        base[0]= number_plus(base[0],small_fixnum(1));
 
1101
        goto T278;
 
1102
        goto T312;
 
1103
T312:;
 
1104
        {object V174;
 
1105
        base[2]= (V163);
 
1106
        base[3]= (V161);
 
1107
        base[4]= (V161);
 
1108
        vs_top=(vs_base=base+2)+3;
 
1109
        L26(base);
 
1110
        vs_top=sup;
 
1111
        V174= vs_base[0];
 
1112
        V164= make_cons((V174),(V164));
 
1113
        goto T278;}
 
1114
        goto T280;
 
1115
T280:;
 
1116
        {object V175;
 
1117
        V176= list(2,(V162),Cnil);
 
1118
        V177= make_cons(/* INLINE-ARGS */V176,Cnil);
 
1119
        base[2]= (V162);
 
1120
        base[3]= (V161);
 
1121
        if(!(type_of(CMPcdr((V165)))==t_symbol)){
 
1122
        goto T333;}
 
1123
        base[4]= CMPcdr((V165));
 
1124
        goto T331;
 
1125
        goto T333;
 
1126
T333:;
 
1127
        base[4]= (V161);
 
1128
        goto T331;
 
1129
T331:;
 
1130
        vs_top=(vs_base=base+2)+3;
 
1131
        L26(base);
 
1132
        vs_top=sup;
 
1133
        V178= vs_base[0];
 
1134
        if(!(type_of((V165))==t_cons)){
 
1135
        goto T337;}
 
1136
        V179= CMPcar((V165));
 
1137
        goto T335;
 
1138
        goto T337;
 
1139
T337:;
 
1140
        V179= (V165);
 
1141
        goto T335;
 
1142
T335:;
 
1143
        V180= (*(LnkLI133))(V179,(V162));
 
1144
        V175= listA(4,VV[24],/* INLINE-ARGS */V177,V178,nreverse(/* INLINE-ARGS */V180));
 
1145
        V164= make_cons((V175),(V164));}
 
1146
        if(!(type_of(CMPcdr((V165)))==t_symbol)){
 
1147
        goto T278;}
 
1148
        {object V181;
 
1149
        V181= CMPcdr((V165));
 
1150
        (VV[48]->s.s_dbind)= make_cons((V181),(VV[48]->s.s_dbind));}
 
1151
        goto T271;
 
1152
        goto T278;
 
1153
T278:;
 
1154
        V165= CMPcdr((V165));
 
1155
        goto T273;}
 
1156
        goto T271;
 
1157
T271:;
 
1158
        {object V182 = (V164);
 
1159
        VMR25(V182)}}
 
1160
        base[0]=base[0];
 
1161
        return Cnil;
 
1162
}
 
1163
/*      macro definition for COLLECTING-ONCE    */
 
1164
 
 
1165
static void L27()
 
1166
{register object *base=vs_base;
 
1167
        register object *sup=base+VM26; VC26
 
1168
        vs_check;
 
1169
        check_arg(2);
 
1170
        vs_top=sup;
 
1171
        {object V183=base[0]->c.c_cdr;
 
1172
        {object V184=getf(V183,VV[134],OBJNULL);
 
1173
        if(V184==OBJNULL){
 
1174
        base[2]= Cnil;} else {
 
1175
        base[2]= V184;
 
1176
        }}
 
1177
        check_other_key(V183,1,VV[134]);}
 
1178
        V185= list(2,VV[57],base[2]);
 
1179
        if(base[2]==Cnil){
 
1180
        V186= Cnil;
 
1181
        goto T349;}
 
1182
        V186= VV[59];
 
1183
        goto T349;
 
1184
T349:;
 
1185
        base[3]= list(3,VV[27],list(2,/* INLINE-ARGS */V185,list(2,VV[58],V186)),VV[60]);
 
1186
        vs_top=(vs_base=base+3)+1;
 
1187
        return;
 
1188
}
 
1189
/*      macro definition for DOPLIST    */
 
1190
 
 
1191
static void L28()
 
1192
{register object *base=vs_base;
 
1193
        register object *sup=base+VM27; VC27
 
1194
        vs_check;
 
1195
        check_arg(2);
 
1196
        vs_top=sup;
 
1197
        {object V187=base[0]->c.c_cdr;
 
1198
        if(endp(V187))invalid_macro_call();
 
1199
        {object V188= (V187->c.c_car);
 
1200
        if(endp(V188))invalid_macro_call();
 
1201
        base[2]= (V188->c.c_car);
 
1202
        V188=V188->c.c_cdr;
 
1203
        if(endp(V188))invalid_macro_call();
 
1204
        base[3]= (V188->c.c_car);
 
1205
        V188=V188->c.c_cdr;
 
1206
        if(!endp(V188))invalid_macro_call();}
 
1207
        V187=V187->c.c_cdr;
 
1208
        if(endp(V187))invalid_macro_call();
 
1209
        base[4]= (V187->c.c_car);
 
1210
        V187=V187->c.c_cdr;
 
1211
        base[5]= V187;}
 
1212
        {object V189;
 
1213
        object V190;
 
1214
        object V191;
 
1215
        base[6]= base[5];
 
1216
        base[7]= base[1];
 
1217
        vs_top=(vs_base=base+6)+2;
 
1218
        (void) (*Lnk131)();
 
1219
        if(vs_base>=vs_top){vs_top=sup;goto T353;}
 
1220
        V189= vs_base[0];
 
1221
        vs_base++;
 
1222
        if(vs_base>=vs_top){vs_top=sup;goto T354;}
 
1223
        V190= vs_base[0];
 
1224
        vs_base++;
 
1225
        if(vs_base>=vs_top){vs_top=sup;goto T355;}
 
1226
        V191= vs_base[0];
 
1227
        vs_top=sup;
 
1228
        goto T356;
 
1229
        goto T353;
 
1230
T353:;
 
1231
        V189= Cnil;
 
1232
        goto T354;
 
1233
T354:;
 
1234
        V190= Cnil;
 
1235
        goto T355;
 
1236
T355:;
 
1237
        V191= Cnil;
 
1238
        goto T356;
 
1239
T356:;
 
1240
        V192= list(3,list(2,VV[61],base[4]),base[2],base[3]);
 
1241
        V193= list(3,VV[50],base[2],VV[64]);
 
1242
        V194= list(3,VV[66],list(2,VV[10],list(2,VV[18],base[2])),VV[67]);
 
1243
        V195= list(3,VV[50],base[3],VV[68]);
 
1244
        V196= list(7,VV[62],VV[63],/* INLINE-ARGS */V193,VV[65],/* INLINE-ARGS */V194,/* INLINE-ARGS */V195,make_cons(VV[44],(V191)));
 
1245
        V197= make_cons(/* INLINE-ARGS */V196,Cnil);
 
1246
        base[6]= listA(3,VV[24],/* INLINE-ARGS */V192,append((V190),/* INLINE-ARGS */V197));
 
1247
        vs_top=(vs_base=base+6)+1;
 
1248
        return;}
 
1249
}
 
1250
/*      macro definition for IF*        */
 
1251
 
 
1252
static void L29()
 
1253
{register object *base=vs_base;
 
1254
        register object *sup=base+VM28; VC28
 
1255
        vs_check;
 
1256
        check_arg(2);
 
1257
        vs_top=sup;
 
1258
        {object V198=base[0]->c.c_cdr;
 
1259
        if(endp(V198))invalid_macro_call();
 
1260
        base[2]= (V198->c.c_car);
 
1261
        V198=V198->c.c_cdr;
 
1262
        if(endp(V198))invalid_macro_call();
 
1263
        base[3]= (V198->c.c_car);
 
1264
        V198=V198->c.c_cdr;
 
1265
        base[4]= V198;}
 
1266
        base[5]= list(4,VV[16],base[2],base[3],make_cons(VV[44],base[4]));
 
1267
        vs_top=(vs_base=base+5)+1;
 
1268
        return;
 
1269
}
 
1270
/*      macro definition for DOLIST-CAREFULLY   */
 
1271
 
 
1272
static void L30()
 
1273
{register object *base=vs_base;
 
1274
        register object *sup=base+VM29; VC29
 
1275
        vs_check;
 
1276
        check_arg(2);
 
1277
        vs_top=sup;
 
1278
        {object V199=base[0]->c.c_cdr;
 
1279
        if(endp(V199))invalid_macro_call();
 
1280
        {object V200= (V199->c.c_car);
 
1281
        if(endp(V200))invalid_macro_call();
 
1282
        base[2]= (V200->c.c_car);
 
1283
        V200=V200->c.c_cdr;
 
1284
        if(endp(V200))invalid_macro_call();
 
1285
        base[3]= (V200->c.c_car);
 
1286
        V200=V200->c.c_cdr;
 
1287
        if(endp(V200))invalid_macro_call();
 
1288
        base[4]= (V200->c.c_car);
 
1289
        V200=V200->c.c_cdr;
 
1290
        if(!endp(V200))invalid_macro_call();}
 
1291
        V199=V199->c.c_cdr;
 
1292
        base[5]= V199;}
 
1293
        V201= list(2,base[2],Cnil);
 
1294
        V202= list(2,/* INLINE-ARGS */V201,list(2,VV[69],base[3]));
 
1295
        V203= listA(3,VV[44],list(3,VV[50],base[2],VV[72]),base[5]);
 
1296
        base[6]= list(3,VV[24],/* INLINE-ARGS */V202,list(3,VV[62],VV[70],list(4,VV[16],VV[71],/* INLINE-ARGS */V203,make_cons(base[4],Cnil))));
 
1297
        vs_top=(vs_base=base+6)+1;
 
1298
        return;
 
1299
}
 
1300
/*      macro definition for PRINTING-RANDOM-THING      */
 
1301
 
 
1302
static void L31()
 
1303
{register object *base=vs_base;
 
1304
        register object *sup=base+VM30; VC30
 
1305
        vs_check;
 
1306
        check_arg(2);
 
1307
        vs_top=sup;
 
1308
        {object V204=base[0]->c.c_cdr;
 
1309
        if(endp(V204))invalid_macro_call();
 
1310
        {object V205= (V204->c.c_car);
 
1311
        if(endp(V205))invalid_macro_call();
 
1312
        base[2]= (V205->c.c_car);
 
1313
        V205=V205->c.c_cdr;
 
1314
        if(endp(V205))invalid_macro_call();
 
1315
        base[3]= (V205->c.c_car);
 
1316
        V205=V205->c.c_cdr;
 
1317
        if(!endp(V205))invalid_macro_call();}
 
1318
        V204=V204->c.c_cdr;
 
1319
        base[4]= V204;}
 
1320
        {register object V206;
 
1321
        register object V207;
 
1322
        object V208;
 
1323
        V206= Cnil;
 
1324
        V207= Cnil;
 
1325
        {object V209;
 
1326
        register object V210;
 
1327
        if(type_of(base[2])==t_symbol){
 
1328
        goto T361;}
 
1329
        if(type_of(base[2])==t_fixnum||
 
1330
type_of(base[2])==t_bignum||
 
1331
type_of(base[2])==t_ratio||
 
1332
type_of(base[2])==t_shortfloat||
 
1333
type_of(base[2])==t_longfloat||
 
1334
type_of(base[2])==t_complex){
 
1335
        goto T361;}
 
1336
        if(!(type_of(base[2])==t_cons||(base[2])==Cnil)){
 
1337
        goto T362;}
 
1338
        {register object x= CMPcar(base[2]),V211= VV[38];
 
1339
        while(V211!=Cnil)
 
1340
        if(eql(x,V211->c.c_car)){
 
1341
        goto T369;
 
1342
        }else V211=V211->c.c_cdr;
 
1343
        goto T362;}
 
1344
        goto T369;
 
1345
T369:;
 
1346
        goto T361;
 
1347
T361:;
 
1348
        V209= base[2];
 
1349
        goto T360;
 
1350
        goto T362;
 
1351
T362:;
 
1352
        {object V212;
 
1353
        vs_base=vs_top;
 
1354
        Lgensym();
 
1355
        vs_top=sup;
 
1356
        V212= vs_base[0];
 
1357
        V206= make_cons(V212,(V206));
 
1358
        V207= make_cons(base[2],(V207));
 
1359
        V209= (V212);}
 
1360
        goto T360;
 
1361
T360:;
 
1362
        if(type_of(base[3])==t_symbol){
 
1363
        goto T376;}
 
1364
        if(type_of(base[3])==t_fixnum||
 
1365
type_of(base[3])==t_bignum||
 
1366
type_of(base[3])==t_ratio||
 
1367
type_of(base[3])==t_shortfloat||
 
1368
type_of(base[3])==t_longfloat||
 
1369
type_of(base[3])==t_complex){
 
1370
        goto T376;}
 
1371
        if(!(type_of(base[3])==t_cons||(base[3])==Cnil)){
 
1372
        goto T377;}
 
1373
        {register object x= CMPcar(base[3]),V215= VV[38];
 
1374
        while(V215!=Cnil)
 
1375
        if(eql(x,V215->c.c_car)){
 
1376
        goto T384;
 
1377
        }else V215=V215->c.c_cdr;
 
1378
        goto T377;}
 
1379
        goto T384;
 
1380
T384:;
 
1381
        goto T376;
 
1382
T376:;
 
1383
        V210= base[3];
 
1384
        goto T375;
 
1385
        goto T377;
 
1386
T377:;
 
1387
        {object V216;
 
1388
        vs_base=vs_top;
 
1389
        Lgensym();
 
1390
        vs_top=sup;
 
1391
        V216= vs_base[0];
 
1392
        V206= make_cons(V216,(V206));
 
1393
        V207= make_cons(base[3],(V207));
 
1394
        V210= (V216);}
 
1395
        goto T375;
 
1396
T375:;
 
1397
        V219= list(3,VV[73],(V210),VV[74]);
 
1398
        V220= list(3,VV[73],(V210),VV[75]);
 
1399
        V221= list(3,VV[76],(V209),(V210));
 
1400
        V222= list(3,/* INLINE-ARGS */V220,/* INLINE-ARGS */V221,list(3,VV[73],(V210),VV[77]));
 
1401
        V208= listA(3,VV[44],/* INLINE-ARGS */V219,append(base[4],/* INLINE-ARGS */V222));}
 
1402
        V227= reverse((V206));
 
1403
        V228= reverse((V207));
 
1404
        {object V224;
 
1405
        object V225= /* INLINE-ARGS */V227;
 
1406
        object V226= /* INLINE-ARGS */V228;
 
1407
        if(V225==Cnil||V226==Cnil){
 
1408
        V223= Cnil;
 
1409
        goto T390;}
 
1410
        base[6]=V224=MMcons(Cnil,Cnil);
 
1411
        goto T391;
 
1412
T391:;
 
1413
        (V224->c.c_car)= list(2,(V225->c.c_car),(V226->c.c_car));
 
1414
        if((V225=MMcdr(V225))==Cnil||(V226=MMcdr(V226))==Cnil){
 
1415
        V223= base[6];
 
1416
        goto T390;}
 
1417
        V224=MMcdr(V224)=MMcons(Cnil,Cnil);
 
1418
        goto T391;}
 
1419
        goto T390;
 
1420
T390:;
 
1421
        base[6]= list(3,VV[24],V223,(V208));
 
1422
        vs_top=(vs_base=base+6)+1;
 
1423
        return;}
 
1424
}
 
1425
/*      local entry for function PRINTING-RANDOM-THING-INTERNAL */
 
1426
 
 
1427
static object LI32(V231,V232)
 
1428
 
 
1429
object V231;object V232;
 
1430
{        VMB31 VMS31 VMV31
 
1431
        goto TTL;
 
1432
TTL:;
 
1433
        {object V233 = Cnil;
 
1434
        VMR31(V233)}
 
1435
        return Cnil;
 
1436
}
 
1437
/*      local entry for function CAPITALIZE-WORDS       */
 
1438
 
 
1439
static object LI33(object V234,object first,...)
 
1440
{       
 
1441
        va_list ap;
 
1442
        int narg = VFUN_NARGS; VMB32 VMS32 VMV32
 
1443
        {object V235;
 
1444
        register object V236;
 
1445
        va_start(ap,first);
 
1446
        if(narg <1) too_few_arguments();
 
1447
        V235= V234;
 
1448
        narg = narg - 1;
 
1449
        if (narg <= 0) goto T393;
 
1450
        else {
 
1451
        V236= first;}
 
1452
        --narg; goto T394;
 
1453
        goto T393;
 
1454
T393:;
 
1455
        V236= Ct;
 
1456
        goto T394;
 
1457
T394:;
 
1458
        {register object V237;
 
1459
        base[0]= coerce_to_string((V235));
 
1460
        vs_top=(vs_base=base+0)+1;
 
1461
        Lcopy_seq();
 
1462
        vs_top=sup;
 
1463
        V237= vs_base[0];
 
1464
        {register object V238;
 
1465
        register object V239;
 
1466
        register object V240;
 
1467
        register object V241;
 
1468
        V238= Ct;
 
1469
        V239= CMPmake_fixnum((long)((V237))->v.v_fillp);
 
1470
        V240= Cnil;
 
1471
        V241= small_fixnum(0);
 
1472
        goto T403;
 
1473
T403:;
 
1474
        if(!(number_compare((V241),(V239))==0)){
 
1475
        goto T404;}
 
1476
        {object V242 = (V237);
 
1477
        VMR32(V242)}
 
1478
        goto T404;
 
1479
T404:;
 
1480
        V240= elt((V237),fix((V241)));
 
1481
        base[1]= (V240);
 
1482
        vs_top=(vs_base=base+1)+1;
 
1483
        Lboth_case_p();
 
1484
        vs_top=sup;
 
1485
        if((vs_base[0])==Cnil){
 
1486
        goto T412;}
 
1487
        if(((V238))==Cnil){
 
1488
        goto T417;}
 
1489
        base[1]= (V240);
 
1490
        vs_top=(vs_base=base+1)+1;
 
1491
        Llower_case_p();
 
1492
        vs_top=sup;
 
1493
        V238= vs_base[0];
 
1494
        if(((V238))!=Cnil){
 
1495
        goto T419;}
 
1496
        goto T415;
 
1497
        goto T419;
 
1498
T419:;
 
1499
        base[1]= (V240);
 
1500
        vs_top=(vs_base=base+1)+1;
 
1501
        Lchar_upcase();
 
1502
        vs_top=sup;
 
1503
        V243= vs_base[0];
 
1504
        (void)(elt_set((V237),fix((V241)),V243));
 
1505
        goto T415;
 
1506
        goto T417;
 
1507
T417:;
 
1508
        if(((V238))==Cnil){
 
1509
        goto T425;}
 
1510
        goto T415;
 
1511
        goto T425;
 
1512
T425:;
 
1513
        base[1]= (V240);
 
1514
        vs_top=(vs_base=base+1)+1;
 
1515
        Lchar_downcase();
 
1516
        vs_top=sup;
 
1517
        V244= vs_base[0];
 
1518
        (void)(elt_set((V237),fix((V241)),V244));
 
1519
        goto T415;
 
1520
T415:;
 
1521
        V238= Cnil;
 
1522
        goto T410;
 
1523
        goto T412;
 
1524
T412:;
 
1525
        base[1]= (V240);
 
1526
        base[2]= VV[78];
 
1527
        vs_top=(vs_base=base+1)+2;
 
1528
        Lchar_equal();
 
1529
        vs_top=sup;
 
1530
        if((vs_base[0])==Cnil){
 
1531
        goto T431;}
 
1532
        V238= Ct;
 
1533
        if(((V236))!=Cnil){
 
1534
        goto T410;}
 
1535
        (void)(elt_set((V237),fix((V241)),VV[79]));
 
1536
        goto T410;
 
1537
        goto T431;
 
1538
T431:;
 
1539
        V238= Cnil;
 
1540
        goto T410;
 
1541
T410:;
 
1542
        V241= number_plus((V241),small_fixnum(1));
 
1543
        goto T403;}}
 
1544
        va_end(ap);
 
1545
        base[0]=base[0];
 
1546
        return Cnil;}
 
1547
        }
 
1548
/*      macro definition for DEFINE-COMPILER-MACRO      */
 
1549
 
 
1550
static void L34()
 
1551
{register object *base=vs_base;
 
1552
        register object *sup=base+VM33; VC33
 
1553
        vs_check;
 
1554
        check_arg(2);
 
1555
        vs_top=sup;
 
1556
        {object V245=base[0]->c.c_cdr;
 
1557
        if(endp(V245))invalid_macro_call();
 
1558
        base[2]= (V245->c.c_car);
 
1559
        V245=V245->c.c_cdr;
 
1560
        if(endp(V245))invalid_macro_call();
 
1561
        base[3]= (V245->c.c_car);
 
1562
        V245=V245->c.c_cdr;
 
1563
        base[4]= V245;}
 
1564
        base[5]= listA(4,VV[80],base[2],base[3],base[4]);
 
1565
        vs_top=(vs_base=base+5)+1;
 
1566
        return;
 
1567
}
 
1568
/*      local entry for function MAKE-CONSTANT-FUNCTION */
 
1569
 
 
1570
static object LI36(V247)
 
1571
 
 
1572
object V247;
 
1573
{        VMB34 VMS34 VMV34
 
1574
        goto TTL;
 
1575
TTL:;
 
1576
        base[0]=MMcons((V247),Cnil);
 
1577
        {object V248 = 
 
1578
        make_cclosure_new(LC65,Cnil,base[0],Cdata);
 
1579
        VMR34(V248)}
 
1580
        base[0]=base[0];
 
1581
        return Cnil;
 
1582
}
 
1583
/*      local entry for function FUNCTION-RETURNING-NIL */
 
1584
 
 
1585
static object LI37(V250)
 
1586
 
 
1587
object V250;
 
1588
{        VMB35 VMS35 VMV35
 
1589
        goto TTL;
 
1590
TTL:;
 
1591
        {object V251 = Cnil;
 
1592
        VMR35(V251)}
 
1593
        return Cnil;
 
1594
}
 
1595
/*      local entry for function FUNCTION-RETURNING-T   */
 
1596
 
 
1597
static object LI38(V253)
 
1598
 
 
1599
object V253;
 
1600
{        VMB36 VMS36 VMV36
 
1601
        goto TTL;
 
1602
TTL:;
 
1603
        {object V254 = Ct;
 
1604
        VMR36(V254)}
 
1605
        return Cnil;
 
1606
}
 
1607
/*      macro definition for FIND-CLASS-CELL-CLASS      */
 
1608
 
 
1609
static void L39()
 
1610
{register object *base=vs_base;
 
1611
        register object *sup=base+VM37; VC37
 
1612
        vs_check;
 
1613
        check_arg(2);
 
1614
        vs_top=sup;
 
1615
        {object V255=base[0]->c.c_cdr;
 
1616
        if(endp(V255))invalid_macro_call();
 
1617
        base[2]= (V255->c.c_car);
 
1618
        V255=V255->c.c_cdr;
 
1619
        if(!endp(V255))invalid_macro_call();}
 
1620
        base[3]= list(2,VV[22],base[2]);
 
1621
        vs_top=(vs_base=base+3)+1;
 
1622
        return;
 
1623
}
 
1624
/*      macro definition for FIND-CLASS-CELL-PREDICATE  */
 
1625
 
 
1626
static void L40()
 
1627
{register object *base=vs_base;
 
1628
        register object *sup=base+VM38; VC38
 
1629
        vs_check;
 
1630
        check_arg(2);
 
1631
        vs_top=sup;
 
1632
        {object V256=base[0]->c.c_cdr;
 
1633
        if(endp(V256))invalid_macro_call();
 
1634
        base[2]= (V256->c.c_car);
 
1635
        V256=V256->c.c_cdr;
 
1636
        if(!endp(V256))invalid_macro_call();}
 
1637
        base[3]= list(2,VV[81],base[2]);
 
1638
        vs_top=(vs_base=base+3)+1;
 
1639
        return;
 
1640
}
 
1641
/*      macro definition for FIND-CLASS-CELL-MAKE-INSTANCE-FUNCTION-KEYS        */
 
1642
 
 
1643
static void L41()
 
1644
{register object *base=vs_base;
 
1645
        register object *sup=base+VM39; VC39
 
1646
        vs_check;
 
1647
        check_arg(2);
 
1648
        vs_top=sup;
 
1649
        {object V257=base[0]->c.c_cdr;
 
1650
        if(endp(V257))invalid_macro_call();
 
1651
        base[2]= (V257->c.c_car);
 
1652
        V257=V257->c.c_cdr;
 
1653
        if(!endp(V257))invalid_macro_call();}
 
1654
        base[3]= list(2,VV[82],base[2]);
 
1655
        vs_top=(vs_base=base+3)+1;
 
1656
        return;
 
1657
}
 
1658
/*      macro definition for MAKE-FIND-CLASS-CELL       */
 
1659
 
 
1660
static void L42()
 
1661
{register object *base=vs_base;
 
1662
        register object *sup=base+VM40; VC40
 
1663
        vs_check;
 
1664
        check_arg(2);
 
1665
        vs_top=sup;
 
1666
        {object V258=base[0]->c.c_cdr;
 
1667
        if(endp(V258))invalid_macro_call();
 
1668
        base[2]= (V258->c.c_car);
 
1669
        V258=V258->c.c_cdr;
 
1670
        if(!endp(V258))invalid_macro_call();}
 
1671
        base[3]= VV[83];
 
1672
        vs_top=(vs_base=base+3)+1;
 
1673
        return;
 
1674
}
 
1675
/*      local entry for function FIND-CLASS-CELL        */
 
1676
 
 
1677
static object LI43(object V259,object first,...)
 
1678
{       
 
1679
        va_list ap;
 
1680
        int narg = VFUN_NARGS; VMB41 VMS41 VMV41
 
1681
        {register object V260;
 
1682
        object V261;
 
1683
        va_start(ap,first);
 
1684
        if(narg <1) too_few_arguments();
 
1685
        V260= V259;
 
1686
        narg = narg - 1;
 
1687
        if (narg <= 0) goto T449;
 
1688
        else {
 
1689
        V261= first;}
 
1690
        --narg; goto T450;
 
1691
        goto T449;
 
1692
T449:;
 
1693
        V261= Cnil;
 
1694
        goto T450;
 
1695
T450:;{object V262;
 
1696
        base[0]= (V260);
 
1697
        base[1]= (VV[84]->s.s_dbind);
 
1698
        vs_top=(vs_base=base+0)+2;
 
1699
        Lgethash();
 
1700
        vs_top=sup;
 
1701
        V262= vs_base[0];
 
1702
        if(V262==Cnil)goto T452;
 
1703
        {object V263 = V262;
 
1704
        VMR41(V263)}
 
1705
        goto T452;
 
1706
T452:;}
 
1707
        if(((V261))!=Cnil){
 
1708
        goto T457;}
 
1709
        if(((*(LnkLI135))((V260)))!=Cnil){
 
1710
        goto T459;}
 
1711
        base[0]= VV[85];
 
1712
        base[1]= (V260);
 
1713
        vs_top=(vs_base=base+0)+2;
 
1714
        Lerror();
 
1715
        vs_top=sup;
 
1716
        goto T459;
 
1717
T459:;
 
1718
        {object V265;
 
1719
        object V266;
 
1720
        V265= (VV[84]->s.s_dbind);
 
1721
        V267= (VV[136]->s.s_gfdef);
 
1722
        V266= listA(3,Cnil,V267,Cnil);
 
1723
        base[1]= V260;
 
1724
        base[2]= (V265);
 
1725
        base[3]= (V266);
 
1726
        vs_top=(vs_base=base+1)+3;
 
1727
        siLhash_set();
 
1728
        vs_top=sup;
 
1729
        {object V268 = vs_base[0];
 
1730
        VMR41(V268)}}
 
1731
        goto T457;
 
1732
T457:;
 
1733
        {object V269 = Cnil;
 
1734
        VMR41(V269)}
 
1735
        va_end(ap);
 
1736
        base[0]=base[0];
 
1737
        return Cnil;}
 
1738
        }
 
1739
/*      local entry for function FIND-CLASS-FROM-CELL   */
 
1740
 
 
1741
static object LI44(object V271,object V270,object first,...)
 
1742
{       
 
1743
        va_list ap;
 
1744
        int narg = VFUN_NARGS; VMB42 VMS42 VMV42
 
1745
        {register object V272;
 
1746
        object V273;
 
1747
        object V274;
 
1748
        va_start(ap,first);
 
1749
        if(narg <2) too_few_arguments();
 
1750
        V272= V271;
 
1751
        V273= V270;
 
1752
        narg = narg - 2;
 
1753
        if (narg <= 0) goto T470;
 
1754
        else {
 
1755
        V274= first;}
 
1756
        --narg; goto T471;
 
1757
        goto T470;
 
1758
T470:;
 
1759
        V274= Ct;
 
1760
        goto T471;
 
1761
T471:;{object V275;
 
1762
        V275= CMPcar((V273));
 
1763
        if(V275==Cnil)goto T473;
 
1764
        {object V276 = V275;
 
1765
        VMR42(V276)}
 
1766
        goto T473;
 
1767
T473:;}{object V277;
 
1768
        if((VV[86]->s.s_dbind)==Cnil){
 
1769
        V277= Cnil;
 
1770
        goto T476;}
 
1771
        if(((*(LnkLI137))((V272)))!=Cnil){
 
1772
        goto T477;}
 
1773
        V277= Cnil;
 
1774
        goto T476;
 
1775
        goto T477;
 
1776
T477:;
 
1777
        base[0]= (V272);
 
1778
        vs_top=(vs_base=base+0)+1;
 
1779
        (void) (*Lnk138)();
 
1780
        vs_top=sup;
 
1781
        V277= vs_base[0];
 
1782
        goto T476;
 
1783
T476:;
 
1784
        if(V277==Cnil)goto T475;
 
1785
        {object V278 = V277;
 
1786
        VMR42(V278)}
 
1787
        goto T475;
 
1788
T475:;}
 
1789
        if(((V274))!=Cnil){
 
1790
        goto T481;}
 
1791
        {object V279 = Cnil;
 
1792
        VMR42(V279)}
 
1793
        goto T481;
 
1794
T481:;
 
1795
        if(((*(LnkLI135))((V272)))==Cnil){
 
1796
        goto T484;}
 
1797
        base[0]= VV[87];
 
1798
        base[1]= (V272);
 
1799
        vs_top=(vs_base=base+0)+2;
 
1800
        Lerror();
 
1801
        vs_top=sup;
 
1802
        {object V280 = vs_base[0];
 
1803
        VMR42(V280)}
 
1804
        goto T484;
 
1805
T484:;
 
1806
        base[0]= VV[88];
 
1807
        base[1]= (V272);
 
1808
        vs_top=(vs_base=base+0)+2;
 
1809
        Lerror();
 
1810
        vs_top=sup;
 
1811
        {object V281 = vs_base[0];
 
1812
        VMR42(V281)}
 
1813
        va_end(ap);
 
1814
        base[0]=base[0];
 
1815
        return Cnil;}
 
1816
        }
 
1817
/*      local entry for function FIND-CLASS-PREDICATE-FROM-CELL */
 
1818
 
 
1819
static object LI45(object V283,object V282,object first,...)
 
1820
{       
 
1821
        va_list ap;
 
1822
        int narg = VFUN_NARGS; VMB43 VMS43 VMV43
 
1823
        {object V284;
 
1824
        object V285;
 
1825
        object V286;
 
1826
        va_start(ap,first);
 
1827
        if(narg <2) too_few_arguments();
 
1828
        V284= V283;
 
1829
        V285= V282;
 
1830
        narg = narg - 2;
 
1831
        if (narg <= 0) goto T490;
 
1832
        else {
 
1833
        V286= first;}
 
1834
        --narg; goto T491;
 
1835
        goto T490;
 
1836
T490:;
 
1837
        V286= Ct;
 
1838
        goto T491;
 
1839
T491:;
 
1840
        if((CMPcar((V285)))!=Cnil){
 
1841
        goto T493;}
 
1842
        (void)((VFUN_NARGS=3,(*(LnkLI139))((V284),(V285),(V286))));
 
1843
        goto T493;
 
1844
T493:;
 
1845
        {object V287 = CMPcadr((V285));
 
1846
        VMR43(V287)}
 
1847
        va_end(ap);
 
1848
        return Cnil;}
 
1849
        }
 
1850
/*      local entry for function LEGAL-CLASS-NAME-P     */
 
1851
 
 
1852
static object LI46(V289)
 
1853
 
 
1854
object V289;
 
1855
{        VMB44 VMS44 VMV44
 
1856
        goto TTL;
 
1857
TTL:;
 
1858
        {object V290 = (type_of((V289))==t_symbol?Ct:Cnil);
 
1859
        VMR44(V290)}
 
1860
        return Cnil;
 
1861
}
 
1862
/*      local entry for function FIND-CLASS     */
 
1863
 
 
1864
static object LI47(object V291,object first,...)
 
1865
{       
 
1866
        va_list ap;
 
1867
        int narg = VFUN_NARGS; VMB45 VMS45 VMV45
 
1868
        {object V292;
 
1869
        object V293;
 
1870
        object V294;
 
1871
        va_start(ap,first);
 
1872
        if(narg <1) too_few_arguments();
 
1873
        V292= V291;
 
1874
        narg = narg - 1;
 
1875
        if (narg <= 0) goto T496;
 
1876
        else {
 
1877
        V293= first;}
 
1878
        if (--narg <= 0) goto T497;
 
1879
        else {
 
1880
        V294= va_arg(ap,object);}
 
1881
        --narg; goto T498;
 
1882
        goto T496;
 
1883
T496:;
 
1884
        V293= Ct;
 
1885
        goto T497;
 
1886
T497:;
 
1887
        V294= Cnil;
 
1888
        goto T498;
 
1889
T498:;
 
1890
        V295= (VFUN_NARGS=2,(*(LnkLI140))((V292),(V293)));
 
1891
        {object V296 = (VFUN_NARGS=3,(*(LnkLI139))((V292),/* INLINE-ARGS */V295,(V293)));
 
1892
        VMR45(V296)}
 
1893
        va_end(ap);
 
1894
        return Cnil;}
 
1895
        }
 
1896
/*      local entry for function FIND-CLASS-PREDICATE   */
 
1897
 
 
1898
static object LI48(object V297,object first,...)
 
1899
{       
 
1900
        va_list ap;
 
1901
        int narg = VFUN_NARGS; VMB46 VMS46 VMV46
 
1902
        {object V298;
 
1903
        object V299;
 
1904
        object V300;
 
1905
        va_start(ap,first);
 
1906
        if(narg <1) too_few_arguments();
 
1907
        V298= V297;
 
1908
        narg = narg - 1;
 
1909
        if (narg <= 0) goto T501;
 
1910
        else {
 
1911
        V299= first;}
 
1912
        if (--narg <= 0) goto T502;
 
1913
        else {
 
1914
        V300= va_arg(ap,object);}
 
1915
        --narg; goto T503;
 
1916
        goto T501;
 
1917
T501:;
 
1918
        V299= Ct;
 
1919
        goto T502;
 
1920
T502:;
 
1921
        V300= Cnil;
 
1922
        goto T503;
 
1923
T503:;
 
1924
        V301= (VFUN_NARGS=2,(*(LnkLI140))((V298),(V299)));
 
1925
        {object V302 = (VFUN_NARGS=3,(*(LnkLI141))((V298),/* INLINE-ARGS */V301,(V299)));
 
1926
        VMR46(V302)}
 
1927
        va_end(ap);
 
1928
        return Cnil;}
 
1929
        }
 
1930
/*      function definition for G2145   */
 
1931
 
 
1932
static void L49()
 
1933
{register object *base=vs_base;
 
1934
        register object *sup=base+VM47; VC47
 
1935
        vs_check;
 
1936
        {register object V303;
 
1937
        object V304;
 
1938
        object V305;
 
1939
        object V306;
 
1940
        if(vs_top-vs_base<2) too_few_arguments();
 
1941
        if(vs_top-vs_base>4) too_many_arguments();
 
1942
        V303=(base[0]);
 
1943
        V304=(base[1]);
 
1944
        vs_base=vs_base+2;
 
1945
        if(vs_base>=vs_top){vs_top=sup;goto T506;}
 
1946
        V305=(base[2]);
 
1947
        vs_base++;
 
1948
        if(vs_base>=vs_top){vs_top=sup;goto T507;}
 
1949
        V306=(base[3]);
 
1950
        vs_top=sup;
 
1951
        goto T508;
 
1952
        goto T506;
 
1953
T506:;
 
1954
        V305= Cnil;
 
1955
        goto T507;
 
1956
T507:;
 
1957
        V306= Cnil;
 
1958
        goto T508;
 
1959
T508:;
 
1960
        if(((*(LnkLI135))((V304)))==Cnil){
 
1961
        goto T512;}
 
1962
        {object V307;
 
1963
        V307= (VFUN_NARGS=1,(*(LnkLI140))((V304)));
 
1964
        (V307)->c.c_car = V303;
 
1965
        if(((VV[89]->s.s_dbind))==(VV[90])){
 
1966
        goto T518;}
 
1967
        if(!(((VV[89]->s.s_dbind))==(VV[91]))){
 
1968
        goto T517;}
 
1969
        goto T518;
 
1970
T518:;
 
1971
        {object V311;
 
1972
        base[6]= (V303);
 
1973
        vs_top=(vs_base=base+6)+1;
 
1974
        (void) (*Lnk142)(Lclptr142);
 
1975
        vs_top=sup;
 
1976
        base[5]= vs_base[0];
 
1977
        vs_top=(vs_base=base+5)+1;
 
1978
        Lsymbol_function();
 
1979
        vs_top=sup;
 
1980
        V311= vs_base[0];
 
1981
        (CMPcdr(V307))->c.c_car = (V311);
 
1982
        (void)(CMPcdr(V307));}
 
1983
        if(((V303))==Cnil){
 
1984
        goto T517;}
 
1985
        base[4]= (V303);
 
1986
        vs_top=(vs_base=base+4)+1;
 
1987
        (void) (*Lnk143)(Lclptr143);
 
1988
        vs_top=sup;
 
1989
        if((vs_base[0])!=Cnil){
 
1990
        goto T517;}
 
1991
        {register object V312;
 
1992
        register object V313;
 
1993
        V312= CMPcddr((V307));
 
1994
        V313= CMPcar((V312));
 
1995
        goto T535;
 
1996
T535:;
 
1997
        if(!(((V312))==Cnil)){
 
1998
        goto T536;}
 
1999
        goto T517;
 
2000
        goto T536;
 
2001
T536:;
 
2002
        V314= (VFUN_NARGS=4,(*(LnkLI145))((V303),CMPcar((V313)),Cnil,CMPcdr((V313))));
 
2003
        (void)((*(LnkLI144))(/* INLINE-ARGS */V314,VV[92]));
 
2004
        V312= CMPcdr((V312));
 
2005
        V313= CMPcar((V312));
 
2006
        goto T535;}
 
2007
        goto T517;
 
2008
T517:;
 
2009
        base[4]= (V303);
 
2010
        vs_top=(vs_base=base+4)+1;
 
2011
        return;}
 
2012
        goto T512;
 
2013
T512:;
 
2014
        base[4]= VV[93];
 
2015
        base[5]= (V304);
 
2016
        vs_top=(vs_base=base+4)+2;
 
2017
        Lerror();
 
2018
        return;
 
2019
        }
 
2020
}
 
2021
/*      function definition for G2154   */
 
2022
 
 
2023
static void L50()
 
2024
{register object *base=vs_base;
 
2025
        register object *sup=base+VM48; VC48
 
2026
        vs_check;
 
2027
        {object V315;
 
2028
        object V316;
 
2029
        check_arg(2);
 
2030
        V315=(base[0]);
 
2031
        V316=(base[1]);
 
2032
        vs_top=sup;
 
2033
        goto TTL;
 
2034
TTL:;
 
2035
        if(((*(LnkLI135))((V316)))==Cnil){
 
2036
        goto T549;}
 
2037
        {object V317;
 
2038
        V317= (VFUN_NARGS=1,(*(LnkLI140))((V316)));
 
2039
        (CMPcdr((V317)))->c.c_car = V315;
 
2040
        (void)(CMPcdr((V317)));
 
2041
        base[3]= V315;
 
2042
        vs_top=(vs_base=base+3)+1;
 
2043
        return;}
 
2044
        goto T549;
 
2045
T549:;
 
2046
        base[2]= VV[94];
 
2047
        base[3]= (V316);
 
2048
        vs_top=(vs_base=base+2)+2;
 
2049
        Lerror();
 
2050
        return;
 
2051
        }
 
2052
}
 
2053
/*      function definition for FIND-WRAPPER    */
 
2054
 
 
2055
static void L51()
 
2056
{register object *base=vs_base;
 
2057
        register object *sup=base+VM49; VC49
 
2058
        vs_check;
 
2059
        {object V319;
 
2060
        check_arg(1);
 
2061
        V319=(base[0]);
 
2062
        vs_top=sup;
 
2063
        goto TTL;
 
2064
TTL:;
 
2065
        base[1]= (VFUN_NARGS=1,(*(LnkLI146))((V319)));
 
2066
        vs_top=(vs_base=base+1)+1;
 
2067
        (void) (*Lnk147)(Lclptr147);
 
2068
        return;
 
2069
        }
 
2070
}
 
2071
/*      macro definition for GATHERING1 */
 
2072
 
 
2073
static void L52()
 
2074
{register object *base=vs_base;
 
2075
        register object *sup=base+VM50; VC50
 
2076
        vs_check;
 
2077
        check_arg(2);
 
2078
        vs_top=sup;
 
2079
        {object V320=base[0]->c.c_cdr;
 
2080
        if(endp(V320))invalid_macro_call();
 
2081
        base[2]= (V320->c.c_car);
 
2082
        V320=V320->c.c_cdr;
 
2083
        base[3]= V320;}
 
2084
        V321= list(2,VV[96],base[2]);
 
2085
        V322= make_cons(/* INLINE-ARGS */V321,Cnil);
 
2086
        base[4]= list(3,VV[95],/* INLINE-ARGS */V322,listA(3,VV[97],VV[98],base[3]));
 
2087
        vs_top=(vs_base=base+4)+1;
 
2088
        return;
 
2089
}
 
2090
/*      macro definition for VECTORIZING        */
 
2091
 
 
2092
static void L53()
 
2093
{register object *base=vs_base;
 
2094
        register object *sup=base+VM51; VC51
 
2095
        vs_check;
 
2096
        check_arg(2);
 
2097
        vs_top=sup;
 
2098
        {object V323=base[0]->c.c_cdr;
 
2099
        {object V324=getf(V323,VV[148],OBJNULL);
 
2100
        if(V324==OBJNULL){
 
2101
        base[2]= small_fixnum(0);} else {
 
2102
        base[2]= V324;
 
2103
        }}
 
2104
        check_other_key(V323,1,VV[148]);}
 
2105
        V325= list(2,VV[99],base[2]);
 
2106
        base[3]= list(3,VV[27],make_cons(/* INLINE-ARGS */V325,VV[100]),VV[101]);
 
2107
        vs_top=(vs_base=base+3)+1;
 
2108
        return;
 
2109
}
 
2110
/*      macro definition for *LIST-ELEMENTS     */
 
2111
 
 
2112
static void L54()
 
2113
{register object *base=vs_base;
 
2114
        register object *sup=base+VM52; VC52
 
2115
        vs_check;
 
2116
        check_arg(2);
 
2117
        vs_top=sup;
 
2118
        {object V326=base[0]->c.c_cdr;
 
2119
        if(endp(V326))invalid_macro_call();
 
2120
        base[2]= (V326->c.c_car);
 
2121
        V326=V326->c.c_cdr;
 
2122
        {object V327=getf(V326,VV[149],OBJNULL);
 
2123
        if(V327==OBJNULL){
 
2124
        base[3]= (VV[55]->s.s_gfdef);} else {
 
2125
        base[3]= V327;
 
2126
        }}
 
2127
        check_other_key(V326,1,VV[149]);}
 
2128
        V328= list(2,VV[58],base[2]);
 
2129
        V329= make_cons(/* INLINE-ARGS */V328,Cnil);
 
2130
        base[4]= list(3,VV[24],/* INLINE-ARGS */V329,list(2,VV[102],list(3,VV[103],VV[104],list(4,VV[16],VV[105],VV[106],list(3,VV[107],VV[108],list(3,VV[50],VV[58],list(3,VV[109],base[3],VV[58])))))));
 
2131
        vs_top=(vs_base=base+4)+1;
 
2132
        return;
 
2133
}
 
2134
/*      macro definition for *LIST-TAILS        */
 
2135
 
 
2136
static void L55()
 
2137
{register object *base=vs_base;
 
2138
        register object *sup=base+VM53; VC53
 
2139
        vs_check;
 
2140
        check_arg(2);
 
2141
        vs_top=sup;
 
2142
        {object V330=base[0]->c.c_cdr;
 
2143
        if(endp(V330))invalid_macro_call();
 
2144
        base[2]= (V330->c.c_car);
 
2145
        V330=V330->c.c_cdr;
 
2146
        {object V331=getf(V330,VV[149],OBJNULL);
 
2147
        if(V331==OBJNULL){
 
2148
        base[3]= (VV[55]->s.s_gfdef);} else {
 
2149
        base[3]= V331;
 
2150
        }}
 
2151
        check_other_key(V330,1,VV[149]);}
 
2152
        V332= list(2,VV[58],base[2]);
 
2153
        V333= make_cons(/* INLINE-ARGS */V332,Cnil);
 
2154
        base[4]= list(3,VV[24],/* INLINE-ARGS */V333,list(2,VV[102],list(3,VV[103],VV[110],list(3,VV[107],VV[111],list(3,VV[50],VV[58],list(3,VV[109],base[3],VV[58]))))));
 
2155
        vs_top=(vs_base=base+4)+1;
 
2156
        return;
 
2157
}
 
2158
/*      macro definition for FUNCTION-FUNCALL   */
 
2159
 
 
2160
static void L56()
 
2161
{register object *base=vs_base;
 
2162
        register object *sup=base+VM54; VC54
 
2163
        vs_check;
 
2164
        check_arg(2);
 
2165
        vs_top=sup;
 
2166
        {object V334=base[0]->c.c_cdr;
 
2167
        if(endp(V334))invalid_macro_call();
 
2168
        base[2]= (V334->c.c_car);
 
2169
        V334=V334->c.c_cdr;
 
2170
        base[3]= V334;}
 
2171
        base[4]= listA(3,VV[109],base[2],base[3]);
 
2172
        vs_top=(vs_base=base+4)+1;
 
2173
        return;
 
2174
}
 
2175
/*      macro definition for FUNCTION-APPLY     */
 
2176
 
 
2177
static void L57()
 
2178
{register object *base=vs_base;
 
2179
        register object *sup=base+VM55; VC55
 
2180
        vs_check;
 
2181
        check_arg(2);
 
2182
        vs_top=sup;
 
2183
        {object V335=base[0]->c.c_cdr;
 
2184
        if(endp(V335))invalid_macro_call();
 
2185
        base[2]= (V335->c.c_car);
 
2186
        V335=V335->c.c_cdr;
 
2187
        base[3]= V335;}
 
2188
        base[4]= listA(3,VV[112],base[2],base[3]);
 
2189
        vs_top=(vs_base=base+4)+1;
 
2190
        return;
 
2191
}
 
2192
/*      local entry for function GET-SETF-FUNCTION-NAME */
 
2193
 
 
2194
static object LI58(V337)
 
2195
 
 
2196
object V337;
 
2197
{        VMB56 VMS56 VMV56
 
2198
        goto TTL;
 
2199
TTL:;
 
2200
        {object V338 = list(2,VV[45],(V337));
 
2201
        VMR56(V338)}
 
2202
        return Cnil;
 
2203
}
 
2204
/*      macro definition for DO-STANDARD-DEFSETF        */
 
2205
 
 
2206
static void L59()
 
2207
{register object *base=vs_base;
 
2208
        register object *sup=base+VM57; VC57
 
2209
        vs_check;
 
2210
        check_arg(2);
 
2211
        vs_top=sup;
 
2212
        {object V339=base[0]->c.c_cdr;
 
2213
        base[2]= V339;}
 
2214
        base[3]= list(3,VV[113],VV[114],list(3,VV[115],list(2,VV[116],list(2,VV[42],base[2])),VV[117]));
 
2215
        vs_top=(vs_base=base+3)+1;
 
2216
        return;
 
2217
}
 
2218
/*      local entry for function DO-STANDARD-DEFSETFS-FOR-DEFCLASS      */
 
2219
 
 
2220
static object LI60(V341)
 
2221
 
 
2222
object V341;
 
2223
{        VMB58 VMS58 VMV58
 
2224
        goto TTL;
 
2225
TTL:;
 
2226
        {register object V342;
 
2227
        register object V343;
 
2228
        V342= (V341);
 
2229
        V343= CMPcar((V342));
 
2230
        goto T562;
 
2231
T562:;
 
2232
        if(!(((V342))==Cnil)){
 
2233
        goto T563;}
 
2234
        {object V344 = Cnil;
 
2235
        VMR58(V344)}
 
2236
        goto T563;
 
2237
T563:;
 
2238
        (void)((*(LnkLI150))((V343)));
 
2239
        V342= CMPcdr((V342));
 
2240
        V343= CMPcar((V342));
 
2241
        goto T562;}
 
2242
        base[0]=base[0];
 
2243
        return Cnil;
 
2244
}
 
2245
/*      local entry for function DO-STANDARD-DEFSETF-1  */
 
2246
 
 
2247
static object LI61(V346)
 
2248
 
 
2249
object V346;
 
2250
{        VMB59 VMS59 VMV59
 
2251
        goto TTL;
 
2252
TTL:;
 
2253
        {object V347 = Cnil;
 
2254
        VMR59(V347)}
 
2255
        return Cnil;
 
2256
}
 
2257
/*      local entry for function SETFBOUNDP     */
 
2258
 
 
2259
static object LI62(V349)
 
2260
 
 
2261
object V349;
 
2262
{        VMB60 VMS60 VMV60
 
2263
        goto TTL;
 
2264
TTL:;{object V350;
 
2265
        {object V351 =((V349))->s.s_plist;
 
2266
         object ind= VV[118];
 
2267
        while(V351!=Cnil){
 
2268
        if(V351->c.c_car==ind){
 
2269
        V350= (V351->c.c_cdr->c.c_car);
 
2270
        goto T574;
 
2271
        }else V351=V351->c.c_cdr->c.c_cdr;}
 
2272
        V350= Cnil;}
 
2273
        goto T574;
 
2274
T574:;
 
2275
        if(V350==Cnil)goto T573;
 
2276
        {object V352 = V350;
 
2277
        VMR60(V352)}
 
2278
        goto T573;
 
2279
T573:;}{object V353;
 
2280
        {object V354 =((V349))->s.s_plist;
 
2281
         object ind= VV[119];
 
2282
        while(V354!=Cnil){
 
2283
        if(V354->c.c_car==ind){
 
2284
        V353= (V354->c.c_cdr->c.c_car);
 
2285
        goto T576;
 
2286
        }else V354=V354->c.c_cdr->c.c_cdr;}
 
2287
        V353= Cnil;}
 
2288
        goto T576;
 
2289
T576:;
 
2290
        if(V353==Cnil)goto T575;
 
2291
        {object V355 = V353;
 
2292
        VMR60(V355)}
 
2293
        goto T575;
 
2294
T575:;}
 
2295
        {object V356 =((V349))->s.s_plist;
 
2296
         object ind= VV[120];
 
2297
        while(V356!=Cnil){
 
2298
        if(V356->c.c_car==ind){
 
2299
        {object V357 = (V356->c.c_cdr->c.c_car);
 
2300
        VMR60(V357)}
 
2301
        }else V356=V356->c.c_cdr->c.c_cdr;}
 
2302
        {object V358 = Cnil;
 
2303
        VMR60(V358)}}
 
2304
        return Cnil;
 
2305
}
 
2306
/*      macro definition for ORIGINAL-DEFINITION        */
 
2307
 
 
2308
static void L63()
 
2309
{register object *base=vs_base;
 
2310
        register object *sup=base+VM61; VC61
 
2311
        vs_check;
 
2312
        check_arg(2);
 
2313
        vs_top=sup;
 
2314
        {object V359=base[0]->c.c_cdr;
 
2315
        if(endp(V359))invalid_macro_call();
 
2316
        base[2]= (V359->c.c_car);
 
2317
        V359=V359->c.c_cdr;
 
2318
        if(!endp(V359))invalid_macro_call();}
 
2319
        base[3]= list(3,VV[121],base[2],VV[122]);
 
2320
        vs_top=(vs_base=base+3)+1;
 
2321
        return;
 
2322
}
 
2323
/*      local entry for function REDEFINE-FUNCTION      */
 
2324
 
 
2325
static object LI64(V362,V363)
 
2326
 
 
2327
register object V362;object V363;
 
2328
{        VMB62 VMS62 VMV62
 
2329
        goto TTL;
 
2330
TTL:;
 
2331
        base[0]= V362;
 
2332
        base[1]= (VV[123]->s.s_dbind);
 
2333
        vs_top=(vs_base=base+0)+2;
 
2334
        Ladjoin();
 
2335
        vs_top=sup;
 
2336
        (VV[123]->s.s_dbind)= vs_base[0];
 
2337
        {object V365 =((V362))->s.s_plist;
 
2338
         object ind= VV[124];
 
2339
        while(V365!=Cnil){
 
2340
        if(V365->c.c_car==ind){
 
2341
        if(((V365->c.c_cdr->c.c_car))!=Cnil){
 
2342
        goto T581;}
 
2343
        goto T583;
 
2344
        }else V365=V365->c.c_cdr->c.c_cdr;}}
 
2345
        goto T583;
 
2346
T583:;
 
2347
        base[0]= (V362);
 
2348
        vs_top=(vs_base=base+0)+1;
 
2349
        Lsymbol_function();
 
2350
        vs_top=sup;
 
2351
        V366= vs_base[0];
 
2352
        (void)(sputprop((V362),VV[124],V366));
 
2353
        goto T581;
 
2354
T581:;
 
2355
        base[0]= (V362);
 
2356
        base[2]= (V363);
 
2357
        vs_top=(vs_base=base+2)+1;
 
2358
        Lsymbol_function();
 
2359
        vs_top=sup;
 
2360
        base[1]= vs_base[0];
 
2361
        vs_top=(vs_base=base+0)+2;
 
2362
        siLfset();
 
2363
        vs_top=sup;
 
2364
        {object V367 = vs_base[0];
 
2365
        VMR62(V367)}
 
2366
        base[0]=base[0];
 
2367
        return Cnil;
 
2368
}
 
2369
/*      local function CLOSURE  */
 
2370
 
 
2371
static void LC65(base0)
 
2372
register object *base0;
 
2373
{       register object *base=vs_base;
 
2374
        register object *sup=base+VM63; VC63
 
2375
        vs_check;
 
2376
        {object V368;
 
2377
        check_arg(1);
 
2378
        V368=(base[0]);
 
2379
        vs_top=sup;
 
2380
        base[1]= (base0[0]->c.c_car);
 
2381
        vs_top=(vs_base=base+1)+1;
 
2382
        return;
 
2383
        }
 
2384
}
 
2385
/*      local function MAKE-POP */
 
2386
 
 
2387
static void L26(base0)
 
2388
register object *base0;
 
2389
{       register object *base=vs_base;
 
2390
        register object *sup=base+VM64; VC64
 
2391
        vs_check;
 
2392
        {object V369;
 
2393
        object V370;
 
2394
        object V371;
 
2395
        check_arg(3);
 
2396
        V369=(base[0]);
 
2397
        V370=(base[1]);
 
2398
        V371=(base[2]);
 
2399
        vs_top=sup;
 
2400
        goto TTL;
 
2401
TTL:;
 
2402
        {object V372;
 
2403
        if(!(number_compare(small_fixnum(0),base0[0])==0)){
 
2404
        goto T591;}
 
2405
        if((V369)==Cnil){
 
2406
        V373= Cnil;
 
2407
        goto T593;}
 
2408
        V373= list(3,VV[50],(V369),list(2,VV[22],(V370)));
 
2409
        goto T593;
 
2410
T593:;
 
2411
        if((V371)==Cnil){
 
2412
        V374= Cnil;
 
2413
        goto T594;}
 
2414
        V374= list(3,VV[50],(V371),list(2,VV[55],(V370)));
 
2415
        goto T594;
 
2416
T594:;
 
2417
        V372= list(3,VV[44],V373,V374);
 
2418
        goto T589;
 
2419
        goto T591;
 
2420
T591:;
 
2421
        if(((V371))!=Cnil){
 
2422
        goto T596;}
 
2423
        if((V369)==Cnil){
 
2424
        V372= Cnil;
 
2425
        goto T589;}
 
2426
        V372= list(3,VV[50],(V369),(*(LnkLI151))(base0[0],(V370)));
 
2427
        goto T589;
 
2428
        goto T596;
 
2429
T596:;
 
2430
        V375= list(3,VV[50],(V371),(*(LnkLI152))(base0[0],(V370)));
 
2431
        if((V369)==Cnil){
 
2432
        V376= Cnil;
 
2433
        goto T598;}
 
2434
        V376= list(3,VV[50],(V369),list(2,VV[56],(V371)));
 
2435
        goto T598;
 
2436
T598:;
 
2437
        V372= list(3,VV[44],/* INLINE-ARGS */V375,V376);
 
2438
        goto T589;
 
2439
T589:;
 
2440
        base0[0]= small_fixnum(0);
 
2441
        base[3]= (V372);
 
2442
        vs_top=(vs_base=base+3)+1;
 
2443
        return;}
 
2444
        }
 
2445
}
 
2446
static object  LnkTLI152(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[152],(void **)(void *)&LnkLI152,2,first,ap);va_end(ap);return V1;} /* MAKE-CDXR */
 
2447
static object  LnkTLI151(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[151],(void **)(void *)&LnkLI151,2,first,ap);va_end(ap);return V1;} /* MAKE-CAXR */
 
2448
static object  LnkTLI150(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[150],(void **)(void *)&LnkLI150,1,first,ap);va_end(ap);return V1;} /* DO-STANDARD-DEFSETF-1 */
 
2449
static void LnkT147(ptr) object *ptr;{ call_or_link_closure(VV[147],(void **)(void *)&Lnk147,(void **)(void *)&Lclptr147);} /* CLASS-WRAPPER */
 
2450
static object  LnkTLI146(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_vproc_new(VV[146],(void **)(void *)&LnkLI146,first,ap);va_end(ap);return V1;} /* FIND-CLASS */
 
2451
static object  LnkTLI145(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_vproc_new(VV[145],(void **)(void *)&LnkLI145,first,ap);va_end(ap);return V1;} /* INITIALIZE-INFO */
 
2452
static object  LnkTLI144(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[144],(void **)(void *)&LnkLI144,2,first,ap);va_end(ap);return V1;} /* UPDATE-INITIALIZE-INFO-INTERNAL */
 
2453
static void LnkT143(ptr) object *ptr;{ call_or_link_closure(VV[143],(void **)(void *)&Lnk143,(void **)(void *)&Lclptr143);} /* FORWARD-REFERENCED-CLASS-P */
 
2454
static void LnkT142(ptr) object *ptr;{ call_or_link_closure(VV[142],(void **)(void *)&Lnk142,(void **)(void *)&Lclptr142);} /* CLASS-PREDICATE-NAME */
 
2455
static object  LnkTLI141(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_vproc_new(VV[141],(void **)(void *)&LnkLI141,first,ap);va_end(ap);return V1;} /* FIND-CLASS-PREDICATE-FROM-CELL */
 
2456
static object  LnkTLI140(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_vproc_new(VV[140],(void **)(void *)&LnkLI140,first,ap);va_end(ap);return V1;} /* FIND-CLASS-CELL */
 
2457
static object  LnkTLI139(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_vproc_new(VV[139],(void **)(void *)&LnkLI139,first,ap);va_end(ap);return V1;} /* FIND-CLASS-FROM-CELL */
 
2458
static void LnkT138(){ call_or_link(VV[138],(void **)(void *)&Lnk138);} /* FIND-STRUCTURE-CLASS */
 
2459
static object  LnkTLI137(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[137],(void **)(void *)&LnkLI137,1,first,ap);va_end(ap);return V1;} /* STRUCTURE-TYPE-P */
 
2460
static object  LnkTLI135(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[135],(void **)(void *)&LnkLI135,1,first,ap);va_end(ap);return V1;} /* LEGAL-CLASS-NAME-P */
 
2461
static void LnkT6(){ call_or_link(VV[6],(void **)(void *)&Lnk6);} /* DELETE */
 
2462
static object  LnkTLI133(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[133],(void **)(void *)&LnkLI133,2,first,ap);va_end(ap);return V1;} /* DESTRUCTURE-INTERNAL */
 
2463
static void LnkT132(){ call_or_link(VV[132],(void **)(void *)&Lnk132);} /* DESTRUCTURE */
 
2464
static void LnkT131(){ call_or_link(VV[131],(void **)(void *)&Lnk131);} /* EXTRACT-DECLARATIONS */
 
2465
static object  LnkTLI128(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_vproc_new(VV[128],(void **)(void *)&LnkLI128,first,ap);va_end(ap);return V1;} /* STRING-APPEND */
 
2466
static void LnkT127(){ call_or_link(VV[127],(void **)(void *)&Lnk127);} /* CONCATENATE */
 
2467
static object  LnkTLI126(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[126],(void **)(void *)&LnkLI126,2,first,ap);va_end(ap);return V1;} /* REMTAIL */
 
2468
static object  LnkTLI125(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[125],(void **)(void *)&LnkLI125,2,first,ap);va_end(ap);return V1;} /* MAKE-PLIST */
 
2469
 
 
2470
#ifdef SYSTEM_SPECIAL_INIT
 
2471
SYSTEM_SPECIAL_INIT
 
2472
#endif
 
2473