]>
Commit | Line | Data |
---|---|---|
1 | -*- Autoconf -*- | |
2 | ||
3 | # C M4 Macros for Bison. | |
4 | ||
5 | # Copyright (C) 2002, 2004-2012 Free Software Foundation, 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 | # b4_tocpp(STRING) | |
22 | # ---------------- | |
23 | # Convert STRING into a valid C macro name. | |
24 | m4_define([b4_tocpp], | |
25 | [m4_toupper(m4_bpatsubst(m4_quote($1), [[^a-zA-Z0-9]+], [_]))]) | |
26 | ||
27 | ||
28 | # b4_cpp_guard(FILE) | |
29 | # ------------------ | |
30 | # A valid C macro name to use as a CPP header guard for FILE. | |
31 | m4_define([b4_cpp_guard], | |
32 | [b4_tocpp(m4_defn([b4_prefix])/[$1])]) | |
33 | ||
34 | ||
35 | # b4_cpp_guard_open(FILE) | |
36 | # b4_cpp_guard_close(FILE) | |
37 | # ------------------------ | |
38 | # Open/close CPP inclusion guards for FILE. | |
39 | m4_define([b4_cpp_guard_open], | |
40 | [#ifndef b4_cpp_guard([$1]) | |
41 | # define b4_cpp_guard([$1])]) | |
42 | ||
43 | m4_define([b4_cpp_guard_close], | |
44 | [#endif b4_comment([!b4_cpp_guard([$1])])]) | |
45 | ||
46 | ||
47 | ## ---------------- ## | |
48 | ## Identification. ## | |
49 | ## ---------------- ## | |
50 | ||
51 | # b4_comment_(TEXT, OPEN, CONTINUE, END) | |
52 | # ------------------------------------- | |
53 | # Put TEXT in comment. Avoid trailing spaces: don't indent empty lines. | |
54 | # Avoid adding indentation to the first line, as the indentation comes | |
55 | # from OPEN. That's why we don't patsubst([$1], [^\(.\)], [ \1]). | |
56 | # | |
57 | # Prefix all the output lines with PREFIX. | |
58 | m4_define([b4_comment_], [$2[]m4_bpatsubst([$1], [ | |
59 | \(.\)], [ | |
60 | $3\1])$4]) | |
61 | ||
62 | ||
63 | # b4_c_comment(TEXT, [PREFIX]) | |
64 | # ---------------------------- | |
65 | # Put TEXT in comment. Avoid trailing spaces: don't indent empty lines. | |
66 | # Avoid adding indentation to the first line, as the indentation comes | |
67 | # from "/*". That's why we don't patsubst([$1], [^\(.\)], [ \1]). | |
68 | # | |
69 | # Prefix all the output lines with PREFIX. | |
70 | m4_define([b4_c_comment], | |
71 | [b4_comment_([$1], [$2/* ], [$2 ], [$2 */])]) | |
72 | ||
73 | ||
74 | # b4_comment(TEXT, [PREFIX]) | |
75 | # -------------------------- | |
76 | # By default, C comments. | |
77 | m4_define([b4_comment], [b4_c_comment($@)]) | |
78 | ||
79 | ||
80 | # b4_identification | |
81 | # ----------------- | |
82 | # Depends on individual skeletons to define b4_pure_flag, b4_push_flag, or | |
83 | # b4_pull_flag if they use the values of the %define variables api.pure or | |
84 | # api.push-pull. | |
85 | m4_define([b4_identification], | |
86 | [[/* Identify Bison output. */ | |
87 | #define YYBISON 1 | |
88 | ||
89 | /* Bison version. */ | |
90 | #define YYBISON_VERSION "]b4_version[" | |
91 | ||
92 | /* Skeleton name. */ | |
93 | #define YYSKELETON_NAME ]b4_skeleton[]m4_ifdef([b4_pure_flag], [[ | |
94 | ||
95 | /* Pure parsers. */ | |
96 | #define YYPURE ]b4_pure_flag])[]m4_ifdef([b4_push_flag], [[ | |
97 | ||
98 | /* Push parsers. */ | |
99 | #define YYPUSH ]b4_push_flag])[]m4_ifdef([b4_pull_flag], [[ | |
100 | ||
101 | /* Pull parsers. */ | |
102 | #define YYPULL ]b4_pull_flag])[ | |
103 | ]]) | |
104 | ||
105 | ||
106 | ## ---------------- ## | |
107 | ## Default values. ## | |
108 | ## ---------------- ## | |
109 | ||
110 | # b4_api_prefix, b4_api_PREFIX | |
111 | # ---------------------------- | |
112 | # Corresponds to %define api.prefix | |
113 | b4_percent_define_default([[api.prefix]], [[yy]]) | |
114 | m4_define([b4_api_prefix], | |
115 | [b4_percent_define_get([[api.prefix]])]) | |
116 | m4_define([b4_api_PREFIX], | |
117 | [m4_toupper(b4_api_prefix)]) | |
118 | ||
119 | ||
120 | # b4_prefix | |
121 | # --------- | |
122 | # If the %name-prefix is not given, it is api.prefix. | |
123 | m4_define_default([b4_prefix], [b4_api_prefix]) | |
124 | ||
125 | # If the %union is not named, its name is YYSTYPE. | |
126 | m4_define_default([b4_union_name], [b4_api_PREFIX[]STYPE]) | |
127 | ||
128 | ||
129 | ## ------------------------ ## | |
130 | ## Pure/impure interfaces. ## | |
131 | ## ------------------------ ## | |
132 | ||
133 | # b4_user_args | |
134 | # ------------ | |
135 | m4_define([b4_user_args], | |
136 | [m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])]) | |
137 | ||
138 | ||
139 | # b4_parse_param | |
140 | # -------------- | |
141 | # If defined, b4_parse_param arrives double quoted, but below we prefer | |
142 | # it to be single quoted. | |
143 | m4_define([b4_parse_param], | |
144 | b4_parse_param) | |
145 | ||
146 | ||
147 | # b4_parse_param_for(DECL, FORMAL, BODY) | |
148 | # --------------------------------------- | |
149 | # Iterate over the user parameters, binding the declaration to DECL, | |
150 | # the formal name to FORMAL, and evaluating the BODY. | |
151 | m4_define([b4_parse_param_for], | |
152 | [m4_foreach([$1_$2], m4_defn([b4_parse_param]), | |
153 | [m4_pushdef([$1], m4_unquote(m4_car($1_$2)))dnl | |
154 | m4_pushdef([$2], m4_shift($1_$2))dnl | |
155 | $3[]dnl | |
156 | m4_popdef([$2])dnl | |
157 | m4_popdef([$1])dnl | |
158 | ])]) | |
159 | ||
160 | # b4_parse_param_use([VAL], [LOC]) | |
161 | # -------------------------------- | |
162 | # `YYUSE' VAL, LOC if locations are enabled, and all the parse-params. | |
163 | m4_define([b4_parse_param_use], | |
164 | [m4_ifvaln([$1], [ YYUSE([$1]);])dnl | |
165 | b4_locations_if([m4_ifvaln([$2], [ YYUSE ([$2]);])])dnl | |
166 | b4_parse_param_for([Decl], [Formal], [ YYUSE (Formal); | |
167 | ])dnl | |
168 | ]) | |
169 | ||
170 | ||
171 | ## ------------ ## | |
172 | ## Data Types. ## | |
173 | ## ------------ ## | |
174 | ||
175 | # b4_int_type(MIN, MAX) | |
176 | # --------------------- | |
177 | # Return the smallest int type able to handle numbers ranging from | |
178 | # MIN to MAX (included). | |
179 | m4_define([b4_int_type], | |
180 | [m4_if(b4_ints_in($@, [0], [255]), [1], [unsigned char], | |
181 | b4_ints_in($@, [-128], [127]), [1], [signed char], | |
182 | ||
183 | b4_ints_in($@, [0], [65535]), [1], [unsigned short int], | |
184 | b4_ints_in($@, [-32768], [32767]), [1], [short int], | |
185 | ||
186 | m4_eval([0 <= $1]), [1], [unsigned int], | |
187 | ||
188 | [int])]) | |
189 | ||
190 | ||
191 | # b4_int_type_for(NAME) | |
192 | # --------------------- | |
193 | # Return the smallest int type able to handle numbers ranging from | |
194 | # `NAME_min' to `NAME_max' (included). | |
195 | m4_define([b4_int_type_for], | |
196 | [b4_int_type($1_min, $1_max)]) | |
197 | ||
198 | ||
199 | # b4_table_value_equals(TABLE, VALUE, LITERAL) | |
200 | # -------------------------------------------- | |
201 | # Without inducing a comparison warning from the compiler, check if the | |
202 | # literal value LITERAL equals VALUE from table TABLE, which must have | |
203 | # TABLE_min and TABLE_max defined. YYID must be defined as an identity | |
204 | # function that suppresses warnings about constant conditions. | |
205 | m4_define([b4_table_value_equals], | |
206 | [m4_if(m4_eval($3 < m4_indir([b4_]$1[_min]) | |
207 | || m4_indir([b4_]$1[_max]) < $3), [1], | |
208 | [[YYID (0)]], | |
209 | [[((]$2[) == (]$3[))]])]) | |
210 | ||
211 | ||
212 | ## ---------## | |
213 | ## Values. ## | |
214 | ## ---------## | |
215 | ||
216 | ||
217 | # b4_null_define | |
218 | # -------------- | |
219 | # Portability issues: define a YY_NULL appropriate for the current | |
220 | # language (C, C++98, or C++11). | |
221 | m4_define([b4_null_define], | |
222 | [# ifndef YY_NULL | |
223 | # if defined __cplusplus && 201103L <= __cplusplus | |
224 | # define YY_NULL nullptr | |
225 | # else | |
226 | # define YY_NULL 0 | |
227 | # endif | |
228 | # endif[]dnl | |
229 | ]) | |
230 | ||
231 | ||
232 | # b4_null | |
233 | # ------- | |
234 | # Return a null pointer constant. | |
235 | m4_define([b4_null], [YY_NULL]) | |
236 | ||
237 | # b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT) | |
238 | # ------------------------------------------------------------- | |
239 | # Define "yy<TABLE-NAME>" which contents is CONTENT. | |
240 | m4_define([b4_integral_parser_table_define], | |
241 | [m4_ifvaln([$3], [b4_c_comment([$3], [ ])])dnl | |
242 | static const b4_int_type_for([$2]) yy$1[[]] = | |
243 | { | |
244 | $2 | |
245 | };dnl | |
246 | ]) | |
247 | ||
248 | ||
249 | ## ------------------------- ## | |
250 | ## Assigning token numbers. ## | |
251 | ## ------------------------- ## | |
252 | ||
253 | # b4_token_define(TOKEN-NUM) | |
254 | # -------------------------- | |
255 | # Output the definition of this token as #define. | |
256 | m4_define([b4_token_define], | |
257 | [b4_token_format([#define %s %s], [$1])]) | |
258 | ||
259 | # b4_token_defines | |
260 | # ---------------- | |
261 | # Output the definition of the tokens. | |
262 | m4_define([b4_token_defines], | |
263 | [b4_any_token_visible_if([/* Tokens. */ | |
264 | m4_join([ | |
265 | ], b4_symbol_map([b4_token_define])) | |
266 | ])]) | |
267 | ||
268 | ||
269 | # b4_token_enum(TOKEN-NUM) | |
270 | # ------------------------ | |
271 | # Output the definition of this token as an enum. | |
272 | m4_define([b4_token_enum], | |
273 | [b4_token_format([%s = %s], [$1])]) | |
274 | ||
275 | ||
276 | # b4_token_enums | |
277 | # -------------- | |
278 | # Output the definition of the tokens (if there are) as enums. | |
279 | m4_define([b4_token_enums], | |
280 | [b4_any_token_visible_if([[/* Tokens. */ | |
281 | #ifndef ]b4_api_PREFIX[TOKENTYPE | |
282 | # define ]b4_api_PREFIX[TOKENTYPE | |
283 | /* Put the tokens into the symbol table, so that GDB and other debuggers | |
284 | know about them. */ | |
285 | enum ]b4_api_prefix[tokentype | |
286 | { | |
287 | ]m4_join([, | |
288 | ], | |
289 | b4_symbol_map([b4_token_enum]))[ | |
290 | }; | |
291 | #endif | |
292 | ]])]) | |
293 | ||
294 | ||
295 | # b4_token_enums_defines | |
296 | # ---------------------- | |
297 | # Output the definition of the tokens (if there are any) as enums and, | |
298 | # if POSIX Yacc is enabled, as #defines. | |
299 | m4_define([b4_token_enums_defines], | |
300 | [b4_token_enums[]b4_yacc_if([b4_token_defines])]) | |
301 | ||
302 | ||
303 | ## ----------------- ## | |
304 | ## Semantic Values. ## | |
305 | ## ----------------- ## | |
306 | ||
307 | ||
308 | # b4_symbol_value(VAL, [TYPE]) | |
309 | # ---------------------------- | |
310 | # Given a semantic value VAL ($$, $1 etc.), extract its value of type | |
311 | # TYPE if TYPE is given, otherwise just return VAL. The result can be | |
312 | # used safetly, it is put in parens to avoid nasty precedence issues. | |
313 | # TYPE is *not* put in braces, provide some if needed. | |
314 | m4_define([b4_symbol_value], | |
315 | [($1[]m4_ifval([$2], [.$2]))]) | |
316 | ||
317 | ||
318 | ||
319 | ## --------------------------------------------- ## | |
320 | ## Defining C functions in both K&R and ANSI-C. ## | |
321 | ## --------------------------------------------- ## | |
322 | ||
323 | ||
324 | # b4_modern_c | |
325 | # ----------- | |
326 | # A predicate useful in #if to determine whether C is ancient or modern. | |
327 | # | |
328 | # If __STDC__ is defined, the compiler is modern. IBM xlc 7.0 when run | |
329 | # as 'cc' doesn't define __STDC__ (or __STDC_VERSION__) for pedantic | |
330 | # reasons, but it defines __C99__FUNC__ so check that as well. | |
331 | # Microsoft C normally doesn't define these macros, but it defines _MSC_VER. | |
332 | # Consider a C++ compiler to be modern if it defines __cplusplus. | |
333 | # | |
334 | m4_define([b4_c_modern], | |
335 | [[(defined __STDC__ || defined __C99__FUNC__ \ | |
336 | || defined __cplusplus || defined _MSC_VER)]]) | |
337 | ||
338 | # b4_c_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...) | |
339 | # ---------------------------------------------------------- | |
340 | # Declare the function NAME. | |
341 | m4_define([b4_c_function_def], | |
342 | [#if b4_c_modern | |
343 | b4_c_ansi_function_def($@) | |
344 | #else | |
345 | $2 | |
346 | $1 (b4_c_knr_formal_names(m4_shift2($@))) | |
347 | b4_c_knr_formal_decls(m4_shift2($@)) | |
348 | #endif[]dnl | |
349 | ]) | |
350 | ||
351 | ||
352 | # b4_c_ansi_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...) | |
353 | # --------------------------------------------------------------- | |
354 | # Declare the function NAME in ANSI. | |
355 | m4_define([b4_c_ansi_function_def], | |
356 | [$2 | |
357 | $1 (b4_c_ansi_formals(m4_shift2($@)))[]dnl | |
358 | ]) | |
359 | ||
360 | ||
361 | # b4_c_ansi_formals([DECL1, NAME1], ...) | |
362 | # -------------------------------------- | |
363 | # Output the arguments ANSI-C definition. | |
364 | m4_define([b4_c_ansi_formals], | |
365 | [m4_if([$#], [0], [void], | |
366 | [$#$1], [1], [void], | |
367 | [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])]) | |
368 | ||
369 | m4_define([b4_c_ansi_formal], | |
370 | [$1]) | |
371 | ||
372 | ||
373 | # b4_c_knr_formal_names([DECL1, NAME1], ...) | |
374 | # ------------------------------------------ | |
375 | # Output the argument names. | |
376 | m4_define([b4_c_knr_formal_names], | |
377 | [m4_map_sep([b4_c_knr_formal_name], [, ], [$@])]) | |
378 | ||
379 | m4_define([b4_c_knr_formal_name], | |
380 | [$2]) | |
381 | ||
382 | ||
383 | # b4_c_knr_formal_decls([DECL1, NAME1], ...) | |
384 | # ------------------------------------------ | |
385 | # Output the K&R argument declarations. | |
386 | m4_define([b4_c_knr_formal_decls], | |
387 | [m4_map_sep([b4_c_knr_formal_decl], | |
388 | [ | |
389 | ], | |
390 | [$@])]) | |
391 | ||
392 | m4_define([b4_c_knr_formal_decl], | |
393 | [ $1;]) | |
394 | ||
395 | ||
396 | ||
397 | ## ------------------------------------------------------------ ## | |
398 | ## Declaring (prototyping) C functions in both K&R and ANSI-C. ## | |
399 | ## ------------------------------------------------------------ ## | |
400 | ||
401 | ||
402 | # b4_c_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...) | |
403 | # ----------------------------------------------------------- | |
404 | # Declare the function NAME. | |
405 | m4_define([b4_c_function_decl], | |
406 | [#if b4_c_modern | |
407 | b4_c_ansi_function_decl($@) | |
408 | #else | |
409 | $2 $1 (); | |
410 | #endif[]dnl | |
411 | ]) | |
412 | ||
413 | ||
414 | # b4_c_ansi_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...) | |
415 | # ---------------------------------------------------------------- | |
416 | # Declare the function NAME. | |
417 | m4_define([b4_c_ansi_function_decl], | |
418 | [$2 $1 (b4_c_ansi_formals(m4_shift2($@)));[]dnl | |
419 | ]) | |
420 | ||
421 | ||
422 | ||
423 | ||
424 | ## --------------------- ## | |
425 | ## Calling C functions. ## | |
426 | ## --------------------- ## | |
427 | ||
428 | ||
429 | # b4_c_function_call(NAME, RETURN-VALUE, [DECL1, NAME1], ...) | |
430 | # ----------------------------------------------------------- | |
431 | # Call the function NAME with arguments NAME1, NAME2 etc. | |
432 | m4_define([b4_c_function_call], | |
433 | [$1 (b4_c_args(m4_shift2($@)))[]dnl | |
434 | ]) | |
435 | ||
436 | ||
437 | # b4_c_args([DECL1, NAME1], ...) | |
438 | # ------------------------------ | |
439 | # Output the arguments NAME1, NAME2... | |
440 | m4_define([b4_c_args], | |
441 | [m4_map_sep([b4_c_arg], [, ], [$@])]) | |
442 | ||
443 | m4_define([b4_c_arg], | |
444 | [$2]) | |
445 | ||
446 | ||
447 | ## ----------- ## | |
448 | ## Synclines. ## | |
449 | ## ----------- ## | |
450 | ||
451 | # b4_sync_start(LINE, FILE) | |
452 | # ----------------------- | |
453 | m4_define([b4_sync_start], [[#]line $1 $2]) | |
454 | ||
455 | ||
456 | ## -------------- ## | |
457 | ## User actions. ## | |
458 | ## -------------- ## | |
459 | ||
460 | # b4_case(LABEL, STATEMENTS) | |
461 | # -------------------------- | |
462 | m4_define([b4_case], | |
463 | [ case $1: | |
464 | $2 | |
465 | b4_syncline([@oline@], [@ofile@]) | |
466 | break;]) | |
467 | ||
468 | ||
469 | # b4_predicate_case(LABEL, CONDITIONS) | |
470 | # ------------------------------------ | |
471 | m4_define([b4_predicate_case], | |
472 | [ case $1: | |
473 | if (! ($2)) YYERROR; | |
474 | b4_syncline([@oline@], [@ofile@]) | |
475 | break;]) | |
476 | ||
477 | ||
478 | # b4_yydestruct_generate(FUNCTION-DECLARATOR) | |
479 | # ------------------------------------------- | |
480 | # Generate the "yydestruct" function, which declaration is issued using | |
481 | # FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C | |
482 | # or "b4_c_function_def" for K&R. | |
483 | m4_define_default([b4_yydestruct_generate], | |
484 | [[/*-----------------------------------------------. | |
485 | | Release the memory associated to this symbol. | | |
486 | `-----------------------------------------------*/ | |
487 | ||
488 | /*ARGSUSED*/ | |
489 | ]$1([yydestruct], | |
490 | [static void], | |
491 | [[const char *yymsg], [yymsg]], | |
492 | [[int yytype], [yytype]], | |
493 | [[YYSTYPE *yyvaluep], [yyvaluep]][]dnl | |
494 | b4_locations_if( [, [[YYLTYPE *yylocationp], [yylocationp]]])[]dnl | |
495 | m4_ifset([b4_parse_param], [, b4_parse_param]))[ | |
496 | { | |
497 | ]b4_parse_param_use([yyvaluep], [yylocationp])dnl | |
498 | [ if (!yymsg) | |
499 | yymsg = "Deleting"; | |
500 | YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); | |
501 | ||
502 | switch (yytype) | |
503 | { | |
504 | ]b4_symbol_foreach([b4_symbol_destructor])dnl | |
505 | [ default: | |
506 | break; | |
507 | } | |
508 | }]dnl | |
509 | ]) | |
510 | ||
511 | ||
512 | # b4_yy_symbol_print_generate(FUNCTION-DECLARATOR) | |
513 | # ------------------------------------------------ | |
514 | # Generate the "yy_symbol_print" function, which declaration is issued using | |
515 | # FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C | |
516 | # or "b4_c_function_def" for K&R. | |
517 | m4_define_default([b4_yy_symbol_print_generate], | |
518 | [[ | |
519 | /*--------------------------------. | |
520 | | Print this symbol on YYOUTPUT. | | |
521 | `--------------------------------*/ | |
522 | ||
523 | /*ARGSUSED*/ | |
524 | ]$1([yy_symbol_value_print], | |
525 | [static void], | |
526 | [[FILE *yyoutput], [yyoutput]], | |
527 | [[int yytype], [yytype]], | |
528 | [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl | |
529 | b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl | |
530 | m4_ifset([b4_parse_param], [, b4_parse_param]))[ | |
531 | { | |
532 | FILE *yyo = yyoutput; | |
533 | ]b4_parse_param_use([yyo], [yylocationp])dnl | |
534 | [ if (!yyvaluep) | |
535 | return;] | |
536 | dnl glr.c does not feature yytoknum. | |
537 | m4_if(b4_skeleton, ["yacc.c"], | |
538 | [[# ifdef YYPRINT | |
539 | if (yytype < YYNTOKENS) | |
540 | YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); | |
541 | # endif | |
542 | ]])dnl | |
543 | [ switch (yytype) | |
544 | { | |
545 | ]b4_symbol_foreach([b4_symbol_printer])dnl | |
546 | [ default: | |
547 | break; | |
548 | } | |
549 | } | |
550 | ||
551 | ||
552 | /*--------------------------------. | |
553 | | Print this symbol on YYOUTPUT. | | |
554 | `--------------------------------*/ | |
555 | ||
556 | ]$1([yy_symbol_print], | |
557 | [static void], | |
558 | [[FILE *yyoutput], [yyoutput]], | |
559 | [[int yytype], [yytype]], | |
560 | [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl | |
561 | b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl | |
562 | m4_ifset([b4_parse_param], [, b4_parse_param]))[ | |
563 | { | |
564 | if (yytype < YYNTOKENS) | |
565 | YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); | |
566 | else | |
567 | YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); | |
568 | ||
569 | ]b4_locations_if([ YY_LOCATION_PRINT (yyoutput, *yylocationp); | |
570 | YYFPRINTF (yyoutput, ": "); | |
571 | ])dnl | |
572 | [ yy_symbol_value_print (yyoutput, yytype, yyvaluep]dnl | |
573 | b4_locations_if([, yylocationp])[]b4_user_args[); | |
574 | YYFPRINTF (yyoutput, ")"); | |
575 | }]dnl | |
576 | ]) | |
577 | ||
578 | ## -------------- ## | |
579 | ## Declarations. ## | |
580 | ## -------------- ## | |
581 | ||
582 | # b4_declare_yylstype | |
583 | # ------------------- | |
584 | # Declarations that might either go into the header (if --defines) or | |
585 | # in the parser body. Declare YYSTYPE/YYLTYPE, and yylval/yylloc. | |
586 | m4_define([b4_declare_yylstype], | |
587 | [[#if ! defined ]b4_api_PREFIX[STYPE && ! defined ]b4_api_PREFIX[STYPE_IS_DECLARED | |
588 | ]m4_ifdef([b4_stype], | |
589 | [[typedef union ]b4_union_name[ | |
590 | { | |
591 | ]b4_user_stype[ | |
592 | } ]b4_api_PREFIX[STYPE; | |
593 | # define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1]], | |
594 | [m4_if(b4_tag_seen_flag, 0, | |
595 | [[typedef int ]b4_api_PREFIX[STYPE; | |
596 | # define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1]])])[ | |
597 | # define ]b4_api_prefix[stype ]b4_api_PREFIX[STYPE /* obsolescent; will be withdrawn */ | |
598 | # define ]b4_api_PREFIX[STYPE_IS_DECLARED 1 | |
599 | #endif]b4_locations_if([[ | |
600 | ||
601 | #if ! defined ]b4_api_PREFIX[LTYPE && ! defined ]b4_api_PREFIX[LTYPE_IS_DECLARED | |
602 | typedef struct ]b4_api_PREFIX[LTYPE | |
603 | { | |
604 | int first_line; | |
605 | int first_column; | |
606 | int last_line; | |
607 | int last_column; | |
608 | } ]b4_api_PREFIX[LTYPE; | |
609 | # define ]b4_api_prefix[ltype ]b4_api_PREFIX[LTYPE /* obsolescent; will be withdrawn */ | |
610 | # define ]b4_api_PREFIX[LTYPE_IS_DECLARED 1 | |
611 | # define ]b4_api_PREFIX[LTYPE_IS_TRIVIAL 1 | |
612 | #endif]]) | |
613 | ||
614 | b4_pure_if([], [[extern ]b4_api_PREFIX[STYPE ]b4_prefix[lval; | |
615 | ]b4_locations_if([[extern ]b4_api_PREFIX[LTYPE ]b4_prefix[lloc;]])])[]dnl | |
616 | ]) | |
617 | ||
618 | # b4_YYDEBUG_define | |
619 | # ------------------ | |
620 | m4_define([b4_YYDEBUG_define], | |
621 | [[/* Enabling traces. */ | |
622 | ]m4_if(b4_api_prefix, [yy], | |
623 | [[#ifndef YYDEBUG | |
624 | # define YYDEBUG ]b4_parse_trace_if([1], [0])[ | |
625 | #endif]], | |
626 | [[#ifndef ]b4_api_PREFIX[DEBUG | |
627 | # if defined YYDEBUG | |
628 | #if YYDEBUG | |
629 | # define ]b4_api_PREFIX[DEBUG 1 | |
630 | # else | |
631 | # define ]b4_api_PREFIX[DEBUG 0 | |
632 | # endif | |
633 | # else /* ! defined YYDEBUG */ | |
634 | # define ]b4_api_PREFIX[DEBUG ]b4_parse_trace_if([1], [0])[ | |
635 | # endif /* ! defined ]b4_api_PREFIX[DEBUG */ | |
636 | #endif /* ! defined ]b4_api_PREFIX[DEBUG */]])[]dnl | |
637 | ]) | |
638 | ||
639 | # b4_declare_yydebug | |
640 | # ------------------ | |
641 | m4_define([b4_declare_yydebug], | |
642 | [b4_YYDEBUG_define[ | |
643 | #if ]b4_api_PREFIX[DEBUG | |
644 | extern int ]b4_prefix[debug; | |
645 | #endif][]dnl | |
646 | ]) | |
647 | ||
648 | # b4_yylloc_default_define | |
649 | # ------------------------ | |
650 | # Define YYLLOC_DEFAULT. | |
651 | m4_define([b4_yylloc_default_define], | |
652 | [[/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. | |
653 | If N is 0, then set CURRENT to the empty location which ends | |
654 | the previous symbol: RHS[0] (always defined). */ | |
655 | ||
656 | #ifndef YYLLOC_DEFAULT | |
657 | # define YYLLOC_DEFAULT(Current, Rhs, N) \ | |
658 | do \ | |
659 | if (YYID (N)) \ | |
660 | { \ | |
661 | (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ | |
662 | (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ | |
663 | (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ | |
664 | (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ | |
665 | } \ | |
666 | else \ | |
667 | { \ | |
668 | (Current).first_line = (Current).last_line = \ | |
669 | YYRHSLOC (Rhs, 0).last_line; \ | |
670 | (Current).first_column = (Current).last_column = \ | |
671 | YYRHSLOC (Rhs, 0).last_column; \ | |
672 | } \ | |
673 | while (YYID (0)) | |
674 | #endif | |
675 | ]]) |