* src/reader.c (symbol_list_new): Be sure to initialize all the

[bison.git] / src / files.c

diff --git a/src/files.c b/src/files.c
index 8ecb1f9ff50b98f9be077be3e9d79efa493b56c0..b3064b5a473d172cbafb872cdbf2e34f73be7fa2 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.
 


@@ -22,35 +22,37 @@
 #include "system.h"
 #include "getargs.h"
 #include "files.h"
 #include "system.h"
 #include "getargs.h"
 #include "files.h"

-#include "xalloc.h"

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

+#include "error.h"

 #include "complain.h"
 
 FILE *finput = NULL;
 
 struct obstack action_obstack;
 struct obstack attrs_obstack;
 #include "complain.h"
 
 FILE *finput = NULL;
 
 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 guard_obstack;
 struct obstack output_obstack;
 

-char *spec_outfile;    /* for -o. */
-char *spec_file_prefix; /* for -b. */
-char *spec_name_prefix; /* for -p. */
+char *spec_outfile = NULL;     /* for -o. */
+char *spec_file_prefix = NULL; /* for -b. */
+const char *spec_name_prefix = "yy";   /* 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 *infile;
-char *attrsfile;
+char *infile = NULL;
+char *attrsfile = NULL;

 
 

-static char *base_name;
-static char *short_base_name;
-
-/* C source file extension (the parser source). */
-static char *src_extension;    
-/* Header file extension (if option ``-d'' is specified). */
-static char *header_extension;
+static char *base_name = NULL;
+static char *short_base_name = 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
 \f

+

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


@@ -83,6 +85,49 @@ stringappend (const char *string1, const char *string2)
   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 (base_name) +
+                           strlen (header_extension) + 1);
+      cp = stpcpy (macro_name, prefix);
+      cp = stpcpy (cp, 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.                                                        |


@@ -132,47 +177,71 @@ obstack_save (struct obstack *obs, const char *filename)
   xfclose (out);
 }
 
   xfclose (out);
 }
 

-

 /*------------------------------------------------------------------.
 | Return the path to the skeleton which locaction might be given in |
 /*------------------------------------------------------------------.
 | Return the path to the skeleton which locaction might be given in |

-| ENVVAR, otherwise return SKELETON.                                |
+| ENVVAR, otherwise return SKELETON_NAME.                           |

 `------------------------------------------------------------------*/
 
 const char *
 `------------------------------------------------------------------*/
 
 const char *

-skeleton_find (const char *envvar, const char *skeleton)
+skeleton_find (const char *envvar, const char *skeleton_name)

 {
   const char *res = getenv (envvar);
 
 {
   const char *res = getenv (envvar);
 

-#ifdef MSDOS
-  const char *cp;
-
-  /* File doesn't exist in current directory; try in INIT directory.  */
-  if (!res && (cp = getenv ("INIT")))
+#if defined (MSDOS) || defined (_WIN32)
+  if (!res)

     {
     {

-      res = XMALLOC (char, strlen (cp) + strlen (skeleton) + 2);
-      sprintf (res, "%s%c%s", cp, '/', skeleton);
+      /* 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 /* !MSDOS */
-
+#endif /* defined (MSDOS) || defined (_WIN32) */

   if (!res)
   if (!res)

-    res = skeleton;
+    res = skeleton_name;

 
   return res;
 }
 
   return res;
 }

-

 \f
 \f

+

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

 static char *
 static char *

-tr(const char *in, char from, char to)
+tr (const char *in, char from, char to)

 {
   char *temp;
   char *out;
 {
   char *temp;
   char *out;

-  
+

   out = XMALLOC (char, strlen (in) + 1);
 
   for (temp = out; *in; in++, out++)
   out = XMALLOC (char, strlen (in) + 1);
 
   for (temp = out; *in; in++, out++)


@@ -184,15 +253,15 @@ tr(const char *in, char from, char to)
   return (temp);
 }
 
   return (temp);
 }
 

-/*  Gets the extension index in FILENAME. Returns 0 if fails to 
-    find an extension. */
-static int 
-get_extension_index(const char *filename)
+/* Gets the extension index in FILENAME. Returns 0 if fails to
+   find an extension.  */
+static int
+get_extension_index (const char *filename)

 {
 {

-  int  len;
+  int len;

 
   len = strlen (filename);
 
   len = strlen (filename);

-  
+

   if (filename[len-- - 1] == '.')
     return (0);
 
   if (filename[len-- - 1] == '.')
     return (0);
 


@@ -207,21 +276,24 @@ get_extension_index(const char *filename)
 
 /* Computes extensions from the grammar file extension. */
 static void
 
 /* Computes extensions from the grammar file extension. */
 static void

-compute_exts_from_gf(const char *ext)
+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');
+  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');

 }
 
 /* Computes extensions from the given c source file extension. */
 static void
 }
 
 /* Computes extensions from the given c source file extension. */
 static void

-compute_exts_from_src(const char *ext)
+compute_exts_from_src (const char *ext)

 {
 {

-  src_extension = xstrdup(ext);
-  header_extension = tr(ext, 'c', 'h');
-  header_extension = tr(header_extension, 'C', 'H');
+  /* We use this function when the user specifies `-o' or `--output',
+     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');

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


