(set_goto_map): Do not subtract from the returned value of malloc.

[bison.git] / src / files.c

diff --git a/src/files.c b/src/files.c
index 11de06e7510a4b64aac10b6886ad375a5115f345..e92771fff0f1f0284a51270d457c519cccfc4642 100644 (file)
--- a/src/files.c
+++ b/src/files.c
@@ -1,5 +1,6 @@
-/* Open and close files for bison,
-   Copyright 1984, 1986, 1989, 1992, 2000, 2001, 2002
+/* Open and close files for Bison.
+
+   Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002

    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.


@@ -21,20 +22,22 @@
 
 
 #include "system.h"
 
 
 #include "system.h"

-#include "getargs.h"
+
+#include <error.h>
+#include <get-errno.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"

 
 /* 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;
 

-struct obstack action_obstack;
-struct obstack attrs_obstack;
-struct obstack output_obstack;
+struct obstack pre_prologue_obstack;
+struct obstack post_prologue_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
 
 /* 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


@@ -51,99 +54,35 @@ 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;
-char *attrsfile = 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;
 }
 

-
-/*-----------------------------------------------------------------.
-| 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 (full_base_name) +
-                           strlen (header_extension) + 1);
-      cp = stpcpy (macro_name, prefix);
-      cp = stpcpy (cp, full_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.                                                        |
 /*-----------------------------------------------------------------.
 | Try to open file NAME with mode MODE, and print an error message |
 | if fails.                                                        |


@@ -156,7 +95,7 @@ xfopen (const char *name, const char *mode)
 
   ptr = fopen (name, mode);
   if (!ptr)
 
   ptr = fopen (name, mode);
   if (!ptr)

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

 
   return ptr;
 }
 
   return ptr;
 }


@@ -165,72 +104,17 @@ 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)
-  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;
+  if (fclose (ptr) != 0)
+    error (EXIT_FAILURE, get_errno (), _("cannot close file"));

 }
 \f
 
 }
 \f
 


@@ -244,9 +128,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)


@@ -318,13 +200,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;
+    }

 }
 
 
 }
 
 


@@ -358,10 +244,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);
     }


@@ -386,24 +268,20 @@ compute_base_names (void)
       else
        {
          /* Otherwise, the short base name is computed from the input
       else
        {
          /* Otherwise, the short base name is computed from the input

-            grammar: `foo.yy' => `foo'.  */
-         filename_split (infile, &base, &tab, &ext);
+            grammar: `foo/bar.yy' => `bar'.  */
+         filename_split (grammar_file, &base, &tab, &ext);

          short_base_name =
          short_base_name =

-           xstrndup (infile,
-                     (strlen (infile) - (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);
+      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.  */
 
       /* Computes the extensions from the grammar file name.  */

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

        compute_exts_from_gf (ext);
     }
 }
        compute_exts_from_gf (ext);
     }
 }


@@ -417,24 +295,22 @@ compute_output_file_names (void)
 {
   compute_base_names ();
 
 {
   compute_base_names ();
 

-  parser_file_name =
-    spec_outfile ? spec_outfile : stringappend (full_base_name, src_extension);
-

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

+  parser_file_name =
+    spec_outfile ? spec_outfile : concat2 (full_base_name, src_extension);
+

   /* It the defines filename if not given, we create it.  */
   if (!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);
+    spec_defines_file = concat2 (full_base_name, header_extension);

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

 
 

-  attrsfile = stringappend (short_base_name, EXT_STYPE_H);
+  spec_verbose_file = concat2 (short_base_name, OUTPUT_EXT);

 }
 }