[bison.git] / src / print-xml.c

/* Print an xml on generated parser, for Bison,

   Copyright (C) 2007, 2009-2012 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 <stdarg.h>

#include <bitset.h>

#include "LR0.h"
#include "closure.h"
#include "conflicts.h"
#include "files.h"
#include "getargs.h"
#include "gram.h"
#include "lalr.h"
#include "print.h"
#include "print-xml.h"
#include "reader.h"
#include "reduce.h"
#include "state.h"
#include "symtab.h"
#include "tables.h"

static bitset no_reduce_set;
struct escape_buf
{
  char *ptr;
  size_t size;
};
static struct escape_buf escape_bufs[3];


/*--------------------------------.
| Report information on a state.  |
`--------------------------------*/

static void
print_core (FILE *out, int level, state *s)
{
  size_t i;
  item_number *sitems = s->items;
  size_t snritems = s->nitems;

  /* Output all the items of a state, not only its kernel.  */
  closure (sitems, snritems);
  sitems = itemset;
  snritems = nitemset;

  if (!snritems) {
    xml_puts (out, level, "<itemset/>");
    return;
  }

  xml_puts (out, level, "<itemset>");

  for (i = 0; i < snritems; i++)
    {
      bool printed = false;
      item_number *sp;
      item_number *sp1;
      rule_number r;

      sp1 = sp = ritem + sitems[i];

      while (*sp >= 0)
	sp++;

      r = item_number_as_rule_number (*sp);
      sp = rules[r].rhs;

      /* Display the lookahead tokens?  */
      if (item_number_is_rule_number (*sp1))
	{
	  reductions *reds = s->reductions;
	  int red = state_reduction_find (s, &rules[r]);
	  /* Print item with lookaheads if there are. */
	  if (reds->lookahead_tokens && red != -1)
	    {
	      xml_printf (out, level + 1,
			  "<item rule-number=\"%d\" point=\"%d\">",
			  rules[r].number, sp1 - sp);
	      state_rule_lookahead_tokens_print_xml (s, &rules[r],
						     out, level + 2);
	      xml_puts (out, level + 1, "</item>");
	      printed = true;
	    }
	}

      if (!printed)
	{
	  xml_printf (out, level + 1,
		      "<item rule-number=\"%d\" point=\"%d\"/>",
		      rules[r].number,
		      sp1 - sp);
	}
    }
  xml_puts (out, level, "</itemset>");
}


/*-----------------------------------------------------------.
| Report the shifts if DISPLAY_SHIFTS_P or the gotos of S on |
| OUT.                                                       |
`-----------------------------------------------------------*/

static void
print_transitions (state *s, FILE *out, int level)
{
  transitions *trans = s->transitions;
  int n = 0;
  int i;

  for (i = 0; i < trans->num; i++)
    if (!TRANSITION_IS_DISABLED (trans, i))
      {
	n++;
      }

  /* Nothing to report. */
  if (!n) {
    xml_puts (out, level, "<transitions/>");
    return;
  }

  /* Report lookahead tokens and shifts.  */
  xml_puts (out, level, "<transitions>");

  for (i = 0; i < trans->num; i++)
    if (!TRANSITION_IS_DISABLED (trans, i)
	&& TRANSITION_IS_SHIFT (trans, i))
      {
	symbol *sym = symbols[TRANSITION_SYMBOL (trans, i)];
	char const *tag = sym->tag;
	state *s1 = trans->states[i];

	xml_printf (out, level + 1,
		    "<transition type=\"shift\" symbol=\"%s\" state=\"%d\"/>",
		    xml_escape (tag), s1->number);
      }

  for (i = 0; i < trans->num; i++)
    if (!TRANSITION_IS_DISABLED (trans, i)
	&& !TRANSITION_IS_SHIFT (trans, i))
      {
	symbol *sym = symbols[TRANSITION_SYMBOL (trans, i)];
	char const *tag = sym->tag;
	state *s1 = trans->states[i];

	xml_printf (out, level + 1,
		    "<transition type=\"goto\" symbol=\"%s\" state=\"%d\"/>",
		    xml_escape (tag), s1->number);
      }

  xml_puts (out, level, "</transitions>");
}


/*--------------------------------------------------------.
| Report the explicit errors of S raised from %nonassoc.  |
`--------------------------------------------------------*/

