From: Akim Demaille Date: Sun, 5 Apr 2009 20:18:06 +0000 (+0200) Subject: rename muscle_tab.* as muscle-tab.* for consistency. X-Git-Tag: v2.7.90~907 X-Git-Url: https://git.saurik.com/bison.git/commitdiff_plain/00f5d57533cf74aeeb50bdf3dc70e344befcdfb5 rename muscle_tab.* as muscle-tab.* for consistency. * src/muscle_tab.h, src/muscle_tab.c: Rename as... * src/muscle-tab.h, src/muscle-tab.c: these. * src/getargs.c, src/local.mk, src/main.c, src/output.c, * src/parse-gram.y, src/reader.c, src/scan-code.l: Adjust. --- diff --git a/ChangeLog b/ChangeLog index 7bf94c53..0f9529e5 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,11 @@ +2009-04-06 Akim Demaille + + rename muscle_tab.* as muscle-tab.* for consistency. + * src/muscle_tab.h, src/muscle_tab.c: Rename as... + * src/muscle-tab.h, src/muscle-tab.c: these. + * src/getargs.c, src/local.mk, src/main.c, src/output.c, + * src/parse-gram.y, src/reader.c, src/scan-code.l: Adjust. + 2009-04-06 Akim Demaille Makefile: introduce $(BISON). diff --git a/src/getargs.c b/src/getargs.c index d7e43850..c68503b1 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 defines_flag; diff --git a/src/local.mk b/src/local.mk index 0ef2355e..ffcf4b01 100644 --- a/src/local.mk +++ b/src/local.mk @@ -60,8 +60,8 @@ src_bison_SOURCES = \ src/location.c \ src/location.h \ src/main.c \ - src/muscle_tab.c \ - src/muscle_tab.h \ + src/muscle-tab.c \ + src/muscle-tab.h \ src/nullable.c \ src/nullable.h \ src/output.c \ diff --git a/src/main.c b/src/main.c index b3ef70ac..d7a7f65f 100644 --- a/src/main.c +++ b/src/main.c @@ -1,7 +1,7 @@ /* Top level entry point of Bison. Copyright (C) 1984, 1986, 1989, 1992, 1995, 2000, 2001, 2002, 2004, - 2005, 2006, 2007, 2008 Free Software Foundation, Inc. + 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -35,7 +35,7 @@ #include "getargs.h" #include "gram.h" #include "lalr.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..9ed80148 --- /dev/null +++ b/src/muscle-tab.c @@ -0,0 +1,650 @@ +/* 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; + hash_insert (muscle_table, entry); + } + 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; + hash_insert (muscle_table, entry); + 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, "]]", ""); +} + +#define MUSCLE_USER_NAME_CONVERT(NAME, PREFIX, USER_NAME, SUFFIX) \ +do { \ + char *tmp; \ + size_t length = strlen ((USER_NAME)); \ + tmp = xmalloc (sizeof (PREFIX) - 1 + length + sizeof (SUFFIX)); \ + strcpy (tmp, (PREFIX)); \ + strcpy (tmp + sizeof (PREFIX) - 1, (USER_NAME)); \ + strcpy (tmp + sizeof (PREFIX) - 1 + length, (SUFFIX)); \ + (NAME) = uniqstr_new (tmp); \ + free (tmp); \ +} while (0) + +void +muscle_percent_define_insert (char const *variable, location variable_loc, + char const *value) +{ + char const *name; + char const *loc_name; + char const *syncline_name; + + MUSCLE_USER_NAME_CONVERT (name, "percent_define(", variable, ")"); + MUSCLE_USER_NAME_CONVERT (loc_name, "percent_define_loc(", variable, ")"); + MUSCLE_USER_NAME_CONVERT (syncline_name, + "percent_define_syncline(", variable, ")"); + + if (muscle_find_const (name)) + { + warn_at (variable_loc, _("%s `%s' redefined"), + "%define variable", variable); + warn_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); +} + +/* This is used for backward compatibility, e.g., "%define api.pure" + supersedes "%pure-parser". */ +void +muscle_percent_define_ensure (char const *variable, location loc, + bool value) +{ + char const *val = value ? "" : "false"; + char const *name; + MUSCLE_USER_NAME_CONVERT (name, "percent_define(", variable, ")"); + + /* %pure-parser is deprecated in favor of `%define api.pure', so use + `%define api.pure' in a backward-compatible manner here. First, + don't complain if %pure-parser is specified multiple times. */ + if (!muscle_find_const (name)) + muscle_percent_define_insert (variable, loc, val); + /* In all cases, use api.pure now so that the backend doesn't complain if + the skeleton ignores api.pure, but do warn now if there's a previous + conflicting definition from an actual %define. */ + if (muscle_percent_define_flag_if (variable) != value) + muscle_percent_define_insert (variable, loc, val); +} + +char * +muscle_percent_define_get (char const *variable) +{ + char const *name; + char const *usage_name; + char *value; + + MUSCLE_USER_NAME_CONVERT (name, "percent_define(", variable, ")"); + MUSCLE_USER_NAME_CONVERT (usage_name, "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; + MUSCLE_USER_NAME_CONVERT (loc_name, "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; + MUSCLE_USER_NAME_CONVERT (syncline_name, + "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; + + MUSCLE_USER_NAME_CONVERT (name, "percent_define(", variable, ")"); + MUSCLE_USER_NAME_CONVERT (usage_name, "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; + + MUSCLE_USER_NAME_CONVERT (invalid_boolean_name, + "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; + MUSCLE_USER_NAME_CONVERT (name, "percent_define(", variable, ")"); + MUSCLE_USER_NAME_CONVERT (loc_name, "percent_define_loc(", variable, ")"); + MUSCLE_USER_NAME_CONVERT (syncline_name, + "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 *variable = *values; + char const *name; + char *value; + + MUSCLE_USER_NAME_CONVERT (name, "percent_define(", variable, ")"); + + value = muscle_string_decode (name); + if (value) + { + bool valid = false; + for (++values; *values; ++values) + { + if (0 == strcmp (value, *values)) + { + valid = true; + while (*values) + ++values; + break; + } + } + if (!valid) + complain_at(muscle_percent_define_get_loc (variable), + _("invalid value for %%define variable `%s': `%s'"), + variable, value); + free (value); + } + else + fatal(_("undefined %%define variable `%s' passed to muscle_percent_define_check_values"), + variable); + } +} + +void +muscle_percent_code_grow (char const *qualifier, location qualifier_loc, + char const *code, location code_loc) +{ + char const *name; + MUSCLE_USER_NAME_CONVERT (name, "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..3fe64e5a --- /dev/null +++ b/src/muscle-tab.h @@ -0,0 +1,207 @@ +/* Muscle table manager for Bison, + + Copyright (C) 2001, 2002, 2003, 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 . */ + +#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) + +/* Key -> Value, but don't apply escaping to Value. */ +#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) + +/* Key -> Value, applying M4 escaping to Value. */ +#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); + +/* Define the muscle for the %define variable VARIABLE appearing at + VARIABLE_LOC in the grammar file with value VALUE. Warn if VARIABLE is + already defined. Record this as a grammar occurrence of VARIABLE by + invoking muscle_user_name_list_grow. */ +void muscle_percent_define_insert (char const *variable, location variable_loc, + char const *value); + +/* Make sure that VARIABLE is set to the boolean VALUE. Warn on mismatches + only, but accept repeated declaration. Used for backward compatibility + between old directives such as %pure-parser, and the recommended use of + variables (%define api.pure). */ +void muscle_percent_define_ensure (char const *variable, location variable_loc, + bool value); + +/* 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 + in the grammar file with code CODE appearing at CODE_LOC. Record this as a + grammar occurrence of VARIABLE 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 3728ade6..00000000 --- a/src/muscle_tab.c +++ /dev/null @@ -1,650 +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; - hash_insert (muscle_table, entry); - } - 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; - hash_insert (muscle_table, entry); - 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, "]]", ""); -} - -#define MUSCLE_USER_NAME_CONVERT(NAME, PREFIX, USER_NAME, SUFFIX) \ -do { \ - char *tmp; \ - size_t length = strlen ((USER_NAME)); \ - tmp = xmalloc (sizeof (PREFIX) - 1 + length + sizeof (SUFFIX)); \ - strcpy (tmp, (PREFIX)); \ - strcpy (tmp + sizeof (PREFIX) - 1, (USER_NAME)); \ - strcpy (tmp + sizeof (PREFIX) - 1 + length, (SUFFIX)); \ - (NAME) = uniqstr_new (tmp); \ - free (tmp); \ -} while (0) - -void -muscle_percent_define_insert (char const *variable, location variable_loc, - char const *value) -{ - char const *name; - char const *loc_name; - char const *syncline_name; - - MUSCLE_USER_NAME_CONVERT (name, "percent_define(", variable, ")"); - MUSCLE_USER_NAME_CONVERT (loc_name, "percent_define_loc(", variable, ")"); - MUSCLE_USER_NAME_CONVERT (syncline_name, - "percent_define_syncline(", variable, ")"); - - if (muscle_find_const (name)) - { - warn_at (variable_loc, _("%s `%s' redefined"), - "%define variable", variable); - warn_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); -} - -/* This is used for backward compatibility, e.g., "%define api.pure" - supersedes "%pure-parser". */ -void -muscle_percent_define_ensure (char const *variable, location loc, - bool value) -{ - char const *val = value ? "" : "false"; - char const *name; - MUSCLE_USER_NAME_CONVERT (name, "percent_define(", variable, ")"); - - /* %pure-parser is deprecated in favor of `%define api.pure', so use - `%define api.pure' in a backward-compatible manner here. First, - don't complain if %pure-parser is specified multiple times. */ - if (!muscle_find_const (name)) - muscle_percent_define_insert (variable, loc, val); - /* In all cases, use api.pure now so that the backend doesn't complain if - the skeleton ignores api.pure, but do warn now if there's a previous - conflicting definition from an actual %define. */ - if (muscle_percent_define_flag_if (variable) != value) - muscle_percent_define_insert (variable, loc, val); -} - -char * -muscle_percent_define_get (char const *variable) -{ - char const *name; - char const *usage_name; - char *value; - - MUSCLE_USER_NAME_CONVERT (name, "percent_define(", variable, ")"); - MUSCLE_USER_NAME_CONVERT (usage_name, "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; - MUSCLE_USER_NAME_CONVERT (loc_name, "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; - MUSCLE_USER_NAME_CONVERT (syncline_name, - "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; - - MUSCLE_USER_NAME_CONVERT (name, "percent_define(", variable, ")"); - MUSCLE_USER_NAME_CONVERT (usage_name, "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; - - MUSCLE_USER_NAME_CONVERT (invalid_boolean_name, - "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; - MUSCLE_USER_NAME_CONVERT (name, "percent_define(", variable, ")"); - MUSCLE_USER_NAME_CONVERT (loc_name, "percent_define_loc(", variable, ")"); - MUSCLE_USER_NAME_CONVERT (syncline_name, - "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 *variable = *values; - char const *name; - char *value; - - MUSCLE_USER_NAME_CONVERT (name, "percent_define(", variable, ")"); - - value = muscle_string_decode (name); - if (value) - { - bool valid = false; - for (++values; *values; ++values) - { - if (0 == strcmp (value, *values)) - { - valid = true; - while (*values) - ++values; - break; - } - } - if (!valid) - complain_at(muscle_percent_define_get_loc (variable), - _("invalid value for %%define variable `%s': `%s'"), - variable, value); - free (value); - } - else - fatal(_("undefined %%define variable `%s' passed to muscle_percent_define_check_values"), - variable); - } -} - -void -muscle_percent_code_grow (char const *qualifier, location qualifier_loc, - char const *code, location code_loc) -{ - char const *name; - MUSCLE_USER_NAME_CONVERT (name, "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 3fe64e5a..00000000 --- a/src/muscle_tab.h +++ /dev/null @@ -1,207 +0,0 @@ -/* Muscle table manager for Bison, - - Copyright (C) 2001, 2002, 2003, 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 . */ - -#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) - -/* Key -> Value, but don't apply escaping to Value. */ -#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) - -/* Key -> Value, applying M4 escaping to Value. */ -#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); - -/* Define the muscle for the %define variable VARIABLE appearing at - VARIABLE_LOC in the grammar file with value VALUE. Warn if VARIABLE is - already defined. Record this as a grammar occurrence of VARIABLE by - invoking muscle_user_name_list_grow. */ -void muscle_percent_define_insert (char const *variable, location variable_loc, - char const *value); - -/* Make sure that VARIABLE is set to the boolean VALUE. Warn on mismatches - only, but accept repeated declaration. Used for backward compatibility - between old directives such as %pure-parser, and the recommended use of - variables (%define api.pure). */ -void muscle_percent_define_ensure (char const *variable, location variable_loc, - bool value); - -/* 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 - in the grammar file with code CODE appearing at CODE_LOC. Record this as a - grammar occurrence of VARIABLE 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 9da543a3..12204461 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.y b/src/parse-gram.y index e45f4bc2..20dee8c3 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 "quotearg.h" #include "reader.h" #include "symlist.h" diff --git a/src/reader.c b/src/reader.c index 7758c772..6184c863 100644 --- a/src/reader.c +++ b/src/reader.c @@ -1,7 +1,7 @@ /* Input parser for Bison Copyright (C) 1984, 1986, 1989, 1992, 1998, 2000, 2001, 2002, 2003, - 2005, 2006, 2007 Free Software Foundation, Inc. + 2005, 2006, 2007, 2009 Free Software Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -28,7 +28,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/scan-code.l b/src/scan-code.l index 913116fb..88f89902 100644 --- a/src/scan-code.l +++ b/src/scan-code.l @@ -34,7 +34,7 @@ #include #include #include -#include +#include #include #include