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 PARAMS ((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;

char *infile = NULL;

static char *full_base_name = NULL;

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

/* Infix used to generate output file names (i.e., `.tab', or `_tab',
   or `').  */
char *output_infix = 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 (2, errno, _("cannot open file `%s'"), name);

  return ptr;
}

/*-------------------------------------------------------------.
| Try to close file PTR, and print an error message if fails.  |
`-------------------------------------------------------------*/

int
xfclose (FILE *ptr)
{
  int result;

  if (ptr == NULL)
    return 0;

  result = fclose (ptr);
  if (result == EOF)
    error (2, errno, _("cannot close file"));

  return result;
}
\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 (tab)
	output_infix = xstrndup (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 (infile, &base, &tab, &ext);
	  short_base_name =
	    xstrndup (base,
		      (strlen (base) - (ext ? strlen (ext) : 0)));
	}

      /* In these cases, always append `.tab'. */
      output_infix = xstrdup (EXT_TAB);

      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 (infile, &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 PARAMS ((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	char *infile = NULL;
	54
	55	static char *full_base_name = NULL;
	56
	57	/* Prefix used to generate output file names. */
	58	char *short_base_name = NULL;
	59
	60	/* Infix used to generate output file names (i.e., `.tab', or `_tab',
	61	or `'). */
	62	char *output_infix = NULL;
	63
	64	/* C source file extension (the parser source). */
	65	const char *src_extension = NULL;
	66	/* Header file extension (if option ``-d'' is specified). */
	67	const char *header_extension = NULL;
	68	\f
	69
	70	/*--------------------------.
	71	\| Is SUFFIX ending STRING? \|
	72	`--------------------------*/
	73
	74	int
	75	strsuffix (const char string, const char suffix)
	76	{
	77	size_t string_len = strlen (string);
	78	size_t suffix_len = strlen (suffix);
	79	if (suffix_len <= string_len)
	80	return !strcmp (string + string_len - suffix_len, suffix);
	81	else
	82	return 0;
	83	}
	84
	85
	86	/*-----------------------------------------------------------------.
	87	\| Return a newly allocated string composed of the concatenation of \|
	88	\| STRING1, and STRING2. \|
	89	`-----------------------------------------------------------------*/
	90
	91	char*
	92	stringappend (const char string1, const char string2)
	93	{
	94	size_t len = strlen (string1) + strlen (string2);
	95	char *res = XMALLOC (char, len + 1);
	96	char *cp;
	97	cp = stpcpy (res, string1);
	98	cp = stpcpy (cp, string2);
	99	return res;
	100	}
	101
	102	/*-----------------------------------------------------------------.
	103	\| Try to open file NAME with mode MODE, and print an error message \|
	104	\| if fails. \|
	105	`-----------------------------------------------------------------*/
	106
	107	FILE *
	108	xfopen (const char name, const char mode)
	109	{
	110	FILE *ptr;
	111
	112	ptr = fopen (name, mode);
	113	if (!ptr)
	114	error (2, errno, _("cannot open file `%s'"), name);
	115
	116	return ptr;
	117	}
	118
	119	/*-------------------------------------------------------------.
	120	\| Try to close file PTR, and print an error message if fails. \|
	121	`-------------------------------------------------------------*/
	122
	123	int
	124	xfclose (FILE *ptr)
	125	{
	126	int result;
	127
	128	if (ptr == NULL)
	129	return 0;
	130
	131	result = fclose (ptr);
	132	if (result == EOF)
	133	error (2, errno, _("cannot close file"));
	134
	135	return result;
	136	}
	137	\f
	138
	139	/*----------------------------------------------------------------.
	140	\| Compute BASE_NAME, SHORT_BASE_NAME and output files extensions. \|
	141	`----------------------------------------------------------------*/
	142
	143	/* Replace all characters FROM by TO in the string IN.
	144	and returns a new allocated string. */
	145	static char *
	146	tr (const char *in, char from, char to)
	147	{
	148	char *temp;
	149	char *out;
	150
	151	out = XMALLOC (char, strlen (in) + 1);
	152
	153	for (temp = out; *in; in++, out++)
	154	if (*in == from)
	155	*out = to;
	156	else
	157	out = in;
	158	*out = 0;
	159	return (temp);
	160	}
	161
	162	/* Computes extensions from the grammar file extension. */
	163	static void
	164	compute_exts_from_gf (const char *ext)
	165	{
	166	src_extension = tr (ext, 'y', 'c');
	167	src_extension = tr (src_extension, 'Y', 'C');
	168	header_extension = tr (ext, 'y', 'h');
	169	header_extension = tr (header_extension, 'Y', 'H');
	170	}
	171
	172	/* Computes extensions from the given c source file extension. */
	173	static void
	174	compute_exts_from_src (const char *ext)
	175	{
	176	/* We use this function when the user specifies `-o' or `--output',
	177	so the extenions must be computed unconditionally from the file name
	178	given by this option. */
	179	src_extension = xstrdup (ext);
	180	header_extension = tr (ext, 'c', 'h');
	181	header_extension = tr (header_extension, 'C', 'H');
	182	}
	183
	184
	185	/* Decompose FILENAME in four parts: BASE, TAB, and *EXT, the fourth
	186	part, (the directory) is ranging from FILENAME to the char before
	187	*BASE, so we don't need an additional parameter.
	188
	189	*EXT points to the last period in the basename, or NULL if none.
	190
	191	If there is no EXT, TAB is NULL. Otherwise, *TAB points to
	192	`.tab' or `_tab' if present right before EXT, or is NULL. TAB
	193	cannot be equal to *BASE.
	194
	195	None are allocated, they are simply pointers to parts of FILENAME.
	196	Examples:
	197
	198	'/tmp/foo.tab.c' -> BASE = 'foo.tab.c', TAB = '.tab.c', *EXT =
	199	'.c'
	200
	201	'foo.c' -> BASE = 'foo.c', TAB = NULL, *EXT = '.c'
	202
	203	'tab.c' -> BASE = 'tab.c', TAB = NULL, *EXT = '.c'
	204
	205	'.tab.c' -> BASE = '.tab.c', TAB = NULL, *EXT = '.c'
	206
	207	'foo.tab' -> BASE = 'foo.tab', TAB = NULL, *EXT = '.tab'
	208
	209	'foo_tab' -> BASE = 'foo_tab', TAB = NULL, *EXT = NULL
	210
	211	'foo' -> BASE = 'foo', TAB = NULL, EXT = NULL. /
	212
	213	static void
	214	filename_split (const char *filename,
	215	const char base, const char tab, const char **ext)
	216	{
	217	*base = base_name (filename);
	218
	219	/* Look for the extension, i.e., look for the last dot. */
	220	ext = strrchr (base, '.');
	221	*tab = NULL;
	222
	223	/* If there is an exentension, check if there is a `.tab' part right
	224	before. */
	225	if (*ext
	226	&& (ext - base) > (int) strlen (".tab")
	227	&& (!strncmp (*ext - strlen (".tab"), ".tab", strlen (".tab"))
	228	\|\| !strncmp (*ext - strlen ("_tab"), "_tab", strlen ("_tab"))))
	229	tab = ext - strlen (".tab");
	230	}
	231
	232
	233	/* FIXME: Should use xstrndup. */
	234
	235	static void
	236	compute_base_names (void)
	237	{
	238	const char base, tab, *ext;
	239
	240	/* If --output=foo.c was specified (SPEC_OUTFILE == foo.c),
	241	BASE_NAME and SHORT_BASE_NAME are `foo'.
	242
	243	If --output=foo.tab.c was specified, BASE_NAME is `foo.tab' and
	244	SHORT_BASE_NAME is `foo'.
	245
	246	The precise -o name will be used for FTABLE. For other output
	247	files, remove the ".c" or ".tab.c" suffix. */
	248	if (spec_outfile)
	249	{
	250	filename_split (spec_outfile, &base, &tab, &ext);
	251
	252	/* The full base name goes up the EXT, excluding it. */
	253	full_base_name =
	254	xstrndup (spec_outfile,
	255	(strlen (spec_outfile) - (ext ? strlen (ext) : 0)));
	256
	257	/* The short base name goes up to TAB, excluding it. */
	258	short_base_name =
	259	xstrndup (spec_outfile,
	260	(strlen (spec_outfile)
	261	- (tab ? strlen (tab) : (ext ? strlen (ext) : 0))));
	262
	263	if (tab)
	264	output_infix = xstrndup (tab,
	265	(strlen (tab) - (ext ? strlen (ext) : 0)));
	266
	267	if (ext)
	268	compute_exts_from_src (ext);
	269	}
	270
	271	/* If --file-prefix=foo was specified, FULL_BASE_NAME = `foo.tab'
	272	and SHORT_BASE_NAME = `foo'.
	273
	274	Construct names from it. */
	275	else
	276	{
	277	if (spec_file_prefix)
	278	{
	279	/* If --file-prefix=foo was specified, SHORT_BASE_NAME =
	280	`foo'. */
	281	short_base_name = xstrdup (spec_file_prefix);
	282	}
	283	else if (yacc_flag)
	284	{
	285	/* If --yacc, then the output is `y.tab.c'. */
	286	short_base_name = xstrdup ("y");
	287	}
	288	else
	289	{
	290	/* Otherwise, the short base name is computed from the input
	291	grammar: `foo/bar.yy' => `bar'. */
	292	filename_split (infile, &base, &tab, &ext);
	293	short_base_name =
	294	xstrndup (base,
	295	(strlen (base) - (ext ? strlen (ext) : 0)));
	296	}
	297
	298	/* In these cases, always append `.tab'. */
	299	output_infix = xstrdup (EXT_TAB);
	300
	301	full_base_name = XMALLOC (char,
	302	strlen (short_base_name)
	303	+ strlen (EXT_TAB) + 1);
	304	stpcpy (stpcpy (full_base_name, short_base_name), EXT_TAB);
	305
	306	/* Computes the extensions from the grammar file name. */
	307	filename_split (infile, &base, &tab, &ext);
	308	if (ext && !yacc_flag)
	309	compute_exts_from_gf (ext);
	310	}
	311	}
	312
	313	/*-------------------------------------------------------.
	314	\| Close the open files, compute the output files names. \|
	315	`-------------------------------------------------------*/
	316
	317	void
	318	compute_output_file_names (void)
	319	{
	320	compute_base_names ();
	321
	322	/* If not yet done. */
	323	if (!src_extension)
	324	src_extension = ".c";
	325	if (!header_extension)
	326	header_extension = ".h";
	327
	328	parser_file_name =
	329	spec_outfile ? spec_outfile : stringappend (full_base_name, src_extension);
	330
	331	/* It the defines filename if not given, we create it. */
	332	if (!spec_defines_file)
	333	spec_defines_file = stringappend (full_base_name, header_extension);
	334
	335	/* It the graph filename if not given, we create it. */
	336	if (!spec_graph_file)
	337	spec_graph_file = stringappend (short_base_name, ".vcg");
	338
	339	spec_verbose_file = stringappend (short_base_name, EXT_OUTPUT);
	340	}