← Back to branch summary

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

« back to all changes in this revision

Viewing changes to pcl/c/pcl_dlisp.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_dlisp.c
 
1
 
 
2
#include "cmpinclude.h"
 
3
#include "pcl_dlisp.h"
 
4
void init_pcl_dlisp(){do_init(VV);}
 
5
/*      function definition for EMIT-ONE-CLASS-READER   */
 
6
 
 
7
static void L1()
 
8
{register object *base=vs_base;
 
9
        register object *sup=base+VM1; VC1
 
10
        vs_check;
 
11
        {object V1;
 
12
        check_arg(1);
 
13
        V1=(base[0]);
 
14
        vs_top=sup;
 
15
        goto TTL;
 
16
TTL:;
 
17
        base[1]= VV[0];
 
18
        base[2]= small_fixnum(1);
 
19
        base[3]= (V1);
 
20
        vs_top=(vs_base=base+1)+3;
 
21
        (void) (*Lnk170)();
 
22
        return;
 
23
        }
 
24
}
 
25
/*      function definition for EMIT-ONE-CLASS-WRITER   */
 
26
 
 
27
static void L2()
 
28
{register object *base=vs_base;
 
29
        register object *sup=base+VM2; VC2
 
30
        vs_check;
 
31
        {object V2;
 
32
        check_arg(1);
 
33
        V2=(base[0]);
 
34
        vs_top=sup;
 
35
        goto TTL;
 
36
TTL:;
 
37
        base[1]= VV[1];
 
38
        base[2]= small_fixnum(1);
 
39
        base[3]= (V2);
 
40
        vs_top=(vs_base=base+1)+3;
 
41
        (void) (*Lnk170)();
 
42
        return;
 
43
        }
 
44
}
 
45
/*      function definition for EMIT-TWO-CLASS-READER   */
 
46
 
 
47
static void L3()
 
48
{register object *base=vs_base;
 
49
        register object *sup=base+VM3; VC3
 
50
        vs_check;
 
51
        {object V3;
 
52
        check_arg(1);
 
53
        V3=(base[0]);
 
54
        vs_top=sup;
 
55
        goto TTL;
 
56
TTL:;
 
57
        base[1]= VV[0];
 
58
        base[2]= small_fixnum(2);
 
59
        base[3]= (V3);
 
60
        vs_top=(vs_base=base+1)+3;
 
61
        (void) (*Lnk170)();
 
62
        return;
 
63
        }
 
64
}
 
65
/*      function definition for EMIT-TWO-CLASS-WRITER   */
 
66
 
 
67
static void L4()
 
68
{register object *base=vs_base;
 
69
        register object *sup=base+VM4; VC4
 
70
        vs_check;
 
71
        {object V4;
 
72
        check_arg(1);
 
73
        V4=(base[0]);
 
74
        vs_top=sup;
 
75
        goto TTL;
 
76
TTL:;
 
77
        base[1]= VV[1];
 
78
        base[2]= small_fixnum(2);
 
79
        base[3]= (V4);
 
80
        vs_top=(vs_base=base+1)+3;
 
81
        (void) (*Lnk170)();
 
82
        return;
 
83
        }
 
84
}
 
85
/*      function definition for EMIT-ONE-INDEX-READERS  */
 
86
 
 
87
static void L5()
 
88
{register object *base=vs_base;
 
89
        register object *sup=base+VM5; VC5
 
90
        vs_check;
 
91
        {object V5;
 
92
        check_arg(1);
 
93
        V5=(base[0]);
 
94
        vs_top=sup;
 
95
        goto TTL;
 
96
TTL:;
 
97
        base[1]= VV[0];
 
98
        base[2]= Cnil;
 
99
        base[3]= (V5);
 
100
        vs_top=(vs_base=base+1)+3;
 
101
        (void) (*Lnk171)();
 
102
        return;
 
103
        }
 
104
}
 
105
/*      function definition for EMIT-ONE-INDEX-WRITERS  */
 
106
 
 
107
static void L6()
 
108
{register object *base=vs_base;
 
109
        register object *sup=base+VM6; VC6
 
110
        vs_check;
 
111
        {object V6;
 
112
        check_arg(1);
 
113
        V6=(base[0]);
 
114
        vs_top=sup;
 
115
        goto TTL;
 
116
TTL:;
 
117
        base[1]= VV[1];
 
118
        base[2]= Cnil;
 
119
        base[3]= (V6);
 
120
        vs_top=(vs_base=base+1)+3;
 
121
        (void) (*Lnk171)();
 
122
        return;
 
123
        }
 
124
}
 
125
/*      function definition for EMIT-N-N-READERS        */
 
126
 
 
127
static void L7()
 
128
{register object *base=vs_base;
 
129
        register object *sup=base+VM7; VC7
 
130
        vs_check;
 
131
        check_arg(0);
 
132
        vs_top=sup;
 
133
        goto TTL;
 
134
TTL:;
 
135
        base[0]= VV[0];
 
136
        base[1]= Ct;
 
137
        base[2]= Cnil;
 
138
        vs_top=(vs_base=base+0)+3;
 
139
        (void) (*Lnk171)();
 
140
        return;
 
141
}
 
142
/*      function definition for EMIT-N-N-WRITERS        */
 
143
 
 
144
static void L8()
 
145
{register object *base=vs_base;
 
146
        register object *sup=base+VM8; VC8
 
147
        vs_check;
 
148
        check_arg(0);
 
149
        vs_top=sup;
 
150
        goto TTL;
 
151
TTL:;
 
152
        base[0]= VV[1];
 
153
        base[1]= Ct;
 
154
        base[2]= Cnil;
 
155
        vs_top=(vs_base=base+0)+3;
 
156
        (void) (*Lnk171)();
 
157
        return;
 
158
}
 
159
/*      function definition for EMIT-CHECKING   */
 
160
 
 
161
static void L9()
 
162
{register object *base=vs_base;
 
163
        register object *sup=base+VM9; VC9
 
164
        vs_check;
 
165
        {object V7;
 
166
        object V8;
 
167
        check_arg(2);
 
168
        V7=(base[0]);
 
169
        V8=(base[1]);
 
170
        vs_top=sup;
 
171
        goto TTL;
 
172
TTL:;
 
173
        base[2]= Cnil;
 
174
        base[3]= Cnil;
 
175
        base[4]= (V7);
 
176
        base[5]= (V8);
 
177
        vs_top=(vs_base=base+2)+4;
 
178
        (void) (*Lnk172)();
 
179
        return;
 
180
        }
 
181
}
 
182
/*      function definition for EMIT-CACHING    */
 
183
 
 
184
static void L10()
 
185
{register object *base=vs_base;
 
186
        register object *sup=base+VM10; VC10
 
187
        vs_check;
 
188
        {object V9;
 
189
        object V10;
 
190
        check_arg(2);
 
191
        V9=(base[0]);
 
192
        V10=(base[1]);
 
193
        vs_top=sup;
 
194
        goto TTL;
 
195
TTL:;
 
196
        base[2]= Ct;
 
197
        base[3]= Cnil;
 
198
        base[4]= (V9);
 
199
        base[5]= (V10);
 
200
        vs_top=(vs_base=base+2)+4;
 
201
        (void) (*Lnk172)();
 
202
        return;
 
203
        }
 
204
}
 
205
/*      function definition for EMIT-IN-CHECKING-CACHE-P        */
 
206
 
 
207
static void L11()
 
208
{register object *base=vs_base;
 
209
        register object *sup=base+VM11; VC11
 
210
        vs_check;
 
211
        {object V11;
 
212
        check_arg(1);
 
213
        V11=(base[0]);
 
214
        vs_top=sup;
 
215
        goto TTL;
 
216
TTL:;
 
217
        base[1]= Cnil;
 
218
        base[2]= Ct;
 
219
        base[3]= (V11);
 
220
        base[4]= Cnil;
 
221
        vs_top=(vs_base=base+1)+4;
 
222
        (void) (*Lnk172)();
 
223
        return;
 
224
        }
 
225
}
 
226
/*      function definition for EMIT-CONSTANT-VALUE     */
 
227
 
 
228
static void L12()
 
229
{register object *base=vs_base;
 
230
        register object *sup=base+VM12; VC12
 
231
        vs_check;
 
232
        {object V12;
 
233
        check_arg(1);
 
234
        V12=(base[0]);
 
235
        vs_top=sup;
 
236
        goto TTL;
 
237
TTL:;
 
238
        base[1]= Ct;
 
239
        base[2]= Ct;
 
240
        base[3]= (V12);
 
241
        base[4]= Cnil;
 
242
        vs_top=(vs_base=base+1)+4;
 
243
        (void) (*Lnk172)();
 
244
        return;
 
245
        }
 
246
}
 
