src/gram.c

/* Allocate input grammar variables for Bison.

   Copyright (C) 1984, 1986, 1989, 2001, 2002, 2003, 2005, 2006,
   2007, 2008, 2009 Free Software Foundation, Inc.

   This file is part of Bison, the GNU Compiler Compiler.

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include <config.h>
#include "system.h"

#include <quotearg.h>

#include "gram.h"
#include "reader.h"
#include "reduce.h"
#include "symtab.h"
#include "print-xml.h"

/* Comments for these variables are in gram.h.  */

item_number *ritem = NULL;
unsigned int nritems = 0;

rule *rules = NULL;
rule_number nrules = 0;

symbol **symbols = NULL;
int nsyms = 0;
int ntokens = 1;
int nvars = 0;

symbol_number *token_translations = NULL;

int max_user_token_number = 256;

bool
rule_useful_in_grammar_p (rule *r)
{
  return r->number < nrules;
}

bool
rule_useless_in_grammar_p (rule *r)
{
  return !rule_useful_in_grammar_p (r);
}

bool
rule_useless_in_parser_p (rule *r)
{
  return !r->useful && rule_useful_in_grammar_p (r);
}

void
rule_lhs_print (rule *r, symbol *previous_lhs, FILE *out)
{
  fprintf (out, "  %3d ", r->number);
  if (previous_lhs != r->lhs)
    {
      fprintf (out, "%s:", r->lhs->tag);
    }
  else
    {
      int n;
      for (n = strlen (previous_lhs->tag); n > 0; --n)
	fputc (' ', out);
      fputc ('|', out);
    }
}

void
rule_lhs_print_xml (rule *r, FILE *out, int level)
{
  xml_printf (out, level, "<lhs>%s</lhs>", r->lhs->tag);
}

int
rule_rhs_length (rule *r)
{
  int res = 0;
  item_number *rhsp;
  for (rhsp = r->rhs; *rhsp >= 0; ++rhsp)
    ++res;
  return res;
}

void
rule_rhs_print (rule *r, FILE *out)
{
  if (*r->rhs >= 0)
    {
      item_number *rp;
      for (rp = r->rhs; *rp >= 0; rp++)
	fprintf (out, " %s", symbols[*rp]->tag);
      fputc ('\n', out);
    }
  else
    {
      fprintf (out, " /* %s */\n", _("empty"));
    }
}

static void
rule_rhs_print_xml (rule *r, FILE *out, int level)
{
  if (*r->rhs >= 0)
    {
      item_number *rp;
      xml_puts (out, level, "<rhs>");
      for (rp = r->rhs; *rp >= 0; rp++)
	xml_printf (out, level + 1, "<symbol>%s</symbol>",
		    xml_escape (symbols[*rp]->tag));
      xml_puts (out, level, "</rhs>");
    }
  else
    {
      xml_puts (out, level, "<rhs>");
      xml_puts (out, level + 1, "<empty/>");
      xml_puts (out, level, "</rhs>");
    }
}

void
rule_print (rule *r, FILE *out)
{
  fprintf (out, "%s:", r->lhs->tag);
  rule_rhs_print (r, out);
}

void
ritem_print (FILE *out)
{
  unsigned int i;
  fputs ("RITEM\n", out);
  for (i = 0; i < nritems; ++i)
    if (ritem[i] >= 0)
      fprintf (out, "  %s", symbols[ritem[i]]->tag);
    else
      fprintf (out, "  (rule %d)\n", item_number_as_rule_number (ritem[i]));
  fputs ("\n\n", out);
}

size_t
ritem_longest_rhs (void)
{
  int max = 0;
  rule_number r;

  for (r = 0; r < nrules; ++r)
    {
      int length = rule_rhs_length (&rules[r]);
      if (length > max)
	max = length;
    }

  return max;
}

