Add lib/subpipe.c.

[bison.git] / src / muscle_tab.c

diff --git a/src/muscle_tab.c b/src/muscle_tab.c
index 380a047107ffd30e41740a5b7d0f9ba77f5b8801..085b838dfea01864bcda6f0a88505f32ff9dcdcf 100644 (file)
--- a/src/muscle_tab.c
+++ b/src/muscle_tab.c
@@ -1,4 +1,4 @@
-/* Macro table manager for Bison,
+/* Muscle table manager for Bison,

    Copyright (C) 2001, 2002 Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
    Copyright (C) 2001, 2002 Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.


@@ -24,6 +24,10 @@
 #include "muscle_tab.h"
 #include "getargs.h"
 
 #include "muscle_tab.h"
 #include "getargs.h"
 

+
+/* An obstack used to create some entries.  */
+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
 


@@ -44,36 +48,68 @@ hash_muscle (const void *x, unsigned int tablesize)
   return hash_string (m->key, tablesize);
 }
 
   return hash_string (m->key, tablesize);
 }
 

+/*-----------------------------------------------------------------.
+| Create the MUSCLE_TABLE, and initialize it with default values.  |
+| Also set up the MUSCLE_OBSTACK.                                  |
+`-----------------------------------------------------------------*/
+

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

+  /* Initialize the muscle obstack.  */
+  obstack_init (&muscle_obstack);
+

   muscle_table = hash_initialize (HT_INITIAL_CAPACITY, NULL, hash_muscle,
   muscle_table = hash_initialize (HT_INITIAL_CAPACITY, NULL, hash_muscle,

-                                 hash_compare_muscles, NULL);
+                                 hash_compare_muscles, free);

 
   /* Version and input file.  */
 
   /* Version and input file.  */

-  muscle_insert ("version", VERSION);
-  muscle_insert ("filename", infile);
+  MUSCLE_INSERT_STRING ("version", VERSION);
+  MUSCLE_INSERT_STRING ("filename", infile);
+
+  /* FIXME: there should probably be no default here, only in the
+     skeletons.  */

 
   /* Types.  */
 
   /* Types.  */

-  muscle_insert ("stype", "int");
-  muscle_insert ("ltype", "yyltype");
+  MUSCLE_INSERT_STRING ("ltype", "yyltype");

 
   /* Default #line formatting.  */
 
   /* Default #line formatting.  */

-  muscle_insert ("linef", "#line %d %s\n");
+  MUSCLE_INSERT_STRING ("linef", "#line %d %s\n");

 
   /* Stack parameters.  */
 
   /* Stack parameters.  */

-  muscle_insert ("maxdepth", "10000");
-  muscle_insert ("initdepth", "200");
+  MUSCLE_INSERT_STRING ("maxdepth", "10000");
+  MUSCLE_INSERT_STRING ("initdepth", "200");

 
   /* C++ macros.  */
 
   /* C++ macros.  */

-  muscle_insert ("name", "Parser");
+  MUSCLE_INSERT_STRING ("name", "Parser");

 }
 
 }
 

+
+/*------------------------------------------------------------.
+| Free all the memory consumed by the muscle machinery only.  |
+`------------------------------------------------------------*/
+

 void
 void

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

 {
 {

-  muscle_entry_t pair = { key, NULL };
-  muscle_entry_t *entry = hash_lookup (muscle_table, &pair);
+  hash_free (muscle_table);
+  obstack_free (&muscle_obstack, NULL);
+}
+
+
+
+/*------------------------------------------------------------.
+| Insert (KEY, VALUE).  If KEY already existed, overwrite the |
+| previous value.                                             |
+`------------------------------------------------------------*/
+
+void
+muscle_insert (const char *key, char *value)
+{
+  muscle_entry_t probe;
+  muscle_entry_t *entry = NULL;
+
+  probe.key = key;
+  entry = hash_lookup (muscle_table, &probe);

 
   if (!entry)
     {
 
   if (!entry)
     {


@@ -85,10 +121,104 @@ muscle_insert (const char *key, const char *value)
   entry->value = value;
 }
 
   entry->value = value;
 }
 

-const char*
+
+/*-------------------------------------------------------------------.
+| 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.                 |
+`-------------------------------------------------------------------*/
+
+void
+muscle_grow (const char *key, const char *val, const char *separator)
+{
+  muscle_entry_t probe;
+  muscle_entry_t *entry = NULL;
+
+  probe.key = key;
+  entry = hash_lookup (muscle_table, &probe);
+
+  if (!entry)
+    {
+      /* First insertion in the hash. */
+      entry = XMALLOC (muscle_entry_t, 1);
+      entry->key = key;
+      hash_insert (muscle_table, entry);
+      entry->value = xstrdup (val);
+    }
+  else
+    {
+      /* Grow the current value. */
+      char *new_val;
+      fprintf (stderr, "<= %s + %s\n", entry->value, val);
+      obstack_sgrow (&muscle_obstack, entry->value);
+      free (entry->value);
+      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);
+      fprintf (stderr, "=> %s\n", new_val);
+      obstack_free (&muscle_obstack, new_val);
+    }
+}
+
+
+/*-------------------------------------------------------------------.
+| 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 *val;
+  obstack_fgrow2 (&muscle_obstack, "[[[%s]], [[%s]]]", a1, a2);
+  obstack_1grow (&muscle_obstack, 0);
+  val = obstack_finish (&muscle_obstack);
+  muscle_grow (muscle, val, ",\n");
+  obstack_free (&muscle_obstack, val);
+}
+
+/*-------------------------------.
+| Find the value of muscle KEY.  |
+`-------------------------------*/
+
+char*

 muscle_find (const char *key)
 {
 muscle_find (const char *key)
 {

-  muscle_entry_t pair = { key, NULL };
-  muscle_entry_t *result = hash_lookup (muscle_table, &pair);
+  muscle_entry_t probe;
+  muscle_entry_t *result = NULL;
+
+  probe.key = key;
+  result = hash_lookup (muscle_table, &probe);

   return result ? result->value : NULL;
 }
   return result ? result->value : NULL;
 }

+
+
+/*------------------------------------------------.
+| Output the definition of ENTRY as a m4_define.  |
+`------------------------------------------------*/
+
+static int
+muscle_m4_output (muscle_entry_t *entry, FILE *out)
+{
+  fprintf (out, "m4_define([b4_%s],\n", entry->key);
+  fprintf (out, "[[%s]])\n\n\n", entry->value);
+  return 1;
+}
+
+
+/*----------------------------------------------------------------.
+| Output the definition of all the current muscles into a list of |
+| m4_defines.                                                     |
+`----------------------------------------------------------------*/
+
+void
+muscles_m4_output (FILE *out)
+{
+  hash_do_for_each (muscle_table,
+                   (Hash_processor) muscle_m4_output,
+                   out);
+}