247
/*      function definition for EMIT-DEFAULT-ONLY       */
 
248
 
 
249
static void L13()
 
250
{register object *base=vs_base;
 
251
        register object *sup=base+VM13; VC13
 
252
        vs_check;
 
253
        {object V13;
 
254
        register object V14;
 
255
        check_arg(2);
 
256
        V13=(base[0]);
 
257
        V14=(base[1]);
 
258
        vs_top=sup;
 
259
        goto TTL;
 
260
TTL:;
 
261
        if(((VV[2]->s.s_dbind))!=Cnil){
 
262
        goto T41;}
 
263
        if(((VV[3]->s.s_dbind))==Cnil){
 
264
        goto T41;}
 
265
        base[2]= (V13);
 
266
        base[3]= (V14);
 
267
        vs_top=(vs_base=base+2)+2;
 
268
        (void) (*Lnk173)();
 
269
        return;
 
270
        goto T41;
 
271
T41:;
 
272
        {object V15;
 
273
        object V16;
 
274
        object V17;
 
275
        V15= (*(LnkLI174))((V13),(V14));
 
276
        base[5]= VV[4];
 
277
        base[6]= (V15);
 
278
        vs_top=(vs_base=base+5)+2;
 
279
        (void) (*Lnk175)();
 
280
        vs_top=sup;
 
281
        V16= vs_base[0];
 
282
        if(((V14))==Cnil){
 
283
        goto T54;}
 
284
        V17= VV[5];
 
285
        goto T52;
 
286
        goto T54;
 
287
T54:;
 
288
        V17= Cnil;
 
289
        goto T52;
 
290
T52:;
 
291
        base[5]= VV[6];
 
292
        base[6]= (V15);
 
293
        base[7]= listA(4,VV[7],VV[8],(V14),append((V16),(V17)));
 
294
        vs_top=(vs_base=base+5)+3;
 
295
        (void) (*Lnk176)();
 
296
        return;}
 
297
        }
 
298
}
 
299
/*      macro definition for EMIT-DEFAULT-ONLY-MACRO    */
 
300
 
 
301
static void L14()
 
302
{register object *base=vs_base;
 
303
        register object *sup=base+VM14; VC14
 
304
        vs_check;
 
305
        bds_check;
 
306
        check_arg(2);
 
307
        vs_top=sup;
 
308
        {object V18=base[0]->c.c_cdr;
 
309
        if(endp(V18))invalid_macro_call();
 
310
        base[2]= (V18->c.c_car);
 
311
        V18=V18->c.c_cdr;
 
312
        if(endp(V18))invalid_macro_call();
 
313
        base[3]= (V18->c.c_car);
 
314
        V18=V18->c.c_cdr;
 
315
        if(!endp(V18))invalid_macro_call();}
 
316
        bds_bind(VV[3],Cnil);
 
317
        bds_bind(VV[2],Ct);
 
318
        base[7]= base[2];
 
319
        base[8]= base[3];
 
320
        vs_top=(vs_base=base+7)+2;
 
321
        (void) (*Lnk177)();
 
322
        vs_top=sup;
 
323
        base[6]= vs_base[0];
 
324
        vs_top=(vs_base=base+6)+1;
 
325
        bds_unwind1;
 
326
        bds_unwind1;
 
327
        return;
 
328
}
 
329
/*      function definition for GENERATING-LISP */
 
330
 
 
331
static void L15()
 
332
{register object *base=vs_base;
 
333
        register object *sup=base+VM15; VC15
 
334
        vs_check;
 
335
        {object V19;
 
336
        object V20;
 
337
        object V21;
 
338
        check_arg(3);
 
339
        V19=(base[0]);
 
340
        V20=(base[1]);
 
341
        V21=(base[2]);
 
342
        vs_top=sup;
 
343
        goto TTL;
 
344
TTL:;
 
345
        {object V22;
 
346
        object V23;
 
347
        object V24;
 
348
        object V25;
 
349
        {register object x= VV[4],V26= (V20);
 
350
        while(V26!=Cnil)
 
351
        if(x==(V26->c.c_car)){
 
352
        V22= V26;
 
353
        goto T62;
 
354
        }else V26=V26->c.c_cdr;
 
355
        V22= Cnil;}
 
356
        goto T62;
 
357
T62:;
 
358
        if((V22)==Cnil){
 
359
        V23= Cnil;
 
360
        goto T63;}
 
361
        base[7]= (V20);
 
362
        base[8]= (V22);
 
363
        vs_top=(vs_base=base+7)+2;
 
364
        Lldiff();
 
365
        vs_top=sup;
 
366
        V23= vs_base[0];
 
367
        goto T63;
 
368
T63:;
 
369
        if(((V22))==Cnil){
 
370
        goto T68;}
 
371
        V24= append((V23),VV[9]);
 
372
        goto T66;
 
373
        goto T68;
 
374
T68:;
 
375
        V24= (V20);
 
376
        goto T66;
 
377
T66:;
 
378
        {register object x= VV[11],V28= (V19);
 
379
        while(V28!=Cnil)
 
380
        if(eql(x,V28->c.c_car)){
 
381
        goto T74;
 
382
        }else V28=V28->c.c_cdr;
 
383
        goto T73;}
 
384
        goto T74;
 
385
T74:;
 
386
        V27= VV[12];
 
387
        goto T71;
 
388
        goto T73;
 
389
T73:;
 
390
        V27= Cnil;
 
391
        goto T71;
 
392
T71:;
 
393
        V29= list(3,VV[13],(V24),list(4,VV[14],Cnil,VV[15],(V21)));
 
394
        V30= make_cons(/* INLINE-ARGS */V29,Cnil);
 
395
        V25= listA(3,VV[10],(V19),append(V27,/* INLINE-ARGS */V30));
 
396
        if(((VV[2]->s.s_dbind))==Cnil){
 
397
        goto T77;}
 
398
        base[7]= list(2,VV[16],(V25));
 
399
        goto T75;
 
400
        goto T77;
 
401
T77:;
 
402
        base[8]= (V25);
 
403
        vs_top=(vs_base=base+8)+1;
 
404
        (void) (*Lnk178)();
 
405
        vs_top=sup;
 
406
        base[7]= vs_base[0];
 
407
        goto T75;
 
408
T75:;
 
409
        base[8]= Cnil;
 
410
        vs_top=(vs_base=base+7)+2;
 
411
        return;}
 
412
        }
 
413
}
 
414
/*      function definition for EMIT-READERWRITER       */
 
415
 
 
416
static void L16()
 
