src/files.c

/* Open and close files for bison,
   Copyright 1984, 1986, 1989, 1992, 2000, 2001 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"

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 *base_name = NULL;
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;

/* Should we insert '.tab' in yacc-compatible parsers?  */
int tab_extension = 0;
\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 (base_name) +
			    strlen (header_extension) + 1);
      cp = stpcpy (macro_name, prefix);
      cp = stpcpy (cp, 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)
  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.  */
      const char *cp = getenv ("INIT");
      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);
}

/* Gets the extension index in FILENAME. Returns 0 if fails to
   find an extension.  */
static int
get_extension_index (const char *filename)
{
  int len;

  len = strlen (filename);

  if (filename[len-- - 1] == '.')
    return (0);

  while ((len > 0) && (filename[len - 1] != '.'))
    if (filename[len - 1] == '/')
      return (0);
    else
      len--;

  return (len - 1);
}

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

/* FIXME: Should use xstrndup. */

static void
compute_base_names (void)
{
  size_t base_length;
  size_t short_base_length;
  size_t ext_index;

  /* 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)
    {
#ifdef MSDOS
      strlwr (spec_outfile);
#endif /* MSDOS */
      /* BASE_LENGTH includes ".tab" but not ".c".  */
      base_length = strlen (spec_outfile);

      ext_index = get_extension_index (spec_outfile);
      /* If the initial segment of extension contains 'c' or a 'C', I assume
         that it is a C or C++ source file.  */
      if (ext_index)
	ext_index =
	  (strspn (spec_outfile + ext_index + 1, "cC")) ? ext_index : 0;
      if (ext_index)
	{
	  base_length -= strlen (spec_outfile + ext_index);
	  compute_exts_from_src (spec_outfile + ext_index);
	}

      base_name = strndup (spec_outfile, base_length);
      /* SHORT_BASE_LENGTH includes neither ".tab" nor ".c".  */
      short_base_length = base_length;
      if (strsuffix (base_name, ".tab") || strsuffix (base_name, "_tab"))
	short_base_length -= 4;
      short_base_name = strndup (spec_outfile, short_base_length);

      /* FIXME: This is a quick and dirty way for me to find out if we
	 should .tab or not, using the computations above.  */
      if (strcmp (base_name, short_base_name))
	tab_extension = 1;

      return;
    }

  /* If --file-prefix=foo was specified, BASE_NAME and SHORT_BASE_NAME
     are `foo'.

     Construct names from it.  */
  if (spec_file_prefix)
    {
#ifdef MSDOS
      strlwr (spec_file_prefix);
#endif /* MSDOS */
      short_base_name = xstrdup (spec_file_prefix);
      base_name = XMALLOC (char,
			   strlen (short_base_name) + strlen (EXT_TAB) + 1);
      stpcpy (stpcpy (base_name, short_base_name), EXT_TAB);

      /* Computes the extensions from the garmmar file name.  */
      ext_index = get_extension_index (infile);
      /* If the initial segment of extension contains a 'y' or a 'Y', I assume
         that it is a yacc or bison grammar file.  */
      if (ext_index)
	ext_index = (strspn (infile + ext_index + 1, "yY")) ? ext_index : 0;
      if (ext_index)
	compute_exts_from_gf (infile + ext_index);

      /* It seems that when only a prefix is given, '.tab' should always be
	 used.  */
      tab_extension = 1;

      return;
    }

  /* If neither -o nor --file-prefix were specified, and the input
     file is foo.y, BASE_NAME is `foo.tab', and SHORT_BASE_NAME is
     `foo'.

     If --yacc is used, do as if the input file was `y.y'.  */
  {
    const char *name_base = yacc_flag ? "y.y" : infile;

    /* BASE_LENGTH gets length of BASE_NAME, sans ".y" suffix if any.  */

    base_length = strlen (name_base);

    ext_index = get_extension_index (name_base);
    /* If the initial segment of extension contains a 'y' or a 'Y', I assume
       that it is a yacc or bison grammar file.  */
    if (ext_index)
      ext_index = (strspn (name_base + ext_index + 1, "yY")) ? ext_index : 0;
    if (ext_index)
      {
	base_length -= strlen (name_base + ext_index);
	compute_exts_from_gf (name_base + ext_index);
      }

    short_base_length = base_length;
    short_base_name = strndup (name_base, short_base_length);

    base_name = XMALLOC (char,
			 strlen (short_base_name) + strlen (EXT_TAB) + 1);
    stpcpy (stpcpy (base_name, short_base_name), EXT_TAB);

    /* By default, Bison should insert '.tab' were needed.  */
    tab_extension = 1;

    return;
  }
}

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

