* src/gram.h (rule_t): `guard' and `guard_line' are new members.

[bison.git] / src / files.c

diff --git a/src/files.c b/src/files.c
index f1cdfe6c54e859c4bb7ee1f0e5bbe6401579df12..5e01b9f80bfb64565c522258de48da7a19e7447f 100644 (file)
--- a/src/files.c
+++ b/src/files.c
@@ -22,23 +22,24 @@
 #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;

-struct obstack graph_obstack;

 
 char *spec_outfile = NULL;     /* for -o. */
 char *spec_file_prefix = NULL; /* for -b. */
 
 char *spec_outfile = NULL;     /* for -o. */
 char *spec_file_prefix = NULL; /* for -b. */

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


@@ -85,32 +86,44 @@ stringappend (const char *string1, const char *string2)
 }
 
 
 }
 
 

-/*---------------------------------------------------------------.
-|  Computes the macro name used to avoid double inclusion in the |
-|  header of the parser and store it in header_macro_name.       |
-`---------------------------------------------------------------*/
+/*-----------------------------------------------------------------.
+| 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).                                    |
+`-----------------------------------------------------------------*/

 
 

-static const char *
+char *

 compute_header_macro (void)
 {
 compute_header_macro (void)
 {

-  int ite;
-  char *macro_name;
+  const char *prefix = "BISON_";
+  char *macro_name, *cp;

 
 

-  macro_name = XMALLOC (char,
-                       strlen (base_name) +
-                       strlen (header_extension) + 1);
+  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);
+    }

 
 

-  stpcpy (macro_name, base_name);
-  strcat (macro_name, header_extension);
+  for (cp = macro_name; *cp; ++cp)
+    if (islower (*cp))
+      *cp = toupper (*cp);
+    else if (!isalnum (*cp))
+      *cp = '_';

 
 

-  for (ite = 0; macro_name[ite]; ite++)
-    if (macro_name[ite] == '.')
-      macro_name[ite] = '_';
-    else
-      {
-       if (islower (macro_name[ite]))
-         macro_name[ite] -= ('a' - 'A');
-      }

   return macro_name;
 }
 
   return macro_name;
 }
 


@@ -151,38 +164,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);
-}
-
-/*---------------------------------------------------------------------.
-| Output double inclusion protection macros and saves defines_obstack  |
-`---------------------------------------------------------------------*/
-
-static void
-defines_obstack_save (const char *filename)
-{
-  FILE *out = xfopen (filename, "w");
-  size_t size = obstack_object_size (&defines_obstack);
-  char *macro_name = compute_header_macro ();
-
-  fprintf (out, "#ifndef %s\n", macro_name);
-  fprintf (out, "# define %s\n\n", macro_name);
-  fwrite (obstack_finish (&defines_obstack), 1, size, out);
-  fprintf (out, "\n#endif /* not %s */\n", macro_name);
-
-  free (macro_name);
-  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 |


@@ -194,17 +175,42 @@ 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;
 
   if (!res)
     res = skeleton_name;
 


@@ -260,20 +266,10 @@ get_extension_index (const char *filename)
 static void
 compute_exts_from_gf (const char *ext)
 {
 static void
 compute_exts_from_gf (const char *ext)
 {

-  /* Checks if SRC_EXTENSION is NULL. In the other case, %source_extension
-     was specified in the grammar file.  */
-  if (src_extension == NULL)
-    {
-      src_extension = tr (ext, 'y', 'c');
-      src_extension = tr (src_extension, 'Y', 'C');
-    }
-  /* Checks if HEADER_EXTENSION is NULL. In the other case,
-     %header_extension was specified in the grammar file.  */
-  if (header_extension == NULL)
-    {
-      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. */
 }
 
 /* Computes extensions from the given c source file extension. */


@@ -395,84 +391,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);
-  obstack_init (&graph_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 ();
 

-  /* Set default extensions */
+  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";
 
   if (!src_extension)
     src_extension = ".c";
   if (!header_extension)
     header_extension = ".h";
 

-  attrsfile = stringappend (short_base_name, EXT_STYPE_H);
-#ifndef MSDOS
-  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)
-    defines_obstack_save (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));
-
-  if (graph_flag)
-    obstack_save (&graph_obstack, stringappend (short_base_name, ".vcg"));

 }
 }