417
{register object *base=vs_base;
 
418
        register object *sup=base+VM16; VC16
 
419
        vs_check;
 
420
        {object V31;
 
421
        object V32;
 
422
        register object V33;
 
423
        check_arg(3);
 
424
        V31=(base[0]);
 
425
        V32=(base[1]);
 
426
        V33=(base[2]);
 
427
        vs_top=sup;
 
428
        goto TTL;
 
429
TTL:;
 
430
        if(((VV[2]->s.s_dbind))!=Cnil){
 
431
        goto T81;}
 
432
        if(((VV[3]->s.s_dbind))==Cnil){
 
433
        goto T81;}
 
434
        base[3]= (V31);
 
435
        base[4]= (V32);
 
436
        base[5]= (V33);
 
437
        vs_top=(vs_base=base+3)+3;
 
438
        (void) (*Lnk179)();
 
439
        return;
 
440
        goto T81;
 
441
T81:;
 
442
        {register object V34;
 
443
        register object V35;
 
444
        object V36;
 
445
        object V37;
 
446
        object V38;
 
447
        object V39;
 
448
        V37= (*(LnkLI180))(VV[17]);
 
449
        V38= (((V31))==(VV[0])?Ct:Cnil);
 
450
        V39= (*(LnkLI181))((V33),VV[18],VV[19]);
 
451
        V34= Cnil;
 
452
        V35= Cnil;
 
453
        V36= Cnil;
 
454
        {object V41= V31;
 
455
        if((V41!= VV[0]))goto T93;
 
456
        V34= (*(LnkLI182))(small_fixnum(0));
 
457
        V35= make_cons((V34),Cnil);
 
458
        goto T92;
 
459
        goto T93;
 
460
T93:;
 
461
        if((V41!= VV[1]))goto T97;
 
462
        V34= (*(LnkLI182))(small_fixnum(1));
 
463
        V42= (*(LnkLI182))(small_fixnum(0));
 
464
        V35= list(2,/* INLINE-ARGS */V42,(V34));
 
465
        goto T92;
 
466
        goto T97;
 
467
T97:;
 
468
        base[3]= VV[20];
 
469
        base[4]= VV[21];
 
470
        base[5]= VV[22];
 
471
        base[6]= VV[23];
 
472
        base[7]= V31;
 
473
        base[8]= VV[24];
 
474
        base[9]= VV[25];
 
475
        base[10]= VV[26];
 
476
        base[11]= VV[27];
 
477
        vs_top=(vs_base=base+3)+9;
 
478
        (void) (*Lnk183)();
 
479
        vs_top=sup;}
 
480
        goto T92;
 
481
T92:;
 
482
        {object V44= V32;
 
483
        if(!eql(V44,VV[28]))goto T111;
 
484
        V36= VV[29];
 
485
        goto T110;
 
486
        goto T111;
 
487
T111:;
 
488
        if(!eql(V44,VV[30]))goto T113;
 
489
        V36= VV[31];
 
490
        goto T110;
 
491
        goto T113;
 
492
T113:;
 
493
        base[3]= VV[20];
 
494
        base[4]= VV[21];
 
495
        base[5]= VV[22];
 
496
        base[6]= VV[23];
 
497
        base[7]= V32;
 
498
        base[8]= VV[24];
 
499
        base[9]= VV[32];
 
500
        base[10]= VV[26];
 
501
        base[11]= VV[33];
 
502
        vs_top=(vs_base=base+3)+9;
 
503
        (void) (*Lnk183)();
 
504
        vs_top=sup;}
 
505
        goto T110;
 
506
T110:;
 
507
        base[3]= (V36);
 
508
        base[4]= (V35);
 
509
        if(((V33))!=Cnil){
 
510
        goto T129;}
 
511
        V45= VV[35];
 
512
        goto T127;
 
513
        goto T129;
 
514
T129:;
 
515
        V45= Cnil;
 
516
        goto T127;
 
517
T127:;
 
518
        V46= list(2,VV[38],(V34));
 
519
        if(((V33))!=Cnil){
 
520
        goto T133;}
 
521
        V48= list(3,VV[39],VV[19],list(2,VV[40],(V34)));
 
522
        V47= make_cons(/* INLINE-ARGS */V48,Cnil);
 
523
        goto T131;
 
524
        goto T133;
 
525
T133:;
 
526
        V47= Cnil;
 
527
        goto T131;
 
528
T131:;
 
529
        V49= list(2,VV[41],(V34));
 
530
        V50= make_cons(/* INLINE-ARGS */V49,Cnil);
 
531
        V51= append(V47,/* INLINE-ARGS */V50);
 
532
        V52= make_cons(/* INLINE-ARGS */V46,/* INLINE-ARGS */V51);
 
533
        V53= list(2,VV[42],(V34));
 
534
        if(((V33))!=Cnil){
 
535
        goto T137;}
 
536
        V55= list(3,VV[39],VV[19],list(2,VV[43],(V34)));
 
537
        V54= make_cons(/* INLINE-ARGS */V55,Cnil);
 
538
        goto T135;
 
539
        goto T137;
 
540
T137:;
 
541
        V54= Cnil;
 
542
        goto T135;
 
543
T135:;
 
544
        V56= list(2,VV[44],(V34));
 
545
        V57= make_cons(/* INLINE-ARGS */V56,Cnil);
 
546
        V58= append(V54,/* INLINE-ARGS */V57);
 
547
        V59= list(2,VV[36],list(3,VV[37],/* INLINE-ARGS */V52,make_cons(/* INLINE-ARGS */V53,/* INLINE-ARGS */V58)));
 
548
        if(((V38))==Cnil){
 
549
        goto T141;}
 
550
        V60= VV[45];
 
551
        goto T139;
 
552
        goto T141;
 
553
T141:;
 
554
        V60= Cnil;
 
555
        goto T139;
 
556
T139:;
 
557
        V61= make_cons(/* INLINE-ARGS */V59,V60);
 
558
        V62= append(V45,/* INLINE-ARGS */V61);
 
559
        V63= list(2,VV[49],list(3,VV[50],VV[36],(V37)));
 
560
        if(!(eql(small_fixnum(2),(V32)))){
 
561
        goto T145;}
 
562
        V64= VV[53];
 
563
        goto T143;
 
564
        goto T145;
 
565
T145:;
 
566
        V64= Cnil;
 
567
        goto T143;
 
568
T143:;
 
569
        V65= list(2,VV[51],listA(3,VV[47],VV[52],V64));
 
570
        if(((V38))==Cnil){
 
571
        goto T149;}
 
572
        V67= list(3,VV[54],VV[55],list(3,VV[39],VV[56],(V39)));
 
573
        V66= make_cons(/* INLINE-ARGS */V67,Cnil);
 
574
        goto T147;
 
575
        goto T149;
 
576
T149:;
 
577
        V66= Cnil;
 
578
        goto T147;
 
579
T147:;
 
580
        V68= listA(5,VV[47],VV[48],/* INLINE-ARGS */V63,/* INLINE-ARGS */V65,V66);
 
581
        V69= listA(3,VV[57],VV[11],(V35));
 
582
        if(((V38))==Cnil){
 
583
        goto T153;}
 
584
        V70= VV[56];
 
585
        goto T151;
 
586
        goto T153;
 
587
T153:;
 
588
        V70= list(3,VV[58],(V39),CMPcar((V35)));
 
589
        goto T151;
 
590
T151:;
 
591
        base[5]= list(3,VV[34],/* INLINE-ARGS */V62,list(4,VV[46],/* INLINE-ARGS */V68,/* INLINE-ARGS */V69,V70));
 
592
        vs_top=(vs_base=base+3)+3;
 
593
        (void) (*Lnk176)();
 
594
        return;}
 
595
        }
 
596
}
 
597
/*      local entry for function EMIT-SLOT-READ-FORM    */
 
598
 
 
599
static object LI17(V74,V75,V76)
 
600
 
 
601
object V74;object V75;object V76;
 
602
{        VMB17 VMS17 VMV17
 
603
        goto TTL;
 
604
TTL:;
 
605
        if(((V74))==Cnil){
 
606
        goto T156;}
 
607
        {object V77 = list(2,VV[59],(V75));
 
608
        VMR17(V77)}
 
609
        goto T156;
 
610
T156:;
 
611
        {object V78 = list(3,VV[60],(V76),(V75));
 
612
        VMR17(V78)}
 
613
        return Cnil;
 
614
}
 
615
/*      local entry for function EMIT-BOUNDP-CHECK      */
 
616
 
 
617
static object LI18(V82,V83,V84)
 
618
 
 
619
object V82;object V83;object V84;
 
620
{        VMB18 VMS18 VMV18
 
621
        goto TTL;
 
622
TTL:;
 
623
        V85= list(2,VV[56],(V82));
 
624
        V86= make_cons(/* INLINE-ARGS */V85,Cnil);
 
625
        {object V87 = list(3,VV[14],/* INLINE-ARGS */V86,list(4,VV[46],VV[61],listA(3,VV[57],(V83),(V84)),VV[56]));
 
626
        VMR18(V87)}
 
627
        return Cnil;
 
628
}
 
629
/*      local entry for function EMIT-SLOT-ACCESS       */
 
630
 
 
631
static object LI19(V94,V95,V96,V97,V98,V99)
 
632
 
 
633
object V94;object V95;object V96;object V97;object V98;object V99;
 
634
{        VMB19 VMS19 VMV19
 
635
        goto TTL;
 
636
TTL:;
 
637
        {object V100;
 
638
        V100= (*(LnkLI181))((V95),(V97),(V96));
 
639
        {object V102= V94;
 
640
        if((V102!= VV[0]))goto T159;
 
641
        {object V103 = (*(LnkLI184))((V100),(V98),(V99));
 
642
        VMR19(V103)}
 
643
        goto T159;
 
644
T159:;
 
645
        if((V102!= VV[1]))goto T160;
 
646
        {object V104 = list(3,VV[58],(V100),CMPcar((V99)));
 
647
        VMR19(V104)}
 
648
        goto T160;
 
649
T160:;
 
650
        base[0]= VV[20];
 
651
        base[1]= VV[21];
 
652
        base[2]= VV[22];
 
653
        base[3]= VV[23];
 
654
        base[4]= V94;
 
655
        base[5]= VV[24];
 
656
        base[6]= VV[62];
 
657
        base[7]= VV[26];
 
658
        base[8]= VV[63];
 
659
        vs_top=(vs_base=base+0)+9;
 
660
        (void) (*Lnk183)();
 
661
        vs_top=sup;
 
662
        {object V105 = vs_base[0];
 
663
        VMR19(V105)}}}
 
664
        base[0]=base[0];
 
665
        return Cnil;
 
666
}
 
