Regenerate.

[bison.git] / src / files.c

diff --git a/src/files.c b/src/files.c
index 5073f04f5780d518f1f929a1f3d859de82f58c61..4acf9e898935196df6e2ee12837b9ddd081719e2 100644 (file)
--- a/src/files.c
+++ b/src/files.c
@@ -1,5 +1,6 @@
-/* Open and close files for bison,
-   Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002
+/* Open and close files for Bison.
+
+   Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002, 2003, 2004, 2005

    Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
    Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.


@@ -16,21 +17,23 @@
 
    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
 
    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.  */
+   Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+   02110-1301, USA.  */

 
 
 #include "system.h"
 
 
 #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));
+#include <error.h>
+#include <get-errno.h>
+#include <quote.h>
+#include <xstrndup.h>

 
 

-FILE *finput = NULL;
+#include "complain.h"
+#include "dirname.h"
+#include "files.h"
+#include "getargs.h"
+#include "gram.h"
+#include "stdio-safer.h"

 
 struct obstack pre_prologue_obstack;
 struct obstack post_prologue_obstack;
 
 struct obstack pre_prologue_obstack;
 struct obstack post_prologue_obstack;


@@ -42,60 +45,55 @@ struct obstack post_prologue_obstack;
    NULL), then the %directive is ignored.  As a result, %name-prefix,
    for instance, will not be honored.  */
 
    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 const *spec_outfile = NULL;       /* for -o. */
+char const *spec_file_prefix = NULL;   /* for -b. */
+char const *spec_name_prefix = NULL;   /* for -p. */
+char const *spec_verbose_file = NULL;  /* for --verbose. */
+char const *spec_graph_file = NULL;    /* for -g. */
+char const *spec_defines_file = NULL;  /* for --defines. */
+char const *parser_file_name;

 
 

-char *infile = NULL;
+uniqstr grammar_file = NULL;
+uniqstr current_file = NULL;

 
 

-static char *full_base_name = NULL;
+/* If --output=dir/foo.c was specified,
+   DIR_PREFIX is `dir/' and ALL_BUT_EXT and ALL_BUT_TAB_EXT are `dir/foo'.

 
 

-/* Prefix used to generate output file names.  */
-char *short_base_name = NULL;
+   If --output=dir/foo.tab.c was specified, DIR_PREFIX is `dir/',
+   ALL_BUT_EXT is `dir/foo.tab', and ALL_BUT_TAB_EXT is `dir/foo'.

 
 

-/* Infix used to generate output file names (i.e., `.tab', or `_tab',
-   or `').  */
-char *output_infix = NULL;
+   If --output was not specified but --file-prefix=dir/foo was specified,
+   ALL_BUT_EXT = `foo.tab' and ALL_BUT_TAB_EXT = `foo'.

 
 

-/* 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
+   If neither --output nor --file was specified but the input grammar
+   is name dir/foo.y, ALL_BUT_EXT and ALL_BUT_TAB_EXT are `foo'.

 
 

-/*--------------------------.
-| 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;
-}
+   If neither --output nor --file was specified, DIR_PREFIX is the
+   empty string (meaning the current directory); otherwise it is
+   `dir/'.  */

 
 

+static char const *all_but_ext;
+static char const *all_but_tab_ext;
+char const *dir_prefix;

 
 

+/* C source file extension (the parser source).  */
+static char const *src_extension = NULL;
+/* Header file extension (if option ``-d'' is specified).  */
+static char const *header_extension = NULL;
+\f

 /*-----------------------------------------------------------------.
 | Return a newly allocated string composed of the concatenation of |
 /*-----------------------------------------------------------------.
 | Return a newly allocated string composed of the concatenation of |

-| STRING1, and STRING2.                                            |
+| STR1, and STR2.                                                  |

 `-----------------------------------------------------------------*/
 
 `-----------------------------------------------------------------*/
 

-char*
-stringappend (const char *string1, const char *string2)
+static char *
+concat2 (char const *str1, char const *str2)

 {
 {

-  size_t len = strlen (string1) + strlen (string2);
-  char *res = XMALLOC (char, len + 1);
+  size_t len = strlen (str1) + strlen (str2);
+  char *res = xmalloc (len + 1);

   char *cp;
   char *cp;

-  cp = stpcpy (res, string1);
-  cp = stpcpy (cp, string2);
+  cp = stpcpy (res, str1);
+  cp = stpcpy (cp, str2);

   return res;
 }
 
   return res;
 }
 


@@ -109,9 +107,9 @@ xfopen (const char *name, const char *mode)
 {
   FILE *ptr;
 
 {
   FILE *ptr;
 

-  ptr = fopen (name, mode);
+  ptr = fopen_safer (name, mode);

   if (!ptr)
   if (!ptr)

-    error (2, errno, _("cannot open file `%s'"), name);
+    error (EXIT_FAILURE, get_errno (), _("cannot open file `%s'"), name);

 
   return ptr;
 }
 
   return ptr;
 }