static void
print_errs (FILE *out, int level, state *s)
{
  errs *errp = s->errs;
  bool count = false;
  int i;

  for (i = 0; i < errp->num; ++i)
    if (errp->symbols[i])
      count = true;

  /* Nothing to report. */
  if (!count) {
    xml_puts (out, level, "<errors/>");
    return;
  }

  /* Report lookahead tokens and errors.  */
  xml_puts (out, level, "<errors>");
  for (i = 0; i < errp->num; ++i)
    if (errp->symbols[i])
      {
	char const *tag = errp->symbols[i]->tag;
	xml_printf (out, level + 1,
		    "<error symbol=\"%s\">nonassociative</error>",
		    xml_escape (tag));
      }
  xml_puts (out, level, "</errors>");
}


/*-------------------------------------------------------------------------.
| Report a reduction of RULE on LOOKAHEAD_TOKEN (which can be `default').  |
| If not ENABLED, the rule is masked by a shift or a reduce (S/R and       |
| R/R conflicts).                                                          |
`-------------------------------------------------------------------------*/

static void
print_reduction (FILE *out, int level, char const *lookahead_token,
		 rule *r, bool enabled)
{
  if (r->number)
    xml_printf (out, level,
		"<reduction symbol=\"%s\" rule=\"%d\" enabled=\"%s\"/>",
		xml_escape (lookahead_token),
		r->number,
		enabled ? "true" : "false");
  else
    xml_printf (out, level,
		"<reduction symbol=\"%s\" rule=\"accept\" enabled=\"%s\"/>",
		xml_escape (lookahead_token),
		enabled ? "true" : "false");
}


/*-------------------------------------------.
| Report on OUT the reduction actions of S.  |
`-------------------------------------------*/

static void
print_reductions (FILE *out, int level, state *s)
{
  transitions *trans = s->transitions;
  reductions *reds = s->reductions;
  rule *default_reduction = NULL;
  int report = false;
  int i, j;

  if (reds->num == 0)
    {
      xml_puts (out, level, "<reductions/>");
      return;
    }

  if (yydefact[s->number] != 0)
    default_reduction = &rules[yydefact[s->number] - 1];

  bitset_zero (no_reduce_set);
  FOR_EACH_SHIFT (trans, i)
    bitset_set (no_reduce_set, TRANSITION_SYMBOL (trans, i));
  for (i = 0; i < s->errs->num; ++i)
    if (s->errs->symbols[i])
      bitset_set (no_reduce_set, s->errs->symbols[i]->number);

  if (default_reduction)
    report = true;

  if (reds->lookahead_tokens)
    for (i = 0; i < ntokens; i++)
      {
	bool count = bitset_test (no_reduce_set, i);

	for (j = 0; j < reds->num; ++j)
	  if (bitset_test (reds->lookahead_tokens[j], i))
	    {
	      if (! count)
		{
		  if (reds->rules[j] != default_reduction)
		    report = true;
		  count = true;
		}
	      else
		{
		  report = true;
		}
	    }
      }

  /* Nothing to report. */
  if (!report) {
    xml_puts (out, level, "<reductions/>");
    return;
  }

  xml_puts (out, level, "<reductions>");

  /* Report lookahead tokens (or $default) and reductions.  */
  if (reds->lookahead_tokens)
    for (i = 0; i < ntokens; i++)
      {
	bool defaulted = false;
	bool count = bitset_test (no_reduce_set, i);

	for (j = 0; j < reds->num; ++j)
	  if (bitset_test (reds->lookahead_tokens[j], i))
	    {
	      if (! count)
		{
		  if (reds->rules[j] != default_reduction)
		    print_reduction (out, level + 1, symbols[i]->tag,
				     reds->rules[j], true);
		  else
		    defaulted = true;
		  count = true;
		}
	      else
		{
		  if (defaulted)
		    print_reduction (out, level + 1, symbols[i]->tag,
				     default_reduction, true);
		  defaulted = false;
		  print_reduction (out, level + 1, symbols[i]->tag,
				   reds->rules[j], false);
		}
	    }
      }

  if (default_reduction)
    print_reduction (out, level + 1,
		     "$default", default_reduction, true);

  xml_puts (out, level, "</reductions>");
}