667
/*      macro definition for EMIT-READERWRITER-MACRO    */
 
668
 
 
669
static void L20()
 
670
{register object *base=vs_base;
 
671
        register object *sup=base+VM20; VC20
 
672
        vs_check;
 
673
        bds_check;
 
674
        check_arg(2);
 
675
        vs_top=sup;
 
676
        {object V106=base[0]->c.c_cdr;
 
677
        if(endp(V106))invalid_macro_call();
 
678
        base[2]= (V106->c.c_car);
 
679
        V106=V106->c.c_cdr;
 
680
        if(endp(V106))invalid_macro_call();
 
681
        base[3]= (V106->c.c_car);
 
682
        V106=V106->c.c_cdr;
 
683
        if(endp(V106))invalid_macro_call();
 
684
        base[4]= (V106->c.c_car);
 
685
        V106=V106->c.c_cdr;
 
686
        if(!endp(V106))invalid_macro_call();}
 
687
        bds_bind(VV[3],Cnil);
 
688
        bds_bind(VV[2],Ct);
 
689
        base[8]= base[2];
 
690
        base[9]= base[3];
 
691
        base[10]= base[4];
 
692
        vs_top=(vs_base=base+8)+3;
 
693
        (void) (*Lnk170)();
 
694
        vs_top=sup;
 
695
        base[7]= vs_base[0];
 
696
        vs_top=(vs_base=base+7)+1;
 
697
        bds_unwind1;
 
698
        bds_unwind1;
 
699
        return;
 
700
}
 
701
/*      function definition for EMIT-ONE-OR-N-INDEX-READERWRITER        */
 
702
 
 
703
static void L21()
 
704
{register object *base=vs_base;
 
705
        register object *sup=base+VM21; VC21
 
706
        vs_check;
 
707
        {object V107;
 
708
        register object V108;
 
709
        register object V109;
 
710
        check_arg(3);
 
711
        V107=(base[0]);
 
712
        V108=(base[1]);
 
713
        V109=(base[2]);
 
714
        vs_top=sup;
 
715
        goto TTL;
 
716
TTL:;
 
717
        if(((VV[2]->s.s_dbind))!=Cnil){
 
718
        goto T174;}
 
719
        if(((VV[3]->s.s_dbind))==Cnil){
 
720
        goto T174;}
 
721
        base[3]= (V107);
 
722
        base[4]= (V108);
 
723
        base[5]= (V109);
 
724
        vs_top=(vs_base=base+3)+3;
 
725
        (void) (*Lnk185)();
 
726
        return;
 
727
        goto T174;
 
728
T174:;
 
729
        {register object V110;
 
730
        object V111;
 
731
        {object V113= V107;
 
732
        if((V113!= VV[0]))goto T183;
 
733
        V114= (*(LnkLI182))(small_fixnum(0));
 
734
        base[3]= make_cons(/* INLINE-ARGS */V114,Cnil);
 
735
        base[4]= VV[64];
 
736
        vs_top=(vs_base=base+3)+2;
 
737
        goto T182;
 
738
        goto T183;
 
739
T183:;
 
740
        if((V113!= VV[1]))goto T186;
 
741
        V115= (*(LnkLI182))(small_fixnum(0));
 
742
        base[3]= list(2,/* INLINE-ARGS */V115,(*(LnkLI182))(small_fixnum(1)));
 
743
        base[4]= VV[65];
 
744
        vs_top=(vs_base=base+3)+2;
 
745
        goto T182;
 
746
        goto T186;
 
747
T186:;
 
748
        base[3]= VV[20];
 
749
        base[4]= VV[21];
 
750
        base[5]= VV[22];
 
751
        base[6]= VV[23];
 
752
        base[7]= V107;
 
753
        base[8]= VV[24];
 
754
        base[9]= VV[66];
 
755
        base[10]= VV[26];
 
756
        base[11]= VV[67];
 
757
        vs_top=(vs_base=base+3)+9;
 
758
        (void) (*Lnk183)();}
 
759
        goto T182;
 
760
T182:;
 
761
        if(vs_base>=vs_top){vs_top=sup;goto T198;}
 
762
        V110= vs_base[0];
 
763
        vs_base++;
 
764
        if(vs_base>=vs_top){vs_top=sup;goto T199;}
 
765
        V111= vs_base[0];
 
766
        vs_top=sup;
 
767
        goto T200;
 
768
        goto T198;
 
769
T198:;
 
770
        V110= Cnil;
 
771
        goto T199;
 
772
T199:;
 
773
        V111= Cnil;
 
774
        goto T200;
 
775
T200:;
 
776
        if(((V108))!=Cnil){
 
777
        goto T204;}
 
778
        V116= VV[69];
 
779
        goto T202;
 
780
        goto T204;
 
781
T204:;
 
782
        V116= Cnil;
 
783
        goto T202;
 
784
T202:;
 
785
        V117= append(V116,VV[70]);
 
786
        base[3]= make_cons(VV[68],/* INLINE-ARGS */V117);
 
787
        base[4]= (V110);
 
788
        if(((V109))!=Cnil){
 
789
        goto T210;}
 
790
        V118= VV[71];
 
791
        goto T208;
 
792
        goto T210;
 
793
T210:;
 
794
        V118= Cnil;
 
795
        goto T208;
 
796
T208:;
 
797
        if(((V108))==Cnil){
 
798
        goto T214;}
 
799
        V119= VV[72];
 
800
        goto T212;
 
801
        goto T214;
 
802
T214:;
 
803
        V119= Cnil;
 
804
        goto T212;
 
805
T212:;
 
806
        V120= append(V118,V119);
 
807
        V121= (*(LnkLI187))((V107),(V109),VV[19],VV[18],VV[11],(V110));
 
808
        V122= listA(3,VV[57],VV[11],(V110));
 
809
        if(((V108))==Cnil){
 
810
        goto T218;}
 
811
        V123= VV[18];
 
812
        goto T216;
 
813
        goto T218;
 
814
T218:;
 
815
        V123= Cnil;
 
816
        goto T216;
 
817
T216:;
 
818
        if(((V109))!=Cnil){
 
819
        goto T222;}
 
820
        V124= VV[73];
 
821
        goto T220;
 
822
        goto T222;
 
823
T222:;
 
824
        V124= Cnil;
 
825
        goto T220;
 
826
T220:;
 
827
        base[5]= list(3,VV[14],/* INLINE-ARGS */V120,(VFUN_NARGS=6,(*(LnkLI186))((V110),(V111),/* INLINE-ARGS */V121,/* INLINE-ARGS */V122,V123,V124)));
 
828
        vs_top=(vs_base=base+3)+3;
 
829
        (void) (*Lnk176)();
 
830
        return;}
 
831
        }
 
832
}
 
833
/*      macro definition for EMIT-ONE-OR-N-INDEX-READERWRITER-MACRO     */
 
834
 
 
835
static void L22()
 
836
{register object *base=vs_base;
 
837
        register object *sup=base+VM22; VC22
 
838
        vs_check;
 
839
        bds_check;
 
840
        check_arg(2);
 
841
        vs_top=sup;
 
842
        {object V125=base[0]->c.c_cdr;
 
843
        if(endp(V125))invalid_macro_call();
 
844
        base[2]= (V125->c.c_car);
 
845
        V125=V125->c.c_cdr;
 
846
        if(endp(V125))invalid_macro_call();
 
847
        base[3]= (V125->c.c_car);
 
848
        V125=V125->c.c_cdr;
 
849
        if(endp(V125))invalid_macro_call();
 
850
        base[4]= (V125->c.c_car);
 
851
        V125=V125->c.c_cdr;
 
852
        if(!endp(V125))invalid_macro_call();}
 
853
        bds_bind(VV[3],Cnil);
 
854
        bds_bind(VV[2],Ct);
 
855
        base[8]= base[2];
 
856
        base[9]= base[3];
 
857
        base[10]= base[4];
 
858
        vs_top=(vs_base=base+8)+3;
 
859
        (void) (*Lnk171)();
 
860
        vs_top=sup;
 
861
        base[7]= vs_base[0];
 
862
        vs_top=(vs_base=base+7)+1;
 
863
        bds_unwind1;
 
864
        bds_unwind1;
 
865
        return;
 
866
}
 