@@ -120,88 +118,31 @@ 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.  |
 `-------------------------------------------------------------*/
 

-int
+void

 xfclose (FILE *ptr)
 {
 xfclose (FILE *ptr)
 {

-  int result;
-

   if (ptr == NULL)
   if (ptr == NULL)

-    return 0;
+    return;

 
 

-  result = fclose (ptr);
-  if (result == EOF)
-    error (2, errno, _("cannot close file"));
+  if (ferror (ptr))
+    error (EXIT_FAILURE, 0, _("I/O error"));

 
 

-  return result;
+  if (fclose (ptr) != 0)
+    error (EXIT_FAILURE, get_errno (), _("cannot close file"));

 }
 }

-
+\f

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

-| Return the path to the skeleton which locaction might be given in |
-| ENVVAR, otherwise return SKELETON_NAME.                           |
+| Compute ALL_BUT_EXT, ALL_BUT_TAB_EXT and output files extensions. |

 `------------------------------------------------------------------*/
 
 `------------------------------------------------------------------*/
 

-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;
 /* 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);
+  char *out = xmalloc (strlen (in) + 1);

 
   for (temp = out; *in; in++, out++)
     if (*in == from)
 
   for (temp = out; *in; in++, out++)
     if (*in == from)


@@ -212,7 +153,7 @@ tr (const char *in, char from, char to)
   return (temp);
 }
 
   return (temp);
 }
 

-/* Computes extensions from the grammar file extension. */
+/* Compute extensions from the grammar file extension.  */

 static void
 compute_exts_from_gf (const char *ext)
 {
 static void
 compute_exts_from_gf (const char *ext)
 {


@@ -222,7 +163,7 @@ compute_exts_from_gf (const char *ext)
   header_extension = tr (header_extension, 'Y', 'H');
 }
 
   header_extension = tr (header_extension, 'Y', 'H');
 }
 

-/* Computes extensions from the given c source file extension. */
+/* Compute extensions from the given c source file extension.  */

 static void
 compute_exts_from_src (const char *ext)
 {
 static void
 compute_exts_from_src (const char *ext)
 {


@@ -235,8 +176,8 @@ compute_exts_from_src (const char *ext)
 }
 
 
 }
 
 

-/* Decompose FILENAME in four parts: *BASE, *TAB, and *EXT, the fourth
-   part, (the directory) is ranging from FILENAME to the char before
+/* Decompose FILE_NAME in four parts: *BASE, *TAB, and *EXT, the fourth
+   part, (the directory) is ranging from FILE_NAME 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.
    *BASE, so we don't need an additional parameter.
 
    *EXT points to the last period in the basename, or NULL if none.


@@ -245,7 +186,7 @@ compute_exts_from_src (const char *ext)
    `.tab' or `_tab' if present right before *EXT, or is NULL. *TAB
    cannot be equal to *BASE.
 
    `.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.
+   None are allocated, they are simply pointers to parts of FILE_NAME.

    Examples:
 
    '/tmp/foo.tab.c' -> *BASE = 'foo.tab.c', *TAB = '.tab.c', *EXT =
    Examples:
 
    '/tmp/foo.tab.c' -> *BASE = 'foo.tab.c', *TAB = '.tab.c', *EXT =


@@ -264,113 +205,106 @@ compute_exts_from_src (const char *ext)
    'foo' -> *BASE = 'foo', *TAB = NULL, *EXT = NULL.  */
 
 static void
    'foo' -> *BASE = 'foo', *TAB = NULL, *EXT = NULL.  */
 
 static void

-filename_split (const char *filename,
-               const char **base, const char **tab, const char **ext)
+file_name_split (const char *file_name,
+                const char **base, const char **tab, const char **ext)

 {
 {

-  *base = base_name (filename);
+  *base = base_name (file_name);

 
   /* Look for the extension, i.e., look for the last dot. */
   *ext = strrchr (*base, '.');
   *tab = NULL;
 
 
   /* 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
+  /* If there is an extension, check if there is a `.tab' part right

      before.  */
      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");
+  if (*ext)
+    {
+      size_t baselen = *ext - *base;
+      size_t dottablen = 4;
+      if (dottablen < baselen
+         && (strncmp (*ext - dottablen, ".tab", dottablen) == 0
+             || strncmp (*ext - dottablen, "_tab", dottablen) == 0))
+       *tab = *ext - dottablen;
+    }

 }
 
 
 }
 
 

-/* FIXME: Should use xstrndup. */
-

 static void
 static void

