* src/print_graph.c (quote): New.

[bison.git] / src / files.c

diff --git a/src/files.c b/src/files.c
index 3e52ff66e8299b734381fa60302dcaa21ad11a63..721f1e5e6bce29ae79fb1867e1cee2b79c817edc 100644 (file)
--- a/src/files.c
+++ b/src/files.c
@@ -1,5 +1,5 @@
 /* Open and close files for bison,
 /* Open and close files for bison,

-   Copyright 1984, 1986, 1989, 1992, 2000 Free Software Foundation, Inc.
+   Copyright 1984, 1986, 1989, 1992, 2000, 2001 Free Software Foundation, Inc.

 
    This file is part of Bison, the GNU Compiler Compiler.
 
 
    This file is part of Bison, the GNU Compiler Compiler.
 


@@ -20,27 +20,6 @@
 
 
 #include "system.h"
 
 
 #include "system.h"

-
-#if defined (VMS) & !defined (__VMS_POSIX)
-# include <ssdef.h>
-# define unlink delete
-# ifndef XPFILE
-#  define XPFILE "GNU_BISON:[000000]BISON.SIMPLE"
-# endif
-# ifndef XPFILE1
-#  define XPFILE1 "GNU_BISON:[000000]BISON.HAIRY"
-# endif
-#endif
-
-#if defined (_MSC_VER)
-# ifndef XPFILE
-#  define XPFILE "c:/usr/local/lib/bison.simple"
-# endif
-# ifndef XPFILE1
-#  define XPFILE1 "c:/usr/local/lib/bison.hairy"
-# endif
-#endif
-

 #include "getargs.h"
 #include "files.h"
 #include "xalloc.h"
 #include "getargs.h"
 #include "files.h"
 #include "xalloc.h"


@@ -48,57 +27,61 @@
 #include "complain.h"
 
 FILE *finput = NULL;
 #include "complain.h"
 
 FILE *finput = NULL;

-FILE *foutput = NULL;
-FILE *fguard = NULL;
-FILE *fparser = NULL;

 
 struct obstack action_obstack;
 struct obstack attrs_obstack;
 struct obstack table_obstack;
 struct obstack defines_obstack;
 
 struct obstack action_obstack;
 struct obstack attrs_obstack;
 struct obstack table_obstack;
 struct obstack defines_obstack;

+struct obstack guard_obstack;
+struct obstack output_obstack;
+struct obstack graph_obstack;

 
 

-/* File name specified with -o for the output file, or 0 if no -o.  */
-char *spec_outfile;
+char *spec_outfile = NULL;     /* for -o. */
+char *spec_file_prefix = NULL; /* for -b. */
+char *spec_name_prefix = NULL; /* for -p. */

 
 

-char *infile;
-char *attrsfile;
+char *infile = NULL;
+char *attrsfile = NULL;

 
 

-static char *outfile;
-static char *defsfile;
-static char *tabfile;
-static char *guardfile;
-static char *actfile;
+static char *base_name = NULL;
+static char *short_base_name = NULL;

 
 

-extern char *getenv ();
+/* 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;

 
 

-extern char *program_name;

 \f
 \f

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

 
 

-static char *
-stringappend (const char *string1, int end1, const char *string2)
+static int
+strsuffix (const char *string, const char *suffix)

 {
 {

-  register char *ostring;
-  register char *cp;
-  register const char *cp1;
-  register int i;
-
-  cp1 = string2;
-  i = 0;
-  while (*cp1++)
-    i++;
-
-  ostring = XCALLOC (char, i + end1 + 1);
+  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;
+}

 
 

-  cp = ostring;
-  cp1 = string1;
-  for (i = 0; i < end1; i++)
-    *cp++ = *cp1++;

 
 

-  cp1 = string2;
-  while ((*cp++ = *cp1++))
-    ;
+/*-----------------------------------------------------------------.
+| Return a newly allocated string composed of the concatenation of |
+| STRING1, and STRING2.                                            |
+`-----------------------------------------------------------------*/

 
 

