]> git.saurik.com Git - bison.git/blobdiff - src/files.c
2007-02-07 Paolo Bonzini <bonzini@gnu.org>
[bison.git] / src / files.c
index f2092b273aa913c6aa6cdb960be85fbab1a1e8ca..06334f8b118e013092b80b1d3ade10c8ce39912b 100644 (file)
@@ -1,7 +1,7 @@
 /* Open and close files for Bison.
 
 /* Open and close files for Bison.
 
-   Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002, 2003, 2004, 2005
-   Free Software Foundation, Inc.
+   Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002, 2003, 2004,
+   2005, 2006, 2007 Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
 
    This file is part of Bison, the GNU Compiler Compiler.
 
    Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.  */
 
    Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.  */
 
-
+#include <config.h>
 #include "system.h"
 
 #include <error.h>
 #include "system.h"
 
 #include <error.h>
+#include <dirname.h>
 #include <get-errno.h>
 #include <quote.h>
 #include <get-errno.h>
 #include <quote.h>
+#include <stdio-safer.h>
 #include <xstrndup.h>
 
 #include "complain.h"
 #include "files.h"
 #include "getargs.h"
 #include "gram.h"
 #include <xstrndup.h>
 
 #include "complain.h"
 #include "files.h"
 #include "getargs.h"
 #include "gram.h"
-#include "stdio-safer.h"
-
-/* From basename.c.  Almost a lie, as it returns a char *. */
-const char *base_name (char const *name);
-
-FILE *finput = NULL;
-
-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
@@ -49,26 +42,45 @@ 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 *spec_verbose_file = NULL;  /* for --verbose. */
+char *spec_graph_file = NULL;    /* for -g. */
+char *spec_defines_file = NULL;  /* for --defines. */
+char *parser_file_name;
+
+/* All computed output file names.  */
+static char **file_names = NULL;
+static int file_names_count = 0;
 
 uniqstr grammar_file = NULL;
 uniqstr current_file = 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'.
+
+   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'.
+
+   If --output was not specified but --file-prefix=dir/foo was specified,
+   ALL_BUT_EXT = `foo.tab' and ALL_BUT_TAB_EXT = `foo'.
+
+   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'.
 
 
-/* Prefix used to generate output file names.  */
-char *short_base_name = NULL;
+   If neither --output nor --file was specified, DIR_PREFIX is the
+   empty string (meaning the current directory); otherwise it is
+   `dir/'.  */
+
+char *all_but_ext;
+static char *all_but_tab_ext;
+char *dir_prefix;
 
 /* C source file extension (the parser source).  */
 
 /* C source file extension (the parser source).  */
-static char const *src_extension = NULL;
+static char *src_extension = NULL;
 /* Header file extension (if option ``-d'' is specified).  */
 /* Header file extension (if option ``-d'' is specified).  */
-static char const *header_extension = NULL;
+static char *header_extension = NULL;
 \f
 /*-----------------------------------------------------------------.
 | Return a newly allocated string composed of the concatenation of |
 \f
 /*-----------------------------------------------------------------.
 | Return a newly allocated string composed of the concatenation of |
@@ -121,35 +133,37 @@ xfclose (FILE *ptr)
 }
 \f
 
 }
 \f
 
-/*---------------------------------------------------------------------.
-| Compute FULL_BASE_NAME, SHORT_BASE_NAME and output files extensions. |
-`---------------------------------------------------------------------*/
+/*------------------------------------------------------------------.
+| Compute ALL_BUT_EXT, ALL_BUT_TAB_EXT 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)
+/* In the string S, replace all characters FROM by TO.  */
+static void
+tr (char *s, char from, char to)
 {
 {
-  char *temp;
-  char *out = xmalloc (strlen (in) + 1);
-
-  for (temp = out; *in; in++, out++)
-    if (*in == from)
-      *out = to;
-    else
-      *out = *in;
-  *out = 0;
-  return (temp);
+  for (; *s; s++)
+    if (*s == from)
+      *s = to;
 }
 
 /* Compute extensions from the grammar file extension.  */
 static void
 compute_exts_from_gf (const char *ext)
 {
 }
 
 /* Compute 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');
+  if (strcmp (ext, ".y") == 0)
+    {
+      src_extension = xstrdup (language->src_extension);
+      header_extension = xstrdup (language->header_extension);
+    }
+  else
+    {
+      src_extension = xstrdup (ext);
+      header_extension = xstrdup (ext);
+      tr (src_extension, 'y', 'c');
+      tr (src_extension, 'Y', 'C');
+      tr (header_extension, 'y', 'h');
+      tr (header_extension, 'Y', 'H');
+    }
 }
 
 /* Compute extensions from the given c source file extension.  */
 }
 
 /* Compute extensions from the given c source file extension.  */
@@ -160,8 +174,9 @@ compute_exts_from_src (const char *ext)
      so the extenions must be computed unconditionally from the file name
      given by this option.  */
   src_extension = xstrdup (ext);
      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');
+  header_extension = xstrdup (ext);
+  tr (header_extension, 'c', 'h');
+  tr (header_extension, 'C', 'H');
 }
 
 
 }
 
 
