src/muscle_tab.c

/* Muscle table manager for Bison.

   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software
   Foundation, Inc.

   This file is part of Bison, the GNU Compiler Compiler.

   Bison 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 2, or (at your option)
   any later version.

   Bison 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 Bison; see the file COPYING.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.  */

#include <config.h>
#include "system.h"

#include <hash.h>
#include <quotearg.h>

#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);
  MUSCLE_INSERT_C_STRING ("file_name", grammar_file);
}


/*------------------------------------------------------------.
| 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);
    }
}


/*------------------------------------------------------------------.
| Append VALUE to the current value of KEY, using muscle_grow.  But |
| in addition, issue a synchronization line for the location LOC.   |
`------------------------------------------------------------------*/

void
muscle_code_grow (const char *key, const char *val, location loc)
{
  char *extension = NULL;
  obstack_fgrow1 (&muscle_obstack, "]b4_syncline(%d, [[", loc.start.line);
  MUSCLE_OBSTACK_SGROW (&muscle_obstack,
			quotearg_style (c_quoting_style, loc.start.file));
  obstack_sgrow (&muscle_obstack, "]])[\n");
  obstack_sgrow (&muscle_obstack, val);
  obstack_1grow (&muscle_obstack, 0);
  extension = obstack_finish (&muscle_obstack);
  muscle_grow (key, extension, "");
  obstack_free (&muscle_obstack, extension);
}


void muscle_pair_list_grow (const char *muscle,
			    const char *a1, const char *a2)
{
  char *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, "]]", "");
}