void
compute_output_file_names (void)
{
  compute_base_names ();

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

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

  /* It the defines filename if not given, we create it.  */
  if (!spec_defines_file)
    spec_defines_file = stringappend (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);
#ifndef MSDOS
  attrsfile = stringappend (attrsfile, header_extension);
#endif /* MSDOS */
}
Commit	Line	Data
	1	/* Open and close files for bison,
	2	Copyright 1984, 1986, 1989, 1992, 2000, 2001 Free Software Foundation, Inc.
	3
	4	This file is part of Bison, the GNU Compiler Compiler.
	5
	6	Bison is free software; you can redistribute it and/or modify it
	7	under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2, or (at your option)
	9	any later version.
	10
	11	Bison is distributed in the hope that it will be useful, but
	12	WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with Bison; see the file COPYING. If not, write to the Free
	18	Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
	19	02111-1307, USA. */
	20
	21
	22	#include "system.h"
	23	#include "getargs.h"
	24	#include "files.h"
	25	#include "gram.h"
	26	#include "error.h"
	27	#include "complain.h"
	28
	29	FILE *finput = NULL;
	30
	31	struct obstack action_obstack;
	32	struct obstack attrs_obstack;
	33	struct obstack output_obstack;
	34
	35	/* Initializing some values below (such SPEC_NAME_PREFIX to `yy') is
	36	tempting, but don't do that: for the time being our handling of the
	37	%directive vs --option leaves precedence to the options by deciding
	38	that if a %directive sets a variable which is really set (i.e., not
	39	NULL), then the %directive is ignored. As a result, %name-prefix,
	40	for instance, will not be honored. */
	41
	42	char spec_outfile = NULL; / for -o. */
	43	char spec_file_prefix = NULL; / for -b. */
	44	const char spec_name_prefix = NULL; / for -p. */
	45	char spec_verbose_file = NULL; / for --verbose. */
	46	char spec_graph_file = NULL; / for -g. */
	47	char spec_defines_file = NULL; / for --defines. */
	48	char *parser_file_name = NULL;
	49
	50	char *infile = NULL;
	51	char *attrsfile = NULL;
	52
	53	static char *base_name = NULL;
	54	char *short_base_name = NULL;
	55
	56	/* C source file extension (the parser source). */
	57	const char *src_extension = NULL;
	58	/* Header file extension (if option ``-d'' is specified). */
	59	const char *header_extension = NULL;
	60
	61	/* Should we insert '.tab' in yacc-compatible parsers? */
	62	int tab_extension = 0;
	63	\f
	64
	65	/*--------------------------.
	66	\| Is SUFFIX ending STRING? \|
	67	`--------------------------*/
	68
	69	int
	70	strsuffix (const char string, const char suffix)
	71	{
	72	size_t string_len = strlen (string);
	73	size_t suffix_len = strlen (suffix);
	74	if (suffix_len <= string_len)
	75	return !strcmp (string + string_len - suffix_len, suffix);
	76	else
	77	return 0;
	78	}
	79
	80
	81	/*-----------------------------------------------------------------.
	82	\| Return a newly allocated string composed of the concatenation of \|
	83	\| STRING1, and STRING2. \|
	84	`-----------------------------------------------------------------*/
	85
	86	char*
	87	stringappend (const char string1, const char string2)
	88	{
	89	size_t len = strlen (string1) + strlen (string2);
	90	char *res = XMALLOC (char, len + 1);
	91	char *cp;
	92	cp = stpcpy (res, string1);
	93	cp = stpcpy (cp, string2);
	94	return res;
	95	}
	96
	97
	98	/*-----------------------------------------------------------------.
	99	\| Computes the macro name used to avoid double inclusion in the \|
	100	\| header of the parser and store it in header_macro_name. Be sure \|
	101	\| to produce valid CPP names (don't start with digit, remain \|
	102	\| alphanumerical + underscore). \|
	103	`-----------------------------------------------------------------*/
	104
	105	char *
	106	compute_header_macro (void)
	107	{
	108	const char *prefix = "BISON_";
	109	char macro_name, cp;
	110
	111	if (spec_defines_file)
	112	{
	113	macro_name = XMALLOC (char,
	114	strlen (prefix) +
	115	strlen (spec_defines_file) + 1);
	116	cp = stpcpy (macro_name, prefix);
	117	cp = stpcpy (cp, spec_defines_file);
	118	}
	119	else
	120	{
	121	macro_name = XMALLOC (char,
	122	strlen (prefix) +
	123	strlen (base_name) +
	124	strlen (header_extension) + 1);
	125	cp = stpcpy (macro_name, prefix);
	126	cp = stpcpy (cp, base_name);
	127	cp = stpcpy (cp, header_extension);
	128	}
	129
	130	for (cp = macro_name; *cp; ++cp)
	131	if (islower (*cp))
	132	cp = toupper (cp);
	133	else if (!isalnum (*cp))
	134	*cp = '_';
	135
	136	return macro_name;
	137	}
	138
	139
	140	/*-----------------------------------------------------------------.
	141	\| Try to open file NAME with mode MODE, and print an error message \|
	142	\| if fails. \|
	143	`-----------------------------------------------------------------*/
	144
	145	FILE *
	146	xfopen (const char name, const char mode)
	147	{
	148	FILE *ptr;
	149
	150	ptr = fopen (name, mode);
	151	if (!ptr)
	152	error (2, errno, _("cannot open file `%s'"), name);
	153
	154	return ptr;
	155	}
	156
	157	/*-------------------------------------------------------------.
	158	\| Try to close file PTR, and print an error message if fails. \|
	159	`-------------------------------------------------------------*/
	160
	161	int
	162	xfclose (FILE *ptr)
	163	{
	164	int result;
	165
	166	if (ptr == NULL)
	167	return 0;
	168
	169	result = fclose (ptr);
	170	if (result == EOF)
	171	error (2, errno, _("cannot close file"));
	172
	173	return result;
	174	}
	175
	176
	177	/*------------------------------------------------------------------.
	178	\| Return the path to the skeleton which locaction might be given in \|
	179	\| ENVVAR, otherwise return SKELETON_NAME. \|
	180	`------------------------------------------------------------------*/
	181
	182	const char *
	183	skeleton_find (const char envvar, const char skeleton_name)
	184	{
	185	const char *res = getenv (envvar);
	186
	187	#if defined (MSDOS) \|\| defined (_WIN32)
	188	if (!res)
	189	{
	190	/* Skeleton file name without path */
	191	const char *skel_name = strrchr (skeleton_name, '/');
	192	if (!skel_name)
	193	skel_name = strrchr (skeleton_name, '\\');
	194	if (!skel_name)
	195	skel_name = skeleton_name;
	196	else
	197	++skel_name;
	198
	199	/* File doesn't exist in current directory; try in INIT directory. */
	200	const char *cp = getenv ("INIT");
	201	if (cp)
	202	{
	203	res = XMALLOC (char, strlen (cp) + strlen (skel_name) + 2);
	204	sprintf (res, "%s%c%s", cp, '\\', skel_name);
	205	}
	206	else if (access (skel_name, 4) == 0) /* Look in current dir. */
	207	res = skel_name;
	208	else
	209	{
	210	/* Look in program locations dir. */
	211	extern char *program_name;
	212	cp = strrchr(program_name, '\\');
	213	if (!cp)
	214	return skeleton_name;
	215	else
	216	++cp;
	217	res = XMALLOC (char, cp - program_name + strlen (skel_name) + 1);
	218	strncpy (res, program_name, cp - program_name);
	219	strcpy (res + (cp - program_name), skel_name);
	220	}
	221	}
	222	#endif /* defined (MSDOS) \|\| defined (_WIN32) */
	223	if (!res)
	224	res = skeleton_name;
	225
	226	return res;
	227	}
	228	\f
	229
	230	/*----------------------------------------------------------------.
	231	\| Compute BASE_NAME, SHORT_BASE_NAME and output files extensions. \|
	232	`----------------------------------------------------------------*/
	233
	234	/* Replace all characters FROM by TO in the string IN.
	235	and returns a new allocated string. */
	236	static char *
	237	tr (const char *in, char from, char to)
	238	{
	239	char *temp;
	240	char *out;
	241
	242	out = XMALLOC (char, strlen (in) + 1);
	243
	244	for (temp = out; *in; in++, out++)
	245	if (*in == from)
	246	*out = to;
	247	else
	248	out = in;
	249	*out = 0;
	250	return (temp);
	251	}
	252
	253	/* Gets the extension index in FILENAME. Returns 0 if fails to
	254	find an extension. */
	255	static int
	256	get_extension_index (const char *filename)
	257	{
	258	int len;
	259
	260	len = strlen (filename);
	261
	262	if (filename[len-- - 1] == '.')
	263	return (0);
	264
	265	while ((len > 0) && (filename[len - 1] != '.'))
	266	if (filename[len - 1] == '/')
	267	return (0);
	268	else
	269	len--;
	270
	271	return (len - 1);
	272	}
	273
	274	/* Computes extensions from the grammar file extension. */
	275	static void
	276	compute_exts_from_gf (const char *ext)
	277	{
	278	src_extension = tr (ext, 'y', 'c');
	279	src_extension = tr (src_extension, 'Y', 'C');
	280	header_extension = tr (ext, 'y', 'h');
	281	header_extension = tr (header_extension, 'Y', 'H');
	282	}
	283
	284	/* Computes extensions from the given c source file extension. */
	285	static void
	286	compute_exts_from_src (const char *ext)
	287	{
	288	/* We use this function when the user specifies `-o' or `--output',
	289	so the extenions must be computed unconditionally from the file name
	290	given by this option. */
	291	src_extension = xstrdup (ext);
	292	header_extension = tr (ext, 'c', 'h');
	293	header_extension = tr (header_extension, 'C', 'H');
	294	}
	295
	296	/* FIXME: Should use xstrndup. */
	297
	298	static void
	299	compute_base_names (void)
	300	{
	301	size_t base_length;
	302	size_t short_base_length;
	303	size_t ext_index;
	304
	305	/* If --output=foo.c was specified (SPEC_OUTFILE == foo.c),
	306	BASE_NAME and SHORT_BASE_NAME are `foo'.
	307
	308	If --output=foo.tab.c was specified, BASE_NAME is `foo.tab' and
	309	SHORT_BASE_NAME is `foo'.
	310
	311	The precise -o name will be used for FTABLE. For other output
	312	files, remove the ".c" or ".tab.c" suffix. */
	313	if (spec_outfile)
	314	{
	315	#ifdef MSDOS
	316	strlwr (spec_outfile);
	317	#endif /* MSDOS */
	318	/* BASE_LENGTH includes ".tab" but not ".c". */
	319	base_length = strlen (spec_outfile);
	320
	321	ext_index = get_extension_index (spec_outfile);
	322	/* If the initial segment of extension contains 'c' or a 'C', I assume
	323	that it is a C or C++ source file. */
	324	if (ext_index)
	325	ext_index =
	326	(strspn (spec_outfile + ext_index + 1, "cC")) ? ext_index : 0;
	327	if (ext_index)
	328	{
	329	base_length -= strlen (spec_outfile + ext_index);
	330	compute_exts_from_src (spec_outfile + ext_index);
	331	}
	332
	333	base_name = strndup (spec_outfile, base_length);
	334	/* SHORT_BASE_LENGTH includes neither ".tab" nor ".c". */
	335	short_base_length = base_length;
	336	if (strsuffix (base_name, ".tab") \|\| strsuffix (base_name, "_tab"))
	337	short_base_length -= 4;
	338	short_base_name = strndup (spec_outfile, short_base_length);
	339
	340	/* FIXME: This is a quick and dirty way for me to find out if we
	341	should .tab or not, using the computations above. */
	342	if (strcmp (base_name, short_base_name))
	343	tab_extension = 1;
	344
	345	return;
	346	}
	347
	348	/* If --file-prefix=foo was specified, BASE_NAME and SHORT_BASE_NAME
	349	are `foo'.
	350
	351	Construct names from it. */
	352	if (spec_file_prefix)
	353	{
	354	#ifdef MSDOS
	355	strlwr (spec_file_prefix);
	356	#endif /* MSDOS */
	357	short_base_name = xstrdup (spec_file_prefix);
	358	base_name = XMALLOC (char,
	359	strlen (short_base_name) + strlen (EXT_TAB) + 1);
	360	stpcpy (stpcpy (base_name, short_base_name), EXT_TAB);
	361
	362	/* Computes the extensions from the garmmar file name. */
	363	ext_index = get_extension_index (infile);
	364	/* If the initial segment of extension contains a 'y' or a 'Y', I assume
	365	that it is a yacc or bison grammar file. */
	366	if (ext_index)
	367	ext_index = (strspn (infile + ext_index + 1, "yY")) ? ext_index : 0;
	368	if (ext_index)
	369	compute_exts_from_gf (infile + ext_index);
	370
	371	/* It seems that when only a prefix is given, '.tab' should always be
	372	used. */
	373	tab_extension = 1;
	374
	375	return;
	376	}
	377
	378	/* If neither -o nor --file-prefix were specified, and the input
	379	file is foo.y, BASE_NAME is `foo.tab', and SHORT_BASE_NAME is
	380	`foo'.
	381
	382	If --yacc is used, do as if the input file was `y.y'. */
	383	{
	384	const char *name_base = yacc_flag ? "y.y" : infile;
	385
	386	/* BASE_LENGTH gets length of BASE_NAME, sans ".y" suffix if any. */
	387
	388	base_length = strlen (name_base);
	389
	390	ext_index = get_extension_index (name_base);
	391	/* If the initial segment of extension contains a 'y' or a 'Y', I assume
	392	that it is a yacc or bison grammar file. */
	393	if (ext_index)
	394	ext_index = (strspn (name_base + ext_index + 1, "yY")) ? ext_index : 0;
	395	if (ext_index)
	396	{
	397	base_length -= strlen (name_base + ext_index);
	398	compute_exts_from_gf (name_base + ext_index);
	399	}
	400
	401	short_base_length = base_length;
	402	short_base_name = strndup (name_base, short_base_length);
	403
	404	base_name = XMALLOC (char,
	405	strlen (short_base_name) + strlen (EXT_TAB) + 1);
	406	stpcpy (stpcpy (base_name, short_base_name), EXT_TAB);
	407
	408	/* By default, Bison should insert '.tab' were needed. */
	409	tab_extension = 1;
	410
	411	return;
	412	}
	413	}
	414
	415	/*-------------------------------------------------------.
	416	\| Close the open files, compute the output files names. \|
	417	`-------------------------------------------------------*/
	418
	419	void
	420	compute_output_file_names (void)
	421	{
	422	compute_base_names ();
	423
	424	parser_file_name =
	425	spec_outfile ? spec_outfile : stringappend (base_name, src_extension);
	426
	427	/* If not yet done. */
	428	if (!src_extension)
	429	src_extension = ".c";
	430	if (!header_extension)
	431	header_extension = ".h";
	432
	433	/* It the defines filename if not given, we create it. */
	434	if (!spec_defines_file)
	435	spec_defines_file = stringappend (base_name, header_extension);
	436
	437	/* It the graph filename if not given, we create it. */
	438	if (!spec_graph_file)
	439	spec_graph_file = stringappend (short_base_name, ".vcg");
	440
	441	spec_verbose_file = stringappend (short_base_name, EXT_OUTPUT);
	442
	443	attrsfile = stringappend (short_base_name, EXT_STYPE_H);
	444	#ifndef MSDOS
	445	attrsfile = stringappend (attrsfile, header_extension);
	446	#endif /* MSDOS */
	447	}