@@ -197,7 +212,7 @@ static void
 file_name_split (const char *file_name,
                 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 (file_name);
+  *base = last_component (file_name);
 
   /* Look for the extension, i.e., look for the last dot. */
   *ext = strrchr (*base, '.');
 
   /* Look for the extension, i.e., look for the last dot. */
   *ext = strrchr (*base, '.');
@@ -218,29 +233,27 @@ file_name_split (const char *file_name,
 
 
 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),
-     FULL_BASE_NAME and SHORT_BASE_NAME are `foo'.
-
-     If --output=foo.tab.c was specified, FULL_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)
     {
       file_name_split (spec_outfile, &base, &tab, &ext);
 
      The precise -o name will be used for FTABLE.  For other output
      files, remove the ".c" or ".tab.c" suffix.  */
   if (spec_outfile)
     {
       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))));
@@ -248,40 +261,37 @@ compute_base_names (void)
       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 =
-            `foo'.  */
-         short_base_name = xstrdup (spec_file_prefix);
+         /* If --file-prefix=foo was specified, ALL_BUT_TAB_EXT = `foo'.  */
+         dir_prefix = xstrndup (grammar_file, base - grammar_file);
+         all_but_tab_ext = xstrdup (spec_file_prefix);
        }
       else if (yacc_flag)
        {
        }
       else if (yacc_flag)
        {
-         /* If --yacc, then the output is `y.tab.c'. */
-         short_base_name = xstrdup ("y");
+         /* If --yacc, then the output is `y.tab.c'.  */
+         dir_prefix = xstrdup ("");
+         all_but_tab_ext = xstrdup ("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'.  */
-         file_name_split (grammar_file, &base, &tab, &ext);
-         short_base_name =
-           xstrndup (base,
-                     (strlen (base) - (ext ? strlen (ext) : 0)));
+         dir_prefix = xstrdup ("");
+         all_but_tab_ext =
+           xstrndup (base, (strlen (base) - (ext ? strlen (ext) : 0)));
        }
 
        }
 
-      full_base_name = xmalloc (strlen (short_base_name)
-                               + strlen (TAB_EXT) + 1);
-      stpcpy (stpcpy (full_base_name, short_base_name), TAB_EXT);
+      if (language->add_tab)
+        all_but_ext = concat2 (all_but_tab_ext, TAB_EXT);
+      else
+        all_but_ext = xstrdup (all_but_tab_ext);
 
       /* Compute the extensions from the grammar file name.  */
 
       /* Compute the extensions from the grammar file name.  */
-      file_name_split (grammar_file, &base, &tab, &ext);
       if (ext && !yacc_flag)
        compute_exts_from_gf (ext);
     }
       if (ext && !yacc_flag)
        compute_exts_from_gf (ext);
     }
@@ -294,44 +304,69 @@ compute_base_names (void)
 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 ();
+  compute_file_name_parts ();
 
   /* If not yet done. */
   if (!src_extension)
 
   /* If not yet done. */
   if (!src_extension)
-    src_extension = ".c";
+    src_extension = xstrdup (".c");
   if (!header_extension)
   if (!header_extension)
-    header_extension = ".h";
+    header_extension = xstrdup (".h");
 
 
-  name[names++] = parser_file_name =
-    spec_outfile ? spec_outfile : concat2 (full_base_name, src_extension);
+  parser_file_name =
+    (spec_outfile
+     ? xstrdup (spec_outfile)
+     : concat2 (all_but_ext, src_extension));
 
   if (defines_flag)
     {
       if (! spec_defines_file)
 
   if (defines_flag)
     {
       if (! spec_defines_file)
-       spec_defines_file = concat2 (full_base_name, header_extension);
-      name[names++] = spec_defines_file;
+       spec_defines_file = concat2 (all_but_ext, header_extension);
     }
 
   if (graph_flag)
     {
       if (! spec_graph_file)
     }
 
   if (graph_flag)
     {
       if (! spec_graph_file)
-       spec_graph_file = concat2 (short_base_name, ".vcg");
-      name[names++] = spec_graph_file;
+       spec_graph_file = concat2 (all_but_tab_ext, ".dot");
+      output_file_name_check (spec_graph_file);
     }
 
   if (report_flag)
     {
     }
 
   if (report_flag)
     {
-      spec_verbose_file = concat2 (short_base_name, OUTPUT_EXT);
-      name[names++] = spec_verbose_file;
+      spec_verbose_file = concat2 (all_but_tab_ext, OUTPUT_EXT);
+      output_file_name_check (spec_verbose_file);
     }
 
     }
 
-  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]));
+  free (all_but_tab_ext);
+  free (src_extension);
+  free (header_extension);
+}
+
+void
+output_file_name_check (char const *file_name)
+{
+  {
+    int i;
+    for (i = 0; i < file_names_count; i++)
+      if (0 == strcmp (file_names[i], file_name))
+        warn (_("conflicting outputs to file %s"), quote (file_name));
+  }
+  file_names = xnrealloc (file_names, ++file_names_count, sizeof *file_names);
+  file_names[file_names_count-1] = xstrdup (file_name);
+}
+
+void
+output_file_names_free (void)
+{
+  free (all_but_ext);
+  free (spec_verbose_file);
+  free (spec_graph_file);
+  free (spec_defines_file);
+  free (parser_file_name);
+  free (dir_prefix);
+  {
+    int i;
+    for (i = 0; i < file_names_count; i++)
+      free (file_names[i]);
+  }
+  free (file_names);
 }
 }