-  return ostring;
+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;

 }
 
 /*-----------------------------------------------------------------.
 }
 
 /*-----------------------------------------------------------------.


@@ -106,7 +89,7 @@ stringappend (const char *string1, int end1, const char *string2)
 | if fails.                                                        |
 `-----------------------------------------------------------------*/
 
 | if fails.                                                        |
 `-----------------------------------------------------------------*/
 

-static FILE *
+FILE *

 xfopen (const char *name, const char *mode)
 {
   FILE *ptr;
 xfopen (const char *name, const char *mode)
 {
   FILE *ptr;


@@ -122,7 +105,7 @@ xfopen (const char *name, const char *mode)
 | Try to close file PTR, and print an error message if fails.  |
 `-------------------------------------------------------------*/
 
 | Try to close file PTR, and print an error message if fails.  |
 `-------------------------------------------------------------*/
 

-static int
+int

 xfclose (FILE *ptr)
 {
   int result;
 xfclose (FILE *ptr)
 {
   int result;


@@ -141,7 +124,7 @@ xfclose (FILE *ptr)
 | Save the content of the obstack OBS in FILENAME.  |
 `--------------------------------------------------*/
 
 | Save the content of the obstack OBS in FILENAME.  |
 `--------------------------------------------------*/
 

-void
+static void

 obstack_save (struct obstack *obs, const char *filename)
 {
   FILE *out = xfopen (filename, "w");
 obstack_save (struct obstack *obs, const char *filename)
 {
   FILE *out = xfopen (filename, "w");


@@ -150,232 +133,227 @@ obstack_save (struct obstack *obs, const char *filename)
   xfclose (out);
 }
 
   xfclose (out);
 }
 

-\f
-/*-----------------------------------------------------------------.
-| Open the input file.  Look for the skeletons.  Find the names of |
-| the output files.  Prepare the obstacks.                         |
-`-----------------------------------------------------------------*/

 
 

-void
-open_files (void)
+/*------------------------------------------------------------------.
+| 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)

 {
 {

-  char *name_base;
-#ifdef MSDOS
-  register char *cp;
-#endif
-  char *filename;
-  int base_length;
-  int short_base_length;
-
-#if defined (VMS) & !defined (__VMS_POSIX)
-  const char *tmp_base = "sys$scratch:b_";
-#else
-  const char *tmp_base = "/tmp/b.";
-#endif
-  int tmp_len;
+  const char *res = getenv (envvar);

 
 #ifdef MSDOS
 
 #ifdef MSDOS

-  tmp_base = getenv ("TMP");
-  if (tmp_base == 0)
-    tmp_base = "";
-  strlwr (infile);
-#endif /* MSDOS */
+  const char *cp;

 
 

-#if (defined(_WIN32) && !defined(__CYGWIN32__))
-  tmp_base = getenv ("TEMP");  /* Windows95 defines this ... */
-  if (tmp_base == 0)
-    tmp_base = getenv ("Temp");        /* ... while NT prefers this */
-  if (tmp_base == 0)
-    tmp_base = "";
-  strlwr (infile);
-#endif /* _WIN32 && !__CYGWIN32__ */
+  /* File doesn't exist in current directory; try in INIT directory.  */
+  if (!res && (cp = getenv ("INIT")))
+    {
+      res = XMALLOC (char, strlen (cp) + strlen (skeleton_name) + 2);
+      sprintf (res, "%s%c%s", cp, '/', skeleton_name);
+    }
+#endif /* !MSDOS */

 
 

-#if (defined(unix) || defined(__unix) || defined(__unix__) || defined(__EMX__))
-  {
-    char *tmp_ptr = getenv ("TMPDIR");
+  if (!res)
+    res = skeleton_name;

 
 

-    if (tmp_ptr != 0)
-      tmp_base = stringappend (tmp_ptr, strlen (tmp_ptr), "/b.");
-  }
-#endif /* unix || __unix || __unix__ */
+  return res;
+}

 
 

