/[gcl]/gcl/lsp/gcl_serror.c
ViewVC logotype

Diff of /gcl/lsp/gcl_serror.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1 by camm, Sun Sep 14 02:30:35 2003 UTC revision 1.2 by camm, Sun Sep 14 02:43:06 2003 UTC
# Line 0  Line 1 
1    
2    #include "cmpinclude.h"
3    #include "gcl_serror.h"
4    void init_gcl_serror(){do_init(VV);}
5    /*      function definition for MAKE-ERROR-CONDITION    */
6    
7    static void L1()
8    {register object *base=vs_base;
9            register object *sup=base+VM1; VC1
10            vs_reserve(VM1);
11            {object V1;
12            object V2;
13            object V3;
14            object V4;
15            object V5;
16            object V6;
17            parse_key(vs_base,FALSE,FALSE,6,VV[25],VV[26],VV[27],VV[28],VV[29],VV[30]);
18            vs_top=sup;
19            V1=(base[0]);
20            V2=(base[1]);
21            V3=(base[2]);
22            V4=(base[3]);
23            V5=(base[4]);
24            V6=(base[5]);
25            base[12]= VV[0];
26            base[13]= (V1);
27            base[14]= (V2);
28            base[15]= (V3);
29            base[16]= (V4);
30            base[17]= (V5);
31            base[18]= (V6);
32            vs_top=(vs_base=base+12)+7;
33            siLmake_structure();
34            return;
35            }
36    }
37    /*      macro definition for COND-ERROR */
38    
39    static void L2()
40    {register object *base=vs_base;
41            register object *sup=base+VM2; VC2
42            vs_reserve(VM2);
43            check_arg(2);
44            vs_top=sup;
45            {object V7=base[0]->c.c_cdr;
46            if(endp(V7))invalid_macro_call();
47            base[2]= (V7->c.c_car);
48            V7=V7->c.c_cdr;
49            if(endp(V7))invalid_macro_call();
50            base[3]= (V7->c.c_car);
51            V7=V7->c.c_cdr;
52            base[4]= V7;}
53            if(base[2]!=Cnil){
54            goto T8;}
55            base[2]= VV[1];
56            goto T8;
57    T8:;
58            {object V8;
59            base[5]= VV[2];
60            vs_top=(vs_base=base+5)+1;
61            Lgensym();
62            vs_top=sup;
63            V8= vs_base[0];
64            {register object V9;
65            V10= list(2,VV[4],(V8));
66            V11= car(base[2]);
67            {object V13;
68            object V14= base[4];
69            if(endp(V14)){
70            V12= Cnil;
71            goto T13;}
72            base[5]=V13=MMcons(Cnil,Cnil);
73            goto T14;
74    T14:;
75            (V13->c.c_car)= car((V14->c.c_car));
76            V14=MMcdr(V14);
77            if(endp(V14)){
78            V12= base[5];
79            goto T13;}
80            V13=MMcdr(V13)=MMcons(Cnil,Cnil);
81            goto T14;}
82            goto T13;
83    T13:;
84            V15= make_cons(VV[13],V12);
85            V16= list(3,VV[3],/* INLINE-ARGS */V10,list(3,VV[5],VV[6],list(3,VV[7],list(3,VV[8],list(3,VV[9],list(2,VV[10],list(4,VV[11],base[2],/* INLINE-ARGS */V11,list(3,VV[12],/* INLINE-ARGS */V15,list(2,VV[4],(V8))))),VV[14]),base[3]),VV[15])));
86            V17= append(base[4],VV[17]);
87            V9= list(2,/* INLINE-ARGS */V16,make_cons(VV[16],/* INLINE-ARGS */V17));
88            if((base[2])==Cnil){
89            goto T18;}
90            V9= listA(3,VV[18],base[2],(V9));
91            goto T16;
92            goto T18;
93    T18:;
94            V9= make_cons(VV[8],(V9));
95            goto T16;
96    T16:;
97            base[5]= list(3,VV[19],VV[6],(V9));
98            vs_top=(vs_base=base+5)+1;
99            return;}}
100    }
101    /*      macro definition for COND-ANY-ERROR     */
102    
103    static void L3()
104    {register object *base=vs_base;
105            register object *sup=base+VM3; VC3
106            vs_reserve(VM3);
107            check_arg(2);
108            vs_top=sup;
109            {object V18=base[0]->c.c_cdr;
110            if(endp(V18))invalid_macro_call();
111            base[2]= (V18->c.c_car);
112            V18=V18->c.c_cdr;
113            if(endp(V18))invalid_macro_call();
114            base[3]= (V18->c.c_car);
115            V18=V18->c.c_cdr;
116            base[4]= V18;}
117            {register object V19;
118            V20= list(3,VV[20],VV[21],list(3,VV[3],VV[22],list(3,VV[5],VV[6],base[3])));
119            V21= list(2,Ct,make_cons(VV[23],base[2]));
120            V22= make_cons(/* INLINE-ARGS */V21,Cnil);
121            V23= append(base[4],/* INLINE-ARGS */V22);
122            V19= list(2,/* INLINE-ARGS */V20,make_cons(VV[16],/* INLINE-ARGS */V23));
123            if((base[2])==Cnil){
124            goto T25;}
125            V19= listA(3,VV[18],base[2],(V19));
126            goto T23;
127            goto T25;
128    T25:;
129            V19= make_cons(VV[8],(V19));
130            goto T23;
131    T23:;
132            base[5]= list(3,VV[19],VV[6],(V19));
133            vs_top=(vs_base=base+5)+1;
134            return;}
135    }
136    /*      local entry for function UNIVERSAL-ERROR-HANDLER        */
137    
138    static object LI4(object first,...)
139    {      
140            va_list ap;
141            int narg = VFUN_NARGS; VMB4 VMS4 VMV4
142            {register object V24;
143            va_start(ap,first);
144            narg= narg - 0;
145            V25 = list_vector_new(narg,first,ap);
146            V24= V25;
147            if((symbol_value(VV[24]))==Cnil){
148            goto T29;}
149            vs_base=vs_top;
150            (void) (*Lnk72)();
151            vs_top=sup;
152            vs_base=vs_top;
153            (void) (*Lnk73)();
154            vs_top=sup;
155            vs_base=vs_top;
156            (void) (*Lnk74)();
157            vs_top=sup;
158            goto T29;
159    T29:;
160            {register object V26;
161            base[0]= VV[25];
162            base[1]= car((V24));
163            base[2]= VV[26];
164            base[4]= (V24);
165            vs_top=(vs_base=base+4)+1;
166            (void) (*Lnk75)();
167            vs_top=sup;
168            base[3]= vs_base[0];
169            base[4]= VV[27];
170            base[5]= caddr((V24));
171            base[6]= VV[28];
172            base[7]= cadddr((V24));
173            base[8]= VV[29];
174            base[10]= cdr(cddddr((V24)));
175            vs_top=(vs_base=base+10)+1;
176            Lcopy_list();
177            vs_top=sup;
178            base[9]= vs_base[0];
179            base[10]= VV[30];
180            base[12]= (V24);
181            vs_top=(vs_base=base+12)+1;
182            Lcopy_list();
183            vs_top=sup;
184            base[11]= vs_base[0];
185            vs_top=(vs_base=base+0)+12;
186            (void) (*Lnk76)();
187            vs_top=sup;
188            V26= vs_base[0];
189            if((symbol_value(VV[31]))==Cnil){
190            goto T51;}
191            {frame_ptr fr;
192            fr=frs_sch_catch(VV[32]);
193            if(fr==NULL) FEerror("The tag ~s is undefined.",1,VV[32]);
194            base[0]= (V26);
195            vs_top=(vs_base=base+0)+1;
196            unwind(fr,VV[32]);}
197            goto T51;
198    T51:;
199            {object V27;
200            {register object V28;
201            V28= Cnil;
202            {register long V29;
203            register long V30;
204            V29= 0;
205            base[0]= symbol_value(VV[14]);
206            vs_top=(vs_base=base+0)+1;
207            Lfill_pointer();
208            vs_top=sup;
209            V30= fix(vs_base[0]);
210            goto T59;
211    T59:;
212            if(!((V29)>=(V30))){
213            goto T60;}
214            V27= Cnil;
215            goto T54;
216            goto T60;
217    T60:;
218            V31= aref1(symbol_value(VV[14]),V29);
219            V28= (
220            V32 = /* INLINE-ARGS */V31,
221            (type_of(V32) == t_sfun ?(*((V32)->sfn.sfn_self)):
222            (fcall.argd=1,type_of(V32)==t_vfun) ?
223            (*((V32)->sfn.sfn_self)):
224            (fcall.fun=(V32),fcalln))((V26)));
225            if(((V28))==Cnil){
226            goto T64;}
227            {frame_ptr fr;
228            fr=frs_sch_catch((V28));
229            if(fr==NULL) FEerror("The tag ~s is undefined.",1,(V28));
230            base[0]= (V26);
231            vs_top=(vs_base=base+0)+1;
232            unwind(fr,(V28));}
233            goto T64;
234    T64:;
235            V29= (long)(V29)+1;
236            goto T59;}}
237            goto T54;
238    T54:;
239            if(((V27))==Cnil){
240            goto T73;}
241            {object V33 = (V27);
242            VMR4(V33)}
243            goto T73;
244    T73:;
245            base[0]= get(symbol_value(VV[33]),VV[34],Cnil);
246            {object V34;
247            V34= (V24);
248             vs_top=base+1;
249             while(!endp(V34))
250             {vs_push(car(V34));V34=cdr(V34);}
251            vs_base=base+1;}
252            super_funcall_no_event(base[0]);
253            vs_top=sup;
254            {object V35 = vs_base[0];
255            VMR4(V35)}}}
256            va_end(ap);
257            base[0]=base[0];
258            return Cnil;}
259            }
260    /*      function definition for INF-SIGNAL      */
261    
262    static void L5()
263    {register object *base=vs_base;
264            register object *sup=base+VM5; VC5
265            vs_reserve(VM5);
266            {object V36;
267            vs_top[0]=Cnil;
268            {object *p=vs_top;
269             for(;p>vs_base;p--)p[-1]=MMcons(p[-1],p[0]);}
270            V36=(base[0]);
271            vs_top=sup;
272            base[1]= symbol_value(VV[33]);
273            {object V37;
274            V37= structure_ref(car((V36)),VV[0],5);
275             vs_top=base+2;
276             while(!endp(V37))
277             {vs_push(car(V37));V37=cdr(V37);}
278            vs_base=base+2;}
279            super_funcall_no_event(base[1]);
280            return;
281            }
282    }
283    /*      macro definition for DEF-ERROR-TYPE     */
284    
285    static void L6()
286    {register object *base=vs_base;
287            register object *sup=base+VM6; VC6
288            vs_reserve(VM6);
289            check_arg(2);
290            vs_top=sup;
291            {object V38=base[0]->c.c_cdr;
292            if(endp(V38))invalid_macro_call();
293            base[2]= (V38->c.c_car);
294            V38=V38->c.c_cdr;
295            if(endp(V38))invalid_macro_call();
296            {object V39= (V38->c.c_car);
297            if(endp(V39))invalid_macro_call();
298            base[3]= (V39->c.c_car);
299            V39=V39->c.c_cdr;
300            if(!endp(V39))invalid_macro_call();}
301            V38=V38->c.c_cdr;
302            base[4]= V38;}
303            {object V40;
304            base[6]= Cnil;
305            base[7]= VV[35];
306            base[8]= base[2];
307            vs_top=(vs_base=base+6)+3;
308            Lformat();
309            vs_top=sup;
310            base[5]= vs_base[0];
311            vs_top=(vs_base=base+5)+1;
312            Lintern();
313            vs_top=sup;
314            V40= vs_base[0];
315            V41= listA(4,VV[38],(V40),make_cons(base[3],Cnil),base[4]);
316            base[5]= list(4,VV[36],VV[37],/* INLINE-ARGS */V41,list(4,VV[39],base[2],Cnil,list(4,VV[40],VV[41],VV[42],list(3,VV[40],VV[43],list(2,VV[4],(V40))))));
317            vs_top=(vs_base=base+5)+1;
318            return;}
319    }
320    /*      function definition for WTA-tester      */
321    
322    static void L7()
323    {register object *base=vs_base;
324            register object *sup=base+VM7; VC7
325            vs_reserve(VM7);
326            {object V42;
327            check_arg(1);
328            V42=(base[0]);
329            vs_top=sup;
330            goto TTL;
331    TTL:;
332            V43= structure_ref((V42),VV[0],0);
333            base[1]= (eql(/* INLINE-ARGS */V43,VV[44])?Ct:Cnil);
334            vs_top=(vs_base=base+1)+1;
335            return;
336            }
337    }
338    /*      function definition for G1387   */
339    
340    static void L8()
341    {register object *base=vs_base;
342            register object *sup=base+VM8; VC8
343            vs_reserve(VM8);
344            check_arg(0);
345            vs_top=sup;
346            goto TTL;
347    TTL:;
348            base[0]= list(3,VV[45],VV[0],list(2,VV[46],VV[47]));
349            vs_top=(vs_base=base+0)+1;
350            return;
351    }
352    /*      function definition for SUBSCRIPT-OUT-OF-BOUNDS-tester  */
353    
354    static void L9()
355    {register object *base=vs_base;
356            register object *sup=base+VM9; VC9
357            vs_reserve(VM9);
358            {object V44;
359            check_arg(1);
360            V44=(base[0]);
361            vs_top=sup;
362            goto TTL;
363    TTL:;
364            V45= structure_ref((V44),VV[0],1);
365            base[1]= (equal(/* INLINE-ARGS */V45,VV[48])?Ct:Cnil);
366            vs_top=(vs_base=base+1)+1;
367            return;
368            }
369    }
370    /*      function definition for G1388   */
371    
372    static void L10()
373    {register object *base=vs_base;
374            register object *sup=base+VM10; VC10
375            vs_reserve(VM10);
376            check_arg(0);
377            vs_top=sup;
378            goto TTL;
379    TTL:;
380            base[0]= list(3,VV[45],VV[0],list(2,VV[46],VV[49]));
381            vs_top=(vs_base=base+0)+1;
382            return;
383    }
384    /*      function definition for ERROR-tester    */
385    
386    static void L11()
387    {register object *base=vs_base;
388            register object *sup=base+VM11; VC11
389            vs_reserve(VM11);
390            {object V46;
391            check_arg(1);
392            V46=(base[0]);
393            vs_top=sup;
394            goto TTL;
395    TTL:;
396            V47= structure_ref((V46),VV[0],0);
397            base[1]= (eql(/* INLINE-ARGS */V47,VV[50])?Ct:Cnil);
398            vs_top=(vs_base=base+1)+1;
399            return;
400            }
401    }
402    /*      function definition for G1389   */
403    
404    static void L12()
405    {register object *base=vs_base;
406            register object *sup=base+VM12; VC12
407            vs_reserve(VM12);
408            check_arg(0);
409            vs_top=sup;
410            goto TTL;
411    TTL:;
412            base[0]= list(3,VV[45],VV[0],list(2,VV[46],VV[51]));
413            vs_top=(vs_base=base+0)+1;
414            return;
415    }
416    /*      function definition for WRONG-TYPE-ARGUMENT-tester      */
417    
418    static void L13()
419    {register object *base=vs_base;
420            register object *sup=base+VM13; VC13
421            vs_reserve(VM13);
422            {object V48;
423            check_arg(1);
424            V48=(base[0]);
425            vs_top=sup;
426            goto TTL;
427    TTL:;
428            V49= structure_ref((V48),VV[0],0);
429            base[1]= (eql(/* INLINE-ARGS */V49,VV[52])?Ct:Cnil);
430            vs_top=(vs_base=base+1)+1;
431            return;
432            }
433    }
434    /*      function definition for G1390   */
435    
436    static void L14()
437    {register object *base=vs_base;
438            register object *sup=base+VM14; VC14
439            vs_reserve(VM14);
440            check_arg(0);
441            vs_top=sup;
442            goto TTL;
443    TTL:;
444            base[0]= list(3,VV[45],VV[0],list(2,VV[46],VV[53]));
445            vs_top=(vs_base=base+0)+1;
446            return;
447    }
448    /*      function definition for TOO-FEW-ARGUMENTS-tester        */
449    
450    static void L15()
451    {register object *base=vs_base;
452            register object *sup=base+VM15; VC15
453            vs_reserve(VM15);
454            {object V50;
455            check_arg(1);
456            V50=(base[0]);
457            vs_top=sup;
458            goto TTL;
459    TTL:;
460            V51= structure_ref((V50),VV[0],0);
461            base[1]= (eql(/* INLINE-ARGS */V51,VV[54])?Ct:Cnil);
462            vs_top=(vs_base=base+1)+1;
463            return;
464            }
465    }
466    /*      function definition for G1391   */
467    
468    static void L16()
469    {register object *base=vs_base;
470            register object *sup=base+VM16; VC16
471            vs_reserve(VM16);
472            check_arg(0);
473            vs_top=sup;
474            goto TTL;
475    TTL:;
476            base[0]= list(3,VV[45],VV[0],list(2,VV[46],VV[55]));
477            vs_top=(vs_base=base+0)+1;
478            return;
479    }
480    /*      function definition for TOO-MANY-ARGUMENTS-tester       */
481    
482    static void L17()
483    {register object *base=vs_base;
484            register object *sup=base+VM17; VC17
485            vs_reserve(VM17);
486            {object V52;
487            check_arg(1);
488            V52=(base[0]);
489            vs_top=sup;
490            goto TTL;
491    TTL:;
492            V53= structure_ref((V52),VV[0],0);
493            base[1]= (eql(/* INLINE-ARGS */V53,VV[56])?Ct:Cnil);
494            vs_top=(vs_base=base+1)+1;
495            return;
496            }
497    }
498    /*      function definition for G1392   */
499    
500    static void L18()
501    {register object *base=vs_base;
502            register object *sup=base+VM18; VC18
503            vs_reserve(VM18);
504            check_arg(0);
505            vs_top=sup;
506            goto TTL;
507    TTL:;
508            base[0]= list(3,VV[45],VV[0],list(2,VV[46],VV[57]));
509            vs_top=(vs_base=base+0)+1;
510            return;
511    }
512    /*      function definition for UNEXPECTED-KEYWORD-tester       */
513    
514    static void L19()
515    {register object *base=vs_base;
516            register object *sup=base+VM19; VC19
517            vs_reserve(VM19);
518            {object V54;
519            check_arg(1);
520            V54=(base[0]);
521            vs_top=sup;
522            goto TTL;
523    TTL:;
524            V55= structure_ref((V54),VV[0],0);
525            base[1]= (eql(/* INLINE-ARGS */V55,VV[58])?Ct:Cnil);
526            vs_top=(vs_base=base+1)+1;
527            return;
528            }
529    }
530    /*      function definition for G1393   */
531    
532    static void L20()
533    {register object *base=vs_base;
534            register object *sup=base+VM20; VC20
535            vs_reserve(VM20);
536            check_arg(0);
537            vs_top=sup;
538            goto TTL;
539    TTL:;
540            base[0]= list(3,VV[45],VV[0],list(2,VV[46],VV[59]));
541            vs_top=(vs_base=base+0)+1;
542            return;
543    }
544    /*      function definition for INVALID-FORM-tester     */
545    
546    static void L21()
547    {register object *base=vs_base;
548            register object *sup=base+VM21; VC21
549            vs_reserve(VM21);
550            {object V56;
551            check_arg(1);
552            V56=(base[0]);
553            vs_top=sup;
554            goto TTL;
555    TTL:;
556            V57= structure_ref((V56),VV[0],0);
557            base[1]= (eql(/* INLINE-ARGS */V57,VV[60])?Ct:Cnil);
558            vs_top=(vs_base=base+1)+1;
559            return;
560            }
561    }
562    /*      function definition for G1394   */
563    
564    static void L22()
565    {register object *base=vs_base;
566            register object *sup=base+VM22; VC22
567            vs_reserve(VM22);
568            check_arg(0);
569            vs_top=sup;
570            goto TTL;
571    TTL:;
572            base[0]= list(3,VV[45],VV[0],list(2,VV[46],VV[61]));
573            vs_top=(vs_base=base+0)+1;
574            return;
575    }
576    /*      function definition for UNBOUND-VARIABLE-tester */
577    
578    static void L23()
579    {register object *base=vs_base;
580            register object *sup=base+VM23; VC23
581            vs_reserve(VM23);
582            {object V58;
583            check_arg(1);
584            V58=(base[0]);
585            vs_top=sup;
586            goto TTL;
587    TTL:;
588            V59= structure_ref((V58),VV[0],0);
589            base[1]= (eql(/* INLINE-ARGS */V59,VV[62])?Ct:Cnil);
590            vs_top=(vs_base=base+1)+1;
591            return;
592            }
593    }
594    /*      function definition for G1395   */
595    
596    static void L24()
597    {register object *base=vs_base;
598            register object *sup=base+VM24; VC24
599            vs_reserve(VM24);
600            check_arg(0);
601            vs_top=sup;
602            goto TTL;
603    TTL:;
604            base[0]= list(3,VV[45],VV[0],list(2,VV[46],VV[63]));
605            vs_top=(vs_base=base+0)+1;
606            return;
607    }
608    /*      function definition for INVALID-VARIABLE-tester */
609    
610    static void L25()
611    {register object *base=vs_base;
612            register object *sup=base+VM25; VC25
613            vs_reserve(VM25);
614            {object V60;
615            check_arg(1);
616            V60=(base[0]);
617            vs_top=sup;
618            goto TTL;
619    TTL:;
620            V61= structure_ref((V60),VV[0],0);
621            base[1]= (eql(/* INLINE-ARGS */V61,VV[64])?Ct:Cnil);
622            vs_top=(vs_base=base+1)+1;
623            return;
624            }
625    }
626    /*      function definition for G1396   */
627    
628    static void L26()
629    {register object *base=vs_base;
630            register object *sup=base+VM26; VC26
631            vs_reserve(VM26);
632            check_arg(0);
633            vs_top=sup;
634            goto TTL;
635    TTL:;
636            base[0]= list(3,VV[45],VV[0],list(2,VV[46],VV[65]));
637            vs_top=(vs_base=base+0)+1;
638            return;
639    }
640    /*      function definition for UNDEFINED-FUNCTION-tester       */
641    
642    static void L27()
643    {register object *base=vs_base;
644            register object *sup=base+VM27; VC27
645            vs_reserve(VM27);
646            {object V62;
647            check_arg(1);
648            V62=(base[0]);
649            vs_top=sup;
650            goto TTL;
651    TTL:;
652            V63= structure_ref((V62),VV[0],0);
653            base[1]= (eql(/* INLINE-ARGS */V63,VV[66])?Ct:Cnil);
654            vs_top=(vs_base=base+1)+1;
655            return;
656            }
657    }
658    /*      function definition for G1397   */
659    
660    static void L28()
661    {register object *base=vs_base;
662            register object *sup=base+VM28; VC28
663            vs_reserve(VM28);
664            check_arg(0);
665            vs_top=sup;
666            goto TTL;
667    TTL:;
668            base[0]= list(3,VV[45],VV[0],list(2,VV[46],VV[67]));
669            vs_top=(vs_base=base+0)+1;
670            return;
671    }
672    /*      function definition for INVALID-FUNCTION-tester */
673    
674    static void L29()
675    {register object *base=vs_base;
676            register object *sup=base+VM29; VC29
677            vs_reserve(VM29);
678            {object V64;
679            check_arg(1);
680            V64=(base[0]);
681            vs_top=sup;
682            goto TTL;
683    TTL:;
684            V65= structure_ref((V64),VV[0],0);
685            base[1]= (eql(/* INLINE-ARGS */V65,VV[68])?Ct:Cnil);
686            vs_top=(vs_base=base+1)+1;
687            return;
688            }
689    }
690    /*      function definition for G1398   */
691    
692    static void L30()
693    {register object *base=vs_base;
694            register object *sup=base+VM30; VC30
695            vs_reserve(VM30);
696            check_arg(0);
697            vs_top=sup;
698            goto TTL;
699    TTL:;
700            base[0]= list(3,VV[45],VV[0],list(2,VV[46],VV[69]));
701            vs_top=(vs_base=base+0)+1;
702            return;
703    }
704    /*      macro definition for CONDITION-CASE     */
705    
706    static void L31()
707    {register object *base=vs_base;
708            register object *sup=base+VM31; VC31
709            vs_reserve(VM31);
710            check_arg(2);
711            vs_top=sup;
712            {object V66=base[0]->c.c_cdr;
713            if(endp(V66))invalid_macro_call();
714            base[2]= (V66->c.c_car);
715            V66=V66->c.c_cdr;
716            if(endp(V66))invalid_macro_call();
717            base[3]= (V66->c.c_car);
718            V66=V66->c.c_cdr;
719            base[4]= V66;}
720            {register object V67;
721            V67= car(base[2]);
722            V68= make_cons((V67),Cnil);
723            {register object V70;
724            register object V71;
725            V70= Cnil;
726            V71= base[4];
727            {register object V72;
728            register object V73;
729            register object V74;
730            register object V75;
731            V72= Cnil;
732            V73= Cnil;
733            V74= Cnil;
734            V75= Cnil;
735            goto T87;
736    T87:;
737            if(((V71))==Cnil){
738            goto T90;}
739            goto T89;
740            goto T90;
741    T90:;
742            goto T88;
743            goto T89;
744    T89:;
745            {register object V76;
746            V76= car((V71));
747            V70= (V76);}
748            {object V77= car((V70));
749            if(!(type_of(V77)==t_cons||(V77)==Cnil)){
750            goto T97;}}
751            V78= list(3,VV[71],(V67),list(2,VV[4],make_cons(VV[13],car((V70)))));
752            V74= make_cons(/* INLINE-ARGS */V78,cdr((V70)));
753            if(((V73))==Cnil){
754            goto T102;}
755            {register object V79;
756            register object V80;
757            V79= (V73);
758            V73= make_cons((V74),Cnil);
759            V80= (V73);
760            if(type_of((V79))!=t_cons)FEwrong_type_argument(Scons,(V79));
761            ((V79))->c.c_cdr = (V80);
762            goto T95;}
763            goto T102;
764    T102:;
765            V73= make_cons((V74),Cnil);
766            V72= (V73);
767            goto T95;
768            goto T97;
769    T97:;
770            V81= list(3,VV[71],(V67),list(2,VV[4],car((V70))));
771            V75= make_cons(/* INLINE-ARGS */V81,cdr((V70)));
772            if(((V73))==Cnil){
773            goto T113;}
774            {register object V82;
775            register object V83;
776            V82= (V73);
777            V73= make_cons((V75),Cnil);
778            V83= (V73);
779            if(type_of((V82))!=t_cons)FEwrong_type_argument(Scons,(V82));
780            ((V82))->c.c_cdr = (V83);
781            goto T95;}
782            goto T113;
783    T113:;
784            V73= make_cons((V75),Cnil);
785            V72= (V73);
786            goto T95;
787    T95:;
788            V71= cdr((V71));
789            goto T87;
790            goto T88;
791    T88:;
792            V69= (V72);
793            goto T85;
794            V69= Cnil;
795            goto T85;
796            V69= Cnil;
797            goto T85;}}
798            goto T85;
799    T85:;
800            base[5]= listA(4,VV[70],/* INLINE-ARGS */V68,base[3],V69);
801            vs_top=(vs_base=base+5)+1;
802            return;}
803    }
804    static void LnkT76(){ call_or_link(VV[76],(void **)(void *)&Lnk76);} /* MAKE-ERROR-CONDITION */
805    static void LnkT75(){ call_or_link(VV[75],(void **)(void *)&Lnk75);} /* FIFTH */
806    static void LnkT74(){ call_or_link(VV[74],(void **)(void *)&Lnk74);} /* BREAK-VS */
807    static void LnkT73(){ call_or_link(VV[73],(void **)(void *)&Lnk73);} /* BACKTRACE */
808    static void LnkT72(){ call_or_link(VV[72],(void **)(void *)&Lnk72);} /* SIMPLE-BACKTRACE */
809    
810    #ifdef SYSTEM_SPECIAL_INIT
811    SYSTEM_SPECIAL_INIT
812    #endif
813    

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.2

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26