867
/*      local entry for function EMIT-MISS      */
 
868
 
 
869
static object LI23(object V127,object V126,object first,...)
 
870
{       
 
871
        va_list ap;
 
872
        int narg = VFUN_NARGS; VMB23 VMS23 VMV23
 
873
        {object V128;
 
874
        object V129;
 
875
        object V130;
 
876
        va_start(ap,first);
 
877
        if(narg <2) too_few_arguments();
 
878
        V128= V127;
 
879
        V129= V126;
 
880
        narg = narg - 2;
 
881
        if (narg <= 0) goto T228;
 
882
        else {
 
883
        V130= first;}
 
884
        --narg; goto T229;
 
885
        goto T228;
 
886
T228:;
 
887
        V130= Cnil;
 
888
        goto T229;
 
889
T229:;
 
890
        {object V131;
 
891
        if(((V130))==Cnil){
 
892
        goto T233;}
 
893
        V131= VV[74];
 
894
        goto T231;
 
895
        goto T233;
 
896
T233:;
 
897
        V131= Cnil;
 
898
        goto T231;
 
899
T231:;
 
900
        if(((V131))==Cnil){
 
901
        goto T236;}
 
902
        {object V132 = listA(3,VV[75],(V128),append((V129),(V131)));
 
903
        VMR23(V132)}
 
904
        goto T236;
 
905
T236:;
 
906
        {object V133 = listA(3,VV[57],(V128),append((V129),(V131)));
 
907
        VMR23(V133)}}
 
908
        va_end(ap);
 
909
        return Cnil;}
 
910
        }
 
911
/*      function definition for EMIT-CHECKING-OR-CACHING        */
 
912
 
 
913
static void L24()
 
914
{register object *base=vs_base;
 
915
        register object *sup=base+VM24; VC24
 
916
        vs_check;
 
917
        {register object V134;
 
918
        object V135;
 
919
        object V136;
 
920
        register object V137;
 
921
        check_arg(4);
 
922
        V134=(base[0]);
 
923
        V135=(base[1]);
 
924
        V136=(base[2]);
 
925
        V137=(base[3]);
 
926
        vs_top=sup;
 
927
        goto TTL;
 
928
TTL:;
 
929
        if(((VV[2]->s.s_dbind))!=Cnil){
 
930
        goto T238;}
 
931
        if(((VV[3]->s.s_dbind))==Cnil){
 
932
        goto T238;}
 
933
        base[4]= (V134);
 
934
        base[5]= (V135);
 
935
        base[6]= (V136);
 
936
        base[7]= (V137);
 
937
        vs_top=(vs_base=base+4)+4;
 
938
        (void) (*Lnk188)();
 
939
        return;
 
940
        goto T238;
 
941
T238:;
 
942
        {object V138;
 
943
        object V139;
 
944
        object V140;
 
945
        V138= (*(LnkLI174))((V136),(V137));
 
946
        base[7]= VV[4];
 
947
        base[8]= (V138);
 
948
        vs_top=(vs_base=base+7)+2;
 
949
        (void) (*Lnk175)();
 
950
        vs_top=sup;
 
951
        V139= vs_base[0];
 
952
        if(((V137))==Cnil){
 
953
        goto T253;}
 
954
        V140= VV[76];
 
955
        goto T251;
 
956
        goto T253;
 
957
T253:;
 
958
        V140= Cnil;
 
959
        goto T251;
 
960
T251:;
 
961
        if(((V134))!=Cnil){
 
962
        goto T258;}
 
963
        V141= VV[77];
 
964
        goto T256;
 
965
        goto T258;
 
966
T258:;
 
967
        V141= Cnil;
 
968
        goto T256;
 
969
T256:;
 
970
        V142= append(V141,VV[78]);
 
971
        base[7]= make_cons(VV[68],/* INLINE-ARGS */V142);
 
972
        base[8]= (V138);
 
973
        if(((V134))==Cnil){
 
974
        goto T264;}
 
975
        V143= VV[79];
 
976
        goto T262;
 
977
        goto T264;
 
978
T264:;
 
979
        V143= Cnil;
 
980
        goto T262;
 
981
T262:;
 
982
        if(((V135))==Cnil){
 
983
        goto T268;}
 
984
        if(((V134))==Cnil){
 
985
        goto T271;}
 
986
        V144= VV[8];
 
987
        goto T266;
 
988
        goto T271;
 
989
T271:;
 
990
        V144= Ct;
 
991
        goto T266;
 
992
        goto T268;
 
993
T268:;
 
994
        V144= listA(4,VV[7],VV[8],(V137),append((V139),(V140)));
 
995
        goto T266;
 
996
T266:;
 
997
        V145= (VFUN_NARGS=3,(*(LnkLI189))(VV[11],(V139),(V137)));
 
998
        if(((V134))==Cnil){
 
999
        goto T275;}
 
1000
        V146= VV[8];
 
1001
        goto T273;
 
1002
        goto T275;
 
1003
T275:;
 
1004
        V146= Cnil;
 
1005
        goto T273;
 
1006
T273:;
 
1007
        base[9]= list(3,VV[14],V143,(VFUN_NARGS=5,(*(LnkLI186))((V139),(V136),V144,/* INLINE-ARGS */V145,V146)));
 
1008
        vs_top=(vs_base=base+7)+3;
 
1009
        (void) (*Lnk176)();
 
1010
        return;}
 
1011
        }
 
1012
}
 
1013
/*      macro definition for EMIT-CHECKING-OR-CACHING-MACRO     */
 
1014
 
 
1015
static void L25()
 
1016
{register object *base=vs_base;
 
1017
        register object *sup=base+VM25; VC25
 
1018
        vs_check;
 
1019
        bds_check;
 
1020
        check_arg(2);
 
1021
        vs_top=sup;
 
1022
        {object V147=base[0]->c.c_cdr;
 
1023
        if(endp(V147))invalid_macro_call();
 
1024
        base[2]= (V147->c.c_car);
 
1025
        V147=V147->c.c_cdr;
 
1026
        if(endp(V147))invalid_macro_call();
 
1027
        base[3]= (V147->c.c_car);
 
1028
        V147=V147->c.c_cdr;
 
1029
        if(endp(V147))invalid_macro_call();
 
1030
        base[4]= (V147->c.c_car);
 
1031
        V147=V147->c.c_cdr;
 
1032
        if(endp(V147))invalid_macro_call();
 
1033
        base[5]= (V147->c.c_car);
 
1034
        V147=V147->c.c_cdr;
 
1035
        if(!endp(V147))invalid_macro_call();}
 
1036
        bds_bind(VV[3],Cnil);
 
1037
        bds_bind(VV[2],Ct);
 
1038
        base[9]= base[2];
 
1039
        base[10]= base[3];
 
1040
        base[11]= base[4];
 
1041
        base[12]= base[5];
 
1042
        vs_top=(vs_base=base+9)+4;
 
1043
        (void) (*Lnk172)();
 
1044
        vs_top=sup;
 
1045
        base[8]= vs_base[0];
 
1046
        vs_top=(vs_base=base+8)+1;
 
1047
        bds_unwind1;
 
1048
        bds_unwind1;
 
1049
        return;
 
1050
}
 
1051
/*      local entry for function EMIT-DLAP      */
 
1052
 
 
1053
static object LI26(object V152,object V151,object V150,object V149,object V148,object first,...)
 
