/* Muscle table manager for Bison.
Copyright (C) 2001-2012 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 <http://www.gnu.org/licenses/>. */
#include <config.h>
#include "system.h"
#include <hash.h>
#include "complain.h"
#include "files.h"
#include "getargs.h"
#include "muscle-tab.h"
#include "quote.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_printf (&muscle_obstack, "]b4_syncline(%d, ", loc.start.line);
obstack_quote (&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, "[");
obstack_quote (&muscle_obstack, a1);
obstack_sgrow (&muscle_obstack, ", ");
obstack_quote (&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;
}
/* In the format `file_name:line.column', append BOUND to MUSCLE. Use
digraphs for special characters in the file name. */
static void
muscle_boundary_grow (char const *key, boundary bound)
{
char *extension;
obstack_sgrow (&muscle_obstack, "[[");
obstack_escape (&muscle_obstack, bound.file);
obstack_1grow (&muscle_obstack, ':');
obstack_printf (&muscle_obstack, "%d", bound.line);
obstack_1grow (&muscle_obstack, '.');
obstack_printf (&muscle_obstack, "%d", bound.column);
obstack_sgrow (&muscle_obstack, "]]");
obstack_1grow (&muscle_obstack, '\0');
extension = obstack_finish (&muscle_obstack);
muscle_grow (key, extension, "");
obstack_free (&muscle_obstack, extension);
}
/* In the format `[[file_name:line.column]], [[file_name:line.column]]',
append LOC to MUSCLE. Use digraphs for special characters in each
file name. */
static void
muscle_location_grow (char const *key, location loc)
{
muscle_boundary_grow (key, loc.start);
muscle_grow (key, "", ", ");
muscle_boundary_grow (key, loc.end);
}
#define 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 obstack_escape. */
static char *
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)
{
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
location_decode (char const *key)
{
location loc;
char const *value = muscle_find_const (key);
aver (value);
aver (*value == '[');
aver (*++value == '[');
while (*++value)
switch (*value)
{
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, "]]", "");
}
/** If the \a variable name is obsolete, return the name to use,
* otherwise \a variable. */
static
char const *
muscle_percent_variable_update (char const *variable)
{
typedef struct
{
const char *obsolete;
const char *updated;
} conversion_type;
const conversion_type conversion[] =
{
{ "api.push_pull", "api.push-pull", },
{ "location_type", "api.location.type", },
{ "lr.keep_unreachable_states", "lr.keep-unreachable-states", },
};
char const *res = variable;
int i;
for (i = 0; i < ARRAY_CARDINALITY (conversion); ++i)
if (STREQ (conversion[i].obsolete, variable))
{
res = conversion[i].updated;
break;
}
return res;
}
void
muscle_percent_define_insert (char const *var, location variable_loc,
char const *value,
muscle_percent_define_how how)
{
/* Backward compatibility. */
char const *variable = muscle_percent_variable_update (var);
char const *name = UNIQSTR_CONCAT ("percent_define(", variable, ")");
char const *loc_name = UNIQSTR_CONCAT ("percent_define_loc(", variable, ")");
char const *syncline_name =
UNIQSTR_CONCAT ("percent_define_syncline(", variable, ")");
char const *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))
{
unsigned i = 0;
muscle_percent_define_how how_old =
atoi (muscle_find_const (how_name));
if (how_old == MUSCLE_PERCENT_DEFINE_F)
return;
complain_at_indent (variable_loc, &i,
_("%%define variable %s redefined"), quote (variable));
i += SUB_INDENT;
complain_at_indent (muscle_percent_define_get_loc (variable), &i,
_("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);
}
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 = 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(_("%s: undefined %%define variable %s"),
"muscle_percent_define_get_loc", quote (variable));
return 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(_("%s: undefined %%define variable %s"),
"muscle_percent_define_get_syncline", quote (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"),
quote (variable));
}
free (value);
}
else
fatal(_("%s: undefined %%define variable %s"),
"muscle_percent_define_flag", quote (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 = "<default value>";
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 = string_decode (name);
if (value)
{
for (++values; *values; ++values)
{
if (0 == strcmp (value, *values))
break;
}
if (!*values)
{
unsigned i = 0;
location loc = muscle_percent_define_get_loc (*variablep);
complain_at_indent (loc, &i,
_("invalid value for %%define variable %s: %s"),
quote (*variablep), quote_n (1, value));
i += SUB_INDENT;
for (values = variablep + 1; *values; ++values)
complain_at_indent (loc, &i, _("accepted value: %s"),
quote (*values));
}
else
{
while (*values)
++values;
}
free (value);
}
else
fatal (_("%s: undefined %%define variable %s"),
"muscle_percent_define_check_values", quote (*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);
}