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 <config.h>
#include "system.h"

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

#include "complain.h"
#include "dirname.h"
#include "files.h"
#include "getargs.h"
#include "gram.h"
#include "stdio-safer.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 const *spec_verbose_file = NULL;  /* for --verbose. */
char const *spec_graph_file = NULL;    /* for -g. */
char const *spec_defines_file = NULL;  /* for --defines. */
char const *parser_file_name;

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/'.  */

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

/* 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 ALL_BUT_EXT, ALL_BUT_TAB_EXT 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_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 = "";
	  all_but_tab_ext = "y";
	}
      else
	{
	  /* Otherwise, ALL_BUT_TAB_EXT is computed from the input
	     grammar: `foo/bar.yy' => `bar'.  */
	  dir_prefix = "";
	  all_but_tab_ext =
	    xstrndup (base, (strlen (base) - (ext ? strlen (ext) : 0)));
	}

      all_but_ext = concat2 (all_but_tab_ext, 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)
{
  char const *name[4];
  int i;
  int j;
  int names = 0;

  compute_file_name_parts ();

  /* 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 (all_but_ext, src_extension);

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

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

  if (report_flag)
    {
      spec_verbose_file = concat2 (all_but_tab_ext, 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	#include <config.h>
	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 "dirname.h"
	33	#include "files.h"
	34	#include "getargs.h"
	35	#include "gram.h"
	36	#include "stdio-safer.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 const spec_verbose_file = NULL; / for --verbose. */
	52	char const spec_graph_file = NULL; / for -g. */
	53	char const spec_defines_file = NULL; / for --defines. */
	54	char const *parser_file_name;
	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	static char const *all_but_ext;
	76	static char const *all_but_tab_ext;
	77	char const *dir_prefix;
	78
	79	/* C source file extension (the parser source). */
	80	static char const *src_extension = NULL;
	81	/* Header file extension (if option ``-d'' is specified). */
	82	static char const *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	/* Replace all characters FROM by TO in the string IN.
	140	and returns a new allocated string. */
	141	static char *
	142	tr (const char *in, char from, char to)
	143	{
	144	char *temp;
	145	char *out = xmalloc (strlen (in) + 1);
	146
	147	for (temp = out; *in; in++, out++)
	148	if (*in == from)
	149	*out = to;
	150	else
	151	out = in;
	152	*out = 0;
	153	return (temp);
	154	}
	155
	156	/* Compute extensions from the grammar file extension. */
	157	static void
	158	compute_exts_from_gf (const char *ext)
	159	{
	160	src_extension = tr (ext, 'y', 'c');
	161	src_extension = tr (src_extension, 'Y', 'C');
	162	header_extension = tr (ext, 'y', 'h');
	163	header_extension = tr (header_extension, 'Y', 'H');
	164	}
	165
	166	/* Compute extensions from the given c source file extension. */
	167	static void
	168	compute_exts_from_src (const char *ext)
	169	{
	170	/* We use this function when the user specifies `-o' or `--output',
	171	so the extenions must be computed unconditionally from the file name
	172	given by this option. */
	173	src_extension = xstrdup (ext);
	174	header_extension = tr (ext, 'c', 'h');
	175	header_extension = tr (header_extension, 'C', 'H');
	176	}
	177
	178
	179	/* Decompose FILE_NAME in four parts: BASE, TAB, and *EXT, the fourth
	180	part, (the directory) is ranging from FILE_NAME to the char before
	181	*BASE, so we don't need an additional parameter.
	182
	183	*EXT points to the last period in the basename, or NULL if none.
	184
	185	If there is no EXT, TAB is NULL. Otherwise, *TAB points to
	186	`.tab' or `_tab' if present right before EXT, or is NULL. TAB
	187	cannot be equal to *BASE.
	188
	189	None are allocated, they are simply pointers to parts of FILE_NAME.
	190	Examples:
	191
	192	'/tmp/foo.tab.c' -> BASE = 'foo.tab.c', TAB = '.tab.c', *EXT =
	193	'.c'
	194
	195	'foo.c' -> BASE = 'foo.c', TAB = NULL, *EXT = '.c'
	196
	197	'tab.c' -> BASE = 'tab.c', TAB = NULL, *EXT = '.c'
	198
	199	'.tab.c' -> BASE = '.tab.c', TAB = NULL, *EXT = '.c'
	200
	201	'foo.tab' -> BASE = 'foo.tab', TAB = NULL, *EXT = '.tab'
	202
	203	'foo_tab' -> BASE = 'foo_tab', TAB = NULL, *EXT = NULL
	204
	205	'foo' -> BASE = 'foo', TAB = NULL, EXT = NULL. /
	206
	207	static void
	208	file_name_split (const char *file_name,
	209	const char base, const char tab, const char **ext)
	210	{
	211	*base = base_name (file_name);
	212
	213	/* Look for the extension, i.e., look for the last dot. */
	214	ext = strrchr (base, '.');
	215	*tab = NULL;
	216
	217	/* If there is an extension, check if there is a `.tab' part right
	218	before. */
	219	if (*ext)
	220	{
	221	size_t baselen = ext - base;
	222	size_t dottablen = 4;
	223	if (dottablen < baselen
	224	&& (strncmp (*ext - dottablen, ".tab", dottablen) == 0
	225	\|\| strncmp (*ext - dottablen, "_tab", dottablen) == 0))
	226	tab = ext - dottablen;
	227	}
	228	}
	229
	230
	231	static void
	232	compute_file_name_parts (void)
	233	{
	234	const char base, tab, *ext;
	235
	236	/* Compute ALL_BUT_EXT and ALL_BUT_TAB_EXT from SPEC_OUTFILE
	237	or GRAMMAR_FILE.
	238
	239	The precise -o name will be used for FTABLE. For other output
	240	files, remove the ".c" or ".tab.c" suffix. */
	241	if (spec_outfile)
	242	{
	243	file_name_split (spec_outfile, &base, &tab, &ext);
	244	dir_prefix = xstrndup (spec_outfile, base - spec_outfile);
	245
	246	/* ALL_BUT_EXT goes up the EXT, excluding it. */
	247	all_but_ext =
	248	xstrndup (spec_outfile,
	249	(strlen (spec_outfile) - (ext ? strlen (ext) : 0)));
	250
	251	/* ALL_BUT_TAB_EXT goes up to TAB, excluding it. */
	252	all_but_tab_ext =
	253	xstrndup (spec_outfile,
	254	(strlen (spec_outfile)
	255	- (tab ? strlen (tab) : (ext ? strlen (ext) : 0))));
	256
	257	if (ext)
	258	compute_exts_from_src (ext);
	259	}
	260	else
	261	{
	262	file_name_split (grammar_file, &base, &tab, &ext);
	263
	264	if (spec_file_prefix)
	265	{
	266	/* If --file-prefix=foo was specified, ALL_BUT_TAB_EXT = `foo'. */
	267	dir_prefix = xstrndup (grammar_file, base - grammar_file);
	268	all_but_tab_ext = xstrdup (spec_file_prefix);
	269	}
	270	else if (yacc_flag)
	271	{
	272	/* If --yacc, then the output is `y.tab.c'. */
	273	dir_prefix = "";
	274	all_but_tab_ext = "y";
	275	}
	276	else
	277	{
	278	/* Otherwise, ALL_BUT_TAB_EXT is computed from the input
	279	grammar: `foo/bar.yy' => `bar'. */
	280	dir_prefix = "";
	281	all_but_tab_ext =
	282	xstrndup (base, (strlen (base) - (ext ? strlen (ext) : 0)));
	283	}
	284
	285	all_but_ext = concat2 (all_but_tab_ext, TAB_EXT);
	286
	287	/* Compute the extensions from the grammar file name. */
	288	if (ext && !yacc_flag)
	289	compute_exts_from_gf (ext);
	290	}
	291	}
	292
	293
	294	/* Compute the output file names. Warn if we detect conflicting
	295	outputs to the same file. */
	296
	297	void
	298	compute_output_file_names (void)
	299	{
	300	char const *name[4];
	301	int i;
	302	int j;
	303	int names = 0;
	304
	305	compute_file_name_parts ();
	306
	307	/* If not yet done. */
	308	if (!src_extension)
	309	src_extension = ".c";
	310	if (!header_extension)
	311	header_extension = ".h";
	312
	313	name[names++] = parser_file_name =
	314	spec_outfile ? spec_outfile : concat2 (all_but_ext, src_extension);
	315
	316	if (defines_flag)
	317	{
	318	if (! spec_defines_file)
	319	spec_defines_file = concat2 (all_but_ext, header_extension);
	320	name[names++] = spec_defines_file;
	321	}
	322
	323	if (graph_flag)
	324	{
	325	if (! spec_graph_file)
	326	spec_graph_file = concat2 (all_but_tab_ext, ".vcg");
	327	name[names++] = spec_graph_file;
	328	}
	329
	330	if (report_flag)
	331	{
	332	spec_verbose_file = concat2 (all_but_tab_ext, OUTPUT_EXT);
	333	name[names++] = spec_verbose_file;
	334	}
	335
	336	for (j = 0; j < names; j++)
	337	for (i = 0; i < j; i++)
	338	if (strcmp (name[i], name[j]) == 0)
	339	warn (_("conflicting outputs to file %s"), quote (name[i]));
	340	}