From: Joel E. Denny Date: Thu, 8 Oct 2009 20:58:22 +0000 (-0400) Subject: Rename muscle_tab.* to muscle-tab.* for consistency with master. X-Git-Tag: v2.5_rc1~148 X-Git-Url: https://git.saurik.com/bison.git/commitdiff_plain/23ec25b7c6c4eb587a5fa832f67765a6143b7925?ds=inline Rename muscle_tab.* to muscle-tab.* for consistency with master. * src/Makefile.am (bison_SOURCES): Update. * src/getargs.c, src/ielr.c, src/lalr.c, src/main.c, src/output.c, src/parse-gram.y, src/print.c, src/reader.c, src/tables.c: Update include. * src/muscle_tab.c, src/muscle_tab.h: Rename to... * src/muscle-tab.c, src/muscle-tab.h: ... these and update include. --- diff --git a/ChangeLog b/ChangeLog index 004ba419..f01a9263 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,14 @@ +2009-10-08 Joel E. Denny + + Rename muscle_tab.* to muscle-tab.* for consistency with master. + * src/Makefile.am (bison_SOURCES): Update. + * src/getargs.c, src/ielr.c, src/lalr.c, src/main.c, + src/output.c, src/parse-gram.y, src/print.c, src/reader.c, + src/tables.c: Update include. + * src/muscle_tab.c, src/muscle_tab.h: Rename to... + * src/muscle-tab.c, src/muscle-tab.h: ... these and update + include. + 2009-10-07 Joel E. Denny Minor code cleanup. diff --git a/src/Makefile.am b/src/Makefile.am index 13442bac..a7b3acbb 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -48,7 +48,7 @@ bison_SOURCES = \ ielr.h ielr.c \ location.c location.h \ main.c \ - muscle_tab.c muscle_tab.h \ + muscle-tab.c muscle-tab.h \ named-ref.c named-ref.h \ nullable.c nullable.h \ output.c output.h \ diff --git a/src/getargs.c b/src/getargs.c index 876130e0..4231cfce 100644 --- a/src/getargs.c +++ b/src/getargs.c @@ -44,7 +44,7 @@ #include "complain.h" #include "files.h" #include "getargs.h" -#include "muscle_tab.h" +#include "muscle-tab.h" #include "uniqstr.h" bool debug_flag; diff --git a/src/ielr.c b/src/ielr.c index 657c3a1d..e47c0202 100644 --- a/src/ielr.c +++ b/src/ielr.c @@ -29,7 +29,7 @@ #include "derives.h" #include "getargs.h" #include "lalr.h" -#include "muscle_tab.h" +#include "muscle-tab.h" #include "nullable.h" #include "relation.h" #include "state.h" diff --git a/src/lalr.c b/src/lalr.c index 8742b4e0..fbd2800f 100644 --- a/src/lalr.c +++ b/src/lalr.c @@ -36,7 +36,7 @@ #include "getargs.h" #include "gram.h" #include "lalr.h" -#include "muscle_tab.h" +#include "muscle-tab.h" #include "nullable.h" #include "reader.h" #include "relation.h" diff --git a/src/main.c b/src/main.c index c80ed870..c8dc696e 100644 --- a/src/main.c +++ b/src/main.c @@ -36,7 +36,7 @@ #include "gram.h" #include "lalr.h" #include "ielr.h" -#include "muscle_tab.h" +#include "muscle-tab.h" #include "nullable.h" #include "output.h" #include "print.h" diff --git a/src/muscle-tab.c b/src/muscle-tab.c new file mode 100644 index 00000000..49a985b3 --- /dev/null +++ b/src/muscle-tab.c @@ -0,0 +1,648 @@ +/* Muscle table manager for Bison. + + Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free + Software Foundation, Inc. + + This file is part of Bison, the GNU Compiler Compiler. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +#include +#include "system.h" + +#include +#include + +#include "complain.h" +#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; + +/* Initial capacity of muscles hash table. */ +#define HT_INITIAL_CAPACITY 257 + +static struct hash_table *muscle_table = NULL; + +static bool +hash_compare_muscles (void const *x, void const *y) +{ + muscle_entry const *m1 = x; + muscle_entry const *m2 = y; + return strcmp (m1->key, m2->key) == 0; +} + +static size_t +hash_muscle (const void *x, size_t tablesize) +{ + muscle_entry const *m = x; + return hash_string (m->key, tablesize); +} + +/*-----------------------------------------------------------------. +| Create the MUSCLE_TABLE, and initialize it with default values. | +| 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) +{ + /* Initialize the muscle obstack. */ + obstack_init (&muscle_obstack); + + muscle_table = hash_initialize (HT_INITIAL_CAPACITY, NULL, hash_muscle, + hash_compare_muscles, muscle_entry_free); + + /* Version and input file. */ + MUSCLE_INSERT_STRING ("version", VERSION); +} + + +/*------------------------------------------------------------. +| Free all the memory consumed by the muscle machinery only. | +`------------------------------------------------------------*/ + +void +muscle_free (void) +{ + hash_free (muscle_table); + obstack_free (&muscle_obstack, NULL); +} + + + +/*------------------------------------------------------------. +| Insert (KEY, VALUE). If KEY already existed, overwrite the | +| previous value. | +`------------------------------------------------------------*/ + +void +muscle_insert (char const *key, char const *value) +{ + muscle_entry probe; + muscle_entry *entry; + + probe.key = key; + entry = hash_lookup (muscle_table, &probe); + + if (!entry) + { + /* First insertion in the hash. */ + entry = xmalloc (sizeof *entry); + entry->key = key; + if (!hash_insert (muscle_table, entry)) + xalloc_die (); + } + else + free (entry->storage); + entry->value = value; + entry->storage = NULL; +} + + +/*-------------------------------------------------------------------. +| 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 probe; + muscle_entry *entry = NULL; + + probe.key = key; + entry = hash_lookup (muscle_table, &probe); + + if (!entry) + { + /* First insertion in the hash. */ + entry = xmalloc (sizeof *entry); + entry->key = key; + if (!hash_insert (muscle_table, entry)) + xalloc_die (); + entry->value = entry->storage = xstrdup (val); + } + else + { + /* Grow the current value. */ + char *new_val; + obstack_sgrow (&muscle_obstack, 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 = entry->storage = xstrdup (new_val); + obstack_free (&muscle_obstack, new_val); + } +} + +/*------------------------------------------------------------------. +| Using muscle_grow, append a synchronization line for the location | +| LOC to the current value of KEY. | +`------------------------------------------------------------------*/ + +static void +muscle_syncline_grow (char const *key, 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, "]])["); + obstack_1grow (&muscle_obstack, 0); + extension = obstack_finish (&muscle_obstack); + muscle_grow (key, extension, ""); + obstack_free (&muscle_obstack, extension); +} + +/*------------------------------------------------------------------. +| Append VALUE to the current value of KEY, using muscle_grow. But | +| in addition, issue a synchronization line for the location LOC | +| using muscle_syncline_grow. | +`------------------------------------------------------------------*/ + +void +muscle_code_grow (const char *key, const char *val, location loc) +{ + muscle_syncline_grow (key, loc); + muscle_grow (key, val, "\n"); +} + + +void muscle_pair_list_grow (const char *muscle, + const char *a1, const char *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); + 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. 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); + if (result) + { + aver (result->value == result->storage); + return result->storage; + } + return NULL; +} + + +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_location_grow (char const *key, location loc) +{ + muscle_grow (key, "[[", ""); + muscle_boundary_grow (key, loc.start); + muscle_grow (key, "]], [[", ""); + muscle_boundary_grow (key, loc.end); + muscle_grow (key, "]]", ""); +} + +#define MUSCLE_COMMON_DECODE(Value) \ + case '$': \ + aver (*++(Value) == ']'); \ + aver (*++(Value) == '['); \ + obstack_sgrow (&muscle_obstack, "$"); \ + break; \ + case '@': \ + switch (*++(Value)) \ + { \ + case '@': obstack_sgrow (&muscle_obstack, "@" ); break; \ + case '{': obstack_sgrow (&muscle_obstack, "[" ); break; \ + case '}': obstack_sgrow (&muscle_obstack, "]" ); break; \ + default: aver (false); break; \ + } \ + break; \ + default: \ + obstack_1grow (&muscle_obstack, *(Value)); \ + break; + +/* Reverse of MUSCLE_OBSTACK_SGROW. */ +static char * +muscle_string_decode (char const *key) +{ + char const *value; + char *value_decoded; + char *result; + + value = muscle_find_const (key); + if (!value) + return NULL; + do { + switch (*value) + { + MUSCLE_COMMON_DECODE (value) + case '[': + case ']': + aver (false); + break; + } + } while (*value++); + value_decoded = obstack_finish (&muscle_obstack); + result = xstrdup (value_decoded); + obstack_free (&muscle_obstack, value_decoded); + return result; +} + +/* Reverse of muscle_location_grow. */ +static location +muscle_location_decode (char const *key) +{ + location loc; + char const *value = muscle_find_const (key); + aver (value); + aver (*value == '['); + aver (*++value == '['); + while (*++value) + switch (*value) + { + MUSCLE_COMMON_DECODE (value) + case '[': + aver (false); + break; + case ']': + { + char *boundary_str; + aver (*++value == ']'); + obstack_1grow (&muscle_obstack, '\0'); + boundary_str = obstack_finish (&muscle_obstack); + switch (*++value) + { + case ',': + boundary_set_from_string (&loc.start, boundary_str); + obstack_free (&muscle_obstack, boundary_str); + aver (*++value == ' '); + aver (*++value == '['); + aver (*++value == '['); + break; + case '\0': + boundary_set_from_string (&loc.end, boundary_str); + obstack_free (&muscle_obstack, boundary_str); + return loc; + break; + default: + aver (false); + break; + } + } + break; + } + aver (false); + return loc; +} + +void +muscle_user_name_list_grow (char const *key, char const *user_name, + location loc) +{ + muscle_grow (key, "[[[[", ","); + muscle_grow (key, user_name, ""); + muscle_grow (key, "]], ", ""); + muscle_location_grow (key, loc); + muscle_grow (key, "]]", ""); +} + +void +muscle_percent_define_insert (char const *variable, location variable_loc, + char const *value, + muscle_percent_define_how how) +{ + char *variable_tr = NULL; + char const *name; + char const *loc_name; + char const *syncline_name; + char const *how_name; + + /* Permit certain names with underscores for backward compatibility. */ + if (0 == strcmp (variable, "api.push_pull") + || 0 == strcmp (variable, "lr.keep_unreachable_states")) + { + variable_tr = strdup (variable); + tr (variable_tr, '_', '-'); + variable = variable_tr; + } + + name = UNIQSTR_CONCAT ("percent_define(", variable, ")"); + loc_name = UNIQSTR_CONCAT ("percent_define_loc(", variable, ")"); + syncline_name = + UNIQSTR_CONCAT ("percent_define_syncline(", variable, ")"); + how_name = UNIQSTR_CONCAT ("percent_define_how(", variable, ")"); + + /* Command-line options are processed before the grammar file. */ + if (how == MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE + && muscle_find_const (name)) + { + muscle_percent_define_how how_old = + atoi (muscle_find_const (how_name)); + if (how_old == MUSCLE_PERCENT_DEFINE_F) + { + free (variable_tr); + return; + } + complain_at (variable_loc, _("%s `%s' redefined"), + "%define variable", variable); + complain_at (muscle_percent_define_get_loc (variable), + _("previous definition")); + } + + MUSCLE_INSERT_STRING (name, value); + muscle_insert (loc_name, ""); + muscle_location_grow (loc_name, variable_loc); + muscle_insert (syncline_name, ""); + muscle_syncline_grow (syncline_name, variable_loc); + muscle_user_name_list_grow ("percent_define_user_variables", variable, + variable_loc); + MUSCLE_INSERT_INT (how_name, how); + + free (variable_tr); +} + +char * +muscle_percent_define_get (char const *variable) +{ + char const *name; + char const *usage_name; + char *value; + + name = UNIQSTR_CONCAT ("percent_define(", variable, ")"); + usage_name = UNIQSTR_CONCAT ("percent_define_bison_variables(", + variable, ")"); + + muscle_insert (usage_name, ""); + value = muscle_string_decode (name); + if (!value) + value = xstrdup (""); + return value; +} + +location +muscle_percent_define_get_loc (char const *variable) +{ + char const *loc_name; + loc_name = UNIQSTR_CONCAT ("percent_define_loc(", variable, ")"); + if (!muscle_find_const (loc_name)) + fatal(_("undefined %%define variable `%s' passed to" + " muscle_percent_define_get_loc"), variable); + return muscle_location_decode (loc_name); +} + +char const * +muscle_percent_define_get_syncline (char const *variable) +{ + char const *syncline_name; + char const *syncline; + syncline_name = + UNIQSTR_CONCAT ("percent_define_syncline(", variable, ")"); + syncline = muscle_find_const (syncline_name); + if (!syncline) + fatal(_("undefined %%define variable `%s' passed to" + " muscle_percent_define_get_syncline"), variable); + return syncline; +} + +bool +muscle_percent_define_ifdef (char const *variable) +{ + char const *name; + char const *usage_name; + char const *value; + + name = UNIQSTR_CONCAT ("percent_define(", variable, ")"); + usage_name = + UNIQSTR_CONCAT ("percent_define_bison_variables(", variable, ")"); + + value = muscle_find_const (name); + if (value) + { + muscle_insert (usage_name, ""); + return true; + } + + return false; +} + +bool +muscle_percent_define_flag_if (char const *variable) +{ + char const *invalid_boolean_name; + bool result = false; + + invalid_boolean_name = + UNIQSTR_CONCAT ("percent_define_invalid_boolean(", variable, ")"); + + if (muscle_percent_define_ifdef (variable)) + { + char *value = muscle_percent_define_get (variable); + if (value[0] == '\0' || 0 == strcmp (value, "true")) + result = true; + else if (0 == strcmp (value, "false")) + result = false; + else if (!muscle_find_const (invalid_boolean_name)) + { + muscle_insert (invalid_boolean_name, ""); + complain_at(muscle_percent_define_get_loc (variable), + _("invalid value for %%define Boolean variable `%s'"), + variable); + } + free (value); + } + else + fatal(_("undefined %%define variable `%s' passed to muscle_percent_define_flag_if"), + variable); + + return result; +} + +void +muscle_percent_define_default (char const *variable, char const *value) +{ + char const *name; + char const *loc_name; + char const *syncline_name; + name = UNIQSTR_CONCAT ("percent_define(", variable, ")"); + loc_name = UNIQSTR_CONCAT ("percent_define_loc(", variable, ")"); + syncline_name = + UNIQSTR_CONCAT ("percent_define_syncline(", variable, ")"); + if (!muscle_find_const (name)) + { + location loc; + MUSCLE_INSERT_STRING (name, value); + loc.start.file = loc.end.file = ""; + loc.start.line = loc.end.line = -1; + loc.start.column = loc.end.column = -1; + muscle_insert (loc_name, ""); + muscle_location_grow (loc_name, loc); + muscle_insert (syncline_name, ""); + } +} + +void +muscle_percent_define_check_values (char const * const *values) +{ + for (; *values; ++values) + { + char const * const *variablep = values; + char const *name; + char *value; + + name = UNIQSTR_CONCAT ("percent_define(", *variablep, ")"); + + value = muscle_string_decode (name); + if (value) + { + for (++values; *values; ++values) + { + if (0 == strcmp (value, *values)) + break; + } + if (!*values) + { + location loc = muscle_percent_define_get_loc (*variablep); + complain_at(loc, + _("invalid value for %%define variable `%s': `%s'"), + *variablep, value); + for (values = variablep + 1; *values; ++values) + complain_at (loc, _("accepted value: `%s'"), *values); + } + else + { + while (*values) + ++values; + } + free (value); + } + else + fatal(_("undefined %%define variable `%s' passed to" + " muscle_percent_define_check_values"), + *variablep); + } +} + +void +muscle_percent_code_grow (char const *qualifier, location qualifier_loc, + char const *code, location code_loc) +{ + char const *name; + name = UNIQSTR_CONCAT ("percent_code(", qualifier, ")"); + muscle_code_grow (name, code, code_loc); + muscle_user_name_list_grow ("percent_code_user_qualifiers", qualifier, + qualifier_loc); +} + + +/*------------------------------------------------. +| Output the definition of ENTRY as a m4_define. | +`------------------------------------------------*/ + +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 true; +} + +static bool +muscle_m4_output_processor (void *entry, void *out) +{ + return muscle_m4_output (entry, out); +} + + +/*----------------------------------------------------------------. +| 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, muscle_m4_output_processor, out); +} diff --git a/src/muscle-tab.h b/src/muscle-tab.h new file mode 100644 index 00000000..e06126b3 --- /dev/null +++ b/src/muscle-tab.h @@ -0,0 +1,211 @@ +/* Muscle table manager for Bison, + Copyright (C) 2001, 2002, 2003, 2006, 2007, 2009 Free Software + Foundation, Inc. + + This file is part of Bison, the GNU Compiler Compiler. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +#ifndef MUSCLE_TAB_H_ +# define MUSCLE_TAB_H_ + +# include "location.h" + +void muscle_init (void); +void muscle_insert (char const *key, char const *value); +char const *muscle_find_const (char const *key); +char *muscle_find (char const *key); +void muscle_free (void); + + +/* An obstack dedicated to receive muscle keys and values. */ +extern struct obstack muscle_obstack; + +#define MUSCLE_INSERT_BOOL(Key, Value) \ +do { \ + int v = Value; \ + MUSCLE_INSERT_INT (Key, v); \ +} while(0) + +#define MUSCLE_INSERT_INT(Key, Value) \ +do { \ + obstack_fgrow1 (&muscle_obstack, "%d", Value); \ + obstack_1grow (&muscle_obstack, 0); \ + muscle_insert (Key, obstack_finish (&muscle_obstack)); \ +} while(0) + +#define MUSCLE_INSERT_LONG_INT(Key, Value) \ +do { \ + obstack_fgrow1 (&muscle_obstack, "%ld", Value); \ + obstack_1grow (&muscle_obstack, 0); \ + muscle_insert (Key, obstack_finish (&muscle_obstack)); \ +} while(0) + +#define MUSCLE_INSERT_STRING_RAW(Key, Value) \ +do { \ + obstack_sgrow (&muscle_obstack, Value); \ + obstack_1grow (&muscle_obstack, 0); \ + muscle_insert (Key, obstack_finish (&muscle_obstack)); \ +} while(0) + +#define MUSCLE_INSERT_STRING(Key, Value) \ +do { \ + MUSCLE_OBSTACK_SGROW (&muscle_obstack, Value); \ + obstack_1grow (&muscle_obstack, 0); \ + muscle_insert (Key, obstack_finish (&muscle_obstack)); \ +} while(0) + +#define MUSCLE_OBSTACK_SGROW(Obstack, Value) \ +do { \ + char const *p; \ + for (p = Value; *p; p++) \ + switch (*p) \ + { \ + case '$': obstack_sgrow (Obstack, "$]["); break; \ + case '@': obstack_sgrow (Obstack, "@@" ); break; \ + case '[': obstack_sgrow (Obstack, "@{" ); break; \ + case ']': obstack_sgrow (Obstack, "@}" ); break; \ + default: obstack_1grow (Obstack, *p); break; \ + } \ +} while(0) + +#define MUSCLE_INSERT_C_STRING(Key, Value) \ +do { \ + MUSCLE_OBSTACK_SGROW (&muscle_obstack, \ + quotearg_style (c_quoting_style, \ + Value)); \ + obstack_1grow (&muscle_obstack, 0); \ + muscle_insert (Key, obstack_finish (&muscle_obstack)); \ +} while(0) + +/* 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 *value, const char *separator); + + +/* 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 *value, location loc); + + +/* MUSCLE is an M4 list of pairs. Create or extend it with the pair + (A1, A2) after escaping both values with digraphs. 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); + +/* In the format `[[file_name:line.column]], [[file_name:line.column]]', append + LOC to MUSCLE. Use digraphs for special characters in each file name. */ +void muscle_location_grow (char const *key, location loc); + +/* In the format `file_name:line.column', append BOUND to MUSCLE. Use digraphs + for special characters in the file name. */ +void muscle_boundary_grow (char const *key, boundary bound); + +/* Grow KEY for the occurrence of the name USER_NAME at LOC appropriately for + use with b4_check_user_names in ../data/bison.m4. USER_NAME is not escaped + with digraphs, so it must not contain `[' or `]'. */ +void muscle_user_name_list_grow (char const *key, char const *user_name, + location loc); + +/* Indicates whether a variable's value was specified with -D/--define, with + -F/--force-define, or in the grammar file. */ +typedef enum { + MUSCLE_PERCENT_DEFINE_D = 0, MUSCLE_PERCENT_DEFINE_F, + MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE +} muscle_percent_define_how; + +/* Define the muscles for %define variable VARIABLE with VALUE specified + at VARIABLE_LOC in the manner HOW unless it was specified in the + grammar file while the previous definition for VARIABLE was specified + with -F/--force-define. Complain if a previous definition is being + overridden and the new definition is specified in the grammar file. + (These rules support the documented behavior as long as command-line + definitions are processed before grammar file definitions.) Record + this as a user occurrence of VARIABLE by invoking + muscle_user_name_list_grow. */ +void muscle_percent_define_insert (char const *variable, location variable_loc, + char const *value, + muscle_percent_define_how how); + +/* Mimic b4_percent_define_get in ../data/bison.m4 exactly. That is, if the + %define variable VARIABLE is defined, return its value. Otherwise, return + the empty string. Also, record Bison's usage of VARIABLE by defining + b4_percent_define_bison_variables(VARIABLE). The caller is responsible for + freeing the memory of the returned string. */ +char *muscle_percent_define_get (char const *variable); + +/* Mimic muscle_percent_define_get_loc in ../data/bison.m4 exactly. That is, + if the %define variable VARIABLE is undefined, complain fatally since that's + a Bison error. Otherwise, return its definition location in a form + approriate for the first argument of warn_at, complain_at, or fatal_at. + Don't record this as a Bison usage of VARIABLE as there's no reason to + suspect that the user-supplied value has yet influenced the output. */ +location muscle_percent_define_get_loc (char const *variable); + +/* Mimic muscle_percent_define_get_syncline in ../data/bison.m4 exactly. That + is, if the %define variable VARIABLE is undefined, complain fatally since + that's a Bison error. Otherwise, return its definition location as a + b4_syncline invocation. Don't record this as a Bison usage of VARIABLE as + there's no reason to suspect that the user-supplied value has yet influenced + the output. */ +char const *muscle_percent_define_get_syncline (char const *variable); + +/* Mimic b4_percent_define_ifdef in ../data/bison.m4 exactly. That is, if the + %define variable VARIABLE is defined, return true. Otherwise, return false. + Also, record Bison's usage of VARIABLE by defining + b4_percent_define_bison_variables(VARIABLE). */ +bool muscle_percent_define_ifdef (char const *variable); + +/* Mimic b4_percent_define_flag_if in ../data/bison.m4 exactly. That is, if + the %define variable VARIABLE is defined to "" or "true", return true. If + it is defined to "false", return false. Complain if it is undefined (a + Bison error since the default value should have been set already) or defined + to any other value (possibly a user error). Also, record Bison's usage of + VARIABLE by defining b4_percent_define_bison_variables(VARIABLE). */ +bool muscle_percent_define_flag_if (char const *variable); + +/* Mimic b4_percent_define_default in ../data/bison.m4 exactly. That is, if + the %define variable VARIABLE is undefined, set its value to VALUE. + Don't record this as a Bison usage of VARIABLE as there's no reason to + suspect that the value has yet influenced the output. */ +void muscle_percent_define_default (char const *variable, char const *value); + +/* Mimic b4_percent_define_check_values in ../data/bison.m4 exactly except that + the VALUES structure is more appropriate for C. That is, VALUES points to a + list of strings that is partitioned into sublists by NULL's, one terminating + each sublist. The last sublist is followed by a second NULL. For each + sublist, the first string is the name of a %define variable, and all + remaining strings in that sublist are the valid values for that variable. + Complain if such a variable is undefined (a Bison error since the default + value should have been set already) or defined to any other value (possibly + a user error). Don't record this as a Bison usage of the variable as + there's no reason to suspect that the value has yet influenced the + output. */ +void muscle_percent_define_check_values (char const * const *values); + +/* Grow the muscle for the %code qualifier QUALIFIER appearing at + QUALIFIER_LOC with code CODE appearing at CODE_LOC. Record this as a + user occurrence of QUALIFIER by invoking + muscle_user_name_list_grow. */ +void muscle_percent_code_grow (char const *qualifier, location qualifier_loc, + char const *code, location code_loc); + +void muscles_m4_output (FILE *out); + +#endif /* not MUSCLE_TAB_H_ */ diff --git a/src/muscle_tab.c b/src/muscle_tab.c deleted file mode 100644 index e75ceef5..00000000 --- a/src/muscle_tab.c +++ /dev/null @@ -1,648 +0,0 @@ -/* Muscle table manager for Bison. - - Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free - Software Foundation, Inc. - - This file is part of Bison, the GNU Compiler Compiler. - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . */ - -#include -#include "system.h" - -#include -#include - -#include "complain.h" -#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; - -/* Initial capacity of muscles hash table. */ -#define HT_INITIAL_CAPACITY 257 - -static struct hash_table *muscle_table = NULL; - -static bool -hash_compare_muscles (void const *x, void const *y) -{ - muscle_entry const *m1 = x; - muscle_entry const *m2 = y; - return strcmp (m1->key, m2->key) == 0; -} - -static size_t -hash_muscle (const void *x, size_t tablesize) -{ - muscle_entry const *m = x; - return hash_string (m->key, tablesize); -} - -/*-----------------------------------------------------------------. -| Create the MUSCLE_TABLE, and initialize it with default values. | -| 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) -{ - /* Initialize the muscle obstack. */ - obstack_init (&muscle_obstack); - - muscle_table = hash_initialize (HT_INITIAL_CAPACITY, NULL, hash_muscle, - hash_compare_muscles, muscle_entry_free); - - /* Version and input file. */ - MUSCLE_INSERT_STRING ("version", VERSION); -} - - -/*------------------------------------------------------------. -| Free all the memory consumed by the muscle machinery only. | -`------------------------------------------------------------*/ - -void -muscle_free (void) -{ - hash_free (muscle_table); - obstack_free (&muscle_obstack, NULL); -} - - - -/*------------------------------------------------------------. -| Insert (KEY, VALUE). If KEY already existed, overwrite the | -| previous value. | -`------------------------------------------------------------*/ - -void -muscle_insert (char const *key, char const *value) -{ - muscle_entry probe; - muscle_entry *entry; - - probe.key = key; - entry = hash_lookup (muscle_table, &probe); - - if (!entry) - { - /* First insertion in the hash. */ - entry = xmalloc (sizeof *entry); - entry->key = key; - if (!hash_insert (muscle_table, entry)) - xalloc_die (); - } - else - free (entry->storage); - entry->value = value; - entry->storage = NULL; -} - - -/*-------------------------------------------------------------------. -| 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 probe; - muscle_entry *entry = NULL; - - probe.key = key; - entry = hash_lookup (muscle_table, &probe); - - if (!entry) - { - /* First insertion in the hash. */ - entry = xmalloc (sizeof *entry); - entry->key = key; - if (!hash_insert (muscle_table, entry)) - xalloc_die (); - entry->value = entry->storage = xstrdup (val); - } - else - { - /* Grow the current value. */ - char *new_val; - obstack_sgrow (&muscle_obstack, 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 = entry->storage = xstrdup (new_val); - obstack_free (&muscle_obstack, new_val); - } -} - -/*------------------------------------------------------------------. -| Using muscle_grow, append a synchronization line for the location | -| LOC to the current value of KEY. | -`------------------------------------------------------------------*/ - -static void -muscle_syncline_grow (char const *key, 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, "]])["); - obstack_1grow (&muscle_obstack, 0); - extension = obstack_finish (&muscle_obstack); - muscle_grow (key, extension, ""); - obstack_free (&muscle_obstack, extension); -} - -/*------------------------------------------------------------------. -| Append VALUE to the current value of KEY, using muscle_grow. But | -| in addition, issue a synchronization line for the location LOC | -| using muscle_syncline_grow. | -`------------------------------------------------------------------*/ - -void -muscle_code_grow (const char *key, const char *val, location loc) -{ - muscle_syncline_grow (key, loc); - muscle_grow (key, val, "\n"); -} - - -void muscle_pair_list_grow (const char *muscle, - const char *a1, const char *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); - 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. 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); - if (result) - { - aver (result->value == result->storage); - return result->storage; - } - return NULL; -} - - -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_location_grow (char const *key, location loc) -{ - muscle_grow (key, "[[", ""); - muscle_boundary_grow (key, loc.start); - muscle_grow (key, "]], [[", ""); - muscle_boundary_grow (key, loc.end); - muscle_grow (key, "]]", ""); -} - -#define MUSCLE_COMMON_DECODE(Value) \ - case '$': \ - aver (*++(Value) == ']'); \ - aver (*++(Value) == '['); \ - obstack_sgrow (&muscle_obstack, "$"); \ - break; \ - case '@': \ - switch (*++(Value)) \ - { \ - case '@': obstack_sgrow (&muscle_obstack, "@" ); break; \ - case '{': obstack_sgrow (&muscle_obstack, "[" ); break; \ - case '}': obstack_sgrow (&muscle_obstack, "]" ); break; \ - default: aver (false); break; \ - } \ - break; \ - default: \ - obstack_1grow (&muscle_obstack, *(Value)); \ - break; - -/* Reverse of MUSCLE_OBSTACK_SGROW. */ -static char * -muscle_string_decode (char const *key) -{ - char const *value; - char *value_decoded; - char *result; - - value = muscle_find_const (key); - if (!value) - return NULL; - do { - switch (*value) - { - MUSCLE_COMMON_DECODE (value) - case '[': - case ']': - aver (false); - break; - } - } while (*value++); - value_decoded = obstack_finish (&muscle_obstack); - result = xstrdup (value_decoded); - obstack_free (&muscle_obstack, value_decoded); - return result; -} - -/* Reverse of muscle_location_grow. */ -static location -muscle_location_decode (char const *key) -{ - location loc; - char const *value = muscle_find_const (key); - aver (value); - aver (*value == '['); - aver (*++value == '['); - while (*++value) - switch (*value) - { - MUSCLE_COMMON_DECODE (value) - case '[': - aver (false); - break; - case ']': - { - char *boundary_str; - aver (*++value == ']'); - obstack_1grow (&muscle_obstack, '\0'); - boundary_str = obstack_finish (&muscle_obstack); - switch (*++value) - { - case ',': - boundary_set_from_string (&loc.start, boundary_str); - obstack_free (&muscle_obstack, boundary_str); - aver (*++value == ' '); - aver (*++value == '['); - aver (*++value == '['); - break; - case '\0': - boundary_set_from_string (&loc.end, boundary_str); - obstack_free (&muscle_obstack, boundary_str); - return loc; - break; - default: - aver (false); - break; - } - } - break; - } - aver (false); - return loc; -} - -void -muscle_user_name_list_grow (char const *key, char const *user_name, - location loc) -{ - muscle_grow (key, "[[[[", ","); - muscle_grow (key, user_name, ""); - muscle_grow (key, "]], ", ""); - muscle_location_grow (key, loc); - muscle_grow (key, "]]", ""); -} - -void -muscle_percent_define_insert (char const *variable, location variable_loc, - char const *value, - muscle_percent_define_how how) -{ - char *variable_tr = NULL; - char const *name; - char const *loc_name; - char const *syncline_name; - char const *how_name; - - /* Permit certain names with underscores for backward compatibility. */ - if (0 == strcmp (variable, "api.push_pull") - || 0 == strcmp (variable, "lr.keep_unreachable_states")) - { - variable_tr = strdup (variable); - tr (variable_tr, '_', '-'); - variable = variable_tr; - } - - name = UNIQSTR_CONCAT ("percent_define(", variable, ")"); - loc_name = UNIQSTR_CONCAT ("percent_define_loc(", variable, ")"); - syncline_name = - UNIQSTR_CONCAT ("percent_define_syncline(", variable, ")"); - how_name = UNIQSTR_CONCAT ("percent_define_how(", variable, ")"); - - /* Command-line options are processed before the grammar file. */ - if (how == MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE - && muscle_find_const (name)) - { - muscle_percent_define_how how_old = - atoi (muscle_find_const (how_name)); - if (how_old == MUSCLE_PERCENT_DEFINE_F) - { - free (variable_tr); - return; - } - complain_at (variable_loc, _("%s `%s' redefined"), - "%define variable", variable); - complain_at (muscle_percent_define_get_loc (variable), - _("previous definition")); - } - - MUSCLE_INSERT_STRING (name, value); - muscle_insert (loc_name, ""); - muscle_location_grow (loc_name, variable_loc); - muscle_insert (syncline_name, ""); - muscle_syncline_grow (syncline_name, variable_loc); - muscle_user_name_list_grow ("percent_define_user_variables", variable, - variable_loc); - MUSCLE_INSERT_INT (how_name, how); - - free (variable_tr); -} - -char * -muscle_percent_define_get (char const *variable) -{ - char const *name; - char const *usage_name; - char *value; - - name = UNIQSTR_CONCAT ("percent_define(", variable, ")"); - usage_name = UNIQSTR_CONCAT ("percent_define_bison_variables(", - variable, ")"); - - muscle_insert (usage_name, ""); - value = muscle_string_decode (name); - if (!value) - value = xstrdup (""); - return value; -} - -location -muscle_percent_define_get_loc (char const *variable) -{ - char const *loc_name; - loc_name = UNIQSTR_CONCAT ("percent_define_loc(", variable, ")"); - if (!muscle_find_const (loc_name)) - fatal(_("undefined %%define variable `%s' passed to" - " muscle_percent_define_get_loc"), variable); - return muscle_location_decode (loc_name); -} - -char const * -muscle_percent_define_get_syncline (char const *variable) -{ - char const *syncline_name; - char const *syncline; - syncline_name = - UNIQSTR_CONCAT ("percent_define_syncline(", variable, ")"); - syncline = muscle_find_const (syncline_name); - if (!syncline) - fatal(_("undefined %%define variable `%s' passed to" - " muscle_percent_define_get_syncline"), variable); - return syncline; -} - -bool -muscle_percent_define_ifdef (char const *variable) -{ - char const *name; - char const *usage_name; - char const *value; - - name = UNIQSTR_CONCAT ("percent_define(", variable, ")"); - usage_name = - UNIQSTR_CONCAT ("percent_define_bison_variables(", variable, ")"); - - value = muscle_find_const (name); - if (value) - { - muscle_insert (usage_name, ""); - return true; - } - - return false; -} - -bool -muscle_percent_define_flag_if (char const *variable) -{ - char const *invalid_boolean_name; - bool result = false; - - invalid_boolean_name = - UNIQSTR_CONCAT ("percent_define_invalid_boolean(", variable, ")"); - - if (muscle_percent_define_ifdef (variable)) - { - char *value = muscle_percent_define_get (variable); - if (value[0] == '\0' || 0 == strcmp (value, "true")) - result = true; - else if (0 == strcmp (value, "false")) - result = false; - else if (!muscle_find_const (invalid_boolean_name)) - { - muscle_insert (invalid_boolean_name, ""); - complain_at(muscle_percent_define_get_loc (variable), - _("invalid value for %%define Boolean variable `%s'"), - variable); - } - free (value); - } - else - fatal(_("undefined %%define variable `%s' passed to muscle_percent_define_flag_if"), - variable); - - return result; -} - -void -muscle_percent_define_default (char const *variable, char const *value) -{ - char const *name; - char const *loc_name; - char const *syncline_name; - name = UNIQSTR_CONCAT ("percent_define(", variable, ")"); - loc_name = UNIQSTR_CONCAT ("percent_define_loc(", variable, ")"); - syncline_name = - UNIQSTR_CONCAT ("percent_define_syncline(", variable, ")"); - if (!muscle_find_const (name)) - { - location loc; - MUSCLE_INSERT_STRING (name, value); - loc.start.file = loc.end.file = ""; - loc.start.line = loc.end.line = -1; - loc.start.column = loc.end.column = -1; - muscle_insert (loc_name, ""); - muscle_location_grow (loc_name, loc); - muscle_insert (syncline_name, ""); - } -} - -void -muscle_percent_define_check_values (char const * const *values) -{ - for (; *values; ++values) - { - char const * const *variablep = values; - char const *name; - char *value; - - name = UNIQSTR_CONCAT ("percent_define(", *variablep, ")"); - - value = muscle_string_decode (name); - if (value) - { - for (++values; *values; ++values) - { - if (0 == strcmp (value, *values)) - break; - } - if (!*values) - { - location loc = muscle_percent_define_get_loc (*variablep); - complain_at(loc, - _("invalid value for %%define variable `%s': `%s'"), - *variablep, value); - for (values = variablep + 1; *values; ++values) - complain_at (loc, _("accepted value: `%s'"), *values); - } - else - { - while (*values) - ++values; - } - free (value); - } - else - fatal(_("undefined %%define variable `%s' passed to" - " muscle_percent_define_check_values"), - *variablep); - } -} - -void -muscle_percent_code_grow (char const *qualifier, location qualifier_loc, - char const *code, location code_loc) -{ - char const *name; - name = UNIQSTR_CONCAT ("percent_code(", qualifier, ")"); - muscle_code_grow (name, code, code_loc); - muscle_user_name_list_grow ("percent_code_user_qualifiers", qualifier, - qualifier_loc); -} - - -/*------------------------------------------------. -| Output the definition of ENTRY as a m4_define. | -`------------------------------------------------*/ - -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 true; -} - -static bool -muscle_m4_output_processor (void *entry, void *out) -{ - return muscle_m4_output (entry, out); -} - - -/*----------------------------------------------------------------. -| 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, muscle_m4_output_processor, out); -} diff --git a/src/muscle_tab.h b/src/muscle_tab.h deleted file mode 100644 index e06126b3..00000000 --- a/src/muscle_tab.h +++ /dev/null @@ -1,211 +0,0 @@ -/* Muscle table manager for Bison, - Copyright (C) 2001, 2002, 2003, 2006, 2007, 2009 Free Software - Foundation, Inc. - - This file is part of Bison, the GNU Compiler Compiler. - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . */ - -#ifndef MUSCLE_TAB_H_ -# define MUSCLE_TAB_H_ - -# include "location.h" - -void muscle_init (void); -void muscle_insert (char const *key, char const *value); -char const *muscle_find_const (char const *key); -char *muscle_find (char const *key); -void muscle_free (void); - - -/* An obstack dedicated to receive muscle keys and values. */ -extern struct obstack muscle_obstack; - -#define MUSCLE_INSERT_BOOL(Key, Value) \ -do { \ - int v = Value; \ - MUSCLE_INSERT_INT (Key, v); \ -} while(0) - -#define MUSCLE_INSERT_INT(Key, Value) \ -do { \ - obstack_fgrow1 (&muscle_obstack, "%d", Value); \ - obstack_1grow (&muscle_obstack, 0); \ - muscle_insert (Key, obstack_finish (&muscle_obstack)); \ -} while(0) - -#define MUSCLE_INSERT_LONG_INT(Key, Value) \ -do { \ - obstack_fgrow1 (&muscle_obstack, "%ld", Value); \ - obstack_1grow (&muscle_obstack, 0); \ - muscle_insert (Key, obstack_finish (&muscle_obstack)); \ -} while(0) - -#define MUSCLE_INSERT_STRING_RAW(Key, Value) \ -do { \ - obstack_sgrow (&muscle_obstack, Value); \ - obstack_1grow (&muscle_obstack, 0); \ - muscle_insert (Key, obstack_finish (&muscle_obstack)); \ -} while(0) - -#define MUSCLE_INSERT_STRING(Key, Value) \ -do { \ - MUSCLE_OBSTACK_SGROW (&muscle_obstack, Value); \ - obstack_1grow (&muscle_obstack, 0); \ - muscle_insert (Key, obstack_finish (&muscle_obstack)); \ -} while(0) - -#define MUSCLE_OBSTACK_SGROW(Obstack, Value) \ -do { \ - char const *p; \ - for (p = Value; *p; p++) \ - switch (*p) \ - { \ - case '$': obstack_sgrow (Obstack, "$]["); break; \ - case '@': obstack_sgrow (Obstack, "@@" ); break; \ - case '[': obstack_sgrow (Obstack, "@{" ); break; \ - case ']': obstack_sgrow (Obstack, "@}" ); break; \ - default: obstack_1grow (Obstack, *p); break; \ - } \ -} while(0) - -#define MUSCLE_INSERT_C_STRING(Key, Value) \ -do { \ - MUSCLE_OBSTACK_SGROW (&muscle_obstack, \ - quotearg_style (c_quoting_style, \ - Value)); \ - obstack_1grow (&muscle_obstack, 0); \ - muscle_insert (Key, obstack_finish (&muscle_obstack)); \ -} while(0) - -/* 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 *value, const char *separator); - - -/* 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 *value, location loc); - - -/* MUSCLE is an M4 list of pairs. Create or extend it with the pair - (A1, A2) after escaping both values with digraphs. 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); - -/* In the format `[[file_name:line.column]], [[file_name:line.column]]', append - LOC to MUSCLE. Use digraphs for special characters in each file name. */ -void muscle_location_grow (char const *key, location loc); - -/* In the format `file_name:line.column', append BOUND to MUSCLE. Use digraphs - for special characters in the file name. */ -void muscle_boundary_grow (char const *key, boundary bound); - -/* Grow KEY for the occurrence of the name USER_NAME at LOC appropriately for - use with b4_check_user_names in ../data/bison.m4. USER_NAME is not escaped - with digraphs, so it must not contain `[' or `]'. */ -void muscle_user_name_list_grow (char const *key, char const *user_name, - location loc); - -/* Indicates whether a variable's value was specified with -D/--define, with - -F/--force-define, or in the grammar file. */ -typedef enum { - MUSCLE_PERCENT_DEFINE_D = 0, MUSCLE_PERCENT_DEFINE_F, - MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE -} muscle_percent_define_how; - -/* Define the muscles for %define variable VARIABLE with VALUE specified - at VARIABLE_LOC in the manner HOW unless it was specified in the - grammar file while the previous definition for VARIABLE was specified - with -F/--force-define. Complain if a previous definition is being - overridden and the new definition is specified in the grammar file. - (These rules support the documented behavior as long as command-line - definitions are processed before grammar file definitions.) Record - this as a user occurrence of VARIABLE by invoking - muscle_user_name_list_grow. */ -void muscle_percent_define_insert (char const *variable, location variable_loc, - char const *value, - muscle_percent_define_how how); - -/* Mimic b4_percent_define_get in ../data/bison.m4 exactly. That is, if the - %define variable VARIABLE is defined, return its value. Otherwise, return - the empty string. Also, record Bison's usage of VARIABLE by defining - b4_percent_define_bison_variables(VARIABLE). The caller is responsible for - freeing the memory of the returned string. */ -char *muscle_percent_define_get (char const *variable); - -/* Mimic muscle_percent_define_get_loc in ../data/bison.m4 exactly. That is, - if the %define variable VARIABLE is undefined, complain fatally since that's - a Bison error. Otherwise, return its definition location in a form - approriate for the first argument of warn_at, complain_at, or fatal_at. - Don't record this as a Bison usage of VARIABLE as there's no reason to - suspect that the user-supplied value has yet influenced the output. */ -location muscle_percent_define_get_loc (char const *variable); - -/* Mimic muscle_percent_define_get_syncline in ../data/bison.m4 exactly. That - is, if the %define variable VARIABLE is undefined, complain fatally since - that's a Bison error. Otherwise, return its definition location as a - b4_syncline invocation. Don't record this as a Bison usage of VARIABLE as - there's no reason to suspect that the user-supplied value has yet influenced - the output. */ -char const *muscle_percent_define_get_syncline (char const *variable); - -/* Mimic b4_percent_define_ifdef in ../data/bison.m4 exactly. That is, if the - %define variable VARIABLE is defined, return true. Otherwise, return false. - Also, record Bison's usage of VARIABLE by defining - b4_percent_define_bison_variables(VARIABLE). */ -bool muscle_percent_define_ifdef (char const *variable); - -/* Mimic b4_percent_define_flag_if in ../data/bison.m4 exactly. That is, if - the %define variable VARIABLE is defined to "" or "true", return true. If - it is defined to "false", return false. Complain if it is undefined (a - Bison error since the default value should have been set already) or defined - to any other value (possibly a user error). Also, record Bison's usage of - VARIABLE by defining b4_percent_define_bison_variables(VARIABLE). */ -bool muscle_percent_define_flag_if (char const *variable); - -/* Mimic b4_percent_define_default in ../data/bison.m4 exactly. That is, if - the %define variable VARIABLE is undefined, set its value to VALUE. - Don't record this as a Bison usage of VARIABLE as there's no reason to - suspect that the value has yet influenced the output. */ -void muscle_percent_define_default (char const *variable, char const *value); - -/* Mimic b4_percent_define_check_values in ../data/bison.m4 exactly except that - the VALUES structure is more appropriate for C. That is, VALUES points to a - list of strings that is partitioned into sublists by NULL's, one terminating - each sublist. The last sublist is followed by a second NULL. For each - sublist, the first string is the name of a %define variable, and all - remaining strings in that sublist are the valid values for that variable. - Complain if such a variable is undefined (a Bison error since the default - value should have been set already) or defined to any other value (possibly - a user error). Don't record this as a Bison usage of the variable as - there's no reason to suspect that the value has yet influenced the - output. */ -void muscle_percent_define_check_values (char const * const *values); - -/* Grow the muscle for the %code qualifier QUALIFIER appearing at - QUALIFIER_LOC with code CODE appearing at CODE_LOC. Record this as a - user occurrence of QUALIFIER by invoking - muscle_user_name_list_grow. */ -void muscle_percent_code_grow (char const *qualifier, location qualifier_loc, - char const *code, location code_loc); - -void muscles_m4_output (FILE *out); - -#endif /* not MUSCLE_TAB_H_ */ diff --git a/src/output.c b/src/output.c index 6663a209..01ca5bea 100644 --- a/src/output.c +++ b/src/output.c @@ -32,7 +32,7 @@ #include "files.h" #include "getargs.h" #include "gram.h" -#include "muscle_tab.h" +#include "muscle-tab.h" #include "output.h" #include "reader.h" #include "scan-code.h" /* max_left_semantic_context */ diff --git a/src/parse-gram.c b/src/parse-gram.c index fd34ec15..2bf83335 100644 --- a/src/parse-gram.c +++ b/src/parse-gram.c @@ -1,4 +1,4 @@ -/* A Bison parser, made by GNU Bison 2.4.1.153-9637-dirty. */ +/* A Bison parser, made by GNU Bison 2.4.1.155-0ab4-dirty. */ /* Skeleton implementation for Bison's Yacc-like parsers in C @@ -45,7 +45,7 @@ #define YYBISON 1 /* Bison version. */ -#define YYBISON_VERSION "2.4.1.153-9637-dirty" +#define YYBISON_VERSION "2.4.1.155-0ab4-dirty" /* Skeleton name. */ #define YYSKELETON_NAME "yacc.c" @@ -104,7 +104,7 @@ #include "files.h" #include "getargs.h" #include "gram.h" -#include "muscle_tab.h" +#include "muscle-tab.h" #include "named-ref.h" #include "quotearg.h" #include "reader.h" diff --git a/src/parse-gram.h b/src/parse-gram.h index 74a4e750..7db9b0a9 100644 --- a/src/parse-gram.h +++ b/src/parse-gram.h @@ -1,4 +1,4 @@ -/* A Bison parser, made by GNU Bison 2.4.1.153-9637-dirty. */ +/* A Bison parser, made by GNU Bison 2.4.1.155-0ab4-dirty. */ /* Skeleton interface for Bison's Yacc-like parsers in C diff --git a/src/parse-gram.y b/src/parse-gram.y index bcc25714..f7843ecf 100644 --- a/src/parse-gram.y +++ b/src/parse-gram.y @@ -26,7 +26,7 @@ #include "files.h" #include "getargs.h" #include "gram.h" -#include "muscle_tab.h" +#include "muscle-tab.h" #include "named-ref.h" #include "quotearg.h" #include "reader.h" diff --git a/src/print.c b/src/print.c index b4256576..41cd19a0 100644 --- a/src/print.c +++ b/src/print.c @@ -31,7 +31,7 @@ #include "getargs.h" #include "gram.h" #include "lalr.h" -#include "muscle_tab.h" +#include "muscle-tab.h" #include "print.h" #include "reader.h" #include "reduce.h" diff --git a/src/reader.c b/src/reader.c index 043fea8b..8a292b8a 100644 --- a/src/reader.c +++ b/src/reader.c @@ -29,7 +29,7 @@ #include "files.h" #include "getargs.h" #include "gram.h" -#include "muscle_tab.h" +#include "muscle-tab.h" #include "reader.h" #include "symlist.h" #include "symtab.h" diff --git a/src/tables.c b/src/tables.c index 5f2d7096..d1f7e7d9 100644 --- a/src/tables.c +++ b/src/tables.c @@ -30,7 +30,7 @@ #include "getargs.h" #include "gram.h" #include "lalr.h" -#include "muscle_tab.h" +#include "muscle-tab.h" #include "reader.h" #include "symtab.h" #include "tables.h"