1 | -*- Autoconf -*-
|
---|
2 |
|
---|
3 | # Language-independent M4 Macros for Bison.
|
---|
4 | # Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008 Free Software Foundation,
|
---|
5 | # Inc.
|
---|
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 |
|
---|
21 | ## ---------------- ##
|
---|
22 | ## Identification. ##
|
---|
23 | ## ---------------- ##
|
---|
24 |
|
---|
25 | # b4_copyright(TITLE, YEARS)
|
---|
26 | # --------------------------
|
---|
27 | m4_define([b4_copyright],
|
---|
28 | [b4_comment([A Bison parser, made by GNU Bison b4_version.])
|
---|
29 |
|
---|
30 | b4_comment([$1
|
---|
31 |
|
---|
32 | m4_text_wrap([Copyright (C) $2 Free Software Foundation, Inc.], [ ])
|
---|
33 |
|
---|
34 | This program is free software: you can redistribute it and/or modify
|
---|
35 | it under the terms of the GNU General Public License as published by
|
---|
36 | the Free Software Foundation, either version 3 of the License, or
|
---|
37 | (at your option) any later version.
|
---|
38 |
|
---|
39 | This program is distributed in the hope that it will be useful,
|
---|
40 | but WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
41 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
---|
42 | GNU General Public License for more details.
|
---|
43 |
|
---|
44 | You should have received a copy of the GNU General Public License
|
---|
45 | along with this program. If not, see <http://www.gnu.org/licenses/>.])
|
---|
46 |
|
---|
47 | b4_comment([As a special exception, you may create a larger work that contains
|
---|
48 | part or all of the Bison parser skeleton and distribute that work
|
---|
49 | under terms of your choice, so long as that work isn't itself a
|
---|
50 | parser generator using the skeleton or a modified version thereof
|
---|
51 | as a parser skeleton. Alternatively, if you modify or redistribute
|
---|
52 | the parser skeleton itself, you may (at your option) remove this
|
---|
53 | special exception, which will cause the skeleton and the resulting
|
---|
54 | Bison output files to be licensed under the GNU General Public
|
---|
55 | License without this special exception.
|
---|
56 |
|
---|
57 | This special exception was added by the Free Software Foundation in
|
---|
58 | version 2.2 of Bison.])])
|
---|
59 |
|
---|
60 |
|
---|
61 | ## ---------------- ##
|
---|
62 | ## Error handling. ##
|
---|
63 | ## ---------------- ##
|
---|
64 |
|
---|
65 | # The following error handling macros print error directives that should not
|
---|
66 | # become arguments of other macro invocations since they would likely then be
|
---|
67 | # mangled. Thus, they print to stdout directly.
|
---|
68 |
|
---|
69 | # b4_cat(TEXT)
|
---|
70 | # ------------
|
---|
71 | # Write TEXT to stdout. Precede the final newline with an @ so that it's
|
---|
72 | # escaped. For example:
|
---|
73 | #
|
---|
74 | # b4_cat([[@complain(invalid input@)]])
|
---|
75 | m4_define([b4_cat],
|
---|
76 | [m4_syscmd([cat <<'_m4eof'
|
---|
77 | ]m4_bpatsubst(m4_dquote($1), [_m4eof], [_m4@`eof])[@
|
---|
78 | _m4eof
|
---|
79 | ])dnl
|
---|
80 | m4_if(m4_sysval, [0], [], [m4_fatal([$0: cannot write to stdout])])])
|
---|
81 |
|
---|
82 | # b4_error(KIND, FORMAT, [ARG1], [ARG2], ...)
|
---|
83 | # -------------------------------------------
|
---|
84 | # Write @KIND(FORMAT@,ARG1@,ARG2@,...@) to stdout.
|
---|
85 | #
|
---|
86 | # For example:
|
---|
87 | #
|
---|
88 | # b4_error([[warn]], [[invalid value for `%s': %s]], [[foo]], [[3]])
|
---|
89 | m4_define([b4_error],
|
---|
90 | [b4_cat([[@]$1[(]$2[]]dnl
|
---|
91 | [m4_if([$#], [2], [],
|
---|
92 | [m4_foreach([b4_arg],
|
---|
93 | m4_dquote(m4_shift(m4_shift($@))),
|
---|
94 | [[@,]b4_arg])])[@)]])])
|
---|
95 |
|
---|
96 | # b4_error_at(KIND, START, END, FORMAT, [ARG1], [ARG2], ...)
|
---|
97 | # ----------------------------------------------------------
|
---|
98 | # Write @KIND_at(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout.
|
---|
99 | #
|
---|
100 | # For example:
|
---|
101 | #
|
---|
102 | # b4_error_at([[complain]], [[input.y:2.3]], [[input.y:5.4]],
|
---|
103 | # [[invalid %s]], [[foo]])
|
---|
104 | m4_define([b4_error_at],
|
---|
105 | [b4_cat([[@]$1[_at(]$2[@,]$3[@,]$4[]]dnl
|
---|
106 | [m4_if([$#], [4], [],
|
---|
107 | [m4_foreach([b4_arg],
|
---|
108 | m4_dquote(m4_shift(m4_shift(m4_shift(m4_shift($@))))),
|
---|
109 | [[@,]b4_arg])])[@)]])])
|
---|
110 |
|
---|
111 | # b4_warn(FORMAT, [ARG1], [ARG2], ...)
|
---|
112 | # ------------------------------------
|
---|
113 | # Write @warn(FORMAT@,ARG1@,ARG2@,...@) to stdout.
|
---|
114 | #
|
---|
115 | # For example:
|
---|
116 | #
|
---|
117 | # b4_warn([[invalid value for `%s': %s]], [[foo]], [[3]])
|
---|
118 | #
|
---|
119 | # As a simple test suite, this:
|
---|
120 | #
|
---|
121 | # m4_divert(-1)
|
---|
122 | # m4_define([asdf], [ASDF])
|
---|
123 | # m4_define([fsa], [FSA])
|
---|
124 | # m4_define([fdsa], [FDSA])
|
---|
125 | # b4_warn([[[asdf), asdf]]], [[[fsa), fsa]]], [[[fdsa), fdsa]]])
|
---|
126 | # b4_warn([[asdf), asdf]], [[fsa), fsa]], [[fdsa), fdsa]])
|
---|
127 | # b4_warn()
|
---|
128 | # b4_warn(1)
|
---|
129 | # b4_warn(1, 2)
|
---|
130 | #
|
---|
131 | # Should produce this without newlines:
|
---|
132 | #
|
---|
133 | # @warn([asdf), asdf]@,[fsa), fsa]@,[fdsa), fdsa]@)
|
---|
134 | # @warn(asdf), asdf@,fsa), fsa@,fdsa), fdsa@)
|
---|
135 | # @warn(@)
|
---|
136 | # @warn(1@)
|
---|
137 | # @warn(1@,2@)
|
---|
138 | m4_define([b4_warn],
|
---|
139 | [b4_error([[warn]], $@)])
|
---|
140 |
|
---|
141 | # b4_warn_at(START, END, FORMAT, [ARG1], [ARG2], ...)
|
---|
142 | # ---------------------------------------------------
|
---|
143 | # Write @warn(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout.
|
---|
144 | #
|
---|
145 | # For example:
|
---|
146 | #
|
---|
147 | # b4_warn_at([[input.y:2.3]], [[input.y:5.4]], [[invalid %s]], [[foo]])
|
---|
148 | m4_define([b4_warn_at],
|
---|
149 | [b4_error_at([[warn]], $@)])
|
---|
150 |
|
---|
151 | # b4_complain(FORMAT, [ARG1], [ARG2], ...)
|
---|
152 | # ----------------------------------------
|
---|
153 | # Write @complain(FORMAT@,ARG1@,ARG2@,...@) to stdout.
|
---|
154 | #
|
---|
155 | # See b4_warn example.
|
---|
156 | m4_define([b4_complain],
|
---|
157 | [b4_error([[complain]], $@)])
|
---|
158 |
|
---|
159 | # b4_complain_at(START, END, FORMAT, [ARG1], [ARG2], ...)
|
---|
160 | # -------------------------------------------------------
|
---|
161 | # Write @complain(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout.
|
---|
162 | #
|
---|
163 | # See b4_warn_at example.
|
---|
164 | m4_define([b4_complain_at],
|
---|
165 | [b4_error_at([[complain]], $@)])
|
---|
166 |
|
---|
167 | # b4_fatal(FORMAT, [ARG1], [ARG2], ...)
|
---|
168 | # -------------------------------------
|
---|
169 | # Write @fatal(FORMAT@,ARG1@,ARG2@,...@) to stdout and exit.
|
---|
170 | #
|
---|
171 | # See b4_warn example.
|
---|
172 | m4_define([b4_fatal],
|
---|
173 | [b4_error([[fatal]], $@)dnl
|
---|
174 | m4_exit(1)])
|
---|
175 |
|
---|
176 | # b4_fatal_at(START, END, FORMAT, [ARG1], [ARG2], ...)
|
---|
177 | # ----------------------------------------------------
|
---|
178 | # Write @fatal(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout and exit.
|
---|
179 | #
|
---|
180 | # See b4_warn_at example.
|
---|
181 | m4_define([b4_fatal_at],
|
---|
182 | [b4_error_at([[fatal]], $@)dnl
|
---|
183 | m4_exit(1)])
|
---|
184 |
|
---|
185 |
|
---|
186 | ## ---------------- ##
|
---|
187 | ## Default values. ##
|
---|
188 | ## ---------------- ##
|
---|
189 |
|
---|
190 | # m4_define_default([b4_lex_param], []) dnl breaks other skeletons
|
---|
191 | m4_define_default([b4_pre_prologue], [])
|
---|
192 | m4_define_default([b4_post_prologue], [])
|
---|
193 | m4_define_default([b4_epilogue], [])
|
---|
194 | m4_define_default([b4_parse_param], [])
|
---|
195 |
|
---|
196 | # The initial column and line.
|
---|
197 | m4_define_default([b4_location_initial_column], [1])
|
---|
198 | m4_define_default([b4_location_initial_line], [1])
|
---|
199 |
|
---|
200 |
|
---|
201 | ## ------------ ##
|
---|
202 | ## Data Types. ##
|
---|
203 | ## ------------ ##
|
---|
204 |
|
---|
205 | # b4_ints_in(INT1, INT2, LOW, HIGH)
|
---|
206 | # ---------------------------------
|
---|
207 | # Return 1 iff both INT1 and INT2 are in [LOW, HIGH], 0 otherwise.
|
---|
208 | m4_define([b4_ints_in],
|
---|
209 | [m4_eval([$3 <= $1 && $1 <= $4 && $3 <= $2 && $2 <= $4])])
|
---|
210 |
|
---|
211 |
|
---|
212 |
|
---|
213 | ## ------------------ ##
|
---|
214 | ## Decoding options. ##
|
---|
215 | ## ------------------ ##
|
---|
216 |
|
---|
217 | # b4_flag_if(FLAG, IF-TRUE, IF-FALSE)
|
---|
218 | # -----------------------------------
|
---|
219 | # Run IF-TRUE if b4_FLAG_flag is 1, IF-FALSE if FLAG is 0, otherwise fail.
|
---|
220 | m4_define([b4_flag_if],
|
---|
221 | [m4_case(b4_$1_flag,
|
---|
222 | [0], [$3],
|
---|
223 | [1], [$2],
|
---|
224 | [m4_fatal([invalid $1 value: ]$1)])])
|
---|
225 |
|
---|
226 |
|
---|
227 | # b4_define_flag_if(FLAG)
|
---|
228 | # -----------------------
|
---|
229 | # Define "b4_FLAG_if(IF-TRUE, IF-FALSE)" that depends on the
|
---|
230 | # value of the Boolean FLAG.
|
---|
231 | m4_define([b4_define_flag_if],
|
---|
232 | [_b4_define_flag_if($[1], $[2], [$1])])
|
---|
233 |
|
---|
234 | # _b4_define_flag_if($1, $2, FLAG)
|
---|
235 | # --------------------------------
|
---|
236 | # This macro works around the impossibility to define macros
|
---|
237 | # inside macros, because issuing `[$1]' is not possible in M4 :(.
|
---|
238 | # This sucks hard, GNU M4 should really provide M5 like $$1.
|
---|
239 | m4_define([_b4_define_flag_if],
|
---|
240 | [m4_if([$1$2], $[1]$[2], [],
|
---|
241 | [m4_fatal([$0: Invalid arguments: $@])])dnl
|
---|
242 | m4_define([b4_$3_if],
|
---|
243 | [b4_flag_if([$3], [$1], [$2])])])
|
---|
244 |
|
---|
245 |
|
---|
246 | # b4_FLAG_if(IF-TRUE, IF-FALSE)
|
---|
247 | # -----------------------------
|
---|
248 | # Expand IF-TRUE, if FLAG is true, IF-FALSE otherwise.
|
---|
249 | b4_define_flag_if([defines]) # Whether headers are requested.
|
---|
250 | b4_define_flag_if([error_verbose]) # Whether error are verbose.
|
---|
251 | b4_define_flag_if([glr]) # Whether a GLR parser is requested.
|
---|
252 | b4_define_flag_if([locations]) # Whether locations are tracked.
|
---|
253 | b4_define_flag_if([nondeterministic]) # Whether conflicts should be handled.
|
---|
254 | b4_define_flag_if([yacc]) # Whether POSIX Yacc is emulated.
|
---|
255 |
|
---|
256 |
|
---|
257 | ## ------------------------- ##
|
---|
258 | ## Assigning token numbers. ##
|
---|
259 | ## ------------------------- ##
|
---|
260 |
|
---|
261 |
|
---|
262 | ## ----------- ##
|
---|
263 | ## Synclines. ##
|
---|
264 | ## ----------- ##
|
---|
265 |
|
---|
266 | # b4_basename(NAME)
|
---|
267 | # -----------------
|
---|
268 | # Similar to POSIX basename; the differences don't matter here.
|
---|
269 | # Beware that NAME is not evaluated.
|
---|
270 | m4_define([b4_basename],
|
---|
271 | [m4_bpatsubst([$1], [^.*/\([^/]+\)/*$], [\1])])
|
---|
272 |
|
---|
273 |
|
---|
274 | # b4_syncline(LINE, FILE)
|
---|
275 | # -----------------------
|
---|
276 | m4_define([b4_syncline],
|
---|
277 | [b4_flag_if([synclines], [
|
---|
278 | b4_sync_end([__line__], [b4_basename(m4_quote(__file__))])
|
---|
279 | b4_sync_start([$1], [$2])])])
|
---|
280 |
|
---|
281 | m4_define([b4_sync_end], [b4_comment([Line $1 of $2])])
|
---|
282 | m4_define([b4_sync_start], [b4_comment([Line $1 of $2])])
|
---|
283 |
|
---|
284 | # b4_user_code(USER-CODE)
|
---|
285 | # -----------------------
|
---|
286 | # Emit code from the user, ending it with synclines.
|
---|
287 | m4_define([b4_user_code],
|
---|
288 | [$1
|
---|
289 | b4_syncline([@oline@], [@ofile@])])
|
---|
290 |
|
---|
291 |
|
---|
292 | # b4_define_user_code(MACRO)
|
---|
293 | # --------------------------
|
---|
294 | # From b4_MACRO, build b4_user_MACRO that includes the synclines.
|
---|
295 | m4_define([b4_define_user_code],
|
---|
296 | [m4_define([b4_user_$1],
|
---|
297 | [b4_user_code([b4_$1])])])
|
---|
298 |
|
---|
299 |
|
---|
300 | # b4_user_actions
|
---|
301 | # b4_user_initial_action
|
---|
302 | # b4_user_post_prologue
|
---|
303 | # b4_user_pre_prologue
|
---|
304 | # b4_user_stype
|
---|
305 | # ----------------------
|
---|
306 | # Macros that issue user code, ending with synclines.
|
---|
307 | b4_define_user_code([actions])
|
---|
308 | b4_define_user_code([initial_action])
|
---|
309 | b4_define_user_code([post_prologue])
|
---|
310 | b4_define_user_code([pre_prologue])
|
---|
311 | b4_define_user_code([stype])
|
---|
312 |
|
---|
313 |
|
---|
314 | # b4_check_user_names(WHAT, USER-LIST, BISON-NAMESPACE)
|
---|
315 | # --------------------------------------------------------
|
---|
316 | # Warn if any name of type WHAT is used by the user (as recorded in USER-LIST)
|
---|
317 | # but is not used by Bison (as recorded by macros in the namespace
|
---|
318 | # BISON-NAMESPACE).
|
---|
319 | #
|
---|
320 | # USER-LIST must expand to a list specifying all grammar occurrences of all
|
---|
321 | # names of type WHAT. Each item in the list must be a triplet specifying one
|
---|
322 | # occurrence: name, start boundary, and end boundary. Empty string names are
|
---|
323 | # fine. An empty list is fine.
|
---|
324 | #
|
---|
325 | # For example, to define b4_foo_user_names to be used for USER-LIST with three
|
---|
326 | # name occurrences and with correct quoting:
|
---|
327 | #
|
---|
328 | # m4_define([b4_foo_user_names],
|
---|
329 | # [[[[[[bar]], [[parser.y:1.7]], [[parser.y:1.16]]]],
|
---|
330 | # [[[[bar]], [[parser.y:5.7]], [[parser.y:5.16]]]],
|
---|
331 | # [[[[baz]], [[parser.y:8.7]], [[parser.y:8.16]]]]]])
|
---|
332 | #
|
---|
333 | # The macro BISON-NAMESPACE(bar) must be defined iff the name bar of type WHAT
|
---|
334 | # is used by Bison (in the front-end or in the skeleton). Empty string names
|
---|
335 | # are fine, but it would be ugly for Bison to actually use one.
|
---|
336 | #
|
---|
337 | # For example, to use b4_foo_bison_names for BISON-NAMESPACE and define that
|
---|
338 | # the names bar and baz are used by Bison:
|
---|
339 | #
|
---|
340 | # m4_define([b4_foo_bison_names(bar)])
|
---|
341 | # m4_define([b4_foo_bison_names(baz)])
|
---|
342 | #
|
---|
343 | # To invoke b4_check_user_names with TYPE foo, with USER-LIST
|
---|
344 | # b4_foo_user_names, with BISON-NAMESPACE b4_foo_bison_names, and with correct
|
---|
345 | # quoting:
|
---|
346 | #
|
---|
347 | # b4_check_user_names([[foo]], [b4_foo_user_names],
|
---|
348 | # [[b4_foo_bison_names]])
|
---|
349 | m4_define([b4_check_user_names],
|
---|
350 | [m4_foreach([b4_occurrence], $2,
|
---|
351 | [m4_pushdef([b4_occurrence], b4_occurrence)dnl
|
---|
352 | m4_pushdef([b4_user_name], m4_car(b4_occurrence))dnl
|
---|
353 | m4_pushdef([b4_start], m4_car(m4_shift(b4_occurrence)))dnl
|
---|
354 | m4_pushdef([b4_end], m4_shift(m4_shift(b4_occurrence)))dnl
|
---|
355 | m4_ifndef($3[(]m4_quote(b4_user_name)[)],
|
---|
356 | [b4_warn_at([b4_start], [b4_end],
|
---|
357 | [[%s `%s' is not used]],
|
---|
358 | [$1], [b4_user_name])])[]dnl
|
---|
359 | m4_popdef([b4_occurrence])dnl
|
---|
360 | m4_popdef([b4_user_name])dnl
|
---|
361 | m4_popdef([b4_start])dnl
|
---|
362 | m4_popdef([b4_end])dnl
|
---|
363 | ])])
|
---|
364 |
|
---|
365 | # b4_percent_define_get(VARIABLE)
|
---|
366 | # -------------------------------
|
---|
367 | # Mimic muscle_percent_define_get in ../src/muscle_tab.h exactly. That is, if
|
---|
368 | # the %define variable VARIABLE is defined, emit its value. Also, record
|
---|
369 | # Bison's usage of VARIABLE by defining
|
---|
370 | # b4_percent_define_bison_variables(VARIABLE).
|
---|
371 | #
|
---|
372 | # For example:
|
---|
373 | #
|
---|
374 | # b4_percent_define_get([[foo]])
|
---|
375 | m4_define([b4_percent_define_get],
|
---|
376 | [m4_define([b4_percent_define_bison_variables(]$1[)])dnl
|
---|
377 | m4_ifdef([b4_percent_define(]$1[)], [m4_indir([b4_percent_define(]$1[)])])])
|
---|
378 |
|
---|
379 | # b4_percent_define_get_loc(VARIABLE)
|
---|
380 | # -----------------------------------
|
---|
381 | # Mimic muscle_percent_define_get_loc in ../src/muscle_tab.h exactly. That is,
|
---|
382 | # if the %define variable VARIABLE is undefined, complain fatally since that's
|
---|
383 | # a Bison or skeleton error. Otherwise, return its definition location in a
|
---|
384 | # form approriate for the first two arguments of b4_warn_at, b4_complain_at, or
|
---|
385 | # b4_fatal_at. Don't record this as a Bison usage of VARIABLE as there's no
|
---|
386 | # reason to suspect that the user-supplied value has yet influenced the output.
|
---|
387 | #
|
---|
388 | # For example:
|
---|
389 | #
|
---|
390 | # b4_complain_at(b4_percent_define_get_loc([[foo]]), [[invalid foo]])
|
---|
391 | m4_define([b4_percent_define_get_loc],
|
---|
392 | [m4_ifdef([b4_percent_define_loc(]$1[)],
|
---|
393 | [m4_pushdef([b4_loc], m4_indir([b4_percent_define_loc(]$1[)]))dnl
|
---|
394 | b4_loc[]dnl
|
---|
395 | m4_popdef([b4_loc])],
|
---|
396 | [b4_fatal([[undefined %%define variable `%s' passed to b4_percent_define_get_loc]], [$1])])])
|
---|
397 |
|
---|
398 | # b4_percent_define_get_syncline(VARIABLE)
|
---|
399 | # ----------------------------------------
|
---|
400 | # Mimic muscle_percent_define_get_syncline in ../src/muscle_tab.h exactly.
|
---|
401 | # That is, if the %define variable VARIABLE is undefined, complain fatally
|
---|
402 | # since that's a Bison or skeleton error. Otherwise, return its definition
|
---|
403 | # location as a b4_syncline invocation. Don't record this as a Bison usage of
|
---|
404 | # VARIABLE as there's no reason to suspect that the user-supplied value has yet
|
---|
405 | # influenced the output.
|
---|
406 | #
|
---|
407 | # For example:
|
---|
408 | #
|
---|
409 | # b4_percent_define_get_syncline([[foo]])
|
---|
410 | m4_define([b4_percent_define_get_syncline],
|
---|
411 | [m4_ifdef([b4_percent_define_syncline(]$1[)],
|
---|
412 | [m4_indir([b4_percent_define_syncline(]$1[)])],
|
---|
413 | [b4_fatal([[undefined %%define variable `%s' passed to b4_percent_define_get_syncline]], [$1])])])
|
---|
414 |
|
---|
415 | # b4_percent_define_ifdef(VARIABLE, IF-TRUE, [IF-FALSE])
|
---|
416 | # ------------------------------------------------------
|
---|
417 | # Mimic muscle_percent_define_ifdef in ../src/muscle_tab.h exactly. That is,
|
---|
418 | # if the %define variable VARIABLE is defined, expand IF-TRUE, else expand
|
---|
419 | # IF-FALSE. Also, record Bison's usage of VARIABLE by defining
|
---|
420 | # b4_percent_define_bison_variables(VARIABLE).
|
---|
421 | #
|
---|
422 | # For example:
|
---|
423 | #
|
---|
424 | # b4_percent_define_ifdef([[foo]], [[it's defined]], [[it's undefined]])
|
---|
425 | m4_define([b4_percent_define_ifdef],
|
---|
426 | [m4_ifdef([b4_percent_define(]$1[)],
|
---|
427 | [m4_define([b4_percent_define_bison_variables(]$1[)])$2],
|
---|
428 | [$3])])
|
---|
429 |
|
---|
430 | # b4_percent_define_flag_if(VARIABLE, IF-TRUE, [IF-FALSE])
|
---|
431 | # --------------------------------------------------------
|
---|
432 | # Mimic muscle_percent_define_flag_if in ../src/muscle_tab.h exactly. That is,
|
---|
433 | # if the %define variable VARIABLE is defined to "" or "true", expand IF-TRUE.
|
---|
434 | # If it is defined to "false", expand IF-FALSE. Complain if it is undefined
|
---|
435 | # (a Bison or skeleton error since the default value should have been set
|
---|
436 | # already) or defined to any other value (possibly a user error). Also, record
|
---|
437 | # Bison's usage of VARIABLE by defining
|
---|
438 | # b4_percent_define_bison_variables(VARIABLE).
|
---|
439 | #
|
---|
440 | # For example:
|
---|
441 | #
|
---|
442 | # b4_percent_define_flag_if([[foo]], [[it's true]], [[it's false]])
|
---|
443 | m4_define([b4_percent_define_flag_if],
|
---|
444 | [b4_percent_define_ifdef([$1],
|
---|
445 | [m4_case(b4_percent_define_get([$1]),
|
---|
446 | [], [$2], [true], [$2], [false], [$3],
|
---|
447 | [m4_expand_once([b4_complain_at(b4_percent_define_get_loc([$1]),
|
---|
448 | [[invalid value for %%define Boolean variable `%s']],
|
---|
449 | [$1])],
|
---|
450 | [[b4_percent_define_flag_if($1)]])])],
|
---|
451 | [b4_fatal([[undefined %%define variable `%s' passed to b4_percent_define_flag_if]], [$1])])])
|
---|
452 |
|
---|
453 | # b4_percent_define_default(VARIABLE, DEFAULT)
|
---|
454 | # --------------------------------------------
|
---|
455 | # Mimic muscle_percent_define_default in ../src/muscle_tab.h exactly. That is,
|
---|
456 | # if the %define variable VARIABLE is undefined, set its value to DEFAULT.
|
---|
457 | # Don't record this as a Bison usage of VARIABLE as there's no reason to
|
---|
458 | # suspect that the value has yet influenced the output.
|
---|
459 | #
|
---|
460 | # For example:
|
---|
461 | #
|
---|
462 | # b4_percent_define_default([[foo]], [[default value]])
|
---|
463 | m4_define([b4_percent_define_default],
|
---|
464 | [m4_ifndef([b4_percent_define(]$1[)],
|
---|
465 | [m4_define([b4_percent_define(]$1[)], [$2])dnl
|
---|
466 | m4_define([b4_percent_define_loc(]$1[)],
|
---|
467 | [[[[[Bison:b4_percent_define_default]:1.0]], [[[Bison:b4_percent_define_default]:1.0]]]])dnl
|
---|
468 | m4_define([b4_percent_define_syncline(]$1[)],
|
---|
469 | [[]b4_syncline(1, [["[Bison:b4_percent_define_default]"]])[
|
---|
470 | ]])])])
|
---|
471 |
|
---|
472 | # b4_percent_define_check_values(VALUES)
|
---|
473 | # --------------------------------------
|
---|
474 | # Mimic muscle_percent_define_check_values in ../src/muscle_tab.h exactly
|
---|
475 | # except that the VALUES structure is more appropriate for M4. That is, VALUES
|
---|
476 | # is a list of sublists of strings. For each sublist, the first string is the
|
---|
477 | # name of a %define variable, and all remaining strings in that sublist are the
|
---|
478 | # valid values for that variable. Complain if such a variable is undefined (a
|
---|
479 | # Bison error since the default value should have been set already) or defined
|
---|
480 | # to any other value (possibly a user error). Don't record this as a Bison
|
---|
481 | # usage of the variable as there's no reason to suspect that the value has yet
|
---|
482 | # influenced the output.
|
---|
483 | #
|
---|
484 | # For example:
|
---|
485 | #
|
---|
486 | # b4_percent_define_check_values([[[[foo]], [[foo-value1]], [[foo-value2]]]],
|
---|
487 | # [[[[bar]], [[bar-value1]]]])
|
---|
488 | m4_define([b4_percent_define_check_values],
|
---|
489 | [m4_foreach([b4_sublist], m4_quote($@),
|
---|
490 | [_b4_percent_define_check_values(b4_sublist)])])
|
---|
491 |
|
---|
492 | m4_define([_b4_percent_define_check_values],
|
---|
493 | [m4_ifdef([b4_percent_define(]$1[)],
|
---|
494 | [m4_pushdef([b4_good_value], [0])dnl
|
---|
495 | m4_if($#, 1, [],
|
---|
496 | [m4_foreach([b4_value], m4_dquote(m4_shift($@)),
|
---|
497 | [m4_if(m4_indir([b4_percent_define(]$1[)]), b4_value,
|
---|
498 | [m4_define([b4_good_value], [1])])])])dnl
|
---|
499 | m4_if(b4_good_value, [0],
|
---|
500 | [b4_complain_at(b4_percent_define_get_loc([$1]),
|
---|
501 | [[invalid value for %%define variable `%s': `%s']],
|
---|
502 | [$1],
|
---|
503 | m4_dquote(m4_indir([b4_percent_define(]$1[)])))])dnl
|
---|
504 | m4_popdef([b4_good_value])],
|
---|
505 | [b4_fatal([[undefined %%define variable `%s' passed to b4_percent_define_check_values]], [$1])])])
|
---|
506 |
|
---|
507 | # b4_percent_code_get([QUALIFIER])
|
---|
508 | # --------------------------------
|
---|
509 | # If any %code blocks for QUALIFIER are defined, emit them beginning with a
|
---|
510 | # comment and ending with synclines and a newline. If QUALIFIER is not
|
---|
511 | # specified or empty, do this for the unqualified %code blocks. Also, record
|
---|
512 | # Bison's usage of QUALIFIER (if specified) by defining
|
---|
513 | # b4_percent_code_bison_qualifiers(QUALIFIER).
|
---|
514 | #
|
---|
515 | # For example, to emit any unqualified %code blocks followed by any %code
|
---|
516 | # blocks for the qualifier foo:
|
---|
517 | #
|
---|
518 | # b4_percent_code_get
|
---|
519 | # b4_percent_code_get([[foo]])
|
---|
520 | m4_define([b4_percent_code_get],
|
---|
521 | [m4_pushdef([b4_macro_name], [[b4_percent_code(]$1[)]])dnl
|
---|
522 | m4_ifval([$1], [m4_define([b4_percent_code_bison_qualifiers(]$1[)])])dnl
|
---|
523 | m4_ifdef(b4_macro_name,
|
---|
524 | [b4_comment([m4_if([$#], [0], [[Unqualified %code]],
|
---|
525 | [["%code ]$1["]])[ blocks.]])
|
---|
526 | b4_user_code([m4_indir(b4_macro_name)])
|
---|
527 | ])dnl
|
---|
528 | m4_popdef([b4_macro_name])])
|
---|
529 |
|
---|
530 | # b4_percent_code_ifdef(QUALIFIER, IF-TRUE, [IF-FALSE])
|
---|
531 | # -----------------------------------------------------
|
---|
532 | # If any %code blocks for QUALIFIER (or unqualified %code blocks if
|
---|
533 | # QUALIFIER is empty) are defined, expand IF-TRUE, else expand IF-FALSE.
|
---|
534 | # Also, record Bison's usage of QUALIFIER (if specified) by defining
|
---|
535 | # b4_percent_code_bison_qualifiers(QUALIFIER).
|
---|
536 | m4_define([b4_percent_code_ifdef],
|
---|
537 | [m4_ifdef([b4_percent_code(]$1[)],
|
---|
538 | [m4_ifval([$1], [m4_define([b4_percent_code_bison_qualifiers(]$1[)])])$2],
|
---|
539 | [$3])])
|
---|
540 |
|
---|
541 |
|
---|
542 | ## ----------------------------------------------------------- ##
|
---|
543 | ## After processing the skeletons, check that all the user's ##
|
---|
544 | ## %define variables and %code qualifiers were used by Bison. ##
|
---|
545 | ## ----------------------------------------------------------- ##
|
---|
546 |
|
---|
547 | m4_define([b4_check_user_names_wrap],
|
---|
548 | [m4_ifdef([b4_percent_]$1[_user_]$2[s],
|
---|
549 | [b4_check_user_names([[%]$1 $2],
|
---|
550 | [b4_percent_]$1[_user_]$2[s],
|
---|
551 | [[b4_percent_]$1[_bison_]$2[s]])])])
|
---|
552 |
|
---|
553 | m4_wrap_lifo([
|
---|
554 | b4_check_user_names_wrap([[define]], [[variable]])
|
---|
555 | b4_check_user_names_wrap([[code]], [[qualifier]])
|
---|
556 | ])
|
---|