src/files.c

/* Open and close files for bison,
   Copyright 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 action_obstack;
struct obstack attrs_obstack;
struct obstack output_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;
char *attrsfile = 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;
}


/*-----------------------------------------------------------------.
| Computes the macro name used to avoid double inclusion in the    |
| header of the parser and store it in header_macro_name.  Be sure |
| to produce valid CPP names (don't start with digit, remain       |
| alphanumerical + underscore).                                    |
`-----------------------------------------------------------------*/

char *
compute_header_macro (void)
{
  const char *prefix = "BISON_";
  char *macro_name, *cp;

  if (spec_defines_file)
    {
      macro_name = XMALLOC (char,
			    strlen (prefix) +
			    strlen (spec_defines_file) + 1);
      cp = stpcpy (macro_name, prefix);
      cp = stpcpy (cp, spec_defines_file);
    }
  else
    {
      macro_name = XMALLOC (char,
			    strlen (prefix) +
			    strlen (full_base_name) +
			    strlen (header_extension) + 1);
      cp = stpcpy (macro_name, prefix);
      cp = stpcpy (cp, full_base_name);
      cp = stpcpy (cp, header_extension);
    }

  for (cp = macro_name; *cp; ++cp)
    if (islower (*cp))
      *cp = toupper (*cp);
    else if (!isalnum (*cp))
      *cp = '_';

  return macro_name;
}


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


/*------------------------------------------------------------------.
| Return the path to the skeleton which locaction might be given in |
| ENVVAR, otherwise return SKELETON_NAME.                           |
`------------------------------------------------------------------*/

