home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 2: PC / frozenfish_august_1995.bin / bbs / d01xx / d0167.lha / CDecl / cdgram.c < prev    next >
C/C++ Source or Header  |  1988-11-22  |  36KB  |  1,075 lines
  1.  
  2. /* Yacc grammar for ANSI and C++ cdecl. */
  3. /* The output of this file is included */
  4. /* into the C file cdecl.c. */
  5. char cdgramsccsid[] = "@(#)cdgram.y    2.2 3/30/88";
  6.  
  7. typedef union  {
  8.     char *dynstr;
  9.     struct {
  10.         char *left;
  11.         char *right;
  12.         char *type;
  13.     } halves;
  14. } YYSTYPE;
  15. # define ARRAY 257
  16. # define AS 258
  17. # define CAST 259
  18. # define COMMA 260
  19. # define DECLARE 261
  20. # define DOUBLECOLON 262
  21. # define EXPLAIN 263
  22. # define FUNCTION 264
  23. # define HELP 265
  24. # define INTO 266
  25. # define OF 267
  26. # define MEMBER 268
  27. # define POINTER 269
  28. # define REFERENCE 270
  29. # define RETURNING 271
  30. # define SET 272
  31. # define TO 273
  32. # define CHAR 274
  33. # define CLASS 275
  34. # define CONSTVOLATILE 276
  35. # define DOUBLE 277
  36. # define ENUM 278
  37. # define FLOAT 279
  38. # define INT 280
  39. # define LONG 281
  40. # define NAME 282
  41. # define NUMBER 283
  42. # define SHORT 284
  43. # define SIGNED 285
  44. # define STRUCT 286
  45. # define UNION 287
  46. # define UNSIGNED 288
  47. # define VOID 289
  48. # define AUTO 290
  49. # define EXTERN 291
  50. # define REGISTER 292
  51. # define STATIC 293
  52. #define yyclearin yychar = -1
  53. #define yyerrok yyerrflag = 0
  54. extern int yychar;
  55. extern short yyerrflag;
  56. #ifndef YYMAXDEPTH
  57. #define YYMAXDEPTH 150
  58. #endif
  59. YYSTYPE yylval, yyval;
  60. # define YYERRCODE 256
  61.  
  62.  
  63. short yyexca[] ={
  64. -1, 1,
  65.     0, -1,
  66.     -2, 0,
  67. -1, 27,
  68.     282, 81,
  69.     40, 81,
  70.     42, 81,
  71.     38, 81,
  72.     -2, 87,
  73. -1, 37,
  74.     260, 31,
  75.     41, 31,
  76.     -2, 81,
  77. -1, 87,
  78.     282, 82,
  79.     40, 82,
  80.     42, 82,
  81.     38, 82,
  82.     -2, 80,
  83. -1, 92,
  84.     260, 31,
  85.     41, 31,
  86.     -2, 81,
  87.     };
  88. # define YYNPROD 89
  89. # define YYLAST 322
  90. short yyact[]={
  91.  
  92.   67,  79,  28,  69,  72,  68,  66,  76, 159,  13,
  93.   77,  75,  78,  73,  74,  70,  79,  16,  17,  18,
  94.   19,  16,  17,  18,  19,  67, 129,  78,  69, 103,
  95.   68,  66, 125,  25,  76,  39,  23,  77,  75, 128,
  96.   70,  74, 118,  22, 115, 137, 117, 118,  85, 115,
  97.   86, 117,  83,  23, 152,  25,  30, 100,  23,  10,
  98.   22,  56,  25,  23,  47,  22,  60,  59,  37,  97,
  99.   22, 121,  25,  40,  41, 123,  58,  25,  20,  34,
  100.  139, 110,  25, 161, 144,  93, 145,  92,  94,  32,
  101.   24,  57, 147,  71, 126,  29,  81,  21,  42,  55,
  102.    8, 136, 108, 150,  12, 135,  33, 106,  11, 114,
  103.   31,  10,  62, 151, 132, 134,  44,  45,  48,  49,
  104.  156,  43,  35,   2,  63,  15,  53,   1,  54,  14,
  105.   50,  64,  27,  65,  52, 101,  26,  46,  87,  82,
  106.   61,  38,   0,  90,  80,  88,   0,   0,  89,   0,
  107.   95,  96,  98, 108,  91, 108,   0,   0, 108,   0,
  108.   11,   0,  51,   0,   0,   0,   0,   0,   0,   0,
  109.    0,   0,   0,   0, 109,   0, 111, 104, 102,   0,
  110.    0,   0, 105, 112, 107,   0, 122,  99,   0, 113,
  111.    0, 119, 120,   0,   0,   0,   0, 127,   0,   0,
  112.    0,   0,   0,   0,   0, 124, 131,   0, 133,   0,
  113.    0,   0,   0, 142,   0,   0, 130, 143,   0,   0,
  114.    0,   0,   0,   0,   0, 138, 146, 140, 141, 148,
  115.    0, 149,   0,   0,   0,   0, 127,   0,   0,   0,
  116.  153,   0,   0,  25, 158,   0,   0, 127,   0, 128,
  117.  155, 160,  16,  17,  18,  19, 154,   0,   0,   0,
  118.    0, 157,   0,   0,   0,   0,   0,  25,   0,   0,
  119.    0,   0,   0, 128,   0,   0,   0,   0,   0,   0,
  120.    0,   0,   0,   0,   0,   0, 116,   0,   0,   0,
  121.    0, 116,  84,   0,   0,   0,   0,   0,   0,  36,
  122.    0,   0, 145, 145,  92,   9,   0,   0,   5,   0,
  123.    4,   0,   6,   0,   3,   0,   0,   0,   0,   0,
  124.    0,   7 };
  125. short yypact[]={
  126.  
  127. -1000,  49,-1000, 101,-273,-204, -38,-226,-1000, 101,
  128. -1000,-1000,-1000,-169,-194,-1000,-1000,-1000,-1000,-1000,
  129. -187, 101,  28,-248,-196,-214,-212,-214,-214, 101,
  130. -1000,-1000,-269, 101,-194,-1000,-194,-221,-191,-1000,
  131. -206,-207,-1000,-274,-1000,-1000,  10,-214,  10,-1000,
  132. -1000,-194,-1000, 101,-1000,  44,-170,-1000,-194,-199,
  133. -194,-1000,-249,-1000,-225,-247,-1000,-1000,-1000,-1000,
  134. -1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
  135.   10, 101,  67,-214,-181,-214,  10,-1000, 101,   9,
  136.  101,-1000,-221,-200,-194,-1000,-1000,-192,-1000,-1000,
  137. -1000,-1000,-1000,-1000, 101,-1000,  -9,-1000, -67,  10,
  138.   72,  10,  74,-1000,  64,   4,-182,   9,   9,-1000,
  139. -173,-194,-1000,-259,-1000,-1000,  43,-1000,-1000,-1000,
  140.   -1,-1000,  10,-1000,-1000,-226,-1000,-1000,  62,  71,
  141.   11,  11,-1000,-228,-1000,-243,   9,-1000,-1000, 101,
  142.   80,   9,-194,-174,  11,-1000, -33,  11,-1000,-1000,
  143.   42,-1000 };
  144. short yypgo[]={
  145.  
  146.    0,  99, 141, 140, 109,  94,  96, 139, 101, 137,
  147.   93, 112, 135, 133,  90,  95, 129, 125, 131, 124,
  148.   98,  91, 127, 123, 100, 121 };
  149. short yyr1[]={
  150.  
  151.    0,  22,  22,  23,  23,  23,  23,  23,  23,  23,
  152.   23,  23,  23,  23,  23,  24,  24,  15,  15,   6,
  153.    6,   6,   6,   7,   7,   7,   7,   7,   5,   5,
  154.    5,   1,   1,   1,   1,   1,   4,   4,   4,   4,
  155.    4,   4,   4,   4,   4,   8,   8,  21,  21,  21,
  156.   21,  21,  21,  21,   2,   2,  20,  25,   3,   3,
  157.    3,   3,  18,  18,  18,  10,  10,  19,  19,  19,
  158.   19,  19,  11,  11,  12,  12,  13,  13,  13,  13,
  159.   14,  14,   9,  17,  17,  17,  17,  16,  16 };
  160. short yyr2[]={
  161.  
  162.    0,   0,   2,   2,   6,   4,   5,   3,   6,   5,
  163.    5,   8,   3,   1,   2,   1,   1,   1,   0,   1,
  164.    3,   4,   3,   3,   4,   2,   3,   1,   3,   3,
  165.    1,   0,   3,   1,   1,   3,   0,   2,   5,   6,
  166.    3,   4,   2,   2,   2,   2,   3,   3,   6,   4,
  167.    4,   8,   4,   2,   0,   1,   2,   0,   1,   1,
  168.    2,   2,   1,   1,   1,   1,   1,   1,   1,   1,
  169.    1,   1,   2,   1,   1,   1,   1,   1,   1,   1,
  170.    2,   0,   2,   1,   1,   1,   1,   1,   0 };
  171. short yychk[]={
  172.  
  173. -1000, -22, -23, 265, 261, 259, 263, 272, -24, 256,
  174.   10,  59, -24, 282, -16, -17, 290, 291, 292, 293,
  175.  282, -21, 264, 257, -14, 276, -16, -17,  40, -15,
  176.  282, -24, 258, -21, 266, -24, 271,  40,  -2, 283,
  177.  269, 270, -20, -25, -14, -14,  -9, 276, -14, -14,
  178.  -24, -16, -24, -21, -21,  -1, 282, -21, 267, 273,
  179.  273,  -3, -11, -19, -18, -13, 280, 274, 279, 277,
  180.  289, -10, 278, 287, 288, 285, 281, 284, 286, 275,
  181.  -20,  -6,  -7,  42, 282,  38,  40, -14,  -6, -20,
  182.  -21, -24, 260,  41, 258, -21, -21, 268, -21, -19,
  183.  282, -12, -11, 276,  -6, -24,  40,  -8,  91, -14,
  184.  262, -14,  -6, -24,  -4,  40, 282,  42,  38, -24,
  185.   -1, 271, -21, 267, -24,  41,  -5, -14, 282,  93,
  186.  283,  -6,  42,  -6,  41,  41,  -8,  41,  -4, 262,
  187.   -4,  -4, -21, -10,  41, 260, -20,  93,  -6, -15,
  188.   41,  42, 282,  -5,  -4, -24,  40,  -4, -21,  41,
  189.   -5,  41 };
  190. short yydef[]={
  191.  
  192.    1,  -2,   2,   0,  88,  81,  88,  18,  13,   0,
  193.   15,  16,   3,   0,  81,  87,  83,  84,  85,  86,
  194.    0,   0,   0,  54,  57,  81,  81,  -2,  81,   0,
  195.   17,  14,  88,   0,  81,   7,  81,  -2,   0,  55,
  196.    0,   0,  53,   0,  80,  57,   0,  81,   0,  57,
  197.   12,  81,   5,   0,  47,   0,  33,  34,  81,  81,
  198.   81,  56,  58,  59,   0,  73,  67,  68,  69,  70,
  199.   71,  62,  63,  64,  76,  77,  78,  79,  65,  66,
  200.    0,   0,  19,  81,  27,  81,   0,  -2,   0,  36,
  201.    0,   6,  -2,   0,  81,  49,  50,   0,  52,  60,
  202.   61,  72,  74,  75,   0,  10,  81,  25,   0,   0,
  203.    0,   0,   0,   9,   0,  36,   0,  36,  36,   4,
  204.   32,  81,  35,   0,   8,  23,   0,  57,  30,  45,
  205.    0,  20,   0,  22,  26,  18,  44,  37,   0,   0,
  206.   42,  43,  48,   0,  24,  81,  36,  46,  21,   0,
  207.   40,  36,  81,  28,  29,  11,  81,  41,  51,  38,
  208.    0,  39 };
  209. #ifndef lint
  210. static    char yaccpar_sccsid[] = "@(#)yaccpar 1.2 86/07/18 SMI"; /* from UCB 4.1 83/02/11 */
  211. #endif
  212.  
  213. #
  214. # define YYFLAG -1000
  215. # define YYERROR goto yyerrlab
  216. # define YYACCEPT return(0)
  217. # define YYABORT return(1)
  218.  
  219. /*    parser for yacc output    */
  220.  
  221. #ifdef YYDEBUG
  222. int yydebug = 0; /* 1 for debugging */
  223. #endif
  224. YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
  225. int yychar = -1; /* current input token number */
  226. int yynerrs = 0;  /* number of errors */
  227. short yyerrflag = 0;  /* error recovery flag */
  228.  
  229. yyparse() {
  230.  
  231.     short yys[YYMAXDEPTH];
  232.     short yyj, yym;
  233.     register YYSTYPE *yypvt;
  234.     register short yystate, *yyps, yyn;
  235.     register YYSTYPE *yypv;
  236.     register short *yyxi;
  237.  
  238.     yystate = 0;
  239.     yychar = -1;
  240.     yynerrs = 0;
  241.     yyerrflag = 0;
  242.     yyps= &yys[-1];
  243.     yypv= &yyv[-1];
  244.  
  245.  yystack:    /* put a state and value onto the stack */
  246.  
  247. #ifdef YYDEBUG
  248.     if( yydebug  ) printf( "state %d, char 0%o\n", yystate, yychar );
  249. #endif
  250.         if( ++yyps>= &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); }
  251.         *yyps = yystate;
  252.         ++yypv;
  253.         *yypv = yyval;
  254.  
  255.  yynewstate:
  256.  
  257.     yyn = yypact[yystate];
  258.  
  259.     if( yyn<= YYFLAG ) goto yydefault; /* simple state */
  260.  
  261.     if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
  262.     if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
  263.  
  264.     if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
  265.         yychar = -1;
  266.         yyval = yylval;
  267.         yystate = yyn;
  268.         if( yyerrflag > 0 ) --yyerrflag;
  269.         goto yystack;
  270.         }
  271.  
  272.  yydefault:
  273.     /* default state action */
  274.  
  275.     if( (yyn=yydef[yystate]) == -2 ) {
  276.         if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
  277.         /* look through exception table */
  278.  
  279.         for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
  280.  
  281.         while( *(yyxi+=2) >= 0 ){
  282.             if( *yyxi == yychar ) break;
  283.             }
  284.         if( (yyn = yyxi[1]) < 0 ) return(0);   /* accept */
  285.         }
  286.  
  287.     if( yyn == 0 ){ /* error */
  288.         /* error ... attempt to resume parsing */
  289.  
  290.         switch( yyerrflag ){
  291.  
  292.         case 0:   /* brand new error */
  293.  
  294.             yyerror( "syntax error" );
  295.         yyerrlab:
  296.             ++yynerrs;
  297.  
  298.         case 1:
  299.         case 2: /* incompletely recovered error ... try again */
  300.  
  301.             yyerrflag = 3;
  302.  
  303.             /* find a state where "error" is a legal shift action */
  304.  
  305.             while ( yyps >= yys ) {
  306.                yyn = yypact[*yyps] + YYERRCODE;
  307.                if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
  308.                   yystate = yyact[yyn];  /* simulate a shift of "error" */
  309.                   goto yystack;
  310.                   }
  311.                yyn = yypact[*yyps];
  312.  
  313.                /* the current yyps has no shift onn "error", pop stack */
  314.  
  315. #ifdef YYDEBUG
  316.                if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
  317. #endif
  318.                --yyps;
  319.                --yypv;
  320.                }
  321.  
  322.             /* there is no state on the stack with an error shift ... abort */
  323.  
  324.     yyabort:
  325.             return(1);
  326.  
  327.  
  328.         case 3:  /* no shift yet; clobber input char */
  329.  
  330. #ifdef YYDEBUG
  331.             if( yydebug ) printf( "error recovery discards char %d\n", yychar );
  332. #endif
  333.  
  334.             if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
  335.             yychar = -1;
  336.             goto yynewstate;   /* try again in the same state */
  337.  
  338.             }
  339.  
  340.         }
  341.  
  342.     /* reduction by production yyn */
  343.  
  344. #ifdef YYDEBUG
  345.         if( yydebug ) printf("reduce %d\n",yyn);
  346. #endif
  347.         yyps -= yyr2[yyn];
  348.         yypvt = yypv;
  349.         yypv -= yyr2[yyn];
  350.         yyval = yypv[1];
  351.         yym=yyn;
  352.             /* consult goto table to find next state */
  353.         yyn = yyr1[yyn];
  354.         yyj = yypgo[yyn] + *yyps + 1;
  355.         if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
  356.         switch(yym){
  357.             
  358. case 2:
  359. {
  360.             prompt();
  361.             prev = 0;
  362.             } break;
  363. case 3:
  364. {
  365.             Debug((stderr, "stmt: help\n"));
  366.             dohelp();
  367.             } break;
  368. case 4:
  369. {
  370.             Debug((stderr, "stmt: DECLARE NAME AS opt_storage adecl\n"));
  371.             Debug((stderr, "\tNAME='%s'\n", yypvt[-4].dynstr));
  372.             Debug((stderr, "\topt_storage='%s'\n", yypvt[-2].dynstr));
  373.             Debug((stderr, "\tacdecl.left='%s'\n", yypvt[-1].halves.left));
  374.             Debug((stderr, "\tacdecl.right='%s'\n", yypvt[-1].halves.right));
  375.             Debug((stderr, "\tacdecl.type='%s'\n", yypvt[-1].halves.type));
  376.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  377.             dodeclare(yypvt[-4].dynstr, yypvt[-2].dynstr, yypvt[-1].halves.left, yypvt[-1].halves.right, yypvt[-1].halves.type);
  378.             } break;
  379. case 5:
  380. {
  381.             Debug((stderr, "stmt: DECLARE opt_storage adecl\n"));
  382.             Debug((stderr, "\topt_storage='%s'\n", yypvt[-2].dynstr));
  383.             Debug((stderr, "\tacdecl.left='%s'\n", yypvt[-1].halves.left));
  384.             Debug((stderr, "\tacdecl.right='%s'\n", yypvt[-1].halves.right));
  385.             Debug((stderr, "\tacdecl.type='%s'\n", yypvt[-1].halves.type));
  386.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  387.             dodeclare(NullCP, yypvt[-2].dynstr, yypvt[-1].halves.left, yypvt[-1].halves.right, yypvt[-1].halves.type);
  388.             } break;
  389. case 6:
  390. {
  391.             Debug((stderr, "stmt: CAST NAME AS adecl\n"));
  392.             Debug((stderr, "\tNAME='%s'\n", yypvt[-3].dynstr));
  393.             Debug((stderr, "\tacdecl.left='%s'\n", yypvt[-1].halves.left));
  394.             Debug((stderr, "\tacdecl.right='%s'\n", yypvt[-1].halves.right));
  395.             Debug((stderr, "\tacdecl.type='%s'\n", yypvt[-1].halves.type));
  396.             docast(yypvt[-3].dynstr, yypvt[-1].halves.left, yypvt[-1].halves.right, yypvt[-1].halves.type);
  397.             } break;
  398. case 7:
  399. {
  400.             Debug((stderr, "stmt: CAST adecl\n"));
  401.             Debug((stderr, "\tacdecl.left='%s'\n", yypvt[-1].halves.left));
  402.             Debug((stderr, "\tacdecl.right='%s'\n", yypvt[-1].halves.right));
  403.             Debug((stderr, "\tacdecl.type='%s'\n", yypvt[-1].halves.type));
  404.             docast(NullCP, yypvt[-1].halves.left, yypvt[-1].halves.right, yypvt[-1].halves.type);
  405.             } break;
  406. case 8:
  407. {
  408.             Debug((stderr, "stmt: EXPLAIN opt_storage opt_constvol_list type cdecl\n"));
  409.             Debug((stderr, "\topt_storage='%s'\n", yypvt[-4].dynstr));
  410.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-3].dynstr));
  411.             Debug((stderr, "\ttype='%s'\n", yypvt[-2].dynstr));
  412.             Debug((stderr, "\tcdecl='%s'\n", yypvt[-1].dynstr));
  413.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  414.             dodexplain(yypvt[-4].dynstr, yypvt[-3].dynstr, yypvt[-2].dynstr, yypvt[-1].dynstr);
  415.             } break;
  416. case 9:
  417. {
  418.             Debug((stderr, "stmt: EXPLAIN storage opt_constvol_list cdecl\n"));
  419.             Debug((stderr, "\tstorage='%s'\n", yypvt[-3].dynstr));
  420.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-2].dynstr));
  421.             Debug((stderr, "\tcdecl='%s'\n", yypvt[-1].dynstr));
  422.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  423.             dodexplain(yypvt[-3].dynstr, yypvt[-2].dynstr, NullCP, yypvt[-1].dynstr);
  424.             } break;
  425. case 10:
  426. {
  427.             Debug((stderr, "stmt: EXPLAIN opt_storage constvol_list cdecl\n"));
  428.             Debug((stderr, "\topt_storage='%s'\n", yypvt[-3].dynstr));
  429.             Debug((stderr, "\tconstvol_list='%s'\n", yypvt[-2].dynstr));
  430.             Debug((stderr, "\tcdecl='%s'\n", yypvt[-1].dynstr));
  431.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  432.             dodexplain(yypvt[-3].dynstr, yypvt[-2].dynstr, NullCP, yypvt[-1].dynstr);
  433.             } break;
  434. case 11:
  435. {
  436.             Debug((stderr, "stmt: EXPLAIN ( opt_constvol_list type cast ) optNAME\n"));
  437.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-5].dynstr));
  438.             Debug((stderr, "\ttype='%s'\n", yypvt[-4].dynstr));
  439.             Debug((stderr, "\tcast='%s'\n", yypvt[-3].dynstr));
  440.             Debug((stderr, "\tNAME='%s'\n", yypvt[-1].dynstr));
  441.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  442.             docexplain(yypvt[-5].dynstr, yypvt[-4].dynstr, yypvt[-3].dynstr, yypvt[-1].dynstr);
  443.             } break;
  444. case 12:
  445. {
  446.             Debug((stderr, "stmt: SET optNAME\n"));
  447.             Debug((stderr, "\toptNAME='%s'\n", yypvt[-1].dynstr));
  448.             doset(yypvt[-1].dynstr);
  449.             } break;
  450. case 14:
  451. {
  452.             yyerrok;
  453.             } break;
  454. case 15:
  455. {
  456.             doprompt();
  457.             } break;
  458. case 16:
  459. {
  460.             noprompt();
  461.             } break;
  462. case 17:
  463. {
  464.             Debug((stderr, "optNAME: NAME\n"));
  465.             Debug((stderr, "\tNAME='%s'\n", yypvt[-0].dynstr));
  466.             yyval.dynstr = yypvt[-0].dynstr;
  467.             } break;
  468. case 18:
  469. {
  470.             Debug((stderr, "optNAME: EMPTY\n"));
  471.             yyval.dynstr = ds(unknown_name);
  472.             } break;
  473. case 20:
  474. {
  475.             Debug((stderr, "cdecl: * opt_constvol_list cdecl\n"));
  476.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-1].dynstr));
  477.             Debug((stderr, "\tcdecl='%s'\n", yypvt[-0].dynstr));
  478.             yyval.dynstr = cat(yypvt[-0].dynstr,yypvt[-1].dynstr,ds(strlen(yypvt[-1].dynstr)?" pointer to ":"pointer to "),NullCP);
  479.             prev = 'p';
  480.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  481.             } break;
  482. case 21:
  483. {
  484.             Debug((stderr, "cdecl: NAME DOUBLECOLON '*' cdecl\n"));
  485.             Debug((stderr, "\tNAME='%s'\n", yypvt[-3].dynstr));
  486.             Debug((stderr, "\tcdecl='%s'\n", yypvt[-0].dynstr));
  487.             if (!CplusplusFlag)
  488.                 unsupp("pointer to member of class", NullCP);
  489.             yyval.dynstr = cat(yypvt[-0].dynstr,ds("pointer to member of class "),yypvt[-3].dynstr,ds(" "),NullCP);
  490.             prev = 'p';
  491.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  492.             } break;
  493. case 22:
  494. {
  495.             Debug((stderr, "cdecl: & opt_constvol_list cdecl\n"));
  496.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-1].dynstr));
  497.             Debug((stderr, "\tcdecl='%s'\n", yypvt[-0].dynstr));
  498.             if (!CplusplusFlag)
  499.                 unsupp("reference", NullCP);
  500.             yyval.dynstr = cat(yypvt[-0].dynstr,yypvt[-1].dynstr,ds(strlen(yypvt[-1].dynstr)?" reference to ":"reference to "),NullCP);
  501.             prev = 'r';
  502.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  503.             } break;
  504. case 23:
  505. {
  506.             Debug((stderr, "cdecl1: cdecl1()\n"));
  507.             Debug((stderr, "\tcdecl1='%s'\n", yypvt[-2].dynstr));
  508.             yyval.dynstr = cat(yypvt[-2].dynstr,ds("function returning "),NullCP);
  509.             prev = 'f';
  510.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  511.             } break;
  512. case 24:
  513. {
  514.             Debug((stderr, "cdecl1: cdecl1(castlist)\n"));
  515.             Debug((stderr, "\tcdecl1='%s'\n", yypvt[-3].dynstr));
  516.             Debug((stderr, "\tcastlist='%s'\n", yypvt[-1].dynstr));
  517.             yyval.dynstr = cat(yypvt[-3].dynstr, ds("function ("),
  518.                   yypvt[-1].dynstr, ds(") returning "), NullCP);
  519.             prev = 'f';
  520.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  521.             } break;
  522. case 25:
  523. {
  524.             Debug((stderr, "cdecl1: cdecl1 cdims\n"));
  525.             Debug((stderr, "\tcdecl1='%s'\n", yypvt[-1].dynstr));
  526.             Debug((stderr, "\tcdims='%s'\n", yypvt[-0].dynstr));
  527.             yyval.dynstr = cat(yypvt[-1].dynstr,ds("array "),yypvt[-0].dynstr,NullCP);
  528.             prev = 'a';
  529.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  530.             } break;
  531. case 26:
  532. {
  533.             Debug((stderr, "cdecl1: (cdecl)\n"));
  534.             Debug((stderr, "\tcdecl='%s'\n", yypvt[-1].dynstr));
  535.             yyval.dynstr = yypvt[-1].dynstr;
  536.             /* prev = prev; */
  537.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  538.             } break;
  539. case 27:
  540. {
  541.             Debug((stderr, "cdecl1: NAME\n"));
  542.             Debug((stderr, "\tNAME='%s'\n", yypvt[-0].dynstr));
  543.             savedname = yypvt[-0].dynstr;
  544.             yyval.dynstr = ds("");
  545.             prev = 'n';
  546.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  547.             } break;
  548. case 28:
  549. {
  550.             Debug((stderr, "castlist: castlist1, castlist2\n"));
  551.             Debug((stderr, "\tcastlist1='%s'\n", yypvt[-2].dynstr));
  552.             Debug((stderr, "\tcastlist2='%s'\n", yypvt[-0].dynstr));
  553.             yyval.dynstr = cat(yypvt[-2].dynstr, ds(", "), yypvt[-0].dynstr, NullCP);
  554.             } break;
  555. case 29:
  556. {
  557.             Debug((stderr, "castlist: opt_constvol_list type cast\n"));
  558.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-2].dynstr));
  559.             Debug((stderr, "\ttype='%s'\n", yypvt[-1].dynstr));
  560.             Debug((stderr, "\tcast='%s'\n", yypvt[-0].dynstr));
  561.             yyval.dynstr = cat(yypvt[-0].dynstr, yypvt[-2].dynstr, ds(strlen(yypvt[-2].dynstr) ? " " : ""), yypvt[-1].dynstr, NullCP);
  562.             } break;
  563. case 30:
  564. {
  565.             yyval.dynstr = yypvt[-0].dynstr;
  566.             } break;
  567. case 31:
  568. {
  569.             Debug((stderr, "adecllist: EMPTY\n"));
  570.             yyval.dynstr = ds("");
  571.             } break;
  572. case 32:
  573. {
  574.             Debug((stderr, "adecllist: adecllist1, adecllist2\n"));
  575.             Debug((stderr, "\tadecllist1='%s'\n", yypvt[-2].dynstr));
  576.             Debug((stderr, "\tadecllist2='%s'\n", yypvt[-0].dynstr));
  577.             yyval.dynstr = cat(yypvt[-2].dynstr, ds(", "), yypvt[-0].dynstr, NullCP);
  578.             } break;
  579. case 33:
  580. {
  581.             Debug((stderr, "adecllist: NAME\n"));
  582.             Debug((stderr, "\tNAME='%s'\n", yypvt[-0].dynstr));
  583.             yyval.dynstr = yypvt[-0].dynstr;
  584.             } break;
  585. case 34:
  586. {
  587.             Debug((stderr, "adecllist: adecl\n"));
  588.             Debug((stderr, "\tadecl.left='%s'\n", yypvt[-0].halves.left));
  589.             Debug((stderr, "\tadecl.right='%s'\n", yypvt[-0].halves.right));
  590.             Debug((stderr, "\tadecl.type='%s'\n", yypvt[-0].halves.type));
  591.             yyval.dynstr = cat(yypvt[-0].halves.type, ds(" "), yypvt[-0].halves.left, yypvt[-0].halves.right, NullCP);
  592.             } break;
  593. case 35:
  594. {
  595.             Debug((stderr, "adecllist: NAME AS adecl\n"));
  596.             Debug((stderr, "\tNAME='%s'\n", yypvt[-2].dynstr));
  597.             Debug((stderr, "\tadecl.left='%s'\n", yypvt[-0].halves.left));
  598.             Debug((stderr, "\tadecl.right='%s'\n", yypvt[-0].halves.right));
  599.             Debug((stderr, "\tadecl.type='%s'\n", yypvt[-0].halves.type));
  600.             yyval.dynstr = cat(yypvt[-0].halves.type, ds(" "), yypvt[-0].halves.left, yypvt[-2].dynstr, yypvt[-0].halves.right, NullCP);
  601.             } break;
  602. case 36:
  603. {
  604.             Debug((stderr, "cast: EMPTY\n"));
  605.             yyval.dynstr = ds("");
  606.             /* prev = prev; */
  607.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  608.             } break;
  609. case 37:
  610. {
  611.             Debug((stderr, "cast: ()\n"));
  612.             yyval.dynstr = ds("function returning ");
  613.             prev = 'f';
  614.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  615.             } break;
  616. case 38:
  617. {
  618.             Debug((stderr, "cast: (cast)()\n"));
  619.             Debug((stderr, "\tcast='%s'\n", yypvt[-3].dynstr));
  620.             yyval.dynstr = cat(yypvt[-3].dynstr,ds("function returning "),NullCP);
  621.             prev = 'f';
  622.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  623.             } break;
  624. case 39:
  625. {
  626.             Debug((stderr, "cast: (cast)(castlist)\n"));
  627.             Debug((stderr, "\tcast='%s'\n", yypvt[-4].dynstr));
  628.             Debug((stderr, "\tcastlist='%s'\n", yypvt[-1].dynstr));
  629.             yyval.dynstr = cat(yypvt[-4].dynstr,ds("function ("),yypvt[-1].dynstr,ds(") returning "),NullCP);
  630.             prev = 'f';
  631.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  632.             } break;
  633. case 40:
  634. {
  635.             Debug((stderr, "cast: (cast)\n"));
  636.             Debug((stderr, "\tcast='%s'\n", yypvt[-1].dynstr));
  637.             yyval.dynstr = yypvt[-1].dynstr;
  638.             /* prev = prev; */
  639.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  640.             } break;
  641. case 41:
  642. {
  643.             Debug((stderr, "cast: NAME::*cast\n"));
  644.             Debug((stderr, "\tcast='%s'\n", yypvt[-0].dynstr));
  645.             if (!CplusplusFlag)
  646.                 unsupp("pointer to member of class", NullCP);
  647.             yyval.dynstr = cat(yypvt[-0].dynstr,ds("pointer to member of class "),yypvt[-3].dynstr,ds(" "),NullCP);
  648.             prev = 'p';
  649.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  650.             } break;
  651. case 42:
  652. {
  653.             Debug((stderr, "cast: *cast\n"));
  654.             Debug((stderr, "\tcast='%s'\n", yypvt[-0].dynstr));
  655.             yyval.dynstr = cat(yypvt[-0].dynstr,ds("pointer to "),NullCP);
  656.             prev = 'p';
  657.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  658.             } break;
  659. case 43:
  660. {
  661.             Debug((stderr, "cast: &cast\n"));
  662.             Debug((stderr, "\tcast='%s'\n", yypvt[-0].dynstr));
  663.             if (!CplusplusFlag)
  664.                 unsupp("reference", NullCP);
  665.             yyval.dynstr = cat(yypvt[-0].dynstr,ds("reference to "),NullCP);
  666.             prev = 'r';
  667.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  668.             } break;
  669. case 44:
  670. {
  671.             Debug((stderr, "cast: cast cdims\n"));
  672.             Debug((stderr, "\tcast='%s'\n", yypvt[-1].dynstr));
  673.             Debug((stderr, "\tcdims='%s'\n", yypvt[-0].dynstr));
  674.             yyval.dynstr = cat(yypvt[-1].dynstr,ds("array "),yypvt[-0].dynstr,NullCP);
  675.             prev = 'a';
  676.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  677.             } break;
  678. case 45:
  679. {
  680.             Debug((stderr, "cdims: []\n"));
  681.             yyval.dynstr = ds("of ");
  682.             } break;
  683. case 46:
  684. {
  685.             Debug((stderr, "cdims: [NUMBER]\n"));
  686.             Debug((stderr, "\tNUMBER='%s'\n", yypvt[-1].dynstr));
  687.             yyval.dynstr = cat(yypvt[-1].dynstr,ds(" of "),NullCP);
  688.             } break;
  689. case 47:
  690. {
  691.             Debug((stderr, "adecl: FUNCTION RETURNING adecl\n"));
  692.             Debug((stderr, "\tadecl.left='%s'\n", yypvt[-0].halves.left));
  693.             Debug((stderr, "\tadecl.right='%s'\n", yypvt[-0].halves.right));
  694.             Debug((stderr, "\tadecl.type='%s'\n", yypvt[-0].halves.type));
  695.             if (prev == 'f')
  696.                 unsupp("Function returning function",
  697.                        "function returning pointer to function");
  698.             else if (prev=='A' || prev=='a')
  699.                 unsupp("Function returning array",
  700.                        "function returning pointer");
  701.             yyval.halves.left = yypvt[-0].halves.left;
  702.             yyval.halves.right = cat(ds("()"),yypvt[-0].halves.right,NullCP);
  703.             yyval.halves.type = yypvt[-0].halves.type;
  704.             prev = 'f';
  705.             Debug((stderr, "\n\tadecl now =\n"));
  706.             Debug((stderr, "\t\tadecl.left='%s'\n", yyval.halves.left));
  707.             Debug((stderr, "\t\tadecl.right='%s'\n", yyval.halves.right));
  708.             Debug((stderr, "\t\tadecl.type='%s'\n", yyval.halves.type));
  709.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  710.             } break;
  711. case 48:
  712. {
  713.             Debug((stderr, "adecl: FUNCTION (adecllist) RETURNING adecl\n"));
  714.             Debug((stderr, "\tadecllist='%s'\n", yypvt[-3].dynstr));
  715.             Debug((stderr, "\tadecl.left='%s'\n", yypvt[-0].halves.left));
  716.             Debug((stderr, "\tadecl.right='%s'\n", yypvt[-0].halves.right));
  717.             Debug((stderr, "\tadecl.type='%s'\n", yypvt[-0].halves.type));
  718.             if (prev == 'f')
  719.                 unsupp("Function returning function",
  720.                        "function returning pointer to function");
  721.             else if (prev=='A' || prev=='a')
  722.                 unsupp("Function returning array",
  723.                        "function returning pointer");
  724.             yyval.halves.left = yypvt[-0].halves.left;
  725.             yyval.halves.right = cat(ds("("),yypvt[-3].dynstr,ds(")"),yypvt[-0].halves.right,NullCP);
  726.             yyval.halves.type = yypvt[-0].halves.type;
  727.             prev = 'f';
  728.             Debug((stderr, "\n\tadecl now =\n"));
  729.             Debug((stderr, "\t\tadecl.left='%s'\n", yyval.halves.left));
  730.             Debug((stderr, "\t\tadecl.right='%s'\n", yyval.halves.right));
  731.             Debug((stderr, "\t\tadecl.type='%s'\n", yyval.halves.type));
  732.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  733.             } break;
  734. case 49:
  735. {
  736.             Debug((stderr, "adecl: ARRAY adims OF adecl\n"));
  737.             Debug((stderr, "\tadims='%s'\n", yypvt[-2].dynstr));
  738.             Debug((stderr, "\tadecl.left='%s'\n", yypvt[-0].halves.left));
  739.             Debug((stderr, "\tadecl.right='%s'\n", yypvt[-0].halves.right));
  740.             Debug((stderr, "\tadecl.type='%s'\n", yypvt[-0].halves.type));
  741.             if (prev == 'f')
  742.                 unsupp("Array of function",
  743.                        "array of pointer to function");
  744.             else if (prev == 'a')
  745.                 unsupp("Inner array of unspecified size",
  746.                        "array of pointer");
  747.             else if (prev == 'v')
  748.                 unsupp("Array of void",
  749.                        "pointer to void");
  750.             if (arbdims)
  751.                 prev = 'a';
  752.             else
  753.                 prev = 'A';
  754.             yyval.halves.left = yypvt[-0].halves.left;
  755.             yyval.halves.right = cat(yypvt[-2].dynstr,yypvt[-0].halves.right,NullCP);
  756.             yyval.halves.type = yypvt[-0].halves.type;
  757.             Debug((stderr, "\n\tadecl now =\n"));
  758.             Debug((stderr, "\t\tadecl.left='%s'\n", yyval.halves.left));
  759.             Debug((stderr, "\t\tadecl.right='%s'\n", yyval.halves.right));
  760.             Debug((stderr, "\t\tadecl.type='%s'\n", yyval.halves.type));
  761.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  762.             } break;
  763. case 50:
  764. {
  765.             char *op = "", *cp = "", *sp = "";
  766.  
  767.             Debug((stderr, "adecl: opt_constvol_list POINTER TO adecl\n"));
  768.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-3].dynstr));
  769.             Debug((stderr, "\tadecl.left='%s'\n", yypvt[-0].halves.left));
  770.             Debug((stderr, "\tadecl.right='%s'\n", yypvt[-0].halves.right));
  771.             Debug((stderr, "\tadecl.type='%s'\n", yypvt[-0].halves.type));
  772.             if (prev == 'a')
  773.                 unsupp("Pointer to array of unspecified dimension",
  774.                        "pointer to object");
  775.             if (prev=='a' || prev=='A' || prev=='f') {
  776.                 op = "(";
  777.                 cp = ")";
  778.             }
  779.             if (strlen(yypvt[-3].dynstr) != 0)
  780.                 sp = " ";
  781.             yyval.halves.left = cat(yypvt[-0].halves.left,ds(op),ds("*"),
  782.                        ds(sp),yypvt[-3].dynstr,ds(sp),NullCP);
  783.             yyval.halves.right = cat(ds(cp),yypvt[-0].halves.right,NullCP);
  784.             yyval.halves.type = yypvt[-0].halves.type;
  785.             prev = 'p';
  786.             Debug((stderr, "\n\tadecl now =\n"));
  787.             Debug((stderr, "\t\tadecl.left='%s'\n", yyval.halves.left));
  788.             Debug((stderr, "\t\tadecl.right='%s'\n", yyval.halves.right));
  789.             Debug((stderr, "\t\tadecl.type='%s'\n", yyval.halves.type));
  790.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  791.             } break;
  792. case 51:
  793. {
  794.             char *op = "", *cp = "", *sp = "";
  795.  
  796.             Debug((stderr, "adecl: opt_constvol_list POINTER TO MEMBER OF ClassStruct NAME adecl\n"));
  797.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-7].dynstr));
  798.             Debug((stderr, "\tClassStruct='%s'\n", yypvt[-2].dynstr));
  799.             Debug((stderr, "\tNAME='%s'\n", yypvt[-1].dynstr));
  800.             Debug((stderr, "\tadecl.left='%s'\n", yypvt[-0].halves.left));
  801.             Debug((stderr, "\tadecl.right='%s'\n", yypvt[-0].halves.right));
  802.             Debug((stderr, "\tadecl.type='%s'\n", yypvt[-0].halves.type));
  803.             if (!CplusplusFlag)
  804.                 unsupp("pointer to member of class", NullCP);
  805.             if (prev == 'a')
  806.                 unsupp("Pointer to array of unspecified dimension",
  807.                        "pointer to object");
  808.             if (prev=='a' || prev=='A' || prev=='f') {
  809.                 op = "(";
  810.                 cp = ")";
  811.             }
  812.             if (strlen(yypvt[-7].dynstr) != 0)
  813.                 sp = " ";
  814.             yyval.halves.left = cat(yypvt[-0].halves.left,ds(op),yypvt[-1].dynstr,ds("::*"),
  815.                       ds(sp),yypvt[-7].dynstr,ds(sp),NullCP);
  816.             yyval.halves.right = cat(ds(cp),yypvt[-0].halves.right,NullCP);
  817.             yyval.halves.type = yypvt[-0].halves.type;
  818.             prev = 'p';
  819.             Debug((stderr, "\n\tadecl now =\n"));
  820.             Debug((stderr, "\t\tadecl.left='%s'\n", yyval.halves.left));
  821.             Debug((stderr, "\t\tadecl.right='%s'\n", yyval.halves.right));
  822.             Debug((stderr, "\t\tadecl.type='%s'\n", yyval.halves.type));
  823.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  824.             } break;
  825. case 52:
  826. {
  827.             char *op = "", *cp = "", *sp = "";
  828.  
  829.             Debug((stderr, "adecl: opt_constvol_list REFERENCE TO adecl\n"));
  830.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-3].dynstr));
  831.             Debug((stderr, "\tadecl.left='%s'\n", yypvt[-0].halves.left));
  832.             Debug((stderr, "\tadecl.right='%s'\n", yypvt[-0].halves.right));
  833.             Debug((stderr, "\tadecl.type='%s'\n", yypvt[-0].halves.type));
  834.             if (!CplusplusFlag)
  835.                 unsupp("reference", NullCP);
  836.             if (prev == 'v')
  837.                 unsupp("Reference to void",
  838.                        "pointer to void");
  839.             else if (prev == 'a')
  840.                 unsupp("Reference to array of unspecified dimension",
  841.                        "reference to object");
  842.             if (prev=='a' || prev=='A' || prev=='f') {
  843.                 op = "(";
  844.                 cp = ")";
  845.             }
  846.             if (strlen(yypvt[-3].dynstr) != 0)
  847.                 sp = " ";
  848.             yyval.halves.left = cat(yypvt[-0].halves.left,ds(op),ds("&"),
  849.                        ds(sp),yypvt[-3].dynstr,ds(sp),NullCP);
  850.             yyval.halves.right = cat(ds(cp),yypvt[-0].halves.right,NullCP);
  851.             yyval.halves.type = yypvt[-0].halves.type;
  852.             prev = 'r';
  853.             Debug((stderr, "\n\tadecl now =\n"));
  854.             Debug((stderr, "\t\tadecl.left='%s'\n", yyval.halves.left));
  855.             Debug((stderr, "\t\tadecl.right='%s'\n", yyval.halves.right));
  856.             Debug((stderr, "\t\tadecl.type='%s'\n", yyval.halves.type));
  857.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  858.             } break;
  859. case 53:
  860. {
  861.             Debug((stderr, "adecl: opt_constvol_list type\n"));
  862.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-1].dynstr));
  863.             Debug((stderr, "\ttype='%s'\n", yypvt[-0].dynstr));
  864.             yyval.halves.left = ds("");
  865.             yyval.halves.right = ds("");
  866.             yyval.halves.type = cat(yypvt[-1].dynstr,ds(strlen(yypvt[-1].dynstr)?" ":""),yypvt[-0].dynstr,NullCP);
  867.             if (strcmp(yypvt[-0].dynstr, "void") == 0)
  868.                 prev = 'v';
  869.             else if ((strncmp(yypvt[-0].dynstr, "struct", 6) == 0) ||
  870.                      (strncmp(yypvt[-0].dynstr, "class", 5) == 0))
  871.                 prev = 's';
  872.             else
  873.                 prev = 't';
  874.             Debug((stderr, "\n\tadecl now =\n"));
  875.             Debug((stderr, "\t\tadecl.left='%s'\n", yyval.halves.left));
  876.             Debug((stderr, "\t\tadecl.right='%s'\n", yyval.halves.right));
  877.             Debug((stderr, "\t\tadecl.type='%s'\n", yyval.halves.type));
  878.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  879.             } break;
  880. case 54:
  881. {
  882.             Debug((stderr, "adims: EMPTY\n"));
  883.             arbdims = 1;
  884.             yyval.dynstr = ds("[]");
  885.             } break;
  886. case 55:
  887. {
  888.             Debug((stderr, "adims: NUMBER\n"));
  889.             Debug((stderr, "\tNUMBER='%s'\n", yypvt[-0].dynstr));
  890.             arbdims = 0;
  891.             yyval.dynstr = cat(ds("["),yypvt[-0].dynstr,ds("]"),NullCP);
  892.             } break;
  893. case 56:
  894. {
  895.             Debug((stderr, "type: tinit c_type\n"));
  896.             Debug((stderr, "\ttinit=''\n"));
  897.             Debug((stderr, "\tc_type='%s'\n", yypvt[-0].dynstr));
  898.             mbcheck();
  899.             yyval.dynstr = yypvt[-0].dynstr;
  900.             } break;
  901. case 57:
  902. {
  903.             Debug((stderr, "tinit: EMPTY\n"));
  904.             modbits = 0;
  905.             } break;
  906. case 58:
  907. {
  908.             Debug((stderr, "c_type: mod_list\n"));
  909.             Debug((stderr, "\tmod_list='%s'\n", yypvt[-0].dynstr));
  910.             yyval.dynstr = yypvt[-0].dynstr;
  911.             } break;
  912. case 59:
  913. {
  914.             Debug((stderr, "c_type: tname\n"));
  915.             Debug((stderr, "\ttname='%s'\n", yypvt[-0].dynstr));
  916.             yyval.dynstr = yypvt[-0].dynstr;
  917.             } break;
  918. case 60:
  919. {
  920.             Debug((stderr, "c_type: mod_list tname\n"));
  921.             Debug((stderr, "\tmod_list='%s'\n", yypvt[-1].dynstr));
  922.             Debug((stderr, "\ttname='%s'\n", yypvt[-0].dynstr));
  923.             yyval.dynstr = cat(yypvt[-1].dynstr,ds(" "),yypvt[-0].dynstr,NullCP);
  924.             } break;
  925. case 61:
  926. {
  927.             Debug((stderr, "c_type: StrClaUniEnum NAME\n"));
  928.             Debug((stderr, "\tStrClaUniEnum='%s'\n", yypvt[-1].dynstr));
  929.             Debug((stderr, "\tNAME='%s'\n", yypvt[-0].dynstr));
  930.             yyval.dynstr = cat(yypvt[-1].dynstr,ds(" "),yypvt[-0].dynstr,NullCP);
  931.             } break;
  932. case 64:
  933. {
  934.             yyval.dynstr = yypvt[-0].dynstr;
  935.             } break;
  936. case 66:
  937. {
  938.             yyval.dynstr = yypvt[-0].dynstr;
  939.             } break;
  940. case 67:
  941. {
  942.             Debug((stderr, "tname: INT\n"));
  943.             Debug((stderr, "\tINT='%s'\n", yypvt[-0].dynstr));
  944.             modbits |= MB_INT; yyval.dynstr = yypvt[-0].dynstr;
  945.             } break;
  946. case 68:
  947. {
  948.             Debug((stderr, "tname: CHAR\n"));
  949.             Debug((stderr, "\tCHAR='%s'\n", yypvt[-0].dynstr));
  950.             modbits |= MB_CHAR; yyval.dynstr = yypvt[-0].dynstr;
  951.             } break;
  952. case 69:
  953. {
  954.             Debug((stderr, "tname: FLOAT\n"));
  955.             Debug((stderr, "\tFLOAT='%s'\n", yypvt[-0].dynstr));
  956.             modbits |= MB_FLOAT; yyval.dynstr = yypvt[-0].dynstr;
  957.             } break;
  958. case 70:
  959. {
  960.             Debug((stderr, "tname: DOUBLE\n"));
  961.             Debug((stderr, "\tDOUBLE='%s'\n", yypvt[-0].dynstr));
  962.             modbits |= MB_DOUBLE; yyval.dynstr = yypvt[-0].dynstr;
  963.             } break;
  964. case 71:
  965. {
  966.             Debug((stderr, "tname: VOID\n"));
  967.             Debug((stderr, "\tVOID='%s'\n", yypvt[-0].dynstr));
  968.             modbits |= MB_VOID; yyval.dynstr = yypvt[-0].dynstr;
  969.             } break;
  970. case 72:
  971. {
  972.             Debug((stderr, "mod_list: modifier mod_list1\n"));
  973.             Debug((stderr, "\tmodifier='%s'\n", yypvt[-1].dynstr));
  974.             Debug((stderr, "\tmod_list1='%s'\n", yypvt[-0].dynstr));
  975.             yyval.dynstr = cat(yypvt[-1].dynstr,ds(" "),yypvt[-0].dynstr,NullCP);
  976.             } break;
  977. case 73:
  978. {
  979.             Debug((stderr, "mod_list: modifier\n"));
  980.             Debug((stderr, "\tmodifier='%s'\n", yypvt[-0].dynstr));
  981.             yyval.dynstr = yypvt[-0].dynstr;
  982.             } break;
  983. case 74:
  984. {
  985.             Debug((stderr, "mod_list1: mod_list\n"));
  986.             Debug((stderr, "\tmod_list='%s'\n", yypvt[-0].dynstr));
  987.             yyval.dynstr = yypvt[-0].dynstr;
  988.             } break;
  989. case 75:
  990. {
  991.             Debug((stderr, "mod_list1: CONSTVOLATILE\n"));
  992.             Debug((stderr, "\tCONSTVOLATILE='%s'\n", yypvt[-0].dynstr));
  993.             if (PreANSIFlag)
  994.                 notsupported(" (Pre-ANSI Compiler)", yypvt[-0].dynstr, NullCP);
  995.             else if (RitchieFlag)
  996.                 notsupported(" (Ritchie Compiler)", yypvt[-0].dynstr, NullCP);
  997.             else if ((strcmp(yypvt[-0].dynstr, "noalias") == 0) && CplusplusFlag)
  998.                 unsupp(yypvt[-0].dynstr, NullCP);
  999.             yyval.dynstr = yypvt[-0].dynstr;
  1000.             } break;
  1001. case 76:
  1002. {
  1003.             Debug((stderr, "modifier: UNSIGNED\n"));
  1004.             Debug((stderr, "\tUNSIGNED='%s'\n", yypvt[-0].dynstr));
  1005.             modbits |= MB_UNSIGNED; yyval.dynstr = yypvt[-0].dynstr;
  1006.             } break;
  1007. case 77:
  1008. {
  1009.             Debug((stderr, "modifier: SIGNED\n"));
  1010.             Debug((stderr, "\tSIGNED='%s'\n", yypvt[-0].dynstr));
  1011.             modbits |= MB_SIGNED; yyval.dynstr = yypvt[-0].dynstr;
  1012.             } break;
  1013. case 78:
  1014. {
  1015.             Debug((stderr, "modifier: LONG\n"));
  1016.             Debug((stderr, "\tLONG='%s'\n", yypvt[-0].dynstr));
  1017.             modbits |= MB_LONG; yyval.dynstr = yypvt[-0].dynstr;
  1018.             } break;
  1019. case 79:
  1020. {
  1021.             Debug((stderr, "modifier: SHORT\n"));
  1022.             Debug((stderr, "\tSHORT='%s'\n", yypvt[-0].dynstr));
  1023.             modbits |= MB_SHORT; yyval.dynstr = yypvt[-0].dynstr;
  1024.             } break;
  1025. case 80:
  1026. {
  1027.             Debug((stderr, "opt_constvol_list: CONSTVOLATILE opt_constvol_list\n"));
  1028.             Debug((stderr, "\tCONSTVOLATILE='%s'\n", yypvt[-1].dynstr));
  1029.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-0].dynstr));
  1030.             if (PreANSIFlag)
  1031.                 notsupported(" (Pre-ANSI Compiler)", yypvt[-1].dynstr, NullCP);
  1032.             else if (RitchieFlag)
  1033.                 notsupported(" (Ritchie Compiler)", yypvt[-1].dynstr, NullCP);
  1034.             else if ((strcmp(yypvt[-1].dynstr, "noalias") == 0) && CplusplusFlag)
  1035.                 unsupp(yypvt[-1].dynstr, NullCP);
  1036.             yyval.dynstr = cat(yypvt[-1].dynstr,ds(strlen(yypvt[-0].dynstr) ? " " : ""),yypvt[-0].dynstr,NullCP);
  1037.             } break;
  1038. case 81:
  1039. {
  1040.             Debug((stderr, "opt_constvol_list: EMPTY\n"));
  1041.             yyval.dynstr = ds("");
  1042.             } break;
  1043. case 82:
  1044. {
  1045.             Debug((stderr, "constvol_list: CONSTVOLATILE opt_constvol_list\n"));
  1046.             Debug((stderr, "\tCONSTVOLATILE='%s'\n", yypvt[-1].dynstr));
  1047.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-0].dynstr));
  1048.             if (PreANSIFlag)
  1049.                 notsupported(" (Pre-ANSI Compiler)", yypvt[-1].dynstr, NullCP);
  1050.             else if (RitchieFlag)
  1051.                 notsupported(" (Ritchie Compiler)", yypvt[-1].dynstr, NullCP);
  1052.             else if ((strcmp(yypvt[-1].dynstr, "noalias") == 0) && CplusplusFlag)
  1053.                 unsupp(yypvt[-1].dynstr, NullCP);
  1054.             yyval.dynstr = cat(yypvt[-1].dynstr,ds(strlen(yypvt[-0].dynstr) ? " " : ""),yypvt[-0].dynstr,NullCP);
  1055.             } break;
  1056. case 86:
  1057. {
  1058.             Debug((stderr, "storage: AUTO,EXTERN,STATIC,REGISTER (%s)\n", yypvt[-0].dynstr));
  1059.             yyval.dynstr = yypvt[-0].dynstr;
  1060.             } break;
  1061. case 87:
  1062. {
  1063.             Debug((stderr, "opt_storage: storage=%s\n", yypvt[-0].dynstr));
  1064.             yyval.dynstr = yypvt[-0].dynstr;
  1065.             } break;
  1066. case 88:
  1067. {
  1068.             Debug((stderr, "opt_storage: EMPTY\n"));
  1069.             yyval.dynstr = ds("");
  1070.             } break;
  1071.         }
  1072.         goto yystack;  /* stack new state and value */
  1073.  
  1074.     }
  1075.