2007-01-30 Paolo Bonzini <bonzini@gnu.org>

[bison.git] / src / muscle_tab.c

diff --git a/src/muscle_tab.c b/src/muscle_tab.c
index 93d44cc9c431dcedcb0812e8543e33572e7982c6..5192fc5c940b95ddf1fc062cb8cb488586205d11 100644 (file)
--- a/src/muscle_tab.c
+++ b/src/muscle_tab.c
@@ -1,6 +1,6 @@
 /* Muscle table manager for Bison.
 
 /* Muscle table manager for Bison.
 

-   Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software
+   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software

    Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
    Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.


@@ -17,9 +17,10 @@
 
    You should have received a copy of the GNU General Public License
    along with Bison; see the file COPYING.  If not, write to
 
    You should have received a copy of the GNU General Public License
    along with Bison; see the file COPYING.  If not, write to

-   the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */

 
 

+#include <config.h>

 #include "system.h"
 
 #include <hash.h>
 #include "system.h"
 
 #include <hash.h>


@@ -29,10 +30,13 @@
 #include "muscle_tab.h"
 #include "getargs.h"
 
 #include "muscle_tab.h"
 #include "getargs.h"
 

+/* A key-value pair, along with storage that can be reclaimed when
+   this pair is no longer needed.  */

 typedef struct
 {
 typedef struct
 {

-  const char *key;
-  char *value;
+  char const *key;
+  char const *value;
+  char *storage;

 } muscle_entry;
 
 /* An obstack used to create some entries.  */
 } muscle_entry;
 
 /* An obstack used to create some entries.  */


@@ -41,7 +45,7 @@ struct obstack muscle_obstack;
 /* Initial capacity of muscles hash table.  */
 #define HT_INITIAL_CAPACITY 257
 
 /* Initial capacity of muscles hash table.  */
 #define HT_INITIAL_CAPACITY 257
 

-struct hash_table *muscle_table = NULL;
+static struct hash_table *muscle_table = NULL;

 
 static bool
 hash_compare_muscles (void const *x, void const *y)
 
 static bool
 hash_compare_muscles (void const *x, void const *y)


@@ -63,6 +67,14 @@ hash_muscle (const void *x, size_t tablesize)
 | Also set up the MUSCLE_OBSTACK.                                  |
 `-----------------------------------------------------------------*/
 
 | Also set up the MUSCLE_OBSTACK.                                  |
 `-----------------------------------------------------------------*/
 

+static void
+muscle_entry_free (void *entry)
+{
+  muscle_entry *mentry = entry;
+  free (mentry->storage);
+  free (mentry);
+}
+

 void
 muscle_init (void)
 {
 void
 muscle_init (void)
 {


@@ -70,11 +82,11 @@ muscle_init (void)
   obstack_init (&muscle_obstack);
 
   muscle_table = hash_initialize (HT_INITIAL_CAPACITY, NULL, hash_muscle,
   obstack_init (&muscle_obstack);
 
   muscle_table = hash_initialize (HT_INITIAL_CAPACITY, NULL, hash_muscle,

-                                 hash_compare_muscles, free);
+                                 hash_compare_muscles, muscle_entry_free);

 
   /* Version and input file.  */
   MUSCLE_INSERT_STRING ("version", VERSION);
 
   /* Version and input file.  */
   MUSCLE_INSERT_STRING ("version", VERSION);

-  MUSCLE_INSERT_C_STRING ("filename", grammar_file);
+  MUSCLE_INSERT_C_STRING ("file_name", grammar_file);

 }
 
 
 }
 
 


@@ -97,7 +109,7 @@ muscle_free (void)
 `------------------------------------------------------------*/
 
 void
 `------------------------------------------------------------*/
 
 void

-muscle_insert (const char *key, char *value)
+muscle_insert (char const *key, char const *value)

 {
   muscle_entry probe;
   muscle_entry *entry;
 {
   muscle_entry probe;
   muscle_entry *entry;


@@ -112,14 +124,17 @@ muscle_insert (const char *key, char *value)
       entry->key = key;
       hash_insert (muscle_table, entry);
     }
       entry->key = key;
       hash_insert (muscle_table, entry);
     }

+  else
+    free (entry->storage);

   entry->value = value;
   entry->value = value;

