* src/reader.c, src/reader.h (tags): Remove.

[bison.git] / src / files.c

diff --git a/src/files.c b/src/files.c
index 2d289fee0a2a6265bf754e2fe0a5176b23225bdf..0b958c1ae40d4c0a8414cdab91ce6e88df20f84f 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,22 +22,23 @@
 #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;
 
 char *spec_outfile = NULL;     /* for -o. */
 struct obstack output_obstack;
 
 char *spec_outfile = NULL;     /* for -o. */

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


@@ -45,12 +46,12 @@ char *attrsfile = NULL;
 static char *base_name = NULL;
 static char *short_base_name = NULL;
 
 static char *base_name = NULL;
 static char *short_base_name = NULL;
 

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


@@ -119,19 +163,6 @@ xfclose (FILE *ptr)
   return result;
 }
 
   return result;
 }
 

-/*--------------------------------------------------.
-| Save the content of the obstack OBS in FILENAME.  |
-`--------------------------------------------------*/
-
-static void
-obstack_save (struct obstack *obs, const char *filename)
-{
-  FILE *out = xfopen (filename, "w");
-  size_t size = obstack_object_size (obs);
-  fwrite (obstack_finish (obs), 1, size, 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 |


@@ -143,32 +174,57 @@ 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_name) + 2);
-      sprintf (res, "%s%c%s", cp, '/', skeleton_name);
+      /* 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)
     res = skeleton_name;
 
   return res;
 }
   if (!res)
     res = skeleton_name;
 
   return res;
 }

-

 \f
 \f

+

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


@@ -184,12 +240,12 @@ 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. */
+/* Gets the extension index in FILENAME. Returns 0 if fails to
+   find an extension.  */

 static int
 static int

-get_extension_index(const char *filename)
+get_extension_index (const char *filename)

 {
 {

-  int  len;
+  int len;

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


@@ -207,21 +263,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. */


@@ -233,10 +292,6 @@ compute_base_names (void)
   size_t short_base_length;
   size_t ext_index;
 
   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'.
 


@@ -254,14 +309,15 @@ compute_base_names (void)
       base_length = strlen (spec_outfile);
 
       ext_index = get_extension_index (spec_outfile);
       base_length = strlen (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);
        }
 
       base_name = strndup (spec_outfile, base_length);


@@ -288,6 +344,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;
     }
 


@@ -304,14 +369,14 @@ compute_base_names (void)
     base_length = strlen (name_base);
 
     ext_index = get_extension_index (name_base);
     base_length = strlen (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,73 +390,36 @@ compute_base_names (void)
   }
 }
 
   }
 }
 

-/*-----------------------------------------------------------------.
-| Open the input file.  Look for the skeletons.  Find the names of |
-| the output files.  Prepare the obstacks.                         |
-`-----------------------------------------------------------------*/
-
-void
-open_files (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);
-}
-
-
-
-/*-----------------------------------------------------.
-| Close the open files, produce all the output files.  |
-`-----------------------------------------------------*/
+/*-------------------------------------------------------.
+| Close the open files, compute the output files names.  |
+`-------------------------------------------------------*/

 
 void
 
 void

-output_files (void)
+compute_output_file_names (void)

 {
 {

-  xfclose (finput);
-

   compute_base_names ();
 
   compute_base_names ();
 

-  attrsfile = stringappend (short_base_name, EXT_STYPE_H);
-#ifndef MSDOS
-  stringappend (attrsfile, header_extension);
-#endif /* MSDOS */
+  parser_file_name =
+    spec_outfile ? spec_outfile : stringappend (base_name, src_extension);

 
 

-  /* Output the main file.  */
-  if (spec_outfile)
-    obstack_save (&table_obstack, spec_outfile);
-  else
-    obstack_save (&table_obstack,  stringappend (base_name, src_extension));
+  /* If not yet done. */
+  if (!src_extension)
+    src_extension = ".c";
+  if (!header_extension)
+    header_extension = ".h";

 
 

-  /* Output the header file if wanted. */
-  if (defines_flag)
-    obstack_save (&defines_obstack, stringappend (base_name, header_extension));
+  /* It the defines filename if not given, we create it.  */
+  if (!spec_defines_file)
+    spec_defines_file = stringappend (base_name, header_extension);

 
 

-  /* If we output only the table, dump the actions in ACTFILE. */
-  if (no_parser_flag)
-    obstack_save (&action_obstack, stringappend (short_base_name, ".act"));
+  /* It the graph filename if not given, we create it.  */
+  if (!spec_graph_file)
+    spec_graph_file = stringappend (short_base_name, ".vcg");

 
 

-  /* If we produced a semantic parser ATTRS_OBSTACK must be dumped
-     into its own file, ATTTRSFILE.  */
-  if (semantic_parser)
-    {
-      char *temp_name;
+  spec_verbose_file = stringappend (short_base_name, EXT_OUTPUT);

 
 

-      obstack_save (&attrs_obstack, attrsfile);
-      temp_name = stringappend (short_base_name, EXT_GUARD_C);
+  attrsfile = stringappend (short_base_name, EXT_STYPE_H);

 #ifndef MSDOS
 #ifndef MSDOS

-      temp_name = stringappend (temp_name, src_extension);
+  attrsfile = stringappend (attrsfile, header_extension);

 #endif /* MSDOS */
 #endif /* MSDOS */

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

 }
 }