Sync.

[bison.git] / src / files.c

diff --git a/src/files.c b/src/files.c
index 5073f04f5780d518f1f929a1f3d859de82f58c61..5a0b2ea46d0574a8825b68b62bf7ed9cbe9cb5cd 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,19 +17,25 @@
 
    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 <error.h>
+#include <get-errno.h>
+#include <quote.h>
+#include <xstrndup.h>
+
+#include "complain.h"

 #include "files.h"
 #include "files.h"

+#include "getargs.h"

 #include "gram.h"
 #include "gram.h"

-#include "error.h"
-#include "complain.h"
+#include "stdio-safer.h"

 
 /* From basename.c.  Almost a lie, as it returns a char *. */
 
 /* From basename.c.  Almost a lie, as it returns a char *. */

-const char *base_name PARAMS ((char const *name));
+const char *base_name (char const *name);

 
 FILE *finput = NULL;
 
 
 FILE *finput = NULL;
 


@@ -50,52 +57,32 @@ char *spec_graph_file = NULL;   /* for -g. */
 char *spec_defines_file = NULL; /* for --defines. */
 char *parser_file_name = NULL;
 
 char *spec_defines_file = NULL; /* for --defines. */
 char *parser_file_name = NULL;
 

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

 
 static char *full_base_name = NULL;
 
 /* Prefix used to generate output file names.  */
 char *short_base_name = NULL;
 
 
 static char *full_base_name = NULL;
 
 /* Prefix used to generate output file names.  */
 char *short_base_name = NULL;
 

-/* Infix used to generate output file names (i.e., `.tab', or `_tab',
-   or `').  */
-char *output_infix = NULL;
-

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

-
-/*--------------------------.
-| Is SUFFIX ending STRING?  |
-`--------------------------*/
-
-int
-strsuffix (const char *string, const char *suffix)
-{
-  size_t string_len = strlen (string);
-  size_t suffix_len = strlen (suffix);
-  if (suffix_len <= string_len)
-    return !strcmp (string + string_len - suffix_len, suffix);
-  else
-    return 0;
-}
-
-

 /*-----------------------------------------------------------------.
 | Return a newly allocated string composed of the concatenation of |
 /*-----------------------------------------------------------------.
 | 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 +96,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,78 +107,23 @@ 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;
-}
-
-
-/*------------------------------------------------------------------.
-| Return the path to the skeleton which locaction might be given in |
-| ENVVAR, otherwise return SKELETON_NAME.                           |
-`------------------------------------------------------------------*/
-
-const char *
-skeleton_find (const char *envvar, const char *skeleton_name)
-{
-  const char *res = getenv (envvar);
-
-#if defined (MSDOS) || defined (_WIN32)
-  const char *cp = getenv ("INIT");
-  if (!res)
-    {
-      /* Skeleton file name without path */
-      const char *skel_name = strrchr (skeleton_name, '/');
-      if (!skel_name)
-        skel_name = strrchr (skeleton_name, '\\');
-      if (!skel_name)
-        skel_name = skeleton_name;
-      else
-        ++skel_name;
-
-      /* File doesn't exist in current directory; try in INIT directory.  */
-      if (cp)
-       {
-         res = XMALLOC (char, strlen (cp) + strlen (skel_name) + 2);
-         sprintf (res, "%s%c%s", cp, '\\', skel_name);
-       }
-      else if (access (skel_name, 4) == 0) /* Look in current dir. */
-        res = skel_name;
-      else
-       {
-         /* Look in program locations dir. */
-         extern char *program_name;
-         cp = strrchr(program_name, '\\');
-         if (!cp)
-           return skeleton_name;
-         else
-           ++cp;
-         res = XMALLOC (char, cp - program_name + strlen (skel_name) + 1);
-         strncpy (res, program_name, cp - program_name);
-         strcpy (res + (cp - program_name), skel_name);
-       }
-    }
-#endif /* defined (MSDOS) || defined (_WIN32) */
-  if (!res)
-    res = skeleton_name;
-
-  return res;
+  if (fclose (ptr) != 0)
+    error (EXIT_FAILURE, get_errno (), _("cannot close file"));

 }
 \f
 
 }
 \f
 

-/*----------------------------------------------------------------.
-| Compute BASE_NAME, SHORT_BASE_NAME and output files extensions. |
-`----------------------------------------------------------------*/
+/*---------------------------------------------------------------------.
+| Compute FULL_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.  */
 
 /* Replace all characters FROM by TO in the string IN.
    and returns a new allocated string.  */


@@ -199,9 +131,7 @@ static char *
 tr (const char *in, char from, char to)
 {
   char *temp;
 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 +142,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 +152,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)
 {


@@ -273,13 +203,17 @@ filename_split (const char *filename,
   *ext = strrchr (*base, '.');
   *tab = NULL;
 
   *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;
+    }

 }
 
 
 }
 
 


@@ -291,10 +225,10 @@ compute_base_names (void)
   const char *base, *tab, *ext;
 
   /* If --output=foo.c was specified (SPEC_OUTFILE == foo.c),
   const char *base, *tab, *ext;
 
   /* If --output=foo.c was specified (SPEC_OUTFILE == foo.c),

-     BASE_NAME and SHORT_BASE_NAME are `foo'.
+     FULL_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'.
+     If --output=foo.tab.c was specified, FULL_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.  */
 
      The precise -o name will be used for FTABLE.  For other output
      files, remove the ".c" or ".tab.c" suffix.  */


@@ -313,10 +247,6 @@ compute_base_names (void)
                  (strlen (spec_outfile)
                   - (tab ? strlen (tab) : (ext ? strlen (ext) : 0))));
 
                  (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);
     }


@@ -342,34 +272,35 @@ compute_base_names (void)
        {
          /* Otherwise, the short base name is computed from the input
             grammar: `foo/bar.yy' => `bar'.  */
        {
          /* Otherwise, the short base name is computed from the input
             grammar: `foo/bar.yy' => `bar'.  */

-         filename_split (infile, &base, &tab, &ext);
+         filename_split (grammar_file, &base, &tab, &ext);

          short_base_name =
            xstrndup (base,
                      (strlen (base) - (ext ? strlen (ext) : 0)));
        }
 
          short_base_name =
            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);
+      full_base_name = xmalloc (strlen (short_base_name)
+                               + strlen (TAB_EXT) + 1);
+      stpcpy (stpcpy (full_base_name, short_base_name), TAB_EXT);

 
 

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

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

+  char const *name[4];
+  int i;
+  int j;
+  int names = 0;
+

   compute_base_names ();
 
   /* If not yet done. */
   compute_base_names ();
 
   /* If not yet done. */


@@ -378,16 +309,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 (full_base_name, src_extension);
+
+  if (defines_flag)
+    {
+      if (! spec_defines_file)
+       spec_defines_file = concat2 (full_base_name, header_extension);
+      name[names++] = spec_defines_file;
+    }

 
 

-  /* It the defines filename if not given, we create it.  */
-  if (!spec_defines_file)
-    spec_defines_file = stringappend (full_base_name, header_extension);
+  if (graph_flag)
+    {
+      if (! spec_graph_file)
+       spec_graph_file = concat2 (short_base_name, ".vcg");
+      name[names++] = spec_graph_file;
+    }

 
 

-  /* It the graph filename if not given, we create it.  */
-  if (!spec_graph_file)
-    spec_graph_file = stringappend (short_base_name, ".vcg");
+  if (report_flag)
+    {
+      spec_verbose_file = concat2 (short_base_name, 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]));

 }
 }