X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/ae7453f2ba115eba9d24aad81b0f17b10c6b839a..0049ec8628e5a320d055a0cea8676a58cec60986:/src/muscle_tab.c diff --git a/src/muscle_tab.c b/src/muscle_tab.c index 3c5dc0c2..5192fc5c 100644 --- a/src/muscle_tab.c +++ b/src/muscle_tab.c @@ -1,5 +1,7 @@ -/* Muscle table manager for Bison, - Copyright (C) 2001, 2002 Free Software Foundation, Inc. +/* Muscle table manager for Bison. + + Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software + Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -15,15 +17,27 @@ 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 #include "system.h" -#include "hash.h" + +#include +#include + #include "files.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 +{ + char const *key; + char const *value; + char *storage; +} muscle_entry; /* An obstack used to create some entries. */ struct obstack muscle_obstack; @@ -31,20 +45,20 @@ struct obstack muscle_obstack; /* 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) { - const muscle_entry_t *m1 = x; - const muscle_entry_t *m2 = y; - return strcmp (m1->key, m2->key) ? FALSE : TRUE; + muscle_entry const *m1 = x; + muscle_entry const *m2 = y; + return strcmp (m1->key, m2->key) == 0; } -static unsigned int -hash_muscle (const void *x, unsigned int tablesize) +static size_t +hash_muscle (const void *x, size_t tablesize) { - const muscle_entry_t *m = x; + muscle_entry const *m = x; return hash_string (m->key, tablesize); } @@ -53,6 +67,14 @@ hash_muscle (const void *x, unsigned int tablesize) | 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) { @@ -60,27 +82,11 @@ muscle_init (void) 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); - MUSCLE_INSERT_STRING ("filename", infile); - - /* FIXME: there should probably be no default here, only in the - skeletons. */ - - /* Types. */ - MUSCLE_INSERT_STRING ("ltype", "yyltype"); - - /* Default #line formatting. */ - MUSCLE_INSERT_STRING ("linef", "#line %d %s\n"); - - /* Stack parameters. */ - MUSCLE_INSERT_STRING ("maxdepth", "10000"); - MUSCLE_INSERT_STRING ("initdepth", "200"); - - /* C++ macros. */ - MUSCLE_INSERT_STRING ("name", "Parser"); + MUSCLE_INSERT_C_STRING ("file_name", grammar_file); } @@ -103,10 +109,10 @@ muscle_free (void) `------------------------------------------------------------*/ void -muscle_insert (const char *key, char *value) +muscle_insert (char const *key, char const *value) { - muscle_entry_t probe; - muscle_entry_t *entry = NULL; + muscle_entry probe; + muscle_entry *entry; probe.key = key; entry = hash_lookup (muscle_table, &probe); @@ -114,25 +120,28 @@ muscle_insert (const char *key, char *value) if (!entry) { /* First insertion in the hash. */ - entry = XMALLOC (muscle_entry_t, 1); + entry = xmalloc (sizeof *entry); entry->key = key; hash_insert (muscle_table, entry); } + else + free (entry->storage); 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 muscle_grow (const char *key, const char *val, const char *separator) { - muscle_entry_t probe; - muscle_entry_t *entry = NULL; + muscle_entry probe; + muscle_entry *entry = NULL; probe.key = key; entry = hash_lookup (muscle_table, &probe); @@ -140,60 +149,103 @@ muscle_grow (const char *key, const char *val, const char *separator) if (!entry) { /* First insertion in the hash. */ - entry = XMALLOC (muscle_entry_t, 1); + 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; - fprintf (stderr, "<= %s + %s\n", entry->value, 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); - entry->value = xstrdup (new_val); - fprintf (stderr, "=> %s\n", new_val); + entry->value = entry->storage = xstrdup (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. | -`-------------------------------------------------------------------*/ +/*------------------------------------------------------------------. +| Append VALUE to the current value of KEY, using muscle_grow. But | +| in addition, issue a synchronization line for the location LOC. | +`------------------------------------------------------------------*/ + +void +muscle_code_grow (const char *key, const char *val, location loc) +{ + char *extension = NULL; + obstack_fgrow1 (&muscle_obstack, "]b4_syncline(%d, [[", loc.start.line); + MUSCLE_OBSTACK_SGROW (&muscle_obstack, + quotearg_style (c_quoting_style, loc.start.file)); + obstack_sgrow (&muscle_obstack, "]])[\n"); + obstack_sgrow (&muscle_obstack, val); + obstack_1grow (&muscle_obstack, 0); + extension = obstack_finish (&muscle_obstack); + muscle_grow (key, extension, ""); + obstack_free (&muscle_obstack, extension); +} + void muscle_pair_list_grow (const char *muscle, const char *a1, const char *a2) { - char *value; - obstack_fgrow2 (&muscle_obstack, "[[[%s]], [[%s]]]", a1, a2); + char *pair; + 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); - value = obstack_finish (&muscle_obstack); - muscle_grow (muscle, value, ",\n"); - obstack_free (&muscle_obstack, value); + pair = obstack_finish (&muscle_obstack); + muscle_grow (muscle, pair, ",\n"); + obstack_free (&muscle_obstack, pair); +} + + +/*----------------------------------------------------------------------------. +| 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. | -`-------------------------------*/ -char* -muscle_find (const char *key) +/*----------------------------------------------------------------------------. +| 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_t probe; - muscle_entry_t *result = NULL; + 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; } @@ -201,12 +253,18 @@ muscle_find (const char *key) | Output the definition of ENTRY as a m4_define. | `------------------------------------------------*/ -static int -muscle_m4_output (muscle_entry_t *entry, FILE *out) +static inline bool +muscle_m4_output (muscle_entry *entry, FILE *out) { fprintf (out, "m4_define([b4_%s],\n", entry->key); fprintf (out, "[[%s]])\n\n\n", entry->value); - return 1; + return true; +} + +static bool +muscle_m4_output_processor (void *entry, void *out) +{ + return muscle_m4_output (entry, out); } @@ -218,7 +276,33 @@ muscle_m4_output (muscle_entry_t *entry, FILE *out) void muscles_m4_output (FILE *out) { - hash_do_for_each (muscle_table, - (Hash_processor) muscle_m4_output, - 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, "]]]]", ""); }