1054
{       
 
1055
        va_list ap;
 
1056
        int narg = VFUN_NARGS; VMB26 VMS26 VMV26
 
1057
        {object V153;
 
1058
        object V154;
 
1059
        object V155;
 
1060
        object V156;
 
1061
        object V157;
 
1062
        object V158;
 
1063
        va_start(ap,first);
 
1064
        if(narg <5) too_few_arguments();
 
1065
        V153= V152;
 
1066
        V154= V151;
 
1067
        V155= V150;
 
1068
        V156= V149;
 
1069
        V157= V148;
 
1070
        narg = narg - 5;
 
1071
        if (narg <= 0) goto T282;
 
1072
        else {
 
1073
        V158= first;}
 
1074
        --narg; goto T283;
 
1075
        goto T282;
 
1076
T282:;
 
1077
        V158= Cnil;
 
1078
        goto T283;
 
1079
T283:;
 
1080
        {long V159;
 
1081
        object V160;
 
1082
        register object V161;
 
1083
        V159= -1;
 
1084
        {object V162;
 
1085
        object V163= (V153);
 
1086
        object V164= (V154);
 
1087
        if(V163==Cnil||V164==Cnil){
 
1088
        V160= Cnil;
 
1089
        goto T286;}
 
1090
        base[2]=V162=MMcons(Cnil,Cnil);
 
1091
        goto T287;
 
1092
T287:;
 
1093
        if(((V164->c.c_car))==(Ct)){
 
1094
        goto T290;}
 
1095
        V159= (long)(V159)+(1);
 
1096
        base[4]= Cnil;
 
1097
        base[5]= VV[80];
 
1098
        base[6]= CMPmake_fixnum(V159);
 
1099
        vs_top=(vs_base=base+4)+3;
 
1100
        Lformat();
 
1101
        vs_top=sup;
 
1102
        base[3]= vs_base[0];
 
1103
        base[4]= (VV[81]->s.s_dbind);
 
1104
        vs_top=(vs_base=base+3)+2;
 
1105
        Lintern();
 
1106
        vs_top=sup;
 
1107
        V167= vs_base[0];
 
1108
        {object V169;
 
1109
        V169= CMPcar((V158));
 
1110
        V158= CMPcdr((V158));
 
1111
        V168= (V169);}
 
1112
        V170= list(2,V167,(VFUN_NARGS=4,(*(LnkLI190))((V164->c.c_car),(V163->c.c_car),VV[82],V168)));
 
1113
        (V162->c.c_cdr)= make_cons(/* INLINE-ARGS */V170,Cnil);
 
1114
        goto T288;
 
1115
        goto T290;
 
1116
T290:;
 
1117
        (V162->c.c_cdr)= Cnil;
 
1118
        goto T288;
 
1119
T288:;
 
1120
        while(MMcdr(V162)!=Cnil)V162=MMcdr(V162);
 
1121
        if((V163=MMcdr(V163))==Cnil||(V164=MMcdr(V164))==Cnil){
 
1122
        base[2]=base[2]->c.c_cdr;
 
1123
        V160= base[2];
 
1124
        goto T286;}
 
1125
        goto T287;}
 
1126
        goto T286;
 
1127
T286:;
 
1128
        {object V171;
 
1129
        object V172= (V160);
 
1130
        if(V172==Cnil){
 
1131
        V161= Cnil;
 
1132
        goto T304;}
 
1133
        base[2]=V171=MMcons(Cnil,Cnil);
 
1134
        goto T305;
 
1135
T305:;
 
1136
        (V171->c.c_car)= CMPcar((V172->c.c_car));
 
1137
        if((V172=MMcdr(V172))==Cnil){
 
1138
        V161= base[2];
 
1139
        goto T304;}
 
1140
        V171=MMcdr(V171)=MMcons(Cnil,Cnil);
 
1141
        goto T305;}
 
1142
        goto T304;
 
1143
T304:;
 
1144
        if(((V161))!=Cnil){
 
1145
        goto T307;}
 
1146
        base[2]= VV[83];
 
1147
        vs_top=(vs_base=base+2)+1;
 
1148
        Lerror();
 
1149
        vs_top=sup;
 
1150
        goto T307;
 
1151
T307:;
 
1152
        V173= listA(6,VV[87],VV[88],VV[89],VV[90],VV[91],(V160));
 
1153
        if((CMPcdr((V161)))==Cnil){
 
1154
        goto T313;}
 
1155
        V174= (*(LnkLI191))((V161),VV[82],(V157));
 
1156
        goto T311;
 
1157
        goto T313;
 
1158
T313:;
 
1159
        if(((V157))==Cnil){
 
1160
        goto T316;}
 
1161
        V174= (*(LnkLI192))(CMPcar((V161)),VV[82],(V157));
 
1162
        goto T311;
 
1163
        goto T316;
 
1164
T316:;
 
1165
        V174= (*(LnkLI193))(CMPcar((V161)),VV[82]);
 
1166
        goto T311;
 
1167
T311:;
 
1168
        V175= list(5,VV[14],/* INLINE-ARGS */V173,VV[92],V174,list(3,VV[93],VV[85],(V155)));
 
1169
        {object V176 = list(3,VV[84],VV[85],list(4,VV[86],/* INLINE-ARGS */V175,VV[82],list(3,VV[93],VV[85],(V156))));
 
1170
        VMR26(V176)}}
 
1171
        va_end(ap);
 
1172
        base[0]=base[0];
 
1173
        return Cnil;}
 
1174
        }
 
1175
/*      local entry for function EMIT-1-NIL-DLAP        */
 
1176
 
 
1177
static object LI27(V179,V180)
 
1178
 
 
1179
object V179;object V180;
 
1180
{        VMB27 VMS27 VMV27
 
1181
        goto TTL;
 
1182
TTL:;
 
1183
        V181= list(2,list(2,VV[94],(*(LnkLI194))((V179),(V180))),VV[95]);
 
1184
        V182= list(3,VV[99],list(3,VV[54],(V179),VV[100]),VV[101]);
 
1185
        V183= list(3,VV[105],VV[106],list(3,VV[99],list(3,VV[54],VV[107],(V179)),VV[108]));
 
1186
        {object V184 = list(4,VV[34],/* INLINE-ARGS */V181,VV[96],list(3,VV[84],VV[97],list(5,VV[98],/* INLINE-ARGS */V182,VV[102],VV[103],list(4,VV[99],VV[104],/* INLINE-ARGS */V183,list(2,VV[109],(V180))))));
 
1187
        VMR27(V184)}
 
1188
        return Cnil;
 
1189
}
 
1190
/*      macro definition for GET-CACHE-VECTOR-LOCK-COUNT        */
 
1191
 
 
1192
static void L28()
 
1193
{register object *base=vs_base;
 
1194
        register object *sup=base+VM28; VC28
 
1195
        vs_check;
 
1196
        check_arg(2);
 
1197
        vs_top=sup;
 
1198
        {object V185=base[0]->c.c_cdr;
 
1199
        if(endp(V185))invalid_macro_call();
 
1200
        base[2]= (V185->c.c_car);
 
1201
        V185=V185->c.c_cdr;
 
1202
        if(!endp(V185))invalid_macro_call();}
 
1203
        V186= list(2,VV[110],list(2,VV[111],base[2]));
 
1204
        base[3]= listA(3,VV[14],make_cons(/* INLINE-ARGS */V186,Cnil),VV[112]);
 
1205
        vs_top=(vs_base=base+3)+1;
 
1206
        return;
 
1207
}
 
1208
/*      local entry for function EMIT-1-T-DLAP  */
 
1209
 
 
1210
static object LI29(V190,V191,V192)
 
1211
 
 
1212
object V190;object V191;object V192;
 
1213
{        VMB29 VMS29 VMV29
 
1214
        goto TTL;
 
1215
TTL:;
 
1216
        V193= list(2,list(2,VV[94],(*(LnkLI194))((V190),(V191))),VV[113]);
 
1217
        V194= list(3,VV[54],(V190),VV[117]);
 
1218
        V195= list(4,VV[99],/* INLINE-ARGS */V194,list(3,VV[39],(V192),VV[118]),VV[119]);
 
1219
        V196= list(3,VV[54],VV[124],(V190));
 
1220
        V197= list(3,VV[105],VV[123],list(4,VV[99],/* INLINE-ARGS */V196,list(3,VV[39],(V192),VV[125]),VV[126]));
 
1221
        V198= list(3,VV[84],VV[97],list(5,VV[98],/* INLINE-ARGS */V195,VV[120],VV[121],list(4,VV[99],VV[122],/* INLINE-ARGS */V197,list(2,VV[109],(V191)))));
 
1222
        {object V199 = list(4,VV[14],/* INLINE-ARGS */V193,VV[114],list(5,VV[14],VV[115],VV[116],/* INLINE-ARGS */V198,list(3,VV[127],VV[128],list(2,VV[109],(V191)))));
 
1223
        VMR29(V199)}
 
1224
        return Cnil;
 
1225
}
 
1226
/*      local entry for function EMIT-GREATER-THAN-1-DLAP       */
 
1227
 
 
1228
static object LI30(V203,V204,V205)
 
1229
 
 
1230
register object V203;object V204;register object V205;
 