-  tmp_len = strlen (tmp_base);
+\f
+/*----------------------------------------------------------------.
+| Compute BASE_NAME, SHORT_BASE_NAME and output files extensions. |
+`----------------------------------------------------------------*/

 
 

-  if (spec_outfile)
+/* 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)
+{
+  if (!src_extension)

     {
     {

-      /* -o was specified.  The precise -o name will be used for FTABLE.
-         For other output files, remove the ".c" or ".tab.c" suffix.  */
-      name_base = spec_outfile;
-#ifdef MSDOS
-      strlwr (name_base);
-#endif /* MSDOS */
-      /* BASE_LENGTH includes ".tab" but not ".c".  */
-      base_length = strlen (name_base);
-      if (!strcmp (name_base + base_length - 2, ".c"))
-       base_length -= 2;
-      /* SHORT_BASE_LENGTH includes neither ".tab" nor ".c".  */
-      short_base_length = base_length;
-      if (!strncmp (name_base + short_base_length - 4, ".tab", 4))
-       short_base_length -= 4;
-      else if (!strncmp (name_base + short_base_length - 4, "_tab", 4))
-       short_base_length -= 4;
+      src_extension = tr(ext, 'y', 'c');
+      src_extension = tr(src_extension, 'Y', 'C');

     }
     }

-  else if (spec_file_prefix)
+  if (!header_extension)

     {
     {

-      /* -b was specified.  Construct names from it.  */
-      /* SHORT_BASE_LENGTH includes neither ".tab" nor ".c".  */
-      short_base_length = strlen (spec_file_prefix);
-      /* Count room for `.tab'.  */
-      base_length = short_base_length + 4;
-      name_base = XMALLOC (char, base_length + 1);
-      /* Append `.tab'.  */
-      strcpy (name_base, spec_file_prefix);
-#ifdef VMS
-      strcat (name_base, "_tab");
-#else
-      strcat (name_base, ".tab");
-#endif
-#ifdef MSDOS
-      strlwr (name_base);
-#endif /* MSDOS */
+      header_extension = tr(ext, 'y', 'h');
+      header_extension = tr(header_extension, 'Y', 'H');

     }
     }

-  else
-    {
-      /* -o was not specified; compute output file name from input
-         or use y.tab.c, etc., if -y was specified.  */
-
-      static char FIXED_NAME_BASE[] = "y.y";
+}

 
 

-      name_base = yacc_flag ? FIXED_NAME_BASE : infile;
+/* Computes extensions from the given c source file extension. */
+static void
+compute_exts_from_src(const char *ext)
+{
+  if (!src_extension)
+    src_extension = xstrdup(ext);
+  if (!header_extension)
+    {
+      header_extension = tr(ext, 'c', 'h');
+      header_extension = tr(header_extension, 'C', 'H');
+    }
+}

 
 

-      /* BASE_LENGTH gets length of NAME_BASE, sans ".y" suffix if any.  */
+/* FIXME: Should use xstrndup. */

 
 

