home *** CD-ROM | disk | FTP | other *** search
/ Really Useful CD 1 / ReallyUsefulCD1.iso / extras / languages / smalltalk / _smalltalk / parser / c / ytab < prev   
Encoding:
Text File  |  1988-01-15  |  22.0 KB  |  748 lines
  1. # define LITNUM 257
  2. # define LITFNUM 258
  3. # define LITCHAR 259
  4. # define LITSTR 260
  5. # define LITSYM 261
  6. # define CLASS 262
  7. # define ASSIGN 263
  8. # define BINARY 264
  9. # define PRIMITIVE 265
  10. # define NAMEDPRIM 266
  11. # define PSEUDO 267
  12. # define UPPERCASEVAR 268
  13. # define LOWERCASEVAR 269
  14. # define COLONVAR 270
  15. # define KEYWORD 271
  16. # define LP 272
  17. # define RP 273
  18. # define LB 274
  19. # define RB 275
  20. # define PERIOD 276
  21. # define BAR 277
  22. # define MBAR 278
  23. # define SEMI 279
  24. # define UPARROW 280
  25. # define PS 281
  26. # define MINUS 282
  27. # define PE 283
  28.  
  29. # line 26 "parser.y"
  30. # include "env.h"
  31. # include "drive.h"
  32. # include "parser.h"
  33.  
  34. # line 31 "parser.y"
  35. typedef union  {
  36.      struct litlist           *a;
  37.      struct blockstruct  *b;
  38.      char                *c;
  39.      struct exprstruct   *e;
  40.      int                  i;
  41.      struct keylist           *k;
  42.      struct classstruct  *l;
  43.      struct methodstruct      *m;
  44.      struct objstruct    *o;
  45.      enum pseuvars        p;
  46.      struct primlist     *r;
  47.      struct statestruct  *s;
  48.      struct litstruct    *t;
  49.      struct primstruct   *u;
  50.      } YYSTYPE;
  51.  
  52. # line 49 "parser.y"
  53. extern struct blockstruct *mkblock();
  54. extern struct classstruct *mkclass();
  55. extern struct varstruct *mkvar(), *addvlist(), *invlist();
  56. extern struct methodstruct *mkmethod();
  57. extern struct exprstruct *mkexpr(), *mkkey();
  58. extern struct keylist *mkklist();
  59. extern struct statestruct *mkstate();
  60. extern struct objstruct *mkobj();
  61. extern struct primstruct *mkprim();
  62. extern struct primlist *addprim();
  63. extern struct litstruct *mklit();
  64. extern struct litlist *addlit();
  65. extern char   *bincat();
  66.  
  67. struct varstruct *instvars;
  68. struct varstruct *contextvars;
  69.  
  70. int bytetop = 0;
  71. uchar bytearray[1000];
  72.  
  73. YYSTYPE e;
  74. int errorcount = 0;
  75. #define yyclearin yychar = -1
  76. #define yyerrok yyerrflag = 0
  77. extern int yychar;
  78. extern short yyerrflag;
  79. #ifndef YYMAXDEPTH
  80. #define YYMAXDEPTH 150
  81. #endif
  82. YYSTYPE yylval, yyval;
  83. # define YYERRCODE 256
  84.  
  85. # line 350 "parser.y"
  86.  
  87. # include <stdio.h>  
  88.  
  89. char *filename, *outfilename;
  90. FILE *fp;
  91. FILE *ofd;
  92.  
  93. # include "lexyy.c"
  94.  
  95. /* THis section altered to use files as parameters, not stin & stdout */
  96. main(argc, argv) 
  97. int argc;
  98. char **argv;
  99. {       
  100.         if (argc != 3) quiter("parser: wrong number of arguments");
  101.         filename = argv[1];
  102.         fp = fopen(filename, "r");
  103.         if (fp == NULL) {
  104.                 yerr("cannot open input file %s", filename);
  105.                 quiter("parser quits");
  106.                 }
  107. /* this bit added TPR */
  108.         outfilename = argv[2];
  109.         ofd = fopen(outfilename, "a");
  110.         if( ofd == NULL) {
  111.                 yerr("cannot open output file %s", outfilename);
  112.                 quiter("parser quits");
  113.                 }
  114. /*        ofd = stdout; */
  115.         return(yyparse());
  116. }
  117.  
  118. quiter(s) char *s; {fprintf(stderr,"%s\n", s); exit(1);}
  119.  
  120. yywarn(s, v) char *s, *v; {
  121.    fprintf(stderr, "%s: line %d: Warning ", filename, linenum);
  122.    fprintf(stderr, s, v);
  123.    fprintf(stderr,"\n");
  124. }
  125.  
  126. yyerror(s) char *s; {yerr(s, "");}
  127.  
  128. yerr(s, v) 
  129. char *s, *v; 
  130. {
  131.    fprintf(stderr, "%s: line %d: ", filename, linenum);
  132.    fprintf(stderr, s, v);
  133.    fprintf(stderr,"\n");
  134.    if (errorcount++ > 10) quiter("too many errors, goodby");
  135. }
  136.  
  137. expect(str) char *str;
  138. {  char buffer[100];
  139.  
  140.    sprintf(buffer,"Expected %%s found %s", yytext);
  141.    yerr(buffer, str);
  142. }
  143.  
  144. int yywrap() { return(1);}
  145.  
  146. char *alloc(size) int size;      /* allocate a block of storage */
  147. {  char *p, *malloc();
  148.  
  149.    p = malloc( (unsigned) size);
  150.    if (p == (char *) 0) yyerror("out of free space");
  151.    return(p);
  152. }
  153.  
  154. char *bincat(s1, s2)
  155. char *s1, *s2;
  156. {    char *p;
  157.  
  158.      p = alloc(strlen(s1) + strlen(s2) + 1);
  159.      strcpy(p, s1);
  160.      strcat(p, s2);
  161.      return(p);
  162. }
  163. short yyexca[] ={
  164. -1, 1,
  165.      0, -1,
  166.      -2, 0,
  167.      };
  168. # define YYNPROD 120
  169. # define YYLAST 370
  170. short yyact[]={
  171.  
  172.   82,  80,  76,  77,  78, 129,  93,  25, 160, 155,
  173.  145, 126, 125, 128, 127, 133, 159, 144, 158,  36,
  174.   26,  90,  37,  28, 132, 134,  29,  82,  80,  76,
  175.   77,  78, 129, 152,  25, 150, 157, 109, 126, 125,
  176.  128, 127, 133, 122, 121, 116,  34,  26,  40, 107,
  177.   28, 132, 134,  29,  82,  80,  76,  77,  78,  15,
  178.   43,  48,  71,  72,  65,  14, 118,  32,  33,  67,
  179.  108,  73, 109,  42,  47,  99,  10,  35,  79,  81,
  180.  151,  82,  80,  76,  77,  78,  15, 100,  85,  71,
  181.   72,  65,  14, 118,   9,  92,  67,   6,  73, 111,
  182.  110, 147, 103,   5, 140,  79,  81, 136,  82,  80,
  183.   76,  77,  78,  15, 102,  13,  71,  72,  65,  14,
  184.   54,  15,  24,  67,  69,  73,  62,  14, 104,  17,
  185.  131, 142,  79,  81,  82,  80,  76,  77,  78,  15,
  186.   60,  53,  71,  72,  65,  14,  54,  45,  58,  67,
  187.   51,  73,   2, 146,   7,  70,  84,  52,  79,  81,
  188.   82,  80,  76,  77,  78,  15,  89,  49,  71,  72,
  189.   65,  14,  54,  94,  46,  67,  30,  73,  82,  80,
  190.   76,  77,  78,  15,  79,  81,  71,  72,  65,  14,
  191.  118,  22,  25,  67,  91,  73,  63,   4,   8,  25,
  192.   34,  12,  79,  81,  21,  26,  23,  25,  28, 101,
  193.   27,  29,  26,  85,  96,  28,  34,  27,  29,  95,
  194.   26,  32,  33,  28,  31,  27,  29, 124,  20,  88,
  195.    1, 137, 135,  97, 115,  41, 117,  32,  33, 120,
  196.  113, 114,  66,  39, 153, 119, 149, 141, 123,  64,
  197.  143, 139, 138,  50,  16,   3,  11,  20,  19,  44,
  198.   75, 105, 137,  83, 106, 148,  38,  61,  59,  57,
  199.   55,  87,  56,  18, 124,  74,  86,  68,   0,  98,
  200.    0, 154,   0,   0, 156,   0,   0,   0,   0,   0,
  201.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  202.    0,   0,   0,   0,   0,   0,   0,   0, 112,   0,
  203.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  204.    0,   0, 130,   0,   0,   0,   0,   0,   0,   0,
  205.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  206.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  207.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  208.    0,   0,   0,   0,   0,   0,   0,   0,   0, 130 };
  209. short yypact[]={
  210.  
  211. -159,-159,-1000,-180,-141,-1000,-1000,-1000, -65,-1000,
  212. -1000,-210,-193,-1000,-1000,-1000,-256,-1000,-210,-223,
  213. -196,-1000,-1000,-196, -72,-1000,-1000,-1000,-1000,-1000,
  214. -1000,-195,-1000,-1000,-1000,-1000,-1000, -65,-123,-181,
  215. -196,-1000,-1000,-1000,-1000,-1000, -40,-1000,-1000,-1000,
  216. -255,-1000, -97,-1000,-168,-273,-1000,-1000, -57, -57,
  217. -194,-182,-1000,-1000,-1000,-1000,-1000, -97,-1000,-1000,
  218. -1000,-155,-1000,-221,-1000,-1000,-1000,-1000,-1000,-202,
  219. -1000,-158,-1000, -56,-1000,-1000,-1000,-1000,-1000,-1000,
  220. -123,-1000, -97,-1000,-226, -79, -79,-226, -79,-1000,
  221. -1000,-229,-230,-1000,-176,-149,-260,-1000,-1000,-156,
  222. -1000,-1000,-1000,-1000,-1000,-1000, -79,-194,-1000, -72,
  223. -194,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
  224. -1000,-1000,-237,-1000,-158,-203,-1000,-1000,-242,-149,
  225. -1000,-267, -97,-1000,-1000,-1000,-239,-1000, -72,-257,
  226. -1000,-1000,-1000,-1000,-268,-1000,-1000,-1000,-1000,-1000,
  227. -1000 };
  228. short yypgo[]={
  229.  
  230.    0, 114, 277, 196, 219, 122, 275, 273, 272, 270,
  231.  148, 140, 269, 268, 267, 266, 264, 263, 261, 260,
  232.  258, 173, 256, 255, 129, 254, 126, 128, 253, 150,
  233.  141, 252, 251, 104, 250, 249, 124, 248, 242, 230,
  234.  152, 198, 197, 176, 224, 174, 166, 235, 156, 155,
  235.  153, 130 };
  236. short yyr1[]={
  237.  
  238.    0,  39,  39,  40,  41,  41,  23,  42,  42,  22,
  239.   22,  22,   3,   3,  43,  43,  45,  45,  45,  25,
  240.   25,  24,   7,   7,   7,   7,  20,  20,  47,  47,
  241.   15,  15,  44,  44,  44,  17,  17,  48,  28,  28,
  242.   46,  46,  29,  29,  30,  30,   9,   9,  12,  12,
  243.   13,  13,  14,  14,   8,   8,  21,  21,  10,  10,
  244.    4,   4,   5,   5,   5,   5,   5,  11,  11,  26,
  245.   26,  26,  26,  26,  26,  26,  38,  38,  27,  27,
  246.    2,  18,  18,  16,  16,  31,  31,  33,  33,  34,
  247.   34,  32,  32,  35,  35,  49,  36,  36,  36,  36,
  248.   36,  36,   6,   6,  19,  19,  37,  37,  37,  37,
  249.   37,  37,  37,  37,  51,  51,   1,   1,  50,  50 };
  250. short yyr2[]={
  251.  
  252.    0,   1,   2,   4,   1,   1,   3,   1,   1,   1,
  253.    2,   1,   1,   1,   0,   3,   1,   2,   1,   1,
  254.    3,   4,   1,   2,   1,   1,   2,   3,   1,   1,
  255.    0,   3,   1,   1,   1,   1,   2,   1,   1,   3,
  256.    0,   1,   2,   1,   3,   1,   1,   1,   1,   2,
  257.    1,   3,   2,   2,   1,   2,   2,   3,   1,   3,
  258.    1,   2,   1,   1,   1,   1,   1,   1,   2,   1,
  259.    1,   1,   1,   1,   3,   1,   4,   3,   0,   2,
  260.    4,   0,   2,   1,   2,   2,   1,   2,   1,   0,
  261.    1,   2,   3,   1,   3,   2,   1,   1,   1,   1,
  262.    1,   4,   1,   2,   1,   2,   1,   1,   1,   1,
  263.    1,   1,   1,   3,   2,   1,   0,   2,   1,   2 };
  264. short yychk[]={
  265.  
  266. -1000, -39, -40, -23, -42, 262, 256, -40, -41, 274,
  267.  256, -22,  -3, 256, 268, 262, -25, -24,  -7, -20,
  268.   -4, 269, 256, 271,  -5, 264, 277, 282, 280, 283,
  269.  -43, -44, 277, 278, 256, 270, 275, 278, -15, -44,
  270.  271, -47, 269, 256, -47,  -5, -45, 269, 256, -24,
  271.  -28, -29, 280, -30, 269,  -9,  -8, -12, -10, -13,
  272.  -11, -14, -26,  -3, -35, 267, -38, 272,  -2, -36,
  273.  -49, 265, 266, 274,  -6, -19, 259, 260, 261, 281,
  274.  258, 282, 257, -17, -48, 269, -47, -44, 269, -46,
  275.  276, -30, 263, 279, -21,  -4, 271, -21,  -4, 269,
  276.  269, -30,  -1, 257, -27, -18, -16, 270, 272, 274,
  277.  258, 257, -44, -48, -29, -30, 271, -11, 269, -10,
  278.  -11, 273, 273, -37, -36, 269, 268, 271, 270, 262,
  279.   -4, -51, 281, 272, 282, -27, 283, -26, -31, -32,
  280.  -33, -30, 280, -34, 277, 270, -50, 257, -10,  -1,
  281.  272, 283, 275, -33, -30, 276, -30, 275, 257, 273,
  282.  276 };
  283. short yydef[]={
  284.  
  285.    0,  -2,   1,   0,   0,   7,   8,   2,   0,   4,
  286.    5,  14,   9,  11,  12,  13,   0,  19,  30,  22,
  287.    0,  24,  25,   0,  60,  62,  63,  64,  65,  66,
  288.    6,   0,  32,  33,  34,  10,   3,   0,   0,   0,
  289.    0,  23,  28,  29,  26,  61,   0,  16,  18,  20,
  290.   40,  38,   0,  43,  70,  45,  46,  47,  54,  48,
  291.   58,  50,  67,  69,  71,  72,  73,   0,  75,  93,
  292.  116,   0,  78,  81,  96,  97,  98,  99, 100,   0,
  293.  102,   0, 104,   0,  35,  37,  27,  15,  17,  21,
  294.   41,  42,   0,  52,  55,   0,   0,  49,   0,  68,
  295.   53,   0,   0,  78,   0,  89,   0,  83,  95,   0,
  296.  103, 105,  31,  36,  39,  44,   0,  59,  70,  56,
  297.   51,  74,  94, 117, 106, 107, 108, 109, 110, 111,
  298.  112, 116,   0, 115,  64,   0,  77,  79,   0,  89,
  299.   86,  90,   0,  88,  82,  84,   0, 118,  57,   0,
  300.  114,  76,  80,  85,  90,  91,  87, 101, 119, 113,
  301.   92 };
  302. #ifndef lint
  303. static char yaccpar_sccsid[] = "@(#)yaccpar  4.1  (Berkeley)     2/11/83";
  304. #endif 
  305.  
  306. #
  307. # define YYFLAG -1000
  308. # define YYERROR goto yyerrlab
  309. # define YYACCEPT return(0)
  310. # define YYABORT return(1)
  311.  
  312. /*   parser for yacc output   */
  313.  
  314. #ifdef YYDEBUG
  315. int yydebug = 0; /* 1 for debugging */
  316. #endif
  317. YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
  318. int yychar = -1; /* current input token number */
  319. int yynerrs = 0;  /* number of errors */
  320. short yyerrflag = 0;  /* error recovery flag */
  321.  
  322. yyparse() {
  323.  
  324.      short yys[YYMAXDEPTH];
  325.      short yyj, yym;
  326.      register YYSTYPE *yypvt;
  327.      register short yystate, *yyps, yyn;
  328.      register YYSTYPE *yypv;
  329.      register short *yyxi;
  330.  
  331.      yystate = 0;
  332.      yychar = -1;
  333.      yynerrs = 0;
  334.      yyerrflag = 0;
  335.      yyps= &yys[-1];
  336.      yypv= &yyv[-1];
  337.  
  338.  yystack:    /* put a state and value onto the stack */
  339.  
  340. #ifdef YYDEBUG
  341.      if( yydebug  ) printf( "state %d, char 0%o\n", yystate, yychar );
  342. #endif
  343.           if( ++yyps> &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); }
  344.           *yyps = yystate;
  345.           ++yypv;
  346.           *yypv = yyval;
  347.  
  348.  yynewstate:
  349.  
  350.      yyn = yypact[yystate];
  351.  
  352.      if( yyn<= YYFLAG ) goto yydefault; /* simple state */
  353.  
  354.      if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
  355.      if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
  356.  
  357.      if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
  358.           yychar = -1;
  359.           yyval = yylval;
  360.           yystate = yyn;
  361.           if( yyerrflag > 0 ) --yyerrflag;
  362.           goto yystack;
  363.           }
  364.  
  365.  yydefault:
  366.      /* default state action */
  367.  
  368.      if( (yyn=yydef[yystate]) == -2 ) {
  369.           if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
  370.           /* look through exception table */
  371.  
  372.           for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
  373.  
  374.           while( *(yyxi+=2) >= 0 ){
  375.                if( *yyxi == yychar ) break;
  376.                }
  377.           if( (yyn = yyxi[1]) < 0 ) return(0);   /* accept */
  378.           }
  379.  
  380.      if( yyn == 0 ){ /* error */
  381.           /* error ... attempt to resume parsing */
  382.  
  383.           switch( yyerrflag ){
  384.  
  385.           case 0:   /* brand new error */
  386.  
  387.                yyerror( "syntax error" );
  388.           yyerrlab:
  389.                ++yynerrs;
  390.  
  391.           case 1:
  392.           case 2: /* incompletely recovered error ... try again */
  393.  
  394.                yyerrflag = 3;
  395.  
  396.                /* find a state where "error" is a legal shift action */
  397.  
  398.                while ( yyps >= yys ) {
  399.                   yyn = yypact[*yyps] + YYERRCODE;
  400.                   if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
  401.                      yystate = yyact[yyn];  /* simulate a shift of "error" */
  402.                      goto yystack;
  403.                      }
  404.                   yyn = yypact[*yyps];
  405.  
  406.                   /* the current yyps has no shift onn "error", pop stack */
  407.  
  408. #ifdef YYDEBUG
  409.                   if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
  410. #endif
  411.                   --yyps;
  412.                   --yypv;
  413.                   }
  414.  
  415.                /* there is no state on the stack with an error shift ... abort */
  416.  
  417.      yyabort:
  418.                return(1);
  419.  
  420.  
  421.           case 3:  /* no shift yet; clobber input char */
  422.  
  423. #ifdef YYDEBUG
  424.                if( yydebug ) printf( "error recovery discards char %d\n", yychar );
  425. #endif
  426.  
  427.                if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
  428.                yychar = -1;
  429.                goto yynewstate;   /* try again in the same state */
  430.  
  431.                }
  432.  
  433.           }
  434.  
  435.      /* reduction by production yyn */
  436.  
  437. #ifdef YYDEBUG
  438.           if( yydebug ) printf("reduce %d\n",yyn);
  439. #endif
  440.           yyps -= yyr2[yyn];
  441.           yypvt = yypv;
  442.           yypv -= yyr2[yyn];
  443.           yyval = yypv[1];
  444.           yym=yyn;
  445.                /* consult goto table to find next state */
  446.           yyn = yyr1[yyn];
  447.           yyj = yypgo[yyn] + *yyps + 1;
  448.           if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
  449.           switch(yym){
  450.                
  451. case 3:
  452. # line 103 "parser.y"
  453. {if (errorcount == 0) genclass(yypvt[-3].l, yypvt[-1].m);} break;
  454. case 5:
  455. # line 107 "parser.y"
  456. {if ((yytext[0] == ':') ||
  457.                              isalpha(yytext[0])) expect(":SuperClass");
  458.                          else expect("open brace [");} break;
  459. case 6:
  460. # line 112 "parser.y"
  461. {yyval.l = yypvt[-1].l;} break;
  462. case 8:
  463. # line 116 "parser.y"
  464. {expect("keyword Class");} break;
  465. case 9:
  466. # line 119 "parser.y"
  467. {yyval.l = mkclass(yypvt[-0].c, (char *) 0);} break;
  468. case 10:
  469. # line 120 "parser.y"
  470. {yyval.l = mkclass(yypvt[-1].c, yypvt[-0].c);} break;
  471. case 11:
  472. # line 121 "parser.y"
  473. {expect("Classname :Superclass");
  474.                                          yyval.l = mkclass("Error", (char *) 0);} break;
  475. case 16:
  476. # line 133 "parser.y"
  477. {addinst(yypvt[-0].c);} break;
  478. case 17:
  479. # line 134 "parser.y"
  480. {addinst(yypvt[-0].c);} break;
  481. case 18:
  482. # line 135 "parser.y"
  483. {expect("instance variable");} break;
  484. case 20:
  485. # line 140 "parser.y"
  486. {yypvt[-0].m->nextmethod = yypvt[-2].m; yyval.m = yypvt[-0].m;} break;
  487. case 21:
  488. # line 144 "parser.y"
  489. {deltemps(yypvt[-2].i); yyval.m = mkmethod(yypvt[-3].e, yypvt[-2].i, yypvt[-1].s);} break;
  490. case 22:
  491. # line 148 "parser.y"
  492. {yyval.e = mkkey((struct exprstruct *) 0, yypvt[-0].k);} break;
  493. case 23:
  494. # line 150 "parser.y"
  495. {yyval.e = mkexpr((struct exprstruct *) 0, bincmd, yypvt[-1].c, (struct exprstruct *) 0);} break;
  496. case 24:
  497. # line 152 "parser.y"
  498. {yyval.e = mkexpr((struct exprstruct *) 0, uncmd, yypvt[-0].c, (struct exprstruct *) 0);} break;
  499. case 25:
  500. # line 153 "parser.y"
  501. {expect("method pattern");
  502. yyval.e = mkexpr((struct exprstruct *) 0, uncmd, "", (struct exprstruct *) 0);} break;
  503. case 26:
  504. # line 158 "parser.y"
  505. {yyval.k = mkklist((struct keylist *) 0, yypvt[-1].c, (struct exprstruct *) 0);} break;
  506. case 27:
  507. # line 160 "parser.y"
  508. {yyval.k = mkklist(yypvt[-2].k, yypvt[-1].c, (struct exprstruct *) 0);} break;
  509. case 28:
  510. # line 163 "parser.y"
  511. {addtemp(yypvt[-0].c, argvar);} break;
  512. case 29:
  513. # line 164 "parser.y"
  514. {expect("argument variable");} break;
  515. case 30:
  516. # line 167 "parser.y"
  517. {yyval.i = 0;} break;
  518. case 31:
  519. # line 168 "parser.y"
  520. {yyval.i = yypvt[-1].i;} break;
  521. case 34:
  522. # line 173 "parser.y"
  523. {expect("| (vertical bar)");} break;
  524. case 35:
  525. # line 176 "parser.y"
  526. {yyval.i = 1;} break;
  527. case 36:
  528. # line 177 "parser.y"
  529. {yyval.i = yypvt[-1].i + 1;} break;
  530. case 37:
  531. # line 180 "parser.y"
  532. {addtemp(yypvt[-0].c, tempvar);} break;
  533. case 38:
  534. # line 183 "parser.y"
  535. {yyval.s = yypvt[-0].s;} break;
  536. case 39:
  537. # line 184 "parser.y"
  538. {yypvt[-0].s->nextstate = yypvt[-2].s; yyval.s = yypvt[-0].s;} break;
  539. case 42:
  540. # line 191 "parser.y"
  541. {yyval.s = mkstate(upar, (char *) 0, yypvt[-0].s);} break;
  542. case 44:
  543. # line 196 "parser.y"
  544. {yyval.s = mkstate(asgn, yypvt[-2].c, yypvt[-0].s);} break;
  545. case 45:
  546. # line 198 "parser.y"
  547. {yyval.s = mkstate(expr, (char *) 0, (struct statestruct *) yypvt[-0].e);} break;
  548. case 47:
  549. # line 202 "parser.y"
  550. {yyval.e = mkexpr(yypvt[-0].e, semiend, 0, 0);} break;
  551. case 49:
  552. # line 206 "parser.y"
  553. {yyval.e = mkkey(yypvt[-1].e, yypvt[-0].k);} break;
  554. case 51:
  555. # line 211 "parser.y"
  556. {yyval.e = mkexpr(yypvt[-2].e, bincmd, yypvt[-1].c, yypvt[-0].e);} break;
  557. case 52:
  558. # line 214 "parser.y"
  559. {yyval.e = mkexpr(yypvt[-1].e, semistart, 0, 0);} break;
  560. case 53:
  561. # line 216 "parser.y"
  562. {yyval.e = mkexpr(yypvt[-1].e, uncmd, yypvt[-0].c, (struct exprstruct *) 0);} break;
  563. case 54:
  564. # line 219 "parser.y"
  565. {yyval.e = yypvt[-0].e;} break;
  566. case 55:
  567. # line 220 "parser.y"
  568. {yyval.e = mkkey(yypvt[-1].e, yypvt[-0].k);} break;
  569. case 56:
  570. # line 224 "parser.y"
  571. {yyval.k = mkklist((struct keylist *) 0, yypvt[-1].c, yypvt[-0].e);} break;
  572. case 57:
  573. # line 226 "parser.y"
  574. {yyval.k = mkklist(yypvt[-2].k, yypvt[-1].c, yypvt[-0].e);} break;
  575. case 58:
  576. # line 229 "parser.y"
  577. {yyval.e = yypvt[-0].e;} break;
  578. case 59:
  579. # line 230 "parser.y"
  580. {yyval.e = mkexpr(yypvt[-2].e, bincmd, yypvt[-1].c, yypvt[-0].e);} break;
  581. case 60:
  582. # line 233 "parser.y"
  583. {yyval.c = yypvt[-0].c;} break;
  584. case 61:
  585. # line 234 "parser.y"
  586. {yyval.c = bincat(yypvt[-1].c, yypvt[-0].c);} break;
  587. case 67:
  588. # line 245 "parser.y"
  589. {yyval.e = mkexpr((struct exprstruct *) 0, reccmd, (char *) 0, 
  590.                          (struct exprstruct *) yypvt[-0].o);} break;
  591. case 68:
  592. # line 248 "parser.y"
  593. {yyval.e = mkexpr(yypvt[-1].e, uncmd, yypvt[-0].c, (struct exprstruct *) 0);} break;
  594. case 69:
  595. # line 251 "parser.y"
  596. {e.c = yypvt[-0].c; yyval.o = mkobj(classobj, &e);} break;
  597. case 70:
  598. # line 252 "parser.y"
  599. {e.c = yypvt[-0].c; yyval.o = mkobj(varobj, &e);} break;
  600. case 71:
  601. # line 253 "parser.y"
  602. {e.t = yypvt[-0].t; yyval.o = mkobj(litobj, &e);} break;
  603. case 72:
  604. # line 254 "parser.y"
  605. {e.p = yypvt[-0].p; yyval.o = mkobj(pseuobj, &e);} break;
  606. case 73:
  607. # line 255 "parser.y"
  608. {e.u = yypvt[-0].u; yyval.o = mkobj(primobj, &e);} break;
  609. case 74:
  610. # line 256 "parser.y"
  611. {e.s = yypvt[-1].s; yyval.o = mkobj(exprobj, &e);} break;
  612. case 75:
  613. # line 257 "parser.y"
  614. {e.b = yypvt[-0].b; yyval.o = mkobj(blockobj, &e);} break;
  615. case 76:
  616. # line 261 "parser.y"
  617. {yyval.u = mkprim(yypvt[-2].i, yypvt[-1].r);} break;
  618. case 77:
  619. # line 263 "parser.y"
  620. {yyval.u = mkprim(yypvt[-2].i, yypvt[-1].r);} break;
  621. case 78:
  622. # line 266 "parser.y"
  623. {yyval.r = (struct primlist *) 0;} break;
  624. case 79:
  625. # line 267 "parser.y"
  626. {yyval.r = addprim(yypvt[-1].r, yypvt[-0].o);} break;
  627. case 80:
  628. # line 271 "parser.y"
  629. {yyval.b = mkblock(yypvt[-2].i, yypvt[-1].s);
  630.                          deltemps(yypvt[-2].i);} break;
  631. case 81:
  632. # line 275 "parser.y"
  633. {yyval.i = 0;} break;
  634. case 82:
  635. # line 276 "parser.y"
  636. {yyval.i = yypvt[-1].i;} break;
  637. case 83:
  638. # line 279 "parser.y"
  639. {addtemp(yypvt[-0].c, argvar); yyval.i = 1;} break;
  640. case 84:
  641. # line 280 "parser.y"
  642. {addtemp(yypvt[-0].c, argvar); yyval.i = yypvt[-1].i + 1;} break;
  643. case 85:
  644. # line 283 "parser.y"
  645. {yypvt[-0].s->nextstate = yypvt[-1].s; yyval.s = yypvt[-0].s;} break;
  646. case 86:
  647. # line 284 "parser.y"
  648. {yyval.s = yypvt[-0].s;} break;
  649. case 87:
  650. # line 287 "parser.y"
  651. {yyval.s = mkstate(blkupar, (char *) 0, yypvt[-0].s);} break;
  652. case 88:
  653. # line 288 "parser.y"
  654. {yyval.s = mkstate(upar, (char *) 0, yypvt[-0].s);} break;
  655. case 89:
  656. # line 292 "parser.y"
  657. {e.p = nilvar;
  658. yyval.s = mkstate(expr, (char *) 0,
  659. (struct statestruct *) mkexpr((struct exprstruct *) 0, reccmd, (char *) 0,
  660.      (struct exprstruct *) mkobj(pseuobj, &e)));} break;
  661. case 90:
  662. # line 296 "parser.y"
  663. {yyval.s = yypvt[-0].s;} break;
  664. case 91:
  665. # line 299 "parser.y"
  666. {yyval.s = yypvt[-1].s;} break;
  667. case 92:
  668. # line 301 "parser.y"
  669. {yypvt[-1].s->nextstate = yypvt[-2].s; yyval.s = yypvt[-1].s;} break;
  670. case 93:
  671. # line 304 "parser.y"
  672. {yyval.t = yypvt[-0].t;} break;
  673. case 94:
  674. # line 305 "parser.y"
  675. {e.a = yypvt[-1].a; yyval.t = mklit(arlit, &e);} break;
  676. case 96:
  677. # line 311 "parser.y"
  678. {e.c = yypvt[-0].c; yyval.t = mklit(fnumlit, &e);} break;
  679. case 97:
  680. # line 312 "parser.y"
  681. {e.i = yypvt[-0].i; yyval.t = mklit(numlit, &e);} break;
  682. case 98:
  683. # line 313 "parser.y"
  684. {e.i = yypvt[-0].i; yyval.t = mklit(charlit, &e);} break;
  685. case 99:
  686. # line 314 "parser.y"
  687. {e.c = yypvt[-0].c; yyval.t = mklit(strlit, &e);} break;
  688. case 100:
  689. # line 315 "parser.y"
  690. {e.c = yypvt[-0].c; yyval.t = mklit(symlit, &e);} break;
  691. case 101:
  692. # line 316 "parser.y"
  693. {bytearray[bytetop] = '\0';
  694.                                          yyval.t = mklit(bytelit, &e);} break;
  695. case 102:
  696. # line 320 "parser.y"
  697. {yyval.c = yypvt[-0].c;} break;
  698. case 103:
  699. # line 321 "parser.y"
  700. {yyval.c = bincat("-", yypvt[-0].c);} break;
  701. case 104:
  702. # line 324 "parser.y"
  703. {yyval.i = yypvt[-0].i;} break;
  704. case 105:
  705. # line 325 "parser.y"
  706. {yyval.i = - yypvt[-0].i;} break;
  707. case 106:
  708. # line 328 "parser.y"
  709. {yyval.t = yypvt[-0].t;} break;
  710. case 107:
  711. # line 329 "parser.y"
  712. {e.c = yypvt[-0].c; yyval.t = mklit(symlit, &e);} break;
  713. case 108:
  714. # line 330 "parser.y"
  715. {e.c = yypvt[-0].c; yyval.t = mklit(symlit, &e);} break;
  716. case 109:
  717. # line 331 "parser.y"
  718. {e.c = yypvt[-0].c; yyval.t = mklit(symlit, &e);} break;
  719. case 110:
  720. # line 332 "parser.y"
  721. {e.c = yypvt[-0].c; yyval.t = mklit(symlit, &e);} break;
  722. case 111:
  723. # line 333 "parser.y"
  724. {e.c = yypvt[-0].c; yyval.t = mklit(symlit, &e);} break;
  725. case 112:
  726. # line 334 "parser.y"
  727. {e.c = yypvt[-0].c; yyval.t = mklit(symlit, &e);} break;
  728. case 113:
  729. # line 335 "parser.y"
  730. {e.a = yypvt[-1].a; yyval.t = mklit(arlit, &e);} break;
  731. case 116:
  732. # line 342 "parser.y"
  733. {yyval.a = (struct litlist *) 0;} break;
  734. case 117:
  735. # line 343 "parser.y"
  736. {yyval.a = addlit(yypvt[-1].a, yypvt[-0].t);} break;
  737. case 118:
  738. # line 346 "parser.y"
  739. {bytetop = 0;
  740.                                          bytearray[bytetop++] = itouc(yypvt[-0].i);} break;
  741. case 119:
  742. # line 348 "parser.y"
  743. {bytearray[bytetop++] = itouc(yypvt[-0].i);} break;
  744.           }
  745.           goto yystack;  /* stack new state and value */
  746.  
  747.      }
  748.