1231
{        VMB30 VMS30 VMV30
 
1232
        goto TTL;
 
1233
TTL:;
 
1234
        {object V206;
 
1235
        V207 = CMPmake_fixnum((long)length((V203)));
 
1236
        if(((V205))==Cnil){
 
1237
        goto T321;}
 
1238
        V208= small_fixnum(1);
 
1239
        goto T319;
 
1240
        goto T321;
 
1241
T321:;
 
1242
        V208= small_fixnum(0);
 
1243
        goto T319;
 
1244
T319:;
 
1245
        V209= number_plus(V207,V208);
 
1246
        V206= (*(LnkLI195))(/* INLINE-ARGS */V209);
 
1247
        V210= (*(LnkLI196))((V203),(V204));
 
1248
        V211= list(3,VV[39],VV[135],list(3,VV[136],VV[137],list(3,VV[138],VV[139],(V206))));
 
1249
        {object V213;
 
1250
        object V214= (V203);
 
1251
        if(V214==Cnil){
 
1252
        V212= Cnil;
 
1253
        goto T323;}
 
1254
        base[0]=V213=MMcons(Cnil,Cnil);
 
1255
        goto T324;
 
1256
T324:;
 
1257
        (V213->c.c_car)= list(3,VV[54],(V214->c.c_car),VV[141]);
 
1258
        if((V214=MMcdr(V214))==Cnil){
 
1259
        V212= base[0];
 
1260
        goto T323;}
 
1261
        V213=MMcdr(V213)=MMcons(Cnil,Cnil);
 
1262
        goto T324;}
 
1263
        goto T323;
 
1264
T323:;
 
1265
        V216= make_cons(VV[140],V212);
 
1266
        if(((V205))==Cnil){
 
1267
        goto T328;}
 
1268
        V217= list(2,VV[142],list(3,VV[39],(V205),VV[143]));
 
1269
        goto T326;
 
1270
        goto T328;
 
1271
T328:;
 
1272
        V217= Cnil;
 
1273
        goto T326;
 
1274
T326:;
 
1275
        V218= listA(3,VV[99],/* INLINE-ARGS */V216,append(V217,VV[144]));
 
1276
        {object V220;
 
1277
        object V221= (V203);
 
1278
        if(V221==Cnil){
 
1279
        V219= Cnil;
 
1280
        goto T330;}
 
1281
        base[0]=V220=MMcons(Cnil,Cnil);
 
1282
        goto T331;
 
1283
T331:;
 
1284
        (V220->c.c_car)= list(3,VV[54],(V221->c.c_car),VV[150]);
 
1285
        if((V221=MMcdr(V221))==Cnil){
 
1286
        V219= base[0];
 
1287
        goto T330;}
 
1288
        V220=MMcdr(V220)=MMcons(Cnil,Cnil);
 
1289
        goto T331;}
 
1290
        goto T330;
 
1291
T330:;
 
1292
        V223= make_cons(VV[140],V219);
 
1293
        if(((V205))==Cnil){
 
1294
        goto T335;}
 
1295
        V225= list(3,VV[39],(V205),VV[151]);
 
1296
        V224= make_cons(/* INLINE-ARGS */V225,Cnil);
 
1297
        goto T333;
 
1298
        goto T335;
 
1299
T335:;
 
1300
        V224= Cnil;
 
1301
        goto T333;
 
1302
T333:;
 
1303
        V226= list(3,VV[105],VV[148],list(3,VV[14],VV[149],listA(3,VV[99],/* INLINE-ARGS */V223,append(V224,VV[152]))));
 
1304
        V227= list(3,VV[84],VV[97],list(6,VV[98],/* INLINE-ARGS */V211,/* INLINE-ARGS */V218,VV[145],VV[146],list(4,VV[99],VV[147],/* INLINE-ARGS */V226,list(2,VV[109],(V204)))));
 
1305
        {object V228 = list(5,VV[14],VV[129],VV[130],/* INLINE-ARGS */V210,list(4,VV[14],VV[131],VV[132],list(5,VV[14],VV[133],VV[134],/* INLINE-ARGS */V227,list(3,VV[127],VV[153],list(2,VV[109],(V204))))));
 
1306
        VMR30(V228)}}
 
1307
        base[0]=base[0];
 
1308
        return Cnil;
 
1309
}
 
1310
/*      local entry for function EMIT-1-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION  */
 
1311
 
 
1312
static object LI31(V231,V232)
 
1313
 
 
1314
object V231;object V232;
 
1315
{        VMB31 VMS31 VMV31
 
1316
        goto TTL;
 
1317
TTL:;
 
1318
        V233= list(2,VV[154],list(3,VV[50],(V231),VV[155]));
 
1319
        V234= make_cons(/* INLINE-ARGS */V233,Cnil);
 
1320
        V235= list(3,VV[99],VV[157],list(2,VV[109],(V232)));
 
1321
        V236= list(3,VV[136],VV[137],VV[158]);
 
1322
        {object V238 = list(5,VV[14],/* INLINE-ARGS */V234,VV[156],/* INLINE-ARGS */V235,V236);
 
1323
        VMR31(V238)}
 
1324
        return Cnil;
 
1325
}
 
1326
/*      local entry for function EMIT-N-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION  */
 
1327
 
 
1328
static object LI32(V241,V242)
 
1329
 
 
1330
object V241;object V242;
 
1331
{        VMB32 VMS32 VMV32
 
1332
        goto TTL;
 
1333
TTL:;
 
1334
        {register long V244;
 
1335
        long V245;
 
1336
        V244= 0;
 
1337
        V245= (long)length((V241));
 
1338
        {object V246;
 
1339
        object V247= (V241);
 
1340
        if(V247==Cnil){
 
1341
        V243= Cnil;
 
1342
        goto T338;}
 
1343
        base[0]=V246=MMcons(Cnil,Cnil);
 
1344
        goto T341;
 
1345
T341:;
 
1346
        V249= list(2,VV[154],list(3,VV[50],(V247->c.c_car),VV[155]));
 
1347
        V250= make_cons(/* INLINE-ARGS */V249,Cnil);
 
1348
        V251= list(3,VV[99],VV[161],list(2,VV[109],(V242)));
 
1349
        V244= (long)(V244)+(1);
 
1350
        if(((long)({fixnum _t=(V244)%(4);((4)<0 && _t<=0) || ((4)>0 && _t>=0) ? _t : _t + (4);}))==0){
 
1351
        goto T346;}
 
1352
        if(!((V244)==(V245))){
 
1353
        goto T347;}
 
1354
        goto T346;
 
1355
T346:;
 
1356
        V253= list(3,VV[136],VV[137],VV[163]);
 
1357
        V255= list(3,VV[39],VV[94],V253);
 
1358
        V252= make_cons(/* INLINE-ARGS */V255,Cnil);
 
1359
        goto T343;
 
1360
        goto T347;
 
1361
T347:;
 
1362
        V252= Cnil;
 
1363
        goto T343;
 
1364
T343:;
 
1365
        (V246->c.c_car)= listA(6,VV[14],/* INLINE-ARGS */V250,VV[160],/* INLINE-ARGS */V251,VV[162],V252);
 
1366
        if((V247=MMcdr(V247))==Cnil){
 
1367
        V243= base[0];
 
1368
        goto T338;}
 
1369
        V246=MMcdr(V246)=MMcons(Cnil,Cnil);
 
1370
        goto T341;}}
 
1371
        goto T338;
 
1372
T338:;
 
1373
        {object V256 = make_cons(VV[159],V243);
 
1374
        VMR32(V256)}
 
1375
        base[0]=base[0];
 
1376
        return Cnil;
 
1377
}
 
1378
/*      local entry for function EMIT-FETCH-WRAPPER     */
 
1379
 
 
1380
static object LI33(object V259,object V258,object V257,object first,...)
 
