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 20m4_include(b4_pkgdatadir/[c-like.m4]) 21 22# b4_tocpp(STRING) 23# ---------------- 24# Convert STRING into a valid C macro name. 25m4_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. 32m4_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. 40m4_define([b4_cpp_guard_open], 41[m4_ifval(m4_quote($1), 42[#ifndef b4_cpp_guard([$1]) 43# define b4_cpp_guard([$1])])]) 44 45m4_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# ---------------- 56m4_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. 65m4_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 93b4_percent_define_default([[api.prefix]], [[yy]]) 94m4_define([b4_api_prefix], 95[b4_percent_define_get([[api.prefix]])]) 96m4_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. 103m4_define_default([b4_prefix], [b4_api_prefix]) 104 105# If the %union is not named, its name is YYSTYPE. 106m4_define_default([b4_union_name], [b4_api_PREFIX[]STYPE]) 107 108 109## ------------------------ ## 110## Pure/impure interfaces. ## 111## ------------------------ ## 112 113# b4_user_args 114# ------------ 115m4_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. 123m4_define([b4_parse_param], 124b4_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. 131m4_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 134m4_pushdef([$2], m4_shift($1_$2))dnl 135$3[]dnl 136m4_popdef([$2])dnl 137m4_popdef([$1])dnl 138])]) 139 140# b4_parse_param_use 141# ------------------ 142# `YYUSE' all the parse-params. 143m4_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). 157m4_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). 173m4_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. 183m4_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). 199m4_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. 213m4_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. 224m4_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. 232m4_define([b4_token_defines], 233[m4_if([$#$1], [1], [], 234[/* Tokens. */ 235m4_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. 242m4_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. 249m4_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. 269m4_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# 290m4_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. 297m4_define([b4_c_function_def], 298[#if b4_c_modern 299b4_c_ansi_function_def($@) 300#else 301$2 302$1 (b4_c_knr_formal_names(m4_shift2($@))) 303b4_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. 311m4_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. 320m4_define([b4_c_ansi_formals], 321[m4_if([$#], [0], [void], 322 [$#$1], [1], [void], 323 [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])]) 324 325m4_define([b4_c_ansi_formal], 326[$1]) 327 328 329# b4_c_knr_formal_names([DECL1, NAME1], ...) 330# ------------------------------------------ 331# Output the argument names. 332m4_define([b4_c_knr_formal_names], 333[m4_map_sep([b4_c_knr_formal_name], [, ], [$@])]) 334 335m4_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. 342m4_define([b4_c_knr_formal_decls], 343[m4_map_sep([b4_c_knr_formal_decl], 344 [ 345], 346 [$@])]) 347 348m4_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. 361m4_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. 370m4_define([b4_c_function_decl], 371[#if defined __STDC__ || defined __cplusplus 372b4_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. 388m4_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... 396m4_define([b4_c_args], 397[m4_map_sep([b4_c_arg], [, ], [$@])]) 398 399m4_define([b4_c_arg], 400[$2]) 401 402 403## ----------- ## 404## Synclines. ## 405## ----------- ## 406 407# b4_sync_start(LINE, FILE) 408# ----------------------- 409m4_define([b4_sync_start], [[#]line $1 $2]) 410 411 412## -------------- ## 413## User actions. ## 414## -------------- ## 415 416# b4_case(LABEL, STATEMENTS) 417# -------------------------- 418m4_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. 431m4_define([b4_symbol_actions], 432[b4_dollar_pushdef([(*yyvaluep)], [$6], [(*yylocationp)])dnl 433 case $4: /* $3 */ 434b4_syncline([$2], [$1]) 435 $5; 436b4_syncline([@oline@], [@ofile@]) 437 break; 438b4_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. 447m4_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 458b4_locations_if( [, [[YYLTYPE *yylocationp], [yylocationp]]])[]dnl 459m4_ifset([b4_parse_param], [, b4_parse_param]))[ 460{ 461 YYUSE (yyvaluep); 462]b4_locations_if([ YYUSE (yylocationp); 463])dnl 464b4_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. 485m4_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 497b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl 498m4_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 506b4_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 531b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl 532m4_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 543b4_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. 556m4_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 572typedef 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 584b4_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# ------------------ 590m4_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# ------------------ 611m4_define([b4_declare_yydebug], 612[b4_YYDEBUG_define[ 613#if ]b4_api_PREFIX[DEBUG 614extern int ]b4_prefix[debug; 615#endif][]dnl 616]) 617 618# b4_yylloc_default_define 619# ------------------------ 620# Define YYLLOC_DEFAULT. 621m4_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. 650m4_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. 705m4_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