1 m4_divert(-1) -*- Autoconf -*-
3 # C M4 Macros for Bison.
4 # Copyright (C) 2002, 2004, 2005, 2006 Free Software Foundation, Inc.
6 # This program is free software; you can redistribute it and/or modify
7 # it under the terms of the GNU General Public License as published by
8 # the Free Software Foundation; either version 2 of the License, or
9 # (at your option) any later version.
11 # This program is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 # GNU General Public License for more details.
16 # You should have received a copy of the GNU General Public License
17 # along with this program; if not, write to the Free Software
18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
22 ## ---------------- ##
24 ## ---------------- ##
26 # b4_copyright(TITLE, YEARS)
27 # --------------------------
28 m4_define([b4_copyright],
29 [/* A Bison parser, made by GNU Bison b4_version. */
33 m4_text_wrap([Copyright (C) $2 Free Software Foundation, Inc.], [ ])
35 This program is free software; you can redistribute it and/or modify
36 it under the terms of the GNU General Public License as published by
37 the Free Software Foundation; either version 2, or (at your option)
40 This program is distributed in the hope that it will be useful,
41 but WITHOUT ANY WARRANTY; without even the implied warranty of
42 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
43 GNU General Public License for more details.
45 You should have received a copy of the GNU General Public License
46 along with this program; if not, write to the Free Software
47 Foundation, Inc., 51 Franklin Street, Fifth Floor,
48 Boston, MA 02110-1301, USA. */
50 /* As a special exception, you may create a larger work that contains
51 part or all of the Bison parser skeleton and distribute that work
52 under terms of your choice, so long as that work isn't itself a
53 parser generator using the skeleton or a modified version thereof
54 as a parser skeleton. Alternatively, if you modify or redistribute
55 the parser skeleton itself, you may (at your option) remove this
56 special exception, which will cause the skeleton and the resulting
57 Bison output files to be licensed under the GNU General Public
58 License without this special exception.
60 This special exception was added by the Free Software Foundation in
61 version 2.2 of Bison. */])
66 m4_define([b4_identification],
67 [/* Identify Bison output. */
71 [#]define YYBISON_VERSION "b4_version"
74 [#]define YYSKELETON_NAME b4_skeleton
77 [#]define YYPURE b4_pure
79 /* Using locations. */
80 [#]define YYLSP_NEEDED b4_locations_flag
85 ## ---------------- ##
87 ## ---------------- ##
89 m4_define_default([b4_epilogue], [])
93 ## ------------------------ ##
94 ## Pure/impure interfaces. ##
95 ## ------------------------ ##
100 m4_define([b4_user_args],
101 [m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])])
106 # If defined, b4_parse_param arrives double quoted, but below we prefer
107 # it to be single quoted.
108 m4_define_default([b4_parse_param])
109 m4_define([b4_parse_param],
113 # b4_parse_param_for(DECL, FORMAL, BODY)
114 # ---------------------------------------
115 # Iterate over the user parameters, binding the declaration to DECL,
116 # the formal name to FORMAL, and evaluating the BODY.
117 m4_define([b4_parse_param_for],
118 [m4_foreach([$1_$2], m4_defn([b4_parse_param]),
119 [m4_pushdef([$1], m4_fst($1_$2))dnl
120 m4_pushdef([$2], m4_shift($1_$2))dnl
128 # `YYUSE' all the parse-params.
129 m4_define([b4_parse_param_use],
130 [b4_parse_param_for([Decl], [Formal], [ YYUSE (Formal);
139 # b4_ints_in(INT1, INT2, LOW, HIGH)
140 # ---------------------------------
141 # Return 1 iff both INT1 and INT2 are in [LOW, HIGH], 0 otherwise.
142 m4_define([b4_ints_in],
143 [m4_eval([$3 <= $1 && $1 <= $4 && $3 <= $2 && $2 <= $4])])
146 # b4_int_type(MIN, MAX)
147 # ---------------------
148 # Return the smallest int type able to handle numbers ranging from
149 # MIN to MAX (included).
150 m4_define([b4_int_type],
151 [m4_if(b4_ints_in($@, [0], [255]), [1], [unsigned char],
152 b4_ints_in($@, [-128], [127]), [1], [signed char],
154 b4_ints_in($@, [0], [65535]), [1], [unsigned short int],
155 b4_ints_in($@, [-32768], [32767]), [1], [short int],
157 m4_eval([0 <= $1]), [1], [unsigned int],
162 # b4_int_type_for(NAME)
163 # ---------------------
164 # Return the smallest int type able to handle numbers ranging from
165 # `NAME_min' to `NAME_max' (included).
166 m4_define([b4_int_type_for],
167 [b4_int_type($1_min, $1_max)])
170 ## ------------------ ##
171 ## Decoding options. ##
172 ## ------------------ ##
175 # b4_error_verbose_if(IF-TRUE, IF-FALSE)
176 # --------------------------------------
177 # Expand IF-TRUE, if errors are verbose, IF-FALSE otherwise.
178 m4_define([b4_error_verbose_if],
179 [m4_if(b4_error_verbose, [1],
184 # b4_location_if(IF-TRUE, IF-FALSE)
185 # ---------------------------------
186 # Expand IF-TRUE, if locations are used, IF-FALSE otherwise.
187 m4_define([b4_location_if],
188 [m4_if(b4_locations_flag, [1],
193 # b4_pure_if(IF-TRUE, IF-FALSE)
194 # -----------------------------
195 # Expand IF-TRUE, if %pure-parser, IF-FALSE otherwise.
196 m4_define([b4_pure_if],
203 ## ------------------------- ##
204 ## Assigning token numbers. ##
205 ## ------------------------- ##
207 # b4_token_define(TOKEN-NAME, TOKEN-NUMBER)
208 # -----------------------------------------
209 # Output the definition of this token as #define.
210 m4_define([b4_token_define],
215 # b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
216 # -------------------------------------------------------
217 # Output the definition of the tokens (if there are) as #defines.
218 m4_define([b4_token_defines],
219 [m4_if([$@], [[]], [],
221 m4_map([b4_token_define], [$@])])
225 # b4_token_enum(TOKEN-NAME, TOKEN-NUMBER)
226 # ---------------------------------------
227 # Output the definition of this token as an enum.
228 m4_define([b4_token_enum],
232 # b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
233 # -----------------------------------------------------
234 # Output the definition of the tokens (if there are) as enums.
235 m4_define([b4_token_enums],
236 [m4_if([$@], [[]], [],
240 /* Put the tokens into the symbol table, so that GDB and other debuggers
243 m4_map_sep([ b4_token_enum], [,
251 # b4_token_enums_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
252 # -------------------------------------------------------------
253 # Output the definition of the tokens (if there are) as enums and #defines.
254 m4_define([b4_token_enums_defines],
255 [b4_token_enums($@)b4_token_defines($@)
260 ## --------------------------------------------- ##
261 ## Defining C functions in both K&R and ANSI-C. ##
262 ## --------------------------------------------- ##
267 # A predicate useful in #if to determine whether C is ancient or modern.
269 # If __STDC__ is defined, the compiler is modern. IBM xlc 7.0 when run
270 # as 'cc' doesn't define __STDC__ (or __STDC_VERSION__) for pedantic
271 # reasons, but it defines __C99__FUNC__ so check that as well.
272 # Microsoft C normally doesn't define these macros, but it defines _MSC_VER.
273 # Consider a C++ compiler to be modern if it defines __cplusplus.
275 m4_define([b4_c_modern],
276 [[(defined __STDC__ || defined __C99__FUNC__ \
277 || defined __cplusplus || defined _MSC_VER)]])
279 # b4_c_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
280 # ----------------------------------------------------------
281 # Declare the function NAME.
282 m4_define([b4_c_function_def],
284 b4_c_ansi_function_def($@)
287 $1 (b4_c_knr_formal_names(m4_shiftn(2, $@)))
288 b4_c_knr_formal_decls(m4_shiftn(2, $@))
293 # b4_c_ansi_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
294 # ---------------------------------------------------------------
295 # Declare the function NAME in ANSI.
296 m4_define([b4_c_ansi_function_def],
298 $1 (b4_c_ansi_formals(m4_shiftn(2, $@)))[]dnl
302 # b4_c_ansi_formals([DECL1, NAME1], ...)
303 # --------------------------------------
304 # Output the arguments ANSI-C definition.
305 m4_define([b4_c_ansi_formals],
309 [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])])
311 m4_define([b4_c_ansi_formal],
315 # b4_c_knr_formal_names([DECL1, NAME1], ...)
316 # ------------------------------------------
317 # Output the argument names.
318 m4_define([b4_c_knr_formal_names],
319 [m4_map_sep([b4_c_knr_formal_name], [, ], [$@])])
321 m4_define([b4_c_knr_formal_name],
325 # b4_c_knr_formal_decls([DECL1, NAME1], ...)
326 # ------------------------------------------
327 # Output the K&R argument declarations.
328 m4_define([b4_c_knr_formal_decls],
329 [m4_map_sep([b4_c_knr_formal_decl],
334 m4_define([b4_c_knr_formal_decl],
339 ## ------------------------------------------------------------ ##
340 ## Declaring (prototyping) C functions in both K&R and ANSI-C. ##
341 ## ------------------------------------------------------------ ##
344 # b4_c_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
345 # -----------------------------------------------------------
346 # Declare the function NAME.
347 m4_define([b4_c_function_decl],
348 [#if defined __STDC__ || defined __cplusplus
349 b4_c_ansi_function_decl($@)
356 # b4_c_ansi_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
357 # ----------------------------------------------------------------
358 # Declare the function NAME.
359 m4_define([b4_c_ansi_function_decl],
360 [$2 $1 (b4_c_ansi_formals(m4_shiftn(2, $@)));[]dnl
366 ## --------------------- ##
367 ## Calling C functions. ##
368 ## --------------------- ##
371 # b4_c_function_call(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
372 # -----------------------------------------------------------
373 # Call the function NAME with arguments NAME1, NAME2 etc.
374 m4_define([b4_c_function_call],
375 [$1 (b4_c_args(m4_shiftn(2, $@)))[]dnl
379 # b4_c_args([DECL1, NAME1], ...)
380 # ------------------------------
381 # Output the arguments NAME1, NAME2...
382 m4_define([b4_c_args],
383 [m4_map_sep([b4_c_arg], [, ], [$@])])
385 m4_define([b4_c_arg],
393 # b4_syncline(LINE, FILE)
394 # -----------------------
395 m4_define([b4_syncline],
396 [m4_if(b4_synclines_flag, 1,
405 # b4_symbol_actions(FILENAME, LINENO,
406 # SYMBOL-TAG, SYMBOL-NUM,
407 # SYMBOL-ACTION, SYMBOL-TYPENAME)
408 # -------------------------------------------------
409 m4_define([b4_symbol_actions],
410 [m4_pushdef([b4_dollar_dollar],
411 [m4_ifval([$6], [(yyvaluep->$6)], [(*yyvaluep)])])dnl
412 m4_pushdef([b4_at_dollar], [(*yylocationp)])dnl
414 b4_syncline([$2], [$1])
416 b4_syncline([@oline@], [@ofile@])
418 m4_popdef([b4_at_dollar])dnl
419 m4_popdef([b4_dollar_dollar])dnl
423 # b4_yydestruct_generate(FUNCTION-DECLARATOR)
424 # -------------------------------------------
425 # Generate the "yydestruct" function, which declaration is issued using
426 # FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C
427 # or "b4_c_function_def" for K&R.
428 m4_define_default([b4_yydestruct_generate],
429 [[/*-----------------------------------------------.
430 | Release the memory associated to this symbol. |
431 `-----------------------------------------------*/
436 [[const char *yymsg], [yymsg]],
437 [[int yytype], [yytype]],
438 [[YYSTYPE *yyvaluep], [yyvaluep]][]dnl
439 b4_location_if( [, [[YYLTYPE *yylocationp], [yylocationp]]])[]dnl
440 m4_ifset([b4_parse_param], [, b4_parse_param]))[
443 ]b4_location_if([ YYUSE (yylocationp);
445 b4_parse_param_use[]dnl
449 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
453 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
461 # b4_yy_symbol_print_generate(FUNCTION-DECLARATOR)
462 # ------------------------------------------------
463 # Generate the "yy_symbol_print" function, which declaration is issued using
464 # FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C
465 # or "b4_c_function_def" for K&R.
466 m4_define_default([b4_yy_symbol_print_generate],
468 /*--------------------------------.
469 | Print this symbol on YYOUTPUT. |
470 `--------------------------------*/
473 ]$1([yy_symbol_value_print],
475 [[FILE *yyoutput], [yyoutput]],
476 [[int yytype], [yytype]],
477 [[const YYSTYPE * const yyvaluep], [yyvaluep]][]dnl
478 b4_location_if([, [[const YYLTYPE * const yylocationp], [yylocationp]]])[]dnl
479 m4_ifset([b4_parse_param], [, b4_parse_param]))[
483 ]b4_location_if([ YYUSE (yylocationp);
485 b4_parse_param_use[]dnl
487 if (yytype < YYNTOKENS)
488 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
494 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
501 /*--------------------------------.
502 | Print this symbol on YYOUTPUT. |
503 `--------------------------------*/
505 ]$1([yy_symbol_print],
507 [[FILE *yyoutput], [yyoutput]],
508 [[int yytype], [yytype]],
509 [[const YYSTYPE * const yyvaluep], [yyvaluep]][]dnl
510 b4_location_if([, [[const YYLTYPE * const yylocationp], [yylocationp]]])[]dnl
511 m4_ifset([b4_parse_param], [, b4_parse_param]))[
513 if (yytype < YYNTOKENS)
514 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
516 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
518 ]b4_location_if([ YY_LOCATION_PRINT (yyoutput, *yylocationp);
519 YYFPRINTF (yyoutput, ": ");
521 [ yy_symbol_value_print (yyoutput, yytype, yyvaluep]dnl
522 b4_location_if([, yylocationp])[]b4_user_args[);
523 YYFPRINTF (yyoutput, ")");