OLD | NEW |
(Empty) | |
| 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 ## --------------------------------------------- ## |
| 210 ## Defining C functions in both K&R and ANSI-C. ## |
| 211 ## --------------------------------------------- ## |
| 212 |
| 213 |
| 214 # b4_modern_c |
| 215 # ----------- |
| 216 # A predicate useful in #if to determine whether C is ancient or modern. |
| 217 # |
| 218 # If __STDC__ is defined, the compiler is modern. IBM xlc 7.0 when run |
| 219 # as 'cc' doesn't define __STDC__ (or __STDC_VERSION__) for pedantic |
| 220 # reasons, but it defines __C99__FUNC__ so check that as well. |
| 221 # Microsoft C normally doesn't define these macros, but it defines _MSC_VER. |
| 222 # Consider a C++ compiler to be modern if it defines __cplusplus. |
| 223 # |
| 224 m4_define([b4_c_modern], |
| 225 [[(defined __STDC__ || defined __C99__FUNC__ \ |
| 226 || defined __cplusplus || defined _MSC_VER)]]) |
| 227 |
| 228 # b4_c_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...) |
| 229 # ---------------------------------------------------------- |
| 230 # Declare the function NAME. |
| 231 m4_define([b4_c_function_def], |
| 232 [#if b4_c_modern |
| 233 b4_c_ansi_function_def($@) |
| 234 #else |
| 235 $2 |
| 236 $1 (b4_c_knr_formal_names(m4_shift2($@))) |
| 237 b4_c_knr_formal_decls(m4_shift2($@)) |
| 238 #endif[]dnl |
| 239 ]) |
| 240 |
| 241 |
| 242 # b4_c_ansi_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...) |
| 243 # --------------------------------------------------------------- |
| 244 # Declare the function NAME in ANSI. |
| 245 m4_define([b4_c_ansi_function_def], |
| 246 [$2 |
| 247 $1 (b4_c_ansi_formals(m4_shift2($@)))[]dnl |
| 248 ]) |
| 249 |
| 250 |
| 251 # b4_c_ansi_formals([DECL1, NAME1], ...) |
| 252 # -------------------------------------- |
| 253 # Output the arguments ANSI-C definition. |
| 254 m4_define([b4_c_ansi_formals], |
| 255 [m4_if([$#], [0], [void], |
| 256 [$#$1], [1], [void], |
| 257 [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])]) |
| 258 |
| 259 m4_define([b4_c_ansi_formal], |
| 260 [$1]) |
| 261 |
| 262 |
| 263 # b4_c_knr_formal_names([DECL1, NAME1], ...) |
| 264 # ------------------------------------------ |
| 265 # Output the argument names. |
| 266 m4_define([b4_c_knr_formal_names], |
| 267 [m4_map_sep([b4_c_knr_formal_name], [, ], [$@])]) |
| 268 |
| 269 m4_define([b4_c_knr_formal_name], |
| 270 [$2]) |
| 271 |
| 272 |
| 273 # b4_c_knr_formal_decls([DECL1, NAME1], ...) |
| 274 # ------------------------------------------ |
| 275 # Output the K&R argument declarations. |
| 276 m4_define([b4_c_knr_formal_decls], |
| 277 [m4_map_sep([b4_c_knr_formal_decl], |
| 278 [ |
| 279 ], |
| 280 [$@])]) |
| 281 |
| 282 m4_define([b4_c_knr_formal_decl], |
| 283 [ $1;]) |
| 284 |
| 285 |
| 286 |
| 287 ## ------------------------------------------------------------ ## |
| 288 ## Declaring (prototyping) C functions in both K&R and ANSI-C. ## |
| 289 ## ------------------------------------------------------------ ## |
| 290 |
| 291 |
| 292 # b4_c_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...) |
| 293 # ----------------------------------------------------------- |
| 294 # Declare the function NAME. |
| 295 m4_define([b4_c_function_decl], |
| 296 [#if defined __STDC__ || defined __cplusplus |
| 297 b4_c_ansi_function_decl($@) |
| 298 #else |
| 299 $2 $1 (); |
| 300 #endif[]dnl |
| 301 ]) |
| 302 |
| 303 |
| 304 # b4_c_ansi_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...) |
| 305 # ---------------------------------------------------------------- |
| 306 # Declare the function NAME. |
| 307 m4_define([b4_c_ansi_function_decl], |
| 308 [$2 $1 (b4_c_ansi_formals(m4_shift2($@)));[]dnl |
| 309 ]) |
| 310 |
| 311 |
| 312 |
| 313 |
| 314 ## --------------------- ## |
| 315 ## Calling C functions. ## |
| 316 ## --------------------- ## |
| 317 |
| 318 |
| 319 # b4_c_function_call(NAME, RETURN-VALUE, [DECL1, NAME1], ...) |
| 320 # ----------------------------------------------------------- |
| 321 # Call the function NAME with arguments NAME1, NAME2 etc. |
| 322 m4_define([b4_c_function_call], |
| 323 [$1 (b4_c_args(m4_shift2($@)))[]dnl |
| 324 ]) |
| 325 |
| 326 |
| 327 # b4_c_args([DECL1, NAME1], ...) |
| 328 # ------------------------------ |
| 329 # Output the arguments NAME1, NAME2... |
| 330 m4_define([b4_c_args], |
| 331 [m4_map_sep([b4_c_arg], [, ], [$@])]) |
| 332 |
| 333 m4_define([b4_c_arg], |
| 334 [$2]) |
| 335 |
| 336 |
| 337 ## ----------- ## |
| 338 ## Synclines. ## |
| 339 ## ----------- ## |
| 340 |
| 341 # b4_sync_start(LINE, FILE) |
| 342 # ----------------------- |
| 343 m4_define([b4_sync_start], [[#]line $1 $2]) |
| 344 |
| 345 |
| 346 ## -------------- ## |
| 347 ## User actions. ## |
| 348 ## -------------- ## |
| 349 |
| 350 # b4_case(LABEL, STATEMENTS) |
| 351 # -------------------------- |
| 352 m4_define([b4_case], |
| 353 [ case $1: |
| 354 $2 |
| 355 break;]) |
| 356 |
| 357 # b4_symbol_actions(FILENAME, LINENO, |
| 358 # SYMBOL-TAG, SYMBOL-NUM, |
| 359 # SYMBOL-ACTION, SYMBOL-TYPENAME) |
| 360 # ------------------------------------------------- |
| 361 m4_define([b4_symbol_actions], |
| 362 [m4_pushdef([b4_dollar_dollar], |
| 363 [m4_ifval([$6], [(yyvaluep->$6)], [(*yyvaluep)])])dnl |
| 364 m4_pushdef([b4_at_dollar], [(*yylocationp)])dnl |
| 365 case $4: /* $3 */ |
| 366 b4_syncline([$2], [$1]) |
| 367 $5; |
| 368 b4_syncline([@oline@], [@ofile@]) |
| 369 break; |
| 370 m4_popdef([b4_at_dollar])dnl |
| 371 m4_popdef([b4_dollar_dollar])dnl |
| 372 ]) |
| 373 |
| 374 |
| 375 # b4_yydestruct_generate(FUNCTION-DECLARATOR) |
| 376 # ------------------------------------------- |
| 377 # Generate the "yydestruct" function, which declaration is issued using |
| 378 # FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C |
| 379 # or "b4_c_function_def" for K&R. |
| 380 m4_define_default([b4_yydestruct_generate], |
| 381 [[/*-----------------------------------------------. |
| 382 | Release the memory associated to this symbol. | |
| 383 `-----------------------------------------------*/ |
| 384 |
| 385 /*ARGSUSED*/ |
| 386 ]$1([yydestruct], |
| 387 [static void], |
| 388 [[const char *yymsg], [yymsg]], |
| 389 [[int yytype], [yytype]], |
| 390 [[YYSTYPE *yyvaluep], [yyvaluep]][]dnl |
| 391 b4_locations_if( [, [[YYLTYPE *yylocationp], [yylocationp]]])[]dnl |
| 392 m4_ifset([b4_parse_param], [, b4_parse_param]))[ |
| 393 { |
| 394 YYUSE (yyvaluep); |
| 395 ]b4_locations_if([ YYUSE (yylocationp); |
| 396 ])dnl |
| 397 b4_parse_param_use[]dnl |
| 398 [ |
| 399 if (!yymsg) |
| 400 yymsg = "Deleting"; |
| 401 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); |
| 402 |
| 403 switch (yytype) |
| 404 { |
| 405 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[ |
| 406 default: |
| 407 break; |
| 408 } |
| 409 }]dnl |
| 410 ]) |
| 411 |
| 412 |
| 413 # b4_yy_symbol_print_generate(FUNCTION-DECLARATOR) |
| 414 # ------------------------------------------------ |
| 415 # Generate the "yy_symbol_print" function, which declaration is issued using |
| 416 # FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C |
| 417 # or "b4_c_function_def" for K&R. |
| 418 m4_define_default([b4_yy_symbol_print_generate], |
| 419 [[ |
| 420 /*--------------------------------. |
| 421 | Print this symbol on YYOUTPUT. | |
| 422 `--------------------------------*/ |
| 423 |
| 424 /*ARGSUSED*/ |
| 425 ]$1([yy_symbol_value_print], |
| 426 [static void], |
| 427 [[FILE *yyoutput], [yyoutput]], |
| 428 [[int yytype], [yytype]], |
| 429 [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl |
| 430 b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl |
| 431 m4_ifset([b4_parse_param], [, b4_parse_param]))[ |
| 432 { |
| 433 if (!yyvaluep) |
| 434 return; |
| 435 ]b4_locations_if([ YYUSE (yylocationp); |
| 436 ])dnl |
| 437 b4_parse_param_use[]dnl |
| 438 [# ifdef YYPRINT |
| 439 if (yytype < YYNTOKENS) |
| 440 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); |
| 441 # else |
| 442 YYUSE (yyoutput); |
| 443 # endif |
| 444 switch (yytype) |
| 445 { |
| 446 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl |
| 447 [ default: |
| 448 break; |
| 449 } |
| 450 } |
| 451 |
| 452 |
| 453 /*--------------------------------. |
| 454 | Print this symbol on YYOUTPUT. | |
| 455 `--------------------------------*/ |
| 456 |
| 457 ]$1([yy_symbol_print], |
| 458 [static void], |
| 459 [[FILE *yyoutput], [yyoutput]], |
| 460 [[int yytype], [yytype]], |
| 461 [[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl |
| 462 b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl |
| 463 m4_ifset([b4_parse_param], [, b4_parse_param]))[ |
| 464 { |
| 465 if (yytype < YYNTOKENS) |
| 466 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); |
| 467 else |
| 468 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); |
| 469 |
| 470 ]b4_locations_if([ YY_LOCATION_PRINT (yyoutput, *yylocationp); |
| 471 YYFPRINTF (yyoutput, ": "); |
| 472 ])dnl |
| 473 [ yy_symbol_value_print (yyoutput, yytype, yyvaluep]dnl |
| 474 b4_locations_if([, yylocationp])[]b4_user_args[); |
| 475 YYFPRINTF (yyoutput, ")"); |
| 476 }]dnl |
| 477 ]) |
OLD | NEW |