src/files.c

/* Open and close files for Bison.

   Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002, 2003, 2004,
   2005, 2006 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 <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"

struct obstack pre_prologue_obstack;
struct obstack post_prologue_obstack;

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