1 /* Muscle table manager for Bison.
3 Copyright (C) 2001-2011 Free Software Foundation, Inc.
5 This file is part of Bison, the GNU Compiler Compiler.
7 This program is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
28 #include "muscle-tab.h"
31 /* A key-value pair, along with storage that can be reclaimed when
32 this pair is no longer needed. */
40 /* An obstack used to create some entries. */
41 struct obstack muscle_obstack
;
43 /* Initial capacity of muscles hash table. */
44 #define HT_INITIAL_CAPACITY 257
46 static struct hash_table
*muscle_table
= NULL
;
49 hash_compare_muscles (void const *x
, void const *y
)
51 muscle_entry
const *m1
= x
;
52 muscle_entry
const *m2
= y
;
53 return strcmp (m1
->key
, m2
->key
) == 0;
57 hash_muscle (const void *x
, size_t tablesize
)
59 muscle_entry
const *m
= x
;
60 return hash_string (m
->key
, tablesize
);
63 /*-----------------------------------------------------------------.
64 | Create the MUSCLE_TABLE, and initialize it with default values. |
65 | Also set up the MUSCLE_OBSTACK. |
66 `-----------------------------------------------------------------*/
69 muscle_entry_free (void *entry
)
71 muscle_entry
*mentry
= entry
;
72 free (mentry
->storage
);
79 /* Initialize the muscle obstack. */
80 obstack_init (&muscle_obstack
);
82 muscle_table
= hash_initialize (HT_INITIAL_CAPACITY
, NULL
, hash_muscle
,
83 hash_compare_muscles
, muscle_entry_free
);
85 /* Version and input file. */
86 MUSCLE_INSERT_STRING ("version", VERSION
);
90 /*------------------------------------------------------------.
91 | Free all the memory consumed by the muscle machinery only. |
92 `------------------------------------------------------------*/
97 hash_free (muscle_table
);
98 obstack_free (&muscle_obstack
, NULL
);
103 /*------------------------------------------------------------.
104 | Insert (KEY, VALUE). If KEY already existed, overwrite the |
106 `------------------------------------------------------------*/
109 muscle_insert (char const *key
, char const *value
)
115 entry
= hash_lookup (muscle_table
, &probe
);
119 /* First insertion in the hash. */
120 entry
= xmalloc (sizeof *entry
);
122 if (!hash_insert (muscle_table
, entry
))
126 free (entry
->storage
);
127 entry
->value
= value
;
128 entry
->storage
= NULL
;
132 /*-------------------------------------------------------------------.
133 | Append VALUE to the current value of KEY. If KEY did not already |
134 | exist, create it. Use MUSCLE_OBSTACK. De-allocate the previously |
135 | associated value. Copy VALUE and SEPARATOR. |
136 `-------------------------------------------------------------------*/
139 muscle_grow (const char *key
, const char *val
, const char *separator
)
142 muscle_entry
*entry
= NULL
;
145 entry
= hash_lookup (muscle_table
, &probe
);
149 /* First insertion in the hash. */
150 entry
= xmalloc (sizeof *entry
);
152 if (!hash_insert (muscle_table
, entry
))
154 entry
->value
= entry
->storage
= xstrdup (val
);
158 /* Grow the current value. */
160 obstack_sgrow (&muscle_obstack
, entry
->value
);
161 free (entry
->storage
);
162 obstack_sgrow (&muscle_obstack
, separator
);
163 obstack_sgrow (&muscle_obstack
, val
);
164 obstack_1grow (&muscle_obstack
, 0);
165 new_val
= obstack_finish (&muscle_obstack
);
166 entry
->value
= entry
->storage
= xstrdup (new_val
);
167 obstack_free (&muscle_obstack
, new_val
);
171 /*------------------------------------------------------------------.
172 | Using muscle_grow, append a synchronization line for the location |
173 | LOC to the current value of KEY. |
174 `------------------------------------------------------------------*/
177 muscle_syncline_grow (char const *key
, location loc
)
179 char *extension
= NULL
;
180 obstack_fgrow1 (&muscle_obstack
, "]b4_syncline(%d, [[", loc
.start
.line
);
181 MUSCLE_OBSTACK_SGROW (&muscle_obstack
,
182 quotearg_style (c_quoting_style
, loc
.start
.file
));
183 obstack_sgrow (&muscle_obstack
, "]])[");
184 obstack_1grow (&muscle_obstack
, 0);
185 extension
= obstack_finish (&muscle_obstack
);
186 muscle_grow (key
, extension
, "");
187 obstack_free (&muscle_obstack
, extension
);
190 /*------------------------------------------------------------------.
191 | Append VALUE to the current value of KEY, using muscle_grow. But |
192 | in addition, issue a synchronization line for the location LOC |
193 | using muscle_syncline_grow. |
194 `------------------------------------------------------------------*/
197 muscle_code_grow (const char *key
, const char *val
, location loc
)
199 muscle_syncline_grow (key
, loc
);
200 muscle_grow (key
, val
, "\n");
204 void muscle_pair_list_grow (const char *muscle
,
205 const char *a1
, const char *a2
)
208 obstack_sgrow (&muscle_obstack
, "[[[");
209 MUSCLE_OBSTACK_SGROW (&muscle_obstack
, a1
);
210 obstack_sgrow (&muscle_obstack
, "]], [[");
211 MUSCLE_OBSTACK_SGROW (&muscle_obstack
, a2
);
212 obstack_sgrow (&muscle_obstack
, "]]]");
213 obstack_1grow (&muscle_obstack
, 0);
214 pair
= obstack_finish (&muscle_obstack
);
215 muscle_grow (muscle
, pair
, ",\n");
216 obstack_free (&muscle_obstack
, pair
);
220 /*----------------------------------------------------------------------------.
221 | Find the value of muscle KEY. Unlike MUSCLE_FIND, this is always reliable |
222 | to determine whether KEY has a value. |
223 `----------------------------------------------------------------------------*/
226 muscle_find_const (char const *key
)
229 muscle_entry
*result
= NULL
;
232 result
= hash_lookup (muscle_table
, &probe
);
234 return result
->value
;
239 /*----------------------------------------------------------------------------.
240 | Find the value of muscle KEY. Abort if muscle_insert was invoked more |
241 | recently than muscle_grow for KEY since muscle_find can't return a |
243 `----------------------------------------------------------------------------*/
246 muscle_find (char const *key
)
249 muscle_entry
*result
= NULL
;
252 result
= hash_lookup (muscle_table
, &probe
);
255 aver (result
->value
== result
->storage
);
256 return result
->storage
;
263 muscle_boundary_grow (char const *key
, boundary bound
)
266 MUSCLE_OBSTACK_SGROW (&muscle_obstack
, bound
.file
);
267 obstack_1grow (&muscle_obstack
, ':');
268 obstack_fgrow1 (&muscle_obstack
, "%d", bound
.line
);
269 obstack_1grow (&muscle_obstack
, '.');
270 obstack_fgrow1 (&muscle_obstack
, "%d", bound
.column
);
271 obstack_1grow (&muscle_obstack
, '\0');
272 extension
= obstack_finish (&muscle_obstack
);
273 muscle_grow (key
, extension
, "");
274 obstack_free (&muscle_obstack
, extension
);
278 muscle_location_grow (char const *key
, location loc
)
280 muscle_grow (key
, "[[", "");
281 muscle_boundary_grow (key
, loc
.start
);
282 muscle_grow (key
, "]], [[", "");
283 muscle_boundary_grow (key
, loc
.end
);
284 muscle_grow (key
, "]]", "");
287 #define MUSCLE_COMMON_DECODE(Value) \
289 aver (*++(Value) == ']'); \
290 aver (*++(Value) == '['); \
291 obstack_sgrow (&muscle_obstack, "$"); \
294 switch (*++(Value)) \
296 case '@': obstack_sgrow (&muscle_obstack, "@" ); break; \
297 case '{': obstack_sgrow (&muscle_obstack, "[" ); break; \
298 case '}': obstack_sgrow (&muscle_obstack, "]" ); break; \
299 default: aver (false); break; \
303 obstack_1grow (&muscle_obstack, *(Value)); \
306 /* Reverse of MUSCLE_OBSTACK_SGROW. */
308 muscle_string_decode (char const *key
)
314 value
= muscle_find_const (key
);
320 MUSCLE_COMMON_DECODE (value
)
327 value_decoded
= obstack_finish (&muscle_obstack
);
328 result
= xstrdup (value_decoded
);
329 obstack_free (&muscle_obstack
, value_decoded
);
333 /* Reverse of muscle_location_grow. */
335 muscle_location_decode (char const *key
)
338 char const *value
= muscle_find_const (key
);
340 aver (*value
== '[');
341 aver (*++value
== '[');
345 MUSCLE_COMMON_DECODE (value
)
352 aver (*++value
== ']');
353 obstack_1grow (&muscle_obstack
, '\0');
354 boundary_str
= obstack_finish (&muscle_obstack
);
358 boundary_set_from_string (&loc
.start
, boundary_str
);
359 obstack_free (&muscle_obstack
, boundary_str
);
360 aver (*++value
== ' ');
361 aver (*++value
== '[');
362 aver (*++value
== '[');
365 boundary_set_from_string (&loc
.end
, boundary_str
);
366 obstack_free (&muscle_obstack
, boundary_str
);
381 muscle_user_name_list_grow (char const *key
, char const *user_name
,
384 muscle_grow (key
, "[[[[", ",");
385 muscle_grow (key
, user_name
, "");
386 muscle_grow (key
, "]], ", "");
387 muscle_location_grow (key
, loc
);
388 muscle_grow (key
, "]]", "");
392 muscle_percent_define_insert (char const *variable
, location variable_loc
,
394 muscle_percent_define_how how
)
396 char *variable_tr
= NULL
;
398 char const *loc_name
;
399 char const *syncline_name
;
400 char const *how_name
;
402 /* Permit certain names with underscores for backward compatibility. */
403 if (0 == strcmp (variable
, "api.push_pull")
404 || 0 == strcmp (variable
, "lr.keep_unreachable_states"))
406 variable_tr
= strdup (variable
);
407 tr (variable_tr
, '_', '-');
408 variable
= variable_tr
;
411 name
= UNIQSTR_CONCAT ("percent_define(", variable
, ")");
412 loc_name
= UNIQSTR_CONCAT ("percent_define_loc(", variable
, ")");
414 UNIQSTR_CONCAT ("percent_define_syncline(", variable
, ")");
415 how_name
= UNIQSTR_CONCAT ("percent_define_how(", variable
, ")");
417 /* Command-line options are processed before the grammar file. */
418 if (how
== MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE
419 && muscle_find_const (name
))
421 muscle_percent_define_how how_old
=
422 atoi (muscle_find_const (how_name
));
423 if (how_old
== MUSCLE_PERCENT_DEFINE_F
)
428 complain_at (variable_loc
, _("%%define variable `%s' redefined"),
430 complain_at (muscle_percent_define_get_loc (variable
),
431 _("previous definition"));
434 MUSCLE_INSERT_STRING (name
, value
);
435 muscle_insert (loc_name
, "");
436 muscle_location_grow (loc_name
, variable_loc
);
437 muscle_insert (syncline_name
, "");
438 muscle_syncline_grow (syncline_name
, variable_loc
);
439 muscle_user_name_list_grow ("percent_define_user_variables", variable
,
441 MUSCLE_INSERT_INT (how_name
, how
);
447 muscle_percent_define_get (char const *variable
)
450 char const *usage_name
;
453 name
= UNIQSTR_CONCAT ("percent_define(", variable
, ")");
454 usage_name
= UNIQSTR_CONCAT ("percent_define_bison_variables(",
457 muscle_insert (usage_name
, "");
458 value
= muscle_string_decode (name
);
460 value
= xstrdup ("");
465 muscle_percent_define_get_loc (char const *variable
)
467 char const *loc_name
;
468 loc_name
= UNIQSTR_CONCAT ("percent_define_loc(", variable
, ")");
469 if (!muscle_find_const (loc_name
))
470 fatal(_("undefined %%define variable `%s' passed to"
471 " muscle_percent_define_get_loc"), variable
);
472 return muscle_location_decode (loc_name
);
476 muscle_percent_define_get_syncline (char const *variable
)
478 char const *syncline_name
;
479 char const *syncline
;
481 UNIQSTR_CONCAT ("percent_define_syncline(", variable
, ")");
482 syncline
= muscle_find_const (syncline_name
);
484 fatal(_("undefined %%define variable `%s' passed to"
485 " muscle_percent_define_get_syncline"), variable
);
490 muscle_percent_define_ifdef (char const *variable
)
493 char const *usage_name
;
496 name
= UNIQSTR_CONCAT ("percent_define(", variable
, ")");
498 UNIQSTR_CONCAT ("percent_define_bison_variables(", variable
, ")");
500 value
= muscle_find_const (name
);
503 muscle_insert (usage_name
, "");
511 muscle_percent_define_flag_if (char const *variable
)
513 char const *invalid_boolean_name
;
516 invalid_boolean_name
=
517 UNIQSTR_CONCAT ("percent_define_invalid_boolean(", variable
, ")");
519 if (muscle_percent_define_ifdef (variable
))
521 char *value
= muscle_percent_define_get (variable
);
522 if (value
[0] == '\0' || 0 == strcmp (value
, "true"))
524 else if (0 == strcmp (value
, "false"))
526 else if (!muscle_find_const (invalid_boolean_name
))
528 muscle_insert (invalid_boolean_name
, "");
529 complain_at(muscle_percent_define_get_loc (variable
),
530 _("invalid value for %%define Boolean variable `%s'"),
536 fatal(_("undefined %%define variable `%s' passed to muscle_percent_define_flag_if"),
543 muscle_percent_define_default (char const *variable
, char const *value
)
546 char const *loc_name
;
547 char const *syncline_name
;
548 name
= UNIQSTR_CONCAT ("percent_define(", variable
, ")");
549 loc_name
= UNIQSTR_CONCAT ("percent_define_loc(", variable
, ")");
551 UNIQSTR_CONCAT ("percent_define_syncline(", variable
, ")");
552 if (!muscle_find_const (name
))
555 MUSCLE_INSERT_STRING (name
, value
);
556 loc
.start
.file
= loc
.end
.file
= "<default value>";
557 loc
.start
.line
= loc
.end
.line
= -1;
558 loc
.start
.column
= loc
.end
.column
= -1;
559 muscle_insert (loc_name
, "");
560 muscle_location_grow (loc_name
, loc
);
561 muscle_insert (syncline_name
, "");
566 muscle_percent_define_check_values (char const * const *values
)
568 for (; *values
; ++values
)
570 char const * const *variablep
= values
;
574 name
= UNIQSTR_CONCAT ("percent_define(", *variablep
, ")");
576 value
= muscle_string_decode (name
);
579 for (++values
; *values
; ++values
)
581 if (0 == strcmp (value
, *values
))
586 location loc
= muscle_percent_define_get_loc (*variablep
);
588 _("invalid value for %%define variable `%s': `%s'"),
590 for (values
= variablep
+ 1; *values
; ++values
)
591 complain_at (loc
, _("accepted value: `%s'"), *values
);
601 fatal(_("undefined %%define variable `%s' passed to"
602 " muscle_percent_define_check_values"),
608 muscle_percent_code_grow (char const *qualifier
, location qualifier_loc
,
609 char const *code
, location code_loc
)
612 name
= UNIQSTR_CONCAT ("percent_code(", qualifier
, ")");
613 muscle_code_grow (name
, code
, code_loc
);
614 muscle_user_name_list_grow ("percent_code_user_qualifiers", qualifier
,
619 /*------------------------------------------------.
620 | Output the definition of ENTRY as a m4_define. |
621 `------------------------------------------------*/
624 muscle_m4_output (muscle_entry
*entry
, FILE *out
)
626 fprintf (out
, "m4_define([b4_%s],\n", entry
->key
);
627 fprintf (out
, "[[%s]])\n\n\n", entry
->value
);
632 muscle_m4_output_processor (void *entry
, void *out
)
634 return muscle_m4_output (entry
, out
);
638 /*----------------------------------------------------------------.
639 | Output the definition of all the current muscles into a list of |
641 `----------------------------------------------------------------*/
644 muscles_m4_output (FILE *out
)
646 hash_do_for_each (muscle_table
, muscle_m4_output_processor
, out
);