@@ -232,10 +304,6 @@ compute_base_names (void)
   size_t base_length;
   size_t short_base_length;
   size_t ext_index;
   size_t base_length;
   size_t short_base_length;
   size_t ext_index;

-  
-  /* Set default extensions */
-  src_extension = ".c";
-  header_extension = ".h";

 
   /* If --output=foo.c was specified (SPEC_OUTFILE == foo.c),
      BASE_NAME and SHORT_BASE_NAME are `foo'.
 
   /* If --output=foo.c was specified (SPEC_OUTFILE == foo.c),
      BASE_NAME and SHORT_BASE_NAME are `foo'.


@@ -252,18 +320,19 @@ compute_base_names (void)
 #endif /* MSDOS */
       /* BASE_LENGTH includes ".tab" but not ".c".  */
       base_length = strlen (spec_outfile);
 #endif /* MSDOS */
       /* BASE_LENGTH includes ".tab" but not ".c".  */
       base_length = strlen (spec_outfile);

-      
+

       ext_index = get_extension_index (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 the initial segment of extension contains 'c' or a 'C', I assume
+         that it is a C or C++ source file.  */

       if (ext_index)
       if (ext_index)

-       ext_index = (strspn(spec_outfile + ext_index + 1, "cC")) ? ext_index : 0;
+       ext_index =
+         (strspn (spec_outfile + ext_index + 1, "cC")) ? ext_index : 0;

       if (ext_index)
        {
          base_length -= strlen (spec_outfile + ext_index);
       if (ext_index)
        {
          base_length -= strlen (spec_outfile + ext_index);

-         compute_exts_from_src(spec_outfile + ext_index);
+         compute_exts_from_src (spec_outfile + ext_index);

        }
        }

-      
+

       base_name = strndup (spec_outfile, base_length);
       /* SHORT_BASE_LENGTH includes neither ".tab" nor ".c".  */
       short_base_length = base_length;
       base_name = strndup (spec_outfile, base_length);
       /* SHORT_BASE_LENGTH includes neither ".tab" nor ".c".  */
       short_base_length = base_length;


@@ -288,6 +357,15 @@ compute_base_names (void)
                           strlen (short_base_name) + strlen (EXT_TAB) + 1);
       stpcpy (stpcpy (base_name, short_base_name), EXT_TAB);
 
                           strlen (short_base_name) + strlen (EXT_TAB) + 1);
       stpcpy (stpcpy (base_name, short_base_name), EXT_TAB);
 

