src/files.c

/* Open and close files for Bison.

   Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002, 2003, 2004,
   2005, 2006, 2007 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 <error.h>
#include <dirname.h>
#include <get-errno.h>
#include <quote.h>
#include <stdio-safer.h>
#include <xstrndup.h>

#include "complain.h"
#include "files.h"
#include "getargs.h"
#include "gram.h"

/* Initializing some values below (such SPEC_NAME_PREFIX to `yy') is
   tempting, but don't do that: for the time being our handling of the
   %directive vs --option leaves precedence to the options by deciding
   that if a %directive sets a variable which is really set (i.e., not
   NULL), then the %directive is ignored.  As a result, %name-prefix,
   for instance, will not be honored.  */

char const *spec_outfile = NULL;       /* for -o. */
char const *spec_file_prefix = NULL;   /* for -b. */
char const *spec_name_prefix = NULL;   /* for -p. */
char *spec_verbose_file = NULL;  /* for --verbose. */
char *spec_graph_file = NULL;    /* for -g. */
char *spec_xml_file = NULL;      /* for -x. */
char *spec_defines_file = NULL;  /* for --defines. */
char *parser_file_name;

/* All computed output file names.  */
static char **file_names = NULL;
static int file_names_count = 0;

uniqstr grammar_file = NULL;
uniqstr current_file = NULL;

/* If --output=dir/foo.c was specified,
   DIR_PREFIX is `dir/' and ALL_BUT_EXT and ALL_BUT_TAB_EXT are `dir/foo'.

   If --output=dir/foo.tab.c was specified, DIR_PREFIX is `dir/',
   ALL_BUT_EXT is `dir/foo.tab', and ALL_BUT_TAB_EXT is `dir/foo'.

   If --output was not specified but --file-prefix=dir/foo was specified,
   ALL_BUT_EXT = `foo.tab' and ALL_BUT_TAB_EXT = `foo'.

   If neither --output nor --file was specified but the input grammar
   is name dir/foo.y, ALL_BUT_EXT and ALL_BUT_TAB_EXT are `foo'.

   If neither --output nor --file was specified, DIR_PREFIX is the
   empty string (meaning the current directory); otherwise it is
   `dir/'.  */

char *all_but_ext;
static char *all_but_tab_ext;
char *dir_prefix;

/* C source file extension (the parser source).  */
static char *src_extension = NULL;
/* Header file extension (if option ``-d'' is specified).  */
static char *header_extension = NULL;
\f
/*-----------------------------------------------------------------.
| Return a newly allocated string composed of the concatenation of |
| STR1, and STR2.                                                  |
`-----------------------------------------------------------------*/

static char *
concat2 (char const *str1, char const *str2)
{
  size_t len = strlen (str1) + strlen (str2);
  char *res = xmalloc (len + 1);
  char *cp;
  cp = stpcpy (res, str1);
  cp = stpcpy (cp, str2);
  return res;
}

/*-----------------------------------------------------------------.
| Try to open file NAME with mode MODE, and print an error message |
| if fails.                                                        |
`-----------------------------------------------------------------*/

FILE *
xfopen (const char *name, const char *mode)
{
  FILE *ptr;

  ptr = fopen_safer (name, mode);
  if (!ptr)
    error (EXIT_FAILURE, get_errno (), _("cannot open file `%s'"), name);

  return ptr;
}

/*-------------------------------------------------------------.
| Try to close file PTR, and print an error message if fails.  |
`-------------------------------------------------------------*/

void
xfclose (FILE *ptr)
{
  if (ptr == NULL)
    return;

  if (ferror (ptr))
    error (EXIT_FAILURE, 0, _("I/O error"));

  if (fclose (ptr) != 0)
    error (EXIT_FAILURE, get_errno (), _("cannot close file"));
}
\f

/*------------------------------------------------------------------.
| Compute ALL_BUT_EXT, ALL_BUT_TAB_EXT and output files extensions. |
`------------------------------------------------------------------*/

/* In the string S, replace all characters FROM by TO.  */
static void
tr (char *s, char from, char to)
{
  for (; *s; s++)
    if (*s == from)
      *s = to;
}

