]>
Commit | Line | Data |
---|---|---|
1 | -*- Autoconf -*- | |
2 | ||
3 | # C M4 Macros for Bison. | |
4 | # Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008 Free Software | |
5 | # 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 | ## Identification. ## | |
22 | ## ---------------- ## | |
23 | ||
24 | # b4_comment(TEXT) | |
25 | # ---------------- | |
26 | m4_define([b4_comment], [/* m4_bpatsubst([$1], [ | |
27 | ], [ | |
28 | ]) */]) | |
29 | ||
30 | # b4_identification | |
31 | # ----------------- | |
32 | # Depends on individual skeletons to define b4_pure_flag, b4_push_flag, or | |
33 | # b4_pull_flag if they use the values of the %define variables api.pure or | |
34 | # api.push_pull. | |
35 | m4_define([b4_identification], | |
36 | [[/* Identify Bison output. */ | |
37 | #define YYBISON 1 | |
38 | ||
39 | /* Bison version. */ | |
40 | #define YYBISON_VERSION "]b4_version[" | |
41 | ||
42 | /* Skeleton name. */ | |
43 | #define YYSKELETON_NAME ]b4_skeleton[]m4_ifdef([b4_pure_flag], [[ | |
44 | ||
45 | /* Pure parsers. */ | |
46 | #define YYPURE ]b4_pure_flag])[]m4_ifdef([b4_push_flag], [[ | |
47 | ||
48 | /* Push parsers. */ | |
49 | #define YYPUSH ]b4_push_flag])[]m4_ifdef([b4_pull_flag], [[ | |
50 | ||
51 | /* Pull parsers. */ | |
52 | #define YYPULL ]b4_pull_flag])[ | |
53 | ||
54 | /* Using locations. */ | |
55 | #define YYLSP_NEEDED ]b4_locations_flag[ | |
56 | ]]) | |
57 | ||
58 | ||
59 | ## ---------------- ## | |
60 | ## Default values. ## | |
61 | ## ---------------- ## | |
62 | ||
63 | # If the %union is not named, its name is YYSTYPE. | |
64 | m4_define_default([b4_union_name], [YYSTYPE]) | |
65 | ||
66 | # If the %name-prefix is not given, it is yy. | |
67 | m4_define_default([b4_prefix], [yy]) | |
68 | ||
69 | ## ------------------------ ## | |
70 | ## Pure/impure interfaces. ## | |
71 | ## ------------------------ ## | |
72 | ||
73 | # b4_user_args | |
74 | # ------------ | |
75 | m4_define([b4_user_args], | |
76 | [m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])]) | |
77 | ||
78 | ||
79 | # b4_parse_param | |
80 | # -------------- | |
81 | # If defined, b4_parse_param arrives double quoted, but below we prefer | |
82 | # it to be single quoted. | |
83 | m4_define([b4_parse_param], | |
84 | b4_parse_param) | |
85 | ||
86 | ||
87 | # b4_parse_param_for(DECL, FORMAL, BODY) | |
88 | # --------------------------------------- | |
89 | # Iterate over the user parameters, binding the declaration to DECL, | |
90 | # the formal name to FORMAL, and evaluating the BODY. | |
91 | m4_define([b4_parse_param_for], | |
92 | [m4_foreach([$1_$2], m4_defn([b4_parse_param]), | |
93 | [m4_pushdef([$1], m4_unquote(m4_car($1_$2)))dnl | |
94 | m4_pushdef([$2], m4_shift($1_$2))dnl | |
95 | $3[]dnl | |
96 | m4_popdef([$2])dnl | |
97 | m4_popdef([$1])dnl | |
98 | ])]) | |
99 | ||
100 | # b4_parse_param_use | |
101 | # ------------------ | |
102 | # `YYUSE' all the parse-params. | |
103 | m4_define([b4_parse_param_use], | |
104 | [b4_parse_param_for([Decl], [Formal], [ YYUSE (Formal); | |
105 | ])dnl | |
106 | ]) | |
107 | ||
108 | ||
109 | ## ------------ ## | |
110 | ## Data Types. ## | |
111 | ## ------------ ## | |
112 | ||
113 | # b4_int_type(MIN, MAX) | |
114 | # --------------------- | |
115 | # Return the smallest int type able to handle numbers ranging from | |
116 | # MIN to MAX (included). | |
117 | m4_define([b4_int_type], | |
118 | [m4_if(b4_ints_in($@, [0], [255]), [1], [unsigned char], | |
119 | b4_ints_in($@, [-128], [127]), [1], [signed char], | |
120 | ||
121 | b4_ints_in($@, [0], [65535]), [1], [unsigned short int], | |
122 | b4_ints_in($@, [-32768], [32767]), [1], [short int], | |
123 | ||
124 | m4_eval([0 <= $1]), [1], [unsigned int], | |
125 | ||
126 | [int])]) | |
127 | ||
128 | ||
129 | # b4_int_type_for(NAME) | |
130 | # --------------------- | |
131 | # Return the smallest int type able to handle numbers ranging from | |
132 | # `NAME_min' to `NAME_max' (included). | |
133 | m4_define([b4_int_type_for], | |
134 | [b4_int_type($1_min, $1_max)]) | |
135 | ||
136 | ||
137 | ||
138 | ## ---------## | |
139 | ## Values. ## | |
140 | ## ---------## | |
141 | ||
142 | # b4_null | |
143 | --------- | |
144 | # Return a null pointer constant. NULL infringes on the user name | |
145 | # space in C, so use 0 rather than NULL. | |
146 | m4_define([b4_null], [0]) | |
147 | ||
148 | ||
149 | ||
150 | ||
151 | ## ------------------------- ## | |
152 | ## Assigning token numbers. ## | |
153 | ## ------------------------- ## | |
154 | ||
155 | # b4_token_define(TOKEN-NAME, TOKEN-NUMBER) | |
156 | # ----------------------------------------- | |
157 | # Output the definition of this token as #define. | |
158 | m4_define([b4_token_define], | |
159 | [#define $1 $2 | |
160 | ]) | |
161 | ||
162 | ||
163 | # b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) | |
164 | # ------------------------------------------------------- | |
165 | # Output the definition of the tokens (if there are) as #defines. | |
166 | m4_define([b4_token_defines], | |
167 | [m4_if([$#$1], [1], [], | |
168 | [/* Tokens. */ | |
169 | m4_map([b4_token_define], [$@])]) | |
170 | ]) | |
171 | ||
172 | ||
173 | # b4_token_enum(TOKEN-NAME, TOKEN-NUMBER) | |
174 | # --------------------------------------- | |
175 | # Output the definition of this token as an enum. | |
176 | m4_define([b4_token_enum], | |
177 | [$1 = $2]) | |
178 | ||
179 | ||
180 | # b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) | |
181 | # ----------------------------------------------------- | |
182 | # Output the definition of the tokens (if there are) as enums. | |
183 | m4_define([b4_token_enums], | |
184 | [m4_if([$#$1], [1], [], | |
185 | [/* Tokens. */ | |
186 | #ifndef YYTOKENTYPE | |
187 | # define YYTOKENTYPE | |
188 | /* Put the tokens into the symbol table, so that GDB and other debuggers | |
189 | know about them. */ | |
190 | enum yytokentype { | |
191 | m4_map_sep([ b4_token_enum], [, | |
192 | ], | |
193 | [$@]) | |
194 | }; | |
195 | #endif | |
196 | ])]) | |
197 | ||
198 | ||
199 | # b4_token_enums_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) | |
200 | # ------------------------------------------------------------- | |
201 | # Output the definition of the tokens (if there are any) as enums and, if POSIX | |
202 | # Yacc is enabled, as #defines. | |
203 | m4_define([b4_token_enums_defines], | |
204 | [b4_token_enums($@)b4_yacc_if([b4_token_defines($@)], []) | |
205 | ]) | |
206 | ||
207 | ||
208 | ## ----------------- ## | |
209 | ## Semantic Values. ## | |
210 | ## ----------------- ## | |
211 | ||
212 | ||
213 | # b4_symbol_value(VAL, [TYPE]) | |
214 | # ---------------------------- | |
215 | # Given a semantic value VAL ($$, $1 etc.), extract its value of type | |
216 | # TYPE if TYPE is given, otherwise just return VAL. The result can be | |
217 | # used safetly, it is put in parens to avoid nasty precedence issues. | |
218 | # TYPE is *not* put in braces, provide some if needed. | |
219 | m4_define([b4_symbol_value], | |
220 | [($1[]m4_ifval([$2], [.$2]))]) | |
221 | ||
222 | ||
223 | ||
224 | ## --------------------------------------------- ## | |
225 | ## Defining C functions in both K&R and ANSI-C. ## | |
226 | ## --------------------------------------------- ## | |
227 | ||
228 | ||
229 | # b4_modern_c | |
230 | # ----------- | |
231 | # A predicate useful in #if to determine whether C is ancient or modern. | |
232 | # | |
233 | # If __STDC__ is defined, the compiler is modern. IBM xlc 7.0 when run | |
234 | # as 'cc' doesn't define __STDC__ (or __STDC_VERSION__) for pedantic | |
235 | # reasons, but it defines __C99__FUNC__ so check that as well. | |
236 | # Microsoft C normally doesn't define these macros, but it defines _MSC_VER. | |
237 | # Consider a C++ compiler to be modern if it defines __cplusplus. | |
238 | # | |
239 | m4_define([b4_c_modern], | |
240 | [[(defined __STDC__ || defined __C99__FUNC__ \ | |
241 | || defined __cplusplus || defined _MSC_VER)]]) | |
242 | ||
243 | # b4_c_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...) | |
244 | # ---------------------------------------------------------- | |
245 | # Declare the function NAME. | |
246 | m4_define([b4_c_function_def], | |
247 | [#if b4_c_modern | |
248 | b4_c_ansi_function_def($@) | |
249 | #else | |
250 | $2 | |
251 | $1 (b4_c_knr_formal_names(m4_shift2($@))) | |
252 | b4_c_knr_formal_decls(m4_shift2($@)) | |
253 | #endif[]dnl | |
254 | ]) | |
255 | ||
256 | ||
257 | # b4_c_ansi_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...) | |
258 | # --------------------------------------------------------------- | |
259 | # Declare the function NAME in ANSI. | |
260 | m4_define([b4_c_ansi_function_def], | |
261 | [$2 | |
262 | $1 (b4_c_ansi_formals(m4_shift2($@)))[]dnl | |
263 | ]) | |
264 | ||
265 | ||
266 | # b4_c_ansi_formals([DECL1, NAME1], ...) | |
267 | # -------------------------------------- | |
268 | # Output the arguments ANSI-C definition. | |
269 | m4_define([b4_c_ansi_formals], | |
270 | [m4_if([$#], [0], [void], | |
271 | [$#$1], [1], [void], | |
272 | [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])]) | |
273 | ||
274 | m4_define([b4_c_ansi_formal], | |
275 | [$1]) | |
276 | ||
277 | ||
278 | # b4_c_knr_formal_names([DECL1, NAME1], ...) | |
279 | # ------------------------------------------ | |
280 | # Output the argument names. | |
281 | m4_define([b4_c_knr_formal_names], | |
282 | [m4_map_sep([b4_c_knr_formal_name], [, ], [$@])]) | |
283 | ||
284 | m4_define([b4_c_knr_formal_name], | |
285 | [$2]) | |
286 | ||
287 | ||
288 | # b4_c_knr_formal_decls([DECL1, NAME1], ...) | |
289 | # ------------------------------------------ | |
290 | # Output the K&R argument declarations. | |
291 | m4_define([b4_c_knr_formal_decls], | |
292 | [m4_map_sep([b4_c_knr_formal_decl], | |
293 | [ | |
294 | ], | |
295 | [$@])]) | |
296 | ||
297 | m4_define([b4_c_knr_formal_decl], | |
298 | [ $1;]) | |
299 | ||
300 | ||
301 | ||
302 | ## ------------------------------------------------------------ ## | |
303 | ## Declaring (prototyping) C functions in both K&R and ANSI-C. ## | |
304 | ## ------------------------------------------------------------ ## | |
305 | ||
306 | ||
307 | # b4_c_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...) | |
308 | # ----------------------------------------------------------- | |
309 | # Declare the function NAME. | |
310 | m4_define([b4_c_function_decl], | |
311 | [#if defined __STDC__ || defined __cplusplus | |
312 | b4_c_ansi_function_decl($@) | |
313 | #else | |
314 | $2 $1 (); | |
315 | #endif[]dnl | |
316 | ]) | |
317 | ||
318 | ||
319 | # b4_c_ansi_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...) | |
320 | # ---------------------------------------------------------------- | |
321 | # Declare the function NAME. | |
322 | m4_define([b4_c_ansi_function_decl], | |
323 | [$2 $1 (b4_c_ansi_formals(m4_shift2($@)));[]dnl | |
324 | ]) | |
325 | ||
326 | ||
327 | ||
328 | ||
329 | ## --------------------- ## | |
330 | ## Calling C functions. ## | |
331 | ## --------------------- ## | |
332 | ||
333 | ||
334 | # b4_c_function_call(NAME, RETURN-VALUE, [DECL1, NAME1], ...) | |
335 | # ----------------------------------------------------------- | |
336 | # Call the function NAME with arguments NAME1, NAME2 etc. | |
337 | m4_define([b4_c_function_call], | |
338 | [$1 (b4_c_args(m4_shift2($@)))[]dnl | |
339 | ]) | |
340 | ||
341 | ||
342 | # b4_c_args([DECL1, NAME1], ...) | |
343 | # ------------------------------ | |
344 | # Output the arguments NAME1, NAME2... | |
345 | m4_define([b4_c_args], | |
346 | [m4_map_sep([b4_c_arg], [, ], [$@])]) | |
347 | ||
348 | m4_define([b4_c_arg], | |
349 | [$2]) | |
350 | ||
351 | ||
352 | ## ----------- ## | |
353 | ## Synclines. ## | |
354 | ## ----------- ## | |
355 | ||
356 | # b4_sync_start(LINE, FILE) | |
357 | # ----------------------- | |
358 | m4_define([b4_sync_start], [[#]line $1 $2]) | |
359 | ||
360 | ||
361 | ## -------------- ## | |
362 | ## User actions. ## | |
363 | ## -------------- ## | |
364 | ||
365 | # b4_case(LABEL, STATEMENTS) | |
366 | # -------------------------- | |
367 | m4_define([b4_case], | |
368 | [ case $1: | |
369 | $2 | |
370 | b4_syncline([@oline@], [@ofile@]) | |
371 | break;]) | |
372 | ||
373 | # b4_symbol_actions(FILENAME, LINENO, | |
374 | # SYMBOL-TAG, SYMBOL-NUM, | |
375 | # SYMBOL-ACTION, SYMBOL-TYPENAME) | |
376 | # ------------------------------------------------- | |
377 | m4_define([b4_symbol_actions], | |
378 | [m4_pushdef([b4_dollar_dollar], | |
379 | [b4_symbol_value([(*yyvaluep)], [$6])])dnl | |
380 | m4_pushdef([b4_at_dollar], [(*yylocationp)])dnl | |
381 | case $4: /* $3 */ | |
382 | b4_syncline([$2], [$1]) | |
383 | $5; | |
384 | b4_syncline([@oline@], [@ofile@]) | |
385 | break; | |
386 | m4_popdef([b4_at_dollar])dnl | |
387 | m4_popdef([b4_dollar_dollar])dnl | |
388 | ]) | |
389 | ||
390 | ||
391 | # b4_yydestruct_generate(FUNCTION-DECLARATOR) | |
392 | # ------------------------------------------- | |
393 | # Generate the "yydestruct" function, which declaration is issued using | |
394 | # FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C | |
395 | # or "b4_c_function_def" for K&R. | |
396 | m4_define_default([b4_yydestruct_generate], | |
397 | [[/*-----------------------------------------------. | |
398 | | Release the memory associated to this symbol. | | |
399 | `-----------------------------------------------*/ | |
400 | ||
401 | /*ARGSUSED*/ | |
402 | ]$1([yydestruct], | |
403 | [static void], | |
404 | [[const char *yymsg], [yymsg]], | |
405 | [[int yytype], [yytype]], | |
406 | [[YYSTYPE *yyvaluep], [yyvaluep]][]dnl | |
407 | b4_locations_if( [, [[YYLTYPE *yylocationp], [yylocationp]]])[]dnl | |
408 | m4_ifset([b4_parse_param], [, b4_parse_param]))[ | |
409 | { | |
410 | YYUSE (yyvaluep); | |
411 | ]b4_locations_if([ YYUSE (yylocationp); | |
412 | ])dnl | |
413 | b4_parse_param_use[]dnl | |
414 | [ | |
415 | if (!yymsg) | |
416 | yymsg = "Deleting"; | |
417 | YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); | |
418 | ||
419 | switch (yytype) | |
420 | { | |
421 | ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[ | |
422 | default: | |
423 | break; | |
424 | } | |
425 | }]dnl | |
426 | ]) | |
427 | ||
428 | ||
429 | # b4_yy_symbol_print_generate(FUNCTION-DECLARATOR) | |
430 | # ------------------------------------------------ | |
431 | # Generate the "yy_symbol_print" function, which declaration is issued using | |
432 | # FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C | |
433 | # or "b4_c_function_def" for K&R. | |
434 | m4_define_default([b4_yy_symbol_print_generate], | |
435 | [[ | |
436 | /*--------------------------------. | |
437 | | Print this symbol on YYOUTPUT. | | |
438 | `--------------------------------*/ | |
439 | ||
440 | /*ARGSUSED*/ | |
441 | ]$1([yy_symbol_value_print], | |
442 | [static void], | |
443 | [[FILE *yyoutput], [yyoutput]], | |
444 | [[int yytype], [yytype]], | |
445 | [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl | |
446 | b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl | |
447 | m4_ifset([b4_parse_param], [, b4_parse_param]))[ | |
448 | { | |
449 | if (!yyvaluep) | |
450 | return; | |
451 | ]b4_locations_if([ YYUSE (yylocationp); | |
452 | ])dnl | |
453 | b4_parse_param_use[]dnl | |
454 | [# ifdef YYPRINT | |
455 | if (yytype < YYNTOKENS) | |
456 | YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); | |
457 | # else | |
458 | YYUSE (yyoutput); | |
459 | # endif | |
460 | switch (yytype) | |
461 | { | |
462 | ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl | |
463 | [ default: | |
464 | break; | |
465 | } | |
466 | } | |
467 | ||
468 | ||
469 | /*--------------------------------. | |
470 | | Print this symbol on YYOUTPUT. | | |
471 | `--------------------------------*/ | |
472 | ||
473 | ]$1([yy_symbol_print], | |
474 | [static void], | |
475 | [[FILE *yyoutput], [yyoutput]], | |
476 | [[int yytype], [yytype]], | |
477 | [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl | |
478 | b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl | |
479 | m4_ifset([b4_parse_param], [, b4_parse_param]))[ | |
480 | { | |
481 | if (yytype < YYNTOKENS) | |
482 | YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); | |
483 | else | |
484 | YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); | |
485 | ||
486 | ]b4_locations_if([ YY_LOCATION_PRINT (yyoutput, *yylocationp); | |
487 | YYFPRINTF (yyoutput, ": "); | |
488 | ])dnl | |
489 | [ yy_symbol_value_print (yyoutput, yytype, yyvaluep]dnl | |
490 | b4_locations_if([, yylocationp])[]b4_user_args[); | |
491 | YYFPRINTF (yyoutput, ")"); | |
492 | }]dnl | |
493 | ]) |