1381
{       
 
1382
        va_list ap;
 
1383
        int narg = VFUN_NARGS; VMB33 VMS33 VMV33
 
1384
        {object V260;
 
1385
        register object V261;
 
1386
        object V262;
 
1387
        register object V263;
 
1388
        va_start(ap,first);
 
1389
        if(narg <3) too_few_arguments();
 
1390
        V260= V259;
 
1391
        V261= V258;
 
1392
        V262= V257;
 
1393
        narg = narg - 3;
 
1394
        if (narg <= 0) goto T352;
 
1395
        else {
 
1396
        V263= first;}
 
1397
        --narg; goto T353;
 
1398
        goto T352;
 
1399
T352:;
 
1400
        V263= Cnil;
 
1401
        goto T353;
 
1402
T353:;
 
1403
        {object V265= V260;
 
1404
        if((V265!= VV[197]))goto T355;
 
1405
        V266= list(2,VV[38],(V261));
 
1406
        if(((V263))==Cnil){
 
1407
        goto T358;}
 
1408
        V268= list(3,VV[39],(V263),list(2,VV[40],(V261)));
 
1409
        V267= make_cons(/* INLINE-ARGS */V268,Cnil);
 
1410
        goto T356;
 
1411
        goto T358;
 
1412
T358:;
 
1413
        V267= Cnil;
 
1414
        goto T356;
 
1415
T356:;
 
1416
        V269= list(2,VV[41],(V261));
 
1417
        V270= make_cons(/* INLINE-ARGS */V269,Cnil);
 
1418
        V271= append(V267,/* INLINE-ARGS */V270);
 
1419
        V272= make_cons(/* INLINE-ARGS */V266,/* INLINE-ARGS */V271);
 
1420
        V273= list(2,VV[42],(V261));
 
1421
        if(((V263))==Cnil){
 
1422
        goto T362;}
 
1423
        V275= list(3,VV[39],(V263),list(2,VV[43],(V261)));
 
1424
        V274= make_cons(/* INLINE-ARGS */V275,Cnil);
 
1425
        goto T360;
 
1426
        goto T362;
 
1427
T362:;
 
1428
        V274= Cnil;
 
1429
        goto T360;
 
1430
T360:;
 
1431
        V276= list(2,VV[44],(V261));
 
1432
        V277= make_cons(/* INLINE-ARGS */V276,Cnil);
 
1433
        V278= append(V274,/* INLINE-ARGS */V277);
 
1434
        V279= make_cons(/* INLINE-ARGS */V273,/* INLINE-ARGS */V278);
 
1435
        {object V280 = list(4,VV[37],/* INLINE-ARGS */V272,/* INLINE-ARGS */V279,list(2,Ct,list(2,VV[109],(V262))));
 
1436
        VMR33(V280)}
 
1437
        goto T355;
 
1438
T355:;
 
1439
        if((V265!= VV[198]))goto T364;
 
1440
        if(((V263))==Cnil){
 
1441
        goto T365;}
 
1442
        base[0]= VV[164];
 
1443
        vs_top=(vs_base=base+0)+1;
 
1444
        Lerror();
 
1445
        vs_top=sup;
 
1446
        goto T365;
 
1447
T365:;
 
1448
        {object V281 = list(2,VV[165],(V261));
 
1449
        VMR33(V281)}
 
1450
        goto T364;
 
1451
T364:;
 
1452
        if((V265!= VV[199])
 
1453
        && (V265!= VV[200]))goto T369;
 
1454
        if(((V263))==Cnil){
 
1455
        goto T370;}
 
1456
        base[0]= VV[166];
 
1457
        vs_top=(vs_base=base+0)+1;
 
1458
        Lerror();
 
1459
        vs_top=sup;
 
1460
        goto T370;
 
1461
T370:;
 
1462
        {object V282 = list(2,VV[167],(V261));
 
1463
        VMR33(V282)}
 
1464
        goto T369;
 
1465
T369:;
 
1466
        base[0]= VV[20];
 
1467
        base[1]= VV[21];
 
1468
        base[2]= VV[22];
 
1469
        base[3]= VV[23];
 
1470
        base[4]= V260;
 
1471
        base[5]= VV[24];
 
1472
        base[6]= VV[168];
 
1473
        base[7]= VV[26];
 
1474
        base[8]= VV[169];
 
1475
        vs_top=(vs_base=base+0)+9;
 
1476
        (void) (*Lnk183)();
 
1477
        vs_top=sup;
 
1478
        {object V283 = vs_base[0];
 
1479
        VMR33(V283)}}
 
1480
        va_end(ap);
 
1481
        base[0]=base[0];
 
1482
        return Cnil;}
 
1483
        }
 
1484
static object  LnkTLI196(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[196],(void **)(void *)&LnkLI196,2,first,ap);va_end(ap);return V1;} /* EMIT-N-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION */
 
1485
static object  LnkTLI195(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[195],(void **)(void *)&LnkLI195,1,first,ap);va_end(ap);return V1;} /* COMPUTE-LINE-SIZE */
 
1486
static object  LnkTLI194(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[194],(void **)(void *)&LnkLI194,2,first,ap);va_end(ap);return V1;} /* EMIT-1-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION */
 
1487
static object  LnkTLI193(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[193],(void **)(void *)&LnkLI193,2,first,ap);va_end(ap);return V1;} /* EMIT-1-NIL-DLAP */
 
1488
static object  LnkTLI192(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[192],(void **)(void *)&LnkLI192,3,first,ap);va_end(ap);return V1;} /* EMIT-1-T-DLAP */
 
1489
static object  LnkTLI191(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[191],(void **)(void *)&LnkLI191,3,first,ap);va_end(ap);return V1;} /* EMIT-GREATER-THAN-1-DLAP */
 
1490
static object  LnkTLI190(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_vproc_new(VV[190],(void **)(void *)&LnkLI190,first,ap);va_end(ap);return V1;} /* EMIT-FETCH-WRAPPER */
 
1491
static object  LnkTLI189(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_vproc_new(VV[189],(void **)(void *)&LnkLI189,first,ap);va_end(ap);return V1;} /* EMIT-MISS */
 
1492
static void LnkT188(){ call_or_link(VV[188],(void **)(void *)&Lnk188);} /* EMIT-CHECKING-OR-CACHING-FUNCTION */
 
1493
static object  LnkTLI187(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[187],(void **)(void *)&LnkLI187,6,first,ap);va_end(ap);return V1;} /* EMIT-SLOT-ACCESS */
 
1494
static object  LnkTLI186(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_vproc_new(VV[186],(void **)(void *)&LnkLI186,first,ap);va_end(ap);return V1;} /* EMIT-DLAP */
 
1495
static void LnkT185(){ call_or_link(VV[185],(void **)(void *)&Lnk185);} /* EMIT-ONE-OR-N-INDEX-READERWRITER-FUNCTION */
 
1496
static object  LnkTLI184(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[184],(void **)(void *)&LnkLI184,3,first,ap);va_end(ap);return V1;} /* EMIT-BOUNDP-CHECK */
 
1497
static void LnkT183(){ call_or_link(VV[183],(void **)(void *)&Lnk183);} /* ERROR */
 
1498
static object  LnkTLI182(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[182],(void **)(void *)&LnkLI182,1,first,ap);va_end(ap);return V1;} /* DFUN-ARG-SYMBOL */
 
1499
static object  LnkTLI181(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[181],(void **)(void *)&LnkLI181,3,first,ap);va_end(ap);return V1;} /* EMIT-SLOT-READ-FORM */
 
1500
static object  LnkTLI180(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[180],(void **)(void *)&LnkLI180,1,first,ap);va_end(ap);return V1;} /* WRAPPER-FIELD */
 
1501
static void LnkT179(){ call_or_link(VV[179],(void **)(void *)&Lnk179);} /* EMIT-READERWRITER-FUNCTION */
 
1502
static void LnkT178(){ call_or_link(VV[178],(void **)(void *)&Lnk178);} /* COMPILE-LAMBDA */
 
1503
static void LnkT177(){ call_or_link(VV[177],(void **)(void *)&Lnk177);} /* EMIT-DEFAULT-ONLY */
 
1504
static void LnkT176(){ call_or_link(VV[176],(void **)(void *)&Lnk176);} /* GENERATING-LISP */
 
1505
static void LnkT175(){ call_or_link(VV[175],(void **)(void *)&Lnk175);} /* REMOVE */
 
1506
static object  LnkTLI174(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[174],(void **)(void *)&LnkLI174,2,first,ap);va_end(ap);return V1;} /* MAKE-DLAP-LAMBDA-LIST */
 
1507
static void LnkT173(){ call_or_link(VV[173],(void **)(void *)&Lnk173);} /* EMIT-DEFAULT-ONLY-FUNCTION */
 
1508
static void LnkT172(){ call_or_link(VV[172],(void **)(void *)&Lnk172);} /* EMIT-CHECKING-OR-CACHING */
 
1509
static void LnkT171(){ call_or_link(VV[171],(void **)(void *)&Lnk171);} /* EMIT-ONE-OR-N-INDEX-READERWRITER */
 
1510
static void LnkT170(){ call_or_link(VV[170],(void **)(void *)&Lnk170);} /* EMIT-READERWRITER */
 
1511
 
 
1512
#ifdef SYSTEM_SPECIAL_INIT
 
1513
SYSTEM_SPECIAL_INIT
 
1514
#endif
 
1515