home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / oct93 / develop / yacc.lha / Yacc / src / output.c < prev    next >
C/C++ Source or Header  |  1993-07-11  |  29KB  |  1,216 lines
  1. #include "defs.h"
  2.  
  3. static int nvectors;
  4. static int nentries;
  5. static short **froms;
  6. static short **tos;
  7. static short *tally;
  8. static short *width;
  9. static short *state_count;
  10. static short *order;
  11. static short *base;
  12. static short *pos;
  13. static int maxtable;
  14. static short *table;
  15. static short *check;
  16. static int lowzero;
  17. static int high;
  18.  
  19.  
  20. output()
  21. {
  22.     free_itemsets();
  23.     free_shifts();
  24.     free_reductions();
  25.     output_prefix();
  26.     output_stored_text();
  27.     output_defines();
  28.     output_rule_data();
  29.     output_yydefred();
  30.     output_actions();
  31.     free_parser();
  32.     output_debug();
  33.     output_stype();
  34.     if (rflag) write_section(tables);
  35.     write_section(header);
  36.     output_trailing_text();
  37.     write_section(body);
  38.     output_semantic_actions();
  39.     write_section(trailer);
  40. }
  41.  
  42.  
  43. output_prefix()
  44. {
  45.     if (symbol_prefix == NULL)
  46.         symbol_prefix = "yy";
  47.     else
  48.     {
  49.         ++outline;
  50.         fprintf(code_file, "#define yyparse %sparse\n", symbol_prefix);
  51.         ++outline;
  52.         fprintf(code_file, "#define yylex %slex\n", symbol_prefix);
  53.         ++outline;
  54.         fprintf(code_file, "#define yyerror %serror\n", symbol_prefix);
  55.         ++outline;
  56.         fprintf(code_file, "#define yychar %schar\n", symbol_prefix);
  57.         ++outline;
  58.         fprintf(code_file, "#define yyval %sval\n", symbol_prefix);
  59.         ++outline;
  60.         fprintf(code_file, "#define yylval %slval\n", symbol_prefix);
  61.         ++outline;
  62.         fprintf(code_file, "#define yydebug %sdebug\n", symbol_prefix);
  63.         ++outline;
  64.         fprintf(code_file, "#define yynerrs %snerrs\n", symbol_prefix);
  65.         ++outline;
  66.         fprintf(code_file, "#define yyerrflag %serrflag\n", symbol_prefix);
  67.         ++outline;
  68.         fprintf(code_file, "#define yyss %sss\n", symbol_prefix);
  69.         ++outline;
  70.         fprintf(code_file, "#define yyssp %sssp\n", symbol_prefix);
  71.         ++outline;
  72.         fprintf(code_file, "#define yyvs %svs\n", symbol_prefix);
  73.         ++outline;
  74.         fprintf(code_file, "#define yyvsp %svsp\n", symbol_prefix);
  75.         ++outline;
  76.         fprintf(code_file, "#define yylhs %slhs\n", symbol_prefix);
  77.         ++outline;
  78.         fprintf(code_file, "#define yylen %slen\n", symbol_prefix);
  79.         ++outline;
  80.         fprintf(code_file, "#define yydefred %sdefred\n", symbol_prefix);
  81.         ++outline;
  82.         fprintf(code_file, "#define yydgoto %sdgoto\n", symbol_prefix);
  83.         ++outline;
  84.         fprintf(code_file, "#define yysindex %ssindex\n", symbol_prefix);
  85.         ++outline;
  86.         fprintf(code_file, "#define yyrindex %srindex\n", symbol_prefix);
  87.         ++outline;
  88.         fprintf(code_file, "#define yygindex %sgindex\n", symbol_prefix);
  89.         ++outline;
  90.         fprintf(code_file, "#define yytable %stable\n", symbol_prefix);
  91.         ++outline;
  92.         fprintf(code_file, "#define yycheck %scheck\n", symbol_prefix);
  93.         ++outline;
  94.         fprintf(code_file, "#define yyname %sname\n", symbol_prefix);
  95.         ++outline;
  96.         fprintf(code_file, "#define yyrule %srule\n", symbol_prefix);
  97.     }
  98.     ++outline;
  99.     fprintf(code_file, "#define YYPREFIX \"%s\"\n", symbol_prefix);
  100. }
  101.  
  102.  
  103. output_rule_data()
  104. {
  105.     register int i;
  106.     register int j;
  107.  
  108.  
  109.     fprintf(output_file, "short %slhs[] = {%42d,", symbol_prefix,
  110.             symbol_value[start_symbol]);
  111.  
  112.     j = 10;
  113.     for (i = 3; i < nrules; i++)
  114.     {
  115.         if (j >= 10)
  116.         {
  117.             if (!rflag) ++outline;
  118.             putc('\n', output_file);
  119.             j = 1;
  120.         }
  121.         else
  122.             ++j;
  123.  
  124.         fprintf(output_file, "%5d,", symbol_value[rlhs[i]]);
  125.     }
  126.     if (!rflag) outline += 2;
  127.     fprintf(output_file, "\n};\n");
  128.  
  129.     fprintf(output_file, "short %slen[] = {%42d,", symbol_prefix, 2);
  130.  
  131.     j = 10;
  132.     for (i = 3; i < nrules; i++)
  133.     {
  134.         if (j >= 10)
  135.         {
  136.             if (!rflag) ++outline;
  137.             putc('\n', output_file);
  138.             j = 1;
  139.         }
  140.         else
  141.           j++;
  142.  
  143.         fprintf(output_file, "%5d,", rrhs[i + 1] - rrhs[i] - 1);
  144.     }
  145.     if (!rflag) outline += 2;
  146.     fprintf(output_file, "\n};\n");
  147. }
  148.  
  149.  
  150. output_yydefred()
  151. {
  152.     register int i, j;
  153.  
  154.     fprintf(output_file, "short %sdefred[] = {%39d,", symbol_prefix,
  155.             (defred[0] ? defred[0] - 2 : 0));
  156.  
  157.     j = 10;
  158.     for (i = 1; i < nstates; i++)
  159.     {
  160.         if (j < 10)
  161.             ++j;
  162.         else
  163.         {
  164.             if (!rflag) ++outline;
  165.             putc('\n', output_file);
  166.             j = 1;
  167.         }
  168.  
  169.         fprintf(output_file, "%5d,", (defred[i] ? defred[i] - 2 : 0));
  170.     }
  171.  
  172.     if (!rflag) outline += 2;
  173.     fprintf(output_file, "\n};\n");
  174. }
  175.  
  176.  
  177. output_actions()
  178. {
  179.     nvectors = 2*nstates + nvars;
  180.  
  181.     froms = NEW2(nvectors, short *);
  182.     tos = NEW2(nvectors, short *);
  183.     tally = NEW2(nvectors, short);
  184.     width = NEW2(nvectors, short);
  185.  
  186.     token_actions();
  187.     FREE(lookaheads);
  188.     FREE(LA);
  189.     FREE(LAruleno);
  190.     FREE(accessing_symbol);
  191.  
  192.     goto_actions();
  193.     FREE(goto_map + ntokens);
  194.     FREE(from_state);
  195.     FREE(to_state);
  196.  
  197.     sort_actions();
  198.     pack_table();
  199.     output_base();
  200.     output_table();
  201.     output_check();
  202. }
  203.  
  204.  
  205. token_actions()
  206. {
  207.     register int i, j;
  208.     register int shiftcount, reducecount;
  209.     register int max, min;
  210.     register short *actionrow, *r, *s;
  211.     register action *p;
  212.  
  213.     actionrow = NEW2(2*ntokens, short);
  214.     for (i = 0; i < nstates; ++i)
  215.     {
  216.         if (parser[i])
  217.         {
  218.             for (j = 0; j < 2*ntokens; ++j)
  219.             actionrow[j] = 0;
  220.  
  221.             shiftcount = 0;
  222.             reducecount = 0;
  223.             for (p = parser[i]; p; p = p->next)
  224.             {
  225.                 if (p->suppressed == 0)
  226.                 {
  227.                     if (p->action_code == SHIFT)
  228.                     {
  229.                         ++shiftcount;
  230.                         actionrow[p->symbol] = p->number;
  231.                     }
  232.                     else if (p->action_code == REDUCE && p->number != defred[i])
  233.                     {
  234.                         ++reducecount;
  235.                         actionrow[p->symbol + ntokens] = p->number;
  236.                     }
  237.                 }
  238.             }
  239.  
  240.             tally[i] = shiftcount;
  241.             tally[nstates+i] = reducecount;
  242.             width[i] = 0;
  243.             width[nstates+i] = 0;
  244.             if (shiftcount > 0)
  245.             {
  246.                 froms[i] = r = NEW2(shiftcount, short);
  247.                 tos[i] = s = NEW2(shiftcount, short);
  248.                 min = MAXSHORT;
  249.                 max = 0;
  250.                 for (j = 0; j < ntokens; ++j)
  251.                 {
  252.                     if (actionrow[j])
  253.                     {
  254.                         if (min > symbol_value[j])
  255.                             min = symbol_value[j];
  256.                         if (max < symbol_value[j])
  257.                             max = symbol_value[j];
  258.                         *r++ = symbol_value[j];
  259.                         *s++ = actionrow[j];
  260.                     }
  261.                 }
  262.                 width[i] = max - min + 1;
  263.             }
  264.             if (reducecount > 0)
  265.             {
  266.                 froms[nstates+i] = r = NEW2(reducecount, short);
  267.                 tos[nstates+i] = s = NEW2(reducecount, short);
  268.                 min = MAXSHORT;
  269.                 max = 0;
  270.                 for (j = 0; j < ntokens; ++j)
  271.                 {
  272.                     if (actionrow[ntokens+j])
  273.                     {
  274.                         if (min > symbol_value[j])
  275.                             min = symbol_value[j];
  276.                         if (max < symbol_value[j])
  277.                             max = symbol_value[j];
  278.                         *r++ = symbol_value[j];
  279.                         *s++ = actionrow[ntokens+j] - 2;
  280.                     }
  281.                 }
  282.                 width[nstates+i] = max - min + 1;
  283.             }
  284.         }
  285.     }
  286.     FREE(actionrow);
  287. }
  288.  
  289. goto_actions()
  290. {
  291.     register int i, j, k;
  292.  
  293.     state_count = NEW2(nstates, short);
  294.  
  295.     k = default_goto(start_symbol + 1);
  296.     fprintf(output_file, "short %sdgoto[] = {%40d,", symbol_prefix, k);
  297.     save_column(start_symbol + 1, k);
  298.  
  299.     j = 10;
  300.     for (i = start_symbol + 2; i < nsyms; i++)
  301.     {
  302.         if (j >= 10)
  303.         {
  304.             if (!rflag) ++outline;
  305.             putc('\n', output_file);
  306.             j = 1;
  307.         }
  308.         else
  309.             ++j;
  310.  
  311.         k = default_goto(i);
  312.         fprintf(output_file, "%5d,", k);
  313.         save_column(i, k);
  314.     }
  315.  
  316.     if (!rflag) outline += 2;
  317.     fprintf(output_file, "\n};\n");
  318.     FREE(state_count);
  319. }
  320.  
  321. int
  322. default_goto(symbol)
  323. int symbol;
  324. {
  325.     register int i;
  326.     register int m;
  327.     register int n;
  328.     register int default_state;
  329.     register int max;
  330.  
  331.     m = goto_map[symbol];
  332.     n = goto_map[symbol + 1];
  333.  
  334.     if (m == n) return (0);
  335.  
  336.     for (i = 0; i < nstates; i++)
  337.         state_count[i] = 0;
  338.  
  339.     for (i = m; i < n; i++)
  340.         state_count[to_state[i]]++;
  341.  
  342.     max = 0;
  343.     default_state = 0;
  344.     for (i = 0; i < nstates; i++)
  345.     {
  346.         if (state_count[i] > max)
  347.         {
  348.             max = state_count[i];
  349.             default_state = i;
  350.         }
  351.     }
  352.  
  353.     return (default_state);
  354. }
  355.  
  356.  
  357.  
  358. save_column(symbol, default_state)
  359. int symbol;
  360. int default_state;
  361. {
  362.     register int i;
  363.     register int m;
  364.     register int n;
  365.     register short *sp;
  366.     register short *sp1;
  367.     register short *sp2;
  368.     register int count;
  369.     register int symno;
  370.  
  371.     m = goto_map[symbol];
  372.     n = goto_map[symbol + 1];
  373.  
  374.     count = 0;
  375.     for (i = m; i < n; i++)
  376.     {
  377.         if (to_state[i] != default_state)
  378.             ++count;
  379.     }
  380.     if (count == 0) return;
  381.  
  382.     symno = symbol_value[symbol] + 2*nstates;
  383.  
  384.     froms[symno] = sp1 = sp = NEW2(count, short);
  385.     tos[symno] = sp2 = NEW2(count, short);
  386.  
  387.     for (i = m; i < n; i++)
  388.     {
  389.         if (to_state[i] != default_state)
  390.         {
  391.             *sp1++ = from_state[i];
  392.             *sp2++ = to_state[i];
  393.         }
  394.     }
  395.  
  396.     tally[symno] = count;
  397.     width[symno] = sp1[-1] - sp[0] + 1;
  398. }
  399.  
  400. sort_actions()
  401. {
  402.   register int i;
  403.   register int j;
  404.   register int k;
  405.   register int t;
  406.   register int w;
  407.  
  408.   order = NEW2(nvectors, short);
  409.   nentries = 0;
  410.  
  411.   for (i = 0; i < nvectors; i++)
  412.     {
  413.       if (tally[i] > 0)
  414.         {
  415.           t = tally[i];
  416.           w = width[i];
  417.           j = nentries - 1;
  418.  
  419.           while (j >= 0 && (width[order[j]] < w))
  420.             j--;
  421.  
  422.           while (j >= 0 && (width[order[j]] == w) && (tally[order[j]] < t))
  423.             j--;
  424.  
  425.           for (k = nentries - 1; k > j; k--)
  426.             order[k + 1] = order[k];
  427.  
  428.           order[j + 1] = i;
  429.           nentries++;
  430.         }
  431.     }
  432. }
  433.  
  434.  
  435. pack_table()
  436. {
  437.     register int i;
  438.     register int place;
  439.     register int state;
  440.  
  441.     base = NEW2(nvectors, short);
  442.     pos = NEW2(nentries, short);
  443.  
  444.     maxtable = 1000;
  445.     table = NEW2(maxtable, short);
  446.     check = NEW2(maxtable, short);
  447.  
  448.     lowzero = 0;
  449.     high = 0;
  450.  
  451.     for (i = 0; i < maxtable; i++)
  452.         check[i] = -1;
  453.  
  454.     for (i = 0; i < nentries; i++)
  455.     {
  456.         state = matching_vector(i);
  457.  
  458.         if (state < 0)
  459.             place = pack_vector(i);
  460.         else
  461.             place = base[state];
  462.  
  463.         pos[i] = place;
  464.         base[order[i]] = place;
  465.     }
  466.  
  467.     for (i = 0; i < nvectors; i++)
  468.     {
  469.         if (froms[i])
  470.             FREE(froms[i]);
  471.         if (tos[i])
  472.             FREE(tos[i]);
  473.     }
  474.  
  475.     FREE(froms);
  476.     FREE(tos);
  477.     FREE(pos);
  478. }
  479.  
  480.  
  481. /*  The function matching_vector determines if the vector specified by  */
  482. /*  the input parameter matches a previously considered vector.  The    */
  483. /*  test at the start of the function checks if the vector represents   */
  484. /*  a row of shifts over terminal symbols or a row of reductions, or a  */
  485. /*  column of shifts over a nonterminal symbol.  Berkeley Yacc does not */
  486. /*  check if a column of shifts over a nonterminal symbols matches a    */
  487. /*  previously considered vector.  Because of the nature of LR parsing  */
  488. /*  tables, no two columns can match.  Therefore, the only possible     */
  489. /*  match would be between a row and a column.  Such matches are        */
  490. /*  unlikely.  Therefore, to save time, no attempt is made to see if a  */
  491. /*  column matches a previously considered vector.                      */
  492. /*                                                                      */
  493. /*  Matching_vector is poorly designed.  The test could easily be made  */
  494. /*  faster.  Also, it depends on the vectors being in a specific        */
  495. /*  order.                                                              */
  496.  
  497. int
  498. matching_vector(vector)
  499. int vector;
  500. {
  501.     register int i;
  502.     register int j;
  503.     register int k;
  504.     register int t;
  505.     register int w;
  506.     register int match;
  507.     register int prev;
  508.  
  509.     i = order[vector];
  510.     if (i >= 2*nstates)
  511.         return (-1);
  512.  
  513.     t = tally[i];
  514.     w = width[i];
  515.  
  516.     for (prev = vector - 1; prev >= 0; prev--)
  517.     {
  518.         j = order[prev];
  519.         if (width[j] != w || tally[j] != t)
  520.             return (-1);
  521.  
  522.         match = 1;
  523.         for (k = 0; match && k < t; k++)
  524.         {
  525.             if (tos[j][k] != tos[i][k] || froms[j][k] != froms[i][k])
  526.                 match = 0;
  527.         }
  528.  
  529.         if (match)
  530.             return (j);
  531.     }
  532.  
  533.     return (-1);
  534. }
  535.  
  536.  
  537.  
  538. int
  539. pack_vector(vector)
  540. int vector;
  541. {
  542.     register int i, j, k, l;
  543.     register int t;
  544.     register int loc;
  545.     register int ok;
  546.     register short *from;
  547.     register short *to;
  548.     int newmax;
  549.  
  550.     i = order[vector];
  551.     t = tally[i];
  552.     assert(t);
  553.  
  554.     from = froms[i];
  555.     to = tos[i];
  556.  
  557.     j = lowzero - from[0];
  558.     for (k = 1; k < t; ++k)
  559.         if (lowzero - from[k] > j)
  560.             j = lowzero - from[k];
  561.     for (;; ++j)
  562.     {
  563.         if (j == 0)
  564.             continue;
  565.         ok = 1;
  566.         for (k = 0; ok && k < t; k++)
  567.         {
  568.             loc = j + from[k];
  569.             if (loc >= maxtable)
  570.             {
  571.                 if (loc >= MAXTABLE)
  572.                     fatal("maximum table size exceeded");
  573.  
  574.                 newmax = maxtable;
  575.                 do { newmax += 200; } while (newmax <= loc);
  576.                 table = (short *) REALLOC(table, newmax*sizeof(short));
  577.                 if (table == 0) no_space();
  578.                 check = (short *) REALLOC(check, newmax*sizeof(short));
  579.                 if (check == 0) no_space();
  580.                 for (l  = maxtable; l < newmax; ++l)
  581.                 {
  582.                     table[l] = 0;
  583.                     check[l] = -1;
  584.                 }
  585.                 maxtable = newmax;
  586.             }
  587.  
  588.             if (check[loc] != -1)
  589.                 ok = 0;
  590.         }
  591.         for (k = 0; ok && k < vector; k++)
  592.         {
  593.             if (pos[k] == j)
  594.                 ok = 0;
  595.         }
  596.         if (ok)
  597.         {
  598.             for (k = 0; k < t; k++)
  599.             {
  600.                 loc = j + from[k];
  601.                 table[loc] = to[k];
  602.                 check[loc] = from[k];
  603.                 if (loc > high) high = loc;
  604.             }
  605.  
  606.             while (check[lowzero] != -1)
  607.                 ++lowzero;
  608.  
  609.             return (j);
  610.         }
  611.     }
  612. }
  613.  
  614.  
  615.  
  616. output_base()
  617. {
  618.     register int i, j;
  619.  
  620.     fprintf(output_file, "short %ssindex[] = {%39d,", symbol_prefix, base[0]);
  621.  
  622.     j = 10;
  623.     for (i = 1; i < nstates; i++)
  624.     {
  625.         if (j >= 10)
  626.         {
  627.             if (!rflag) ++outline;
  628.             putc('\n', output_file);
  629.             j = 1;
  630.         }
  631.         else
  632.             ++j;
  633.  
  634.         fprintf(output_file, "%5d,", base[i]);
  635.     }
  636.  
  637.     if (!rflag) outline += 2;
  638.     fprintf(output_file, "\n};\nshort %srindex[] = {%39d,", symbol_prefix,
  639.             base[nstates]);
  640.  
  641.     j = 10;
  642.     for (i = nstates + 1; i < 2*nstates; i++)
  643.     {
  644.         if (j >= 10)
  645.         {
  646.             if (!rflag) ++outline;
  647.             putc('\n', output_file);
  648.             j = 1;
  649.         }
  650.         else
  651.             ++j;
  652.  
  653.         fprintf(output_file, "%5d,", base[i]);
  654.     }
  655.  
  656.     if (!rflag) outline += 2;
  657.     fprintf(output_file, "\n};\nshort %sgindex[] = {%39d,", symbol_prefix,
  658.             base[2*nstates]);
  659.  
  660.     j = 10;
  661.     for (i = 2*nstates + 1; i < nvectors - 1; i++)
  662.     {
  663.         if (j >= 10)
  664.         {
  665.             if (!rflag) ++outline;
  666.             putc('\n', output_file);
  667.             j = 1;
  668.         }
  669.         else
  670.             ++j;
  671.  
  672.         fprintf(output_file, "%5d,", base[i]);
  673.     }
  674.  
  675.     if (!rflag) outline += 2;
  676.     fprintf(output_file, "\n};\n");
  677.     FREE(base);
  678. }
  679.  
  680.  
  681.  
  682. output_table()
  683. {
  684.     register int i;
  685.     register int j;
  686.  
  687.     ++outline;
  688.     fprintf(code_file, "#define YYTABLESIZE %d\n", high);
  689.     fprintf(output_file, "short %stable[] = {%40d,", symbol_prefix,
  690.             table[0]);
  691.  
  692.     j = 10;
  693.     for (i = 1; i <= high; i++)
  694.     {
  695.         if (j >= 10)
  696.         {
  697.             if (!rflag) ++outline;
  698.             putc('\n', output_file);
  699.             j = 1;
  700.         }
  701.         else
  702.             ++j;
  703.  
  704.         fprintf(output_file, "%5d,", table[i]);
  705.     }
  706.  
  707.     if (!rflag) outline += 2;
  708.     fprintf(output_file, "\n};\n");
  709.     FREE(table);
  710. }
  711.  
  712.  
  713.  
  714. output_check()
  715. {
  716.     register int i;
  717.     register int j;
  718.  
  719.     fprintf(output_file, "short %scheck[] = {%40d,", symbol_prefix,
  720.             check[0]);
  721.  
  722.     j = 10;
  723.     for (i = 1; i <= high; i++)
  724.     {
  725.         if (j >= 10)
  726.         {
  727.             if (!rflag) ++outline;
  728.             putc('\n', output_file);
  729.             j = 1;
  730.         }
  731.         else
  732.             ++j;
  733.  
  734.         fprintf(output_file, "%5d,", check[i]);
  735.     }
  736.  
  737.     if (!rflag) outline += 2;
  738.     fprintf(output_file, "\n};\n");
  739.     FREE(check);
  740. }
  741.  
  742.  
  743. int
  744. is_C_identifier(name)
  745. char *name;
  746. {
  747.     register char *s;
  748.     register int c;
  749.  
  750.     s = name;
  751.     c = *s;
  752.     if (c == '"')
  753.     {
  754.         c = *++s;
  755.         if (!isalpha(c) && c != '_' && c != '$')
  756.             return (0);
  757.         while ((c = *++s) != '"')
  758.         {
  759.             if (!isalnum(c) && c != '_' && c != '$')
  760.                 return (0);
  761.         }
  762.         return (1);
  763.     }
  764.  
  765.     if (!isalpha(c) && c != '_' && c != '$')
  766.         return (0);
  767.     while (c = *++s)
  768.     {
  769.         if (!isalnum(c) && c != '_' && c != '$')
  770.             return (0);
  771.     }
  772.     return (1);
  773. }
  774.  
  775.  
  776. output_defines()
  777. {
  778.     register int c, i;
  779.     register char *s;
  780.  
  781.     for (i = 2; i < ntokens; ++i)
  782.     {
  783.         s = symbol_name[i];
  784.         if (is_C_identifier(s))
  785.         {
  786.             fprintf(code_file, "#define ");
  787.             if (dflag) fprintf(defines_file, "#define ");
  788.             c = *s;
  789.             if (c == '"')
  790.             {
  791.                 while ((c = *++s) != '"')
  792.                 {
  793.                     putc(c, code_file);
  794.                     if (dflag) putc(c, defines_file);
  795.                 }
  796.             }
  797.             else
  798.             {
  799.                 do
  800.                 {
  801.                     putc(c, code_file);
  802.                     if (dflag) putc(c, defines_file);
  803.                 }
  804.                 while (c = *++s);
  805.             }
  806.             ++outline;
  807.             fprintf(code_file, " %d\n", symbol_value[i]);
  808.             if (dflag) fprintf(defines_file, " %d\n", symbol_value[i]);
  809.         }
  810.     }
  811.  
  812.     ++outline;
  813.     fprintf(code_file, "#define YYERRCODE %d\n", symbol_value[1]);
  814.  
  815.     if (dflag)
  816.     {
  817.         if (unionized)
  818.         {
  819.             fclose(union_file);
  820.             union_file = fopen(union_file_name, "r");
  821.             if (union_file == NULL) open_error(union_file_name);
  822.             while ((c = getc(union_file)) != EOF)
  823.                 putc(c, defines_file);
  824.             fprintf(defines_file, " YYSTYPE;\n");
  825.         }
  826.         else
  827.             fprintf(defines_file, "#ifndef YYSTYPE\ntypedef int YYSTYPE;\n#endif\n");
  828.         fprintf(defines_file, "extern YYSTYPE %slval;\n", symbol_prefix);
  829.     }
  830. }
  831.  
  832.  
  833. output_stored_text()
  834. {
  835.     register int c;
  836.     register FILE *in, *out;
  837.  
  838.     fclose(text_file);
  839.     text_file = fopen(text_file_name, "r");
  840.     if (text_file == NULL)
  841.         open_error(text_file_name);
  842.     in = text_file;
  843.     if ((c = getc(in)) == EOF)
  844.         return;
  845.     out = code_file;
  846.     if (c ==  '\n')
  847.         ++outline;
  848.     putc(c, out);
  849.     while ((c = getc(in)) != EOF)
  850.     {
  851.         if (c == '\n')
  852.             ++outline;
  853.         putc(c, out);
  854.     }
  855.     if (!lflag)
  856.         fprintf(out, line_format, ++outline + 1, code_file_name);
  857. }
  858.  
  859.  
  860. output_debug()
  861. {
  862.     register int i, j, k, max;
  863.     char **symnam, *s;
  864.  
  865.     ++outline;
  866.     fprintf(code_file, "#define YYFINAL %d\n", final_state);
  867.     outline += 3;
  868.     fprintf(code_file, "#ifndef YYDEBUG\n#define YYDEBUG %d\n#endif\n",
  869.             tflag);
  870.     if (rflag)
  871.         fprintf(output_file, "#ifndef YYDEBUG\n#define YYDEBUG %d\n#endif\n",
  872.                 tflag);
  873.  
  874.     max = 0;
  875.     for (i = 2; i < ntokens; ++i)
  876.         if (symbol_value[i] > max)
  877.             max = symbol_value[i];
  878.     ++outline;
  879.     fprintf(code_file, "#define YYMAXTOKEN %d\n", max);
  880.  
  881.     symnam = (char **) MALLOC((max+1)*sizeof(char *));
  882.     if (symnam == 0) no_space();
  883.  
  884.     /* Note that it is  not necessary to initialize the element         */
  885.     /* symnam[max].                                                     */
  886.     for (i = 0; i < max; ++i)
  887.         symnam[i] = 0;
  888.     for (i = ntokens - 1; i >= 2; --i)
  889.         symnam[symbol_value[i]] = symbol_name[i];
  890.     symnam[0] = "end-of-file";
  891.  
  892.     if (!rflag) ++outline;
  893.     fprintf(output_file, "#if YYDEBUG\nchar *%sname[] = {", symbol_prefix);
  894.     j = 80;
  895.     for (i = 0; i <= max; ++i)
  896.     {
  897.         if (s = symnam[i])
  898.         {
  899.             if (s[0] == '"')
  900.             {
  901.                 k = 7;
  902.                 while (*++s != '"')
  903.                 {
  904.                     ++k;
  905.                     if (*s == '\\')
  906.                     {
  907.                         k += 2;
  908.                         if (*++s == '\\')
  909.                             ++k;
  910.                     }
  911.                 }
  912.                 j += k;
  913.                 if (j > 80)
  914.                 {
  915.                     if (!rflag) ++outline;
  916.                     putc('\n', output_file);
  917.                     j = k;
  918.                 }
  919.                 fprintf(output_file, "\"\\\"");
  920.                 s = symnam[i];
  921.                 while (*++s != '"')
  922.                 {
  923.                     if (*s == '\\')
  924.                     {
  925.                         fprintf(output_file, "\\\\");
  926.                         if (*++s == '\\')
  927.                             fprintf(output_file, "\\\\");
  928.                         else
  929.                             putc(*s, output_file);
  930.                     }
  931.                     else
  932.                         putc(*s, output_file);
  933.                 }
  934.                 fprintf(output_file, "\\\"\",");
  935.             }
  936.             else if (s[0] == '\'')
  937.             {
  938.                 if (s[1] == '"')
  939.                 {
  940.                     j += 7;
  941.                     if (j > 80)
  942.                     {
  943.                         if (!rflag) ++outline;
  944.                         putc('\n', output_file);
  945.                         j = 7;
  946.                     }
  947.                     fprintf(output_file, "\"'\\\"'\",");
  948.                 }
  949.                 else
  950.                 {
  951.                     k = 5;
  952.                     while (*++s != '\'')
  953.                     {
  954.                         ++k;
  955.                         if (*s == '\\')
  956.                         {
  957.                             k += 2;
  958.                             if (*++s == '\\')
  959.                                 ++k;
  960.                         }
  961.                     }
  962.                     j += k;
  963.                     if (j > 80)
  964.                     {
  965.                         if (!rflag) ++outline;
  966.                         putc('\n', output_file);
  967.                         j = k;
  968.                     }
  969.                     fprintf(output_file, "\"'");
  970.                     s = symnam[i];
  971.                     while (*++s != '\'')
  972.                     {
  973.                         if (*s == '\\')
  974.                         {
  975.                             fprintf(output_file, "\\\\");
  976.                             if (*++s == '\\')
  977.                                 fprintf(output_file, "\\\\");
  978.                             else
  979.                                 putc(*s, output_file);
  980.                         }
  981.                         else
  982.                             putc(*s, output_file);
  983.                     }
  984.                     fprintf(output_file, "'\",");
  985.                 }
  986.             }
  987.             else
  988.             {
  989.                 k = strlen(s) + 3;
  990.                 j += k;
  991.                 if (j > 80)
  992.                 {
  993.                     if (!rflag) ++outline;
  994.                     putc('\n', output_file);
  995.                     j = k;
  996.                 }
  997.                 putc('"', output_file);
  998.                 do { putc(*s, output_file); } while (*++s);
  999.                 fprintf(output_file, "\",");
  1000.             }
  1001.         }
  1002.         else
  1003.         {
  1004.             j += 2;
  1005.             if (j > 80)
  1006.             {
  1007.                 if (!rflag) ++outline;
  1008.                 putc('\n', output_file);
  1009.                 j = 2;
  1010.             }
  1011.             fprintf(output_file, "0,");
  1012.         }
  1013.     }
  1014.     if (!rflag) outline += 2;
  1015.     fprintf(output_file, "\n};\n");
  1016.     FREE(symnam);
  1017.  
  1018.     if (!rflag) ++outline;
  1019.     fprintf(output_file, "char *%srule[] = {\n", symbol_prefix);
  1020.     for (i = 2; i < nrules; ++i)
  1021.     {
  1022.         fprintf(output_file, "\"%s :", symbol_name[rlhs[i]]);
  1023.         for (j = rrhs[i]; ritem[j] > 0; ++j)
  1024.         {
  1025.             s = symbol_name[ritem[j]];
  1026.             if (s[0] == '"')
  1027.             {
  1028.                 fprintf(output_file, " \\\"");
  1029.                 while (*++s != '"')
  1030.                 {
  1031.                     if (*s == '\\')
  1032.                     {
  1033.                         if (s[1] == '\\')
  1034.                             fprintf(output_file, "\\\\\\\\");
  1035.                         else
  1036.                             fprintf(output_file, "\\\\%c", s[1]);
  1037.                         ++s;
  1038.                     }
  1039.                     else
  1040.                         putc(*s, output_file);
  1041.                 }
  1042.                 fprintf(output_file, "\\\"");
  1043.             }
  1044.             else if (s[0] == '\'')
  1045.             {
  1046.                 if (s[1] == '"')
  1047.                     fprintf(output_file, " '\\\"'");
  1048.                 else if (s[1] == '\\')
  1049.                 {
  1050.                     if (s[2] == '\\')
  1051.                         fprintf(output_file, " '\\\\\\\\");
  1052.                     else
  1053.                         fprintf(output_file, " '\\\\%c", s[2]);
  1054.                     s += 2;
  1055.                     while (*++s != '\'')
  1056.                         putc(*s, output_file);
  1057.                     putc('\'', output_file);
  1058.                 }
  1059.                 else
  1060.                     fprintf(output_file, " '%c'", s[1]);
  1061.             }
  1062.             else
  1063.                 fprintf(output_file, " %s", s);
  1064.         }
  1065.         if (!rflag) ++outline;
  1066.         fprintf(output_file, "\",\n");
  1067.     }
  1068.  
  1069.     if (!rflag) outline += 2;
  1070.     fprintf(output_file, "};\n#endif\n");
  1071. }
  1072.  
  1073.  
  1074. output_stype()
  1075. {
  1076.     if (!unionized && ntags == 0)
  1077.     {
  1078.         outline += 3;
  1079.         fprintf(code_file, "#ifndef YYSTYPE\ntypedef int YYSTYPE;\n#endif\n");
  1080.     }
  1081. }
  1082.  
  1083.  
  1084. output_trailing_text()
  1085. {
  1086.     register int c, last;
  1087.     register FILE *in, *out;
  1088.  
  1089.     if (line == 0)
  1090.         return;
  1091.  
  1092.     in = input_file;
  1093.     out = code_file;
  1094.     c = *cptr;
  1095.     if (c == '\n')
  1096.     {
  1097.         ++lineno;
  1098.         if ((c = getc(in)) == EOF)
  1099.             return;
  1100.         if (!lflag)
  1101.         {
  1102.             ++outline;
  1103.             fprintf(out, line_format, lineno, input_file_name);
  1104.         }
  1105.         if (c == '\n')
  1106.             ++outline;
  1107.         putc(c, out);
  1108.         last = c;
  1109.     }
  1110.     else
  1111.     {
  1112.         if (!lflag)
  1113.         {
  1114.             ++outline;
  1115.             fprintf(out, line_format, lineno, input_file_name);
  1116.         }
  1117.         do { putc(c, out); } while ((c = *++cptr) != '\n');
  1118.         ++outline;
  1119.         putc('\n', out);
  1120.         last = '\n';
  1121.     }
  1122.  
  1123.     while ((c = getc(in)) != EOF)
  1124.     {
  1125.         if (c == '\n')
  1126.             ++outline;
  1127.         putc(c, out);
  1128.         last = c;
  1129.     }
  1130.  
  1131.     if (last != '\n')
  1132.     {
  1133.         ++outline;
  1134.         putc('\n', out);
  1135.     }
  1136.     if (!lflag)
  1137.         fprintf(out, line_format, ++outline + 1, code_file_name);
  1138. }
  1139.  
  1140.  
  1141. output_semantic_actions()
  1142. {
  1143.     register int c, last;
  1144.     register FILE *out;
  1145.  
  1146.     fclose(action_file);
  1147.     action_file = fopen(action_file_name, "r");
  1148.     if (action_file == NULL)
  1149.         open_error(action_file_name);
  1150.  
  1151.     if ((c = getc(action_file)) == EOF)
  1152.         return;
  1153.  
  1154.     out = code_file;
  1155.     last = c;
  1156.     if (c == '\n')
  1157.         ++outline;
  1158.     putc(c, out);
  1159.     while ((c = getc(action_file)) != EOF)
  1160.     {
  1161.         if (c == '\n')
  1162.             ++outline;
  1163.         putc(c, out);
  1164.         last = c;
  1165.     }
  1166.  
  1167.     if (last != '\n')
  1168.     {
  1169.         ++outline;
  1170.         putc('\n', out);
  1171.     }
  1172.  
  1173.     if (!lflag)
  1174.         fprintf(out, line_format, ++outline + 1, code_file_name);
  1175. }
  1176.  
  1177.  
  1178. free_itemsets()
  1179. {
  1180.     register core *cp, *next;
  1181.  
  1182.     FREE(state_table);
  1183.     for (cp = first_state; cp; cp = next)
  1184.     {
  1185.         next = cp->next;
  1186.         FREE(cp);
  1187.     }
  1188. }
  1189.  
  1190.  
  1191. free_shifts()
  1192. {
  1193.     register shifts *sp, *next;
  1194.  
  1195.     FREE(shift_table);
  1196.     for (sp = first_shift; sp; sp = next)
  1197.     {
  1198.         next = sp->next;
  1199.         FREE(sp);
  1200.     }
  1201. }
  1202.  
  1203.  
  1204.  
  1205. free_reductions()
  1206. {
  1207.     register reductions *rp, *next;
  1208.  
  1209.     FREE(reduction_table);
  1210.     for (rp = first_reduction; rp; rp = next)
  1211.     {
  1212.         next = rp->next;
  1213.         FREE(rp);
  1214.     }
  1215. }
  1216.