-      base_length = strlen (name_base);
-      if (!strcmp (name_base + base_length - 2, ".y"))
-       base_length -= 2;
-      short_base_length = base_length;
+static void
+compute_base_names (void)
+{
+  size_t base_length;
+  size_t short_base_length;
+  size_t ext_index;

 
 

-#ifdef VMS
-      name_base = stringappend (name_base, short_base_length, "_tab");
-#else
-#ifdef MSDOS
-      name_base = stringappend (name_base, short_base_length, "_tab");
-#else
-      name_base = stringappend (name_base, short_base_length, ".tab");
-#endif /* not MSDOS */
-#endif
-      base_length = short_base_length + 4;
-    }
+  /* If --output=foo.c was specified (SPEC_OUTFILE == foo.c),
+     BASE_NAME and SHORT_BASE_NAME are `foo'.

 
 

-  finput = xfopen (infile, "r");
+     If --output=foo.tab.c was specified, BASE_NAME is `foo.tab' and
+     SHORT_BASE_NAME is `foo'.

 
 

-  if (!no_parser_flag)
+     The precise -o name will be used for FTABLE.  For other output
+     files, remove the ".c" or ".tab.c" suffix.  */
+  if (spec_outfile)

     {
     {

-      filename = getenv ("BISON_SIMPLE");

 #ifdef MSDOS
 #ifdef MSDOS

-      /* File doesn't exist in current directory; try in INIT directory.  */
-      cp = getenv ("INIT");
-      if (filename == 0 && cp != NULL)
+      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)

        {
        {

-         filename = XMALLOC (char, strlen (cp) + strlen (PFILE) + 2);
-         strcpy (filename, cp);
-         cp = filename + strlen (filename);
-         *cp++ = '/';
-         strcpy (cp, PFILE);
+         base_length -= strlen (spec_outfile + ext_index);
+         compute_exts_from_src(spec_outfile + ext_index);

        }
        }

-#endif /* MSDOS */
-      fparser = xfopen (filename ? filename : PFILE, "r");
+
+      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 (verbose_flag)
+  /* If --file-prefix=foo was specified, BASE_NAME and SHORT_BASE_NAME
+     are `foo'.
+
+     Construct names from it.  */
+  if (spec_file_prefix)

     {
 #ifdef MSDOS
     {
 #ifdef MSDOS

-      outfile = stringappend (name_base, short_base_length, ".out");
-#else
-      /* We used to use just .out if spec_name_prefix (-p) was used,
-         but that conflicts with Posix.  */
-      outfile = stringappend (name_base, short_base_length, ".output");
-#endif
-      foutput = xfopen (outfile, "w");
-    }
+      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);

 
 

-  if (no_parser_flag)
-    {
-      /* use permanent name for actions file */
-      actfile = stringappend (name_base, short_base_length, ".act");
+      return;

     }
 
     }
 

-  if (defines_flag)
-    {
-      defsfile = stringappend (name_base, base_length, ".h");
-    }
+  /* 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'.

 
 

-  /* These are opened by `done' or `open_extra_files', if at all */
-  if (spec_outfile)
-    tabfile = spec_outfile;
-  else
-    tabfile = stringappend (name_base, base_length, ".c");
+     If --yacc is used, do as if the input file was `y.y'.  */
+  {
+    const char *name_base = yacc_flag ? "y.y" : infile;

 
 

-#ifdef VMS
-  attrsfile = stringappend (name_base, short_base_length, "_stype.h");
-  guardfile = stringappend (name_base, short_base_length, "_guard.c");
-#else
-#ifdef MSDOS
-  attrsfile = stringappend (name_base, short_base_length, ".sth");
-  guardfile = stringappend (name_base, short_base_length, ".guc");
-#else
-  attrsfile = stringappend (name_base, short_base_length, ".stype.h");
-  guardfile = stringappend (name_base, short_base_length, ".guard.c");
-#endif /* not MSDOS */
-#endif /* not VMS */
+    /* BASE_LENGTH gets length of BASE_NAME, sans ".y" suffix if any.  */

 
 

-  /* Initialize the obstacks. */
-  obstack_init (&action_obstack);
-  obstack_init (&attrs_obstack);
-  obstack_init (&table_obstack);
-  obstack_init (&defines_obstack);
-}
+    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);

 
 

-/*--------------------------------------------------------------------.
-| Open the output files needed only for the semantic parser.  This    |
-| is done when %semantic_parser is seen in the declarations section.  |
-`--------------------------------------------------------------------*/
+    base_name = XMALLOC (char,
+                        strlen (short_base_name) + strlen (EXT_TAB) + 1);
+    stpcpy (stpcpy (base_name, short_base_name), EXT_TAB);

 
 

-void
-open_extra_files (void)
-{
-  int c;
-  char *filename;
+    return;
+  }
+}

 
 

-  xfclose (fparser);
+/*-----------------------------------------------------------------.
+| Open the input file.  Look for the skeletons.  Find the names of |
+| the output files.  Prepare the obstacks.                         |
+`-----------------------------------------------------------------*/

 
 