-compute_base_names (void)
+compute_file_name_parts (void)

 {
   const char *base, *tab, *ext;
 
 {
   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'.
+  /* Compute ALL_BUT_EXT and ALL_BUT_TAB_EXT from SPEC_OUTFILE
+     or GRAMMAR_FILE.

 
      The precise -o name will be used for FTABLE.  For other output
      files, remove the ".c" or ".tab.c" suffix.  */
   if (spec_outfile)
     {
 
      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);
+      file_name_split (spec_outfile, &base, &tab, &ext);
+      dir_prefix = xstrndup (spec_outfile, base - spec_outfile);

 
 

-      /* The full base name goes up the EXT, excluding it. */
-      full_base_name =
+      /* ALL_BUT_EXT goes up the EXT, excluding it. */
+      all_but_ext =

        xstrndup (spec_outfile,
                  (strlen (spec_outfile) - (ext ? strlen (ext) : 0)));
 
        xstrndup (spec_outfile,
                  (strlen (spec_outfile) - (ext ? strlen (ext) : 0)));
 

-      /* The short base name goes up to TAB, excluding it.  */
-      short_base_name =
+      /* ALL_BUT_TAB_EXT goes up to TAB, excluding it.  */
+      all_but_tab_ext =

        xstrndup (spec_outfile,
                  (strlen (spec_outfile)
                   - (tab ? strlen (tab) : (ext ? strlen (ext) : 0))));
 
        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 (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
     {
   else
     {

+      file_name_split (grammar_file, &base, &tab, &ext);
+

       if (spec_file_prefix)
        {
       if (spec_file_prefix)
        {

-         /* If --file-prefix=foo was specified, SHORT_BASE_NAME =
+         /* If --file-prefix=foo was specified, ALL_BUT_TAB_EXT =

             `foo'.  */
             `foo'.  */

-         short_base_name = xstrdup (spec_file_prefix);
+         dir_prefix = xstrndup (grammar_file, base - grammar_file);
+         all_but_tab_ext = xstrdup (spec_file_prefix);

        }
       else if (yacc_flag)
        {
          /* If --yacc, then the output is `y.tab.c'. */
        }
       else if (yacc_flag)
        {
          /* If --yacc, then the output is `y.tab.c'. */

-         short_base_name = xstrdup ("y");
+         dir_prefix = "";
+         all_but_tab_ext = "y";

        }
       else
        {
        }
       else
        {

-         /* Otherwise, the short base name is computed from the input
+         /* Otherwise, ALL_BUT_TAB_EXT is computed from the input

             grammar: `foo/bar.yy' => `bar'.  */
             grammar: `foo/bar.yy' => `bar'.  */

-         filename_split (infile, &base, &tab, &ext);
-         short_base_name =
+         dir_prefix = "";
+         all_but_tab_ext =

            xstrndup (base,
                      (strlen (base) - (ext ? strlen (ext) : 0)));
        }
 
            xstrndup (base,
                      (strlen (base) - (ext ? strlen (ext) : 0)));
        }
 

-      /* In these cases, always append `.tab'. */
-      output_infix = xstrdup (EXT_TAB);
-
-      full_base_name = XMALLOC (char,
-                               strlen (short_base_name)
-                               + strlen (EXT_TAB) + 1);
-      stpcpy (stpcpy (full_base_name, short_base_name), EXT_TAB);
+      all_but_ext = concat2 (all_but_tab_ext, TAB_EXT);

 
 

-      /* Computes the extensions from the grammar file name.  */
-      filename_split (infile, &base, &tab, &ext);
+      /* Compute the extensions from the grammar file name.  */

       if (ext && !yacc_flag)
        compute_exts_from_gf (ext);
     }
 }
 
       if (ext && !yacc_flag)
        compute_exts_from_gf (ext);
     }
 }
 

-/*-------------------------------------------------------.
-| Close the open files, compute the output files names.  |
-`-------------------------------------------------------*/
+
+/* Compute the output file names.  Warn if we detect conflicting
+   outputs to the same file.  */

 
 void
 compute_output_file_names (void)
 {
 
 void
 compute_output_file_names (void)
 {

-  compute_base_names ();
+  char const *name[4];
+  int i;
+  int j;
+  int names = 0;
+
+  compute_file_name_parts ();

 
   /* If not yet done. */
   if (!src_extension)
 
   /* If not yet done. */
   if (!src_extension)


@@ -378,16 +312,31 @@ compute_output_file_names (void)
   if (!header_extension)
     header_extension = ".h";
 
   if (!header_extension)
     header_extension = ".h";
 

-  parser_file_name =
-    spec_outfile ? spec_outfile : stringappend (full_base_name, src_extension);
+  name[names++] = parser_file_name =
+    spec_outfile ? spec_outfile : concat2 (all_but_ext, 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);
+  if (defines_flag)
+    {
+      if (! spec_defines_file)
+       spec_defines_file = concat2 (all_but_ext, header_extension);
+      name[names++] = spec_defines_file;
+    }

 
 

-  /* It the graph filename if not given, we create it.  */
-  if (!spec_graph_file)
-    spec_graph_file = stringappend (short_base_name, ".vcg");
+  if (graph_flag)
+    {
+      if (! spec_graph_file)
+       spec_graph_file = concat2 (all_but_tab_ext, ".vcg");
+      name[names++] = spec_graph_file;
+    }
+
+  if (report_flag)
+    {
+      spec_verbose_file = concat2 (all_but_tab_ext, OUTPUT_EXT);
+      name[names++] = spec_verbose_file;
+    }

 
 

-  spec_verbose_file = stringappend (short_base_name, EXT_OUTPUT);
+  for (j = 0; j < names; j++)
+    for (i = 0; i < j; i++)
+      if (strcmp (name[i], name[j]) == 0)
+       warn (_("conflicting outputs to file %s"), quote (name[i]));

 }
 }