1 m4_divert(-1) -*- Autoconf -*- 2 3 # C M4 Macros for Bison. 4 # Copyright (C) 2002, 2004, 2005, 2006 Free Software Foundation, Inc. 5 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. 10 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. 15 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 19 # 02110-1301 USA 20 21 22 ## ---------------- ## 23 ## Identification. ## 24 ## ---------------- ## 25 26 # b4_copyright(TITLE, YEARS) 27 # -------------------------- 28 m4_define([b4_copyright], 29 [/* A Bison parser, made by GNU Bison b4_version. */ 30 31 /* $1 32 33 m4_text_wrap([Copyright (C) $2 Free Software Foundation, Inc.], [ ]) 34 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) 38 any later version. 39 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. 44 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. */ 49 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. 59 60 This special exception was added by the Free Software Foundation in 61 version 2.2 of Bison. */]) 62 63 64 # b4_identification 65 # ----------------- 66 m4_define([b4_identification], 67 [/* Identify Bison output. */ 68 [#]define YYBISON 1 69 70 /* Bison version. */ 71 [#]define YYBISON_VERSION "b4_version" 72 73 /* Skeleton name. */ 74 [#]define YYSKELETON_NAME b4_skeleton 75 76 /* Pure parsers. */ 77 [#]define YYPURE b4_pure_flag 78 79 /* Using locations. */ 80 [#]define YYLSP_NEEDED b4_locations_flag 81 ]) 82 83 84 85 ## ---------------- ## 86 ## Default values. ## 87 ## ---------------- ## 88 89 m4_define_default([b4_epilogue], []) 90 91 92 93 ## ------------------------ ## 94 ## Pure/impure interfaces. ## 95 ## ------------------------ ## 96 97 98 # b4_user_args 99 # ------------ 100 m4_define([b4_user_args], 101 [m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])]) 102 103 104 # b4_parse_param 105 # -------------- 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], 110 b4_parse_param)) 111 112 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 121 $3[]dnl 122 m4_popdef([$2])dnl 123 m4_popdef([$1])dnl 124 ])]) 125 126 # b4_parse_param_use 127 # ------------------ 128 # `YYUSE' all the parse-params. 129 m4_define([b4_parse_param_use], 130 [b4_parse_param_for([Decl], [Formal], [ YYUSE (Formal); 131 ])dnl 132 ]) 133 134 ## ------------ ## 135 ## Data Types. ## 136 ## ------------ ## 137 138 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])]) 144 145 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], 153 154 b4_ints_in($@, [0], [65535]), [1], [unsigned short int], 155 b4_ints_in($@, [-32768], [32767]), [1], [short int], 156 157 m4_eval([0 <= $1]), [1], [unsigned int], 158 159 [int])]) 160 161 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)]) 168 169 170 ## ------------------ ## 171 ## Decoding options. ## 172 ## ------------------ ## 173 174 # b4_flag_if(FLAG, IF-TRUE, IF-FALSE) 175 # ----------------------------------- 176 # Run IF-TRUE if b4_FLAG_flag is 1, IF-FALSE if FLAG is 0, otherwise fail. 177 m4_define([b4_flag_if], 178 [m4_case(b4_$1_flag, 179 [0], [$3], 180 [1], [$2], 181 [m4_fatal([invalid $1 value: ]$1)])]) 182 183 184 # b4_define_flag_if(FLAG) 185 # ----------------------- 186 # Define "b4_FLAG_if(IF-TRUE, IF-FALSE)" that depends on the 187 # value of the Boolean FLAG. 188 m4_define([b4_define_flag_if], 189 [_b4_define_flag_if($[1], $[2], [$1])]) 190 191 # _b4_define_flag_if($1, $2, FLAG) 192 # -------------------------------- 193 # This macro works around the impossibility to define macros 194 # inside macros, because issuing `[$1]' is not possible in M4 :(. 195 # This sucks hard, GNU M4 should really provide M5 like $$1. 196 m4_define([_b4_define_flag_if], 197 [m4_if([$1$2], $[1]$[2], [], 198 [m4_fatal([$0: Invalid arguments: $@])])dnl 199 m4_define([b4_$3_if], 200 [b4_flag_if([$3], [$1], [$2])])]) 201 202 203 # b4_FLAG_if(IF-TRUE, IF-FALSE) 204 # ----------------------------- 205 # Expand IF-TRUE, if FLAG is true, IF-FALSE otherwise. 206 b4_define_flag_if([defines]) # Whether headers are requested. 207 b4_define_flag_if([error_verbose]) # Wheter error are verbose. 208 b4_define_flag_if([locations]) # Whether locations are tracked. 209 b4_define_flag_if([pure]) # Whether the interface is pure. 210 211 212 213 ## ------------------------- ## 214 ## Assigning token numbers. ## 215 ## ------------------------- ## 216 217 # b4_token_define(TOKEN-NAME, TOKEN-NUMBER) 218 # ----------------------------------------- 219 # Output the definition of this token as #define. 220 m4_define([b4_token_define], 221 [#define $1 $2 222 ]) 223 224 225 # b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) 226 # ------------------------------------------------------- 227 # Output the definition of the tokens (if there are) as #defines. 228 m4_define([b4_token_defines], 229 [m4_if([$@], [[]], [], 230 [/* Tokens. */ 231 m4_map([b4_token_define], [$@])]) 232 ]) 233 234 235 # b4_token_enum(TOKEN-NAME, TOKEN-NUMBER) 236 # --------------------------------------- 237 # Output the definition of this token as an enum. 238 m4_define([b4_token_enum], 239 [$1 = $2]) 240 241 242 # b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) 243 # ----------------------------------------------------- 244 # Output the definition of the tokens (if there are) as enums. 245 m4_define([b4_token_enums], 246 [m4_if([$@], [[]], [], 247 [/* Tokens. */ 248 #ifndef YYTOKENTYPE 249 # define YYTOKENTYPE 250 /* Put the tokens into the symbol table, so that GDB and other debuggers 251 know about them. */ 252 enum yytokentype { 253 m4_map_sep([ b4_token_enum], [, 254 ], 255 [$@]) 256 }; 257 #endif 258 ])]) 259 260 261 # b4_token_enums_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) 262 # ------------------------------------------------------------- 263 # Output the definition of the tokens (if there are) as enums and #defines. 264 m4_define([b4_token_enums_defines], 265 [b4_token_enums($@)b4_token_defines($@) 266 ]) 267 268 269 270 ## --------------------------------------------- ## 271 ## Defining C functions in both K&R and ANSI-C. ## 272 ## --------------------------------------------- ## 273 274 275 # b4_modern_c 276 # ----------- 277 # A predicate useful in #if to determine whether C is ancient or modern. 278 # 279 # If __STDC__ is defined, the compiler is modern. IBM xlc 7.0 when run 280 # as 'cc' doesn't define __STDC__ (or __STDC_VERSION__) for pedantic 281 # reasons, but it defines __C99__FUNC__ so check that as well. 282 # Microsoft C normally doesn't define these macros, but it defines _MSC_VER. 283 # Consider a C++ compiler to be modern if it defines __cplusplus. 284 # 285 m4_define([b4_c_modern], 286 [[(defined __STDC__ || defined __C99__FUNC__ \ 287 || defined __cplusplus || defined _MSC_VER)]]) 288 289 # b4_c_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...) 290 # ---------------------------------------------------------- 291 # Declare the function NAME. 292 m4_define([b4_c_function_def], 293 [#if b4_c_modern 294 b4_c_ansi_function_def($@) 295 #else 296 $2 297 $1 (b4_c_knr_formal_names(m4_shiftn(2, $@))) 298 b4_c_knr_formal_decls(m4_shiftn(2, $@)) 299 #endif[]dnl 300 ]) 301 302 303 # b4_c_ansi_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...) 304 # --------------------------------------------------------------- 305 # Declare the function NAME in ANSI. 306 m4_define([b4_c_ansi_function_def], 307 [$2 308 $1 (b4_c_ansi_formals(m4_shiftn(2, $@)))[]dnl 309 ]) 310 311 312 # b4_c_ansi_formals([DECL1, NAME1], ...) 313 # -------------------------------------- 314 # Output the arguments ANSI-C definition. 315 m4_define([b4_c_ansi_formals], 316 [m4_case([$@], 317 [], [void], 318 [[]], [void], 319 [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])]) 320 321 m4_define([b4_c_ansi_formal], 322 [$1]) 323 324 325 # b4_c_knr_formal_names([DECL1, NAME1], ...) 326 # ------------------------------------------ 327 # Output the argument names. 328 m4_define([b4_c_knr_formal_names], 329 [m4_map_sep([b4_c_knr_formal_name], [, ], [$@])]) 330 331 m4_define([b4_c_knr_formal_name], 332 [$2]) 333 334 335 # b4_c_knr_formal_decls([DECL1, NAME1], ...) 336 # ------------------------------------------ 337 # Output the K&R argument declarations. 338 m4_define([b4_c_knr_formal_decls], 339 [m4_map_sep([b4_c_knr_formal_decl], 340 [ 341 ], 342 [$@])]) 343 344 m4_define([b4_c_knr_formal_decl], 345 [ $1;]) 346 347 348 349 ## ------------------------------------------------------------ ## 350 ## Declaring (prototyping) C functions in both K&R and ANSI-C. ## 351 ## ------------------------------------------------------------ ## 352 353 354 # b4_c_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...) 355 # ----------------------------------------------------------- 356 # Declare the function NAME. 357 m4_define([b4_c_function_decl], 358 [#if defined __STDC__ || defined __cplusplus 359 b4_c_ansi_function_decl($@) 360 #else 361 $2 $1 (); 362 #endif[]dnl 363 ]) 364 365 366 # b4_c_ansi_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...) 367 # ---------------------------------------------------------------- 368 # Declare the function NAME. 369 m4_define([b4_c_ansi_function_decl], 370 [$2 $1 (b4_c_ansi_formals(m4_shiftn(2, $@)));[]dnl 371 ]) 372 373 374 375 376 ## --------------------- ## 377 ## Calling C functions. ## 378 ## --------------------- ## 379 380 381 # b4_c_function_call(NAME, RETURN-VALUE, [DECL1, NAME1], ...) 382 # ----------------------------------------------------------- 383 # Call the function NAME with arguments NAME1, NAME2 etc. 384 m4_define([b4_c_function_call], 385 [$1 (b4_c_args(m4_shiftn(2, $@)))[]dnl 386 ]) 387 388 389 # b4_c_args([DECL1, NAME1], ...) 390 # ------------------------------ 391 # Output the arguments NAME1, NAME2... 392 m4_define([b4_c_args], 393 [m4_map_sep([b4_c_arg], [, ], [$@])]) 394 395 m4_define([b4_c_arg], 396 [$2]) 397 398 399 ## ----------- ## 400 ## Synclines. ## 401 ## ----------- ## 402 403 # b4_syncline(LINE, FILE) 404 # ----------------------- 405 m4_define([b4_syncline], 406 [b4_flag_if([synclines], [[#]line $1 $2])]) 407 408 409 410 ## -------------- ## 411 ## User actions. ## 412 ## -------------- ## 413 414 # b4_symbol_actions(FILENAME, LINENO, 415 # SYMBOL-TAG, SYMBOL-NUM, 416 # SYMBOL-ACTION, SYMBOL-TYPENAME) 417 # ------------------------------------------------- 418 m4_define([b4_symbol_actions], 419 [m4_pushdef([b4_dollar_dollar], 420 [m4_ifval([$6], [(yyvaluep->$6)], [(*yyvaluep)])])dnl 421 m4_pushdef([b4_at_dollar], [(*yylocationp)])dnl 422 case $4: /* $3 */ 423 b4_syncline([$2], [$1]) 424 $5; 425 b4_syncline([@oline@], [@ofile@]) 426 break; 427 m4_popdef([b4_at_dollar])dnl 428 m4_popdef([b4_dollar_dollar])dnl 429 ]) 430 431 432 # b4_yydestruct_generate(FUNCTION-DECLARATOR) 433 # ------------------------------------------- 434 # Generate the "yydestruct" function, which declaration is issued using 435 # FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C 436 # or "b4_c_function_def" for K&R. 437 m4_define_default([b4_yydestruct_generate], 438 [[/*-----------------------------------------------. 439 | Release the memory associated to this symbol. | 440 `-----------------------------------------------*/ 441 442 /*ARGSUSED*/ 443 ]$1([yydestruct], 444 [static void], 445 [[const char *yymsg], [yymsg]], 446 [[int yytype], [yytype]], 447 [[YYSTYPE *yyvaluep], [yyvaluep]][]dnl 448 b4_locations_if( [, [[YYLTYPE *yylocationp], [yylocationp]]])[]dnl 449 m4_ifset([b4_parse_param], [, b4_parse_param]))[ 450 { 451 YYUSE (yyvaluep); 452 ]b4_locations_if([ YYUSE (yylocationp); 453 ])dnl 454 b4_parse_param_use[]dnl 455 [ 456 if (!yymsg) 457 yymsg = "Deleting"; 458 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 459 460 switch (yytype) 461 { 462 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[ 463 default: 464 break; 465 } 466 }]dnl 467 ]) 468 469 470 # b4_yy_symbol_print_generate(FUNCTION-DECLARATOR) 471 # ------------------------------------------------ 472 # Generate the "yy_symbol_print" function, which declaration is issued using 473 # FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C 474 # or "b4_c_function_def" for K&R. 475 m4_define_default([b4_yy_symbol_print_generate], 476 [[ 477 /*--------------------------------. 478 | Print this symbol on YYOUTPUT. | 479 `--------------------------------*/ 480 481 /*ARGSUSED*/ 482 ]$1([yy_symbol_value_print], 483 [static void], 484 [[FILE *yyoutput], [yyoutput]], 485 [[int yytype], [yytype]], 486 [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl 487 b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl 488 m4_ifset([b4_parse_param], [, b4_parse_param]))[ 489 { 490 if (!yyvaluep) 491 return; 492 ]b4_locations_if([ YYUSE (yylocationp); 493 ])dnl 494 b4_parse_param_use[]dnl 495 [# ifdef YYPRINT 496 if (yytype < YYNTOKENS) 497 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 498 # else 499 YYUSE (yyoutput); 500 # endif 501 switch (yytype) 502 { 503 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl 504 [ default: 505 break; 506 } 507 } 508 509 510 /*--------------------------------. 511 | Print this symbol on YYOUTPUT. | 512 `--------------------------------*/ 513 514 ]$1([yy_symbol_print], 515 [static void], 516 [[FILE *yyoutput], [yyoutput]], 517 [[int yytype], [yytype]], 518 [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl 519 b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl 520 m4_ifset([b4_parse_param], [, b4_parse_param]))[ 521 { 522 if (yytype < YYNTOKENS) 523 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 524 else 525 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 526 527 ]b4_locations_if([ YY_LOCATION_PRINT (yyoutput, *yylocationp); 528 YYFPRINTF (yyoutput, ": "); 529 ])dnl 530 [ yy_symbol_value_print (yyoutput, yytype, yyvaluep]dnl 531 b4_locations_if([, yylocationp])[]b4_user_args[); 532 YYFPRINTF (yyoutput, ")"); 533 }]dnl 534 ]) 535
