1m4_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# -------------------------- 28m4_define([b4_copyright], 29[/* A Bison parser, made by GNU Bison b4_version. */ 30 31/* $1 32 33m4_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# ----------------- 66m4_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 89m4_define_default([b4_epilogue], []) 90 91 92 93## ------------------------ ## 94## Pure/impure interfaces. ## 95## ------------------------ ## 96 97 98# b4_user_args 99# ------------ 100m4_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. 108m4_define_default([b4_parse_param]) 109m4_define([b4_parse_param], 110b4_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. 117m4_define([b4_parse_param_for], 118[m4_foreach([$1_$2], m4_defn([b4_parse_param]), 119[m4_pushdef([$1], m4_fst($1_$2))dnl 120m4_pushdef([$2], m4_shift($1_$2))dnl 121$3[]dnl 122m4_popdef([$2])dnl 123m4_popdef([$1])dnl 124])]) 125 126# b4_parse_param_use 127# ------------------ 128# `YYUSE' all the parse-params. 129m4_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. 142m4_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). 150m4_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). 166m4_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. 177m4_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. 188m4_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. 196m4_define([_b4_define_flag_if], 197[m4_if([$1$2], $[1]$[2], [], 198 [m4_fatal([$0: Invalid arguments: $@])])dnl 199m4_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. 206b4_define_flag_if([defines]) # Whether headers are requested. 207b4_define_flag_if([error_verbose]) # Wheter error are verbose. 208b4_define_flag_if([locations]) # Whether locations are tracked. 209b4_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. 220m4_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. 228m4_define([b4_token_defines], 229[m4_if([$@], [[]], [], 230[/* Tokens. */ 231m4_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. 238m4_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. 245m4_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 { 253m4_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. 264m4_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# 285m4_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. 292m4_define([b4_c_function_def], 293[#if b4_c_modern 294b4_c_ansi_function_def($@) 295#else 296$2 297$1 (b4_c_knr_formal_names(m4_shiftn(2, $@))) 298b4_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. 306m4_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. 315m4_define([b4_c_ansi_formals], 316[m4_case([$@], 317 [], [void], 318 [[]], [void], 319 [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])]) 320 321m4_define([b4_c_ansi_formal], 322[$1]) 323 324 325# b4_c_knr_formal_names([DECL1, NAME1], ...) 326# ------------------------------------------ 327# Output the argument names. 328m4_define([b4_c_knr_formal_names], 329[m4_map_sep([b4_c_knr_formal_name], [, ], [$@])]) 330 331m4_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. 338m4_define([b4_c_knr_formal_decls], 339[m4_map_sep([b4_c_knr_formal_decl], 340 [ 341], 342 [$@])]) 343 344m4_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. 357m4_define([b4_c_function_decl], 358[#if defined __STDC__ || defined __cplusplus 359b4_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. 369m4_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. 384m4_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... 392m4_define([b4_c_args], 393[m4_map_sep([b4_c_arg], [, ], [$@])]) 394 395m4_define([b4_c_arg], 396[$2]) 397 398 399## ----------- ## 400## Synclines. ## 401## ----------- ## 402 403# b4_syncline(LINE, FILE) 404# ----------------------- 405m4_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# ------------------------------------------------- 418m4_define([b4_symbol_actions], 419[m4_pushdef([b4_dollar_dollar], 420 [m4_ifval([$6], [(yyvaluep->$6)], [(*yyvaluep)])])dnl 421m4_pushdef([b4_at_dollar], [(*yylocationp)])dnl 422 case $4: /* $3 */ 423b4_syncline([$2], [$1]) 424 $5; 425b4_syncline([@oline@], [@ofile@]) 426 break; 427m4_popdef([b4_at_dollar])dnl 428m4_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. 437m4_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 448b4_locations_if( [, [[YYLTYPE *yylocationp], [yylocationp]]])[]dnl 449m4_ifset([b4_parse_param], [, b4_parse_param]))[ 450{ 451 YYUSE (yyvaluep); 452]b4_locations_if([ YYUSE (yylocationp); 453])dnl 454b4_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. 475m4_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 487b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl 488m4_ifset([b4_parse_param], [, b4_parse_param]))[ 489{ 490 if (!yyvaluep) 491 return; 492]b4_locations_if([ YYUSE (yylocationp); 493])dnl 494b4_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 519b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl 520m4_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 531b4_locations_if([, yylocationp])[]b4_user_args[); 532 YYFPRINTF (yyoutput, ")"); 533}]dnl 534]) 535