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