verbose.c 6.4 KB

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