/* 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)
      {
        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;
        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;
        default:
          obstack_1grow (&muscle_obstack, *value);
          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;

  MUSCLE_USER_NAME_CONVERT (name, "percent_define(", variable, ")");
  MUSCLE_USER_NAME_CONVERT (loc_name, "percent_define_loc(", variable, ")");

  if (muscle_find_const (name))
    {
      warn_at (variable_loc, _("%s `%s' redefined"),
               "%define variable", variable);
      warn_at (muscle_location_decode (loc_name), _("previous definition"));
    }
  MUSCLE_INSERT_STRING (name, value);

  muscle_insert (loc_name, "");
  muscle_location_grow (loc_name, variable_loc);
  muscle_user_name_list_grow ("percent_define_user_variables", variable,
                              variable_loc);
}

bool
muscle_percent_define_flag_if (char const *variable)
{
  char const *name;
  char const *loc_name;
  char const *usage_name;
  char const *value;
  bool result = false;

  MUSCLE_USER_NAME_CONVERT (name, "percent_define(", variable, ")");
  MUSCLE_USER_NAME_CONVERT (loc_name, "percent_define_loc(", variable, ")");
  MUSCLE_USER_NAME_CONVERT (usage_name, "percent_define_bison_variables(",
                            variable, ")");

  value = muscle_find_const (name);
  if (value)
    {
      if (value[0] == '\0' || 0 == strcmp (value, "true"))
        result = true;
      else if (0 == strcmp (value, "false"))
        result = false;
      else if (!muscle_find_const (usage_name))
        complain_at(muscle_location_decode (loc_name),
                    _("invalid value for %%define boolean variable `%s'"),
                    variable);
    }
  else
    fatal(_("undefined %%define variable `%s' passed to muscle_percent_define_flag_if"),
          variable);

  muscle_insert (usage_name, "");

  return result;
}

void
muscle_percent_define_default (char const *variable, char const *value)
{
  char const *name;
  char const *loc_name;
  MUSCLE_USER_NAME_CONVERT (name, "percent_define(", variable, ")");
  MUSCLE_USER_NAME_CONVERT (loc_name, "percent_define_loc(", variable, ")");
  if (!muscle_find_const (name))
    {
      location loc;
      MUSCLE_INSERT_STRING (name, value);
      loc.start.file = loc.end.file = "[Bison:muscle_percent_define_default]";
      loc.start.line = loc.start.column = 0;
      loc.end.line = loc.end.column = 0;
      muscle_insert (loc_name, "");
      muscle_location_grow (loc_name, loc);
    }
}

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);
}
Commit	Line	Data
	1	/* Muscle table manager for Bison.
	2
	3	Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software
	4	Foundation, Inc.
	5
	6	This file is part of Bison, the GNU Compiler Compiler.
	7
	8	Bison is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2, or (at your option)
	11	any later version.
	12
	13	Bison is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with Bison; see the file COPYING. If not, write to
	20	the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	21	Boston, MA 02110-1301, USA. */
	22
	23	#include <config.h>
	24	#include "system.h"
	25
	26	#include <hash.h>
	27	#include <quotearg.h>
	28
	29	#include "complain.h"
	30	#include "files.h"
	31	#include "muscle_tab.h"
	32	#include "getargs.h"
	33
	34	/* A key-value pair, along with storage that can be reclaimed when
	35	this pair is no longer needed. */
	36	typedef struct
	37	{
	38	char const *key;
	39	char const *value;
	40	char *storage;
	41	} muscle_entry;
	42
	43	/* An obstack used to create some entries. */
	44	struct obstack muscle_obstack;
	45
	46	/* Initial capacity of muscles hash table. */
	47	#define HT_INITIAL_CAPACITY 257
	48
	49	static struct hash_table *muscle_table = NULL;
	50
	51	static bool
	52	hash_compare_muscles (void const x, void const y)
	53	{
	54	muscle_entry const *m1 = x;
	55	muscle_entry const *m2 = y;
	56	return strcmp (m1->key, m2->key) == 0;
	57	}
	58
	59	static size_t
	60	hash_muscle (const void *x, size_t tablesize)
	61	{
	62	muscle_entry const *m = x;
	63	return hash_string (m->key, tablesize);
	64	}
	65
	66	/*-----------------------------------------------------------------.
	67	\| Create the MUSCLE_TABLE, and initialize it with default values. \|
	68	\| Also set up the MUSCLE_OBSTACK. \|
	69	`-----------------------------------------------------------------*/
	70
	71	static void
	72	muscle_entry_free (void *entry)
	73	{
	74	muscle_entry *mentry = entry;
	75	free (mentry->storage);
	76	free (mentry);
	77	}
	78
	79	void
	80	muscle_init (void)
	81	{
	82	/* Initialize the muscle obstack. */
	83	obstack_init (&muscle_obstack);
	84
	85	muscle_table = hash_initialize (HT_INITIAL_CAPACITY, NULL, hash_muscle,
	86	hash_compare_muscles, muscle_entry_free);
	87
	88	/* Version and input file. */
	89	MUSCLE_INSERT_STRING ("version", VERSION);
	90	MUSCLE_INSERT_C_STRING ("file_name", grammar_file);
	91	}
	92
	93
	94	/*------------------------------------------------------------.
	95	\| Free all the memory consumed by the muscle machinery only. \|
	96	`------------------------------------------------------------*/
	97
	98	void
	99	muscle_free (void)
	100	{
	101	hash_free (muscle_table);
	102	obstack_free (&muscle_obstack, NULL);
	103	}
	104
	105
	106
	107	/*------------------------------------------------------------.
	108	\| Insert (KEY, VALUE). If KEY already existed, overwrite the \|
	109	\| previous value. \|
	110	`------------------------------------------------------------*/
	111
	112	void
	113	muscle_insert (char const key, char const value)
	114	{
	115	muscle_entry probe;
	116	muscle_entry *entry;
	117
	118	probe.key = key;
	119	entry = hash_lookup (muscle_table, &probe);
	120
	121	if (!entry)
	122	{
	123	/* First insertion in the hash. */
	124	entry = xmalloc (sizeof *entry);
	125	entry->key = key;
	126	hash_insert (muscle_table, entry);
	127	}
	128	else
	129	free (entry->storage);
	130	entry->value = value;
	131	entry->storage = NULL;
	132	}
	133
	134
	135	/*-------------------------------------------------------------------.
	136	\| Append VALUE to the current value of KEY. If KEY did not already \|
	137	\| exist, create it. Use MUSCLE_OBSTACK. De-allocate the previously \|
	138	\| associated value. Copy VALUE and SEPARATOR. \|
	139	`-------------------------------------------------------------------*/
	140
	141	void
	142	muscle_grow (const char key, const char val, const char *separator)
	143	{
	144	muscle_entry probe;
	145	muscle_entry *entry = NULL;
	146
	147	probe.key = key;
	148	entry = hash_lookup (muscle_table, &probe);
	149
	150	if (!entry)
	151	{
	152	/* First insertion in the hash. */
	153	entry = xmalloc (sizeof *entry);
	154	entry->key = key;
	155	hash_insert (muscle_table, entry);
	156	entry->value = entry->storage = xstrdup (val);
	157	}
	158	else
	159	{
	160	/* Grow the current value. */
	161	char *new_val;
	162	obstack_sgrow (&muscle_obstack, entry->value);
	163	free (entry->storage);
	164	obstack_sgrow (&muscle_obstack, separator);
	165	obstack_sgrow (&muscle_obstack, val);
	166	obstack_1grow (&muscle_obstack, 0);
	167	new_val = obstack_finish (&muscle_obstack);
	168	entry->value = entry->storage = xstrdup (new_val);
	169	obstack_free (&muscle_obstack, new_val);
	170	}
	171	}
	172
	173
	174	/*------------------------------------------------------------------.
	175	\| Append VALUE to the current value of KEY, using muscle_grow. But \|
	176	\| in addition, issue a synchronization line for the location LOC. \|
	177	`------------------------------------------------------------------*/
	178
	179	void
	180	muscle_code_grow (const char key, const char val, location loc)
	181	{
	182	char *extension = NULL;
	183	obstack_fgrow1 (&muscle_obstack, "]b4_syncline(%d, [[", loc.start.line);
	184	MUSCLE_OBSTACK_SGROW (&muscle_obstack,
	185	quotearg_style (c_quoting_style, loc.start.file));
	186	obstack_sgrow (&muscle_obstack, "]])[\n");
	187	obstack_sgrow (&muscle_obstack, val);
	188	obstack_1grow (&muscle_obstack, 0);
	189	extension = obstack_finish (&muscle_obstack);
	190	muscle_grow (key, extension, "");
	191	obstack_free (&muscle_obstack, extension);
	192	}
	193
	194
	195	void muscle_pair_list_grow (const char *muscle,
	196	const char a1, const char a2)
	197	{
	198	char *pair;
	199	obstack_sgrow (&muscle_obstack, "[[[");
	200	MUSCLE_OBSTACK_SGROW (&muscle_obstack, a1);
	201	obstack_sgrow (&muscle_obstack, "]], [[");
	202	MUSCLE_OBSTACK_SGROW (&muscle_obstack, a2);
	203	obstack_sgrow (&muscle_obstack, "]]]");
	204	obstack_1grow (&muscle_obstack, 0);
	205	pair = obstack_finish (&muscle_obstack);
	206	muscle_grow (muscle, pair, ",\n");
	207	obstack_free (&muscle_obstack, pair);
	208	}
	209
	210
	211	/*----------------------------------------------------------------------------.
	212	\| Find the value of muscle KEY. Unlike MUSCLE_FIND, this is always reliable \|
	213	\| to determine whether KEY has a value. \|
	214	`----------------------------------------------------------------------------*/
	215
	216	char const *
	217	muscle_find_const (char const *key)
	218	{
	219	muscle_entry probe;
	220	muscle_entry *result = NULL;
	221
	222	probe.key = key;
	223	result = hash_lookup (muscle_table, &probe);
	224	if (result)
	225	return result->value;
	226	return NULL;
	227	}
	228
	229
	230	/*----------------------------------------------------------------------------.
	231	\| Find the value of muscle KEY. Abort if muscle_insert was invoked more \|
	232	\| recently than muscle_grow for KEY since muscle_find can't return a \|
	233	\| char const *. \|
	234	`----------------------------------------------------------------------------*/
	235
	236	char *
	237	muscle_find (char const *key)
	238	{
	239	muscle_entry probe;
	240	muscle_entry *result = NULL;
	241
	242	probe.key = key;
	243	result = hash_lookup (muscle_table, &probe);
	244	if (result)
	245	{
	246	aver (result->value == result->storage);
	247	return result->storage;
	248	}
	249	return NULL;
	250	}
	251
	252
	253	void
	254	muscle_boundary_grow (char const *key, boundary bound)
	255	{
	256	char *extension;
	257	MUSCLE_OBSTACK_SGROW (&muscle_obstack, bound.file);
	258	obstack_1grow (&muscle_obstack, ':');
	259	obstack_fgrow1 (&muscle_obstack, "%d", bound.line);
	260	obstack_1grow (&muscle_obstack, '.');
	261	obstack_fgrow1 (&muscle_obstack, "%d", bound.column);
	262	obstack_1grow (&muscle_obstack, '\0');
	263	extension = obstack_finish (&muscle_obstack);
	264	muscle_grow (key, extension, "");
	265	obstack_free (&muscle_obstack, extension);
	266	}
	267
	268	void
	269	muscle_location_grow (char const *key, location loc)
	270	{
	271	muscle_grow (key, "[[", "");
	272	muscle_boundary_grow (key, loc.start);
	273	muscle_grow (key, "]], [[", "");
	274	muscle_boundary_grow (key, loc.end);
	275	muscle_grow (key, "]]", "");
	276	}
	277
	278	/* Reverse of muscle_location_grow. */
	279	static location
	280	muscle_location_decode (char const *key)
	281	{
	282	location loc;
	283	char const *value = muscle_find_const (key);
	284	aver (value);
	285	aver (*value == '[');
	286	aver (*++value == '[');
	287	while (*++value)
	288	switch (*value)
	289	{
	290	case '$':
	291	aver (*++value == ']');
	292	aver (*++value == '[');
	293	obstack_sgrow (&muscle_obstack, "$");
	294	break;
	295	case '@':
	296	switch (*++value)
	297	{
	298	case '@': obstack_sgrow (&muscle_obstack, "@" ); break;
	299	case '{': obstack_sgrow (&muscle_obstack, "[" ); break;
	300	case '}': obstack_sgrow (&muscle_obstack, "]" ); break;
	301	default: aver (false); break;
	302	}
	303	break;
	304	case '[':
	305	aver (false);
	306	break;
	307	case ']':
	308	{
	309	char *boundary_str;
	310	aver (*++value == ']');
	311	obstack_1grow (&muscle_obstack, '\0');
	312	boundary_str = obstack_finish (&muscle_obstack);
	313	switch (*++value)
	314	{
	315	case ',':
	316	boundary_set_from_string (&loc.start, boundary_str);
	317	obstack_free (&muscle_obstack, boundary_str);
	318	aver (*++value == ' ');
	319	aver (*++value == '[');
	320	aver (*++value == '[');
	321	break;
	322	case '\0':
	323	boundary_set_from_string (&loc.end, boundary_str);
	324	obstack_free (&muscle_obstack, boundary_str);
	325	return loc;
	326	break;
	327	default:
	328	aver (false);
	329	break;
	330	}
	331	}
	332	break;
	333	default:
	334	obstack_1grow (&muscle_obstack, *value);
	335	break;
	336	}
	337	aver (false);
	338	return loc;
	339	}
	340
	341	void
	342	muscle_user_name_list_grow (char const key, char const user_name,
	343	location loc)
	344	{
	345	muscle_grow (key, "[[[[", ",");
	346	muscle_grow (key, user_name, "");
	347	muscle_grow (key, "]], ", "");
	348	muscle_location_grow (key, loc);
	349	muscle_grow (key, "]]", "");
	350	}
	351
	352	#define MUSCLE_USER_NAME_CONVERT(NAME, PREFIX, USER_NAME, SUFFIX) \
	353	do { \
	354	char *tmp; \
	355	size_t length = strlen ((USER_NAME)); \
	356	tmp = xmalloc (sizeof (PREFIX) - 1 + length + sizeof (SUFFIX)); \
	357	strcpy (tmp, (PREFIX)); \
	358	strcpy (tmp + sizeof (PREFIX) - 1, (USER_NAME)); \
	359	strcpy (tmp + sizeof (PREFIX) - 1 + length, (SUFFIX)); \
	360	(NAME) = uniqstr_new (tmp); \
	361	free (tmp); \
	362	} while (0)
	363
	364	void
	365	muscle_percent_define_insert (char const *variable, location variable_loc,
	366	char const *value)
	367	{
	368	char const *name;
	369	char const *loc_name;
	370
	371	MUSCLE_USER_NAME_CONVERT (name, "percent_define(", variable, ")");
	372	MUSCLE_USER_NAME_CONVERT (loc_name, "percent_define_loc(", variable, ")");
	373
	374	if (muscle_find_const (name))
	375	{
	376	warn_at (variable_loc, _("%s `%s' redefined"),
	377	"%define variable", variable);
	378	warn_at (muscle_location_decode (loc_name), _("previous definition"));
	379	}
	380	MUSCLE_INSERT_STRING (name, value);
	381
	382	muscle_insert (loc_name, "");
	383	muscle_location_grow (loc_name, variable_loc);
	384	muscle_user_name_list_grow ("percent_define_user_variables", variable,
	385	variable_loc);
	386	}
	387
	388	bool
	389	muscle_percent_define_flag_if (char const *variable)
	390	{
	391	char const *name;
	392	char const *loc_name;
	393	char const *usage_name;
	394	char const *value;
	395	bool result = false;
	396
	397	MUSCLE_USER_NAME_CONVERT (name, "percent_define(", variable, ")");
	398	MUSCLE_USER_NAME_CONVERT (loc_name, "percent_define_loc(", variable, ")");
	399	MUSCLE_USER_NAME_CONVERT (usage_name, "percent_define_bison_variables(",
	400	variable, ")");
	401
	402	value = muscle_find_const (name);
	403	if (value)
	404	{
	405	if (value[0] == '\0' \|\| 0 == strcmp (value, "true"))
	406	result = true;
	407	else if (0 == strcmp (value, "false"))
	408	result = false;
	409	else if (!muscle_find_const (usage_name))
	410	complain_at(muscle_location_decode (loc_name),
	411	_("invalid value for %%define boolean variable `%s'"),
	412	variable);
	413	}
	414	else
	415	fatal(_("undefined %%define variable `%s' passed to muscle_percent_define_flag_if"),
	416	variable);
	417
	418	muscle_insert (usage_name, "");
	419
	420	return result;
	421	}
	422
	423	void
	424	muscle_percent_define_default (char const variable, char const value)
	425	{
	426	char const *name;
	427	char const *loc_name;
	428	MUSCLE_USER_NAME_CONVERT (name, "percent_define(", variable, ")");
	429	MUSCLE_USER_NAME_CONVERT (loc_name, "percent_define_loc(", variable, ")");
	430	if (!muscle_find_const (name))
	431	{
	432	location loc;
	433	MUSCLE_INSERT_STRING (name, value);
	434	loc.start.file = loc.end.file = "[Bison:muscle_percent_define_default]";
	435	loc.start.line = loc.start.column = 0;
	436	loc.end.line = loc.end.column = 0;
	437	muscle_insert (loc_name, "");
	438	muscle_location_grow (loc_name, loc);
	439	}
	440	}
	441
	442	void
	443	muscle_percent_code_grow (char const *qualifier, location qualifier_loc,
	444	char const *code, location code_loc)
	445	{
	446	char const *name;
	447	MUSCLE_USER_NAME_CONVERT (name, "percent_code(", qualifier, ")");
	448	muscle_code_grow (name, code, code_loc);
	449	muscle_user_name_list_grow ("percent_code_user_qualifiers", qualifier,
	450	qualifier_loc);
	451	}
	452
	453
	454	/*------------------------------------------------.
	455	\| Output the definition of ENTRY as a m4_define. \|
	456	`------------------------------------------------*/
	457
	458	static inline bool
	459	muscle_m4_output (muscle_entry entry, FILE out)
	460	{
	461	fprintf (out, "m4_define([b4_%s],\n", entry->key);
	462	fprintf (out, "[[%s]])\n\n\n", entry->value);
	463	return true;
	464	}
	465
	466	static bool
	467	muscle_m4_output_processor (void entry, void out)
	468	{
	469	return muscle_m4_output (entry, out);
	470	}
	471
	472
	473	/*----------------------------------------------------------------.
	474	\| Output the definition of all the current muscles into a list of \|
	475	\| m4_defines. \|
	476	`----------------------------------------------------------------*/
	477
	478	void
	479	muscles_m4_output (FILE *out)
	480	{
	481	hash_do_for_each (muscle_table, muscle_m4_output_processor, out);
	482	}