const char *
skeleton_find (const char *envvar, const char *skeleton_name)
{
  const char *res = getenv (envvar);

#if defined (MSDOS) || defined (_WIN32)
  const char *cp = getenv ("INIT");
  if (!res)
    {
      /* Skeleton file name without path */
      const char *skel_name = strrchr (skeleton_name, '/');
      if (!skel_name)
        skel_name = strrchr (skeleton_name, '\\');
      if (!skel_name)
        skel_name = skeleton_name;
      else
        ++skel_name;

      /* File doesn't exist in current directory; try in INIT directory.  */
      if (cp)
	{
	  res = XMALLOC (char, strlen (cp) + strlen (skel_name) + 2);
	  sprintf (res, "%s%c%s", cp, '\\', skel_name);
	}
      else if (access (skel_name, 4) == 0) /* Look in current dir. */
        res = skel_name;
      else
	{
	  /* Look in program locations dir. */
	  extern char *program_name;
	  cp = strrchr(program_name, '\\');
	  if (!cp)
	    return skeleton_name;
	  else
	    ++cp;
	  res = XMALLOC (char, cp - program_name + strlen (skel_name) + 1);
	  strncpy (res, program_name, cp - program_name);
	  strcpy (res + (cp - program_name), skel_name);
	}
    }
#endif /* defined (MSDOS) || defined (_WIN32) */
  if (!res)
    res = skeleton_name;

  return res;
}
\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.yy' => `foo'.  */
	  filename_split (infile, &base, &tab, &ext);
	  short_base_name =
	    xstrndup (infile,
		      (strlen (infile) - (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);

  attrsfile = stringappend (short_base_name, EXT_STYPE_H);
}
Commit	Line	Data
	1	/* Open and close files for bison,
	2	Copyright 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 action_obstack;
	36	struct obstack attrs_obstack;
	37	struct obstack output_obstack;
	38
	39	/* Initializing some values below (such SPEC_NAME_PREFIX to `yy') is
	40	tempting, but don't do that: for the time being our handling of the
	41	%directive vs --option leaves precedence to the options by deciding
	42	that if a %directive sets a variable which is really set (i.e., not
	43	NULL), then the %directive is ignored. As a result, %name-prefix,
	44	for instance, will not be honored. */
	45
	46	char spec_outfile = NULL; / for -o. */
	47	char spec_file_prefix = NULL; / for -b. */
	48	const char spec_name_prefix = NULL; / for -p. */
	49	char spec_verbose_file = NULL; / for --verbose. */
	50	char spec_graph_file = NULL; / for -g. */
	51	char spec_defines_file = NULL; / for --defines. */
	52	char *parser_file_name = NULL;
	53
	54	char *infile = NULL;
	55	char *attrsfile = NULL;
	56
	57	static char *full_base_name = NULL;
	58
	59	/* Prefix used to generate output file names. */
	60	char *short_base_name = NULL;
	61
	62	/* Infix used to generate output file names (i.e., `.tab', or `_tab',
	63	or `'). */
	64	char *output_infix = 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	/*--------------------------.
	73	\| Is SUFFIX ending STRING? \|
	74	`--------------------------*/
	75
	76	int
	77	strsuffix (const char string, const char suffix)
	78	{
	79	size_t string_len = strlen (string);
	80	size_t suffix_len = strlen (suffix);
	81	if (suffix_len <= string_len)
	82	return !strcmp (string + string_len - suffix_len, suffix);
	83	else
	84	return 0;
	85	}
	86
	87
	88	/*-----------------------------------------------------------------.
	89	\| Return a newly allocated string composed of the concatenation of \|
	90	\| STRING1, and STRING2. \|
	91	`-----------------------------------------------------------------*/
	92
	93	char*
	94	stringappend (const char string1, const char string2)
	95	{
	96	size_t len = strlen (string1) + strlen (string2);
	97	char *res = XMALLOC (char, len + 1);
	98	char *cp;
	99	cp = stpcpy (res, string1);
	100	cp = stpcpy (cp, string2);
	101	return res;
	102	}
	103
	104
	105	/*-----------------------------------------------------------------.
	106	\| Computes the macro name used to avoid double inclusion in the \|
	107	\| header of the parser and store it in header_macro_name. Be sure \|
	108	\| to produce valid CPP names (don't start with digit, remain \|
	109	\| alphanumerical + underscore). \|
	110	`-----------------------------------------------------------------*/
	111
	112	char *
	113	compute_header_macro (void)
	114	{
	115	const char *prefix = "BISON_";
	116	char macro_name, cp;
	117
	118	if (spec_defines_file)
	119	{
	120	macro_name = XMALLOC (char,
	121	strlen (prefix) +
	122	strlen (spec_defines_file) + 1);
	123	cp = stpcpy (macro_name, prefix);
	124	cp = stpcpy (cp, spec_defines_file);
	125	}
	126	else
	127	{
	128	macro_name = XMALLOC (char,
	129	strlen (prefix) +
	130	strlen (full_base_name) +
	131	strlen (header_extension) + 1);
	132	cp = stpcpy (macro_name, prefix);
	133	cp = stpcpy (cp, full_base_name);
	134	cp = stpcpy (cp, header_extension);
	135	}
	136
	137	for (cp = macro_name; *cp; ++cp)
	138	if (islower (*cp))
	139	cp = toupper (cp);
	140	else if (!isalnum (*cp))
	141	*cp = '_';
	142
	143	return macro_name;
	144	}
	145
	146
	147	/*-----------------------------------------------------------------.
	148	\| Try to open file NAME with mode MODE, and print an error message \|
	149	\| if fails. \|
	150	`-----------------------------------------------------------------*/
	151
	152	FILE *
	153	xfopen (const char name, const char mode)
	154	{
	155	FILE *ptr;
	156
	157	ptr = fopen (name, mode);
	158	if (!ptr)
	159	error (2, errno, _("cannot open file `%s'"), name);
	160
	161	return ptr;
	162	}
	163
	164	/*-------------------------------------------------------------.
	165	\| Try to close file PTR, and print an error message if fails. \|
	166	`-------------------------------------------------------------*/
	167
	168	int
	169	xfclose (FILE *ptr)
	170	{
	171	int result;
	172
	173	if (ptr == NULL)
	174	return 0;
	175
	176	result = fclose (ptr);
	177	if (result == EOF)
	178	error (2, errno, _("cannot close file"));
	179
	180	return result;
	181	}
	182
	183
	184	/*------------------------------------------------------------------.
	185	\| Return the path to the skeleton which locaction might be given in \|
	186	\| ENVVAR, otherwise return SKELETON_NAME. \|
	187	`------------------------------------------------------------------*/
	188
	189	const char *
	190	skeleton_find (const char envvar, const char skeleton_name)
	191	{
	192	const char *res = getenv (envvar);
	193
	194	#if defined (MSDOS) \|\| defined (_WIN32)
	195	const char *cp = getenv ("INIT");
	196	if (!res)
	197	{
	198	/* Skeleton file name without path */
	199	const char *skel_name = strrchr (skeleton_name, '/');
	200	if (!skel_name)
	201	skel_name = strrchr (skeleton_name, '\\');
	202	if (!skel_name)
	203	skel_name = skeleton_name;
	204	else
	205	++skel_name;
	206
	207	/* File doesn't exist in current directory; try in INIT directory. */
	208	if (cp)
	209	{
	210	res = XMALLOC (char, strlen (cp) + strlen (skel_name) + 2);
	211	sprintf (res, "%s%c%s", cp, '\\', skel_name);
	212	}
	213	else if (access (skel_name, 4) == 0) /* Look in current dir. */
	214	res = skel_name;
	215	else
	216	{
	217	/* Look in program locations dir. */
	218	extern char *program_name;
	219	cp = strrchr(program_name, '\\');
	220	if (!cp)
	221	return skeleton_name;
	222	else
	223	++cp;
	224	res = XMALLOC (char, cp - program_name + strlen (skel_name) + 1);
	225	strncpy (res, program_name, cp - program_name);
	226	strcpy (res + (cp - program_name), skel_name);
	227	}
	228	}
	229	#endif /* defined (MSDOS) \|\| defined (_WIN32) */
	230	if (!res)
	231	res = skeleton_name;
	232
	233	return res;
	234	}
	235	\f
	236
	237	/*----------------------------------------------------------------.
	238	\| Compute BASE_NAME, SHORT_BASE_NAME and output files extensions. \|
	239	`----------------------------------------------------------------*/
	240
	241	/* Replace all characters FROM by TO in the string IN.
	242	and returns a new allocated string. */
	243	static char *
	244	tr (const char *in, char from, char to)
	245	{
	246	char *temp;
	247	char *out;
	248
	249	out = XMALLOC (char, strlen (in) + 1);
	250
	251	for (temp = out; *in; in++, out++)
	252	if (*in == from)
	253	*out = to;
	254	else
	255	out = in;
	256	*out = 0;
	257	return (temp);
	258	}
	259
	260	/* Computes extensions from the grammar file extension. */
	261	static void
	262	compute_exts_from_gf (const char *ext)
	263	{
	264	src_extension = tr (ext, 'y', 'c');
	265	src_extension = tr (src_extension, 'Y', 'C');
	266	header_extension = tr (ext, 'y', 'h');
	267	header_extension = tr (header_extension, 'Y', 'H');
	268	}
	269
	270	/* Computes extensions from the given c source file extension. */
	271	static void
	272	compute_exts_from_src (const char *ext)
	273	{
	274	/* We use this function when the user specifies `-o' or `--output',
	275	so the extenions must be computed unconditionally from the file name
	276	given by this option. */
	277	src_extension = xstrdup (ext);
	278	header_extension = tr (ext, 'c', 'h');
	279	header_extension = tr (header_extension, 'C', 'H');
	280	}
	281
	282
	283	/* Decompose FILENAME in four parts: BASE, TAB, and *EXT, the fourth
	284	part, (the directory) is ranging from FILENAME to the char before
	285	*BASE, so we don't need an additional parameter.
	286
	287	*EXT points to the last period in the basename, or NULL if none.
	288
	289	If there is no EXT, TAB is NULL. Otherwise, *TAB points to
	290	`.tab' or `_tab' if present right before EXT, or is NULL. TAB
	291	cannot be equal to *BASE.
	292
	293	None are allocated, they are simply pointers to parts of FILENAME.
	294	Examples:
	295
	296	'/tmp/foo.tab.c' -> BASE = 'foo.tab.c', TAB = '.tab.c', *EXT =
	297	'.c'
	298
	299	'foo.c' -> BASE = 'foo.c', TAB = NULL, *EXT = '.c'
	300
	301	'tab.c' -> BASE = 'tab.c', TAB = NULL, *EXT = '.c'
	302
	303	'.tab.c' -> BASE = '.tab.c', TAB = NULL, *EXT = '.c'
	304
	305	'foo.tab' -> BASE = 'foo.tab', TAB = NULL, *EXT = '.tab'
	306
	307	'foo_tab' -> BASE = 'foo_tab', TAB = NULL, *EXT = NULL
	308
	309	'foo' -> BASE = 'foo', TAB = NULL, EXT = NULL. /
	310
	311	static void
	312	filename_split (const char *filename,
	313	const char base, const char tab, const char **ext)
	314	{
	315	*base = base_name (filename);
	316
	317	/* Look for the extension, i.e., look for the last dot. */
	318	ext = strrchr (base, '.');
	319	*tab = NULL;
	320
	321	/* If there is an exentension, check if there is a `.tab' part right
	322	before. */
	323	if (*ext
	324	&& (ext - base) > (int) strlen (".tab")
	325	&& (!strncmp (*ext - strlen (".tab"), ".tab", strlen (".tab"))
	326	\|\| !strncmp (*ext - strlen ("_tab"), "_tab", strlen ("_tab"))))
	327	tab = ext - strlen (".tab");
	328	}
	329
	330
	331	/* FIXME: Should use xstrndup. */
	332
	333	static void
	334	compute_base_names (void)
	335	{
	336	const char base, tab, *ext;
	337
	338	/* If --output=foo.c was specified (SPEC_OUTFILE == foo.c),
	339	BASE_NAME and SHORT_BASE_NAME are `foo'.
	340
	341	If --output=foo.tab.c was specified, BASE_NAME is `foo.tab' and
	342	SHORT_BASE_NAME is `foo'.
	343
	344	The precise -o name will be used for FTABLE. For other output
	345	files, remove the ".c" or ".tab.c" suffix. */
	346	if (spec_outfile)
	347	{
	348	filename_split (spec_outfile, &base, &tab, &ext);
	349
	350	/* The full base name goes up the EXT, excluding it. */
	351	full_base_name =
	352	xstrndup (spec_outfile,
	353	(strlen (spec_outfile) - (ext ? strlen (ext) : 0)));
	354
	355	/* The short base name goes up to TAB, excluding it. */
	356	short_base_name =
	357	xstrndup (spec_outfile,
	358	(strlen (spec_outfile)
	359	- (tab ? strlen (tab) : (ext ? strlen (ext) : 0))));
	360
	361	if (tab)
	362	output_infix = xstrndup (tab,
	363	(strlen (tab) - (ext ? strlen (ext) : 0)));
	364
	365	if (ext)
	366	compute_exts_from_src (ext);
	367	}
	368
	369	/* If --file-prefix=foo was specified, FULL_BASE_NAME = `foo.tab'
	370	and SHORT_BASE_NAME = `foo'.
	371
	372	Construct names from it. */
	373	else
	374	{
	375	if (spec_file_prefix)
	376	{
	377	/* If --file-prefix=foo was specified, SHORT_BASE_NAME =
	378	`foo'. */
	379	short_base_name = xstrdup (spec_file_prefix);
	380	}
	381	else if (yacc_flag)
	382	{
	383	/* If --yacc, then the output is `y.tab.c'. */
	384	short_base_name = xstrdup ("y");
	385	}
	386	else
	387	{
	388	/* Otherwise, the short base name is computed from the input
	389	grammar: `foo.yy' => `foo'. */
	390	filename_split (infile, &base, &tab, &ext);
	391	short_base_name =
	392	xstrndup (infile,
	393	(strlen (infile) - (ext ? strlen (ext) : 0)));
	394	}
	395
	396	/* In these cases, always append `.tab'. */
	397	output_infix = xstrdup (EXT_TAB);
	398
	399	full_base_name = XMALLOC (char,
	400	strlen (short_base_name)
	401	+ strlen (EXT_TAB) + 1);
	402	stpcpy (stpcpy (full_base_name, short_base_name), EXT_TAB);
	403
	404	/* Computes the extensions from the grammar file name. */
	405	filename_split (infile, &base, &tab, &ext);
	406	if (ext && !yacc_flag)
	407	compute_exts_from_gf (ext);
	408	}
	409	}
	410
	411	/*-------------------------------------------------------.
	412	\| Close the open files, compute the output files names. \|
	413	`-------------------------------------------------------*/
	414
	415	void
	416	compute_output_file_names (void)
	417	{
	418	compute_base_names ();
	419
	420	/* If not yet done. */
	421	if (!src_extension)
	422	src_extension = ".c";
	423	if (!header_extension)
	424	header_extension = ".h";
	425
	426	parser_file_name =
	427	spec_outfile ? spec_outfile : stringappend (full_base_name, src_extension);
	428
	429	/* It the defines filename if not given, we create it. */
	430	if (!spec_defines_file)
	431	spec_defines_file = stringappend (full_base_name, header_extension);
	432
	433	/* It the graph filename if not given, we create it. */
	434	if (!spec_graph_file)
	435	spec_graph_file = stringappend (short_base_name, ".vcg");
	436
	437	spec_verbose_file = stringappend (short_base_name, EXT_OUTPUT);
	438
	439	attrsfile = stringappend (short_base_name, EXT_STYPE_H);
	440	}