home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 018.lha / parser / y.tab.c < prev    next >
Encoding:
C/C++ Source or Header  |  1986-10-19  |  20.1 KB  |  745 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 PSEUDO 266
  11. #define UPPERCASEVAR 267
  12. #define LOWERCASEVAR 268
  13. #define COLONVAR 269
  14. #define KEYWORD 270
  15. #define LP 271
  16. #define RP 272
  17. #define LB 273
  18. #define RB 274
  19. #define PERIOD 275
  20. #define BAR 276
  21. #define MBAR 277
  22. #define SEMI 278
  23. #define UPARROW 279
  24. #define PS 280
  25. #define MINUS 281
  26. #define PE 282
  27.  
  28. #line 26 "parser.y"
  29. #include "env.h"
  30. #include "drive.h"
  31. #include "parser.h"
  32.  
  33. #line 31 "parser.y"
  34. typedef union {
  35.     struct litlist         *a;
  36.     struct blockstruct     *b;
  37.     char             *c;
  38.     struct exprstruct     *e;
  39.     int             i;
  40.     struct keylist         *k;
  41.     struct classstruct     *l;
  42.     struct methodstruct     *m;
  43.     struct objstruct     *o;
  44.     /* enum pseuvars */ int  p;
  45.     struct primlist     *r;
  46.     struct statestruct     *s;
  47.     struct litstruct     *t;
  48.     struct primstruct     *u;
  49.     } YYSTYPE;
  50.  
  51. #line 49 "parser.y"
  52. extern struct blockstruct *mkblock();
  53. extern struct classstruct *mkclass();
  54. extern struct varstruct *mkvar(), *addvlist(), *invlist();
  55. extern struct methodstruct *mkmethod();
  56. extern struct exprstruct *mkexpr(), *mkkey();
  57. extern struct keylist *mkklist();
  58. extern struct statestruct *mkstate();
  59. extern struct objstruct *mkobj();
  60. extern struct primstruct *mkprim();
  61. extern struct primlist *addprim();
  62. extern struct litstruct *mklit();
  63. extern struct litlist *addlit();
  64. extern char *bincat();
  65.  
  66. struct varstruct *instvars;
  67. struct varstruct *contextvars;
  68.  
  69. int bytetop = 0;
  70. uchar bytearray[1000];
  71.  
  72. YYSTYPE e;
  73. int errorcount = 0;
  74. #define yyclearin yychar = -1
  75. #define yyerrok yyerrflag = 0
  76. extern int yychar;
  77. extern short yyerrflag;
  78. #ifndef YYMAXDEPTH
  79. #define YYMAXDEPTH 150
  80. #endif
  81. YYSTYPE yylval, yyval;
  82. #define YYERRCODE 256
  83.  
  84. #line 348 "parser.y"
  85.  
  86. #include <stdio.h> 
  87.  
  88. char *filename;
  89. FILE *fp;
  90. FILE *ofd;
  91. FILE *fdout;    /* added WMK */
  92.  
  93. #include "lex.yy.c" 
  94.  
  95. main(argc, argv) 
  96. int argc;
  97. char **argv;
  98. {    
  99.     long status;
  100.     if (argc < 2) 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. /* added by WMK */
  108.     if (argc==3) {
  109.         ofd = fopen(argv[2],"w");
  110.         if (ofd==NULL) {
  111.             yerr("Cannot open output file %s", argv[2]);
  112.             quiter("parser quits");
  113.         }
  114.     }
  115.  
  116.     else ofd = stdout;
  117.     status = (long)yyparse();
  118.     if (argc==3) fclose(ofd);
  119.     exit(status);
  120. }
  121.  
  122. quiter(s) char *s; {
  123. /* WMK changed this--was fprintf(stderr..) */
  124.     printf("%s\n", s); exit(10);
  125. }
  126.  
  127. yywarn(s, v) char *s, *v; {
  128. /* WMK again */
  129.     printf("%s: line %d: Warning ", filename, linenum);
  130.     printf(s, v);
  131.     printf("\n");
  132. }
  133.  
  134. yyerror(s) char *s; {yerr(s, "");}
  135.  
  136. yerr(s, v) 
  137. char *s, *v; 
  138. {
  139. /* WMK changed */
  140.     printf("%s: line %d: ", filename, linenum);
  141.     printf(s, v);
  142.     printf("\n");
  143.     if (errorcount++ > 10) quiter("too many errors, goodby");
  144. }
  145.  
  146. expect(str) char *str;
  147. {    char buffer[100];
  148.  
  149.     sprintf(buffer,"Expected %%s found %s", yytext);
  150.     yerr(buffer, str);
  151. }
  152.  
  153. int yywrap() { return(1);}
  154.  
  155. char *alloc(size) int size;        /* allocate a block of storage */
  156. {  char *p, *malloc();
  157.  
  158.     p = malloc( (unsigned) size);
  159.     if (p == (char *) 0) yyerror("out of free space");
  160.     return(p);
  161. }
  162.  
  163. char *bincat(s1, s2)
  164. char *s1, *s2;
  165. {    char *p;
  166.  
  167.     p = alloc(strlen(s1) + strlen(s2) + 1);
  168.     strcpy(p, s1);
  169.     strcat(p, s2);
  170.     return(p);
  171. }
  172. short yyexca[] = {
  173.     -1, 1,
  174.     0, -1,
  175.     -2, 0,
  176.     };
  177. #define YYNPROD 119
  178. #define YYLAST 309
  179. short yyact[]={
  180.  
  181.   81,  79,  75,  76,  77, 127,  92,  25, 157, 141,
  182.  124, 123, 126, 125, 131, 156, 140, 155,  36,  26,
  183.  152,  37,  28, 130, 132,  29,  81,  79,  75,  76,
  184.   77, 127,  89,  25, 154, 149, 124, 123, 126, 125,
  185.  131, 120,  10, 119,  34,  26, 114,  40,  28, 130,
  186.  132,  29,  81,  79,  75,  76,  77,  15, 105,    9,
  187.   71,  65,  14, 116,  32,  33,  67, 146,  72, 107,
  188.  106,  35, 107,  43,  98,  78,  80, 147,  81,  79,
  189.   75,  76,  77,  15,  48,  42,  71,  65,  14,  54,
  190.   99,  84,  67,  91,  72, 143,  47, 109, 108, 102,
  191.  138,  78,  80,  81,  79,  75,  76,  77,  15,  13,
  192.    6,  71,  65,  14,  54,  15,   5,  67, 136,  72,
  193.   14,  69,  62, 101,  58,  52,  78,  80,  81,  79,
  194.   75,  76,  77,  15,  53,  60,  71,  65,  14,  54,
  195.   24,  51,  67,  93,  72,  81,  79,  75,  76,  77,
  196.   15,  78,  80,  71,  65,  14, 116,  31,  22,  67,
  197.   83,  72,  94,  17, 129,  45,  25, 142,  78,  80,
  198.   21,  20,  23,  25,  70,  41,  39,  25,  26,  95,
  199.    2,  28,   7,  27,  29,  26,  34,  90,  28,  26,
  200.   27,  29,  28,  34,  27,  29,  88,  46,  84,  44,
  201.   20,  49, 100,  96,  86,  87,  32,  33,  30,    4,
  202.   63,    8,   1,  32,  33,  12,  85,  66, 121,  64,
  203.  117, 139,  97, 122, 135, 134, 113,  50, 133,  16,
  204.  115, 112,   3, 118,  11,  19,  74, 103, 137, 144,
  205.  110,  82, 104, 111,  38,  61,  59,  57,  55,  56,
  206.   18,  73,  68, 145, 150,   0, 148,   0,   0,    0,
  207.    0,    0,   0,    0, 128,    0,   0, 122,   0,   0,
  208.  151,    0,   0, 153,   0,   0,   0,   0,   0,    0,
  209.    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,
  210.    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,
  211.    0,   0,   0,   0,   0,   0,   0,   0, 128 };
  212. short yypact[]={
  213.  
  214. -146,-146,-1000,-214,-147,-1000,-1000,-1000, -98,-1000,
  215. -1000,-212,-198,-1000,-1000,-1000,-256,-1000,-212,-223,
  216. -183,-1000,-1000,-183, -87,-1000,-1000,-1000,-1000,-1000,
  217. -1000,-172,-1000,-1000,-1000,-1000,-1000, -98,-154,-177,
  218. -183,-1000,-1000,-1000,-1000,-1000, -63,-1000,-1000,-1000,
  219. -243,-1000,-129,-1000,-170,-272,-1000,-1000, -91, -91,
  220. -194,-178,-1000,-1000,-1000,-1000,-1000,-129,-1000,-1000,
  221. -1000,-158,-211,-1000,-1000,-1000,-1000,-1000,-201,-1000,
  222. -160,-1000, -70,-1000,-1000,-1000,-1000,-1000,-1000,-154,
  223. -1000,-129,-1000,-224,-112,-112,-224,-112,-1000,-1000,
  224. -229,-231,-1000,-179,-260,-1000,-1000,-162,-1000,-1000,
  225. -1000,-1000,-1000,-1000,-112,-194,-1000, -87,-194,-1000,
  226. -1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
  227. -204,-1000,-160,-205,-239,-179,-1000,-255,-129,-1000,
  228. -1000,-1000,-240,-1000, -87,-257,-1000,-1000,-1000,-1000,
  229. -1000,-267,-1000,-1000,-1000,-1000,-1000,-1000 };
  230. short yypgo[]={
  231.  
  232.    0, 123, 252, 210, 162, 140, 251, 250, 249, 248,
  233.  124, 135, 247, 246, 245, 244, 242, 241, 237, 236,
  234.  235, 143, 234, 232, 163, 229, 122, 228, 227, 141,
  235.  134, 225, 224, 118, 221, 219, 121, 218, 217, 212,
  236.  180, 211, 209, 208, 157, 197, 196, 175, 160, 174,
  237.  167, 164 };
  238. short yyr1[]={
  239.  
  240.    0,  39,  39,  40,  41,  41,  23,  42,  42,  22,
  241.   22,  22,   3,   3,  43,  43,  45,  45,  45,  25,
  242.   25,  24,   7,    7,   7,    7,  20,  20,  47,  47,
  243.   15,  15,  44,  44,  44,  17,  17,  48,  28,  28,
  244.   46,  46,  29,  29,  30,  30,    9,   9,  12,  12,
  245.   13,  13,  14,  14,   8,   8,  21,  21,  10,  10,
  246.    4,   4,   5,   5,   5,   5,    5,  11,  11,  26,
  247.   26,  26,  26,  26,  26,  26,  38,  27,  27,   2,
  248.   18,  18,  16,  16,  31,  31,  33,  33,  34,  34,
  249.   32,  32,  35,  35,  49,  36,  36,  36,  36,  36,
  250.   36,    6,   6,  19,  19,  37,  37,  37,  37,  37,
  251.   37,  37,  37,  51,  51,   1,    1,  50,  50 };
  252. short yyr2[]={
  253.  
  254.    0,   1,   2,   4,   1,   1,   3,   1,   1,    1,
  255.    2,   1,   1,   1,   0,   3,   1,   2,   1,   1,
  256.    3,   4,   1,   2,   1,   1,   2,   3,   1,    1,
  257.    0,   3,   1,   1,   1,   1,   2,   1,   1,    3,
  258.    0,   1,   2,   1,   3,   1,   1,   1,   1,    2,
  259.    1,   3,   2,   2,   1,   2,   2,   3,   1,    3,
  260.    1,   2,   1,   1,   1,   1,   1,   1,   2,    1,
  261.    1,   1,   1,   1,   3,   1,   4,   0,   2,    4,
  262.    0,   2,   1,   2,   2,   1,   2,   1,   0,    1,
  263.    2,   3,   1,   3,   2,   1,   1,   1,   1,    1,
  264.    4,   1,   2,   1,   2,   1,   1,   1,   1,    1,
  265.    1,   1,   3,   2,   1,   0,   2,   1,   2 };
  266. short yychk[]={
  267.  
  268. -1000, -39, -40, -23, -42, 262, 256, -40, -41, 273,
  269.  256, -22,  -3, 256, 267, 262, -25, -24,  -7, -20,
  270.   -4, 268, 256, 270,  -5, 264, 276, 281, 279, 282,
  271.  -43, -44, 276, 277, 256, 269, 274, 277, -15, -44,
  272.  270, -47, 268, 256, -47,  -5, -45, 268, 256, -24,
  273.  -28, -29, 279, -30, 268,  -9,  -8, -12, -10, -13,
  274.  -11, -14, -26,  -3, -35, 266, -38, 271,  -2, -36,
  275.  -49, 265, 273,  -6, -19, 259, 260, 261, 280, 258,
  276.  281, 257, -17, -48, 268, -47, -44, 268, -46, 275,
  277.  -30, 263, 278, -21,  -4, 270, -21,  -4, 268, 268,
  278.  -30,  -1, 257, -18, -16, 269, 271, 273, 258, 257,
  279.  -44, -48, -29, -30, 270, -11, 268, -10, -11, 272,
  280.  272, -37, -36, 268, 267, 270, 269, 262,  -4, -51,
  281.  280, 271, 281, -27, -31, -32, -33, -30, 279, -34,
  282.  276, 269, -50, 257, -10,  -1, 271, 282, -26, 274,
  283.  -33, -30, 275, -30, 274, 257, 272, 275 };
  284. short yydef[]={
  285.  
  286.    0,  -2,   1,   0,   0,   7,   8,   2,   0,    4,
  287.    5,  14,   9,  11,  12,  13,   0,  19,  30,  22,
  288.    0,  24,  25,   0,  60,  62,  63,  64,  65,  66,
  289.    6,   0,  32,  33,  34,  10,   3,   0,   0,   0,
  290.    0,  23,  28,  29,  26,  61,   0,  16,  18,  20,
  291.   40,  38,   0,  43,  70,  45,  46,  47,  54,  48,
  292.   58,  50,  67,  69,  71,  72,  73,   0,  75,  92,
  293.  115,   0,  80,  95,  96,  97,  98,  99,   0, 101,
  294.    0, 103,   0,  35,  37,  27,  15,  17,  21,  41,
  295.   42,   0,  52,  55,   0,   0,  49,   0,  68,  53,
  296.    0,   0,  77,  88,   0,  82,  94,   0, 102, 104,
  297.   31,  36,  39,  44,   0,  59,  70,  56,  51,  74,
  298.   93, 116, 105, 106, 107, 108, 109, 110, 111, 115,
  299.    0, 114,  64,   0,   0,  88,  85,  89,   0,  87,
  300.   81,  83,   0, 117,  57,   0, 113,  76,  78,  79,
  301.   84,  89,  90,  86, 100, 118, 112,  91 };
  302. #ifndef lint
  303. static char yaccpar_sccsid[] = "@(#)yaccpar    4.1    (Berkeley)    2/11/83";
  304. #endif not lint
  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 = 1; /* 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 264 "parser.y"
  620. {yyval.r = NULL;} break;
  621. case 78:
  622. #line 265 "parser.y"
  623. {yyval.r = addprim(yypvt[-1].r, yypvt[-0].o);} break;
  624. case 79:
  625. #line 269 "parser.y"
  626. {yyval.b = mkblock(yypvt[-2].i, yypvt[-1].s);
  627.                     deltemps(yypvt[-2].i);} break;
  628. case 80:
  629. #line 273 "parser.y"
  630. {yyval.i = 0;} break;
  631. case 81:
  632. #line 274 "parser.y"
  633. {yyval.i = yypvt[-1].i;} break;
  634. case 82:
  635. #line 277 "parser.y"
  636. {addtemp(yypvt[-0].c, argvar); yyval.i = 1;} break;
  637. case 83:
  638. #line 278 "parser.y"
  639. {addtemp(yypvt[-0].c, argvar); yyval.i = yypvt[-1].i + 1;} break;
  640. case 84:
  641. #line 281 "parser.y"
  642. {yypvt[-0].s->nextstate = yypvt[-1].s; yyval.s = yypvt[-0].s;} break;
  643. case 85:
  644. #line 282 "parser.y"
  645. {yyval.s = yypvt[-0].s;} break;
  646. case 86:
  647. #line 285 "parser.y"
  648. {yyval.s = mkstate(blkupar, (char *) 0, yypvt[-0].s);} break;
  649. case 87:
  650. #line 286 "parser.y"
  651. {yyval.s = mkstate(upar, (char *) 0, yypvt[-0].s);} break;
  652. case 88:
  653. #line 290 "parser.y"
  654. {e.p = nilvar;
  655. yyval.s = mkstate(expr, (char *) 0,
  656. (struct statestruct *) mkexpr((struct exprstruct *) 0, reccmd, (char *) 0,
  657.     (struct exprstruct *) mkobj(pseuobj, &e)));} break;
  658. case 89:
  659. #line 294 "parser.y"
  660. {yyval.s = yypvt[-0].s;} break;
  661. case 90:
  662. #line 297 "parser.y"
  663. {yyval.s = yypvt[-1].s;} break;
  664. case 91:
  665. #line 299 "parser.y"
  666. {yypvt[-1].s->nextstate = yypvt[-2].s; yyval.s = yypvt[-1].s;} break;
  667. case 92:
  668. #line 302 "parser.y"
  669. {yyval.t = yypvt[-0].t;} break;
  670. case 93:
  671. #line 303 "parser.y"
  672. {e.a = yypvt[-1].a; yyval.t = mklit(arlit, &e);} break;
  673. case 95:
  674. #line 309 "parser.y"
  675. {e.c = yypvt[-0].c; yyval.t = mklit(fnumlit, &e);} break;
  676. case 96:
  677. #line 310 "parser.y"
  678. {e.i = yypvt[-0].i; yyval.t = mklit(numlit, &e);} break;
  679. case 97:
  680. #line 311 "parser.y"
  681. {e.i = yypvt[-0].i; yyval.t = mklit(charlit, &e);} break;
  682. case 98:
  683. #line 312 "parser.y"
  684. {e.c = yypvt[-0].c; yyval.t = mklit(strlit, &e);} break;
  685. case 99:
  686. #line 313 "parser.y"
  687. {e.c = yypvt[-0].c; yyval.t = mklit(symlit, &e);} break;
  688. case 100:
  689. #line 314 "parser.y"
  690. {bytearray[bytetop] = '\0';
  691.                                                       yyval.t = mklit(bytelit, &e);} break;
  692. case 101:
  693. #line 318 "parser.y"
  694. {yyval.c = yypvt[-0].c;} break;
  695. case 102:
  696. #line 319 "parser.y"
  697. {yyval.c = bincat("-", yypvt[-0].c);} break;
  698. case 103:
  699. #line 322 "parser.y"
  700. {yyval.i = yypvt[-0].i;} break;
  701. case 104:
  702. #line 323 "parser.y"
  703. {yyval.i = - yypvt[-0].i;} break;
  704. case 105:
  705. #line 326 "parser.y"
  706. {yyval.t = yypvt[-0].t;} break;
  707. case 106:
  708. #line 327 "parser.y"
  709. {e.c = yypvt[-0].c; yyval.t = mklit(symlit, &e);} break;
  710. case 107:
  711. #line 328 "parser.y"
  712. {e.c = yypvt[-0].c; yyval.t = mklit(symlit, &e);} break;
  713. case 108:
  714. #line 329 "parser.y"
  715. {e.c = yypvt[-0].c; yyval.t = mklit(symlit, &e);} break;
  716. case 109:
  717. #line 330 "parser.y"
  718. {e.c = yypvt[-0].c; yyval.t = mklit(symlit, &e);} break;
  719. case 110:
  720. #line 331 "parser.y"
  721. {e.c = yypvt[-0].c; yyval.t = mklit(symlit, &e);} break;
  722. case 111:
  723. #line 332 "parser.y"
  724. {e.c = yypvt[-0].c; yyval.t = mklit(symlit, &e);} break;
  725. case 112:
  726. #line 333 "parser.y"
  727. {e.a = yypvt[-1].a; yyval.t = mklit(arlit, &e);} break;
  728. case 115:
  729. #line 340 "parser.y"
  730. {yyval.a = NULL;} break;
  731. case 116:
  732. #line 341 "parser.y"
  733. {yyval.a = addlit(yypvt[-1].a, yypvt[-0].t);} break;
  734. case 117:
  735. #line 344 "parser.y"
  736. {bytetop = 0;
  737.                                                       bytearray[bytetop++] = itouc(yypvt[-0].i);} break;
  738. case 118:
  739. #line 346 "parser.y"
  740. {bytearray[bytetop++] = itouc(yypvt[-0].i);} break;
  741.         }
  742.         goto yystack;  /* stack new state and value */
  743.  
  744.     }
  745.