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

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

   Copyright (C) 2007, 2009, 2010 Free Software Foundation, Inc.

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

   Bison 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 2, or (at your option)
   any later version.

   Bison 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 Bison; see the file COPYING.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.  */

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

#include <stdarg.h>

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