home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / devel / lisp / kcl_tar.z / kcl_tar / lsp / evalmacros.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-06-04  |  23.7 KB  |  1,033 lines
  1.  
  2. /* (C) Copyright Taiichi Yuasa and Masami Hagiya, 1984. All rights reserved. */
  3. #include <cmpinclude.h>
  4. #include "evalmacros.h"
  5. init_evalmacros(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.     MM(VV[44],L1,start,size,data);
  9.     MM(VV[45],L2,start,size,data);
  10.     MM(VV[46],L3,start,size,data);
  11.     MM(VV[47],L4,start,size,data);
  12.     MM(VV[48],L5,start,size,data);
  13.     MM(VV[49],L6,start,size,data);
  14.     MM(VV[50],L7,start,size,data);
  15.     MM(VV[51],L8,start,size,data);
  16.     MM(VV[52],L9,start,size,data);
  17.     MM(VV[33],L10,start,size,data);
  18.     MM(VV[53],L11,start,size,data);
  19.     MM(VV[54],L12,start,size,data);
  20.     MM(VV[5],L13,start,size,data);
  21.     MM(VV[55],L14,start,size,data);
  22.     MM(VV[56],L15,start,size,data);
  23.     MM(VV[57],L16,start,size,data);
  24.     MM(VV[58],L17,start,size,data);
  25.     MM(VV[30],L18,start,size,data);
  26.     MM(VV[59],L19,start,size,data);
  27.     MM(VV[60],L20,start,size,data);
  28.     MM(VV[61],L21,start,size,data);
  29.     MM(VV[38],L22,start,size,data);
  30.     MM(VV[62],L23,start,size,data);
  31.     MM(VV[32],L24,start,size,data);
  32.     MM(VV[63],L25,start,size,data);
  33.     MM(VV[64],L26,start,size,data);
  34.     vs_top=vs_base=base;
  35. }
  36. /*    macro definition for DEFVAR    */
  37.  
  38. static L1()
  39. {    register object *base=vs_base;
  40.     register object *sup=base+VM3;
  41.     vs_reserve(VM3);
  42.     check_arg(2);
  43.     vs_top=sup;
  44.     {object V1=base[0]->c.c_cdr;
  45.     if(endp(V1))invalid_macro_call();
  46.     base[2]= (V1->c.c_car);
  47.     V1=V1->c.c_cdr;
  48.     if(endp(V1)){
  49.     base[3]= Cnil;
  50.     base[4]= Cnil;
  51.     } else {
  52.     base[3]= (V1->c.c_car);
  53.     base[4]= Ct;
  54.     V1=V1->c.c_cdr;}
  55.     if(endp(V1)){
  56.     base[5]= Cnil;
  57.     } else {
  58.     base[5]= (V1->c.c_car);
  59.     V1=V1->c.c_cdr;}
  60.     if(!endp(V1))invalid_macro_call();}
  61.     if((base[4])==Cnil){
  62.     goto T4;}
  63.     if((base[5])==Cnil){
  64.     goto T7;}
  65.     base[6]= list(2,VV[2],base[2]);
  66.     base[7]= list(2,VV[1],base[6]);
  67.     base[8]= list(2,VV[2],base[2]);
  68.     base[9]= list(4,VV[3],base[8],base[5],VV[4]);
  69.     base[10]= list(2,VV[2],base[2]);
  70.     base[11]= list(2,VV[6],base[10]);
  71.     base[12]= list(3,VV[7],base[2],base[3]);
  72.     base[13]= list(3,VV[5],base[11],base[12]);
  73.     base[14]= list(2,VV[2],base[2]);
  74.     base[15]= list(5,VV[0],base[7],base[9],base[13],base[14]);
  75.     vs_top=(vs_base=base+15)+1;
  76.     return;
  77. T7:;
  78.     base[6]= list(2,VV[2],base[2]);
  79.     base[7]= list(2,VV[1],base[6]);
  80.     base[8]= list(2,VV[2],base[2]);
  81.     base[9]= list(2,VV[6],base[8]);
  82.     base[10]= list(3,VV[7],base[2],base[3]);
  83.     base[11]= list(3,VV[5],base[9],base[10]);
  84.     base[12]= list(2,VV[2],base[2]);
  85.     base[13]= list(4,VV[0],base[7],base[11],base[12]);
  86.     vs_top=(vs_base=base+13)+1;
  87.     return;
  88. T4:;
  89.     base[6]= list(2,VV[2],base[2]);
  90.     base[7]= list(2,VV[1],base[6]);
  91.     base[8]= list(2,VV[2],base[2]);
  92.     base[9]= list(3,VV[0],base[7],base[8]);
  93.     vs_top=(vs_base=base+9)+1;
  94.     return;
  95. }
  96. /*    macro definition for DEFPARAMETER    */
  97.  
  98. static L2()
  99. {    register object *base=vs_base;
  100.     register object *sup=base+VM4;
  101.     vs_reserve(VM4);
  102.     check_arg(2);
  103.     vs_top=sup;
  104.     {object V2=base[0]->c.c_cdr;
  105.     if(endp(V2))invalid_macro_call();
  106.     base[2]= (V2->c.c_car);
  107.     V2=V2->c.c_cdr;
  108.     if(endp(V2))invalid_macro_call();
  109.     base[3]= (V2->c.c_car);
  110.     V2=V2->c.c_cdr;
  111.     if(endp(V2)){
  112.     base[4]= Cnil;
  113.     } else {
  114.     base[4]= (V2->c.c_car);
  115.     V2=V2->c.c_cdr;}
  116.     if(!endp(V2))invalid_macro_call();}
  117.     if((base[4])==Cnil){
  118.     goto T11;}
  119.     base[5]= list(2,VV[2],base[2]);
  120.     base[6]= list(2,VV[1],base[5]);
  121.     base[7]= list(2,VV[2],base[2]);
  122.     base[8]= list(4,VV[3],base[7],base[4],VV[8]);
  123.     base[9]= list(3,VV[7],base[2],base[3]);
  124.     base[10]= list(2,VV[2],base[2]);
  125.     base[11]= list(5,VV[0],base[6],base[8],base[9],base[10]);
  126.     vs_top=(vs_base=base+11)+1;
  127.     return;
  128. T11:;
  129.     base[5]= list(2,VV[2],base[2]);
  130.     base[6]= list(2,VV[1],base[5]);
  131.     base[7]= list(3,VV[7],base[2],base[3]);
  132.     base[8]= list(2,VV[2],base[2]);
  133.     base[9]= list(4,VV[0],base[6],base[7],base[8]);
  134.     vs_top=(vs_base=base+9)+1;
  135.     return;
  136. }
  137. /*    macro definition for DEFCONSTANT    */
  138.  
  139. static L3()
  140. {    register object *base=vs_base;
  141.     register object *sup=base+VM5;
  142.     vs_reserve(VM5);
  143.     check_arg(2);
  144.     vs_top=sup;
  145.     {object V3=base[0]->c.c_cdr;
  146.     if(endp(V3))invalid_macro_call();
  147.     base[2]= (V3->c.c_car);
  148.     V3=V3->c.c_cdr;
  149.     if(endp(V3))invalid_macro_call();
  150.     base[3]= (V3->c.c_car);
  151.     V3=V3->c.c_cdr;
  152.     if(endp(V3)){
  153.     base[4]= Cnil;
  154.     } else {
  155.     base[4]= (V3->c.c_car);
  156.     V3=V3->c.c_cdr;}
  157.     if(!endp(V3))invalid_macro_call();}
  158.     if((base[4])==Cnil){
  159.     goto T15;}
  160.     base[5]= list(2,VV[2],base[2]);
  161.     base[6]= list(3,VV[9],base[5],base[3]);
  162.     base[7]= list(2,VV[2],base[2]);
  163.     base[8]= list(4,VV[3],base[7],base[4],VV[10]);
  164.     base[9]= list(2,VV[2],base[2]);
  165.     base[10]= list(4,VV[0],base[6],base[8],base[9]);
  166.     vs_top=(vs_base=base+10)+1;
  167.     return;
  168. T15:;
  169.     base[5]= list(2,VV[2],base[2]);
  170.     base[6]= list(3,VV[9],base[5],base[3]);
  171.     base[7]= list(2,VV[2],base[2]);
  172.     base[8]= list(3,VV[0],base[6],base[7]);
  173.     vs_top=(vs_base=base+8)+1;
  174.     return;
  175. }
  176. /*    macro definition for AND    */
  177.  
  178. static L4()
  179. {    register object *base=vs_base;
  180.     register object *sup=base+VM6;
  181.     vs_reserve(VM6);
  182.     check_arg(2);
  183.     vs_top=sup;
  184.     {object V4=base[0]->c.c_cdr;
  185.     base[2]= V4;}
  186.     if(!(endp(base[2]))){
  187.     goto T18;}
  188.     base[3]= Ct;
  189.     vs_top=(vs_base=base+3)+1;
  190.     return;
  191. T18:;
  192.     base[3]= reverse(base[2]);
  193.     base[4]= cdr(base[3]);
  194.     base[5]= car(base[3]);
  195. T24:;
  196.     if(!(endp(base[4]))){
  197.     goto T25;}
  198.     vs_top=(vs_base=base+5)+1;
  199.     return;
  200. T25:;
  201.     base[6]= cdr(base[4]);
  202.     base[5]= list(3,VV[11],car(base[4]),base[5]);
  203.     base[4]= base[6];
  204.     goto T24;
  205. }
  206. /*    macro definition for OR    */
  207.  
  208. static L5()
  209. {    register object *base=vs_base;
  210.     register object *sup=base+VM7;
  211.     vs_reserve(VM7);
  212.     check_arg(2);
  213.     vs_top=sup;
  214.     {object V5=base[0]->c.c_cdr;
  215.     base[2]= V5;}
  216.     if(!(endp(base[2]))){
  217.     goto T34;}
  218.     base[3]= Cnil;
  219.     vs_top=(vs_base=base+3)+1;
  220.     return;
  221. T34:;
  222.     base[3]= reverse(base[2]);
  223.     base[4]= cdr(base[3]);
  224.     base[5]= car(base[3]);
  225. T40:;
  226.     if(!(endp(base[4]))){
  227.     goto T41;}
  228.     vs_top=(vs_base=base+5)+1;
  229.     return;
  230. T41:;
  231.     base[6]= cdr(base[4]);
  232.     vs_base=vs_top;
  233.     Lgensym();
  234.     vs_top=sup;
  235.     base[7]= vs_base[0];
  236.     base[8]= list(2,base[7],car(base[4]));
  237.     base[9]= make_cons(base[8],Cnil);
  238.     base[10]= list(4,VV[11],base[7],base[7],base[5]);
  239.     base[5]= list(3,VV[12],base[9],base[10]);
  240.     base[4]= base[6];
  241.     goto T40;
  242. }
  243. /*    macro definition for LOCALLY    */
  244.  
  245. static L6()
  246. {    register object *base=vs_base;
  247.     register object *sup=base+VM8;
  248.     vs_reserve(VM8);
  249.     check_arg(2);
  250.     vs_top=sup;
  251.     {object V6=base[0]->c.c_cdr;
  252.     base[2]= V6;}
  253.     base[3]= listA(3,VV[12],Cnil,base[2]);
  254.     vs_top=(vs_base=base+3)+1;
  255.     return;
  256. }
  257. /*    macro definition for LOOP    */
  258.  
  259. static L7()
  260. {    register object *base=vs_base;
  261.     register object *sup=base+VM9;
  262.     vs_reserve(VM9);
  263.     check_arg(2);
  264.     vs_top=sup;
  265.     {object V7=base[0]->c.c_cdr;
  266.     base[2]= V7;
  267.     vs_base=vs_top;
  268.     Lgensym();
  269.     vs_top=sup;
  270.     base[3]= vs_base[0];}
  271.     base[4]= make_cons(VV[0],base[2]);
  272.     base[5]= list(2,VV[15],base[3]);
  273.     base[6]= list(4,VV[14],base[3],base[4],base[5]);
  274.     base[7]= list(3,VV[13],Cnil,base[6]);
  275.     vs_top=(vs_base=base+7)+1;
  276.     return;
  277. }
  278. /*    macro definition for DEFMACRO    */
  279.  
  280. static L8()
  281. {    register object *base=vs_base;
  282.     register object *sup=base+VM10;
  283.     vs_reserve(VM10);
  284.     check_arg(2);
  285.     vs_top=sup;
  286.     {object V8=base[0]->c.c_cdr;
  287.     if(endp(V8))invalid_macro_call();
  288.     base[2]= (V8->c.c_car);
  289.     V8=V8->c.c_cdr;
  290.     if(endp(V8))invalid_macro_call();
  291.     base[3]= (V8->c.c_car);
  292.     V8=V8->c.c_cdr;
  293.     base[4]= V8;}
  294.     base[5]= list(2,VV[2],base[2]);
  295.     base[6]= list(2,VV[2],base[2]);
  296.     base[7]= list(2,VV[2],base[3]);
  297.     base[8]= list(2,VV[2],base[4]);
  298.     base[9]= list(4,VV[17],base[6],base[7],base[8]);
  299.     base[10]= list(3,VV[16],base[5],base[9]);
  300.     vs_top=(vs_base=base+10)+1;
  301.     return;
  302. }
  303. /*    macro definition for DEFUN    */
  304.  
  305. static L9()
  306. {    register object *base=vs_base;
  307.     register object *sup=base+VM11;
  308.     vs_reserve(VM11);
  309.     check_arg(2);
  310.     vs_top=sup;
  311.     {object V9=base[0]->c.c_cdr;
  312.     if(endp(V9))invalid_macro_call();
  313.     base[2]= (V9->c.c_car);
  314.     V9=V9->c.c_cdr;
  315.     if(endp(V9))invalid_macro_call();
  316.     base[3]= (V9->c.c_car);
  317.     V9=V9->c.c_cdr;
  318.     base[4]= V9;}
  319.     base[6]= base[4];
  320.     base[7]= Cnil;
  321.     symlispcall_no_event(VV[65],base+6,2);
  322.     Llist();
  323.     vs_top=sup;
  324.     base[5]= vs_base[0];
  325.     base[6]= car(base[5]);
  326.     base[7]= cadr(base[5]);
  327.     base[8]= caddr(base[5]);
  328.     if((base[6])==Cnil){
  329.     goto T59;}
  330.     base[9]= list(2,VV[2],base[2]);
  331.     base[10]= list(3,VV[19],base[9],VV[20]);
  332.     base[11]= list(3,VV[18],base[10],base[6]);
  333.     base[12]= list(2,VV[2],base[2]);
  334.     base[13]= list(2,VV[21],base[12]);
  335.     base[14]= listA(3,VV[13],base[2],base[8]);
  336.     base[15]= make_cons(base[14],Cnil);
  337.     base[16]= append(base[7],base[15]);
  338.     base[17]= listA(3,VV[23],base[3],base[16]);
  339.     base[18]= list(2,VV[22],base[17]);
  340.     base[19]= list(3,VV[18],base[13],base[18]);
  341.     base[20]= list(2,VV[2],base[2]);
  342.     base[21]= list(4,VV[0],base[11],base[19],base[20]);
  343.     vs_top=(vs_base=base+21)+1;
  344.     return;
  345. T59:;
  346.     base[9]= list(2,VV[2],base[2]);
  347.     base[10]= list(2,VV[21],base[9]);
  348.     base[11]= listA(3,VV[13],base[2],base[8]);
  349.     base[12]= make_cons(base[11],Cnil);
  350.     base[13]= append(base[7],base[12]);
  351.     base[14]= listA(3,VV[23],base[3],base[13]);
  352.     base[15]= list(2,VV[22],base[14]);
  353.     base[16]= list(3,VV[18],base[10],base[15]);
  354.     base[17]= list(2,VV[2],base[2]);
  355.     base[18]= list(3,VV[0],base[16],base[17]);
  356.     vs_top=(vs_base=base+18)+1;
  357.     return;
  358. }
  359. /*    macro definition for PSETQ    */
  360.  
  361. static L10()
  362. {    register object *base=vs_base;
  363.     register object *sup=base+VM12;
  364.     vs_reserve(VM12);
  365.     check_arg(2);
  366.     vs_top=sup;
  367.     {object V10=base[0]->c.c_cdr;
  368.     base[2]= V10;}
  369.     {object V11;
  370.     V11= base[2];
  371.     base[3]= Cnil;
  372.     base[4]= Cnil;
  373. T63:;
  374.     if(!(endp((V11)))){
  375.     goto T64;}
  376.     base[5]= reverse(base[4]);
  377.     base[6]= make_cons(Cnil,base[3]);
  378.     base[7]= reverse(base[6]);
  379.     base[8]= listA(3,VV[24],base[5],base[7]);
  380.     vs_top=(vs_base=base+8)+1;
  381.     return;
  382. T64:;
  383.     vs_base=vs_top;
  384.     Lgensym();
  385.     vs_top=sup;
  386.     base[5]= vs_base[0];
  387.     base[6]= list(2,base[5],cadr((V11)));
  388.     base[4]= make_cons(base[6],base[4]);
  389.     base[6]= list(3,VV[7],car((V11)),base[5]);
  390.     base[3]= make_cons(base[6],base[3]);
  391.     V11= cddr((V11));
  392.     goto T63;}
  393. }
  394. /*    macro definition for COND    */
  395.  
  396. static L11()
  397. {    register object *base=vs_base;
  398.     register object *sup=base+VM13;
  399.     vs_reserve(VM13);
  400.     check_arg(2);
  401.     vs_top=sup;
  402.     {object V12=base[0]->c.c_cdr;
  403.     base[2]= V12;
  404.     base[3]= Cnil;}
  405.     {object V13;
  406.     base[4]= reverse(base[2]);
  407.     V13= car(base[4]);
  408. T80:;
  409.     if(!(endp(base[4]))){
  410.     goto T81;}
  411.     vs_top=(vs_base=base+3)+1;
  412.     return;
  413. T81:;
  414.     if(!(endp(cdr((V13))))){
  415.     goto T87;}
  416.     if(!(car((V13))==Ct)){
  417.     goto T90;}
  418.     base[3]= Ct;
  419.     goto T85;
  420. T90:;
  421.     vs_base=vs_top;
  422.     Lgensym();
  423.     vs_top=sup;
  424.     base[5]= vs_base[0];
  425.     base[6]= list(2,base[5],car((V13)));
  426.     base[7]= make_cons(base[6],Cnil);
  427.     base[8]= list(4,VV[11],base[5],base[5],base[3]);
  428.     base[3]= list(3,VV[12],base[7],base[8]);
  429.     goto T85;
  430. T87:;
  431.     if(!(car((V13))==Ct)){
  432.     goto T96;}
  433.     if(!(endp(cddr((V13))))){
  434.     goto T100;}
  435.     base[3]= cadr((V13));
  436.     goto T98;
  437. T100:;
  438.     base[3]= make_cons(VV[0],cdr((V13)));
  439. T98:;
  440.     goto T85;
  441. T96:;
  442.     if(!(endp(cddr((V13))))){
  443.     goto T104;}
  444.     base[3]= list(4,VV[11],car((V13)),cadr((V13)),base[3]);
  445.     goto T102;
  446. T104:;
  447.     {object V14= car((V13));
  448.     base[5]= make_cons(VV[0],cdr((V13)));
  449.     base[3]= list(4,VV[11],V14,base[5],base[3]);}
  450. T102:;
  451. T85:;
  452.     base[4]= cdr(base[4]);
  453.     V13= car(base[4]);
  454.     goto T80;}
  455. }
  456. /*    macro definition for WHEN    */
  457.  
  458. static L12()
  459. {    register object *base=vs_base;
  460.     register object *sup=base+VM14;
  461.     vs_reserve(VM14);
  462.     check_arg(2);
  463.     vs_top=sup;
  464.     {object V15=base[0]->c.c_cdr;
  465.     if(endp(V15))invalid_macro_call();
  466.     base[2]= (V15->c.c_car);
  467.     V15=V15->c.c_cdr;
  468.     base[3]= V15;}
  469.     base[4]= make_cons(VV[0],base[3]);
  470.     base[5]= list(3,VV[11],base[2],base[4]);
  471.     vs_top=(vs_base=base+5)+1;
  472.     return;
  473. }
  474. /*    macro definition for UNLESS    */
  475.  
  476. static L13()
  477. {    register object *base=vs_base;
  478.     register object *sup=base+VM15;
  479.     vs_reserve(VM15);
  480.     check_arg(2);
  481.     vs_top=sup;
  482.     {object V16=base[0]->c.c_cdr;
  483.     if(endp(V16))invalid_macro_call();
  484.     base[2]= (V16->c.c_car);
  485.     V16=V16->c.c_cdr;
  486.     base[3]= V16;}
  487.     base[4]= list(2,VV[25],base[2]);
  488.     base[5]= make_cons(VV[0],base[3]);
  489.     base[6]= list(3,VV[11],base[4],base[5]);
  490.     vs_top=(vs_base=base+6)+1;
  491.     return;
  492. }
  493. /*    macro definition for PROG    */
  494.  
  495. static L14()
  496. {    register object *base=vs_base;
  497.     register object *sup=base+VM16;
  498.     vs_reserve(VM16);
  499.     check_arg(2);
  500.     vs_top=sup;
  501.     {object V17=base[0]->c.c_cdr;
  502.     if(endp(V17))invalid_macro_call();
  503.     base[2]= (V17->c.c_car);
  504.     V17=V17->c.c_cdr;
  505.     base[3]= V17;
  506.     base[4]= Cnil;}
  507. T113:;
  508.     if(endp(base[3])){
  509.     goto T115;}
  510.     if(!(type_of(car(base[3]))==t_cons)){
  511.     goto T115;}
  512.     if(caar(base[3])==VV[26]){
  513.     goto T114;}
  514. T115:;
  515.     base[5]= make_cons(VV[14],base[3]);
  516.     base[6]= make_cons(base[5],Cnil);
  517.     base[7]= append(base[4],base[6]);
  518.     base[8]= listA(3,VV[12],base[2],base[7]);
  519.     base[9]= list(3,VV[13],Cnil,base[8]);
  520.     vs_top=(vs_base=base+9)+1;
  521.     return;
  522. T114:;
  523.     base[4]= make_cons(car(base[3]),base[4]);
  524.     base[5]= car(base[3]);
  525.     base[3]= cdr(base[3]);
  526.     goto T113;
  527. }
  528. /*    macro definition for PROG*    */
  529.  
  530. static L15()
  531. {    register object *base=vs_base;
  532.     register object *sup=base+VM17;
  533.     vs_reserve(VM17);
  534.     check_arg(2);
  535.     vs_top=sup;
  536.     {object V18=base[0]->c.c_cdr;
  537.     if(endp(V18))invalid_macro_call();
  538.     base[2]= (V18->c.c_car);
  539.     V18=V18->c.c_cdr;
  540.     base[3]= V18;
  541.     base[4]= Cnil;}
  542. T132:;
  543.     if(endp(base[3])){
  544.     goto T134;}
  545.     if(!(type_of(car(base[3]))==t_cons)){
  546.     goto T134;}
  547.     if(caar(base[3])==VV[26]){
  548.     goto T133;}
  549. T134:;
  550.     base[5]= make_cons(VV[14],base[3]);
  551.     base[6]= make_cons(base[5],Cnil);
  552.     base[7]= append(base[4],base[6]);
  553.     base[8]= listA(3,VV[24],base[2],base[7]);
  554.     base[9]= list(3,VV[13],Cnil,base[8]);
  555.     vs_top=(vs_base=base+9)+1;
  556.     return;
  557. T133:;
  558.     base[4]= make_cons(car(base[3]),base[4]);
  559.     base[5]= car(base[3]);
  560.     base[3]= cdr(base[3]);
  561.     goto T132;
  562. }
  563. /*    macro definition for PROG1    */
  564.  
  565. static L16()
  566. {    register object *base=vs_base;
  567.     register object *sup=base+VM18;
  568.     vs_reserve(VM18);
  569.     check_arg(2);
  570.     vs_top=sup;
  571.     {object V19=base[0]->c.c_cdr;
  572.     if(endp(V19))invalid_macro_call();
  573.     base[2]= (V19->c.c_car);
  574.     V19=V19->c.c_cdr;
  575.     base[3]= V19;
  576.     vs_base=vs_top;
  577.     Lgensym();
  578.     vs_top=sup;
  579.     base[4]= vs_base[0];}
  580.     base[5]= list(2,base[4],base[2]);
  581.     base[6]= make_cons(base[5],Cnil);
  582.     base[7]= make_cons(base[4],Cnil);
  583.     base[8]= append(base[3],base[7]);
  584.     base[9]= listA(3,VV[12],base[6],base[8]);
  585.     vs_top=(vs_base=base+9)+1;
  586.     return;
  587. }
  588. /*    macro definition for PROG2    */
  589.  
  590. static L17()
  591. {    register object *base=vs_base;
  592.     register object *sup=base+VM19;
  593.     vs_reserve(VM19);
  594.     check_arg(2);
  595.     vs_top=sup;
  596.     {object V20=base[0]->c.c_cdr;
  597.     if(endp(V20))invalid_macro_call();
  598.     base[2]= (V20->c.c_car);
  599.     V20=V20->c.c_cdr;
  600.     if(endp(V20))invalid_macro_call();
  601.     base[3]= (V20->c.c_car);
  602.     V20=V20->c.c_cdr;
  603.     base[4]= V20;
  604.     vs_base=vs_top;
  605.     Lgensym();
  606.     vs_top=sup;
  607.     base[5]= vs_base[0];}
  608.     base[6]= list(2,base[5],base[3]);
  609.     base[7]= make_cons(base[6],Cnil);
  610.     base[8]= make_cons(base[5],Cnil);
  611.     base[9]= append(base[4],base[8]);
  612.     base[10]= listA(3,VV[12],base[7],base[9]);
  613.     base[11]= list(3,VV[0],base[2],base[10]);
  614.     vs_top=(vs_base=base+11)+1;
  615.     return;
  616. }
  617. /*    macro definition for MULTIPLE-VALUE-LIST    */
  618.  
  619. static L18()
  620. {    register object *base=vs_base;
  621.     register object *sup=base+VM20;
  622.     vs_reserve(VM20);
  623.     check_arg(2);
  624.     vs_top=sup;
  625.     {object V21=base[0]->c.c_cdr;
  626.     if(endp(V21))invalid_macro_call();
  627.     base[2]= (V21->c.c_car);
  628.     V21=V21->c.c_cdr;
  629.     if(!endp(V21))invalid_macro_call();}
  630.     base[3]= list(3,VV[27],VV[28],base[2]);
  631.     vs_top=(vs_base=base+3)+1;
  632.     return;
  633. }
  634. /*    macro definition for MULTIPLE-VALUE-SETQ    */
  635.  
  636. static L19()
  637. {    register object *base=vs_base;
  638.     register object *sup=base+VM21;
  639.     vs_reserve(VM21);
  640.     check_arg(2);
  641.     vs_top=sup;
  642.     {object V22=base[0]->c.c_cdr;
  643.     if(endp(V22))invalid_macro_call();
  644.     base[2]= (V22->c.c_car);
  645.     V22=V22->c.c_cdr;
  646.     if(endp(V22))invalid_macro_call();
  647.     base[3]= (V22->c.c_car);
  648.     V22=V22->c.c_cdr;
  649.     if(!endp(V22))invalid_macro_call();}
  650.     {object V23;
  651.     int V24;
  652.     V23= base[2];
  653.     vs_base=vs_top;
  654.     Lgensym();
  655.     vs_top=sup;
  656.     base[4]= vs_base[0];
  657.     V24= 0;
  658.     base[5]= Cnil;
  659. T155:;
  660.     if(!(endp((V23)))){
  661.     goto T156;}
  662.     base[6]= list(2,VV[30],base[3]);
  663.     base[7]= list(2,base[4],base[6]);
  664.     base[8]= make_cons(base[7],Cnil);
  665.     base[9]= listA(3,VV[12],base[8],base[5]);
  666.     vs_top=(vs_base=base+9)+1;
  667.     return;
  668. T156:;
  669.     {object V25= car((V23));
  670.     base[6]= make_fixnum(V24);
  671.     base[7]= list(3,VV[31],base[6],base[4]);
  672.     base[8]= list(3,VV[7],V25,base[7]);
  673.     base[5]= make_cons(base[8],base[5]);}
  674.     V23= cdr((V23));
  675.     V24= (V24)+1;
  676.     goto T155;}
  677. }
  678. /*    macro definition for MULTIPLE-VALUE-BIND    */
  679.  
  680. static L20()
  681. {    register object *base=vs_base;
  682.     register object *sup=base+VM22;
  683.     vs_reserve(VM22);
  684.     check_arg(2);
  685.     vs_top=sup;
  686.     {object V26=base[0]->c.c_cdr;
  687.     if(endp(V26))invalid_macro_call();
  688.     base[2]= (V26->c.c_car);
  689.     V26=V26->c.c_cdr;
  690.     if(endp(V26))invalid_macro_call();
  691.     base[3]= (V26->c.c_car);
  692.     V26=V26->c.c_cdr;
  693.     base[4]= V26;}
  694.     {object V27;
  695.     int V28;
  696.     V27= base[2];
  697.     vs_base=vs_top;
  698.     Lgensym();
  699.     vs_top=sup;
  700.     base[5]= vs_base[0];
  701.     V28= 0;
  702.     base[6]= Cnil;
  703. T170:;
  704.     if(!(endp((V27)))){
  705.     goto T171;}
  706.     base[7]= list(2,VV[30],base[3]);
  707.     base[8]= list(2,base[5],base[7]);
  708.     base[9]= reverse(base[6]);
  709.     base[10]= make_cons(base[8],base[9]);
  710.     base[11]= listA(3,VV[24],base[10],base[4]);
  711.     vs_top=(vs_base=base+11)+1;
  712.     return;
  713. T171:;
  714.     {object V29= car((V27));
  715.     base[7]= make_fixnum(V28);
  716.     base[8]= list(3,VV[31],base[7],base[5]);
  717.     base[9]= list(2,V29,base[8]);
  718.     base[6]= make_cons(base[9],base[6]);}
  719.     V27= cdr((V27));
  720.     V28= (V28)+1;
  721.     goto T170;}
  722. }
  723. /*    macro definition for DO    */
  724.  
  725. static L21()
  726. {    register object *base=vs_base;
  727.     register object *sup=base+VM23;
  728.     vs_reserve(VM23);
  729.     check_arg(2);
  730.     vs_top=sup;
  731.     {object V30=base[0]->c.c_cdr;
  732.     if(endp(V30))invalid_macro_call();
  733.     base[2]= (V30->c.c_car);
  734.     V30=V30->c.c_cdr;
  735.     if(endp(V30))invalid_macro_call();
  736.     {object V31= (V30->c.c_car);
  737.     if(endp(V31))invalid_macro_call();
  738.     base[3]= (V31->c.c_car);
  739.     V31=V31->c.c_cdr;
  740.     base[4]= V31;}
  741.     V30=V30->c.c_cdr;
  742.     base[5]= V30;
  743.     base[6]= Cnil;
  744.     vs_base=vs_top;
  745.     Lgensym();
  746.     vs_top=sup;
  747.     base[7]= vs_base[0];
  748.     base[8]= Cnil;
  749.     base[9]= Cnil;}
  750. T187:;
  751.     if(endp(base[5])){
  752.     goto T189;}
  753.     if(!(type_of(car(base[5]))==t_cons)){
  754.     goto T189;}
  755.     if(caar(base[5])==VV[26]){
  756.     goto T188;}
  757. T189:;
  758.     goto T185;
  759. T188:;
  760.     base[6]= make_cons(car(base[5]),base[6]);
  761.     base[10]= car(base[5]);
  762.     base[5]= cdr(base[5]);
  763.     goto T187;
  764. T185:;
  765.     {object V32;
  766.     base[10]= base[2];
  767.     V32= car(base[10]);
  768. T207:;
  769.     if(!(endp(base[10]))){
  770.     goto T208;}
  771.     goto T204;
  772. T208:;
  773.     base[11]= list(2,car((V32)),cadr((V32)));
  774.     base[8]= make_cons(base[11],base[8]);
  775.     if(endp(cddr((V32)))){
  776.     goto T214;}
  777.     base[9]= make_cons(car((V32)),base[9]);
  778.     base[9]= make_cons(caddr((V32)),base[9]);
  779. T214:;
  780.     base[10]= cdr(base[10]);
  781.     V32= car(base[10]);
  782.     goto T207;}
  783. T204:;
  784.     base[10]= reverse(base[8]);
  785.     base[11]= make_cons(VV[0],base[4]);
  786.     base[12]= list(2,VV[32],base[11]);
  787.     base[13]= list(3,VV[11],base[3],base[12]);
  788.     base[14]= make_cons(VV[14],base[5]);
  789.     base[15]= reverse(base[9]);
  790.     base[16]= make_cons(VV[33],base[15]);
  791.     base[17]= list(2,VV[15],base[7]);
  792.     base[18]= list(6,VV[14],base[7],base[13],base[14],base[16],base[17]);
  793.     base[19]= make_cons(base[18],Cnil);
  794.     base[20]= append(base[6],base[19]);
  795.     base[21]= listA(3,VV[12],base[10],base[20]);
  796.     base[22]= list(3,VV[13],Cnil,base[21]);
  797.     vs_top=(vs_base=base+22)+1;
  798.     return;
  799. }
  800. /*    macro definition for DO*    */
  801.  
  802. static L22()
  803. {    register object *base=vs_base;
  804.     register object *sup=base+VM24;
  805.     vs_reserve(VM24);
  806.     check_arg(2);
  807.     vs_top=sup;
  808.     {object V33=base[0]->c.c_cdr;
  809.     if(endp(V33))invalid_macro_call();
  810.     base[2]= (V33->c.c_car);
  811.     V33=V33->c.c_cdr;
  812.     if(endp(V33))invalid_macro_call();
  813.     {object V34= (V33->c.c_car);
  814.     if(endp(V34))invalid_macro_call();
  815.     base[3]= (V34->c.c_car);
  816.     V34=V34->c.c_cdr;
  817.     base[4]= V34;}
  818.     V33=V33->c.c_cdr;
  819.     base[5]= V33;
  820.     base[6]= Cnil;
  821.     vs_base=vs_top;
  822.     Lgensym();
  823.     vs_top=sup;
  824.     base[7]= vs_base[0];
  825.     base[8]= Cnil;
  826.     base[9]= Cnil;}
  827. T231:;
  828.     if(endp(base[5])){
  829.     goto T233;}
  830.     if(!(type_of(car(base[5]))==t_cons)){
  831.     goto T233;}
  832.     if(caar(base[5])==VV[26]){
  833.     goto T232;}
  834. T233:;
  835.     goto T229;
  836. T232:;
  837.     base[6]= make_cons(car(base[5]),base[6]);
  838.     base[10]= car(base[5]);
  839.     base[5]= cdr(base[5]);
  840.     goto T231;
  841. T229:;
  842.     {object V35;
  843.     base[10]= base[2];
  844.     V35= car(base[10]);
  845. T251:;
  846.     if(!(endp(base[10]))){
  847.     goto T252;}
  848.     goto T248;
  849. T252:;
  850.     base[11]= list(2,car((V35)),cadr((V35)));
  851.     base[8]= make_cons(base[11],base[8]);
  852.     if(endp(cddr((V35)))){
  853.     goto T258;}
  854.     base[9]= make_cons(car((V35)),base[9]);
  855.     base[9]= make_cons(caddr((V35)),base[9]);
  856. T258:;
  857.     base[10]= cdr(base[10]);
  858.     V35= car(base[10]);
  859.     goto T251;}
  860. T248:;
  861.     base[10]= reverse(base[8]);
  862.     base[11]= make_cons(VV[0],base[4]);
  863.     base[12]= list(2,VV[32],base[11]);
  864.     base[13]= list(3,VV[11],base[3],base[12]);
  865.     base[14]= make_cons(VV[14],base[5]);
  866.     base[15]= reverse(base[9]);
  867.     base[16]= make_cons(VV[7],base[15]);
  868.     base[17]= list(2,VV[15],base[7]);
  869.     base[18]= list(6,VV[14],base[7],base[13],base[14],base[16],base[17]);
  870.     base[19]= make_cons(base[18],Cnil);
  871.     base[20]= append(base[6],base[19]);
  872.     base[21]= listA(3,VV[24],base[10],base[20]);
  873.     base[22]= list(3,VV[13],Cnil,base[21]);
  874.     vs_top=(vs_base=base+22)+1;
  875.     return;
  876. }
  877. /*    macro definition for CASE    */
  878.  
  879. static L23()
  880. {    register object *base=vs_base;
  881.     register object *sup=base+VM25;
  882.     vs_reserve(VM25);
  883.     check_arg(2);
  884.     vs_top=sup;
  885.     {object V36=base[0]->c.c_cdr;
  886.     if(endp(V36))invalid_macro_call();
  887.     base[2]= (V36->c.c_car);
  888.     V36=V36->c.c_cdr;
  889.     base[3]= V36;
  890.     base[4]= Cnil;
  891.     vs_base=vs_top;
  892.     Lgensym();
  893.     vs_top=sup;
  894.     base[5]= vs_base[0];}
  895.     {object V37;
  896.     base[6]= reverse(base[3]);
  897.     V37= car(base[6]);
  898. T274:;
  899.     if(!(endp(base[6]))){
  900.     goto T275;}
  901.     base[7]= list(2,base[5],base[2]);
  902.     base[8]= make_cons(base[7],Cnil);
  903.     base[9]= list(3,VV[12],base[8],base[4]);
  904.     vs_top=(vs_base=base+9)+1;
  905.     return;
  906. T275:;
  907.     if(car((V37))==Ct){
  908.     goto T280;}
  909.     if(!(car((V37))==VV[34])){
  910.     goto T281;}
  911. T280:;
  912.     base[4]= make_cons(VV[0],cdr((V37)));
  913.     goto T279;
  914. T281:;
  915.     if(!(type_of(car((V37)))==t_cons)){
  916.     goto T287;}
  917.     base[7]= list(2,VV[2],car((V37)));
  918.     base[8]= list(3,VV[35],base[5],base[7]);
  919.     base[9]= make_cons(VV[0],cdr((V37)));
  920.     base[4]= list(4,VV[11],base[8],base[9],base[4]);
  921.     goto T279;
  922. T287:;
  923.     if((car((V37)))==Cnil){
  924.     goto T279;}
  925.     base[7]= list(2,VV[2],car((V37)));
  926.     base[8]= list(3,VV[36],base[5],base[7]);
  927.     base[9]= make_cons(VV[0],cdr((V37)));
  928.     base[4]= list(4,VV[11],base[8],base[9],base[4]);
  929. T279:;
  930.     base[6]= cdr(base[6]);
  931.     V37= car(base[6]);
  932.     goto T274;}
  933. }
  934. /*    macro definition for RETURN    */
  935.  
  936. static L24()
  937. {    register object *base=vs_base;
  938.     register object *sup=base+VM26;
  939.     vs_reserve(VM26);
  940.     check_arg(2);
  941.     vs_top=sup;
  942.     {object V38=base[0]->c.c_cdr;
  943.     if(endp(V38)){
  944.     base[2]= Cnil;
  945.     } else {
  946.     base[2]= (V38->c.c_car);
  947.     V38=V38->c.c_cdr;}
  948.     if(!endp(V38))invalid_macro_call();}
  949.     base[3]= list(3,VV[37],Cnil,base[2]);
  950.     vs_top=(vs_base=base+3)+1;
  951.     return;
  952. }
  953. /*    macro definition for DOLIST    */
  954.  
  955. static L25()
  956. {    register object *base=vs_base;
  957.     register object *sup=base+VM27;
  958.     vs_reserve(VM27);
  959.     check_arg(2);
  960.     vs_top=sup;
  961.     {object V39=base[0]->c.c_cdr;
  962.     if(endp(V39))invalid_macro_call();
  963.     {object V40= (V39->c.c_car);
  964.     if(endp(V40))invalid_macro_call();
  965.     base[2]= (V40->c.c_car);
  966.     V40=V40->c.c_cdr;
  967.     if(endp(V40))invalid_macro_call();
  968.     base[3]= (V40->c.c_car);
  969.     V40=V40->c.c_cdr;
  970.     if(endp(V40)){
  971.     base[4]= Cnil;
  972.     } else {
  973.     base[4]= (V40->c.c_car);
  974.     V40=V40->c.c_cdr;}
  975.     if(!endp(V40))invalid_macro_call();}
  976.     V39=V39->c.c_cdr;
  977.     base[5]= V39;
  978.     vs_base=vs_top;
  979.     Lgensym();
  980.     vs_top=sup;
  981.     base[6]= vs_base[0];}
  982.     base[7]= list(2,VV[39],base[6]);
  983.     base[8]= list(3,base[6],base[3],base[7]);
  984.     base[9]= list(2,VV[40],base[6]);
  985.     base[10]= list(2,VV[40],base[6]);
  986.     base[11]= list(3,base[2],base[9],base[10]);
  987.     base[12]= list(2,base[8],base[11]);
  988.     base[13]= list(2,VV[41],base[6]);
  989.     base[14]= list(2,base[13],base[4]);
  990.     base[15]= listA(4,VV[38],base[12],base[14],base[5]);
  991.     vs_top=(vs_base=base+15)+1;
  992.     return;
  993. }
  994. /*    macro definition for DOTIMES    */
  995.  
  996. static L26()
  997. {    register object *base=vs_base;
  998.     register object *sup=base+VM28;
  999.     vs_reserve(VM28);
  1000.     check_arg(2);
  1001.     vs_top=sup;
  1002.     {object V41=base[0]->c.c_cdr;
  1003.     if(endp(V41))invalid_macro_call();
  1004.     {object V42= (V41->c.c_car);
  1005.     if(endp(V42))invalid_macro_call();
  1006.     base[2]= (V42->c.c_car);
  1007.     V42=V42->c.c_cdr;
  1008.     if(endp(V42))invalid_macro_call();
  1009.     base[3]= (V42->c.c_car);
  1010.     V42=V42->c.c_cdr;
  1011.     if(endp(V42)){
  1012.     base[4]= Cnil;
  1013.     } else {
  1014.     base[4]= (V42->c.c_car);
  1015.     V42=V42->c.c_cdr;}
  1016.     if(!endp(V42))invalid_macro_call();}
  1017.     V41=V41->c.c_cdr;
  1018.     base[5]= V41;
  1019.     vs_base=vs_top;
  1020.     Lgensym();
  1021.     vs_top=sup;
  1022.     base[6]= vs_base[0];}
  1023.     base[7]= list(2,base[6],base[3]);
  1024.     base[8]= list(2,VV[42],base[2]);
  1025.     base[9]= list(3,base[2],VV[29],base[8]);
  1026.     base[10]= list(2,base[7],base[9]);
  1027.     base[11]= list(3,VV[43],base[2],base[6]);
  1028.     base[12]= list(2,base[11],base[4]);
  1029.     base[13]= listA(4,VV[38],base[10],base[12],base[5]);
  1030.     vs_top=(vs_base=base+13)+1;
  1031.     return;
  1032. }
  1033.