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