/* Compute extensions from the grammar file extension.  */
static void
compute_exts_from_gf (const char *ext)
{
  if (strcmp (ext, ".y") == 0)
    {
      src_extension = xstrdup (language->src_extension);
      header_extension = xstrdup (language->header_extension);
    }
  else
    {
      src_extension = xstrdup (ext);
      header_extension = xstrdup (ext);
      tr (src_extension, 'y', 'c');
      tr (src_extension, 'Y', 'C');
      tr (header_extension, 'y', 'h');
      tr (header_extension, 'Y', 'H');
    }
}

/* Compute extensions from the given c source file extension.  */
static void
compute_exts_from_src (const char *ext)
{
  /* We use this function when the user specifies `-o' or `--output',
     so the extenions must be computed unconditionally from the file name
     given by this option.  */
  src_extension = xstrdup (ext);
  header_extension = xstrdup (ext);
  tr (header_extension, 'c', 'h');
  tr (header_extension, 'C', 'H');
}


/* Decompose FILE_NAME in four parts: *BASE, *TAB, and *EXT, the fourth
   part, (the directory) is ranging from FILE_NAME to the char before
   *BASE, so we don't need an additional parameter.

   *EXT points to the last period in the basename, or NULL if none.

   If there is no *EXT, *TAB is NULL.  Otherwise, *TAB points to
   `.tab' or `_tab' if present right before *EXT, or is NULL. *TAB
   cannot be equal to *BASE.

   None are allocated, they are simply pointers to parts of FILE_NAME.
   Examples:

   '/tmp/foo.tab.c' -> *BASE = 'foo.tab.c', *TAB = '.tab.c', *EXT =
   '.c'

   'foo.c' -> *BASE = 'foo.c', *TAB = NULL, *EXT = '.c'

   'tab.c' -> *BASE = 'tab.c', *TAB = NULL, *EXT = '.c'

   '.tab.c' -> *BASE = '.tab.c', *TAB = NULL, *EXT = '.c'

   'foo.tab' -> *BASE = 'foo.tab', *TAB = NULL, *EXT = '.tab'

   'foo_tab' -> *BASE = 'foo_tab', *TAB = NULL, *EXT = NULL

   'foo' -> *BASE = 'foo', *TAB = NULL, *EXT = NULL.  */

static void
file_name_split (const char *file_name,
		 const char **base, const char **tab, const char **ext)
{
  *base = last_component (file_name);

  /* Look for the extension, i.e., look for the last dot. */
  *ext = strrchr (*base, '.');
  *tab = NULL;

  /* If there is an extension, check if there is a `.tab' part right
     before.  */
  if (*ext)
    {
      size_t baselen = *ext - *base;
      size_t dottablen = 4;
      if (dottablen < baselen
	  && (strncmp (*ext - dottablen, ".tab", dottablen) == 0
	      || strncmp (*ext - dottablen, "_tab", dottablen) == 0))
	*tab = *ext - dottablen;
    }
}


static void
compute_file_name_parts (void)
{
  const char *base, *tab, *ext;

  /* Compute ALL_BUT_EXT and ALL_BUT_TAB_EXT from SPEC_OUTFILE
     or GRAMMAR_FILE.

     The precise -o name will be used for FTABLE.  For other output
     files, remove the ".c" or ".tab.c" suffix.  */
  if (spec_outfile)
    {
      file_name_split (spec_outfile, &base, &tab, &ext);
      dir_prefix = xstrndup (spec_outfile, base - spec_outfile);

      /* ALL_BUT_EXT goes up the EXT, excluding it. */
      all_but_ext =
	xstrndup (spec_outfile,
		  (strlen (spec_outfile) - (ext ? strlen (ext) : 0)));

      /* ALL_BUT_TAB_EXT goes up to TAB, excluding it.  */
      all_but_tab_ext =
	xstrndup (spec_outfile,
		  (strlen (spec_outfile)
		   - (tab ? strlen (tab) : (ext ? strlen (ext) : 0))));

      if (ext)
	compute_exts_from_src (ext);
    }
  else
    {
      file_name_split (grammar_file, &base, &tab, &ext);

      if (spec_file_prefix)
	{
	  /* If --file-prefix=foo was specified, ALL_BUT_TAB_EXT = `foo'.  */
	  dir_prefix = xstrndup (grammar_file, base - grammar_file);
	  all_but_tab_ext = xstrdup (spec_file_prefix);
	}
      else if (yacc_flag)
	{
	  /* If --yacc, then the output is `y.tab.c'.  */
	  dir_prefix = xstrdup ("");
	  all_but_tab_ext = xstrdup ("y");
	}
      else
	{
	  /* Otherwise, ALL_BUT_TAB_EXT is computed from the input
	     grammar: `foo/bar.yy' => `bar'.  */
	  dir_prefix = xstrdup ("");
	  all_but_tab_ext =
	    xstrndup (base, (strlen (base) - (ext ? strlen (ext) : 0)));
	}

      if (language->add_tab)
        all_but_ext = concat2 (all_but_tab_ext, TAB_EXT);
      else
        all_but_ext = xstrdup (all_but_tab_ext);

      /* Compute the extensions from the grammar file name.  */
      if (ext && !yacc_flag)
	compute_exts_from_gf (ext);
    }
}


