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;

char *spec_outfile = NULL;	/* for -o. */
char *spec_file_prefix = NULL;	/* for -b. */
const char *spec_name_prefix = "yy";	/* 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;
static 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?  |
`--------------------------*/

static 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.                                            |
`-----------------------------------------------------------------*/

static 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);

      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);

      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);

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