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