-  if (!no_parser_flag)
-    {
-      filename = (char *) getenv ("BISON_HAIRY");
-#ifdef MSDOS
-      {
-       /* File doesn't exist in current directory; try in INIT
-          directory.  */
-       char *cp = getenv ("INIT");
-       if (filename == 0 && cp != NULL)
-         {
-           filename = XMALLOC (char, strlen (cp) + strlen (PFILE1) + 2);
-           strcpy (filename, cp);
-           cp = filename + strlen (filename);
-           *cp++ = '/';
-           strcpy (cp, PFILE1);
-         }
-      }
-#endif
-      fparser = xfopen (filename ? filename : PFILE1, "r");
-    }
+void
+open_files (void)
+{
+  finput = xfopen (infile, "r");

 
 

-  fguard = xfopen (guardfile, "w");
+  /* Initialize the obstacks. */
+  obstack_init (&action_obstack);
+  obstack_init (&attrs_obstack);
+  obstack_init (&table_obstack);
+  obstack_init (&defines_obstack);
+  obstack_init (&guard_obstack);
+  obstack_init (&output_obstack);
+  obstack_init (&graph_obstack);

 }
 
 
 }
 
 

+

 /*-----------------------------------------------------.
 | Close the open files, produce all the output files.  |
 `-----------------------------------------------------*/
 /*-----------------------------------------------------.
 | Close the open files, produce all the output files.  |
 `-----------------------------------------------------*/


@@ -383,25 +361,54 @@ open_extra_files (void)
 void
 output_files (void)
 {
 void
 output_files (void)
 {

-  xfclose (fguard);

   xfclose (finput);
   xfclose (finput);

-  xfclose (fparser);
-  xfclose (foutput);
+
+  compute_base_names ();
+
+  /* Set default extensions */
+  if (!src_extension)
+    src_extension = ".c";
+  if (!header_extension)
+    header_extension = ".h";
+
+  attrsfile = stringappend (short_base_name, EXT_STYPE_H);
+#ifndef MSDOS
+  stringappend (attrsfile, header_extension);
+#endif /* MSDOS */

 
   /* Output the main file.  */
 
   /* Output the main file.  */

-  obstack_save (&table_obstack, tabfile);
+  if (spec_outfile)
+    obstack_save (&table_obstack, spec_outfile);
+  else
+    obstack_save (&table_obstack,  stringappend (base_name, src_extension));

 
   /* Output the header file if wanted. */
   if (defines_flag)
 
   /* Output the header file if wanted. */
   if (defines_flag)

-    obstack_save (&defines_obstack, defsfile);
+    obstack_save (&defines_obstack, stringappend (base_name, header_extension));

 
 

-  /* If we output only the table, dump the actions in ACTFILE.
-     */
+  /* If we output only the table, dump the actions in ACTFILE. */

   if (no_parser_flag)
   if (no_parser_flag)

-    obstack_save (&action_obstack, actfile);
+    obstack_save (&action_obstack, stringappend (short_base_name, ".act"));

 
   /* If we produced a semantic parser ATTRS_OBSTACK must be dumped
      into its own file, ATTTRSFILE.  */
   if (semantic_parser)
 
   /* If we produced a semantic parser ATTRS_OBSTACK must be dumped
      into its own file, ATTTRSFILE.  */
   if (semantic_parser)

-    obstack_save (&attrs_obstack, attrsfile);
+    {
+      char *temp_name;
+
+      obstack_save (&attrs_obstack, attrsfile);
+      temp_name = stringappend (short_base_name, EXT_GUARD_C);
+#ifndef MSDOS
+      temp_name = stringappend (temp_name, src_extension);
+#endif /* MSDOS */
+      obstack_save (&guard_obstack, temp_name);
+    }
+
+  if (verbose_flag)
+    /* We used to use just .out if spec_name_prefix (-p) was used, but
+       that conflicts with Posix.  */
+    obstack_save (&output_obstack, stringappend (short_base_name, EXT_OUTPUT));
+
+  if (graph_flag)
+    obstack_save (&graph_obstack, stringappend (short_base_name, ".vcg"));

 }
 }