/*--------------------------------------------------------------.
| Report on OUT all the actions (shifts, gotos, reductions, and |
| explicit erros from %nonassoc) of S.                          |
`--------------------------------------------------------------*/

static void
print_actions (FILE *out, int level, state *s)
{
  xml_puts (out, level, "<actions>");
  print_transitions (s, out, level + 1);
  print_errs (out, level + 1, s);
  print_reductions (out, level + 1, s);
  xml_puts (out, level, "</actions>");
}


/*----------------------------------.
| Report all the data on S on OUT.  |
`----------------------------------*/

static void
print_state (FILE *out, int level, state *s)
{
  fputc ('\n', out);
  xml_printf (out, level, "<state number=\"%d\">", s->number);
  print_core (out, level + 1, s);
  print_actions (out, level + 1, s);
  if (s->solved_conflicts_xml)
    {
      xml_puts (out, level + 1, "<solved-conflicts>");
      fputs (s->solved_conflicts_xml, out);
      xml_puts (out, level + 1, "</solved-conflicts>");
    }
  else
    xml_puts (out, level + 1, "<solved-conflicts/>");
  xml_puts (out, level, "</state>");
}


/*-----------------------------------------.
| Print information on the whole grammar.  |
`-----------------------------------------*/

static void
print_grammar (FILE *out, int level)
{
  symbol_number i;

  fputc ('\n', out);
  xml_puts (out, level, "<grammar>");
  grammar_rules_print_xml (out, level);

  /* Terminals */
  xml_puts (out, level + 1, "<terminals>");
  for (i = 0; i < max_user_token_number + 1; i++)
    if (token_translations[i] != undeftoken->number)
      {
	char const *tag = symbols[token_translations[i]]->tag;
        int precedence = symbols[token_translations[i]]->prec;
        assoc associativity = symbols[token_translations[i]]->assoc;
        xml_indent (out, level + 2);
        fprintf (out,
                 "<terminal symbol-number=\"%d\" token-number=\"%d\""
                 " name=\"%s\" usefulness=\"%s\"",
                 token_translations[i], i, xml_escape (tag),
                 reduce_token_unused_in_grammar (token_translations[i])
                   ? "unused-in-grammar" : "useful");
        if (precedence)
          fprintf (out, " prec=\"%d\"", precedence);
        if (associativity != undef_assoc)
          fprintf (out, " assoc=\"%s\"", assoc_to_string (associativity) + 1);
        fputs ("/>\n", out);
      }
  xml_puts (out, level + 1, "</terminals>");

  /* Nonterminals */
  xml_puts (out, level + 1, "<nonterminals>");
  for (i = ntokens; i < nsyms + nuseless_nonterminals; i++)
    {
      char const *tag = symbols[i]->tag;
      xml_printf (out, level + 2,
		  "<nonterminal symbol-number=\"%d\" name=\"%s\""
                  " usefulness=\"%s\"/>",
		  i, xml_escape (tag),
                  reduce_nonterminal_useless_in_grammar (i)
                    ? "useless-in-grammar" : "useful");
    }
  xml_puts (out, level + 1, "</nonterminals>");
  xml_puts (out, level, "</grammar>");
}

void
xml_indent (FILE *out, int level)
{
  int i;
  for (i = 0; i < level; i++)
    fputs ("  ", out);
}

void
xml_puts (FILE *out, int level, char const *s)
{
  xml_indent (out, level);
  fputs (s, out);
  fputc ('\n', out);
}

void
xml_printf (FILE *out, int level, char const *fmt, ...)
{
  va_list arglist;

  xml_indent (out, level);

  va_start (arglist, fmt);
  vfprintf (out, fmt, arglist);
  va_end (arglist);

  fputc ('\n', out);
}

static char const *
xml_escape_string (struct escape_buf *buf, char const *str)
{
  size_t len = strlen (str);
  size_t max_expansion = sizeof "&quot;" - 1;
  char *p;

  if (buf->size <= max_expansion * len)
    {
      buf->size = max_expansion * len + 1;
      buf->ptr = x2realloc (buf->ptr, &buf->size);
    }
  p = buf->ptr;

  for (; *str; str++)
    switch (*str)
      {
      default: *p++ = *str; break;
      case '&': p = stpcpy (p, "&amp;" ); break;
      case '<': p = stpcpy (p, "&lt;"  ); break;
      case '>': p = stpcpy (p, "&gt;"  ); break;
      case '"': p = stpcpy (p, "&quot;"); break;
      }

  *p = '\0';
  return buf->ptr;
}

