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

Diff of /gcl/lsp/arraylib.c

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

revision 1.3 by camm, Fri May 17 22:36:31 2002 UTC revision 1.4 by camm, Wed May 22 20:14:51 2002 UTC
# Line 106  T35:;} Line 106  T35:;}
106          return;          return;
107          }          }
108  }  }
109  /*      function definition for ARRAY-DISPLACEMENT      */  /*      function definition for MAKE-ARRAY      */
110    
111  static L2()  static L2()
112  {register object *base=vs_base;  {register object *base=vs_base;
113          register object *sup=base+VM2; VC2          register object *sup=base+VM2; VC2
114          vs_reserve(VM2);          vs_reserve(VM2);
115          {object V8;          {register object V8;
116          check_arg(1);          object V9;
117          V8=(base[0]);          object V10;
118          vs_top=sup;          register object V11;
 TTL:;  
         {object V9;  
         base[1]= (V8);  
         vs_top=(vs_base=base+1)+1;  
         (void) (*Lnk19)();  
         vs_top=sup;  
         V9= vs_base[0];  
         base[1]= car((V9));  
         base[2]= cdr((V9));  
         vs_top=(vs_base=base+1)+2;  
         return;}  
         }  
 }  
 /*      function definition for MAKE-ARRAY      */  
   
 static L3()  
 {register object *base=vs_base;  
         register object *sup=base+VM3; VC3  
         vs_reserve(VM3);  
         {register object V10;  
         object V11;  
119          object V12;          object V12;
120          register object V13;          object V13;
121          object V14;          object V14;
122          object V15;          object V15;
123          object V16;          object V16;
124          object V17;          object V17;
         object V18;  
         object V19;  
125          if(vs_top-vs_base<1) too_few_arguments();          if(vs_top-vs_base<1) too_few_arguments();
126          parse_key(vs_base+1,FALSE,FALSE,8,VV[8],VV[7],VV[9],VV[15],VV[11],VV[20],VV[21],VV[14]);          parse_key(vs_base+1,FALSE,FALSE,8,VV[8],VV[7],VV[9],VV[15],VV[11],VV[19],VV[20],VV[14]);
127          V10=(base[0]);          V8=(base[0]);
128          vs_top=sup;          vs_top=sup;
129          if(base[9]==Cnil){          if(base[9]==Cnil){
130          V11= Ct;          V9= Ct;
131          }else{          }else{
132          V11=(base[1]);}          V9=(base[1]);}
133          V12=(base[2]);          V10=(base[2]);
134          V13=(base[3]);          V11=(base[3]);
135          V14=(base[11]);          V12=(base[11]);
136          V15=(base[4]);          V13=(base[4]);
137          V16=(base[5]);          V14=(base[5]);
138          V17=(base[6]);          V15=(base[6]);
139          if(base[15]==Cnil){          if(base[15]==Cnil){
140          V18= small_fixnum(0);          V16= small_fixnum(0);
141          }else{          }else{
142          V18=(base[7]);}          V16=(base[7]);}
143          V19=(base[8]);          V17=(base[8]);
144          if(!(type_of((V10))==t_fixnum||type_of((V10))==t_bignum)){          if(!(type_of((V8))==t_fixnum||type_of((V8))==t_bignum)){
145          goto T61;}          goto T57;}
146          V10= make_cons((V10),Cnil);          V8= make_cons((V8),Cnil);
147  T61:;  T57:;
148          base[17]= (V11);          base[17]= (V9);
149          vs_top=(vs_base=base+17)+1;          vs_top=(vs_base=base+17)+1;
150          (void) (*Lnk22)();          (void) (*Lnk21)();
151          vs_top=sup;          vs_top=sup;
152          V11= vs_base[0];          V9= vs_base[0];
153          if(!((length((V10)))==(1))){          if(!((length((V8)))==(1))){
154          goto T69;}          goto T65;}
155          {register object V20;          {register object V18;
156          base[17]= (V11);          base[17]= (V9);
157          base[18]= car((V10));          base[18]= car((V8));
158          base[19]= (V15);          base[19]= (V13);
159          base[20]= (V16);          base[20]= (V14);
160          base[21]= (V17);          base[21]= (V15);
161          base[22]= (V18);          base[22]= (V16);
162          base[23]= (V19);          base[23]= (V17);
163          base[24]= (V12);          base[24]= (V10);
164          vs_top=(vs_base=base+17)+8;          vs_top=(vs_base=base+17)+8;
165          siLmake_vector();          siLmake_vector();
166          vs_top=sup;          vs_top=sup;
167          V20= vs_base[0];          V18= vs_base[0];
168          if(((V14))==Cnil){          if(((V12))==Cnil){
169          goto T80;}          goto T76;}
170          {int V21;          {int V19;
171          register int V22;          register int V20;
172          V21= fix(car((V10)));          V19= fix(car((V8)));
173          V22= 0;          V20= 0;
174  T86:;  T82:;
175          if(!((V22)>=(V21))){          if(!((V20)>=(V19))){
176          goto T87;}          goto T83;}
177          goto T80;          goto T76;
178  T87:;  T83:;
179          V23= elt((V13),V22);          V21= elt((V11),V20);
180          (void)(aset1((V20),V22,/* INLINE-ARGS */V23));          (void)(aset1((V18),V20,/* INLINE-ARGS */V21));
181          V22= (V22)+1;          V20= (V20)+1;
182          goto T86;}          goto T82;}
183  T80:;  T76:;
184          base[17]= (V20);          base[17]= (V18);
185          vs_top=(vs_base=base+17)+1;          vs_top=(vs_base=base+17)+1;
186          return;}          return;}
187  T69:;  T65:;
188          {register object V24;          {register object V22;
189          base[18]= (V11);          base[18]= (V9);
190          vs_top=(vs_base=base+18)+1;          vs_top=(vs_base=base+18)+1;
191          (void) (*Lnk23)();          (void) (*Lnk22)();
192          vs_top=sup;          vs_top=sup;
193          base[17]= vs_base[0];          base[17]= vs_base[0];
194          base[18]= (V19);          base[18]= (V17);
195          base[19]= (V12);          base[19]= (V10);
196          base[20]= (V17);          base[20]= (V15);
197          base[21]= (V18);          base[21]= (V16);
198          base[22]= (V10);          base[22]= (V8);
199          vs_top=(vs_base=base+17)+6;          vs_top=(vs_base=base+17)+6;
200          (void) (*Lnk24)();          (void) (*Lnk23)();
201          vs_top=sup;          vs_top=sup;
202          V24= vs_base[0];          V22= vs_base[0];
203          if(((V16))==Cnil){          if(((V14))==Cnil){
204          goto T103;}          goto T99;}
205          base[17]= VV[6];          base[17]= VV[6];
206          vs_top=(vs_base=base+17)+1;          vs_top=(vs_base=base+17)+1;
207          Lerror();          Lerror();
208          vs_top=sup;          vs_top=sup;
209  T103:;  T99:;
210          {register object x= small_fixnum(0),V25= (V10);          {register object x= small_fixnum(0),V23= (V8);
211          while(!endp(V25))          while(!endp(V23))
212          if(eql(x,V25->c.c_car)){          if(eql(x,V23->c.c_car)){
213          goto T107;          goto T103;
214          }else V25=V25->c.c_cdr;}          }else V23=V23->c.c_cdr;}
215          if(((V14))==Cnil){          if(((V12))==Cnil){
216          goto T107;}          goto T103;}
217          {register object V26;          {register object V24;
218          base[17]= make_fixnum(length((V10)));          base[17]= make_fixnum(length((V8)));
219          base[18]= VV[7];          base[18]= VV[7];
220          base[19]= small_fixnum(0);          base[19]= small_fixnum(0);
221          vs_top=(vs_base=base+17)+3;          vs_top=(vs_base=base+17)+3;
222          Lmake_list();          Lmake_list();
223          vs_top=sup;          vs_top=sup;
224          V26= vs_base[0];          V24= vs_base[0];
225  T117:;  T113:;
226          base[17]= (V24);          base[17]= (V22);
227          base[19]= (V13);          base[19]= (V11);
228          base[20]= (V26);          base[20]= (V24);
229          vs_top=(vs_base=base+19)+2;          vs_top=(vs_base=base+19)+2;
230          (void) (*Lnk25)();          (void) (*Lnk24)();
231          vs_top=sup;          vs_top=sup;
232          base[18]= vs_base[0];          base[18]= vs_base[0];
233          base[19]= (V26);          base[19]= (V24);
234          vs_top=(vs_base=base+17)+3;          vs_top=(vs_base=base+17)+3;
235          (void) (*Lnk26)();          (void) (*Lnk25)();
236          vs_top=sup;          vs_top=sup;
237          base[17]= (V26);          base[17]= (V24);
238          base[18]= (V10);          base[18]= (V8);
239          vs_top=(vs_base=base+17)+2;          vs_top=(vs_base=base+17)+2;
240          (void) (*Lnk27)();          (void) (*Lnk26)();
241          vs_top=sup;          vs_top=sup;
242          if((vs_base[0])==Cnil){          if((vs_base[0])==Cnil){
243          goto T126;}          goto T122;}
244          goto T107;          goto T103;
245  T126:;  T122:;
246          goto T117;}          goto T113;}
247  T107:;  T103:;
248          base[17]= (V24);          base[17]= (V22);
249          vs_top=(vs_base=base+17)+1;          vs_top=(vs_base=base+17)+1;
250          return;}          return;}
251          }          }
252  }  }
253  /*      function definition for INCREMENT-CURSOR        */  /*      function definition for INCREMENT-CURSOR        */
254    
255  static L4()  static L3()
256  {register object *base=vs_base;  {register object *base=vs_base;
257          register object *sup=base+VM4; VC4          register object *sup=base+VM3; VC3
258          vs_reserve(VM4);          vs_reserve(VM3);
259          {register object V27;          {register object V25;
260          object V28;          object V26;
261          check_arg(2);          check_arg(2);
262          V27=(base[0]);          V25=(base[0]);
263          V28=(base[1]);          V26=(base[1]);
264          vs_top=sup;          vs_top=sup;
265  TTL:;  TTL:;
266          if(((V27))!=Cnil){          if(((V25))!=Cnil){
267          goto T134;}          goto T130;}
268          base[2]= Ct;          base[2]= Ct;
269          vs_top=(vs_base=base+2)+1;          vs_top=(vs_base=base+2)+1;
270          return;          return;
271  T134:;  T130:;
272          {object V29;          {object V27;
273          base[2]= cdr((V27));          base[2]= cdr((V25));
274          base[3]= cdr((V28));          base[3]= cdr((V26));
275          vs_top=(vs_base=base+2)+2;          vs_top=(vs_base=base+2)+2;
276          (void) (*Lnk27)();          (void) (*Lnk26)();
277          vs_top=sup;          vs_top=sup;
278          V29= vs_base[0];          V27= vs_base[0];
279          if(((V29))==Cnil){          if(((V27))==Cnil){
280          goto T140;}          goto T136;}
281          if(!(((fix(car((V27))))+1)>=(fix(car((V28)))))){          if(!(((fix(car((V25))))+1)>=(fix(car((V26)))))){
282          goto T143;}          goto T139;}
283          if(type_of((V27))!=t_cons)FEwrong_type_argument(Scons,(V27));          if(type_of((V25))!=t_cons)FEwrong_type_argument(Scons,(V25));
284          ((V27))->c.c_car = small_fixnum(0);          ((V25))->c.c_car = small_fixnum(0);
285          base[2]= Ct;          base[2]= Ct;
286          vs_top=(vs_base=base+2)+1;          vs_top=(vs_base=base+2)+1;
287          return;          return;
288  T143:;  T139:;
289          V30 = make_fixnum((fix(car((V27))))+1);          V28 = make_fixnum((fix(car((V25))))+1);
290          if(type_of((V27))!=t_cons)FEwrong_type_argument(Scons,(V27));          if(type_of((V25))!=t_cons)FEwrong_type_argument(Scons,(V25));
291          ((V27))->c.c_car = V30;          ((V25))->c.c_car = V28;
292          base[2]= Cnil;          base[2]= Cnil;
293          vs_top=(vs_base=base+2)+1;          vs_top=(vs_base=base+2)+1;
294          return;          return;
295  T140:;  T136:;
296          base[2]= Cnil;          base[2]= Cnil;
297          vs_top=(vs_base=base+2)+1;          vs_top=(vs_base=base+2)+1;
298          return;}          return;}
# Line 323  T140:; Line 300  T140:;
300  }  }
301  /*      function definition for SEQUENCE-CURSOR */  /*      function definition for SEQUENCE-CURSOR */
302    
303  static L5()  static L4()
304  {register object *base=vs_base;  {register object *base=vs_base;
305          register object *sup=base+VM5; VC5          register object *sup=base+VM4; VC4
306          vs_reserve(VM5);          vs_reserve(VM4);
307          {object V31;          {object V29;
308          object V32;          object V30;
309          check_arg(2);          check_arg(2);
310          V31=(base[0]);          V29=(base[0]);
311          V32=(base[1]);          V30=(base[1]);
312          vs_top=sup;          vs_top=sup;
313  TTL:;  TTL:;
314          if(((V32))!=Cnil){          if(((V30))!=Cnil){
315          goto T148;}          goto T144;}
316          base[2]= (V31);          base[2]= (V29);
317          vs_top=(vs_base=base+2)+1;          vs_top=(vs_base=base+2)+1;
318          return;          return;
319  T148:;  T144:;
320          V31= elt((V31),fix(car((V32))));          V29= elt((V29),fix(car((V30))));
321          V32= cdr((V32));          V30= cdr((V30));
322          goto TTL;          goto TTL;
323          }          }
324  }  }
325  /*      function definition for VECTOR  */  /*      function definition for VECTOR  */
326    
327  static L6()  static L5()
328  {register object *base=vs_base;  {register object *base=vs_base;
329          register object *sup=base+VM6; VC6          register object *sup=base+VM5; VC5
330          vs_reserve(VM6);          vs_reserve(VM5);
331          {object V33;          {object V31;
332          vs_top[0]=Cnil;          vs_top[0]=Cnil;
333          {object *p=vs_top;          {object *p=vs_top;
334           for(;p>vs_base;p--)p[-1]=ON_STACK_CONS(p[-1],p[0]);}           for(;p>vs_base;p--)p[-1]=ON_STACK_CONS(p[-1],p[0]);}
335          V33=(base[0]);          V31=(base[0]);
336          vs_top=sup;          vs_top=sup;
337          {object V34;          {object V32;
338          V35 = make_fixnum(length((V33)));          V33 = make_fixnum(length((V31)));
339          V34= make_cons(V35,Cnil);          V32= make_cons(V33,Cnil);
340          base[2]= (V34);          base[2]= (V32);
341          base[3]= VV[8];          base[3]= VV[8];
342          base[4]= Ct;          base[4]= Ct;
343          base[5]= VV[9];          base[5]= VV[9];
344          base[6]= (V33);          base[6]= (V31);
345          vs_top=(vs_base=base+2)+5;          vs_top=(vs_base=base+2)+5;
346          (void) (*Lnk28)();          (void) (*Lnk27)();
347          return;}          return;}
348          }          }
349  }  }
350  /*      function definition for ARRAY-DIMENSIONS        */  /*      function definition for ARRAY-DIMENSIONS        */
351    
352  static L7()  static L6()
353  {register object *base=vs_base;  {register object *base=vs_base;
354          register object *sup=base+VM7; VC7          register object *sup=base+VM6; VC6
355          vs_reserve(VM7);          vs_reserve(VM6);
356          {register object V36;          {register object V34;
357          check_arg(1);          check_arg(1);
358          V36=(base[0]);          V34=(base[0]);
359          vs_top=sup;          vs_top=sup;
360  TTL:;  TTL:;
361          {register object V37;          {register object V35;
362          register object V38;          register object V36;
363          base[1]= (V36);          base[1]= (V34);
364          vs_top=(vs_base=base+1)+1;          vs_top=(vs_base=base+1)+1;
365          Larray_rank();          Larray_rank();
366          vs_top=sup;          vs_top=sup;
367          V37= vs_base[0];          V35= vs_base[0];
368          V38= Cnil;          V36= Cnil;
369  T162:;  T158:;
370          if(!(number_compare((V37),small_fixnum(0))==0)){          if(!(number_compare((V35),small_fixnum(0))==0)){
371          goto T163;}          goto T159;}
372          base[1]= (V38);          base[1]= (V36);
373          vs_top=(vs_base=base+1)+1;          vs_top=(vs_base=base+1)+1;
374          return;          return;
375  T163:;  T159:;
376          V37= one_minus((V37));          V35= one_minus((V35));
377          base[1]= (V36);          base[1]= (V34);
378          base[2]= (V37);          base[2]= (V35);
379          vs_top=(vs_base=base+1)+2;          vs_top=(vs_base=base+1)+2;
380          Larray_dimension();          Larray_dimension();
381          vs_top=sup;          vs_top=sup;
382          V39= vs_base[0];          V37= vs_base[0];
383          V38= make_cons(V39,(V38));          V36= make_cons(V37,(V36));
384          goto T162;}          goto T158;}
385          }          }
386  }  }
387  /*      function definition for ARRAY-IN-BOUNDS-P       */  /*      function definition for ARRAY-IN-BOUNDS-P       */
388    
389  static L8()  static L7()
390  {register object *base=vs_base;  {register object *base=vs_base;
391          register object *sup=base+VM8; VC8          register object *sup=base+VM7; VC7
392          vs_reserve(VM8);          vs_reserve(VM7);
393          {register object V40;          {register object V38;
394          object V41;          object V39;
395          if(vs_top-vs_base<1) too_few_arguments();          if(vs_top-vs_base<1) too_few_arguments();
396          V40=(base[0]);          V38=(base[0]);
397          vs_base=vs_base+1;          vs_base=vs_base+1;
398          vs_top[0]=Cnil;          vs_top[0]=Cnil;
399          {object *p=vs_top;          {object *p=vs_top;
400           for(;p>vs_base;p--)p[-1]=ON_STACK_CONS(p[-1],p[0]);}           for(;p>vs_base;p--)p[-1]=ON_STACK_CONS(p[-1],p[0]);}
401          V41=(base[1]);          V39=(base[1]);
402          vs_top=sup;          vs_top=sup;
403          {register object V42;          {register object V40;
404          base[3]= (V40);          base[3]= (V38);
405          vs_top=(vs_base=base+3)+1;          vs_top=(vs_base=base+3)+1;
406          Larray_rank();          Larray_rank();
407          vs_top=sup;          vs_top=sup;
408          V42= vs_base[0];          V40= vs_base[0];
409          V43 = make_fixnum(length((V41)));          V41 = make_fixnum(length((V39)));
410          if(!(number_compare((V42),V43)!=0)){          if(!(number_compare((V40),V41)!=0)){
411          goto T178;}          goto T174;}
412          base[3]= VV[10];          base[3]= VV[10];
413          base[4]= (V42);          base[4]= (V40);
414          base[5]= make_fixnum(length((V41)));          base[5]= make_fixnum(length((V39)));
415          vs_top=(vs_base=base+3)+3;          vs_top=(vs_base=base+3)+3;
416          Lerror();          Lerror();
417          vs_top=sup;          vs_top=sup;
418  T178:;  T174:;
419          {register object V44;          {register object V42;
420          register object V45;          register object V43;
421          V44= small_fixnum(0);          V42= small_fixnum(0);
422          V45= (V41);          V43= (V39);
423  T185:;  T181:;
424          if(!(number_compare((V44),(V42))>=0)){          if(!(number_compare((V42),(V40))>=0)){
425          goto T186;}          goto T182;}
426          base[3]= Ct;          base[3]= Ct;
427          vs_top=(vs_base=base+3)+1;          vs_top=(vs_base=base+3)+1;
428          return;          return;
429  T186:;  T182:;
430          if(number_compare(car((V45)),small_fixnum(0))<0){          if(number_compare(car((V43)),small_fixnum(0))<0){
431          goto T191;}          goto T187;}
432          V46= car((V45));          V44= car((V43));
433          base[3]= (V40);          base[3]= (V38);
434          base[4]= (V44);          base[4]= (V42);
435          vs_top=(vs_base=base+3)+2;          vs_top=(vs_base=base+3)+2;
436          Larray_dimension();          Larray_dimension();
437          vs_top=sup;          vs_top=sup;
438          V47= vs_base[0];          V45= vs_base[0];
439          if(!(number_compare(/* INLINE-ARGS */V46,V47)>=0)){          if(!(number_compare(/* INLINE-ARGS */V44,V45)>=0)){
440          goto T190;}          goto T186;}
441  T191:;  T187:;
442          base[3]= Cnil;          base[3]= Cnil;
443          vs_top=(vs_base=base+3)+1;          vs_top=(vs_base=base+3)+1;
444          return;          return;
445  T190:;  T186:;
446          V44= one_plus((V44));          V42= one_plus((V42));
447          V45= cdr((V45));          V43= cdr((V43));
448          goto T185;}}          goto T181;}}
449          }          }
450  }  }
451  /*      function definition for ARRAY-ROW-MAJOR-INDEX   */  /*      function definition for ARRAY-ROW-MAJOR-INDEX   */
452    
453  static L9()  static L8()
454  {register object *base=vs_base;  {register object *base=vs_base;
455          register object *sup=base+VM9; VC9          register object *sup=base+VM8; VC8
456          vs_reserve(VM9);          vs_reserve(VM8);
457          {register object V48;          {register object V46;
458          object V49;          object V47;
459          if(vs_top-vs_base<1) too_few_arguments();          if(vs_top-vs_base<1) too_few_arguments();
460          V48=(base[0]);          V46=(base[0]);
461          vs_base=vs_base+1;          vs_base=vs_base+1;
462          vs_top[0]=Cnil;          vs_top[0]=Cnil;
463          {object *p=vs_top;          {object *p=vs_top;
464           for(;p>vs_base;p--)p[-1]=ON_STACK_CONS(p[-1],p[0]);}           for(;p>vs_base;p--)p[-1]=ON_STACK_CONS(p[-1],p[0]);}
465          V49=(base[1]);          V47=(base[1]);
466          vs_top=sup;          vs_top=sup;
467          {register object V50;          {register object V48;
468          register object V51;          register object V49;
469          register object V52;          register object V50;
470          V50= small_fixnum(0);          V48= small_fixnum(0);
471          V51= small_fixnum(0);          V49= small_fixnum(0);
472          V52= (V49);          V50= (V47);
473  T203:;  T199:;
474          if(((V52))!=Cnil){          if(((V50))!=Cnil){
475          goto T204;}          goto T200;}
476          base[2]= (V51);          base[2]= (V49);
477          vs_top=(vs_base=base+2)+1;          vs_top=(vs_base=base+2)+1;
478          return;          return;
479  T204:;  T200:;
480          {object V53;          {object V51;
481          V53= one_plus((V50));          V51= one_plus((V48));
482          base[2]= (V48);          base[2]= (V46);
483          base[3]= (V50);          base[3]= (V48);
484          vs_top=(vs_base=base+2)+2;          vs_top=(vs_base=base+2)+2;
485          Larray_dimension();          Larray_dimension();
486          vs_top=sup;          vs_top=sup;
487          V54= vs_base[0];          V52= vs_base[0];
488          V55= number_times((V51),V54);          V53= number_times((V49),V52);
489          V51= number_plus(/* INLINE-ARGS */V55,car((V52)));          V49= number_plus(/* INLINE-ARGS */V53,car((V50)));
490          V52= cdr((V52));          V50= cdr((V50));
491          V50= (V53);}          V48= (V51);}
492          goto T203;}          goto T199;}
493          }          }
494  }  }
495  /*      function definition for BIT     */  /*      function definition for BIT     */
496    
497  static L10()  static L9()
498  {register object *base=vs_base;  {register object *base=vs_base;
499          register object *sup=base+VM10; VC10          register object *sup=base+VM9; VC9
500          vs_reserve(VM10);          vs_reserve(VM9);
501          {object V56;          {object V54;
502          object V57;          object V55;
503          if(vs_top-vs_base<1) too_few_arguments();          if(vs_top-vs_base<1) too_few_arguments();
504          V56=(base[0]);          V54=(base[0]);
505          vs_base=vs_base+1;          vs_base=vs_base+1;
506          vs_top[0]=Cnil;          vs_top[0]=Cnil;
507          {object *p=vs_top;          {object *p=vs_top;
508           for(;p>vs_base;p--)p[-1]=ON_STACK_CONS(p[-1],p[0]);}           for(;p>vs_base;p--)p[-1]=ON_STACK_CONS(p[-1],p[0]);}
509          V57=(base[1]);          V55=(base[1]);
510          vs_top=sup;          vs_top=sup;
511          base[2]= (V56);          base[2]= (V54);
512          {object V58;          {object V56;
513          V58= (V57);          V56= (V55);
514           vs_top=base+3;           vs_top=base+3;
515           while(!endp(V58))           while(!endp(V56))
516           {vs_push(car(V58));V58=cdr(V58);}           {vs_push(car(V56));V56=cdr(V56);}
517          vs_base=base+2;}          vs_base=base+2;}
518          Laref();          Laref();
519          return;          return;
# Line 544  static L10() Line 521  static L10()
521  }  }
522  /*      function definition for SBIT    */  /*      function definition for SBIT    */
523    
524  static L11()  static L10()
525  {register object *base=vs_base;  {register object *base=vs_base;
526          register object *sup=base+VM11; VC11          register object *sup=base+VM10; VC10
527          vs_reserve(VM11);          vs_reserve(VM10);
528          {object V59;          {object V57;
529          object V60;          object V58;
530          if(vs_top-vs_base<1) too_few_arguments();          if(vs_top-vs_base<1) too_few_arguments();
531          V59=(base[0]);          V57=(base[0]);
532          vs_base=vs_base+1;          vs_base=vs_base+1;
533          vs_top[0]=Cnil;          vs_top[0]=Cnil;
534          {object *p=vs_top;          {object *p=vs_top;
535           for(;p>vs_base;p--)p[-1]=ON_STACK_CONS(p[-1],p[0]);}           for(;p>vs_base;p--)p[-1]=ON_STACK_CONS(p[-1],p[0]);}
536          V60=(base[1]);          V58=(base[1]);
537          vs_top=sup;          vs_top=sup;
538          base[2]= (V59);          base[2]= (V57);
539          {object V61;          {object V59;
540          V61= (V60);          V59= (V58);
541           vs_top=base+3;           vs_top=base+3;
542           while(!endp(V61))           while(!endp(V59))
543           {vs_push(car(V61));V61=cdr(V61);}           {vs_push(car(V59));V59=cdr(V59);}
544          vs_base=base+2;}          vs_base=base+2;}
545          Laref();          Laref();
546          return;          return;
# Line 571  static L11() Line 548  static L11()
548  }  }
549  /*      function definition for BIT-AND */  /*      function definition for BIT-AND */
550    
551    static L11()
552    {register object *base=vs_base;
553            register object *sup=base+VM11; VC11
554            vs_reserve(VM11);
555            {object V60;
556            object V61;
557            object V62;
558            if(vs_top-vs_base<2) too_few_arguments();
559            if(vs_top-vs_base>3) too_many_arguments();
560            V60=(base[0]);
561            V61=(base[1]);
562            vs_base=vs_base+2;
563            if(vs_base>=vs_top){vs_top=sup;goto T216;}
564            V62=(base[2]);
565            vs_top=sup;
566            goto T217;
567    T216:;
568            V62= Cnil;
569    T217:;
570            base[3]= small_fixnum(1);
571            base[4]= (V60);
572            base[5]= (V61);
573            base[6]= (V62);
574            vs_top=(vs_base=base+3)+4;
575            siLbit_array_op();
576            return;
577            }
578    }
579    /*      function definition for BIT-IOR */
580    
581  static L12()  static L12()
582  {register object *base=vs_base;  {register object *base=vs_base;
583          register object *sup=base+VM12; VC12          register object *sup=base+VM12; VC12
584          vs_reserve(VM12);          vs_reserve(VM12);
585          {object V62;          {object V63;
         object V63;  
586          object V64;          object V64;
587            object V65;
588          if(vs_top-vs_base<2) too_few_arguments();          if(vs_top-vs_base<2) too_few_arguments();
589          if(vs_top-vs_base>3) too_many_arguments();          if(vs_top-vs_base>3) too_many_arguments();
590          V62=(base[0]);          V63=(base[0]);
591          V63=(base[1]);          V64=(base[1]);
592          vs_base=vs_base+2;          vs_base=vs_base+2;
593          if(vs_base>=vs_top){vs_top=sup;goto T220;}          if(vs_base>=vs_top){vs_top=sup;goto T223;}
594          V64=(base[2]);          V65=(base[2]);
595          vs_top=sup;          vs_top=sup;
596          goto T221;          goto T224;
597  T220:;  T223:;
598          V64= Cnil;          V65= Cnil;
599  T221:;  T224:;
600          base[3]= small_fixnum(1);          base[3]= small_fixnum(7);
601          base[4]= (V62);          base[4]= (V63);
602          base[5]= (V63);          base[5]= (V64);
603          base[6]= (V64);          base[6]= (V65);
604          vs_top=(vs_base=base+3)+4;          vs_top=(vs_base=base+3)+4;
605          siLbit_array_op();          siLbit_array_op();
606          return;          return;
607          }          }
608  }  }
609  /*      function definition for BIT-IOR */  /*      function definition for BIT-XOR */
610    
611  static L13()  static L13()
612  {register object *base=vs_base;  {register object *base=vs_base;
613          register object *sup=base+VM13; VC13          register object *sup=base+VM13; VC13
614          vs_reserve(VM13);          vs_reserve(VM13);
615          {object V65;          {object V66;
         object V66;  
616          object V67;          object V67;
617            object V68;
618          if(vs_top-vs_base<2) too_few_arguments();          if(vs_top-vs_base<2) too_few_arguments();
619          if(vs_top-vs_base>3) too_many_arguments();          if(vs_top-vs_base>3) too_many_arguments();
620          V65=(base[0]);          V66=(base[0]);
621          V66=(base[1]);          V67=(base[1]);
622          vs_base=vs_base+2;          vs_base=vs_base+2;
623          if(vs_base>=vs_top){vs_top=sup;goto T227;}          if(vs_base>=vs_top){vs_top=sup;goto T230;}
624          V67=(base[2]);          V68=(base[2]);
625          vs_top=sup;          vs_top=sup;
626          goto T228;          goto T231;
627  T227:;  T230:;
628          V67= Cnil;          V68= Cnil;
629  T228:;  T231:;
630          base[3]= small_fixnum(7);          base[3]= small_fixnum(6);
631          base[4]= (V65);          base[4]= (V66);
632          base[5]= (V66);          base[5]= (V67);
633          base[6]= (V67);          base[6]= (V68);
634          vs_top=(vs_base=base+3)+4;          vs_top=(vs_base=base+3)+4;
635          siLbit_array_op();          siLbit_array_op();
636          return;          return;
637          }          }
638  }  }
639  /*      function definition for BIT-XOR */  /*      function definition for BIT-EQV */
640    
641  static L14()  static L14()
642  {register object *base=vs_base;  {register object *base=vs_base;
643          register object *sup=base+VM14; VC14          register object *sup=base+VM14; VC14
644          vs_reserve(VM14);          vs_reserve(VM14);
645          {object V68;          {object V69;
         object V69;  
646          object V70;          object V70;
647            object V71;
648          if(vs_top-vs_base<2) too_few_arguments();          if(vs_top-vs_base<2) too_few_arguments();
649          if(vs_top-vs_base>3) too_many_arguments();          if(vs_top-vs_base>3) too_many_arguments();
650          V68=(base[0]);          V69=(base[0]);
651          V69=(base[1]);          V70=(base[1]);
652          vs_base=vs_base+2;          vs_base=vs_base+2;
653          if(vs_base>=vs_top){vs_top=sup;goto T234;}          if(vs_base>=vs_top){vs_top=sup;goto T237;}
654          V70=(base[2]);          V71=(base[2]);
655          vs_top=sup;          vs_top=sup;
656          goto T235;          goto T238;
657  T234:;  T237:;
658          V70= Cnil;          V71= Cnil;
659  T235:;  T238:;
660          base[3]= small_fixnum(6);          base[3]= small_fixnum(9);
661          base[4]= (V68);          base[4]= (V69);
662          base[5]= (V69);          base[5]= (V70);
663          base[6]= (V70);          base[6]= (V71);
664          vs_top=(vs_base=base+3)+4;          vs_top=(vs_base=base+3)+4;
665          siLbit_array_op();          siLbit_array_op();
666          return;          return;
667          }          }
668  }  }
669  /*      function definition for BIT-EQV */  /*      function definition for BIT-NAND        */
670    
671  static L15()  static L15()
672  {register object *base=vs_base;  {register object *base=vs_base;
673          register object *sup=base+VM15; VC15          register object *sup=base+VM15; VC15
674          vs_reserve(VM15);          vs_reserve(VM15);
675          {object V71;          {object V72;
         object V72;  
676          object V73;          object V73;
677            object V74;
678          if(vs_top-vs_base<2) too_few_arguments();          if(vs_top-vs_base<2) too_few_arguments();
679          if(vs_top-vs_base>3) too_many_arguments();          if(vs_top-vs_base>3) too_many_arguments();
680          V71=(base[0]);          V72=(base[0]);
681          V72=(base[1]);          V73=(base[1]);
682          vs_base=vs_base+2;          vs_base=vs_base+2;
683          if(vs_base>=vs_top){vs_top=sup;goto T241;}          if(vs_base>=vs_top){vs_top=sup;goto T244;}
684          V73=(base[2]);          V74=(base[2]);
685          vs_top=sup;          vs_top=sup;
686          goto T242;          goto T245;
687  T241:;  T244:;
688          V73= Cnil;          V74= Cnil;
689  T242:;  T245:;
690          base[3]= small_fixnum(9);          base[3]= small_fixnum(14);
691          base[4]= (V71);          base[4]= (V72);
692          base[5]= (V72);          base[5]= (V73);
693          base[6]= (V73);          base[6]= (V74);
694          vs_top=(vs_base=base+3)+4;          vs_top=(vs_base=base+3)+4;
695          siLbit_array_op();          siLbit_array_op();
696          return;          return;
697          }          }
698  }  }
699  /*      function definition for BIT-NAND        */  /*      function definition for BIT-NOR */
700    
701  static L16()  static L16()
702  {register object *base=vs_base;  {register object *base=vs_base;
703          register object *sup=base+VM16; VC16          register object *sup=base+VM16; VC16
704          vs_reserve(VM16);          vs_reserve(VM16);
705          {object V74;          {object V75;
         object V75;  
706          object V76;          object V76;
707            object V77;
708          if(vs_top-vs_base<2) too_few_arguments();          if(vs_top-vs_base<2) too_few_arguments();
709          if(vs_top-vs_base>3) too_many_arguments();          if(vs_top-vs_base>3) too_many_arguments();
710          V74=(base[0]);          V75=(base[0]);
711          V75=(base[1]);          V76=(base[1]);
712          vs_base=vs_base+2;          vs_base=vs_base+2;
713          if(vs_base>=vs_top){vs_top=sup;goto T248;}          if(vs_base>=vs_top){vs_top=sup;goto T251;}
714          V76=(base[2]);          V77=(base[2]);
715          vs_top=sup;          vs_top=sup;
716          goto T249;          goto T252;
717  T248:;  T251:;
718          V76= Cnil;          V77= Cnil;
719  T249:;  T252:;
720          base[3]= small_fixnum(14);          base[3]= small_fixnum(8);
721          base[4]= (V74);          base[4]= (V75);
722          base[5]= (V75);          base[5]= (V76);
723          base[6]= (V76);          base[6]= (V77);
724          vs_top=(vs_base=base+3)+4;          vs_top=(vs_base=base+3)+4;
725          siLbit_array_op();          siLbit_array_op();
726          return;          return;
727          }          }
728  }  }
729  /*      function definition for BIT-NOR */  /*      function definition for BIT-ANDC1       */
730    
731  static L17()  static L17()
732  {register object *base=vs_base;  {register object *base=vs_base;
733          register object *sup=base+VM17; VC17          register object *sup=base+VM17; VC17
734          vs_reserve(VM17);          vs_reserve(VM17);
735          {object V77;          {object V78;
         object V78;  
736          object V79;          object V79;
737            object V80;
738          if(vs_top-vs_base<2) too_few_arguments();          if(vs_top-vs_base<2) too_few_arguments();
739          if(vs_top-vs_base>3) too_many_arguments();          if(vs_top-vs_base>3) too_many_arguments();
740          V77=(base[0]);          V78=(base[0]);
741          V78=(base[1]);          V79=(base[1]);
742          vs_base=vs_base+2;          vs_base=vs_base+2;
743          if(vs_base>=vs_top){vs_top=sup;goto T255;}          if(vs_base>=vs_top){vs_top=sup;goto T258;}
744          V79=(base[2]);          V80=(base[2]);
745          vs_top=sup;          vs_top=sup;
746          goto T256;          goto T259;
747  T255:;  T258:;
748          V79= Cnil;          V80= Cnil;
749  T256:;  T259:;
750          base[3]= small_fixnum(8);          base[3]= small_fixnum(4);
751          base[4]= (V77);          base[4]= (V78);
752          base[5]= (V78);          base[5]= (V79);
753          base[6]= (V79);          base[6]= (V80);
754          vs_top=(vs_base=base+3)+4;          vs_top=(vs_base=base+3)+4;
755          siLbit_array_op();          siLbit_array_op();
756          return;          return;
757          }          }
758  }  }
759  /*      function definition for BIT-ANDC1       */  /*      function definition for BIT-ANDC2       */
760    
761  static L18()  static L18()
762  {register object *base=vs_base;  {register object *base=vs_base;
763          register object *sup=base+VM18; VC18          register object *sup=base+VM18; VC18
764          vs_reserve(VM18);          vs_reserve(VM18);
765          {object V80;          {object V81;
         object V81;  
766          object V82;          object V82;
767            object V83;
768          if(vs_top-vs_base<2) too_few_arguments();          if(vs_top-vs_base<2) too_few_arguments();
769          if(vs_top-vs_base>3) too_many_arguments();          if(vs_top-vs_base>3) too_many_arguments();
770          V80=(base[0]);          V81=(base[0]);
771          V81=(base[1]);          V82=(base[1]);
772          vs_base=vs_base+2;          vs_base=vs_base+2;
773          if(vs_base>=vs_top){vs_top=sup;goto T262;}          if(vs_base>=vs_top){vs_top=sup;goto T265;}
774          V82=(base[2]);          V83=(base[2]);
775          vs_top=sup;          vs_top=sup;
776          goto T263;          goto T266;
777  T262:;  T265:;
778          V82= Cnil;          V83= Cnil;
779  T263:;  T266:;
780          base[3]= small_fixnum(4);          base[3]= small_fixnum(2);
781          base[4]= (V80);          base[4]= (V81);
782          base[5]= (V81);          base[5]= (V82);
783          base[6]= (V82);          base[6]= (V83);
784          vs_top=(vs_base=base+3)+4;          vs_top=(vs_base=base+3)+4;
785          siLbit_array_op();          siLbit_array_op();
786          return;          return;
787          }          }
788  }  }
789  /*      function definition for BIT-ANDC2       */  /*      function definition for BIT-ORC1        */
790    
791  static L19()  static L19()
792  {register object *base=vs_base;  {register object *base=vs_base;
793          register object *sup=base+VM19; VC19          register object *sup=base+VM19; VC19
794          vs_reserve(VM19);          vs_reserve(VM19);
795          {object V83;          {object V84;
         object V84;  
796          object V85;          object V85;
797            object V86;
798          if(vs_top-vs_base<2) too_few_arguments();          if(vs_top-vs_base<2) too_few_arguments();
799          if(vs_top-vs_base>3) too_many_arguments();          if(vs_top-vs_base>3) too_many_arguments();
800          V83=(base[0]);          V84=(base[0]);
801          V84=(base[1]);          V85=(base[1]);
802          vs_base=vs_base+2;          vs_base=vs_base+2;
803          if(vs_base>=vs_top){vs_top=sup;goto T269;}          if(vs_base>=vs_top){vs_top=sup;goto T272;}
804          V85=(base[2]);          V86=(base[2]);
805          vs_top=sup;          vs_top=sup;
806          goto T270;          goto T273;
807  T269:;  T272:;
808          V85= Cnil;          V86= Cnil;
809  T270:;  T273:;
810          base[3]= small_fixnum(2);          base[3]= small_fixnum(13);
811          base[4]= (V83);          base[4]= (V84);
812          base[5]= (V84);          base[5]= (V85);
813          base[6]= (V85);          base[6]= (V86);
814          vs_top=(vs_base=base+3)+4;          vs_top=(vs_base=base+3)+4;
815          siLbit_array_op();          siLbit_array_op();
816          return;          return;
817          }          }
818  }  }
819  /*      function definition for BIT-ORC1        */  /*      function definition for BIT-ORC2        */
820    
821  static L20()  static L20()
822  {register object *base=vs_base;  {register object *base=vs_base;
823          register object *sup=base+VM20; VC20          register object *sup=base+VM20; VC20
824          vs_reserve(VM20);          vs_reserve(VM20);
825          {object V86;          {object V87;
         object V87;  
826          object V88;          object V88;
827            object V89;
828          if(vs_top-vs_base<2) too_few_arguments();          if(vs_top-vs_base<2) too_few_arguments();
829          if(vs_top-vs_base>3) too_many_arguments();          if(vs_top-vs_base>3) too_many_arguments();
830          V86=(base[0]);          V87=(base[0]);
831          V87=(base[1]);          V88=(base[1]);
832          vs_base=vs_base+2;          vs_base=vs_base+2;
833          if(vs_base>=vs_top){vs_top=sup;goto T276;}          if(vs_base>=vs_top){vs_top=sup;goto T279;}
834          V88=(base[2]);          V89=(base[2]);
835          vs_top=sup;          vs_top=sup;
836          goto T277;          goto T280;
837  T276:;  T279:;
838          V88= Cnil;          V89= Cnil;
839  T277:;  T280:;
840          base[3]= small_fixnum(13);          base[3]= small_fixnum(11);
841          base[4]= (V86);          base[4]= (V87);
842          base[5]= (V87);          base[5]= (V88);
843          base[6]= (V88);          base[6]= (V89);
844          vs_top=(vs_base=base+3)+4;          vs_top=(vs_base=base+3)+4;
845          siLbit_array_op();          siLbit_array_op();
846          return;          return;
847          }          }
848  }  }
849  /*      function definition for BIT-ORC2        */  /*      function definition for BIT-NOT */
850    
851  static L21()  static L21()
852  {register object *base=vs_base;  {register object *base=vs_base;
853          register object *sup=base+VM21; VC21          register object *sup=base+VM21; VC21
854          vs_reserve(VM21);          vs_reserve(VM21);
855          {object V89;          {object V90;
         object V90;  
856          object V91;          object V91;
         if(vs_top-vs_base<2) too_few_arguments();  
         if(vs_top-vs_base>3) too_many_arguments();  
         V89=(base[0]);  
         V90=(base[1]);  
         vs_base=vs_base+2;  
         if(vs_base>=vs_top){vs_top=sup;goto T283;}  
         V91=(base[2]);  
         vs_top=sup;  
         goto T284;  
 T283:;  
         V91= Cnil;  
 T284:;  
         base[3]= small_fixnum(11);  
         base[4]= (V89);  
         base[5]= (V90);  
         base[6]= (V91);  
         vs_top=(vs_base=base+3)+4;  
         siLbit_array_op();  
         return;  
         }  
 }  
 /*      function definition for BIT-NOT */  
   
 static L22()  
 {register object *base=vs_base;  
         register object *sup=base+VM22; VC22  
         vs_reserve(VM22);  
         {object V92;  
         object V93;  
857          if(vs_top-vs_base<1) too_few_arguments();          if(vs_top-vs_base<1) too_few_arguments();
858          if(vs_top-vs_base>2) too_many_arguments();          if(vs_top-vs_base>2) too_many_arguments();
859          V92=(base[0]);          V90=(base[0]);
860          vs_base=vs_base+1;          vs_base=vs_base+1;
861          if(vs_base>=vs_top){vs_top=sup;goto T290;}          if(vs_base>=vs_top){vs_top=sup;goto T286;}
862          V93=(base[1]);          V91=(base[1]);
863          vs_top=sup;          vs_top=sup;
864          goto T291;          goto T287;
865  T290:;  T286:;
866          V93= Cnil;          V91= Cnil;
867  T291:;  T287:;
868          base[2]= small_fixnum(12);          base[2]= small_fixnum(12);
869          base[3]= (V92);          base[3]= (V90);
870          base[4]= (V92);          base[4]= (V90);
871          base[5]= (V93);          base[5]= (V91);
872          vs_top=(vs_base=base+2)+4;          vs_top=(vs_base=base+2)+4;
873          siLbit_array_op();          siLbit_array_op();
874          return;          return;
# Line 899  T291:; Line 876  T291:;
876  }  }
877  /*      function definition for VECTOR-PUSH     */  /*      function definition for VECTOR-PUSH     */
878    
879  static L23()  static L22()
880  {register object *base=vs_base;  {register object *base=vs_base;
881          register object *sup=base+VM23; VC23          register object *sup=base+VM22; VC22
882          vs_reserve(VM23);          vs_reserve(VM22);
883          {object V94;          {object V92;
884          register object V95;          register object V93;
885          check_arg(2);          check_arg(2);
886          V94=(base[0]);          V92=(base[0]);
887          V95=(base[1]);          V93=(base[1]);
888          vs_top=sup;          vs_top=sup;
889  TTL:;  TTL:;
890          {register int V96;          {register int V94;
891          base[2]= (V95);          base[2]= (V93);
892          vs_top=(vs_base=base+2)+1;          vs_top=(vs_base=base+2)+1;
893          Lfill_pointer();          Lfill_pointer();
894          vs_top=sup;          vs_top=sup;
895          V96= fix(vs_base[0]);          V94= fix(vs_base[0]);
896          base[2]= (V95);          base[2]= (V93);
897          base[3]= small_fixnum(0);          base[3]= small_fixnum(0);
898          vs_top=(vs_base=base+2)+2;          vs_top=(vs_base=base+2)+2;
899          Larray_dimension();          Larray_dimension();
900          vs_top=sup;          vs_top=sup;
901          V97= vs_base[0];          V95= vs_base[0];
902          if(!((V96)<(fix(V97)))){          if(!((V94)<(fix(V95)))){
903          goto T300;}          goto T296;}
904          (void)(aset1((V95),V96,(V94)));          (void)(aset1((V93),V94,(V92)));
905          base[2]= (V95);          base[2]= (V93);
906          base[3]= make_fixnum((V96)+1);          base[3]= make_fixnum((V94)+1);
907          vs_top=(vs_base=base+2)+2;          vs_top=(vs_base=base+2)+2;
908          siLfill_pointer_set();          siLfill_pointer_set();
909          vs_top=sup;          vs_top=sup;
910          base[2]= make_fixnum(V96);          base[2]= make_fixnum(V94);
911          vs_top=(vs_base=base+2)+1;          vs_top=(vs_base=base+2)+1;
912          return;          return;
913  T300:;  T296:;
914          base[2]= Cnil;          base[2]= Cnil;
915          vs_top=(vs_base=base+2)+1;          vs_top=(vs_base=base+2)+1;
916          return;}          return;}
# Line 941  T300:; Line 918  T300:;
918  }  }
919  /*      function definition for VECTOR-PUSH-EXTEND      */  /*      function definition for VECTOR-PUSH-EXTEND      */
920    
921  static L24()  static L23()
922  {register object *base=vs_base;  {register object *base=vs_base;
923          register object *sup=base+VM24; VC24          register object *sup=base+VM23; VC23
924          vs_reserve(VM24);          vs_reserve(VM23);
925          {object V98;          {object V96;
926          register object V99;          register object V97;
927          object V100;          object V98;
928          if(vs_top-vs_base<2) too_few_arguments();          if(vs_top-vs_base<2) too_few_arguments();
929          if(vs_top-vs_base>3) too_many_arguments();          if(vs_top-vs_base>3) too_many_arguments();
930          V98=(base[0]);          V96=(base[0]);
931          V99=(base[1]);          V97=(base[1]);
932          vs_base=vs_base+2;          vs_base=vs_base+2;
933          if(vs_base>=vs_top){vs_top=sup;goto T309;}          if(vs_base>=vs_top){vs_top=sup;goto T305;}
934          V100=(base[2]);          V98=(base[2]);
935          vs_top=sup;          vs_top=sup;
936          goto T310;          goto T306;
937  T309:;  T305:;
938          V100= Cnil;          V98= Cnil;
939  T310:;  T306:;
940          {register int V101;          {register int V99;
941          base[3]= (V99);          base[3]= (V97);
942          vs_top=(vs_base=base+3)+1;          vs_top=(vs_base=base+3)+1;
943          Lfill_pointer();          Lfill_pointer();
944          vs_top=sup;          vs_top=sup;
945          V101= fix(vs_base[0]);          V99= fix(vs_base[0]);
946          base[3]= (V99);          base[3]= (V97);
947          base[4]= small_fixnum(0);          base[4]= small_fixnum(0);
948          vs_top=(vs_base=base+3)+2;          vs_top=(vs_base=base+3)+2;
949          Larray_dimension();          Larray_dimension();
950          vs_top=sup;          vs_top=sup;
951          V102= vs_base[0];          V100= vs_base[0];
952          if(!((V101)<(fix(V102)))){          if(!((V99)<(fix(V100)))){
953          goto T315;}          goto T311;}
954          (void)(aset1((V99),V101,(V98)));          (void)(aset1((V97),V99,(V96)));
955          base[3]= (V99);          base[3]= (V97);
956          base[4]= make_fixnum((V101)+1);          base[4]= make_fixnum((V99)+1);
957          vs_top=(vs_base=base+3)+2;          vs_top=(vs_base=base+3)+2;
958          siLfill_pointer_set();          siLfill_pointer_set();
959          vs_top=sup;          vs_top=sup;
960          base[3]= make_fixnum(V101);          base[3]= make_fixnum(V99);
961          vs_top=(vs_base=base+3)+1;          vs_top=(vs_base=base+3)+1;
962          return;          return;
963  T315:;  T311:;
964          base[3]= (V99);          base[3]= (V97);
965          base[5]= (V99);          base[5]= (V97);
966          base[6]= small_fixnum(0);          base[6]= small_fixnum(0);
967          vs_top=(vs_base=base+5)+2;          vs_top=(vs_base=base+5)+2;
968          Larray_dimension();          Larray_dimension();
969          vs_top=sup;          vs_top=sup;
970          V103= vs_base[0];          V101= vs_base[0];
971          if((V100)!=Cnil){          if((V98)!=Cnil){
972          V104= (V100);          V102= (V98);
973          goto T330;}          goto T326;}
974          base[5]= (V99);          base[5]= (V97);
975          base[6]= small_fixnum(0);          base[6]= small_fixnum(0);
976          vs_top=(vs_base=base+5)+2;          vs_top=(vs_base=base+5)+2;
977          Larray_dimension();          Larray_dimension();
978          vs_top=sup;          vs_top=sup;
979          V105= vs_base[0];          V103= vs_base[0];
980          if(!((fix(V105))>(0))){          if(!((fix(V103))>(0))){
981          goto T332;}          goto T328;}
982          base[5]= (V99);          base[5]= (V97);
983          base[6]= small_fixnum(0);          base[6]= small_fixnum(0);
984          vs_top=(vs_base=base+5)+2;          vs_top=(vs_base=base+5)+2;
985          Larray_dimension();          Larray_dimension();
986          vs_top=sup;          vs_top=sup;
987          V104= vs_base[0];          V102= vs_base[0];
988          goto T330;          goto T326;
989  T332:;  T328:;
990          V104= small_fixnum(5);          V102= small_fixnum(5);
991  T330:;  T326:;
992          V106= number_plus(V103,V104);          V104= number_plus(V101,V102);
993          base[4]= make_cons(/* INLINE-ARGS */V106,Cnil);          base[4]= make_cons(/* INLINE-ARGS */V104,Cnil);
994          base[5]= VV[8];          base[5]= VV[8];
995          base[7]= (V99);          base[7]= (V97);
996          vs_top=(vs_base=base+7)+1;          vs_top=(vs_base=base+7)+1;
997          Larray_element_type();          Larray_element_type();
998          vs_top=sup;          vs_top=sup;
999          base[6]= vs_base[0];          base[6]= vs_base[0];
1000          base[7]= VV[11];          base[7]= VV[11];
1001          base[8]= make_fixnum(V101);          base[8]= make_fixnum(V99);
1002          vs_top=(vs_base=base+3)+6;          vs_top=(vs_base=base+3)+6;
1003          (void) (*Lnk29)();          (void) (*Lnk28)();
1004          vs_top=sup;          vs_top=sup;
1005          (void)(aset1((V99),V101,(V98)));          (void)(aset1((V97),V99,(V96)));
1006          base[3]= (V99);          base[3]= (V97);
1007          base[4]= make_fixnum((V101)+1);          base[4]= make_fixnum((V99)+1);
1008          vs_top=(vs_base=base+3)+2;          vs_top=(vs_base=base+3)+2;
1009          siLfill_pointer_set();          siLfill_pointer_set();
1010          vs_top=sup;          vs_top=sup;
1011          base[3]= make_fixnum(V101);          base[3]= make_fixnum(V99);
1012          vs_top=(vs_base=base+3)+1;          vs_top=(vs_base=base+3)+1;
1013          return;}          return;}
1014          }          }
1015  }  }
1016  /*      function definition for VECTOR-POP      */  /*      function definition for VECTOR-POP      */
1017    
1018  static L25()  static L24()
1019  {register object *base=vs_base;  {register object *base=vs_base;
1020          register object *sup=base+VM25; VC25          register object *sup=base+VM24; VC24
1021          vs_reserve(VM25);          vs_reserve(VM24);
1022          {register object V107;          {register object V105;
1023          check_arg(1);          check_arg(1);
1024          V107=(base[0]);          V105=(base[0]);
1025          vs_top=sup;          vs_top=sup;
1026  TTL:;  TTL:;
1027          {int V108;          {int V106;
1028          base[1]= (V107);          base[1]= (V105);
1029          vs_top=(vs_base=base+1)+1;          vs_top=(vs_base=base+1)+1;
1030          Lfill_pointer();          Lfill_pointer();
1031          vs_top=sup;          vs_top=sup;
1032          V108= fix(vs_base[0]);          V106= fix(vs_base[0]);
1033          if(!((V108)==(0))){          if(!((V106)==(0))){
1034          goto T350;}          goto T346;}
1035          base[1]= VV[12];          base[1]= VV[12];
1036          base[2]= (V107);          base[2]= (V105);
1037          vs_top=(vs_base=base+1)+2;          vs_top=(vs_base=base+1)+2;
1038          Lerror();          Lerror();
1039          vs_top=sup;          vs_top=sup;
1040  T350:;  T346:;
1041          base[1]= (V107);          base[1]= (V105);
1042          base[2]= make_fixnum((V108)-1);          base[2]= make_fixnum((V106)-1);
1043          vs_top=(vs_base=base+1)+2;          vs_top=(vs_base=base+1)+2;
1044          siLfill_pointer_set();          siLfill_pointer_set();
1045          vs_top=sup;          vs_top=sup;
1046          base[1]= aref1((V107),(V108)-1);          base[1]= aref1((V105),(V106)-1);
1047          vs_top=(vs_base=base+1)+1;          vs_top=(vs_base=base+1)+1;
1048          return;}          return;}
1049          }          }
1050  }  }
1051  /*      function definition for ADJUST-ARRAY    */  /*      function definition for ADJUST-ARRAY    */
1052    
1053  static L26()  static L25()
1054  {register object *base=vs_base;  {register object *base=vs_base;
1055          register object *sup=base+VM26; VC26          register object *sup=base+VM25; VC25
1056          vs_reserve(VM26);          vs_reserve(VM25);
1057          {register object V109;          {register object V107;
1058          register object V110;          register object V108;
1059          register object V111;          register object V109;
1060            object V110;
1061            object V111;
1062          object V112;          object V112;
1063          object V113;          object V113;
1064          object V114;          object V114;
1065          object V115;          object V115;
1066          object V116;          object V116;
         object V117;  
         object V118;  
1067          if(vs_top-vs_base<2) too_few_arguments();          if(vs_top-vs_base<2) too_few_arguments();
1068          parse_key(vs_base+2,TRUE,FALSE,7,VV[8],VV[7],VV[9],VV[11],VV[20],VV[21],VV[14]);          parse_key(vs_base+2,TRUE,FALSE,7,VV[8],VV[7],VV[9],VV[11],VV[19],VV[20],VV[14]);
1069          V109=(base[0]);          V107=(base[0]);
1070          V110=(base[1]);          V108=(base[1]);
1071          vs_top=sup;          vs_top=sup;
1072          V111=(base[2]);          V109=(base[2]);
1073          V112=(base[3]);          V110=(base[3]);
1074          V113=(base[4]);          V111=(base[4]);
1075          V114=(base[5]);          V112=(base[5]);
1076          V115=(base[6]);          V113=(base[6]);
1077          V116=(base[7]);          V114=(base[7]);
1078          V117=(base[8]);          V115=(base[8]);
1079          V118=(base[9]);          V116=(base[9]);
1080          {register object V119;          {register object V117;
1081          V119= Cnil;          V117= Cnil;
1082          if(!(type_of((V110))==t_fixnum||type_of((V110))==t_bignum)){          if(!(type_of((V108))==t_fixnum||type_of((V108))==t_bignum)){
1083          goto T359;}          goto T355;}
1084          V110= make_cons((V110),Cnil);          V108= make_cons((V108),Cnil);
1085  T359:;  T355:;
1086          {register object x= VV[11],V120= (V111);          {register object x= VV[11],V118= (V109);
1087          while(!endp(V120))          while(!endp(V118))
1088          if(eql(x,V120->c.c_car)){          if(eql(x,V118->c.c_car)){
1089          V119= V120;          V117= V118;
1090          goto T367;          goto T363;
1091          }else V120=V120->c.c_cdr;          }else V118=V118->c.c_cdr;
1092          V119= Cnil;}          V117= Cnil;}
1093  T367:;  T363:;
1094          if(((V119))==Cnil){          if(((V117))==Cnil){
1095          goto T365;}          goto T361;}
1096          base[17]= (V109);          base[17]= (V107);
1097          vs_top=(vs_base=base+17)+1;          vs_top=(vs_base=base+17)+1;
1098          (void) (*Lnk30)();          (void) (*Lnk29)();
1099          vs_top=sup;          vs_top=sup;
1100          if((vs_base[0])!=Cnil){          if((vs_base[0])!=Cnil){
1101          goto T363;}          goto T359;}
1102          base[17]= VV[13];          base[17]= VV[13];
1103          vs_top=(vs_base=base+17)+1;          vs_top=(vs_base=base+17)+1;
1104          Lerror();          Lerror();
1105          vs_top=sup;          vs_top=sup;
1106          goto T363;          goto T359;
1107  T365:;  T361:;
1108          base[17]= (V109);          base[17]= (V107);
1109          vs_top=(vs_base=base+17)+1;          vs_top=(vs_base=base+17)+1;
1110          (void) (*Lnk30)();          (void) (*Lnk29)();
1111          vs_top=sup;          vs_top=sup;
1112          if((vs_base[0])==Cnil){          if((vs_base[0])==Cnil){
1113          goto T363;}          goto T359;}
1114          base[17]= (V109);          base[17]= (V107);
1115          vs_top=(vs_base=base+17)+1;          vs_top=(vs_base=base+17)+1;
1116          Lfill_pointer();          Lfill_pointer();
1117          vs_top=sup;          vs_top=sup;
1118          V121= vs_base[0];          V119= vs_base[0];
1119          V111= ON_STACK_CONS(V121,(V111));          V109= ON_STACK_CONS(V119,(V109));
1120          V111= ON_STACK_CONS(VV[11],(V111));          V109= ON_STACK_CONS(VV[11],(V109));
1121  T363:;  T359:;
1122          base[17]= (V109);          base[17]= (V107);
1123          vs_top=(vs_base=base+17)+1;          vs_top=(vs_base=base+17)+1;
1124          Larray_element_type();          Larray_element_type();
1125          vs_top=sup;          vs_top=sup;
1126          V112= vs_base[0];          V110= vs_base[0];
1127          if(((V112))==(Ct)){          if(((V110))==(Ct)){
1128          goto T383;}          goto T379;}
1129          V111= ON_STACK_CONS((V112),(V111));          V109= ON_STACK_CONS((V110),(V109));
1130          V111= ON_STACK_CONS(VV[8],(V111));          V109= ON_STACK_CONS(VV[8],(V109));
1131  T383:;  T379:;
1132          {register object x= VV[14],V122= (V111);          {register object x= VV[14],V120= (V109);
1133          while(!endp(V122))          while(!endp(V120))
1134          if(eql(x,V122->c.c_car)){          if(eql(x,V120->c.c_car)){
1135          goto T389;          goto T385;
1136          }else V122=V122->c.c_cdr;}          }else V120=V120->c.c_cdr;}
1137          base[17]= (V109);          base[17]= (V107);
1138          vs_top=(vs_base=base+17)+1;          vs_top=(vs_base=base+17)+1;
1139          (void) (*Lnk31)();          (void) (*Lnk30)();
1140          vs_top=sup;          vs_top=sup;
1141          V123= vs_base[0];          V121= vs_base[0];
1142          V111= ON_STACK_CONS(V123,(V111));          V109= ON_STACK_CONS(V121,(V109));
1143          V111= ON_STACK_CONS(VV[14],(V111));          V109= ON_STACK_CONS(VV[14],(V109));
1144  T389:;  T385:;
1145          {register object V124;          {register object V122;
1146          base[17]= (V110);          base[17]= (V108);
1147          base[18]= VV[15];          base[18]= VV[15];
1148          base[19]= Ct;          base[19]= Ct;
1149          {object V125;          {object V123;
1150          V125= (V111);          V123= (V109);
1151           vs_top=base+20;           vs_top=base+20;
1152           while(!endp(V125))           while(!endp(V123))
1153           {vs_push(car(V125));V125=cdr(V125);}           {vs_push(car(V123));V123=cdr(V123);}
1154          vs_base=base+17;}          vs_base=base+17;}
1155          (void) (*Lnk28)();          (void) (*Lnk27)();
1156          vs_top=sup;          vs_top=sup;
1157          V124= vs_base[0];          V122= vs_base[0];
1158          if((cdr((V110)))==Cnil){          if((cdr((V108)))==Cnil){
1159          goto T403;}          goto T399;}
1160          V126= cdr((V110));          V124= cdr((V108));
1161          base[17]= (V109);          base[17]= (V107);
1162          vs_top=(vs_base=base+17)+1;          vs_top=(vs_base=base+17)+1;
1163          (void) (*Lnk32)();          (void) (*Lnk31)();
1164          vs_top=sup;          vs_top=sup;
1165          V127= vs_base[0];          V125= vs_base[0];
1166          if(!(equal(/* INLINE-ARGS */V126,cdr(V127)))){          if(!(equal(/* INLINE-ARGS */V124,cdr(V125)))){
1167          goto T404;}          goto T400;}
1168          if(!(((V112))==(VV[16]))){          if(!(((V110))==(VV[16]))){
1169          goto T403;}          goto T399;}
1170          base[17]= (V110);          base[17]= (V108);
1171          vs_top=(vs_base=base+17)+1;          vs_top=(vs_base=base+17)+1;
1172          Llast();          Llast();
1173          vs_top=sup;          vs_top=sup;
1174          V128= vs_base[0];          V126= vs_base[0];
1175          {int V129= fix(car(V128));          {int V127= fix(car(V126));
1176          if(!((0)==((V129>=0&&(8)>0?(V129)%(8):imod(V129,8))))){          if(!((0)==((V127>=0&&(8)>0?(V127)%(8):imod(V127,8))))){
1177          goto T404;}}          goto T400;}}
1178  T403:;  T399:;
1179          base[17]= (V109);          base[17]= (V107);
1180          base[18]= (V124);          base[18]= (V122);
1181          base[19]= small_fixnum(0);          base[19]= small_fixnum(0);
1182          base[20]= small_fixnum(0);          base[20]= small_fixnum(0);
1183          base[22]= (V124);          base[22]= (V122);
1184          vs_top=(vs_base=base+22)+1;          vs_top=(vs_base=base+22)+1;
1185          (void) (*Lnk33)();          (void) (*Lnk32)();
1186          vs_top=sup;          vs_top=sup;
1187          V130= vs_base[0];          V128= vs_base[0];
1188          base[22]= (V109);          base[22]= (V107);
1189          vs_top=(vs_base=base+22)+1;          vs_top=(vs_base=base+22)+1;
1190          (void) (*Lnk33)();          (void) (*Lnk32)();
1191          vs_top=sup;          vs_top=sup;
1192          V131= vs_base[0];          V129= vs_base[0];
1193          base[21]= (number_compare(V130,V131)<=0?(V130):V131);          base[21]= (number_compare(V128,V129)<=0?(V128):V129);
1194          vs_top=(vs_base=base+17)+5;          vs_top=(vs_base=base+17)+5;
1195          (void) (*Lnk34)();          (void) (*Lnk33)();
1196          vs_top=sup;          vs_top=sup;
1197          goto T402;          goto T398;
1198  T404:;  T400:;
1199          {register object V132;          {register object V130;
1200          base[17]= make_fixnum(length((V110)));          base[17]= make_fixnum(length((V108)));
1201          base[18]= VV[7];          base[18]= VV[7];
1202          base[19]= small_fixnum(0);          base[19]= small_fixnum(0);
1203          vs_top=(vs_base=base+17)+3;          vs_top=(vs_base=base+17)+3;
1204          Lmake_list();          Lmake_list();
1205          vs_top=sup;          vs_top=sup;
1206          V132= vs_base[0];          V130= vs_base[0];
1207  T430:;  T426:;
1208          base[17]= (V109);          base[17]= (V107);
1209          {object V133;          {object V131;
1210          V133= (V132);          V131= (V130);
1211           vs_top=base+18;           vs_top=base+18;
1212           while(!endp(V133))           while(!endp(V131))
1213           {vs_push(car(V133));V133=cdr(V133);}           {vs_push(car(V131));V131=cdr(V131);}
1214          vs_base=base+17;}          vs_base=base+17;}
1215          (void) (*Lnk35)();          (void) (*Lnk34)();
1216          vs_top=sup;          vs_top=sup;
1217          if((vs_base[0])==Cnil){          if((vs_base[0])==Cnil){
1218          goto T433;}          goto T429;}
1219          base[17]= (V124);          base[17]= (V122);
1220          base[19]= (V109);          base[19]= (V107);
1221          {object V134;          {object V132;
1222          V134= (V132);          V132= (V130);
1223           vs_top=base+20;           vs_top=base+20;
1224           while(!endp(V134))           while(!endp(V132))
1225           {vs_push(car(V134));V134=cdr(V134);}           {vs_push(car(V132));V132=cdr(V132);}
1226          vs_base=base+19;}          vs_base=base+19;}
1227          Laref();          Laref();
1228          vs_top=sup;          vs_top=sup;
1229          base[18]= vs_base[0];          base[18]= vs_base[0];
1230          base[19]= (V132);          base[19]= (V130);
1231          vs_top=(vs_base=base+17)+3;          vs_top=(vs_base=base+17)+3;
1232          (void) (*Lnk26)();          (void) (*Lnk25)();
1233          vs_top=sup;          vs_top=sup;
1234  T433:;  T429:;
1235          base[17]= (V132);          base[17]= (V130);
1236          base[18]= (V110);          base[18]= (V108);
1237          vs_top=(vs_base=base+17)+2;          vs_top=(vs_base=base+17)+2;
1238          (void) (*Lnk27)();          (void) (*Lnk26)();
1239          vs_top=sup;          vs_top=sup;
1240          if((vs_base[0])==Cnil){          if((vs_base[0])==Cnil){
1241          goto T443;}          goto T439;}
1242          goto T402;          goto T398;
1243  T443:;  T439:;
1244          goto T430;}          goto T426;}
1245  T402:;  T398:;
1246          base[17]= (V109);          base[17]= (V107);
1247          base[18]= (V124);          base[18]= (V122);
1248          vs_top=(vs_base=base+17)+2;          vs_top=(vs_base=base+17)+2;
1249          siLreplace_array();          siLreplace_array();
1250          vs_top=sup;          vs_top=sup;
1251          V119= cadr((V119));          V117= cadr((V117));
1252          if(((V119))==Cnil){          if(((V117))==Cnil){
1253            goto T451;}
1254            if(!(eql(Ct,(V117)))){
1255          goto T455;}          goto T455;}
1256          if(!(eql(Ct,(V119)))){          base[17]= (V107);
1257          goto T459;}          base[19]= (V107);
         base[17]= (V109);  
         base[19]= (V109);  
1258          vs_top=(vs_base=base+19)+1;          vs_top=(vs_base=base+19)+1;
1259          (void) (*Lnk33)();          (void) (*Lnk32)();
1260          vs_top=sup;          vs_top=sup;
1261          base[18]= vs_base[0];          base[18]= vs_base[0];
1262          vs_top=(vs_base=base+17)+2;          vs_top=(vs_base=base+17)+2;
1263          siLfill_pointer_set();          siLfill_pointer_set();
1264          vs_top=sup;          vs_top=sup;
1265          goto T455;          goto T451;
1266  T459:;  T455:;
1267          if(!(type_of((V119))==t_fixnum)){          if(!(type_of((V117))==t_fixnum)){
1268          goto T465;}          goto T461;}
1269          base[17]= (V109);          base[17]= (V107);
1270          base[18]= (V119);          base[18]= (V117);
1271          vs_top=(vs_base=base+17)+2;          vs_top=(vs_base=base+17)+2;
1272          siLfill_pointer_set();          siLfill_pointer_set();
1273          vs_top=sup;          vs_top=sup;
1274          goto T455;          goto T451;
1275  T465:;  T461:;
1276          base[17]= VV[17];          base[17]= VV[17];
1277          base[18]= (V119);          base[18]= (V117);
1278          vs_top=(vs_base=base+17)+2;          vs_top=(vs_base=base+17)+2;
1279          Lerror();          Lerror();
1280          vs_top=sup;          vs_top=sup;
1281  T455:;  T451:;
1282          base[17]= (V109);          base[17]= (V107);
1283          vs_top=(vs_base=base+17)+1;          vs_top=(vs_base=base+17)+1;
1284          return;}}          return;}}
1285          }          }
1286  }  }
1287  static LnkT35(){ call_or_link(VV[35],&Lnk35);} /* ARRAY-IN-BOUNDS-P */  static LnkT34(){ call_or_link(VV[34],&Lnk34);} /* ARRAY-IN-BOUNDS-P */
1288  static LnkT34(){ call_or_link(VV[34],&Lnk34);} /* COPY-ARRAY-PORTION */  static LnkT33(){ call_or_link(VV[33],&Lnk33);} /* COPY-ARRAY-PORTION */
1289  static LnkT33(){ call_or_link(VV[33],&Lnk33);} /* ARRAY-TOTAL-SIZE */  static LnkT32(){ call_or_link(VV[32],&Lnk32);} /* ARRAY-TOTAL-SIZE */
1290  static LnkT32(){ call_or_link(VV[32],&Lnk32);} /* ARRAY-DIMENSIONS */  static LnkT31(){ call_or_link(VV[31],&Lnk31);} /* ARRAY-DIMENSIONS */
1291  static LnkT31(){ call_or_link(VV[31],&Lnk31);} /* STATICP */  static LnkT30(){ call_or_link(VV[30],&Lnk30);} /* STATICP */
1292  static LnkT30(){ call_or_link(VV[30],&Lnk30);} /* ARRAY-HAS-FILL-POINTER-P */  static LnkT29(){ call_or_link(VV[29],&Lnk29);} /* ARRAY-HAS-FILL-POINTER-P */
1293  static LnkT29(){ call_or_link(VV[29],&Lnk29);} /* ADJUST-ARRAY */  static LnkT28(){ call_or_link(VV[28],&Lnk28);} /* ADJUST-ARRAY */
1294  static LnkT28(){ call_or_link(VV[28],&Lnk28);} /* MAKE-ARRAY */  static LnkT27(){ call_or_link(VV[27],&Lnk27);} /* MAKE-ARRAY */
1295  static LnkT27(){ call_or_link(VV[27],&Lnk27);} /* INCREMENT-CURSOR */  static LnkT26(){ call_or_link(VV[26],&Lnk26);} /* INCREMENT-CURSOR */
1296  static LnkT26(){ call_or_link(VV[26],&Lnk26);} /* ASET-BY-CURSOR */  static LnkT25(){ call_or_link(VV[25],&Lnk25);} /* ASET-BY-CURSOR */
1297  static LnkT25(){ call_or_link(VV[25],&Lnk25);} /* SEQUENCE-CURSOR */  static LnkT24(){ call_or_link(VV[24],&Lnk24);} /* SEQUENCE-CURSOR */
1298  static LnkT24(){ call_or_link(VV[24],&Lnk24);} /* MAKE-ARRAY1 */  static LnkT23(){ call_or_link(VV[23],&Lnk23);} /* MAKE-ARRAY1 */
1299  static LnkT23(){ call_or_link(VV[23],&Lnk23);} /* GET-AELTTYPE */  static LnkT22(){ call_or_link(VV[22],&Lnk22);} /* GET-AELTTYPE */
1300  static LnkT22(){ call_or_link(VV[22],&Lnk22);} /* BEST-ARRAY-ELEMENT-TYPE */  static LnkT21(){ call_or_link(VV[21],&Lnk21);} /* BEST-ARRAY-ELEMENT-TYPE */
 static LnkT19(){ call_or_link(VV[19],&Lnk19);} /* ARRAY-DISPLACEMENT1 */  
1301  static LnkT18(){ call_or_link(VV[18],&Lnk18);} /* SUBTYPEP */  static LnkT18(){ call_or_link(VV[18],&Lnk18);} /* SUBTYPEP */

Legend:
Removed from v.1.3  
changed lines
  Added in v.1.4

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