]> git.saurik.com Git - bison.git/blob - src/muscle-tab.c
1e55a0095a75ac8fca14f8e3212fca336f44b11d
[bison.git] / src / muscle-tab.c
1 /* Muscle table manager for Bison.
2
3 Copyright (C) 2001-2011 Free Software Foundation, Inc.
4
5 This file is part of Bison, the GNU Compiler Compiler.
6
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.
11
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.
16
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/>. */
19
20 #include <config.h>
21 #include "system.h"
22
23 #include <hash.h>
24 #include <quotearg.h>
25
26 #include "complain.h"
27 #include "files.h"
28 #include "muscle-tab.h"
29 #include "getargs.h"
30
31 /* A key-value pair, along with storage that can be reclaimed when
32 this pair is no longer needed. */
33 typedef struct
34 {
35 char const *key;
36 char const *value;
37 char *storage;
38 } muscle_entry;
39
40 /* An obstack used to create some entries. */
41 struct obstack muscle_obstack;
42
43 /* Initial capacity of muscles hash table. */
44 #define HT_INITIAL_CAPACITY 257
45
46 static struct hash_table *muscle_table = NULL;
47
48 static bool
49 hash_compare_muscles (void const *x, void const *y)
50 {
51 muscle_entry const *m1 = x;
52 muscle_entry const *m2 = y;
53 return strcmp (m1->key, m2->key) == 0;
54 }
55
56 static size_t
57 hash_muscle (const void *x, size_t tablesize)
58 {
59 muscle_entry const *m = x;
60 return hash_string (m->key, tablesize);
61 }
62
63 /*-----------------------------------------------------------------.
64 | Create the MUSCLE_TABLE, and initialize it with default values. |
65 | Also set up the MUSCLE_OBSTACK. |
66 `-----------------------------------------------------------------*/
67
68 static void
69 muscle_entry_free (void *entry)
70 {
71 muscle_entry *mentry = entry;
72 free (mentry->storage);
73 free (mentry);
74 }
75
76 void
77 muscle_init (void)
78 {
79 /* Initialize the muscle obstack. */
80 obstack_init (&muscle_obstack);
81
82 muscle_table = hash_initialize (HT_INITIAL_CAPACITY, NULL, hash_muscle,
83 hash_compare_muscles, muscle_entry_free);
84
85 /* Version and input file. */
86 MUSCLE_INSERT_STRING ("version", VERSION);
87 }
88
89
90 /*------------------------------------------------------------.
91 | Free all the memory consumed by the muscle machinery only. |
92 `------------------------------------------------------------*/
93
94 void
95 muscle_free (void)
96 {
97 hash_free (muscle_table);
98 obstack_free (&muscle_obstack, NULL);
99 }
100
101
102
103 /*------------------------------------------------------------.
104 | Insert (KEY, VALUE). If KEY already existed, overwrite the |
105 | previous value. |
106 `------------------------------------------------------------*/
107
108 void
109 muscle_insert (char const *key, char const *value)
110 {
111 muscle_entry probe;
112 muscle_entry *entry;
113
114 probe.key = key;
115 entry = hash_lookup (muscle_table, &probe);
116
117 if (!entry)
118 {
119 /* First insertion in the hash. */
120 entry = xmalloc (sizeof *entry);
121 entry->key = key;
122 if (!hash_insert (muscle_table, entry))
123 xalloc_die ();
124 }
125 else
126 free (entry->storage);
127 entry->value = value;
128 entry->storage = NULL;
129 }
130
131
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 `-------------------------------------------------------------------*/
137
138 void
139 muscle_grow (const char *key, const char *val, const char *separator)
140 {
141 muscle_entry probe;
142 muscle_entry *entry = NULL;
143
144 probe.key = key;
145 entry = hash_lookup (muscle_table, &probe);
146
147 if (!entry)
148 {
149 /* First insertion in the hash. */
150 entry = xmalloc (sizeof *entry);
151 entry->key = key;
152 if (!hash_insert (muscle_table, entry))
153 xalloc_die ();
154 entry->value = entry->storage = xstrdup (val);
155 }
156 else
157 {
158 /* Grow the current value. */
159 char *new_val;
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);
168 }
169 }
170
171 /*------------------------------------------------------------------.
172 | Using muscle_grow, append a synchronization line for the location |
173 | LOC to the current value of KEY. |
174 `------------------------------------------------------------------*/
175
176 static void
177 muscle_syncline_grow (char const *key, location loc)
178 {
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);
188 }
189
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 `------------------------------------------------------------------*/
195
196 void
197 muscle_code_grow (const char *key, const char *val, location loc)
198 {
199 muscle_syncline_grow (key, loc);
200 muscle_grow (key, val, "\n");
201 }
202
203
204 void muscle_pair_list_grow (const char *muscle,
205 const char *a1, const char *a2)
206 {
207 char *pair;
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);
217 }
218
219
220 /*----------------------------------------------------------------------------.
221 | Find the value of muscle KEY. Unlike MUSCLE_FIND, this is always reliable |
222 | to determine whether KEY has a value. |
223 `----------------------------------------------------------------------------*/
224
225 char const *
226 muscle_find_const (char const *key)
227 {
228 muscle_entry probe;
229 muscle_entry *result = NULL;
230
231 probe.key = key;
232 result = hash_lookup (muscle_table, &probe);
233 if (result)
234 return result->value;
235 return NULL;
236 }
237
238
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 |
242 | char const *. |
243 `----------------------------------------------------------------------------*/
244
245 char *
246 muscle_find (char const *key)
247 {
248 muscle_entry probe;
249 muscle_entry *result = NULL;
250
251 probe.key = key;
252 result = hash_lookup (muscle_table, &probe);
253 if (result)
254 {
255 aver (result->value == result->storage);
256 return result->storage;
257 }
258 return NULL;
259 }
260
261
262 void
263 muscle_boundary_grow (char const *key, boundary bound)
264 {
265 char *extension;
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);
275 }
276
277 void
278 muscle_location_grow (char const *key, location loc)
279 {
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, "]]", "");
285 }
286
287 #define MUSCLE_COMMON_DECODE(Value) \
288 case '$': \
289 aver (*++(Value) == ']'); \
290 aver (*++(Value) == '['); \
291 obstack_sgrow (&muscle_obstack, "$"); \
292 break; \
293 case '@': \
294 switch (*++(Value)) \
295 { \
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; \
300 } \
301 break; \
302 default: \
303 obstack_1grow (&muscle_obstack, *(Value)); \
304 break;
305
306 /* Reverse of MUSCLE_OBSTACK_SGROW. */
307 static char *
308 muscle_string_decode (char const *key)
309 {
310 char const *value;
311 char *value_decoded;
312 char *result;
313
314 value = muscle_find_const (key);
315 if (!value)
316 return NULL;
317 do {
318 switch (*value)
319 {
320 MUSCLE_COMMON_DECODE (value)
321 case '[':
322 case ']':
323 aver (false);
324 break;
325 }
326 } while (*value++);
327 value_decoded = obstack_finish (&muscle_obstack);
328 result = xstrdup (value_decoded);
329 obstack_free (&muscle_obstack, value_decoded);
330 return result;
331 }
332
333 /* Reverse of muscle_location_grow. */
334 static location
335 muscle_location_decode (char const *key)
336 {
337 location loc;
338 char const *value = muscle_find_const (key);
339 aver (value);
340 aver (*value == '[');
341 aver (*++value == '[');
342 while (*++value)
343 switch (*value)
344 {
345 MUSCLE_COMMON_DECODE (value)
346 case '[':
347 aver (false);
348 break;
349 case ']':
350 {
351 char *boundary_str;
352 aver (*++value == ']');
353 obstack_1grow (&muscle_obstack, '\0');
354 boundary_str = obstack_finish (&muscle_obstack);
355 switch (*++value)
356 {
357 case ',':
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 == '[');
363 break;
364 case '\0':
365 boundary_set_from_string (&loc.end, boundary_str);
366 obstack_free (&muscle_obstack, boundary_str);
367 return loc;
368 break;
369 default:
370 aver (false);
371 break;
372 }
373 }
374 break;
375 }
376 aver (false);
377 return loc;
378 }
379
380 void
381 muscle_user_name_list_grow (char const *key, char const *user_name,
382 location loc)
383 {
384 muscle_grow (key, "[[[[", ",");
385 muscle_grow (key, user_name, "");
386 muscle_grow (key, "]], ", "");
387 muscle_location_grow (key, loc);
388 muscle_grow (key, "]]", "");
389 }
390
391 void
392 muscle_percent_define_insert (char const *variable, location variable_loc,
393 char const *value,
394 muscle_percent_define_how how)
395 {
396 char *variable_tr = NULL;
397 char const *name;
398 char const *loc_name;
399 char const *syncline_name;
400 char const *how_name;
401
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"))
405 {
406 variable_tr = strdup (variable);
407 tr (variable_tr, '_', '-');
408 variable = variable_tr;
409 }
410
411 name = UNIQSTR_CONCAT ("percent_define(", variable, ")");
412 loc_name = UNIQSTR_CONCAT ("percent_define_loc(", variable, ")");
413 syncline_name =
414 UNIQSTR_CONCAT ("percent_define_syncline(", variable, ")");
415 how_name = UNIQSTR_CONCAT ("percent_define_how(", variable, ")");
416
417 /* Command-line options are processed before the grammar file. */
418 if (how == MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE
419 && muscle_find_const (name))
420 {
421 muscle_percent_define_how how_old =
422 atoi (muscle_find_const (how_name));
423 if (how_old == MUSCLE_PERCENT_DEFINE_F)
424 {
425 free (variable_tr);
426 return;
427 }
428 complain_at (variable_loc, _("%%define variable `%s' redefined"),
429 variable);
430 complain_at (muscle_percent_define_get_loc (variable),
431 _("previous definition"));
432 }
433
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,
440 variable_loc);
441 MUSCLE_INSERT_INT (how_name, how);
442
443 free (variable_tr);
444 }
445
446 char *
447 muscle_percent_define_get (char const *variable)
448 {
449 char const *name;
450 char const *usage_name;
451 char *value;
452
453 name = UNIQSTR_CONCAT ("percent_define(", variable, ")");
454 usage_name = UNIQSTR_CONCAT ("percent_define_bison_variables(",
455 variable, ")");
456
457 muscle_insert (usage_name, "");
458 value = muscle_string_decode (name);
459 if (!value)
460 value = xstrdup ("");
461 return value;
462 }
463
464 location
465 muscle_percent_define_get_loc (char const *variable)
466 {
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);
473 }
474
475 char const *
476 muscle_percent_define_get_syncline (char const *variable)
477 {
478 char const *syncline_name;
479 char const *syncline;
480 syncline_name =
481 UNIQSTR_CONCAT ("percent_define_syncline(", variable, ")");
482 syncline = muscle_find_const (syncline_name);
483 if (!syncline)
484 fatal(_("undefined %%define variable `%s' passed to"
485 " muscle_percent_define_get_syncline"), variable);
486 return syncline;
487 }
488
489 bool
490 muscle_percent_define_ifdef (char const *variable)
491 {
492 char const *name;
493 char const *usage_name;
494 char const *value;
495
496 name = UNIQSTR_CONCAT ("percent_define(", variable, ")");
497 usage_name =
498 UNIQSTR_CONCAT ("percent_define_bison_variables(", variable, ")");
499
500 value = muscle_find_const (name);
501 if (value)
502 {
503 muscle_insert (usage_name, "");
504 return true;
505 }
506
507 return false;
508 }
509
510 bool
511 muscle_percent_define_flag_if (char const *variable)
512 {
513 char const *invalid_boolean_name;
514 bool result = false;
515
516 invalid_boolean_name =
517 UNIQSTR_CONCAT ("percent_define_invalid_boolean(", variable, ")");
518
519 if (muscle_percent_define_ifdef (variable))
520 {
521 char *value = muscle_percent_define_get (variable);
522 if (value[0] == '\0' || 0 == strcmp (value, "true"))
523 result = true;
524 else if (0 == strcmp (value, "false"))
525 result = false;
526 else if (!muscle_find_const (invalid_boolean_name))
527 {
528 muscle_insert (invalid_boolean_name, "");
529 complain_at(muscle_percent_define_get_loc (variable),
530 _("invalid value for %%define Boolean variable `%s'"),
531 variable);
532 }
533 free (value);
534 }
535 else
536 fatal(_("undefined %%define variable `%s' passed to muscle_percent_define_flag_if"),
537 variable);
538
539 return result;
540 }
541
542 void
543 muscle_percent_define_default (char const *variable, char const *value)
544 {
545 char const *name;
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, ")");
550 syncline_name =
551 UNIQSTR_CONCAT ("percent_define_syncline(", variable, ")");
552 if (!muscle_find_const (name))
553 {
554 location loc;
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, "");
562 }
563 }
564
565 void
566 muscle_percent_define_check_values (char const * const *values)
567 {
568 for (; *values; ++values)
569 {
570 char const * const *variablep = values;
571 char const *name;
572 char *value;
573
574 name = UNIQSTR_CONCAT ("percent_define(", *variablep, ")");
575
576 value = muscle_string_decode (name);
577 if (value)
578 {
579 for (++values; *values; ++values)
580 {
581 if (0 == strcmp (value, *values))
582 break;
583 }
584 if (!*values)
585 {
586 location loc = muscle_percent_define_get_loc (*variablep);
587 complain_at(loc,
588 _("invalid value for %%define variable `%s': `%s'"),
589 *variablep, value);
590 for (values = variablep + 1; *values; ++values)
591 complain_at (loc, _("accepted value: `%s'"), *values);
592 }
593 else
594 {
595 while (*values)
596 ++values;
597 }
598 free (value);
599 }
600 else
601 fatal(_("undefined %%define variable `%s' passed to"
602 " muscle_percent_define_check_values"),
603 *variablep);
604 }
605 }
606
607 void
608 muscle_percent_code_grow (char const *qualifier, location qualifier_loc,
609 char const *code, location code_loc)
610 {
611 char const *name;
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,
615 qualifier_loc);
616 }
617
618
619 /*------------------------------------------------.
620 | Output the definition of ENTRY as a m4_define. |
621 `------------------------------------------------*/
622
623 static inline bool
624 muscle_m4_output (muscle_entry *entry, FILE *out)
625 {
626 fprintf (out, "m4_define([b4_%s],\n", entry->key);
627 fprintf (out, "[[%s]])\n\n\n", entry->value);
628 return true;
629 }
630
631 static bool
632 muscle_m4_output_processor (void *entry, void *out)
633 {
634 return muscle_m4_output (entry, out);
635 }
636
637
638 /*----------------------------------------------------------------.
639 | Output the definition of all the current muscles into a list of |
640 | m4_defines. |
641 `----------------------------------------------------------------*/
642
643 void
644 muscles_m4_output (FILE *out)
645 {
646 hash_do_for_each (muscle_table, muscle_m4_output_processor, out);
647 }