+      /* Computes the extensions from the garmmar file name.  */
+      ext_index = get_extension_index (infile);
+      /* 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 (infile + ext_index + 1, "yY")) ? ext_index : 0;
+      if (ext_index)
+       compute_exts_from_gf (infile + ext_index);
+

       return;
     }
 
       return;
     }
 


@@ -302,16 +380,16 @@ compute_base_names (void)
     /* BASE_LENGTH gets length of BASE_NAME, sans ".y" suffix if any.  */
 
     base_length = strlen (name_base);
     /* BASE_LENGTH gets length of BASE_NAME, sans ".y" suffix if any.  */
 
     base_length = strlen (name_base);

-    
+

     ext_index = get_extension_index (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 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)
     if (ext_index)

-      ext_index = (strspn(name_base + ext_index + 1, "yY")) ? ext_index : 0;
+      ext_index = (strspn (name_base + ext_index + 1, "yY")) ? ext_index : 0;

     if (ext_index)
       {
        base_length -= strlen (name_base + ext_index);
     if (ext_index)
       {
        base_length -= strlen (name_base + ext_index);

-       compute_exts_from_gf(name_base + ext_index);
+       compute_exts_from_gf (name_base + ext_index);

       }
 
     short_base_length = base_length;
       }
 
     short_base_length = base_length;


@@ -325,56 +403,56 @@ compute_base_names (void)
   }
 }
 
   }
 }
 

-/*-----------------------------------------------------------------.
-| Open the input file.  Look for the skeletons.  Find the names of |
-| the output files.  Prepare the obstacks.                         |
-`-----------------------------------------------------------------*/
+/*-------------------------------------------------------.
+| Close the open files, compute the output files names.  |
+`-------------------------------------------------------*/

 
 void
 
 void

-open_files (void)
+compute_output_file_names (void)

 {
 {

-  finput = xfopen (infile, "r");
-
-  /* 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);
-}
+  compute_base_names ();

 
 

+  parser_file_name =
+    spec_outfile ? spec_outfile : stringappend (base_name, src_extension);

 
 

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

 
 

-/*-----------------------------------------------------.
-| Close the open files, produce all the output files.  |
-`-----------------------------------------------------*/
+  /* It the defines filename if not given, we create it.  */
+  if (!spec_defines_file)
+    spec_defines_file = stringappend (base_name, header_extension);

 
 

-void
-output_files (void)
-{
-  xfclose (finput);
+  /* It the graph filename if not given, we create it.  */
+  if (!spec_graph_file)
+    spec_graph_file = stringappend (short_base_name, ".vcg");

 
 

-  compute_base_names ();
+  spec_verbose_file = stringappend (short_base_name, EXT_OUTPUT);

 
   attrsfile = stringappend (short_base_name, EXT_STYPE_H);
 #ifndef MSDOS
 
   attrsfile = stringappend (short_base_name, EXT_STYPE_H);
 #ifndef MSDOS

-  stringappend (attrsfile, header_extension);
-#endif /* MSDOS */  
+  attrsfile = stringappend (attrsfile, header_extension);
+#endif /* MSDOS */
+}

 
 

-  /* Output the main file.  */
-  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)
-    obstack_save (&defines_obstack, stringappend (base_name, header_extension));
+/*---------------------------.
+| Produce the output files.  |
+`---------------------------*/
+
+void
+output_files (void)
+{
+#if 0
+  /* Seems to be invalid now --akim. */

 
   /* If we output only the table, dump the actions in ACTFILE. */
   if (no_parser_flag)
     obstack_save (&action_obstack, stringappend (short_base_name, ".act"));
 
   /* If we output only the table, dump the actions in ACTFILE. */
   if (no_parser_flag)
     obstack_save (&action_obstack, stringappend (short_base_name, ".act"));

+  obstack_free (&action_obstack, NULL);
+#endif

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


@@ -390,8 +468,6 @@ output_files (void)
       obstack_save (&guard_obstack, temp_name);
     }
 
       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));
+  obstack_free (&guard_obstack, NULL);
+  obstack_free (&attrs_obstack, NULL);

 }
 }