src/files.c

/* Open and close files for Bison.

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