data/c.m4

   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 ## Default values.  ##
  86 ## ---------------- ##
  87
  88 m4_define_default([b4_epilogue], [])
  89
  90 # If the %union is not named, its name is YYSTYPE.
  91 m4_define_default([b4_union_name], [YYSTYPE])
  92
  93 # The initial column and line.
  94 m4_define_default([b4_location_initial_column], [1])
  95 m4_define_default([b4_location_initial_line],   [1])
  96
  97
  98 ## ------------------------ ##
  99 ## Pure/impure interfaces.  ##
 100 ## ------------------------ ##
 101
 102 # b4_user_args
 103 # ------------
 104 m4_define([b4_user_args],
 105 [m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])])
 106
 107
 108 # b4_parse_param
 109 # --------------
 110 # If defined, b4_parse_param arrives double quoted, but below we prefer
 111 # it to be single quoted.
 112 m4_define_default([b4_parse_param])
 113 m4_define([b4_parse_param],
 114 b4_parse_param))
 115
 116
 117 # b4_parse_param_for(DECL, FORMAL, BODY)
 118 # ---------------------------------------
 119 # Iterate over the user parameters, binding the declaration to DECL,
 120 # the formal name to FORMAL, and evaluating the BODY.
 121 m4_define([b4_parse_param_for],
 122 [m4_foreach([$1_$2], m4_defn([b4_parse_param]),
 123 [m4_pushdef([$1], m4_fst($1_$2))dnl
 124 m4_pushdef([$2], m4_shift($1_$2))dnl
 125 $3[]dnl
 126 m4_popdef([$2])dnl
 127 m4_popdef([$1])dnl
 128 ])])
 129
 130 # b4_parse_param_use
 131 # ------------------
 132 # `YYUSE' all the parse-params.
 133 m4_define([b4_parse_param_use],
 134 [b4_parse_param_for([Decl], [Formal], [  YYUSE (Formal);
 135 ])dnl
 136 ])
 137
 138
 139 ## ------------ ##
 140 ## Data Types.  ##
 141 ## ------------ ##
 142
 143 # b4_ints_in(INT1, INT2, LOW, HIGH)
 144 # ---------------------------------
 145 # Return 1 iff both INT1 and INT2 are in [LOW, HIGH], 0 otherwise.
 146 m4_define([b4_ints_in],
 147 [m4_eval([$3 <= $1 && $1 <= $4 && $3 <= $2 && $2 <= $4])])
 148
 149
 150 # b4_int_type(MIN, MAX)
 151 # ---------------------
 152 # Return the smallest int type able to handle numbers ranging from
 153 # MIN to MAX (included).
 154 m4_define([b4_int_type],
 155 [m4_if(b4_ints_in($@,      [0],   [255]), [1], [unsigned char],
 156        b4_ints_in($@,   [-128],   [127]), [1], [signed char],
 157
 158        b4_ints_in($@,      [0], [65535]), [1], [unsigned short int],
 159        b4_ints_in($@, [-32768], [32767]), [1], [short int],
 160
 161        m4_eval([0 <= $1]),                [1], [unsigned int],
 162
 163                                                [int])])
 164
 165
 166 # b4_int_type_for(NAME)
 167 # ---------------------
 168 # Return the smallest int type able to handle numbers ranging from
 169 # `NAME_min' to `NAME_max' (included).
 170 m4_define([b4_int_type_for],
 171 [b4_int_type($1_min, $1_max)])
 172
 173
 174 ## ---------##
 175 ## Values.  ##
 176 ## ---------##
 177
 178 # b4_null
 179 ---------
 180 # Return a null pointer constant.  NULL infringes on the user name
 181 # space in C, so use 0 rather than NULL.
 182 m4_define([b4_null], [0])
 183
 184
 185 ## ------------------ ##
 186 ## Decoding options.  ##
 187 ## ------------------ ##
 188
 189 # b4_flag_if(FLAG, IF-TRUE, IF-FALSE)
 190 # -----------------------------------
 191 # Run IF-TRUE if b4_FLAG_flag is 1, IF-FALSE if FLAG is 0, otherwise fail.
 192 m4_define([b4_flag_if],
 193 [m4_case(b4_$1_flag,
 194          [0], [$3],
 195          [1], [$2],
 196          [m4_fatal([invalid $1 value: ]$1)])])
 197
 198
 199 # b4_define_flag_if(FLAG)
 200 # -----------------------
 201 # Define "b4_FLAG_if(IF-TRUE, IF-FALSE)" that depends on the
 202 # value of the Boolean FLAG.
 203 m4_define([b4_define_flag_if],
 204 [_b4_define_flag_if($[1], $[2], [$1])])
 205
 206 # _b4_define_flag_if($1, $2, FLAG)
 207 # --------------------------------
 208 # This macro works around the impossibility to define macros
 209 # inside macros, because issuing `[$1]' is not possible in M4 :(.
 210 # This sucks hard, GNU M4 should really provide M5 like $$1.
 211 m4_define([_b4_define_flag_if],
 212 [m4_if([$1$2], $[1]$[2], [],
 213        [m4_fatal([$0: Invalid arguments: $@])])dnl
 214 m4_define([b4_$3_if],
 215           [b4_flag_if([$3], [$1], [$2])])])
 216
 217
 218 # b4_FLAG_if(IF-TRUE, IF-FALSE)
 219 # -----------------------------
 220 # Expand IF-TRUE, if FLAG is true, IF-FALSE otherwise.
 221 b4_define_flag_if([defines])        # Whether headers are requested.
 222 b4_define_flag_if([error_verbose])  # Whether error are verbose.
 223 b4_define_flag_if([locations])      # Whether locations are tracked.
 224 b4_define_flag_if([pure])           # Whether the interface is pure.
 225 b4_define_flag_if([yacc])           # Whether POSIX Yacc is emulated.
 226
 227
 228
 229 ## ------------------------- ##
 230 ## Assigning token numbers.  ##
 231 ## ------------------------- ##
 232
 233 # b4_token_define(TOKEN-NAME, TOKEN-NUMBER)
 234 # -----------------------------------------
 235 # Output the definition of this token as #define.
 236 m4_define([b4_token_define],
 237 [#define $1 $2
 238 ])
 239
 240
 241 # b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
 242 # -------------------------------------------------------
 243 # Output the definition of the tokens (if there are) as #defines.
 244 m4_define([b4_token_defines],
 245 [m4_if([$@], [[]], [],
 246 [/* Tokens.  */
 247 m4_map([b4_token_define], [$@])])
 248 ])
 249
 250
 251 # b4_token_enum(TOKEN-NAME, TOKEN-NUMBER)
 252 # ---------------------------------------
 253 # Output the definition of this token as an enum.
 254 m4_define([b4_token_enum],
 255 [$1 = $2])
 256
 257
 258 # b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
 259 # -----------------------------------------------------
 260 # Output the definition of the tokens (if there are) as enums.
 261 m4_define([b4_token_enums],
 262 [m4_if([$@], [[]], [],
 263 [/* Tokens.  */
 264 #ifndef YYTOKENTYPE
 265 # define YYTOKENTYPE
 266    /* Put the tokens into the symbol table, so that GDB and other debuggers
 267       know about them.  */
 268    enum yytokentype {
 269 m4_map_sep([     b4_token_enum], [,
 270 ],
 271            [$@])
 272    };
 273 #endif
 274 ])])
 275
 276
 277 # b4_token_enums_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
 278 # -------------------------------------------------------------
 279 # Output the definition of the tokens (if there are any) as enums and, if POSIX
 280 # Yacc is enabled, as #defines.
 281 m4_define([b4_token_enums_defines],
 282 [b4_token_enums($@)b4_yacc_if([b4_token_defines($@)], [])
 283 ])
 284
 285
 286
 287 ## --------------------------------------------- ##
 288 ## Defining C functions in both K&R and ANSI-C.  ##
 289 ## --------------------------------------------- ##
 290
 291
 292 # b4_modern_c
 293 # -----------
 294 # A predicate useful in #if to determine whether C is ancient or modern.
 295 #
 296 # If __STDC__ is defined, the compiler is modern.  IBM xlc 7.0 when run
 297 # as 'cc' doesn't define __STDC__ (or __STDC_VERSION__) for pedantic
 298 # reasons, but it defines __C99__FUNC__ so check that as well.
 299 # Microsoft C normally doesn't define these macros, but it defines _MSC_VER.
 300 # Consider a C++ compiler to be modern if it defines __cplusplus.
 301 #
 302 m4_define([b4_c_modern],
 303   [[(defined __STDC__ || defined __C99__FUNC__ \
 304      || defined __cplusplus || defined _MSC_VER)]])
 305
 306 # b4_c_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
 307 # ----------------------------------------------------------
 308 # Declare the function NAME.
 309 m4_define([b4_c_function_def],
 310 [#if b4_c_modern
 311 b4_c_ansi_function_def($@)
 312 #else
 313 $2
 314 $1 (b4_c_knr_formal_names(m4_shiftn(2, $@)))
 315 b4_c_knr_formal_decls(m4_shiftn(2, $@))
 316 #endif[]dnl
 317 ])
 318
 319
 320 # b4_c_ansi_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
 321 # ---------------------------------------------------------------
 322 # Declare the function NAME in ANSI.
 323 m4_define([b4_c_ansi_function_def],
 324 [$2
 325 $1 (b4_c_ansi_formals(m4_shiftn(2, $@)))[]dnl
 326 ])
 327
 328
 329 # b4_c_ansi_formals([DECL1, NAME1], ...)
 330 # --------------------------------------
 331 # Output the arguments ANSI-C definition.
 332 m4_define([b4_c_ansi_formals],
 333 [m4_case([$@],
 334          [],   [void],
 335          [[]], [void],
 336                [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])])
 337
 338 m4_define([b4_c_ansi_formal],
 339 [$1])
 340
 341
 342 # b4_c_knr_formal_names([DECL1, NAME1], ...)
 343 # ------------------------------------------
 344 # Output the argument names.
 345 m4_define([b4_c_knr_formal_names],
 346 [m4_map_sep([b4_c_knr_formal_name], [, ], [$@])])
 347
 348 m4_define([b4_c_knr_formal_name],
 349 [$2])
 350
 351
 352 # b4_c_knr_formal_decls([DECL1, NAME1], ...)
 353 # ------------------------------------------
 354 # Output the K&R argument declarations.
 355 m4_define([b4_c_knr_formal_decls],
 356 [m4_map_sep([b4_c_knr_formal_decl],
 357             [
 358 ],
 359             [$@])])
 360
 361 m4_define([b4_c_knr_formal_decl],
 362 [    $1;])
 363
 364
 365
 366 ## ------------------------------------------------------------ ##
 367 ## Declaring (prototyping) C functions in both K&R and ANSI-C.  ##
 368 ## ------------------------------------------------------------ ##
 369
 370
 371 # b4_c_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
 372 # -----------------------------------------------------------
 373 # Declare the function NAME.
 374 m4_define([b4_c_function_decl],
 375 [#if defined __STDC__ || defined __cplusplus
 376 b4_c_ansi_function_decl($@)
 377 #else
 378 $2 $1 ();
 379 #endif[]dnl
 380 ])
 381
 382
 383 # b4_c_ansi_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
 384 # ----------------------------------------------------------------
 385 # Declare the function NAME.
 386 m4_define([b4_c_ansi_function_decl],
 387 [$2 $1 (b4_c_ansi_formals(m4_shiftn(2, $@)));[]dnl
 388 ])
 389
 390
 391
 392
 393 ## --------------------- ##
 394 ## Calling C functions.  ##
 395 ## --------------------- ##
 396
 397
 398 # b4_c_function_call(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
 399 # -----------------------------------------------------------
 400 # Call the function NAME with arguments NAME1, NAME2 etc.
 401 m4_define([b4_c_function_call],
 402 [$1 (b4_c_args(m4_shiftn(2, $@)))[]dnl
 403 ])
 404
 405
 406 # b4_c_args([DECL1, NAME1], ...)
 407 # ------------------------------
 408 # Output the arguments NAME1, NAME2...
 409 m4_define([b4_c_args],
 410 [m4_map_sep([b4_c_arg], [, ], [$@])])
 411
 412 m4_define([b4_c_arg],
 413 [$2])
 414
 415
 416 ## ----------- ##
 417 ## Synclines.  ##
 418 ## ----------- ##
 419
 420 # b4_basename(NAME)
 421 # -----------------
 422 # Similar to POSIX basename; the differences don't matter here.
 423 # Beware that NAME is not evaluated.
 424 m4_define([b4_basename],
 425 [m4_bpatsubst([$1], [^.*/\([^/]+\)/*$], [\1])])
 426
 427
 428 # b4_syncline(LINE, FILE)
 429 # -----------------------
 430 m4_define([b4_syncline],
 431 [b4_flag_if([synclines],
 432 [/* Line __line__ of b4_basename(m4_quote(__file__)).  */
 433 [#]line $1 $2])])
 434
 435
 436 # b4_user_code(USER-CODE)
 437 # -----------------------
 438 # Emit code from the user, ending it with synclines.
 439 m4_define([b4_user_code],
 440 [$1
 441 b4_syncline([@oline@], [@ofile@])])
 442
 443
 444 # b4_define_user_code(MACRO)
 445 # --------------------------
 446 # From b4_MACRO, build b4_user_MACRO that includes the synclines.
 447 m4_define([b4_define_user_code],
 448 [m4_define([b4_user_$1],
 449 [b4_user_code([b4_$1])])])
 450
 451
 452 # b4_user_actions
 453 # b4_user_initial_action
 454 # b4_user_post_prologue
 455 # b4_user_start_header
 456 # b4_user_stype
 457 # ----------------------
 458 # Macros that issue user code, ending with synclines.
 459 b4_define_user_code([actions])
 460 b4_define_user_code([initial_action])
 461 b4_define_user_code([post_prologue])
 462 b4_define_user_code([start_header])
 463 b4_define_user_code([stype])
 464
 465
 466 ## -------------- ##
 467 ## User actions.  ##
 468 ## -------------- ##
 469
 470 # b4_case(LABEL, STATEMENTS)
 471 # --------------------------
 472 m4_define([b4_case],
 473 [  case $1:
 474 $2
 475     break;])
 476
 477 # b4_symbol_actions(FILENAME, LINENO,
 478 #                   SYMBOL-TAG, SYMBOL-NUM,
 479 #                   SYMBOL-ACTION, SYMBOL-TYPENAME)
 480 # -------------------------------------------------
 481 m4_define([b4_symbol_actions],
 482 [m4_pushdef([b4_dollar_dollar],
 483    [m4_ifval([$6], [(yyvaluep->$6)], [(*yyvaluep)])])dnl
 484 m4_pushdef([b4_at_dollar], [(*yylocationp)])dnl
 485       case $4: /* $3 */
 486 b4_syncline([$2], [$1])
 487         $5;
 488 b4_syncline([@oline@], [@ofile@])
 489         break;
 490 m4_popdef([b4_at_dollar])dnl
 491 m4_popdef([b4_dollar_dollar])dnl
 492 ])
 493
 494
 495 # b4_yydestruct_generate(FUNCTION-DECLARATOR)
 496 # -------------------------------------------
 497 # Generate the "yydestruct" function, which declaration is issued using
 498 # FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C
 499 # or "b4_c_function_def" for K&R.
 500 m4_define_default([b4_yydestruct_generate],
 501 [[/*-----------------------------------------------.
 502 | Release the memory associated to this symbol.  |
 503 `-----------------------------------------------*/
 504
 505 /*ARGSUSED*/
 506 ]$1([yydestruct],
 507     [static void],
 508     [[const char *yymsg],    [yymsg]],
 509     [[int yytype],           [yytype]],
 510     [[YYSTYPE *yyvaluep],    [yyvaluep]][]dnl
 511 b4_locations_if(            [, [[YYLTYPE *yylocationp], [yylocationp]]])[]dnl
 512 m4_ifset([b4_parse_param], [, b4_parse_param]))[
 513 {
 514   YYUSE (yyvaluep);
 515 ]b4_locations_if([  YYUSE (yylocationp);
 516 ])dnl
 517 b4_parse_param_use[]dnl
 518 [
 519   if (!yymsg)
 520     yymsg = "Deleting";
 521   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
 522
 523   switch (yytype)
 524     {
 525 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
 526       default:
 527         break;
 528     }
 529 }]dnl
 530 ])
 531
 532
 533 # b4_yy_symbol_print_generate(FUNCTION-DECLARATOR)
 534 # ------------------------------------------------
 535 # Generate the "yy_symbol_print" function, which declaration is issued using
 536 # FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C
 537 # or "b4_c_function_def" for K&R.
 538 m4_define_default([b4_yy_symbol_print_generate],
 539 [[
 540 /*--------------------------------.
 541 | Print this symbol on YYOUTPUT.  |
 542 `--------------------------------*/
 543
 544 /*ARGSUSED*/
 545 ]$1([yy_symbol_value_print],
 546     [static void],
 547                [[FILE *yyoutput],                       [yyoutput]],
 548                [[int yytype],                           [yytype]],
 549                [[YYSTYPE const * const yyvaluep],       [yyvaluep]][]dnl
 550 b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl
 551 m4_ifset([b4_parse_param], [, b4_parse_param]))[
 552 {
 553   if (!yyvaluep)
 554     return;
 555 ]b4_locations_if([  YYUSE (yylocationp);
 556 ])dnl
 557 b4_parse_param_use[]dnl
 558 [# ifdef YYPRINT
 559   if (yytype < YYNTOKENS)
 560     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
 561 # else
 562   YYUSE (yyoutput);
 563 # endif
 564   switch (yytype)
 565     {
 566 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
 567 [      default:
 568         break;
 569     }
 570 }
 571
 572
 573 /*--------------------------------.
 574 | Print this symbol on YYOUTPUT.  |
 575 `--------------------------------*/
 576
 577 ]$1([yy_symbol_print],
 578     [static void],
 579                [[FILE *yyoutput],                       [yyoutput]],
 580                [[int yytype],                           [yytype]],
 581                [[YYSTYPE const * const yyvaluep],       [yyvaluep]][]dnl
 582 b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl
 583 m4_ifset([b4_parse_param], [, b4_parse_param]))[
 584 {
 585   if (yytype < YYNTOKENS)
 586     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
 587   else
 588     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
 589
 590 ]b4_locations_if([  YY_LOCATION_PRINT (yyoutput, *yylocationp);
 591   YYFPRINTF (yyoutput, ": ");
 592 ])dnl
 593 [  yy_symbol_value_print (yyoutput, yytype, yyvaluep]dnl
 594 b4_locations_if([, yylocationp])[]b4_user_args[);
 595   YYFPRINTF (yyoutput, ")");
 596 }]dnl
 597 ])