void
grammar_rules_partial_print (FILE *out, const char *title,
			     rule_filter filter)
{
  rule_number r;
  bool first = true;
  symbol *previous_lhs = NULL;

  /* rule # : LHS -> RHS */
  for (r = 0; r < nrules + nuseless_productions; r++)
    {
      if (filter && !filter (&rules[r]))
	continue;
      if (first)
	fprintf (out, "%s\n\n", title);
      else if (previous_lhs && previous_lhs != rules[r].lhs)
	fputc ('\n', out);
      first = false;
      rule_lhs_print (&rules[r], previous_lhs, out);
      rule_rhs_print (&rules[r], out);
      previous_lhs = rules[r].lhs;
    }
  if (!first)
    fputs ("\n\n", out);
}

void
grammar_rules_print (FILE *out)
{
  grammar_rules_partial_print (out, _("Grammar"), rule_useful_in_grammar_p);
}

void
grammar_rules_print_xml (FILE *out, int level)
{
  rule_number r;
  bool first = true;

  for (r = 0; r < nrules + nuseless_productions; r++)
    {
      if (first)
	xml_puts (out, level + 1, "<rules>");
      first = false;
      {
        char const *usefulness;
        if (rule_useless_in_grammar_p (&rules[r]))
          usefulness = "useless-in-grammar";
        else if (rule_useless_in_parser_p (&rules[r]))
          usefulness = "useless-in-parser";
        else
          usefulness = "useful";
        xml_indent (out, level + 2);
        fprintf (out, "<rule number=\"%d\" usefulness=\"%s\"",
                 rules[r].number, usefulness);
        if (rules[r].precsym)
          fprintf (out, " percent_prec=\"%s\"",
                   xml_escape (rules[r].precsym->tag));
        fputs (">\n", out);
      }
      rule_lhs_print_xml (&rules[r], out, level + 3);
      rule_rhs_print_xml (&rules[r], out, level + 3);
      xml_puts (out, level + 2, "</rule>");
    }
  if (!first)
    xml_puts (out, level + 1, "</rules>");
  else
   xml_puts (out, level + 1, "<rules/>");
}

void
grammar_dump (FILE *out, const char *title)
{
  fprintf (out, "%s\n\n", title);
  fprintf (out,
	   "ntokens = %d, nvars = %d, nsyms = %d, nrules = %d, nritems = %d\n\n",
	   ntokens, nvars, nsyms, nrules, nritems);


  fprintf (out, "Variables\n---------\n\n");
  {
    symbol_number i;
    fprintf (out, "Value  Sprec  Sassoc  Tag\n");

    for (i = ntokens; i < nsyms; i++)
      fprintf (out, "%5d  %5d   %5d  %s\n",
	       i,
	       symbols[i]->prec, symbols[i]->assoc,
	       symbols[i]->tag);
    fprintf (out, "\n\n");
  }

  fprintf (out, "Rules\n-----\n\n");
  {
    rule_number i;
    fprintf (out, "Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem range) [Num]\n");
    for (i = 0; i < nrules + nuseless_productions; i++)
      {
	rule *rule_i = &rules[i];
	item_number *rp = NULL;
	unsigned int rhs_itemno = rule_i->rhs - ritem;
	unsigned int rhs_count = 0;
	/* Find the last RHS index in ritems. */
	for (rp = rule_i->rhs; *rp >= 0; ++rp)
	  ++rhs_count;
	fprintf (out, "%3d (%2d, %2d, %2d, %2u-%2u)   %2d ->",
		 i,
		 rule_i->prec ? rule_i->prec->prec : 0,
		 rule_i->prec ? rule_i->prec->assoc : 0,
		 rule_i->useful,
		 rhs_itemno,
		 rhs_itemno + rhs_count - 1,
		 rule_i->lhs->number);
	/* Dumped the RHS. */
	for (rp = rule_i->rhs; *rp >= 0; rp++)
	  fprintf (out, " %3d", *rp);
	fprintf (out, "  [%d]\n", item_number_as_rule_number (*rp));
      }
  }
  fprintf (out, "\n\n");

  fprintf (out, "Rules interpreted\n-----------------\n\n");
  {
    rule_number r;
    for (r = 0; r < nrules + nuseless_productions; r++)
      {
	fprintf (out, "%-5d  ", r);
	rule_print (&rules[r], out);
      }
  }
  fprintf (out, "\n\n");
}