/* Compute the output file names.  Warn if we detect conflicting
   outputs to the same file.  */

void
compute_output_file_names (void)
{
  compute_file_name_parts ();

  /* If not yet done. */
  if (!src_extension)
    src_extension = xstrdup (".c");
  if (!header_extension)
    header_extension = xstrdup (".h");

  parser_file_name =
    (spec_outfile
     ? xstrdup (spec_outfile)
     : concat2 (all_but_ext, src_extension));

  if (defines_flag)
    {
      if (! spec_defines_file)
	spec_defines_file = concat2 (all_but_ext, header_extension);
    }

  if (graph_flag)
    {
      if (! spec_graph_file)
	spec_graph_file = concat2 (all_but_tab_ext, ".dot");
      output_file_name_check (spec_graph_file);
    }

  if (xml_flag)
    {
      if (! spec_xml_file)
	spec_xml_file = concat2 (all_but_tab_ext, ".xml");
      output_file_name_check (spec_xml_file);
    }

  if (report_flag)
    {
      spec_verbose_file = concat2 (all_but_tab_ext, OUTPUT_EXT);
      output_file_name_check (spec_verbose_file);
    }

  free (all_but_tab_ext);
  free (src_extension);
  free (header_extension);
}

void
output_file_name_check (char const *file_name)
{
  {
    int i;
    for (i = 0; i < file_names_count; i++)
      if (0 == strcmp (file_names[i], file_name))
        warn (_("conflicting outputs to file %s"), quote (file_name));
  }
  file_names = xnrealloc (file_names, ++file_names_count, sizeof *file_names);
  file_names[file_names_count-1] = xstrdup (file_name);
}

