src/files.c

/* Open and close files for bison,
   Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002
   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 "getargs.h"
#include "files.h"
#include "gram.h"
#include "error.h"
#include "complain.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;

struniq_t grammar_file = NULL;
struniq_t 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

/*--------------------------.
| Is SUFFIX ending STRING?  |
`--------------------------*/

int
strsuffix (const char *string, const char *suffix)
{
  size_t string_len = strlen (string);
  size_t suffix_len = strlen (suffix);
  if (suffix_len <= string_len)
    return !strcmp (string + string_len - suffix_len, suffix);
  else
    return 0;
}


/*-----------------------------------------------------------------.
| Return a newly allocated string composed of the concatenation of |
| STRING1, and STRING2.                                            |
`-----------------------------------------------------------------*/

char*
stringappend (const char *string1, const char *string2)
{
  size_t len = strlen (string1) + strlen (string2);
  char *res = XMALLOC (char, len + 1);
  char *cp;
  cp = stpcpy (res, string1);
  cp = stpcpy (cp, string2);
  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, 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, errno, _("cannot close file"));
}
\f

/*----------------------------------------------------------------.
| Compute 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;

  out = XMALLOC (char, strlen (in) + 1);

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

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

/* Computes 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 exentension, check if there is a `.tab' part right
     before.  */
  if (*ext
      && (*ext - *base) > (int) strlen (".tab")
      && (!strncmp (*ext - strlen (".tab"), ".tab", strlen (".tab"))
	  || !strncmp (*ext - strlen ("_tab"), "_tab", strlen ("_tab"))))
    *tab = *ext - strlen (".tab");
}


/* 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),
     BASE_NAME and SHORT_BASE_NAME are `foo'.

     If --output=foo.tab.c was specified, 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 (char,
				strlen (short_base_name)
				+ strlen (EXT_TAB) + 1);
      stpcpy (stpcpy (full_base_name, short_base_name), EXT_TAB);

      /* Computes the extensions from the grammar file name.  */
      filename_split (grammar_file, &base, &tab, &ext);
      if (ext && !yacc_flag)
	compute_exts_from_gf (ext);
    }
}

/*-------------------------------------------------------.
| Close the open files, compute the output files names.  |
`-------------------------------------------------------*/

