src/files.c

/* Open and close files for Bison.

   Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002, 2003
   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., 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.  */


#include "system.h"

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

#include "complain.h"
#include "files.h"
#include "getargs.h"
#include "gram.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).  */
const char *src_extension = NULL;
/* Header file extension (if option ``-d'' is specified).  */
const 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 (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 FILENAME in four parts: *BASE, *TAB, and *EXT, the fourth
   part, (the directory) is ranging from FILENAME 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 FILENAME.
   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
filename_split (const char *filename,
		const char **base, const char **tab, const char **ext)
{
  *base = base_name (filename);

  /* 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;
    }
}


/* FIXME: Should use xstrndup. */

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)
    {
      filename_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'.  */
	  filename_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.  */
      filename_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
	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., 59 Temple Place - Suite 330, Boston, MA
	21	02111-1307, USA. */
	22
	23
	24	#include "system.h"
	25
	26	#include <error.h>
	27	#include <get-errno.h>
	28	#include <quote.h>
	29
	30	#include "complain.h"
	31	#include "files.h"
	32	#include "getargs.h"
	33	#include "gram.h"
	34
	35	/* From basename.c. Almost a lie, as it returns a char . /
	36	const char base_name (char const name);
	37
	38	FILE *finput = NULL;
	39
	40	struct obstack pre_prologue_obstack;
	41	struct obstack post_prologue_obstack;
	42
	43	/* Initializing some values below (such SPEC_NAME_PREFIX to `yy') is
	44	tempting, but don't do that: for the time being our handling of the
	45	%directive vs --option leaves precedence to the options by deciding
	46	that if a %directive sets a variable which is really set (i.e., not
	47	NULL), then the %directive is ignored. As a result, %name-prefix,
	48	for instance, will not be honored. */
	49
	50	char spec_outfile = NULL; / for -o. */
	51	char spec_file_prefix = NULL; / for -b. */
	52	const char spec_name_prefix = NULL; / for -p. */
	53	char spec_verbose_file = NULL; / for --verbose. */
	54	char spec_graph_file = NULL; / for -g. */
	55	char spec_defines_file = NULL; / for --defines. */
	56	char *parser_file_name = NULL;
	57
	58	uniqstr grammar_file = NULL;
	59	uniqstr current_file = NULL;
	60
	61	static char *full_base_name = NULL;
	62
	63	/* Prefix used to generate output file names. */
	64	char *short_base_name = NULL;
	65
	66	/* C source file extension (the parser source). */
	67	const char *src_extension = NULL;
	68	/* Header file extension (if option ``-d'' is specified). */
	69	const char *header_extension = NULL;
	70	\f
	71	/*-----------------------------------------------------------------.
	72	\| Return a newly allocated string composed of the concatenation of \|
	73	\| STR1, and STR2. \|
	74	`-----------------------------------------------------------------*/
	75
	76	static char *
	77	concat2 (char const str1, char const str2)
	78	{
	79	size_t len = strlen (str1) + strlen (str2);
	80	char *res = xmalloc (len + 1);
	81	char *cp;
	82	cp = stpcpy (res, str1);
	83	cp = stpcpy (cp, str2);
	84	return res;
	85	}
	86
	87	/*-----------------------------------------------------------------.
	88	\| Try to open file NAME with mode MODE, and print an error message \|
	89	\| if fails. \|
	90	`-----------------------------------------------------------------*/
	91
	92	FILE *
	93	xfopen (const char name, const char mode)
	94	{
	95	FILE *ptr;
	96
	97	ptr = fopen (name, mode);
	98	if (!ptr)
	99	error (EXIT_FAILURE, get_errno (), _("cannot open file `%s'"), name);
	100
	101	return ptr;
	102	}
	103
	104	/*-------------------------------------------------------------.
	105	\| Try to close file PTR, and print an error message if fails. \|
	106	`-------------------------------------------------------------*/
	107
	108	void
	109	xfclose (FILE *ptr)
	110	{
	111	if (ptr == NULL)
	112	return;
	113
	114	if (ferror (ptr))
	115	error (EXIT_FAILURE, 0, _("I/O error"));
	116
	117	if (fclose (ptr) != 0)
	118	error (EXIT_FAILURE, get_errno (), _("cannot close file"));
	119	}
	120	\f
	121
	122	/*---------------------------------------------------------------------.
	123	\| Compute FULL_BASE_NAME, SHORT_BASE_NAME and output files extensions. \|
	124	`---------------------------------------------------------------------*/
	125
	126	/* Replace all characters FROM by TO in the string IN.
	127	and returns a new allocated string. */
	128	static char *
	129	tr (const char *in, char from, char to)
	130	{
	131	char *temp;
	132	char *out = xmalloc (strlen (in) + 1);
	133
	134	for (temp = out; *in; in++, out++)
	135	if (*in == from)
	136	*out = to;
	137	else
	138	out = in;
	139	*out = 0;
	140	return (temp);
	141	}
	142
	143	/* Compute extensions from the grammar file extension. */
	144	static void
	145	compute_exts_from_gf (const char *ext)
	146	{
	147	src_extension = tr (ext, 'y', 'c');
	148	src_extension = tr (src_extension, 'Y', 'C');
	149	header_extension = tr (ext, 'y', 'h');
	150	header_extension = tr (header_extension, 'Y', 'H');
	151	}
	152
	153	/* Compute extensions from the given c source file extension. */
	154	static void
	155	compute_exts_from_src (const char *ext)
	156	{
	157	/* We use this function when the user specifies `-o' or `--output',
	158	so the extenions must be computed unconditionally from the file name
	159	given by this option. */
	160	src_extension = xstrdup (ext);
	161	header_extension = tr (ext, 'c', 'h');
	162	header_extension = tr (header_extension, 'C', 'H');
	163	}
	164
	165
	166	/* Decompose FILENAME in four parts: BASE, TAB, and *EXT, the fourth
	167	part, (the directory) is ranging from FILENAME to the char before
	168	*BASE, so we don't need an additional parameter.
	169
	170	*EXT points to the last period in the basename, or NULL if none.
	171
	172	If there is no EXT, TAB is NULL. Otherwise, *TAB points to
	173	`.tab' or `_tab' if present right before EXT, or is NULL. TAB
	174	cannot be equal to *BASE.
	175
	176	None are allocated, they are simply pointers to parts of FILENAME.
	177	Examples:
	178
	179	'/tmp/foo.tab.c' -> BASE = 'foo.tab.c', TAB = '.tab.c', *EXT =
	180	'.c'
	181
	182	'foo.c' -> BASE = 'foo.c', TAB = NULL, *EXT = '.c'
	183
	184	'tab.c' -> BASE = 'tab.c', TAB = NULL, *EXT = '.c'
	185
	186	'.tab.c' -> BASE = '.tab.c', TAB = NULL, *EXT = '.c'
	187
	188	'foo.tab' -> BASE = 'foo.tab', TAB = NULL, *EXT = '.tab'
	189
	190	'foo_tab' -> BASE = 'foo_tab', TAB = NULL, *EXT = NULL
	191
	192	'foo' -> BASE = 'foo', TAB = NULL, EXT = NULL. /
	193
	194	static void
	195	filename_split (const char *filename,
	196	const char base, const char tab, const char **ext)
	197	{
	198	*base = base_name (filename);
	199
	200	/* Look for the extension, i.e., look for the last dot. */
	201	ext = strrchr (base, '.');
	202	*tab = NULL;
	203
	204	/* If there is an extension, check if there is a `.tab' part right
	205	before. */
	206	if (*ext)
	207	{
	208	size_t baselen = ext - base;
	209	size_t dottablen = 4;
	210	if (dottablen < baselen
	211	&& (strncmp (*ext - dottablen, ".tab", dottablen) == 0
	212	\|\| strncmp (*ext - dottablen, "_tab", dottablen) == 0))
	213	tab = ext - dottablen;
	214	}
	215	}
	216
	217
	218	/* FIXME: Should use xstrndup. */
	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	filename_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	filename_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	filename_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	}