void
output_file_names_free (void)
{
  free (all_but_ext);
  free (spec_verbose_file);
  free (spec_graph_file);
  free (spec_xml_file);
  free (spec_defines_file);
  free (parser_file_name);
  free (dir_prefix);
  {
    int i;
    for (i = 0; i < file_names_count; i++)
      free (file_names[i]);
  }
  free (file_names);
}
Commit	Line	Data
	1	/* Open and close files for Bison.
	2
	3	Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002, 2003, 2004,
	4	2005, 2006, 2007 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 <error.h>
	25	#include <dirname.h>
	26	#include <get-errno.h>
	27	#include <quote.h>
	28	#include <stdio-safer.h>
	29	#include <xstrndup.h>
	30
	31	#include "complain.h"
	32	#include "files.h"
	33	#include "getargs.h"
	34	#include "gram.h"
	35
	36	/* Initializing some values below (such SPEC_NAME_PREFIX to `yy') is
	37	tempting, but don't do that: for the time being our handling of the
	38	%directive vs --option leaves precedence to the options by deciding
	39	that if a %directive sets a variable which is really set (i.e., not
	40	NULL), then the %directive is ignored. As a result, %name-prefix,
	41	for instance, will not be honored. */
	42
	43	char const spec_outfile = NULL; / for -o. */
	44	char const spec_file_prefix = NULL; / for -b. */
	45	char const spec_name_prefix = NULL; / for -p. */
	46	char spec_verbose_file = NULL; / for --verbose. */
	47	char spec_graph_file = NULL; / for -g. */
	48	char spec_xml_file = NULL; / for -x. */
	49	char spec_defines_file = NULL; / for --defines. */
	50	char *parser_file_name;
	51
	52	/* All computed output file names. */
	53	static char **file_names = NULL;
	54	static int file_names_count = 0;
	55
	56	uniqstr grammar_file = NULL;
	57	uniqstr current_file = NULL;
	58
	59	/* If --output=dir/foo.c was specified,
	60	DIR_PREFIX is `dir/' and ALL_BUT_EXT and ALL_BUT_TAB_EXT are `dir/foo'.
	61
	62	If --output=dir/foo.tab.c was specified, DIR_PREFIX is `dir/',
	63	ALL_BUT_EXT is `dir/foo.tab', and ALL_BUT_TAB_EXT is `dir/foo'.
	64
	65	If --output was not specified but --file-prefix=dir/foo was specified,
	66	ALL_BUT_EXT = `foo.tab' and ALL_BUT_TAB_EXT = `foo'.
	67
	68	If neither --output nor --file was specified but the input grammar
	69	is name dir/foo.y, ALL_BUT_EXT and ALL_BUT_TAB_EXT are `foo'.
	70
	71	If neither --output nor --file was specified, DIR_PREFIX is the
	72	empty string (meaning the current directory); otherwise it is
	73	`dir/'. */
	74
	75	char *all_but_ext;
	76	static char *all_but_tab_ext;
	77	char *dir_prefix;
	78
	79	/* C source file extension (the parser source). */
	80	static char *src_extension = NULL;
	81	/* Header file extension (if option ``-d'' is specified). */
	82	static char *header_extension = NULL;
	83	\f
	84	/*-----------------------------------------------------------------.
	85	\| Return a newly allocated string composed of the concatenation of \|
	86	\| STR1, and STR2. \|
	87	`-----------------------------------------------------------------*/
	88
	89	static char *
	90	concat2 (char const str1, char const str2)
	91	{
	92	size_t len = strlen (str1) + strlen (str2);
	93	char *res = xmalloc (len + 1);
	94	char *cp;
	95	cp = stpcpy (res, str1);
	96	cp = stpcpy (cp, str2);
	97	return res;
	98	}
	99
	100	/*-----------------------------------------------------------------.
	101	\| Try to open file NAME with mode MODE, and print an error message \|
	102	\| if fails. \|
	103	`-----------------------------------------------------------------*/
	104
	105	FILE *
	106	xfopen (const char name, const char mode)
	107	{
	108	FILE *ptr;
	109
	110	ptr = fopen_safer (name, mode);
	111	if (!ptr)
	112	error (EXIT_FAILURE, get_errno (), _("cannot open file `%s'"), name);
	113
	114	return ptr;
	115	}
	116
	117	/*-------------------------------------------------------------.
	118	\| Try to close file PTR, and print an error message if fails. \|
	119	`-------------------------------------------------------------*/
	120
	121	void
	122	xfclose (FILE *ptr)
	123	{
	124	if (ptr == NULL)
	125	return;
	126
	127	if (ferror (ptr))
	128	error (EXIT_FAILURE, 0, _("I/O error"));
	129
	130	if (fclose (ptr) != 0)
	131	error (EXIT_FAILURE, get_errno (), _("cannot close file"));
	132	}
	133	\f
	134
	135	/*------------------------------------------------------------------.
	136	\| Compute ALL_BUT_EXT, ALL_BUT_TAB_EXT and output files extensions. \|
	137	`------------------------------------------------------------------*/
	138
	139	/* In the string S, replace all characters FROM by TO. */
	140	static void
	141	tr (char *s, char from, char to)
	142	{
	143	for (; *s; s++)
	144	if (*s == from)
	145	*s = to;
	146	}
	147
	148	/* Compute extensions from the grammar file extension. */
	149	static void
	150	compute_exts_from_gf (const char *ext)
	151	{
	152	if (strcmp (ext, ".y") == 0)
	153	{
	154	src_extension = xstrdup (language->src_extension);
	155	header_extension = xstrdup (language->header_extension);
	156	}
	157	else
	158	{
	159	src_extension = xstrdup (ext);
	160	header_extension = xstrdup (ext);
	161	tr (src_extension, 'y', 'c');
	162	tr (src_extension, 'Y', 'C');
	163	tr (header_extension, 'y', 'h');
	164	tr (header_extension, 'Y', 'H');
	165	}
	166	}
	167
	168	/* Compute extensions from the given c source file extension. */
	169	static void
	170	compute_exts_from_src (const char *ext)
	171	{
	172	/* We use this function when the user specifies `-o' or `--output',
	173	so the extenions must be computed unconditionally from the file name
	174	given by this option. */
	175	src_extension = xstrdup (ext);
	176	header_extension = xstrdup (ext);
	177	tr (header_extension, 'c', 'h');
	178	tr (header_extension, 'C', 'H');
	179	}
	180
	181
	182	/* Decompose FILE_NAME in four parts: BASE, TAB, and *EXT, the fourth
	183	part, (the directory) is ranging from FILE_NAME to the char before
	184	*BASE, so we don't need an additional parameter.
	185
	186	*EXT points to the last period in the basename, or NULL if none.
	187
	188	If there is no EXT, TAB is NULL. Otherwise, *TAB points to
	189	`.tab' or `_tab' if present right before EXT, or is NULL. TAB
	190	cannot be equal to *BASE.
	191
	192	None are allocated, they are simply pointers to parts of FILE_NAME.
	193	Examples:
	194
	195	'/tmp/foo.tab.c' -> BASE = 'foo.tab.c', TAB = '.tab.c', *EXT =
	196	'.c'
	197
	198	'foo.c' -> BASE = 'foo.c', TAB = NULL, *EXT = '.c'
	199
	200	'tab.c' -> BASE = 'tab.c', TAB = NULL, *EXT = '.c'
	201
	202	'.tab.c' -> BASE = '.tab.c', TAB = NULL, *EXT = '.c'
	203
	204	'foo.tab' -> BASE = 'foo.tab', TAB = NULL, *EXT = '.tab'
	205
	206	'foo_tab' -> BASE = 'foo_tab', TAB = NULL, *EXT = NULL
	207
	208	'foo' -> BASE = 'foo', TAB = NULL, EXT = NULL. /
	209
	210	static void
	211	file_name_split (const char *file_name,
	212	const char base, const char tab, const char **ext)
	213	{
	214	*base = last_component (file_name);
	215
	216	/* Look for the extension, i.e., look for the last dot. */
	217	ext = strrchr (base, '.');
	218	*tab = NULL;
	219
	220	/* If there is an extension, check if there is a `.tab' part right
	221	before. */
	222	if (*ext)
	223	{
	224	size_t baselen = ext - base;
	225	size_t dottablen = 4;
	226	if (dottablen < baselen
	227	&& (strncmp (*ext - dottablen, ".tab", dottablen) == 0
	228	\|\| strncmp (*ext - dottablen, "_tab", dottablen) == 0))
	229	tab = ext - dottablen;
	230	}
	231	}
	232
	233
	234	static void
	235	compute_file_name_parts (void)
	236	{
	237	const char base, tab, *ext;
	238
	239	/* Compute ALL_BUT_EXT and ALL_BUT_TAB_EXT from SPEC_OUTFILE
	240	or GRAMMAR_FILE.
	241
	242	The precise -o name will be used for FTABLE. For other output
	243	files, remove the ".c" or ".tab.c" suffix. */
	244	if (spec_outfile)
	245	{
	246	file_name_split (spec_outfile, &base, &tab, &ext);
	247	dir_prefix = xstrndup (spec_outfile, base - spec_outfile);
	248
	249	/* ALL_BUT_EXT goes up the EXT, excluding it. */
	250	all_but_ext =
	251	xstrndup (spec_outfile,
	252	(strlen (spec_outfile) - (ext ? strlen (ext) : 0)));
	253
	254	/* ALL_BUT_TAB_EXT goes up to TAB, excluding it. */
	255	all_but_tab_ext =
	256	xstrndup (spec_outfile,
	257	(strlen (spec_outfile)
	258	- (tab ? strlen (tab) : (ext ? strlen (ext) : 0))));
	259
	260	if (ext)
	261	compute_exts_from_src (ext);
	262	}
	263	else
	264	{
	265	file_name_split (grammar_file, &base, &tab, &ext);
	266
	267	if (spec_file_prefix)
	268	{
	269	/* If --file-prefix=foo was specified, ALL_BUT_TAB_EXT = `foo'. */
	270	dir_prefix = xstrndup (grammar_file, base - grammar_file);
	271	all_but_tab_ext = xstrdup (spec_file_prefix);
	272	}
	273	else if (yacc_flag)
	274	{
	275	/* If --yacc, then the output is `y.tab.c'. */
	276	dir_prefix = xstrdup ("");
	277	all_but_tab_ext = xstrdup ("y");
	278	}
	279	else
	280	{
	281	/* Otherwise, ALL_BUT_TAB_EXT is computed from the input
	282	grammar: `foo/bar.yy' => `bar'. */
	283	dir_prefix = xstrdup ("");
	284	all_but_tab_ext =
	285	xstrndup (base, (strlen (base) - (ext ? strlen (ext) : 0)));
	286	}
	287
	288	if (language->add_tab)
	289	all_but_ext = concat2 (all_but_tab_ext, TAB_EXT);
	290	else
	291	all_but_ext = xstrdup (all_but_tab_ext);
	292
	293	/* Compute the extensions from the grammar file name. */
	294	if (ext && !yacc_flag)
	295	compute_exts_from_gf (ext);
	296	}
	297	}
	298
	299
	300	/* Compute the output file names. Warn if we detect conflicting
	301	outputs to the same file. */
	302
	303	void
	304	compute_output_file_names (void)
	305	{
	306	compute_file_name_parts ();
	307
	308	/* If not yet done. */
	309	if (!src_extension)
	310	src_extension = xstrdup (".c");
	311	if (!header_extension)
	312	header_extension = xstrdup (".h");
	313
	314	parser_file_name =
	315	(spec_outfile
	316	? xstrdup (spec_outfile)
	317	: concat2 (all_but_ext, src_extension));
	318
	319	if (defines_flag)
	320	{
	321	if (! spec_defines_file)
	322	spec_defines_file = concat2 (all_but_ext, header_extension);
	323	}
	324
	325	if (graph_flag)
	326	{
	327	if (! spec_graph_file)
	328	spec_graph_file = concat2 (all_but_tab_ext, ".dot");
	329	output_file_name_check (spec_graph_file);
	330	}
	331
	332	if (xml_flag)
	333	{
	334	if (! spec_xml_file)
	335	spec_xml_file = concat2 (all_but_tab_ext, ".xml");
	336	output_file_name_check (spec_xml_file);
	337	}
	338
	339	if (report_flag)
	340	{
	341	spec_verbose_file = concat2 (all_but_tab_ext, OUTPUT_EXT);
	342	output_file_name_check (spec_verbose_file);
	343	}
	344
	345	free (all_but_tab_ext);
	346	free (src_extension);
	347	free (header_extension);
	348	}
	349
	350	void
	351	output_file_name_check (char const *file_name)
	352	{
	353	{
	354	int i;
	355	for (i = 0; i < file_names_count; i++)
	356	if (0 == strcmp (file_names[i], file_name))
	357	warn (_("conflicting outputs to file %s"), quote (file_name));
	358	}
	359	file_names = xnrealloc (file_names, ++file_names_count, sizeof *file_names);
	360	file_names[file_names_count-1] = xstrdup (file_name);
	361	}
	362
	363	void
	364	output_file_names_free (void)
	365	{
	366	free (all_but_ext);
	367	free (spec_verbose_file);
	368	free (spec_graph_file);
	369	free (spec_xml_file);
	370	free (spec_defines_file);
	371	free (parser_file_name);
	372	free (dir_prefix);
	373	{
	374	int i;
	375	for (i = 0; i < file_names_count; i++)
	376	free (file_names[i]);
	377	}
	378	free (file_names);
	379	}