char const *
xml_escape_n (int n, char const *str)
{
  return xml_escape_string (escape_bufs + n, str);
}

char const *
xml_escape (char const *str)
{
  return xml_escape_n (0, str);
}

void
print_xml (void)
{
  state_number i;
  int level = 0;

  FILE *out = xfopen (spec_xml_file, "w");

  fputs ("<?xml version=\"1.0\"?>\n\n", out);
  xml_printf (out, level,
              "<bison-xml-report version=\"%s\" bug-report=\"%s\""
              " url=\"%s\">",
              xml_escape_n (0, VERSION),
              xml_escape_n (1, PACKAGE_BUGREPORT),
              xml_escape_n (2, PACKAGE_URL));

  fputc ('\n', out);
  xml_printf (out, level + 1, "<filename>%s</filename>",
	      xml_escape (grammar_file));

  /* print grammar */
  print_grammar (out, level + 1);

  new_closure (nritems);
  no_reduce_set =  bitset_create (ntokens, BITSET_FIXED);

  /* print automaton */
  fputc ('\n', out);
  xml_puts (out, level + 1, "<automaton>");
  for (i = 0; i < nstates; i++)
    print_state (out, level + 2, states[i]);
  xml_puts (out, level + 1, "</automaton>");

  bitset_free (no_reduce_set);
  free_closure ();

  xml_puts (out, 0, "</bison-xml-report>");

  free (escape_bufs[0].ptr);
  free (escape_bufs[1].ptr);

  xfclose (out);
}
Commit	Line	Data
41d7a5f2 PE	1	/* Print an xml on generated parser, for Bison,
41d7a5f2 PE	2
c932d613	3	Copyright (C) 2007, 2009-2012 Free Software Foundation, Inc.
41d7a5f2 PE	4
	5	This file is part of Bison, the GNU Compiler Compiler.
	6
fea2d6b0	7	This program is free software: you can redistribute it and/or modify
41d7a5f2	8	it under the terms of the GNU General Public License as published by
fea2d6b0 JD	9	the Free Software Foundation, either version 3 of the License, or
fea2d6b0 JD	10	(at your option) any later version.
41d7a5f2	11
fea2d6b0	12	This program is distributed in the hope that it will be useful,
41d7a5f2 PE	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
fea2d6b0	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
41d7a5f2 PE	19
	20	#include <config.h>
	21	#include "system.h"
	22
	23	#include <stdarg.h>
	24
	25	#include <bitset.h>
41d7a5f2 PE	26
	27	#include "LR0.h"
	28	#include "closure.h"
	29	#include "conflicts.h"
	30	#include "files.h"
	31	#include "getargs.h"
	32	#include "gram.h"
	33	#include "lalr.h"
	34	#include "print.h"
	35	#include "print-xml.h"
	36	#include "reader.h"
	37	#include "reduce.h"
	38	#include "state.h"
	39	#include "symtab.h"
	40	#include "tables.h"
	41
	42	static bitset no_reduce_set;
34cdeddf JD	43	struct escape_buf
	44	{
	45	char *ptr;
	46	size_t size;
	47	};
ca7a59e8	48	static struct escape_buf escape_bufs[3];
41d7a5f2 PE	49
41d7a5f2 PE	50
41d7a5f2 PE	51	/*--------------------------------.
	52	\| Report information on a state. \|
	53	`--------------------------------*/
	54
	55	static void
	56	print_core (FILE out, int level, state s)
	57	{
	58	size_t i;
	59	item_number *sitems = s->items;
	60	size_t snritems = s->nitems;
	61
	62	/* Output all the items of a state, not only its kernel. */
ef1b4273 JD	63	closure (sitems, snritems);
	64	sitems = itemset;
	65	snritems = nitemset;
41d7a5f2 PE	66
	67	if (!snritems) {
	68	xml_puts (out, level, "<itemset/>");
	69	return;
	70	}
	71
	72	xml_puts (out, level, "<itemset>");
	73
	74	for (i = 0; i < snritems; i++)
	75	{
25f6da67	76	bool printed = false;
41d7a5f2 PE	77	item_number *sp;
	78	item_number *sp1;
	79	rule_number r;
	80
	81	sp1 = sp = ritem + sitems[i];
	82
	83	while (*sp >= 0)
	84	sp++;
	85
	86	r = item_number_as_rule_number (*sp);
25f6da67	87	sp = rules[r].rhs;
41d7a5f2 PE	88
41d7a5f2 PE	89	/* Display the lookahead tokens? */
ef1b4273	90	if (item_number_is_rule_number (*sp1))
25f6da67 WP	91	{
	92	reductions *reds = s->reductions;
	93	int red = state_reduction_find (s, &rules[r]);
	94	/* Print item with lookaheads if there are. */
	95	if (reds->lookahead_tokens && red != -1)
	96	{
	97	xml_printf (out, level + 1,
	98	"<item rule-number=\"%d\" point=\"%d\">",
	99	rules[r].number, sp1 - sp);
	100	state_rule_lookahead_tokens_print_xml (s, &rules[r],
	101	out, level + 2);
	102	xml_puts (out, level + 1, "</item>");
	103	printed = true;
	104	}
	105	}
41d7a5f2	106
25f6da67 WP	107	if (!printed)
	108	{
	109	xml_printf (out, level + 1,
	110	"<item rule-number=\"%d\" point=\"%d\"/>",
	111	rules[r].number,
	112	sp1 - sp);
	113	}
41d7a5f2 PE	114	}
	115	xml_puts (out, level, "</itemset>");
	116	}
	117
	118
	119	/*-----------------------------------------------------------.
	120	\| Report the shifts if DISPLAY_SHIFTS_P or the gotos of S on \|
	121	\| OUT. \|
	122	`-----------------------------------------------------------*/
	123
	124	static void
	125	print_transitions (state s, FILE out, int level)
	126	{
	127	transitions *trans = s->transitions;
	128	int n = 0;
	129	int i;
	130
	131	for (i = 0; i < trans->num; i++)
	132	if (!TRANSITION_IS_DISABLED (trans, i))
	133	{
	134	n++;
	135	}
	136
	137	/* Nothing to report. */
	138	if (!n) {
	139	xml_puts (out, level, "<transitions/>");
	140	return;
	141	}
	142
	143	/* Report lookahead tokens and shifts. */
	144	xml_puts (out, level, "<transitions>");
	145
	146	for (i = 0; i < trans->num; i++)
	147	if (!TRANSITION_IS_DISABLED (trans, i)
	148	&& TRANSITION_IS_SHIFT (trans, i))
	149	{
	150	symbol *sym = symbols[TRANSITION_SYMBOL (trans, i)];
	151	char const *tag = sym->tag;
	152	state *s1 = trans->states[i];
	153
	154	xml_printf (out, level + 1,
	155	"<transition type=\"shift\" symbol=\"%s\" state=\"%d\"/>",
	156	xml_escape (tag), s1->number);
	157	}
	158
	159	for (i = 0; i < trans->num; i++)
	160	if (!TRANSITION_IS_DISABLED (trans, i)
	161	&& !TRANSITION_IS_SHIFT (trans, i))
	162	{
	163	symbol *sym = symbols[TRANSITION_SYMBOL (trans, i)];
	164	char const *tag = sym->tag;
	165	state *s1 = trans->states[i];
	166
	167	xml_printf (out, level + 1,
	168	"<transition type=\"goto\" symbol=\"%s\" state=\"%d\"/>",
	169	xml_escape (tag), s1->number);
	170	}
	171
	172	xml_puts (out, level, "</transitions>");
	173	}
	174
	175
	176	/*--------------------------------------------------------.
	177	\| Report the explicit errors of S raised from %nonassoc. \|
178	`--------------------------------------------------------*/
179
180	static void
181	print_errs (FILE out, int level, state s)
182	{
183	errs *errp = s->errs;
184	bool count = false;
185	int i;
186
187	for (i = 0; i < errp->num; ++i)
188	if (errp->symbols[i])
189	count = true;
190
191	/* Nothing to report. */
192	if (!count) {
193	xml_puts (out, level, "<errors/>");
194	return;
195	}
196
197	/* Report lookahead tokens and errors. */
198	xml_puts (out, level, "<errors>");
199	for (i = 0; i < errp->num; ++i)
200	if (errp->symbols[i])
201	{
202	char const *tag = errp->symbols[i]->tag;
203	xml_printf (out, level + 1,
204	"<error symbol=\"%s\">nonassociative</error>",
205	xml_escape (tag));
206	}
207	xml_puts (out, level, "</errors>");
208	}
209
210
211	/*-------------------------------------------------------------------------.
212	\| Report a reduction of RULE on LOOKAHEAD_TOKEN (which can be `default'). \|
213	\| If not ENABLED, the rule is masked by a shift or a reduce (S/R and \|
214	\| R/R conflicts). \|
215	`-------------------------------------------------------------------------*/
216
217	static void
218	print_reduction (FILE out, int level, char const lookahead_token,
219	rule *r, bool enabled)
220	{
221	if (r->number)
222	xml_printf (out, level,
223	"<reduction symbol=\"%s\" rule=\"%d\" enabled=\"%s\"/>",
224	xml_escape (lookahead_token),
225	r->number,
226	enabled ? "true" : "false");
227	else
228	xml_printf (out, level,
229	"<reduction symbol=\"%s\" rule=\"accept\" enabled=\"%s\"/>",
230	xml_escape (lookahead_token),
231	enabled ? "true" : "false");
232	}
233
234
235	/*-------------------------------------------.
236	\| Report on OUT the reduction actions of S. \|
237	`-------------------------------------------*/
238
239	static void
240	print_reductions (FILE out, int level, state s)
241	{
242	transitions *trans = s->transitions;
243	reductions *reds = s->reductions;
620b5727	244	rule *default_reduction = NULL;
41d7a5f2 PE	245	int report = false;
	246	int i, j;
	247
83b66ddd AD	248	if (reds->num == 0)
	249	{
	250	xml_puts (out, level, "<reductions/>");
	251	return;
	252	}
41d7a5f2 PE	253
41d7a5f2 PE	254	if (yydefact[s->number] != 0)
620b5727	255	default_reduction = &rules[yydefact[s->number] - 1];
41d7a5f2 PE	256
	257	bitset_zero (no_reduce_set);
	258	FOR_EACH_SHIFT (trans, i)
	259	bitset_set (no_reduce_set, TRANSITION_SYMBOL (trans, i));
	260	for (i = 0; i < s->errs->num; ++i)
	261	if (s->errs->symbols[i])
	262	bitset_set (no_reduce_set, s->errs->symbols[i]->number);
	263
620b5727	264	if (default_reduction)
41d7a5f2 PE	265	report = true;
	266
	267	if (reds->lookahead_tokens)
	268	for (i = 0; i < ntokens; i++)
	269	{
	270	bool count = bitset_test (no_reduce_set, i);
	271
	272	for (j = 0; j < reds->num; ++j)
	273	if (bitset_test (reds->lookahead_tokens[j], i))
	274	{
	275	if (! count)
	276	{
620b5727	277	if (reds->rules[j] != default_reduction)
41d7a5f2 PE	278	report = true;
	279	count = true;
	280	}
	281	else
	282	{
	283	report = true;
	284	}
	285	}
	286	}
	287
	288	/* Nothing to report. */
	289	if (!report) {
	290	xml_puts (out, level, "<reductions/>");
	291	return;
	292	}
	293
	294	xml_puts (out, level, "<reductions>");
	295
	296	/* Report lookahead tokens (or $default) and reductions. */
	297	if (reds->lookahead_tokens)
	298	for (i = 0; i < ntokens; i++)
	299	{
	300	bool defaulted = false;
	301	bool count = bitset_test (no_reduce_set, i);
	302
	303	for (j = 0; j < reds->num; ++j)
	304	if (bitset_test (reds->lookahead_tokens[j], i))
	305	{
	306	if (! count)
	307	{
620b5727	308	if (reds->rules[j] != default_reduction)
41d7a5f2 PE	309	print_reduction (out, level + 1, symbols[i]->tag,
	310	reds->rules[j], true);
	311	else
	312	defaulted = true;
	313	count = true;
	314	}
	315	else
	316	{
	317	if (defaulted)
	318	print_reduction (out, level + 1, symbols[i]->tag,
620b5727	319	default_reduction, true);
41d7a5f2 PE	320	defaulted = false;
	321	print_reduction (out, level + 1, symbols[i]->tag,
	322	reds->rules[j], false);
	323	}
	324	}
	325	}
	326
620b5727	327	if (default_reduction)
41d7a5f2	328	print_reduction (out, level + 1,
620b5727	329	"$default", default_reduction, true);
41d7a5f2 PE	330
	331	xml_puts (out, level, "</reductions>");
	332	}
	333
	334
	335	/*--------------------------------------------------------------.
	336	\| Report on OUT all the actions (shifts, gotos, reductions, and \|
	337	\| explicit erros from %nonassoc) of S. \|
	338	`--------------------------------------------------------------*/
	339
	340	static void
	341	print_actions (FILE out, int level, state s)
	342	{
	343	xml_puts (out, level, "<actions>");
	344	print_transitions (s, out, level + 1);
	345	print_errs (out, level + 1, s);
	346	print_reductions (out, level + 1, s);
	347	xml_puts (out, level, "</actions>");
	348	}
	349
	350
	351	/*----------------------------------.
	352	\| Report all the data on S on OUT. \|
	353	`----------------------------------*/
	354
	355	static void
	356	print_state (FILE out, int level, state s)
	357	{
	358	fputc ('\n', out);
	359	xml_printf (out, level, "<state number=\"%d\">", s->number);
	360	print_core (out, level + 1, s);
	361	print_actions (out, level + 1, s);
ef1b4273	362	if (s->solved_conflicts_xml)
41d7a5f2 PE	363	{
	364	xml_puts (out, level + 1, "<solved-conflicts>");
	365	fputs (s->solved_conflicts_xml, out);
	366	xml_puts (out, level + 1, "</solved-conflicts>");
	367	}
	368	else
	369	xml_puts (out, level + 1, "<solved-conflicts/>");
	370	xml_puts (out, level, "</state>");
	371	}
	372
	373
	374	/*-----------------------------------------.
	375	\| Print information on the whole grammar. \|
	376	`-----------------------------------------*/
	377
	378	static void
	379	print_grammar (FILE *out, int level)
	380	{
	381	symbol_number i;
	382
	383	fputc ('\n', out);
	384	xml_puts (out, level, "<grammar>");
	385	grammar_rules_print_xml (out, level);
	386
	387	/* Terminals */
	388	xml_puts (out, level + 1, "<terminals>");
	389	for (i = 0; i < max_user_token_number + 1; i++)
	390	if (token_translations[i] != undeftoken->number)
	391	{
	392	char const *tag = symbols[token_translations[i]]->tag;
408476bc JD	393	int precedence = symbols[token_translations[i]]->prec;
	394	assoc associativity = symbols[token_translations[i]]->assoc;
	395	xml_indent (out, level + 2);
	396	fprintf (out,
	397	"<terminal symbol-number=\"%d\" token-number=\"%d\""
	398	" name=\"%s\" usefulness=\"%s\"",
	399	token_translations[i], i, xml_escape (tag),
	400	reduce_token_unused_in_grammar (token_translations[i])
	401	? "unused-in-grammar" : "useful");
	402	if (precedence)
	403	fprintf (out, " prec=\"%d\"", precedence);
	404	if (associativity != undef_assoc)
	405	fprintf (out, " assoc=\"%s\"", assoc_to_string (associativity) + 1);
	406	fputs ("/>\n", out);
41d7a5f2 PE	407	}
	408	xml_puts (out, level + 1, "</terminals>");
	409
	410	/* Nonterminals */
	411	xml_puts (out, level + 1, "<nonterminals>");
d80fb37a	412	for (i = ntokens; i < nsyms + nuseless_nonterminals; i++)
41d7a5f2	413	{
41d7a5f2	414	char const *tag = symbols[i]->tag;
41d7a5f2	415	xml_printf (out, level + 2,
d80fb37a	416	"<nonterminal symbol-number=\"%d\" name=\"%s\""
d4a26c48	417	" usefulness=\"%s\"/>",
d80fb37a JD	418	i, xml_escape (tag),
	419	reduce_nonterminal_useless_in_grammar (i)
	420	? "useless-in-grammar" : "useful");
41d7a5f2 PE	421	}
	422	xml_puts (out, level + 1, "</nonterminals>");
	423	xml_puts (out, level, "</grammar>");
	424	}
	425
	426	void