void
compute_output_file_names (void)
{
  compute_base_names ();

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

  parser_file_name =
    spec_outfile ? spec_outfile : stringappend (full_base_name, src_extension);

  /* It the defines filename if not given, we create it.  */
  if (!spec_defines_file)
    spec_defines_file = stringappend (full_base_name, header_extension);

  /* It the graph filename if not given, we create it.  */
  if (!spec_graph_file)
    spec_graph_file = stringappend (short_base_name, ".vcg");

  spec_verbose_file = stringappend (short_base_name, EXT_OUTPUT);
}
Commit	Line	Data
	1	/* Open and close files for bison,
	2	Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002
	3	Free Software Foundation, Inc.
	4
	5	This file is part of Bison, the GNU Compiler Compiler.
	6
	7	Bison is free software; you can redistribute it and/or modify it
	8	under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2, or (at your option)
	10	any later version.
	11
	12	Bison is distributed in the hope that it will be useful, but
	13	WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with Bison; see the file COPYING. If not, write to the Free
	19	Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
	20	02111-1307, USA. */
	21
	22
	23	#include "system.h"
	24	#include "getargs.h"
	25	#include "files.h"
	26	#include "gram.h"
	27	#include "error.h"
	28	#include "complain.h"
	29
	30	/* From basename.c. Almost a lie, as it returns a char . /
	31	const char base_name (char const name);
	32
	33	FILE *finput = NULL;
	34
	35	struct obstack pre_prologue_obstack;
	36	struct obstack post_prologue_obstack;
	37
	38	/* Initializing some values below (such SPEC_NAME_PREFIX to `yy') is
	39	tempting, but don't do that: for the time being our handling of the
	40	%directive vs --option leaves precedence to the options by deciding
	41	that if a %directive sets a variable which is really set (i.e., not
	42	NULL), then the %directive is ignored. As a result, %name-prefix,
	43	for instance, will not be honored. */
	44
	45	char spec_outfile = NULL; / for -o. */
	46	char spec_file_prefix = NULL; / for -b. */
	47	const char spec_name_prefix = NULL; / for -p. */
	48	char spec_verbose_file = NULL; / for --verbose. */
	49	char spec_graph_file = NULL; / for -g. */
	50	char spec_defines_file = NULL; / for --defines. */
	51	char *parser_file_name = NULL;
	52
	53	struniq_t grammar_file = NULL;
	54	struniq_t current_file = NULL;
	55
	56	static char *full_base_name = NULL;
	57
	58	/* Prefix used to generate output file names. */
	59	char *short_base_name = NULL;
	60
	61	/* C source file extension (the parser source). */
	62	const char *src_extension = NULL;
	63	/* Header file extension (if option ``-d'' is specified). */
	64	const char *header_extension = NULL;
	65	\f
	66
	67	/*--------------------------.
	68	\| Is SUFFIX ending STRING? \|
	69	`--------------------------*/
	70
	71	int
	72	strsuffix (const char string, const char suffix)
	73	{
	74	size_t string_len = strlen (string);
	75	size_t suffix_len = strlen (suffix);
	76	if (suffix_len <= string_len)
	77	return !strcmp (string + string_len - suffix_len, suffix);
	78	else
	79	return 0;
	80	}
	81
	82
	83	/*-----------------------------------------------------------------.
	84	\| Return a newly allocated string composed of the concatenation of \|
	85	\| STRING1, and STRING2. \|
	86	`-----------------------------------------------------------------*/
	87
	88	char*
	89	stringappend (const char string1, const char string2)
	90	{
	91	size_t len = strlen (string1) + strlen (string2);
	92	char *res = XMALLOC (char, len + 1);
	93	char *cp;
	94	cp = stpcpy (res, string1);
	95	cp = stpcpy (cp, string2);
	96	return res;
	97	}
	98
	99	/*-----------------------------------------------------------------.
	100	\| Try to open file NAME with mode MODE, and print an error message \|
	101	\| if fails. \|
	102	`-----------------------------------------------------------------*/
	103
	104	FILE *
	105	xfopen (const char name, const char mode)
	106	{
	107	FILE *ptr;
	108
	109	ptr = fopen (name, mode);
	110	if (!ptr)
	111	error (EXIT_FAILURE, errno, _("cannot open file `%s'"), name);
	112
	113	return ptr;
	114	}
	115
	116	/*-------------------------------------------------------------.
	117	\| Try to close file PTR, and print an error message if fails. \|
	118	`-------------------------------------------------------------*/
	119
	120	void
	121	xfclose (FILE *ptr)
	122	{
	123	if (ptr == NULL)
	124	return;
	125
	126	if (ferror (ptr))
	127	error (EXIT_FAILURE, 0, _("I/O error"));
	128
	129	if (fclose (ptr) != 0)
	130	error (EXIT_FAILURE, errno, _("cannot close file"));
	131	}
	132	\f
	133
	134	/*----------------------------------------------------------------.
	135	\| Compute BASE_NAME, SHORT_BASE_NAME and output files extensions. \|
	136	`----------------------------------------------------------------*/
	137
	138	/* Replace all characters FROM by TO in the string IN.
	139	and returns a new allocated string. */
	140	static char *
	141	tr (const char *in, char from, char to)
	142	{
	143	char *temp;
	144	char *out;
	145
	146	out = XMALLOC (char, strlen (in) + 1);
	147
	148	for (temp = out; *in; in++, out++)
	149	if (*in == from)
	150	*out = to;
	151	else
	152	out = in;
	153	*out = 0;
	154	return (temp);
	155	}
	156
	157	/* Computes extensions from the grammar file extension. */
	158	static void
	159	compute_exts_from_gf (const char *ext)
	160	{
	161	src_extension = tr (ext, 'y', 'c');
	162	src_extension = tr (src_extension, 'Y', 'C');
	163	header_extension = tr (ext, 'y', 'h');
	164	header_extension = tr (header_extension, 'Y', 'H');
	165	}
	166
	167	/* Computes extensions from the given c source file extension. */
	168	static void
	169	compute_exts_from_src (const char *ext)
	170	{
	171	/* We use this function when the user specifies `-o' or `--output',
	172	so the extenions must be computed unconditionally from the file name
	173	given by this option. */
	174	src_extension = xstrdup (ext);
	175	header_extension = tr (ext, 'c', 'h');
	176	header_extension = tr (header_extension, 'C', 'H');
	177	}
	178
	179
	180	/* Decompose FILENAME in four parts: BASE, TAB, and *EXT, the fourth
	181	part, (the directory) is ranging from FILENAME to the char before
	182	*BASE, so we don't need an additional parameter.
	183
	184	*EXT points to the last period in the basename, or NULL if none.
	185
	186	If there is no EXT, TAB is NULL. Otherwise, *TAB points to
	187	`.tab' or `_tab' if present right before EXT, or is NULL. TAB
	188	cannot be equal to *BASE.
	189
	190	None are allocated, they are simply pointers to parts of FILENAME.
	191	Examples:
	192
	193	'/tmp/foo.tab.c' -> BASE = 'foo.tab.c', TAB = '.tab.c', *EXT =
	194	'.c'
	195
	196	'foo.c' -> BASE = 'foo.c', TAB = NULL, *EXT = '.c'
	197
	198	'tab.c' -> BASE = 'tab.c', TAB = NULL, *EXT = '.c'
	199
	200	'.tab.c' -> BASE = '.tab.c', TAB = NULL, *EXT = '.c'
	201
	202	'foo.tab' -> BASE = 'foo.tab', TAB = NULL, *EXT = '.tab'
	203
	204	'foo_tab' -> BASE = 'foo_tab', TAB = NULL, *EXT = NULL
	205
	206	'foo' -> BASE = 'foo', TAB = NULL, EXT = NULL. /
	207
	208	static void
	209	filename_split (const char *filename,
	210	const char base, const char tab, const char **ext)
	211	{
	212	*base = base_name (filename);
	213
	214	/* Look for the extension, i.e., look for the last dot. */
	215	ext = strrchr (base, '.');
	216	*tab = NULL;
	217
	218	/* If there is an exentension, check if there is a `.tab' part right
	219	before. */
	220	if (*ext
	221	&& (ext - base) > (int) strlen (".tab")
	222	&& (!strncmp (*ext - strlen (".tab"), ".tab", strlen (".tab"))
	223	\|\| !strncmp (*ext - strlen ("_tab"), "_tab", strlen ("_tab"))))
	224	tab = ext - strlen (".tab");
	225	}
	226
	227
	228	/* FIXME: Should use xstrndup. */
	229
	230	static void
	231	compute_base_names (void)
	232	{
	233	const char base, tab, *ext;
	234
	235	/* If --output=foo.c was specified (SPEC_OUTFILE == foo.c),
	236	BASE_NAME and SHORT_BASE_NAME are `foo'.
	237
	238	If --output=foo.tab.c was specified, BASE_NAME is `foo.tab' and
	239	SHORT_BASE_NAME is `foo'.
	240
	241	The precise -o name will be used for FTABLE. For other output
	242	files, remove the ".c" or ".tab.c" suffix. */
	243	if (spec_outfile)
	244	{
	245	filename_split (spec_outfile, &base, &tab, &ext);
	246
	247	/* The full base name goes up the EXT, excluding it. */
	248	full_base_name =
	249	xstrndup (spec_outfile,
	250	(strlen (spec_outfile) - (ext ? strlen (ext) : 0)));
	251
	252	/* The short base name goes up to TAB, excluding it. */
	253	short_base_name =
	254	xstrndup (spec_outfile,
	255	(strlen (spec_outfile)
	256	- (tab ? strlen (tab) : (ext ? strlen (ext) : 0))));
	257
	258	if (ext)
	259	compute_exts_from_src (ext);
	260	}
	261
	262	/* If --file-prefix=foo was specified, FULL_BASE_NAME = `foo.tab'
	263	and SHORT_BASE_NAME = `foo'.
	264
	265	Construct names from it. */
	266	else
	267	{
	268	if (spec_file_prefix)
	269	{
	270	/* If --file-prefix=foo was specified, SHORT_BASE_NAME =
	271	`foo'. */
	272	short_base_name = xstrdup (spec_file_prefix);
	273	}
	274	else if (yacc_flag)
	275	{
	276	/* If --yacc, then the output is `y.tab.c'. */
	277	short_base_name = xstrdup ("y");
	278	}
	279	else
	280	{
	281	/* Otherwise, the short base name is computed from the input
	282	grammar: `foo/bar.yy' => `bar'. */
	283	filename_split (grammar_file, &base, &tab, &ext);
	284	short_base_name =
	285	xstrndup (base,
	286	(strlen (base) - (ext ? strlen (ext) : 0)));
	287	}
	288
	289	full_base_name = XMALLOC (char,
	290	strlen (short_base_name)
	291	+ strlen (EXT_TAB) + 1);
	292	stpcpy (stpcpy (full_base_name, short_base_name), EXT_TAB);
	293
	294	/* Computes the extensions from the grammar file name. */
	295	filename_split (grammar_file, &base, &tab, &ext);
	296	if (ext && !yacc_flag)
	297	compute_exts_from_gf (ext);
	298	}
	299	}
	300
	301	/*-------------------------------------------------------.
	302	\| Close the open files, compute the output files names. \|
	303	`-------------------------------------------------------*/
	304
	305	void
	306	compute_output_file_names (void)
	307	{
	308	compute_base_names ();
	309
	310	/* If not yet done. */
	311	if (!src_extension)
	312	src_extension = ".c";
	313	if (!header_extension)
	314	header_extension = ".h";
	315
	316	parser_file_name =
	317	spec_outfile ? spec_outfile : stringappend (full_base_name, src_extension);
	318
	319	/* It the defines filename if not given, we create it. */
	320	if (!spec_defines_file)
	321	spec_defines_file = stringappend (full_base_name, header_extension);
	322
	323	/* It the graph filename if not given, we create it. */
	324	if (!spec_graph_file)
	325	spec_graph_file = stringappend (short_base_name, ".vcg");
	326
	327	spec_verbose_file = stringappend (short_base_name, EXT_OUTPUT);
	328	}