src/files.c

/* Open and close files for Bison.

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

#include <error.h>
#include <get-errno.h>
#include <quote.h>
#include <xstrndup.h>

#include "complain.h"
#include "files.h"
#include "getargs.h"
#include "gram.h"
#include "stdio-safer.h"

/* From basename.c.  Almost a lie, as it returns a char *. */
const char *base_name (char const *name);

FILE *finput = NULL;

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 *spec_outfile = NULL;	/* for -o. */
char *spec_file_prefix = NULL;	/* for -b. */
const char *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 = NULL;

uniqstr grammar_file = NULL;
uniqstr current_file = NULL;

static char *full_base_name = NULL;

/* Prefix used to generate output file names.  */
char *short_base_name = NULL;

/* C source file extension (the parser source).  */
static char const *src_extension = NULL;
/* Header file extension (if option ``-d'' is specified).  */
static char const *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 FULL_BASE_NAME, SHORT_BASE_NAME and output files extensions. |
`---------------------------------------------------------------------*/

/* Replace all characters FROM by TO in the string IN.
   and returns a new allocated string.  */
static char *
tr (const char *in, char from, char to)
{
  char *temp;
  char *out = xmalloc (strlen (in) + 1);

  for (temp = out; *in; in++, out++)
    if (*in == from)
      *out = to;
    else
      *out = *in;
  *out = 0;
  return (temp);
}

/* Compute extensions from the grammar file extension.  */
static void
compute_exts_from_gf (const char *ext)
{
  src_extension = tr (ext, 'y', 'c');
  src_extension = tr (src_extension, 'Y', 'C');
  header_extension = tr (ext, 'y', 'h');
  header_extension = 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 = tr (ext, 'c', 'h');
  header_extension = 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 = base_name (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_base_names (void)
{
  const char *base, *tab, *ext;

  /* If --output=foo.c was specified (SPEC_OUTFILE == foo.c),
     FULL_BASE_NAME and SHORT_BASE_NAME are `foo'.

     If --output=foo.tab.c was specified, FULL_BASE_NAME is `foo.tab'
     and SHORT_BASE_NAME is `foo'.

     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);

      /* The full base name goes up the EXT, excluding it. */
      full_base_name =
	xstrndup (spec_outfile,
		  (strlen (spec_outfile) - (ext ? strlen (ext) : 0)));

      /* The short base name goes up to TAB, excluding it.  */
      short_base_name =
	xstrndup (spec_outfile,
		  (strlen (spec_outfile)
		   - (tab ? strlen (tab) : (ext ? strlen (ext) : 0))));

      if (ext)
	compute_exts_from_src (ext);
    }

  /* If --file-prefix=foo was specified, FULL_BASE_NAME = `foo.tab'
     and SHORT_BASE_NAME = `foo'.

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

      full_base_name = xmalloc (strlen (short_base_name)
				+ strlen (TAB_EXT) + 1);
      stpcpy (stpcpy (full_base_name, short_base_name), TAB_EXT);

      /* Compute the extensions from the grammar file name.  */
      file_name_split (grammar_file, &base, &tab, &ext);
      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)
{
  char const *name[4];
  int i;
  int j;
  int names = 0;

  compute_base_names ();

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

  name[names++] = parser_file_name =
    spec_outfile ? spec_outfile : concat2 (full_base_name, src_extension);

  if (defines_flag)
    {
      if (! spec_defines_file)
	spec_defines_file = concat2 (full_base_name, header_extension);
      name[names++] = spec_defines_file;
    }

  if (graph_flag)
    {
      if (! spec_graph_file)
	spec_graph_file = concat2 (short_base_name, ".vcg");
      name[names++] = spec_graph_file;
    }

  if (report_flag)
    {
      spec_verbose_file = concat2 (short_base_name, OUTPUT_EXT);
      name[names++] = spec_verbose_file;
    }

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