408476bc	427	xml_indent (FILE *out, int level)
41d7a5f2 PE	428	{
41d7a5f2 PE	429	int i;
41d7a5f2	430	for (i = 0; i < level; i++)
a4f75309	431	fputs (" ", out);
408476bc JD	432	}
	433
	434	void
	435	xml_puts (FILE out, int level, char const s)
	436	{
	437	xml_indent (out, level);
41d7a5f2 PE	438	fputs (s, out);
	439	fputc ('\n', out);
	440	}
	441
	442	void
	443	xml_printf (FILE out, int level, char const fmt, ...)
	444	{
41d7a5f2 PE	445	va_list arglist;
41d7a5f2 PE	446
408476bc	447	xml_indent (out, level);
41d7a5f2 PE	448
	449	va_start (arglist, fmt);
	450	vfprintf (out, fmt, arglist);
	451	va_end (arglist);
	452
	453	fputc ('\n', out);
	454	}
	455
41d7a5f2 PE	456	static char const *
	457	xml_escape_string (struct escape_buf buf, char const str)
	458	{
	459	size_t len = strlen (str);
	460	size_t max_expansion = sizeof """ - 1;
	461	char *p;
	462
	463	if (buf->size <= max_expansion * len)
	464	{
	465	buf->size = max_expansion * len + 1;
	466	buf->ptr = x2realloc (buf->ptr, &buf->size);
	467	}
	468	p = buf->ptr;
	469
	470	for (; *str; str++)
	471	switch (*str)
	472	{
	473	default: p++ = str; break;
	474	case '&': p = stpcpy (p, "&" ); break;
	475	case '<': p = stpcpy (p, "<" ); break;
	476	case '>': p = stpcpy (p, ">" ); break;
	477	case '"': p = stpcpy (p, """); break;
	478	}
	479
	480	*p = '\0';
	481	return buf->ptr;
	482	}
	483
	484	char const *
	485	xml_escape_n (int n, char const *str)
	486	{
34cdeddf	487	return xml_escape_string (escape_bufs + n, str);
41d7a5f2 PE	488	}
	489
	490	char const *
	491	xml_escape (char const *str)
	492	{
	493	return xml_escape_n (0, str);
	494	}
	495
	496	void
	497	print_xml (void)
	498	{
	499	state_number i;
	500	int level = 0;
	501
	502	FILE *out = xfopen (spec_xml_file, "w");
	503
	504	fputs ("<?xml version=\"1.0\"?>\n\n", out);
ca7a59e8 JD	505	xml_printf (out, level,
	506	"<bison-xml-report version=\"%s\" bug-report=\"%s\""
	507	" url=\"%s\">",
	508	xml_escape_n (0, VERSION),
	509	xml_escape_n (1, PACKAGE_BUGREPORT),
	510	xml_escape_n (2, PACKAGE_URL));
41d7a5f2 PE	511
	512	fputc ('\n', out);
	513	xml_printf (out, level + 1, "<filename>%s</filename>",
	514	xml_escape (grammar_file));
	515
41d7a5f2 PE	516	/* print grammar */
	517	print_grammar (out, level + 1);
	518
ef1b4273	519	new_closure (nritems);
41d7a5f2 PE	520	no_reduce_set = bitset_create (ntokens, BITSET_FIXED);
	521
	522	/* print automaton */
	523	fputc ('\n', out);
	524	xml_puts (out, level + 1, "<automaton>");
	525	for (i = 0; i < nstates; i++)
	526	print_state (out, level + 2, states[i]);
	527	xml_puts (out, level + 1, "</automaton>");
	528
	529	bitset_free (no_reduce_set);
ef1b4273	530	free_closure ();
41d7a5f2 PE	531
	532	xml_puts (out, 0, "</bison-xml-report>");
	533
34cdeddf JD	534	free (escape_bufs[0].ptr);
	535	free (escape_bufs[1].ptr);
	536
41d7a5f2 PE	537	xfclose (out);
41d7a5f2 PE	538	}