Commit | Line | Data |
---|---|---|
e00b6826 PE |
1 | /* Muscle table manager for Bison. |
2 | ||
c932d613 | 3 | Copyright (C) 2001-2012 Free Software Foundation, Inc. |
f753cd62 MA |
4 | |
5 | This file is part of Bison, the GNU Compiler Compiler. | |
6 | ||
f16b0819 | 7 | This program is free software: you can redistribute it and/or modify |
f753cd62 | 8 | it under the terms of the GNU General Public License as published by |
f16b0819 PE |
9 | the Free Software Foundation, either version 3 of the License, or |
10 | (at your option) any later version. | |
f753cd62 | 11 | |
f16b0819 | 12 | This program is distributed in the hope that it will be useful, |
f753cd62 MA |
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 | |
f16b0819 | 18 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
f753cd62 | 19 | |
2cec9080 | 20 | #include <config.h> |
f753cd62 | 21 | #include "system.h" |
8322e8f5 PE |
22 | |
23 | #include <hash.h> | |
8322e8f5 | 24 | |
9611cfa2 | 25 | #include "complain.h" |
f753cd62 | 26 | #include "files.h" |
f508cb0a | 27 | #include "getargs.h" |
4c787a31 AD |
28 | #include "muscle-tab.h" |
29 | #include "quote.h" | |
f753cd62 | 30 | |
eb095650 PE |
31 | /* A key-value pair, along with storage that can be reclaimed when |
32 | this pair is no longer needed. */ | |
8322e8f5 PE |
33 | typedef struct |
34 | { | |
eb095650 PE |
35 | char const *key; |
36 | char const *value; | |
37 | char *storage; | |
8322e8f5 | 38 | } muscle_entry; |
592e8d4d AD |
39 | |
40 | /* An obstack used to create some entries. */ | |
41 | struct obstack muscle_obstack; | |
42 | ||
beda758b AD |
43 | /* Initial capacity of muscles hash table. */ |
44 | #define HT_INITIAL_CAPACITY 257 | |
f753cd62 | 45 | |
04098407 | 46 | static struct hash_table *muscle_table = NULL; |
f753cd62 | 47 | |
beda758b AD |
48 | static bool |
49 | hash_compare_muscles (void const *x, void const *y) | |
f753cd62 | 50 | { |
8322e8f5 PE |
51 | muscle_entry const *m1 = x; |
52 | muscle_entry const *m2 = y; | |
5dd5fd4a | 53 | return strcmp (m1->key, m2->key) == 0; |
f753cd62 MA |
54 | } |
55 | ||
233a88ad PE |
56 | static size_t |
57 | hash_muscle (const void *x, size_t tablesize) | |
f753cd62 | 58 | { |
8322e8f5 | 59 | muscle_entry const *m = x; |
beda758b | 60 | return hash_string (m->key, tablesize); |
f753cd62 MA |
61 | } |
62 | ||
592e8d4d AD |
63 | /*-----------------------------------------------------------------. |
64 | | Create the MUSCLE_TABLE, and initialize it with default values. | | |
65 | | Also set up the MUSCLE_OBSTACK. | | |
66 | `-----------------------------------------------------------------*/ | |
67 | ||
eb095650 PE |
68 | static void |
69 | muscle_entry_free (void *entry) | |
70 | { | |
71 | muscle_entry *mentry = entry; | |
72 | free (mentry->storage); | |
73 | free (mentry); | |
74 | } | |
75 | ||
f753cd62 MA |
76 | void |
77 | muscle_init (void) | |
78 | { | |
ae7453f2 AD |
79 | /* Initialize the muscle obstack. */ |
80 | obstack_init (&muscle_obstack); | |
81 | ||
beda758b | 82 | muscle_table = hash_initialize (HT_INITIAL_CAPACITY, NULL, hash_muscle, |
eb095650 | 83 | hash_compare_muscles, muscle_entry_free); |
f753cd62 MA |
84 | |
85 | /* Version and input file. */ | |
ae7453f2 | 86 | MUSCLE_INSERT_STRING ("version", VERSION); |
f753cd62 MA |
87 | } |
88 | ||
592e8d4d AD |
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 | ||
ae7453f2 AD |
103 | /*------------------------------------------------------------. |
104 | | Insert (KEY, VALUE). If KEY already existed, overwrite the | | |
105 | | previous value. | | |
106 | `------------------------------------------------------------*/ | |
107 | ||
a870c567 | 108 | void |
eb095650 | 109 | muscle_insert (char const *key, char const *value) |
f753cd62 | 110 | { |
8322e8f5 | 111 | muscle_entry probe; |
da2a7671 | 112 | muscle_entry *entry; |
e9bca3ad | 113 | |
ae7453f2 AD |
114 | probe.key = key; |
115 | entry = hash_lookup (muscle_table, &probe); | |
beda758b AD |
116 | |
117 | if (!entry) | |
118 | { | |
119 | /* First insertion in the hash. */ | |
da2a7671 | 120 | entry = xmalloc (sizeof *entry); |
beda758b | 121 | entry->key = key; |
75c7a52a AD |
122 | if (!hash_insert (muscle_table, entry)) |
123 | xalloc_die (); | |
beda758b | 124 | } |
4502eadc JD |
125 | else |
126 | free (entry->storage); | |
beda758b | 127 | entry->value = value; |
4502eadc | 128 | entry->storage = NULL; |
f753cd62 MA |
129 | } |
130 | ||
ae7453f2 AD |
131 | |
132 | /*-------------------------------------------------------------------. | |
ff5150d9 PE |
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. | | |
ae7453f2 AD |
136 | `-------------------------------------------------------------------*/ |
137 | ||
138 | void | |
139 | muscle_grow (const char *key, const char *val, const char *separator) | |
140 | { | |
8322e8f5 PE |
141 | muscle_entry probe; |
142 | muscle_entry *entry = NULL; | |
ae7453f2 AD |
143 | |
144 | probe.key = key; | |
145 | entry = hash_lookup (muscle_table, &probe); | |
146 | ||
147 | if (!entry) | |
148 | { | |
149 | /* First insertion in the hash. */ | |
da2a7671 | 150 | entry = xmalloc (sizeof *entry); |
ae7453f2 | 151 | entry->key = key; |
75c7a52a AD |
152 | if (!hash_insert (muscle_table, entry)) |
153 | xalloc_die (); | |
eb095650 | 154 | entry->value = entry->storage = xstrdup (val); |
ae7453f2 AD |
155 | } |
156 | else | |
157 | { | |
158 | /* Grow the current value. */ | |
159 | char *new_val; | |
ae7453f2 | 160 | obstack_sgrow (&muscle_obstack, entry->value); |
eb095650 | 161 | free (entry->storage); |
ae7453f2 AD |
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); | |
eb095650 | 166 | entry->value = entry->storage = xstrdup (new_val); |
ae7453f2 AD |
167 | obstack_free (&muscle_obstack, new_val); |
168 | } | |
169 | } | |
170 | ||
cd3684cf | 171 | /*------------------------------------------------------------------. |
35b8730d JD |
172 | | Using muscle_grow, append a synchronization line for the location | |
173 | | LOC to the current value of KEY. | | |
cd3684cf AD |
174 | `------------------------------------------------------------------*/ |
175 | ||
35b8730d JD |
176 | static void |
177 | muscle_syncline_grow (char const *key, location loc) | |
cd3684cf AD |
178 | { |
179 | char *extension = NULL; | |
05ac60f3 | 180 | obstack_fgrow1 (&muscle_obstack, "]b4_syncline(%d, [[", loc.start.line); |
cd3684cf AD |
181 | MUSCLE_OBSTACK_SGROW (&muscle_obstack, |
182 | quotearg_style (c_quoting_style, loc.start.file)); | |
35b8730d | 183 | obstack_sgrow (&muscle_obstack, "]])["); |
cd3684cf AD |
184 | obstack_1grow (&muscle_obstack, 0); |
185 | extension = obstack_finish (&muscle_obstack); | |
186 | muscle_grow (key, extension, ""); | |
eb095650 | 187 | obstack_free (&muscle_obstack, extension); |
cd3684cf AD |
188 | } |
189 | ||
35b8730d JD |
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 | ||
cd3684cf | 203 | |
ae7453f2 AD |
204 | void muscle_pair_list_grow (const char *muscle, |
205 | const char *a1, const char *a2) | |
206 | { | |
66d30cd4 | 207 | char *pair; |
7ecec4dd JD |
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, "]]]"); | |
ae7453f2 | 213 | obstack_1grow (&muscle_obstack, 0); |
66d30cd4 AD |
214 | pair = obstack_finish (&muscle_obstack); |
215 | muscle_grow (muscle, pair, ",\n"); | |
216 | obstack_free (&muscle_obstack, pair); | |
ae7453f2 AD |
217 | } |
218 | ||
7eb8a0bc JD |
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 | ||
4502eadc JD |
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 | `----------------------------------------------------------------------------*/ | |
ae7453f2 | 244 | |
ff5150d9 | 245 | char * |
7eb8a0bc | 246 | muscle_find (char const *key) |
f753cd62 | 247 | { |
8322e8f5 PE |
248 | muscle_entry probe; |
249 | muscle_entry *result = NULL; | |
e9bca3ad | 250 | |
ae7453f2 AD |
251 | probe.key = key; |
252 | result = hash_lookup (muscle_table, &probe); | |
4502eadc JD |
253 | if (result) |
254 | { | |
255 | aver (result->value == result->storage); | |
256 | return result->storage; | |
257 | } | |
258 | return NULL; | |
f753cd62 | 259 | } |
be2a1a68 AD |
260 | |
261 | ||
9611cfa2 JD |
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 | ||
f124d423 JD |
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 | ||
9611cfa2 JD |
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 | { | |
f124d423 | 345 | MUSCLE_COMMON_DECODE (value) |
9611cfa2 JD |
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; | |
9611cfa2 JD |
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 | ||
9611cfa2 JD |
391 | void |
392 | muscle_percent_define_insert (char const *variable, location variable_loc, | |
34d41938 JD |
393 | char const *value, |
394 | muscle_percent_define_how how) | |
9611cfa2 | 395 | { |
812775a0 | 396 | char *variable_tr = NULL; |
9611cfa2 JD |
397 | char const *name; |
398 | char const *loc_name; | |
35b8730d | 399 | char const *syncline_name; |
34d41938 | 400 | char const *how_name; |
9611cfa2 | 401 | |
812775a0 JD |
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 | ||
0ab402b4 JD |
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, ")"); | |
9611cfa2 | 416 | |
34d41938 JD |
417 | /* Command-line options are processed before the grammar file. */ |
418 | if (how == MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE | |
419 | && muscle_find_const (name)) | |
9611cfa2 | 420 | { |
34d41938 JD |
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 | } | |
4c787a31 AD |
428 | complain_at (variable_loc, _("%%define variable %s redefined"), |
429 | quote (variable)); | |
e3a33f7c | 430 | complain_at (muscle_percent_define_get_loc (variable), |
34d41938 | 431 | _("previous definition")); |
9611cfa2 | 432 | } |
9611cfa2 | 433 | |
34d41938 | 434 | MUSCLE_INSERT_STRING (name, value); |
9611cfa2 JD |
435 | muscle_insert (loc_name, ""); |
436 | muscle_location_grow (loc_name, variable_loc); | |
35b8730d JD |
437 | muscle_insert (syncline_name, ""); |
438 | muscle_syncline_grow (syncline_name, variable_loc); | |
9611cfa2 JD |
439 | muscle_user_name_list_grow ("percent_define_user_variables", variable, |
440 | variable_loc); | |
34d41938 | 441 | MUSCLE_INSERT_INT (how_name, how); |
812775a0 JD |
442 | |
443 | free (variable_tr); | |
9611cfa2 JD |
444 | } |
445 | ||
f124d423 JD |
446 | char * |
447 | muscle_percent_define_get (char const *variable) | |
448 | { | |
449 | char const *name; | |
450 | char const *usage_name; | |
451 | char *value; | |
452 | ||
0ab402b4 JD |
453 | name = UNIQSTR_CONCAT ("percent_define(", variable, ")"); |
454 | usage_name = UNIQSTR_CONCAT ("percent_define_bison_variables(", | |
455 | variable, ")"); | |
f124d423 JD |
456 | |
457 | muscle_insert (usage_name, ""); | |
458 | value = muscle_string_decode (name); | |
459 | if (!value) | |
460 | value = xstrdup (""); | |
461 | return value; | |
462 | } | |
463 | ||
35b8730d JD |
464 | location |
465 | muscle_percent_define_get_loc (char const *variable) | |
466 | { | |
467 | char const *loc_name; | |
0ab402b4 | 468 | loc_name = UNIQSTR_CONCAT ("percent_define_loc(", variable, ")"); |
35b8730d | 469 | if (!muscle_find_const (loc_name)) |
4c787a31 AD |
470 | fatal(_("%s: undefined %%define variable %s"), |
471 | "muscle_percent_define_get_loc", quote (variable)); | |
35b8730d JD |
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; | |
0ab402b4 JD |
480 | syncline_name = |
481 | UNIQSTR_CONCAT ("percent_define_syncline(", variable, ")"); | |
35b8730d JD |
482 | syncline = muscle_find_const (syncline_name); |
483 | if (!syncline) | |
4c787a31 AD |
484 | fatal(_("%s: undefined %%define variable %s"), |
485 | "muscle_percent_define_get_syncline", quote (variable)); | |
35b8730d JD |
486 | return syncline; |
487 | } | |
488 | ||
f124d423 JD |
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 | ||
0ab402b4 JD |
496 | name = UNIQSTR_CONCAT ("percent_define(", variable, ")"); |
497 | usage_name = | |
498 | UNIQSTR_CONCAT ("percent_define_bison_variables(", variable, ")"); | |
f124d423 JD |
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 | ||
9611cfa2 JD |
510 | bool |
511 | muscle_percent_define_flag_if (char const *variable) | |
512 | { | |
cbd50549 | 513 | char const *invalid_boolean_name; |
9611cfa2 JD |
514 | bool result = false; |
515 | ||
0ab402b4 JD |
516 | invalid_boolean_name = |
517 | UNIQSTR_CONCAT ("percent_define_invalid_boolean(", variable, ")"); | |
9611cfa2 | 518 | |
f124d423 | 519 | if (muscle_percent_define_ifdef (variable)) |
9611cfa2 | 520 | { |
f124d423 | 521 | char *value = muscle_percent_define_get (variable); |
9611cfa2 JD |
522 | if (value[0] == '\0' || 0 == strcmp (value, "true")) |
523 | result = true; | |
524 | else if (0 == strcmp (value, "false")) | |
525 | result = false; | |
cbd50549 JD |
526 | else if (!muscle_find_const (invalid_boolean_name)) |
527 | { | |
528 | muscle_insert (invalid_boolean_name, ""); | |
35b8730d | 529 | complain_at(muscle_percent_define_get_loc (variable), |
4c787a31 AD |
530 | _("invalid value for %%define Boolean variable %s"), |
531 | quote (variable)); | |
cbd50549 | 532 | } |
f124d423 | 533 | free (value); |
9611cfa2 JD |
534 | } |
535 | else | |
4c787a31 AD |
536 | fatal(_("%s: undefined %%define variable %s"), |
537 | "muscle_percent_define_flag", quote (variable)); | |
9611cfa2 | 538 | |
9611cfa2 JD |
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; | |
35b8730d | 547 | char const *syncline_name; |
0ab402b4 JD |
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, ")"); | |
9611cfa2 JD |
552 | if (!muscle_find_const (name)) |
553 | { | |
554 | location loc; | |
555 | MUSCLE_INSERT_STRING (name, value); | |
580c075d JD |
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; | |
9611cfa2 JD |
559 | muscle_insert (loc_name, ""); |
560 | muscle_location_grow (loc_name, loc); | |
35b8730d | 561 | muscle_insert (syncline_name, ""); |
9611cfa2 JD |
562 | } |
563 | } | |
564 | ||
f124d423 | 565 | void |
b1a81613 | 566 | muscle_percent_define_check_values (char const * const *values) |
f124d423 | 567 | { |
b1a81613 JD |
568 | for (; *values; ++values) |
569 | { | |
25029e16 | 570 | char const * const *variablep = values; |
b1a81613 | 571 | char const *name; |
b1a81613 JD |
572 | char *value; |
573 | ||
0ab402b4 | 574 | name = UNIQSTR_CONCAT ("percent_define(", *variablep, ")"); |
b1a81613 JD |
575 | |
576 | value = muscle_string_decode (name); | |
577 | if (value) | |
578 | { | |
b1a81613 JD |
579 | for (++values; *values; ++values) |
580 | { | |
581 | if (0 == strcmp (value, *values)) | |
25029e16 JD |
582 | break; |
583 | } | |
584 | if (!*values) | |
585 | { | |
586 | location loc = muscle_percent_define_get_loc (*variablep); | |
587 | complain_at(loc, | |
4c787a31 AD |
588 | _("invalid value for %%define variable %s: %s"), |
589 | quote (*variablep), quote_n (1, value)); | |
25029e16 | 590 | for (values = variablep + 1; *values; ++values) |
4c787a31 | 591 | complain_at (loc, _("accepted value: %s"), quote (*values)); |
25029e16 JD |
592 | } |
593 | else | |
594 | { | |
595 | while (*values) | |
596 | ++values; | |
b1a81613 | 597 | } |
b1a81613 JD |
598 | free (value); |
599 | } | |
600 | else | |
4c787a31 AD |
601 | fatal (_("%s: undefined %%define variable %s"), |
602 | "muscle_percent_define_check_values", quote (*variablep)); | |
b1a81613 | 603 | } |
f124d423 JD |
604 | } |
605 | ||
9611cfa2 JD |
606 | void |
607 | muscle_percent_code_grow (char const *qualifier, location qualifier_loc, | |
608 | char const *code, location code_loc) | |
609 | { | |
610 | char const *name; | |
0ab402b4 | 611 | name = UNIQSTR_CONCAT ("percent_code(", qualifier, ")"); |
9611cfa2 JD |
612 | muscle_code_grow (name, code, code_loc); |
613 | muscle_user_name_list_grow ("percent_code_user_qualifiers", qualifier, | |
614 | qualifier_loc); | |
615 | } | |
616 | ||
617 | ||
ae7453f2 AD |
618 | /*------------------------------------------------. |
619 | | Output the definition of ENTRY as a m4_define. | | |
620 | `------------------------------------------------*/ | |
be2a1a68 | 621 | |
e00b6826 | 622 | static inline bool |
8322e8f5 | 623 | muscle_m4_output (muscle_entry *entry, FILE *out) |
be2a1a68 AD |
624 | { |
625 | fprintf (out, "m4_define([b4_%s],\n", entry->key); | |
ae7453f2 | 626 | fprintf (out, "[[%s]])\n\n\n", entry->value); |
e00b6826 PE |
627 | return true; |
628 | } | |
629 | ||
630 | static bool | |
631 | muscle_m4_output_processor (void *entry, void *out) | |
632 | { | |
633 | return muscle_m4_output (entry, out); | |
be2a1a68 AD |
634 | } |
635 | ||
636 | ||
ae7453f2 AD |
637 | /*----------------------------------------------------------------. |
638 | | Output the definition of all the current muscles into a list of | | |
639 | | m4_defines. | | |
640 | `----------------------------------------------------------------*/ | |
be2a1a68 AD |
641 | |
642 | void | |
643 | muscles_m4_output (FILE *out) | |
644 | { | |
e00b6826 | 645 | hash_do_for_each (muscle_table, muscle_m4_output_processor, out); |
be2a1a68 | 646 | } |