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