home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / devel / lisp / kcl_tar.z / kcl_tar / lsp / arraylib.c next >
Encoding:
C/C++ Source or Header  |  1987-06-04  |  18.4 KB  |  891 lines
  1.  
  2. /* (C) Copyright Taiichi Yuasa and Masami Hagiya, 1984. All rights reserved. */
  3. #include <cmpinclude.h>
  4. #include "arraylib.h"
  5. init_arraylib(start,size,data)char *start;int size;object data;
  6. {    register object *base=vs_top;register object *sup=base+VM2;vs_top=sup;vs_check;
  7.     Cstart=start;Csize=size;Cdata=data;set_VV(VV,VM1,data);
  8.     base[0]= VV[0];
  9.     (void)simple_symlispcall_no_event(VV[20],base+0,1);
  10.     MF(VV[21],L2,start,size,data);
  11.     MF(VV[22],L3,start,size,data);
  12.     MF(VV[23],L4,start,size,data);
  13.     MF(VV[24],L5,start,size,data);
  14.     MF(VV[25],L6,start,size,data);
  15.     MF(VV[26],L7,start,size,data);
  16.     MF(VV[27],L8,start,size,data);
  17.     MF(VV[28],L9,start,size,data);
  18.     MF(VV[29],L10,start,size,data);
  19.     MF(VV[30],L11,start,size,data);
  20.     MF(VV[31],L12,start,size,data);
  21.     MF(VV[32],L13,start,size,data);
  22.     MF(VV[33],L14,start,size,data);
  23.     MF(VV[34],L15,start,size,data);
  24.     MF(VV[35],L16,start,size,data);
  25.     MF(VV[36],L17,start,size,data);
  26.     MF(VV[37],L18,start,size,data);
  27.     MF(VV[38],L19,start,size,data);
  28.     MF(VV[39],L20,start,size,data);
  29.     MF(VV[40],L21,start,size,data);
  30.     MF(VV[41],L22,start,size,data);
  31.     MF(VV[42],L23,start,size,data);
  32.     MF(VV[43],L24,start,size,data);
  33.     MF(VV[44],L25,start,size,data);
  34.     vs_top=vs_base=base;
  35. }
  36. /*    function definition for MAKE-ARRAY    */
  37.  
  38. static L2()
  39. {    register object *base=vs_base;
  40.     register object *sup=base+VM3;
  41.     vs_reserve(VM3);
  42.     if(vs_top-vs_base<1) too_few_arguments();
  43.     parse_key(vs_base+1,FALSE,FALSE,8,VV[4],VV[3],VV[5],VV[19],VV[17],VV[45],VV[46],VV[47]);
  44.     vs_top=sup;
  45.     if(base[9]==Cnil){
  46.     base[1]= Ct;
  47.     }else{}
  48.     if(base[15]==Cnil){
  49.     base[7]= VV[1];
  50.     }else{}
  51.     if(!(type_of(base[0])==t_fixnum||type_of(base[0])==t_bignum)){
  52.     goto T5;}
  53.     base[0]= make_cons(base[0],Cnil);
  54. T5:;
  55.     if(!((length(base[0]))==(1))){
  56.     goto T10;}
  57.     base[18]= base[1];
  58.     base[19]= car(base[0]);
  59.     base[20]= base[4];
  60.     base[21]= base[5];
  61.     base[22]= base[6];
  62.     base[23]= base[7];
  63.     base[24]= base[8];
  64.     vs_top=(vs_base=base+18)+7;
  65.     siLmake_vector();
  66.     vs_top=sup;
  67.     base[17]= vs_base[0];
  68.     if((base[10])==Cnil){
  69.     goto T20;}
  70.     {int V1;
  71.     int V2;
  72.     V1= fix(car(base[0]));
  73.     V2= 0;
  74. T26:;
  75.     if(!((V2)>=(V1))){
  76.     goto T27;}
  77.     goto T20;
  78. T27:;
  79.     (void)(aset1(base[17],V2,base[2]));
  80.     V2= (V2)+1;
  81.     goto T26;}
  82. T20:;
  83.     if((base[11])==Cnil){
  84.     goto T35;}
  85.     {int V3;
  86.     int V4;
  87.     V3= fix(car(base[0]));
  88.     V4= 0;
  89. T41:;
  90.     if(!((V4)>=(V3))){
  91.     goto T42;}
  92.     goto T35;
  93. T42:;
  94.     base[18]= elt(base[3],V4);
  95.     (void)(aset1(base[17],V4,base[18]));
  96.     V4= (V4)+1;
  97.     goto T41;}
  98. T35:;
  99.     vs_top=(vs_base=base+17)+1;
  100.     return;
  101. T10:;
  102.     base[18]= base[1];
  103.     base[19]= base[4];
  104.     base[20]= base[6];
  105.     base[21]= base[7];
  106.     base[22]= base[8];
  107.     {object V5;
  108.     V5= base[0];
  109.      vs_top=base+23;
  110.      while(!endp(V5))
  111.      {vs_push(car(V5));V5=cdr(V5);}
  112.     vs_base=base+18;}
  113.     siLmake_pure_array();
  114.     vs_top=sup;
  115.     base[17]= vs_base[0];
  116.     if((base[10])==Cnil){
  117.     goto T57;}
  118.     base[19]= make_fixnum(length(base[0]));
  119.     base[20]= VV[3];
  120.     base[21]= VV[1];
  121.     vs_top=(vs_base=base+19)+3;
  122.     Lmake_list();
  123.     vs_top=sup;
  124.     base[18]= vs_base[0];
  125. T65:;
  126.     base[19]= base[17];
  127.     base[20]= base[2];
  128.     base[21]= base[18];
  129.     (void)simple_symlispcall_no_event(VV[48],base+19,3);
  130.     base[19]= base[18];
  131.     base[20]= base[0];
  132.     vs_top=(vs_base=base+19)+2;
  133.     L3();
  134.     vs_top=sup;
  135.     if((vs_base[0])==Cnil){
  136.     goto T72;}
  137.     goto T57;
  138. T72:;
  139.     goto T65;
  140. T57:;
  141.     if((base[11])==Cnil){
  142.     goto T79;}
  143.     base[19]= make_fixnum(length(base[0]));
  144.     base[20]= VV[3];
  145.     base[21]= VV[1];
  146.     vs_top=(vs_base=base+19)+3;
  147.     Lmake_list();
  148.     vs_top=sup;
  149.     base[18]= vs_base[0];
  150. T87:;
  151.     base[19]=symbol_function(VV[48]);
  152.     base[20]= base[17];
  153.     base[22]= base[3];
  154.     base[23]= base[18];
  155.     vs_top=(vs_base=base+22)+2;
  156.     L4();
  157.     vs_top=sup;
  158.     base[21]= vs_base[0];
  159.     base[22]= base[18];
  160.     (void)simple_lispcall_no_event(base+19,3);
  161.     base[19]= base[18];
  162.     base[20]= base[0];
  163.     vs_top=(vs_base=base+19)+2;
  164.     L3();
  165.     vs_top=sup;
  166.     if((vs_base[0])==Cnil){
  167.     goto T96;}
  168.     goto T79;
  169. T96:;
  170.     goto T87;
  171. T79:;
  172.     vs_top=(vs_base=base+17)+1;
  173.     return;
  174. }
  175. /*    function definition for INCREMENT-CURSOR    */
  176.  
  177. static L3()
  178. {    register object *base=vs_base;
  179.     register object *sup=base+VM4;
  180.     vs_reserve(VM4);
  181.     check_arg(2);
  182.     vs_top=sup;
  183. TTL:;
  184.     if((base[0])!=Cnil){
  185.     goto T104;}
  186.     base[2]= Ct;
  187.     vs_top=(vs_base=base+2)+1;
  188.     return;
  189. T104:;
  190.     base[3]= cdr(base[0]);
  191.     base[4]= cdr(base[1]);
  192.     vs_top=(vs_base=base+3)+2;
  193.     L3();
  194.     vs_top=sup;
  195.     base[2]= vs_base[0];
  196.     if((base[2])==Cnil){
  197.     goto T110;}
  198.     if(!(((fix(car(base[0])))+1)>=(fix(car(base[1]))))){
  199.     goto T113;}
  200.     if(type_of(base[0])!=t_cons)FEwrong_type_argument(Scons,base[0]);
  201.     (base[0])->c.c_car = VV[1];
  202.     base[3]= Ct;
  203.     vs_top=(vs_base=base+3)+1;
  204.     return;
  205. T113:;
  206.     base[3]= make_fixnum((fix(car(base[0])))+1);
  207.     if(type_of(base[0])!=t_cons)FEwrong_type_argument(Scons,base[0]);
  208.     (base[0])->c.c_car = base[3];
  209.     base[3]= Cnil;
  210.     vs_top=(vs_base=base+3)+1;
  211.     return;
  212. T110:;
  213.     base[3]= Cnil;
  214.     vs_top=(vs_base=base+3)+1;
  215.     return;
  216. }
  217. /*    function definition for SEQUENCE-CURSOR    */
  218.  
  219. static L4()
  220. {    register object *base=vs_base;
  221.     register object *sup=base+VM5;
  222.     vs_reserve(VM5);
  223.     check_arg(2);
  224.     vs_top=sup;
  225. TTL:;
  226.     if((base[1])!=Cnil){
  227.     goto T118;}
  228.     vs_top=(vs_base=base+0)+1;
  229.     return;
  230. T118:;
  231.     base[0]= elt(base[0],fix(car(base[1])));
  232.     base[1]= cdr(base[1]);
  233.     goto TTL;
  234. }
  235. /*    function definition for VECTOR    */
  236.  
  237. static L5()
  238. {    register object *base=vs_base;
  239.     register object *sup=base+VM6;
  240.     vs_reserve(VM6);
  241.     vs_top[0]=Cnil;
  242.     {object *p=vs_top;
  243.      for(;p>vs_base;p--)p[-1]=MMcons(p[-1],p[0]);}
  244.     vs_top=sup;
  245.     base[2]= make_fixnum(length(base[0]));
  246.     base[1]= make_cons(base[2],Cnil);
  247.     base[2]= VV[4];
  248.     base[3]= Ct;
  249.     base[4]= VV[5];
  250.     base[5]= base[0];
  251.     vs_top=(vs_base=base+1)+5;
  252.     L2();
  253.     return;
  254. }
  255. /*    function definition for ARRAY-DIMENSIONS    */
  256.  
  257. static L6()
  258. {    register object *base=vs_base;
  259.     register object *sup=base+VM7;
  260.     vs_reserve(VM7);
  261.     check_arg(1);
  262.     vs_top=sup;
  263. TTL:;
  264.     base[3]= base[0];
  265.     vs_top=(vs_base=base+3)+1;
  266.     Larray_rank();
  267.     vs_top=sup;
  268.     base[1]= vs_base[0];
  269.     base[2]= Cnil;
  270. T131:;
  271.     if(!(number_compare(base[1],VV[1])==0)){
  272.     goto T132;}
  273.     vs_top=(vs_base=base+2)+1;
  274.     return;
  275. T132:;
  276.     base[1]= one_minus(base[1]);
  277.     base[4]= base[0];
  278.     base[5]= base[1];
  279.     vs_top=(vs_base=base+4)+2;
  280.     Larray_dimension();
  281.     vs_top=sup;
  282.     base[3]= vs_base[0];
  283.     base[2]= make_cons(base[3],base[2]);
  284.     goto T131;
  285. }
  286. /*    function definition for ARRAY-IN-BOUNDS-P    */
  287.  
  288. static L7()
  289. {    register object *base=vs_base;
  290.     register object *sup=base+VM8;
  291.     vs_reserve(VM8);
  292.     if(vs_top-vs_base<1) too_few_arguments();
  293.     vs_base=vs_base+1;
  294.     vs_top[0]=Cnil;
  295.     {object *p=vs_top;
  296.      for(;p>vs_base;p--)p[-1]=MMcons(p[-1],p[0]);}
  297.     vs_top=sup;
  298.     base[3]= base[0];
  299.     vs_top=(vs_base=base+3)+1;
  300.     Larray_rank();
  301.     vs_top=sup;
  302.     base[2]= vs_base[0];
  303.     base[3]= make_fixnum(length(base[1]));
  304.     if(!(number_compare(base[2],base[3])!=0)){
  305.     goto T147;}
  306.     base[3]= VV[6];
  307.     base[4]= base[2];
  308.     base[5]= make_fixnum(length(base[1]));
  309.     vs_top=(vs_base=base+3)+3;
  310.     Lerror();
  311.     vs_top=sup;
  312. T147:;
  313.     base[3]= VV[1];
  314.     base[4]= base[1];
  315. T154:;
  316.     if(!(number_compare(base[3],base[2])>=0)){
  317.     goto T155;}
  318.     base[5]= Ct;
  319.     vs_top=(vs_base=base+5)+1;
  320.     return;
  321. T155:;
  322.     if(number_compare(car(base[4]),VV[1])<0){
  323.     goto T160;}
  324.     {object V6= car(base[4]);
  325.     base[6]= base[0];
  326.     base[7]= base[3];
  327.     vs_top=(vs_base=base+6)+2;
  328.     Larray_dimension();
  329.     vs_top=sup;
  330.     base[5]= vs_base[0];
  331.     if(!(number_compare(V6,base[5])>=0)){
  332.     goto T159;}}
  333. T160:;
  334.     base[5]= Cnil;
  335.     vs_top=(vs_base=base+5)+1;
  336.     return;
  337. T159:;
  338.     base[3]= one_plus(base[3]);
  339.     base[4]= cdr(base[4]);
  340.     goto T154;
  341. }
  342. /*    function definition for ARRAY-ROW-MAJOR-INDEX    */
  343.  
  344. static L8()
  345. {    register object *base=vs_base;
  346.     register object *sup=base+VM9;
  347.     vs_reserve(VM9);
  348.     if(vs_top-vs_base<1) too_few_arguments();
  349.     vs_base=vs_base+1;
  350.     vs_top[0]=Cnil;
  351.     {object *p=vs_top;
  352.      for(;p>vs_base;p--)p[-1]=MMcons(p[-1],p[0]);}
  353.     vs_top=sup;
  354.     base[2]= VV[1];
  355.     base[3]= VV[1];
  356.     base[4]= base[1];
  357. T172:;
  358.     if((base[4])!=Cnil){
  359.     goto T173;}
  360.     vs_top=(vs_base=base+3)+1;
  361.     return;
  362. T173:;
  363.     base[5]= one_plus(base[2]);
  364.     base[7]= base[0];
  365.     base[8]= base[2];
  366.     vs_top=(vs_base=base+7)+2;
  367.     Larray_dimension();
  368.     vs_top=sup;
  369.     base[6]= vs_base[0];
  370.     base[7]= number_times(base[3],base[6]);
  371.     base[3]= number_plus(base[7],car(base[4]));
  372.     base[4]= cdr(base[4]);
  373.     base[2]= base[5];
  374.     goto T172;
  375. }
  376. /*    function definition for BIT    */
  377.  
  378. static L9()
  379. {    register object *base=vs_base;
  380.     register object *sup=base+VM10;
  381.     vs_reserve(VM10);
  382.     if(vs_top-vs_base<1) too_few_arguments();
  383.     vs_base=vs_base+1;
  384.     vs_top[0]=Cnil;
  385.     {object *p=vs_top;
  386.      for(;p>vs_base;p--)p[-1]=MMcons(p[-1],p[0]);}
  387.     vs_top=sup;
  388.     base[2]= base[0];
  389.     {object V7;
  390.     V7= base[1];
  391.      vs_top=base+3;
  392.      while(!endp(V7))
  393.      {vs_push(car(V7));V7=cdr(V7);}
  394.     vs_base=base+2;}
  395.     Laref();
  396.     return;
  397. }
  398. /*    function definition for SBIT    */
  399.  
  400. static L10()
  401. {    register object *base=vs_base;
  402.     register object *sup=base+VM11;
  403.     vs_reserve(VM11);
  404.     if(vs_top-vs_base<1) too_few_arguments();
  405.     vs_base=vs_base+1;
  406.     vs_top[0]=Cnil;
  407.     {object *p=vs_top;
  408.      for(;p>vs_base;p--)p[-1]=MMcons(p[-1],p[0]);}
  409.     vs_top=sup;
  410.     base[2]= base[0];
  411.     {object V8;
  412.     V8= base[1];
  413.      vs_top=base+3;
  414.      while(!endp(V8))
  415.      {vs_push(car(V8));V8=cdr(V8);}
  416.     vs_base=base+2;}
  417.     Laref();
  418.     return;
  419. }
  420. /*    function definition for BIT-AND    */
  421.  
  422. static L11()
  423. {    register object *base=vs_base;
  424.     register object *sup=base+VM12;
  425.     vs_reserve(VM12);
  426.     if(vs_top-vs_base<2) too_few_arguments();
  427.     if(vs_top-vs_base>3) too_many_arguments();
  428.     vs_base=vs_base+2;
  429.     if(vs_base>=vs_top){vs_top=sup;goto T189;}
  430.     vs_top=sup;
  431.     goto T190;
  432. T189:;
  433.     base[2]= Cnil;
  434. T190:;
  435.     base[3]= VV[2];
  436.     base[4]= base[0];
  437.     base[5]= base[1];
  438.     base[6]= base[2];
  439.     symlispcall_no_event(VV[49],base+3,4);
  440.     return;
  441. }
  442. /*    function definition for BIT-IOR    */
  443.  
  444. static L12()
  445. {    register object *base=vs_base;
  446.     register object *sup=base+VM13;
  447.     vs_reserve(VM13);
  448.     if(vs_top-vs_base<2) too_few_arguments();
  449.     if(vs_top-vs_base>3) too_many_arguments();
  450.     vs_base=vs_base+2;
  451.     if(vs_base>=vs_top){vs_top=sup;goto T196;}
  452.     vs_top=sup;
  453.     goto T197;
  454. T196:;
  455.     base[2]= Cnil;
  456. T197:;
  457.     base[3]= VV[7];
  458.     base[4]= base[0];
  459.     base[5]= base[1];
  460.     base[6]= base[2];
  461.     symlispcall_no_event(VV[49],base+3,4);
  462.     return;
  463. }
  464. /*    function definition for BIT-XOR    */
  465.  
  466. static L13()
  467. {    register object *base=vs_base;
  468.     register object *sup=base+VM14;
  469.     vs_reserve(VM14);
  470.     if(vs_top-vs_base<2) too_few_arguments();
  471.     if(vs_top-vs_base>3) too_many_arguments();
  472.     vs_base=vs_base+2;
  473.     if(vs_base>=vs_top){vs_top=sup;goto T203;}
  474.     vs_top=sup;
  475.     goto T204;
  476. T203:;
  477.     base[2]= Cnil;
  478. T204:;
  479.     base[3]= VV[8];
  480.     base[4]= base[0];
  481.     base[5]= base[1];
  482.     base[6]= base[2];
  483.     symlispcall_no_event(VV[49],base+3,4);
  484.     return;
  485. }
  486. /*    function definition for BIT-EQV    */
  487.  
  488. static L14()
  489. {    register object *base=vs_base;
  490.     register object *sup=base+VM15;
  491.     vs_reserve(VM15);
  492.     if(vs_top-vs_base<2) too_few_arguments();
  493.     if(vs_top-vs_base>3) too_many_arguments();
  494.     vs_base=vs_base+2;
  495.     if(vs_base>=vs_top){vs_top=sup;goto T210;}
  496.     vs_top=sup;
  497.     goto T211;
  498. T210:;
  499.     base[2]= Cnil;
  500. T211:;
  501.     base[3]= VV[9];
  502.     base[4]= base[0];
  503.     base[5]= base[1];
  504.     base[6]= base[2];
  505.     symlispcall_no_event(VV[49],base+3,4);
  506.     return;
  507. }
  508. /*    function definition for BIT-NAND    */
  509.  
  510. static L15()
  511. {    register object *base=vs_base;
  512.     register object *sup=base+VM16;
  513.     vs_reserve(VM16);
  514.     if(vs_top-vs_base<2) too_few_arguments();
  515.     if(vs_top-vs_base>3) too_many_arguments();
  516.     vs_base=vs_base+2;
  517.     if(vs_base>=vs_top){vs_top=sup;goto T217;}
  518.     vs_top=sup;
  519.     goto T218;
  520. T217:;
  521.     base[2]= Cnil;
  522. T218:;
  523.     base[3]= VV[10];
  524.     base[4]= base[0];
  525.     base[5]= base[1];
  526.     base[6]= base[2];
  527.     symlispcall_no_event(VV[49],base+3,4);
  528.     return;
  529. }
  530. /*    function definition for BIT-NOR    */
  531.  
  532. static L16()
  533. {    register object *base=vs_base;
  534.     register object *sup=base+VM17;
  535.     vs_reserve(VM17);
  536.     if(vs_top-vs_base<2) too_few_arguments();
  537.     if(vs_top-vs_base>3) too_many_arguments();
  538.     vs_base=vs_base+2;
  539.     if(vs_base>=vs_top){vs_top=sup;goto T224;}
  540.     vs_top=sup;
  541.     goto T225;
  542. T224:;
  543.     base[2]= Cnil;
  544. T225:;
  545.     base[3]= VV[11];
  546.     base[4]= base[0];
  547.     base[5]= base[1];
  548.     base[6]= base[2];
  549.     symlispcall_no_event(VV[49],base+3,4);
  550.     return;
  551. }
  552. /*    function definition for BIT-ANDC1    */
  553.  
  554. static L17()
  555. {    register object *base=vs_base;
  556.     register object *sup=base+VM18;
  557.     vs_reserve(VM18);
  558.     if(vs_top-vs_base<2) too_few_arguments();
  559.     if(vs_top-vs_base>3) too_many_arguments();
  560.     vs_base=vs_base+2;
  561.     if(vs_base>=vs_top){vs_top=sup;goto T231;}
  562.     vs_top=sup;
  563.     goto T232;
  564. T231:;
  565.     base[2]= Cnil;
  566. T232:;
  567.     base[3]= VV[12];
  568.     base[4]= base[0];
  569.     base[5]= base[1];
  570.     base[6]= base[2];
  571.     symlispcall_no_event(VV[49],base+3,4);
  572.     return;
  573. }
  574. /*    function definition for BIT-ANDC2    */
  575.  
  576. static L18()
  577. {    register object *base=vs_base;
  578.     register object *sup=base+VM19;
  579.     vs_reserve(VM19);
  580.     if(vs_top-vs_base<2) too_few_arguments();
  581.     if(vs_top-vs_base>3) too_many_arguments();
  582.     vs_base=vs_base+2;
  583.     if(vs_base>=vs_top){vs_top=sup;goto T238;}
  584.     vs_top=sup;
  585.     goto T239;
  586. T238:;
  587.     base[2]= Cnil;
  588. T239:;
  589.     base[3]= VV[13];
  590.     base[4]= base[0];
  591.     base[5]= base[1];
  592.     base[6]= base[2];
  593.     symlispcall_no_event(VV[49],base+3,4);
  594.     return;
  595. }
  596. /*    function definition for BIT-ORC1    */
  597.  
  598. static L19()
  599. {    register object *base=vs_base;
  600.     register object *sup=base+VM20;
  601.     vs_reserve(VM20);
  602.     if(vs_top-vs_base<2) too_few_arguments();
  603.     if(vs_top-vs_base>3) too_many_arguments();
  604.     vs_base=vs_base+2;
  605.     if(vs_base>=vs_top){vs_top=sup;goto T245;}
  606.     vs_top=sup;
  607.     goto T246;
  608. T245:;
  609.     base[2]= Cnil;
  610. T246:;
  611.     base[3]= VV[14];
  612.     base[4]= base[0];
  613.     base[5]= base[1];
  614.     base[6]= base[2];
  615.     symlispcall_no_event(VV[49],base+3,4);
  616.     return;
  617. }
  618. /*    function definition for BIT-ORC2    */
  619.  
  620. static L20()
  621. {    register object *base=vs_base;
  622.     register object *sup=base+VM21;
  623.     vs_reserve(VM21);
  624.     if(vs_top-vs_base<2) too_few_arguments();
  625.     if(vs_top-vs_base>3) too_many_arguments();
  626.     vs_base=vs_base+2;
  627.     if(vs_base>=vs_top){vs_top=sup;goto T252;}
  628.     vs_top=sup;
  629.     goto T253;
  630. T252:;
  631.     base[2]= Cnil;
  632. T253:;
  633.     base[3]= VV[15];
  634.     base[4]= base[0];
  635.     base[5]= base[1];
  636.     base[6]= base[2];
  637.     symlispcall_no_event(VV[49],base+3,4);
  638.     return;
  639. }
  640. /*    function definition for BIT-NOT    */
  641.  
  642. static L21()
  643. {    register object *base=vs_base;
  644.     register object *sup=base+VM22;
  645.     vs_reserve(VM22);
  646.     if(vs_top-vs_base<1) too_few_arguments();
  647.     if(vs_top-vs_base>2) too_many_arguments();
  648.     vs_base=vs_base+1;
  649.     if(vs_base>=vs_top){vs_top=sup;goto T259;}
  650.     vs_top=sup;
  651.     goto T260;
  652. T259:;
  653.     base[1]= Cnil;
  654. T260:;
  655.     base[2]= VV[16];
  656.     base[3]= base[0];
  657.     base[4]= base[0];
  658.     base[5]= base[1];
  659.     symlispcall_no_event(VV[49],base+2,4);
  660.     return;
  661. }
  662. /*    function definition for VECTOR-PUSH    */
  663.  
  664. static L22()
  665. {    register object *base=vs_base;
  666.     register object *sup=base+VM23;
  667.     vs_reserve(VM23);
  668.     check_arg(2);
  669.     vs_top=sup;
  670. TTL:;
  671.     {int V9;
  672.     base[2]= base[1];
  673.     vs_top=(vs_base=base+2)+1;
  674.     Lfill_pointer();
  675.     vs_top=sup;
  676.     V9= fix(vs_base[0]);
  677.     base[3]= base[1];
  678.     base[4]= VV[1];
  679.     vs_top=(vs_base=base+3)+2;
  680.     Larray_dimension();
  681.     vs_top=sup;
  682.     base[2]= vs_base[0];
  683.     if(!((V9)<(fix(base[2])))){
  684.     goto T269;}
  685.     (void)(aset1(base[1],V9,base[0]));
  686.     base[2]= base[1];
  687.     base[3]= make_fixnum((V9)+1);
  688.     vs_top=(vs_base=base+2)+2;
  689.     siLfill_pointer_set();
  690.     vs_top=sup;
  691.     base[2]= make_fixnum(V9);
  692.     vs_top=(vs_base=base+2)+1;
  693.     return;
  694. T269:;
  695.     base[2]= Cnil;
  696.     vs_top=(vs_base=base+2)+1;
  697.     return;}
  698. }
  699. /*    function definition for VECTOR-PUSH-EXTEND    */
  700.  
  701. static L23()
  702. {    register object *base=vs_base;
  703.     register object *sup=base+VM24;
  704.     vs_reserve(VM24);
  705.     if(vs_top-vs_base<2) too_few_arguments();
  706.     if(vs_top-vs_base>3) too_many_arguments();
  707.     vs_base=vs_base+2;
  708.     if(vs_base>=vs_top){vs_top=sup;goto T278;}
  709.     vs_top=sup;
  710.     goto T279;
  711. T278:;
  712.     base[3]= base[1];
  713.     base[4]= VV[1];
  714.     vs_top=(vs_base=base+3)+2;
  715.     Larray_dimension();
  716.     vs_top=sup;
  717.     base[2]= vs_base[0];
  718. T279:;
  719.     {int V10;
  720.     base[3]= base[1];
  721.     vs_top=(vs_base=base+3)+1;
  722.     Lfill_pointer();
  723.     vs_top=sup;
  724.     V10= fix(vs_base[0]);
  725.     base[4]= base[1];
  726.     base[5]= VV[1];
  727.     vs_top=(vs_base=base+4)+2;
  728.     Larray_dimension();
  729.     vs_top=sup;
  730.     base[3]= vs_base[0];
  731.     if(!((V10)<(fix(base[3])))){
  732.     goto T286;}
  733.     (void)(aset1(base[1],V10,base[0]));
  734.     base[3]= base[1];
  735.     base[4]= make_fixnum((V10)+1);
  736.     vs_top=(vs_base=base+3)+2;
  737.     siLfill_pointer_set();
  738.     vs_top=sup;
  739.     base[3]= make_fixnum(V10);
  740.     vs_top=(vs_base=base+3)+1;
  741.     return;
  742. T286:;
  743.     base[3]= base[1];
  744.     base[6]= base[1];
  745.     base[7]= VV[1];
  746.     vs_top=(vs_base=base+6)+2;
  747.     Larray_dimension();
  748.     vs_top=sup;
  749.     base[5]= vs_base[0];
  750.     base[6]= number_plus(base[5],base[2]);
  751.     base[4]= make_cons(base[6],Cnil);
  752.     base[5]= VV[4];
  753.     base[7]= base[1];
  754.     vs_top=(vs_base=base+7)+1;
  755.     Larray_element_type();
  756.     vs_top=sup;
  757.     base[6]= vs_base[0];
  758.     base[7]= VV[17];
  759.     base[8]= make_fixnum(V10);
  760.     vs_top=(vs_base=base+3)+6;
  761.     L25();
  762.     vs_top=sup;
  763.     (void)(aset1(base[1],V10,base[0]));
  764.     base[3]= base[1];
  765.     base[4]= make_fixnum((V10)+1);
  766.     vs_top=(vs_base=base+3)+2;
  767.     siLfill_pointer_set();
  768.     vs_top=sup;
  769.     base[3]= make_fixnum(V10);
  770.     vs_top=(vs_base=base+3)+1;
  771.     return;}
  772. }
  773. /*    function definition for VECTOR-POP    */
  774.  
  775. static L24()
  776. {    register object *base=vs_base;
  777.     register object *sup=base+VM25;
  778.     vs_reserve(VM25);
  779.     check_arg(1);
  780.     vs_top=sup;
  781. TTL:;
  782.     {int V11;
  783.     base[1]= base[0];
  784.     vs_top=(vs_base=base+1)+1;
  785.     Lfill_pointer();
  786.     vs_top=sup;
  787.     V11= fix(vs_base[0]);
  788.     if(!((V11)==(0))){
  789.     goto T312;}
  790.     base[1]= VV[18];
  791.     base[2]= base[0];
  792.     vs_top=(vs_base=base+1)+2;
  793.     Lerror();
  794.     vs_top=sup;
  795. T312:;
  796.     base[1]= base[0];
  797.     base[2]= make_fixnum((V11)-1);
  798.     vs_top=(vs_base=base+1)+2;
  799.     siLfill_pointer_set();
  800.     vs_top=sup;
  801.     base[1]= aref1(base[0],(V11)-1);
  802.     vs_top=(vs_base=base+1)+1;
  803.     return;}
  804. }
  805. /*    function definition for ADJUST-ARRAY    */
  806.  
  807. static L25()
  808. {    register object *base=vs_base;
  809.     register object *sup=base+VM26;
  810.     vs_reserve(VM26);
  811.     if(vs_top-vs_base<2) too_few_arguments();
  812.     parse_key(vs_base+2,TRUE,FALSE,7,VV[4],VV[3],VV[5],VV[17],VV[45],VV[46],VV[47]);
  813.     vs_top=sup;
  814.     if(!(type_of(base[1])==t_fixnum||type_of(base[1])==t_bignum)){
  815.     goto T320;}
  816.     base[1]= make_cons(base[1],Cnil);
  817. T320:;
  818.     base[18]= base[0];
  819.     vs_top=(vs_base=base+18)+1;
  820.     Larray_element_type();
  821.     vs_top=sup;
  822.     base[17]= vs_base[0];
  823.     if(base[17]==Ct){
  824.     goto T324;}
  825.     base[2]= make_cons(base[17],base[2]);
  826.     base[2]= make_cons(VV[4],base[2]);
  827. T324:;
  828.     base[18]= base[1];
  829.     base[19]= VV[19];
  830.     base[20]= Ct;
  831.     {object V12;
  832.     V12= base[2];
  833.      vs_top=base+21;
  834.      while(!endp(V12))
  835.      {vs_push(car(V12));V12=cdr(V12);}
  836.     vs_base=base+18;}
  837.     L2();
  838.     vs_top=sup;
  839.     base[17]= vs_base[0];
  840.     base[19]= make_fixnum(length(base[1]));
  841.     base[20]= VV[3];
  842.     base[21]= VV[1];
  843.     vs_top=(vs_base=base+19)+3;
  844.     Lmake_list();
  845.     vs_top=sup;
  846.     base[18]= vs_base[0];
  847. T343:;
  848.     base[19]= base[0];
  849.     {object V13;
  850.     V13= base[18];
  851.      vs_top=base+20;
  852.      while(!endp(V13))
  853.      {vs_push(car(V13));V13=cdr(V13);}
  854.     vs_base=base+19;}
  855.     L7();
  856.     vs_top=sup;
  857.     if((vs_base[0])==Cnil){
  858.     goto T346;}
  859.     base[19]=symbol_function(VV[48]);
  860.     base[20]= base[17];
  861.     base[22]= base[0];
  862.     {object V14;
  863.     V14= base[18];
  864.      vs_top=base+23;
  865.      while(!endp(V14))
  866.      {vs_push(car(V14));V14=cdr(V14);}
  867.     vs_base=base+22;}
  868.     Laref();
  869.     vs_top=sup;
  870.     base[21]= vs_base[0];
  871.     base[22]= base[18];
  872.     (void)simple_lispcall_no_event(base+19,3);
  873. T346:;
  874.     base[19]= base[18];
  875.     base[20]= base[1];
  876.     vs_top=(vs_base=base+19)+2;
  877.     L3();
  878.     vs_top=sup;
  879.     if((vs_base[0])==Cnil){
  880.     goto T356;}
  881.     goto T337;
  882. T356:;
  883.     goto T343;
  884. T337:;
  885.     base[18]= base[0];
  886.     base[19]= base[17];
  887.     vs_top=(vs_base=base+18)+2;
  888.     siLreplace_array();
  889.     return;
  890. }
  891.