1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
|
/* Muscle table manager for Bison,
Copyright (C) 2001-2003, 2006-2015, 2018-2021 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 <https://www.gnu.org/licenses/>. */
#ifndef MUSCLE_TAB_H_
# define MUSCLE_TAB_H_
# include <quotearg.h>
# include "location.h"
/* The kind of value associated to this muscle, depending on the
syntax of the value: keyword (no delimiter, e.g., true), string
(double quotes, e.g., "foo.h"), or code (braces, e.g., {int}). */
typedef enum
{
muscle_code,
muscle_keyword,
muscle_string
} muscle_kind;
/* Conversion from string. */
muscle_kind muscle_kind_new (char const *k);
/* Conversion to string. */
char const *muscle_kind_string (muscle_kind k);
/* Create the MUSCLE_TABLE, and initialize it with default values.
Also set up the MUSCLE_OBSTACK. */
void muscle_init (void);
/* Insert (KEY, VALUE). If KEY already existed, overwrite the
previous value. Otherwise create as a muscle_string type. */
void muscle_insert (char const *key, char const *value);
/* 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);
/* 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);
/* Free all the memory consumed by the muscle machinery only. */
void muscle_free (void);
/* An obstack dedicated to receive muscle keys and values. */
extern struct obstack muscle_obstack;
# define MUSCLE_INSERT_BOOL(Key, Value) \
do { \
int v__ = Value; \
MUSCLE_INSERT_INT (Key, v__); \
} while (0)
# define MUSCLE_INSERTF(Key, Format, Value) \
do { \
obstack_printf (&muscle_obstack, Format, Value); \
muscle_insert (Key, obstack_finish0 (&muscle_obstack)); \
} while (0)
# define MUSCLE_INSERT_INT(Key, Value) \
MUSCLE_INSERTF (Key, "%d", Value)
# define MUSCLE_INSERT_LONG_INT(Key, Value) \
MUSCLE_INSERTF (Key, "%ld", Value)
/* Key -> Value, but don't apply escaping to Value. */
# define MUSCLE_INSERT_STRING_RAW(Key, Value) \
MUSCLE_INSERTF (Key, "%s", Value)
/* Key -> Value, applying M4 escaping to Value. */
# define MUSCLE_INSERT_STRING(Key, Value) \
do { \
obstack_escape (&muscle_obstack, Value); \
muscle_insert (Key, obstack_finish0 (&muscle_obstack)); \
} while (0)
/* Key -> Value, applying C escaping to Value (and then M4). */
# define MUSCLE_INSERT_C_STRING(Key, Value) \
MUSCLE_INSERT_STRING (Key, quotearg_style (c_quoting_style, Value))
/* Append VALUE to the current value of KEY, using muscle_grow. But
in addition, issue a synchronization line for the location LOC.
Be sure to append on a new line. */
void muscle_code_grow (const char *key, const char *value, location loc);
/* MUSCLE is an M4 list of pairs. Create or extend it with the pair
(A1, A2) after escaping both values with digraphs. Note that because the
muscle values are output *double* quoted, one needs to strip the first level
of quotes to reach the list itself. */
void muscle_pair_list_grow (const char *muscle,
const char *a1, const char *a2);
/* Grow KEY for the occurrence of the name USER_NAME at LOC appropriately for
use with b4_check_user_names in ../data/bison.m4. USER_NAME is not escaped
with digraphs, so it must not contain '[' or ']'. */
void muscle_user_name_list_grow (char const *key, char const *user_name,
location loc);
/* In the format '[[file_name:line.column]], [[file_name:line.column]]',
append LOC to MUSCLE. Use digraphs for special characters in each
file name. */
void muscle_location_grow (char const *key, location loc);
/* Indicates whether a variable's value was specified with -D/--define, with
-F/--force-define, or in the grammar file. */
typedef enum {
MUSCLE_PERCENT_DEFINE_D = 0,
MUSCLE_PERCENT_DEFINE_F,
MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE
} muscle_percent_define_how;
/* Define the muscles for %define variable VARIABLE with VALUE specified
at VARIABLE_LOC in the manner HOW unless it was specified in the
grammar file while the previous definition for VARIABLE was specified
with -F/--force-define. Complain if a previous definition is being
overridden and the new definition is specified in the grammar file.
(These rules support the documented behavior as long as command-line
definitions are processed before grammar file definitions.) Record
this as a user occurrence of VARIABLE by invoking
muscle_user_name_list_grow. */
void muscle_percent_define_insert (char const *variable, location variable_loc,
muscle_kind kind,
char const *value,
muscle_percent_define_how how);
/* Make sure that VARIABLE is set to the boolean VALUE. Warn on mismatches
only, but accept repeated declaration. Used for backward compatibility
between old directives such as %pure-parser, and the recommended use of
variables (%define api.pure). */
void muscle_percent_define_ensure (char const *variable, location variable_loc,
bool value);
/* Mimic b4_percent_define_get in ../data/bison.m4 exactly. That is, if the
%define variable VARIABLE is defined, return its value. Otherwise, return
the empty string. Also, record Bison's usage of VARIABLE by defining
b4_percent_define_bison_variables(VARIABLE). The caller is responsible for
freeing the memory of the returned string. */
char *muscle_percent_define_get (char const *variable);
/* Mimic muscle_percent_define_get_loc in ../data/bison.m4 exactly. That is,
if the %define variable VARIABLE is undefined, complain fatally since that's
a Bison error. Otherwise, return its definition location in a form
appropriate for the first argument of warn_at, complain_at, or fatal_at.
Don't record this as a Bison usage of VARIABLE as there's no reason to
suspect that the user-supplied value has yet influenced the output. */
location muscle_percent_define_get_loc (char const *variable);
/* Mimic muscle_percent_define_get_syncline in ../data/bison.m4 exactly. That
is, if the %define variable VARIABLE is undefined, complain fatally since
that's a Bison error. Otherwise, return its definition location as a
b4_syncline invocation. Don't record this as a Bison usage of VARIABLE as
there's no reason to suspect that the user-supplied value has yet influenced
the output. */
char const *muscle_percent_define_get_syncline (char const *variable);
/* Mimic b4_percent_define_ifdef in ../data/bison.m4 exactly. That is, if the
%define variable VARIABLE is defined, return true. Otherwise, return false.
Also, record Bison's usage of VARIABLE by defining
b4_percent_define_bison_variables(VARIABLE). */
bool muscle_percent_define_ifdef (char const *variable);
/* Mimic b4_percent_define_flag_if in ../data/bison.m4 exactly. That is, if
the %define variable VARIABLE is defined to "" or "true", return true. If
it is defined to "false", return false. Complain if it is undefined (a
Bison error since the default value should have been set already) or defined
to any other value (possibly a user error). Also, record Bison's usage of
VARIABLE by defining b4_percent_define_bison_variables(VARIABLE). */
bool muscle_percent_define_flag_if (char const *variable);
/* Mimic b4_percent_define_default in ../data/bison.m4 exactly. That is, if
the %define variable VARIABLE is undefined, set its value to VALUE.
Don't record this as a Bison usage of VARIABLE as there's no reason to
suspect that the value has yet influenced the output. */
void muscle_percent_define_default (char const *variable, char const *value);
/* Mimic b4_percent_define_check_values in ../data/bison.m4 exactly except that
the VALUES structure is more appropriate for C. That is, VALUES points to a
list of strings that is partitioned into sublists by NULL's, one terminating
each sublist. The last sublist is followed by a second NULL. For each
sublist, the first string is the name of a %define variable, and all
remaining strings in that sublist are the valid values for that variable.
Complain if such a variable is undefined (a Bison error since the default
value should have been set already) or defined to any other value (possibly
a user error). Don't record this as a Bison usage of the variable as
there's no reason to suspect that the value has yet influenced the
output. */
void muscle_percent_define_check_values (char const * const *values);
/* Grow the muscle for the %code qualifier QUALIFIER appearing at
QUALIFIER_LOC with code CODE appearing at CODE_LOC. Record this as a
user occurrence of QUALIFIER by invoking
muscle_user_name_list_grow. */
void muscle_percent_code_grow (char const *qualifier, location qualifier_loc,
char const *code, location code_loc);
/* Output the definition of all the current muscles into a list of
m4_defines. */
void muscles_m4_output (FILE *out);
#endif /* not MUSCLE_TAB_H_ */
|