void
grammar_rules_useless_report (const char *message)
{
  rule_number r;
  for (r = 0; r < nrules ; ++r)
    if (!rules[r].useful)
      {
	location_print (stderr, rules[r].location);
	fprintf (stderr, ": %s: %s: ", _("warning"), message);
	rule_print (&rules[r], stderr);
      }
}

void
grammar_free (void)
{
  if (ritem)
    free (ritem - 1);
  free (rules);
  free (token_translations);
  /* Free the symbol table data structure.  */
  symbols_free ();
  free_merger_functions ();
}
Commit	Line	Data
	1	/* Allocate input grammar variables for Bison.
	2
	3	Copyright (C) 1984, 1986, 1989, 2001, 2002, 2003, 2005, 2006,
	4	2007, 2008, 2009 Free Software Foundation, Inc.
	5
	6	This file is part of Bison, the GNU Compiler Compiler.
	7
	8	This program is free software: you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation, either version 3 of the License, or
	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	20
	21	#include <config.h>
	22	#include "system.h"
	23
	24	#include <quotearg.h>
	25
	26	#include "gram.h"
	27	#include "reader.h"
	28	#include "reduce.h"
	29	#include "symtab.h"
	30	#include "print-xml.h"
	31
	32	/* Comments for these variables are in gram.h. */
	33
	34	item_number *ritem = NULL;
	35	unsigned int nritems = 0;
	36
	37	rule *rules = NULL;
	38	rule_number nrules = 0;
	39
	40	symbol **symbols = NULL;
	41	int nsyms = 0;
	42	int ntokens = 1;
	43	int nvars = 0;
	44
	45	symbol_number *token_translations = NULL;
	46
	47	int max_user_token_number = 256;
	48
	49	bool
	50	rule_useful_in_grammar_p (rule *r)
	51	{
	52	return r->number < nrules;
	53	}
	54
	55	bool
	56	rule_useless_in_grammar_p (rule *r)
	57	{
	58	return !rule_useful_in_grammar_p (r);
	59	}
	60
	61	bool
	62	rule_useless_in_parser_p (rule *r)
	63	{
	64	return !r->useful && rule_useful_in_grammar_p (r);
	65	}
	66
	67	void
	68	rule_lhs_print (rule r, symbol previous_lhs, FILE *out)
	69	{
	70	fprintf (out, " %3d ", r->number);
	71	if (previous_lhs != r->lhs)
	72	{
	73	fprintf (out, "%s:", r->lhs->tag);
	74	}
	75	else
	76	{
	77	int n;
	78	for (n = strlen (previous_lhs->tag); n > 0; --n)
	79	fputc (' ', out);
	80	fputc ('\|', out);
	81	}
	82	}
	83
	84	void
	85	rule_lhs_print_xml (rule r, FILE out, int level)
	86	{
	87	xml_printf (out, level, "<lhs>%s</lhs>", r->lhs->tag);
	88	}
	89
	90	int
	91	rule_rhs_length (rule *r)
	92	{
	93	int res = 0;
	94	item_number *rhsp;
	95	for (rhsp = r->rhs; *rhsp >= 0; ++rhsp)
	96	++res;
	97	return res;
	98	}
	99
	100	void
	101	rule_rhs_print (rule r, FILE out)
	102	{
	103	if (*r->rhs >= 0)
	104	{
	105	item_number *rp;
	106	for (rp = r->rhs; *rp >= 0; rp++)
	107	fprintf (out, " %s", symbols[*rp]->tag);
	108	fputc ('\n', out);
	109	}
	110	else
	111	{
	112	fprintf (out, " /* %s */\n", _("empty"));
	113	}
	114	}
	115
	116	static void
	117	rule_rhs_print_xml (rule r, FILE out, int level)
	118	{
	119	if (*r->rhs >= 0)
	120	{
	121	item_number *rp;
	122	xml_puts (out, level, "<rhs>");
	123	for (rp = r->rhs; *rp >= 0; rp++)
	124	xml_printf (out, level + 1, "<symbol>%s</symbol>",
	125	xml_escape (symbols[*rp]->tag));
	126	xml_puts (out, level, "</rhs>");
	127	}
	128	else
	129	{
	130	xml_puts (out, level, "<rhs>");
	131	xml_puts (out, level + 1, "<empty/>");
	132	xml_puts (out, level, "</rhs>");
	133	}
	134	}
	135
	136	void
	137	rule_print (rule r, FILE out)
	138	{
	139	fprintf (out, "%s:", r->lhs->tag);
	140	rule_rhs_print (r, out);
	141	}
	142
	143	void
	144	ritem_print (FILE *out)
	145	{
	146	unsigned int i;
	147	fputs ("RITEM\n", out);
	148	for (i = 0; i < nritems; ++i)
	149	if (ritem[i] >= 0)
	150	fprintf (out, " %s", symbols[ritem[i]]->tag);
	151	else
	152	fprintf (out, " (rule %d)\n", item_number_as_rule_number (ritem[i]));
	153	fputs ("\n\n", out);
	154	}
	155
	156	size_t
	157	ritem_longest_rhs (void)
	158	{
	159	int max = 0;
	160	rule_number r;
	161
	162	for (r = 0; r < nrules; ++r)
	163	{
	164	int length = rule_rhs_length (&rules[r]);
	165	if (length > max)
	166	max = length;
	167	}
	168
	169	return max;
	170	}
	171
	172	void
	173	grammar_rules_partial_print (FILE out, const char title,
	174	rule_filter filter)
	175	{
	176	rule_number r;
	177	bool first = true;
	178	symbol *previous_lhs = NULL;
	179
	180	/* rule # : LHS -> RHS */
	181	for (r = 0; r < nrules + nuseless_productions; r++)
	182	{
	183	if (filter && !filter (&rules[r]))
	184	continue;
	185	if (first)
	186	fprintf (out, "%s\n\n", title);
	187	else if (previous_lhs && previous_lhs != rules[r].lhs)
	188	fputc ('\n', out);
	189	first = false;
	190	rule_lhs_print (&rules[r], previous_lhs, out);
	191	rule_rhs_print (&rules[r], out);
	192	previous_lhs = rules[r].lhs;
	193	}
	194	if (!first)
	195	fputs ("\n\n", out);
	196	}
	197
	198	void
	199	grammar_rules_print (FILE *out)
	200	{
	201	grammar_rules_partial_print (out, _("Grammar"), rule_useful_in_grammar_p);
	202	}
	203
	204	void
	205	grammar_rules_print_xml (FILE *out, int level)
	206	{
	207	rule_number r;
	208	bool first = true;
	209
	210	for (r = 0; r < nrules + nuseless_productions; r++)
	211	{
	212	if (first)
	213	xml_puts (out, level + 1, "<rules>");
	214	first = false;
	215	{
	216	char const *usefulness;
	217	if (rule_useless_in_grammar_p (&rules[r]))
	218	usefulness = "useless-in-grammar";
	219	else if (rule_useless_in_parser_p (&rules[r]))
	220	usefulness = "useless-in-parser";
	221	else
	222	usefulness = "useful";
	223	xml_indent (out, level + 2);
	224	fprintf (out, "<rule number=\"%d\" usefulness=\"%s\"",
	225	rules[r].number, usefulness);
	226	if (rules[r].precsym)
	227	fprintf (out, " percent_prec=\"%s\"",
	228	xml_escape (rules[r].precsym->tag));
	229	fputs (">\n", out);
	230	}
	231	rule_lhs_print_xml (&rules[r], out, level + 3);
	232	rule_rhs_print_xml (&rules[r], out, level + 3);
	233	xml_puts (out, level + 2, "</rule>");
	234	}
	235	if (!first)
	236	xml_puts (out, level + 1, "</rules>");
	237	else
	238	xml_puts (out, level + 1, "<rules/>");
	239	}
	240
	241	void
	242	grammar_dump (FILE out, const char title)
	243	{
	244	fprintf (out, "%s\n\n", title);
	245	fprintf (out,
	246	"ntokens = %d, nvars = %d, nsyms = %d, nrules = %d, nritems = %d\n\n",
	247	ntokens, nvars, nsyms, nrules, nritems);
	248
	249
	250	fprintf (out, "Variables\n---------\n\n");
	251	{
	252	symbol_number i;
	253	fprintf (out, "Value Sprec Sassoc Tag\n");
	254
	255	for (i = ntokens; i < nsyms; i++)
	256	fprintf (out, "%5d %5d %5d %s\n",
	257	i,
	258	symbols[i]->prec, symbols[i]->assoc,
	259	symbols[i]->tag);
	260	fprintf (out, "\n\n");
	261	}
	262
	263	fprintf (out, "Rules\n-----\n\n");
	264	{
	265	rule_number i;
	266	fprintf (out, "Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem range) [Num]\n");
	267	for (i = 0; i < nrules + nuseless_productions; i++)
	268	{
	269	rule *rule_i = &rules[i];
	270	item_number *rp = NULL;
	271	unsigned int rhs_itemno = rule_i->rhs - ritem;
	272	unsigned int rhs_count = 0;
	273	/* Find the last RHS index in ritems. */
	274	for (rp = rule_i->rhs; *rp >= 0; ++rp)
	275	++rhs_count;
	276	fprintf (out, "%3d (%2d, %2d, %2d, %2u-%2u) %2d ->",
	277	i,
	278	rule_i->prec ? rule_i->prec->prec : 0,
	279	rule_i->prec ? rule_i->prec->assoc : 0,
	280	rule_i->useful,
	281	rhs_itemno,
	282	rhs_itemno + rhs_count - 1,
	283	rule_i->lhs->number);
	284	/* Dumped the RHS. */
	285	for (rp = rule_i->rhs; *rp >= 0; rp++)
	286	fprintf (out, " %3d", *rp);
	287	fprintf (out, " [%d]\n", item_number_as_rule_number (*rp));
	288	}
	289	}
	290	fprintf (out, "\n\n");
	291
	292	fprintf (out, "Rules interpreted\n-----------------\n\n");
	293	{
	294	rule_number r;
	295	for (r = 0; r < nrules + nuseless_productions; r++)
	296	{
	297	fprintf (out, "%-5d ", r);
	298	rule_print (&rules[r], out);
	299	}
	300	}
	301	fprintf (out, "\n\n");
	302	}
	303
	304	void
	305	grammar_rules_useless_report (const char *message)
	306	{
	307	rule_number r;
	308	for (r = 0; r < nrules ; ++r)
	309	if (!rules[r].useful)
	310	{
	311	location_print (stderr, rules[r].location);
	312	fprintf (stderr, ": %s: %s: ", _("warning"), message);
	313	rule_print (&rules[r], stderr);
	314	}
	315	}
	316
	317	void
	318	grammar_free (void)
	319	{
	320	if (ritem)
	321	free (ritem - 1);
	322	free (rules);
	323	free (token_translations);
	324	/* Free the symbol table data structure. */
	325	symbols_free ();
	326	free_merger_functions ();
	327	}