+  entry->storage = NULL;

 }
 
 
 /*-------------------------------------------------------------------.
 }
 
 
 /*-------------------------------------------------------------------.

-| Insert (KEY, VALUE).  If KEY already existed, overwrite the        |
-| previous value.  Uses MUSCLE_OBSTACK.  De-allocates the previously |
-| associated value.  VALUE and SEPARATOR are copied.                 |
+| Append VALUE to the current value of KEY.  If KEY did not already  |
+| exist, create it.  Use MUSCLE_OBSTACK.  De-allocate the previously |
+| associated value.  Copy VALUE and SEPARATOR.                       |

 `-------------------------------------------------------------------*/
 
 void
 `-------------------------------------------------------------------*/
 
 void


@@ -137,19 +152,19 @@ muscle_grow (const char *key, const char *val, const char *separator)
       entry = xmalloc (sizeof *entry);
       entry->key = key;
       hash_insert (muscle_table, entry);
       entry = xmalloc (sizeof *entry);
       entry->key = key;
       hash_insert (muscle_table, entry);

-      entry->value = xstrdup (val);
+      entry->value = entry->storage = xstrdup (val);

     }
   else
     {
       /* Grow the current value. */
       char *new_val;
       obstack_sgrow (&muscle_obstack, entry->value);
     }
   else
     {
       /* Grow the current value. */
       char *new_val;
       obstack_sgrow (&muscle_obstack, entry->value);

-      free (entry->value);
+      free (entry->storage);

       obstack_sgrow (&muscle_obstack, separator);
       obstack_sgrow (&muscle_obstack, val);
       obstack_1grow (&muscle_obstack, 0);
       new_val = obstack_finish (&muscle_obstack);
       obstack_sgrow (&muscle_obstack, separator);
       obstack_sgrow (&muscle_obstack, val);
       obstack_1grow (&muscle_obstack, 0);
       new_val = obstack_finish (&muscle_obstack);

-      entry->value = xstrdup (new_val);
+      entry->value = entry->storage = xstrdup (new_val);

       obstack_free (&muscle_obstack, new_val);
     }
 }
       obstack_free (&muscle_obstack, new_val);
     }
 }


@@ -172,40 +187,65 @@ muscle_code_grow (const char *key, const char *val, location loc)
   obstack_1grow (&muscle_obstack, 0);
   extension = obstack_finish (&muscle_obstack);
   muscle_grow (key, extension, "");
   obstack_1grow (&muscle_obstack, 0);
   extension = obstack_finish (&muscle_obstack);
   muscle_grow (key, extension, "");

+  obstack_free (&muscle_obstack, extension);

 }
 
 
 }
 
 

-/*-------------------------------------------------------------------.
-| MUSCLE is an M4 list of pairs.  Create or extend it with the pair  |
-| (A1, A2).  Note that because the muscle values are output *double* |
-| quoted, one needs to strip the first level of quotes to reach the  |
-| list itself.                                                       |
-`-------------------------------------------------------------------*/
-

 void muscle_pair_list_grow (const char *muscle,
                            const char *a1, const char *a2)
 {
   char *pair;
 void muscle_pair_list_grow (const char *muscle,
                            const char *a1, const char *a2)
 {
   char *pair;

-  obstack_fgrow2 (&muscle_obstack, "[[[%s]], [[%s]]]", a1, a2);
+  obstack_sgrow (&muscle_obstack, "[[[");
+  MUSCLE_OBSTACK_SGROW (&muscle_obstack, a1);
+  obstack_sgrow (&muscle_obstack, "]], [[");
+  MUSCLE_OBSTACK_SGROW (&muscle_obstack, a2);
+  obstack_sgrow (&muscle_obstack, "]]]");

   obstack_1grow (&muscle_obstack, 0);
   pair = obstack_finish (&muscle_obstack);
   muscle_grow (muscle, pair, ",\n");
   obstack_free (&muscle_obstack, pair);
 }
 
   obstack_1grow (&muscle_obstack, 0);
   pair = obstack_finish (&muscle_obstack);
   muscle_grow (muscle, pair, ",\n");
   obstack_free (&muscle_obstack, pair);
 }
 

-/*-------------------------------.
-| Find the value of muscle KEY.  |
-`-------------------------------*/

 
 

-char*
-muscle_find (const char *key)
+/*----------------------------------------------------------------------------.
+| Find the value of muscle KEY.  Unlike MUSCLE_FIND, this is always reliable  |
+| to determine whether KEY has a value.                                       |
+`----------------------------------------------------------------------------*/
+
+char const *
+muscle_find_const (char const *key)
+{
+  muscle_entry probe;
+  muscle_entry *result = NULL;
+
+  probe.key = key;
+  result = hash_lookup (muscle_table, &probe);
+  if (result)
+    return result->value;
+  return NULL;
+}
+
+
+/*----------------------------------------------------------------------------.
+| Find the value of muscle KEY.  Abort if muscle_insert was invoked more      |
+| recently than muscle_grow for KEY since muscle_find can't return a          |
+| char const *.                                                               |
+`----------------------------------------------------------------------------*/
+
+char *
+muscle_find (char const *key)

 {
   muscle_entry probe;
   muscle_entry *result = NULL;
 
   probe.key = key;
   result = hash_lookup (muscle_table, &probe);
 {
   muscle_entry probe;
   muscle_entry *result = NULL;
 
   probe.key = key;
   result = hash_lookup (muscle_table, &probe);

-  return result ? result->value : NULL;
+  if (result)
+    {
+      aver (result->value == result->storage);
+      return result->storage;
+    }
+  return NULL;

 }
 
 
 }
 
 


@@ -238,3 +278,31 @@ muscles_m4_output (FILE *out)
 {
   hash_do_for_each (muscle_table, muscle_m4_output_processor, out);
 }
 {
   hash_do_for_each (muscle_table, muscle_m4_output_processor, out);
 }

+
+void
+muscle_boundary_grow (char const *key, boundary bound)
+{
+  char *extension;
+  MUSCLE_OBSTACK_SGROW (&muscle_obstack, bound.file);
+  obstack_1grow (&muscle_obstack, ':');
+  obstack_fgrow1 (&muscle_obstack, "%d", bound.line);
+  obstack_1grow (&muscle_obstack, '.');
+  obstack_fgrow1 (&muscle_obstack, "%d", bound.column);
+  obstack_1grow (&muscle_obstack, '\0');
+  extension = obstack_finish (&muscle_obstack);
+  muscle_grow (key, extension, "");
+  obstack_free (&muscle_obstack, extension);
+}
+
+void
+muscle_grow_user_name_list (char const *key, char const *user_name,
+                            location loc)
+{
+  muscle_grow (key, "[[[[", ",");
+  muscle_grow (key, user_name, "");
+  muscle_grow (key, "]], [[", "");
+  muscle_boundary_grow (key, loc.start);
+  muscle_grow (key, "]], [[", "");
+  muscle_boundary_grow (key, loc.end);
+  muscle_grow (key, "]]]]", "");
+}