src/muscle_tab.c

   1 /* Muscle table manager for Bison,
   2    Copyright (C) 2001, 2002 Free Software Foundation, Inc.
   3
   4    This file is part of Bison, the GNU Compiler Compiler.
   5
   6    Bison is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    Bison is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with Bison; see the file COPYING.  If not, write to
  18    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #include "system.h"
  22 #include "hash.h"
  23 #include "quotearg.h"
  24 #include "files.h"
  25 #include "muscle_tab.h"
  26 #include "getargs.h"
  27
  28
  29 /* An obstack used to create some entries.  */
  30 struct obstack muscle_obstack;
  31
  32 /* Initial capacity of muscles hash table.  */
  33 #define HT_INITIAL_CAPACITY 257
  34
  35 struct hash_table *muscle_table = NULL;
  36
  37 static bool
  38 hash_compare_muscles (void const *x, void const *y)
  39 {
  40   const muscle_entry_t *m1 = x;
  41   const muscle_entry_t *m2 = y;
  42   return strcmp (m1->key, m2->key) == 0;
  43 }
  44
  45 static unsigned int
  46 hash_muscle (const void *x, unsigned int tablesize)
  47 {
  48   const muscle_entry_t *m = x;
  49   return hash_string (m->key, tablesize);
  50 }
  51
  52 /*-----------------------------------------------------------------.
  53 | Create the MUSCLE_TABLE, and initialize it with default values.  |
  54 | Also set up the MUSCLE_OBSTACK.                                  |
  55 `-----------------------------------------------------------------*/
  56
  57 void
  58 muscle_init (void)
  59 {
  60   /* Initialize the muscle obstack.  */
  61   obstack_init (&muscle_obstack);
  62
  63   muscle_table = hash_initialize (HT_INITIAL_CAPACITY, NULL, hash_muscle,
  64                                   hash_compare_muscles, free);
  65
  66   /* Version and input file.  */
  67   MUSCLE_INSERT_STRING ("version", VERSION);
  68   MUSCLE_INSERT_C_STRING ("filename", grammar_file);
  69 }
  70
  71
  72 /*------------------------------------------------------------.
  73 | Free all the memory consumed by the muscle machinery only.  |
  74 `------------------------------------------------------------*/
  75
  76 void
  77 muscle_free (void)
  78 {
  79   hash_free (muscle_table);
  80   obstack_free (&muscle_obstack, NULL);
  81 }
  82
  83
  84
  85 /*------------------------------------------------------------.
  86 | Insert (KEY, VALUE).  If KEY already existed, overwrite the |
  87 | previous value.                                             |
  88 `------------------------------------------------------------*/
  89
  90 void
  91 muscle_insert (const char *key, char *value)
  92 {
  93   muscle_entry_t probe;
  94   muscle_entry_t *entry = NULL;
  95
  96   probe.key = key;
  97   entry = hash_lookup (muscle_table, &probe);
  98
  99   if (!entry)
 100     {
 101       /* First insertion in the hash. */
 102       entry = XMALLOC (muscle_entry_t, 1);
 103       entry->key = key;
 104       hash_insert (muscle_table, entry);
 105     }
 106   entry->value = value;
 107 }
 108
 109
 110 /*-------------------------------------------------------------------.
 111 | Insert (KEY, VALUE).  If KEY already existed, overwrite the        |
 112 | previous value.  Uses MUSCLE_OBSTACK.  De-allocates the previously |
 113 | associated value.  VALUE and SEPARATOR are copied.                 |
 114 `-------------------------------------------------------------------*/
 115
 116 void
 117 muscle_grow (const char *key, const char *val, const char *separator)
 118 {
 119   muscle_entry_t probe;
 120   muscle_entry_t *entry = NULL;
 121
 122   probe.key = key;
 123   entry = hash_lookup (muscle_table, &probe);
 124
 125   if (!entry)
 126     {
 127       /* First insertion in the hash. */
 128       entry = XMALLOC (muscle_entry_t, 1);
 129       entry->key = key;
 130       hash_insert (muscle_table, entry);
 131       entry->value = xstrdup (val);
 132     }
 133   else
 134     {
 135       /* Grow the current value. */
 136       char *new_val;
 137       obstack_sgrow (&muscle_obstack, entry->value);
 138       free (entry->value);
 139       obstack_sgrow (&muscle_obstack, separator);
 140       obstack_sgrow (&muscle_obstack, val);
 141       obstack_1grow (&muscle_obstack, 0);
 142       new_val = obstack_finish (&muscle_obstack);
 143       entry->value = xstrdup (new_val);
 144       obstack_free (&muscle_obstack, new_val);
 145     }
 146 }
 147
 148
 149 /*-------------------------------------------------------------------.
 150 | MUSCLE is an M4 list of pairs.  Create or extend it with the pair  |
 151 | (A1, A2).  Note that because the muscle values are output *double* |
 152 | quoted, one needs to strip the first level of quotes to reach the  |
 153 | list itself.                                                       |
 154 `-------------------------------------------------------------------*/
 155
 156 void muscle_pair_list_grow (const char *muscle,
 157                             const char *a1, const char *a2)
 158 {
 159   char *pair;
 160   obstack_fgrow2 (&muscle_obstack, "[[[%s]], [[%s]]]", a1, a2);
 161   obstack_1grow (&muscle_obstack, 0);
 162   pair = obstack_finish (&muscle_obstack);
 163   muscle_grow (muscle, pair, ",\n");
 164   obstack_free (&muscle_obstack, pair);
 165 }
 166
 167 /*-------------------------------.
 168 | Find the value of muscle KEY.  |
 169 `-------------------------------*/
 170
 171 char*
 172 muscle_find (const char *key)
 173 {
 174   muscle_entry_t probe;
 175   muscle_entry_t *result = NULL;
 176
 177   probe.key = key;
 178   result = hash_lookup (muscle_table, &probe);
 179   return result ? result->value : NULL;
 180 }
 181
 182
 183 /*------------------------------------------------.
 184 | Output the definition of ENTRY as a m4_define.  |
 185 `------------------------------------------------*/
 186
 187 static int
 188 muscle_m4_output (muscle_entry_t *entry, FILE *out)
 189 {
 190   fprintf (out, "m4_define([b4_%s],\n", entry->key);
 191   fprintf (out, "[[%s]])\n\n\n", entry->value);
 192   return 1;
 193 }
 194
 195
 196 /*----------------------------------------------------------------.
 197 | Output the definition of all the current muscles into a list of |
 198 | m4_defines.                                                     |
 199 `----------------------------------------------------------------*/
 200
 201 void
 202 muscles_m4_output (FILE *out)
 203 {
 204   hash_do_for_each (muscle_table,
 205                     (Hash_processor) muscle_m4_output,
 206                     out);
 207 }