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 / verbose.c < prev    next >
Text File  |  1992-10-20  |  6KB  |  337 lines
  1.  
  2. #include "defs.h"
  3.  
  4.  
  5. static short *null_rules;
  6.  
  7. verbose()
  8. {
  9.     register int i;
  10.  
  11.     if (!vflag) return;
  12.  
  13.     null_rules = (short *) MALLOC(nrules*sizeof(short));
  14.     if (null_rules == 0) no_space();
  15.     fprintf(verbose_file, "\f\n");
  16.     for (i = 0; i < nstates; i++)
  17.     print_state(i);
  18.     FREE(null_rules);
  19.     
  20.     Cooperate();
  21.     
  22.     if (nunused)
  23.     log_unused();
  24.     if (SRtotal || RRtotal)
  25.     log_conflicts();
  26.  
  27.     fprintf(verbose_file, "\n\n%d terminals, %d nonterminals\n", ntokens,
  28.         nvars);
  29.     fprintf(verbose_file, "%d grammar rules, %d states\n", nrules - 2, nstates);
  30. }
  31.  
  32.  
  33. log_unused()
  34. {
  35.     register int i;
  36.     register short *p;
  37.  
  38.     fprintf(verbose_file, "\n\nRules never reduced:\n");
  39.     for (i = 3; i < nrules; ++i)
  40.     {
  41.     if (!rules_used[i])
  42.     {
  43.         Cooperate();
  44.         fprintf(verbose_file, "\t%s :", symbol_name[rlhs[i]]);
  45.         for (p = ritem + rrhs[i]; *p >= 0; ++p)
  46.         fprintf(verbose_file, " %s", symbol_name[*p]);
  47.         fprintf(verbose_file, "  (%d)\n", i - 2);
  48.     }
  49.     }
  50. }
  51.  
  52.  
  53. log_conflicts()
  54. {
  55.     register int i;
  56.  
  57.     fprintf(verbose_file, "\n\n");
  58.     for (i = 0; i < nstates; i++)
  59.     {
  60.     if (SRconflicts[i] || RRconflicts[i])
  61.     {
  62.         Cooperate();
  63.         fprintf(verbose_file, "State %d contains ", i);
  64.         if (SRconflicts[i] == 1)
  65.         fprintf(verbose_file, "1 shift/reduce conflict");
  66.         else if (SRconflicts[i] > 1)
  67.         fprintf(verbose_file, "%d shift/reduce conflicts",
  68.             SRconflicts[i]);
  69.         if (SRconflicts[i] && RRconflicts[i])
  70.         fprintf(verbose_file, ", ");
  71.         if (RRconflicts[i] == 1)
  72.         fprintf(verbose_file, "1 reduce/reduce conflict");
  73.         else if (RRconflicts[i] > 1)
  74.         fprintf(verbose_file, "%d reduce/reduce conflicts",
  75.             RRconflicts[i]);
  76.         fprintf(verbose_file, ".\n");
  77.     }
  78.     }
  79. }
  80.  
  81.  
  82. print_state(state)
  83. int state;
  84. {
  85.     if (state)
  86.     fprintf(verbose_file, "\n\n");
  87.     if (SRconflicts[state] || RRconflicts[state])
  88.     print_conflicts(state);
  89.     fprintf(verbose_file, "state %d\n", state);
  90.     print_core(state);
  91.     print_nulls(state);
  92.     print_actions(state);
  93. }
  94.  
  95.  
  96. print_conflicts(state)
  97. int state;
  98. {
  99.     register int symbol, act, number;
  100.     register action *p;
  101.  
  102.     symbol = -1;
  103.     for (p = parser[state]; p; p = p->next)
  104.     {
  105.     if (p->suppressed == 2)
  106.         continue;
  107.  
  108.     Cooperate();
  109.     if (p->symbol != symbol)
  110.     {
  111.         symbol = p->symbol;
  112.         number = p->number;
  113.         if (p->action_code == SHIFT)
  114.         act = SHIFT;
  115.         else
  116.         act = REDUCE;
  117.     }
  118.     else if (p->suppressed == 1)
  119.     {
  120.         if (state == final_state && symbol == 0)
  121.         {
  122.         fprintf(verbose_file, "%d: shift/reduce conflict \
  123. (accept, reduce %d) on $end\n", state, p->number - 2);
  124.         }
  125.         else
  126.         {
  127.         if (act == SHIFT)
  128.         {
  129.             fprintf(verbose_file, "%d: shift/reduce conflict \
  130. (shift %d, reduce %d) on %s\n", state, number, p->number - 2,
  131.                 symbol_name[symbol]);
  132.         }
  133.         else
  134.         {
  135.             fprintf(verbose_file, "%d: reduce/reduce conflict \
  136. (reduce %d, reduce %d) on %s\n", state, number - 2, p->number - 2,
  137.                 symbol_name[symbol]);
  138.         }
  139.         }
  140.     }
  141.     }
  142. }
  143.  
  144.  
  145. print_core(state)
  146. int state;
  147. {
  148.     register int i;
  149.     register int k;
  150.     register int rule;
  151.     register core *statep;
  152.     register short *sp;
  153.     register short *sp1;
  154.  
  155.     statep = state_table[state];
  156.     k = statep->nitems;
  157.  
  158.     for (i = 0; i < k; i++)
  159.     {
  160.     sp1 = sp = ritem + statep->items[i];
  161.  
  162.     while (*sp >= 0) ++sp;
  163.     rule = -(*sp);
  164.     fprintf(verbose_file, "\t%s : ", symbol_name[rlhs[rule]]);
  165.  
  166.         for (sp = ritem + rrhs[rule]; sp < sp1; sp++)
  167.         fprintf(verbose_file, "%s ", symbol_name[*sp]);
  168.  
  169.     putc('.', verbose_file);
  170.  
  171.     Cooperate();
  172.     while (*sp >= 0)
  173.     {
  174.         fprintf(verbose_file, " %s", symbol_name[*sp]);
  175.         sp++;
  176.     }
  177.     fprintf(verbose_file, "  (%d)\n", -2 - *sp);
  178.     }
  179. }
  180.  
  181.  
  182. print_nulls(state)
  183. int state;
  184. {
  185.     register action *p;
  186.     register int i, j, k, nnulls;
  187.  
  188.     nnulls = 0;
  189.     for (p = parser[state]; p; p = p->next)
  190.     {
  191.     if (p->action_code == REDUCE &&
  192.         (p->suppressed == 0 || p->suppressed == 1))
  193.     {
  194.         Cooperate();
  195.         i = p->number;
  196.         if (rrhs[i] + 1 == rrhs[i+1])
  197.         {
  198.         for (j = 0; j < nnulls && i > null_rules[j]; ++j)
  199.             continue;
  200.  
  201.         if (j == nnulls)
  202.         {
  203.             ++nnulls;
  204.             null_rules[j] = i;
  205.         }
  206.         else if (i != null_rules[j])
  207.         {
  208.             ++nnulls;
  209.             for (k = nnulls - 1; k > j; --k)
  210.             null_rules[k] = null_rules[k-1];
  211.             null_rules[j] = i;
  212.         }
  213.         }
  214.     }
  215.     }
  216.  
  217.     for (i = 0; i < nnulls; ++i)
  218.     {
  219.     j = null_rules[i];
  220.     fprintf(verbose_file, "\t%s : .  (%d)\n", symbol_name[rlhs[j]],
  221.         j - 2);
  222.     }
  223.     fprintf(verbose_file, "\n");
  224. }
  225.  
  226.  
  227. print_actions(stateno)
  228. int stateno;
  229. {
  230.     register action *p;
  231.     register shifts *sp;
  232.     register int as;
  233.  
  234.     if (stateno == final_state)
  235.     fprintf(verbose_file, "\t$end  accept\n");
  236.  
  237.     p = parser[stateno];
  238.     if (p)
  239.     {
  240.     print_shifts(p);
  241.     print_reductions(p, defred[stateno]);
  242.     }
  243.  
  244.     sp = shift_table[stateno];
  245.     if (sp && sp->nshifts > 0)
  246.     {
  247.     as = accessing_symbol[sp->shift[sp->nshifts - 1]];
  248.     if (ISVAR(as))
  249.         print_gotos(stateno);
  250.     }
  251. }
  252.  
  253.  
  254. print_shifts(p)
  255. register action *p;
  256. {
  257.     register int count;
  258.     register action *q;
  259.  
  260.     count = 0;
  261.     for (q = p; q; q = q->next)
  262.     {
  263.     if (q->suppressed < 2 && q->action_code == SHIFT)
  264.         ++count;
  265.     }
  266.  
  267.     if (count > 0)
  268.     {
  269.     for (; p; p = p->next)
  270.     {
  271.         if (p->action_code == SHIFT && p->suppressed == 0)
  272.         fprintf(verbose_file, "\t%s  shift %d\n",
  273.                 symbol_name[p->symbol], p->number);
  274.     }
  275.     }
  276. }
  277.  
  278.  
  279. print_reductions(p, defred)
  280. register action *p;
  281. register int defred;
  282. {
  283.     register int k, anyreds;
  284.     register action *q;
  285.  
  286.     anyreds = 0;
  287.     for (q = p; q ; q = q->next)
  288.     {
  289.     if (q->action_code == REDUCE && q->suppressed < 2)
  290.     {
  291.         anyreds = 1;
  292.         break;
  293.     }
  294.     }
  295.  
  296.     if (anyreds == 0)
  297.     fprintf(verbose_file, "\t.  error\n");
  298.     else
  299.     {
  300.     for (; p; p = p->next)
  301.     {
  302.         if (p->action_code == REDUCE && p->number != defred)
  303.         {
  304.         k = p->number - 2;
  305.         if (p->suppressed == 0)
  306.             fprintf(verbose_file, "\t%s  reduce %d\n",
  307.                 symbol_name[p->symbol], k);
  308.         }
  309.     }
  310.  
  311.         if (defred > 0)
  312.         fprintf(verbose_file, "\t.  reduce %d\n", defred - 2);
  313.     }
  314. }
  315.  
  316.  
  317. print_gotos(stateno)
  318. int stateno;
  319. {
  320.     register int i, k;
  321.     register int as;
  322.     register short *to_state;
  323.     register shifts *sp;
  324.  
  325.     putc('\n', verbose_file);
  326.     sp = shift_table[stateno];
  327.     to_state = sp->shift;
  328.     for (i = 0; i < sp->nshifts; ++i)
  329.     {
  330.     k = to_state[i];
  331.     as = accessing_symbol[k];
  332.     if (ISVAR(as))
  333.         fprintf(verbose_file, "\t%s  goto %d\n", symbol_name[as], k);
  334.     }
  335. }
  336.  
  337.