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 ## ---------------- ##
  86 ## Default values.  ##
  87 ## ---------------- ##
  88
  89 m4_define_default([b4_epilogue], [])
  90
  91
  92
  93 ## ------------------------ ##
  94 ## Pure/impure interfaces.  ##
  95 ## ------------------------ ##
  96
  97
  98 # b4_user_args
  99 # ------------
 100 m4_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.
 108 m4_define_default([b4_parse_param])
 109 m4_define([b4_parse_param],
 110 b4_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.
 117 m4_define([b4_parse_param_for],
 118 [m4_foreach([$1_$2], m4_defn([b4_parse_param]),
 119 [m4_pushdef([$1], m4_fst($1_$2))dnl
 120 m4_pushdef([$2], m4_shift($1_$2))dnl
 121 $3[]dnl
 122 m4_popdef([$2])dnl
 123 m4_popdef([$1])dnl
 124 ])])
 125
 126 # b4_parse_param_use
 127 # ------------------
 128 # `YYUSE' all the parse-params.
 129 m4_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.
 142 m4_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).
 150 m4_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).
 166 m4_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.
 177 m4_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.
 188 m4_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.
 196 m4_define([_b4_define_flag_if],
 197 [m4_if([$1$2], $[1]$[2], [],
 198        [m4_fatal([$0: Invalid arguments: $@])])dnl
 199 m4_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.
 206 b4_define_flag_if([defines])        # Whether headers are requested.
 207 b4_define_flag_if([error_verbose])  # Wheter error are verbose.
 208 b4_define_flag_if([locations])      # Whether locations are tracked.
 209 b4_define_flag_if([pure])           # Whether the interface is pure.
 210 b4_define_flag_if([yacc])           # Whether POSIX Yacc is emulated.
 211
 212
 213
 214 ## ------------------------- ##
 215 ## Assigning token numbers.  ##
 216 ## ------------------------- ##
 217
 218 # b4_token_define(TOKEN-NAME, TOKEN-NUMBER)
 219 # -----------------------------------------
 220 # Output the definition of this token as #define.
 221 m4_define([b4_token_define],
 222 [#define $1 $2
 223 ])
 224
 225
 226 # b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
 227 # -------------------------------------------------------
 228 # Output the definition of the tokens (if there are) as #defines.
 229 m4_define([b4_token_defines],
 230 [m4_if([$@], [[]], [],
 231 [/* Tokens.  */
 232 m4_map([b4_token_define], [$@])])
 233 ])
 234
 235
 236 # b4_token_enum(TOKEN-NAME, TOKEN-NUMBER)
 237 # ---------------------------------------
 238 # Output the definition of this token as an enum.
 239 m4_define([b4_token_enum],
 240 [$1 = $2])
 241
 242
 243 # b4_token_enums(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
 244 # -----------------------------------------------------
 245 # Output the definition of the tokens (if there are) as enums.
 246 m4_define([b4_token_enums],
 247 [m4_if([$@], [[]], [],
 248 [/* Tokens.  */
 249 #ifndef YYTOKENTYPE
 250 # define YYTOKENTYPE
 251    /* Put the tokens into the symbol table, so that GDB and other debuggers
 252       know about them.  */
 253    enum yytokentype {
 254 m4_map_sep([     b4_token_enum], [,
 255 ],
 256            [$@])
 257    };
 258 #endif
 259 ])])
 260
 261
 262 # b4_token_enums_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
 263 # -------------------------------------------------------------
 264 # Output the definition of the tokens (if there are any) as enums and, if POSIX
 265 # Yacc is enabled, as #defines.
 266 m4_define([b4_token_enums_defines],
 267 [b4_token_enums($@)b4_yacc_if([b4_token_defines($@)], [])
 268 ])
 269
 270
 271
 272 ## --------------------------------------------- ##
 273 ## Defining C functions in both K&R and ANSI-C.  ##
 274 ## --------------------------------------------- ##
 275
 276
 277 # b4_modern_c
 278 # -----------
 279 # A predicate useful in #if to determine whether C is ancient or modern.
 280 #
 281 # If __STDC__ is defined, the compiler is modern.  IBM xlc 7.0 when run
 282 # as 'cc' doesn't define __STDC__ (or __STDC_VERSION__) for pedantic
 283 # reasons, but it defines __C99__FUNC__ so check that as well.
 284 # Microsoft C normally doesn't define these macros, but it defines _MSC_VER.
 285 # Consider a C++ compiler to be modern if it defines __cplusplus.
 286 #
 287 m4_define([b4_c_modern],
 288   [[(defined __STDC__ || defined __C99__FUNC__ \
 289      || defined __cplusplus || defined _MSC_VER)]])
 290
 291 # b4_c_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
 292 # ----------------------------------------------------------
 293 # Declare the function NAME.
 294 m4_define([b4_c_function_def],
 295 [#if b4_c_modern
 296 b4_c_ansi_function_def($@)
 297 #else
 298 $2
 299 $1 (b4_c_knr_formal_names(m4_shiftn(2, $@)))
 300 b4_c_knr_formal_decls(m4_shiftn(2, $@))
 301 #endif[]dnl
 302 ])
 303
 304
 305 # b4_c_ansi_function_def(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
 306 # ---------------------------------------------------------------
 307 # Declare the function NAME in ANSI.
 308 m4_define([b4_c_ansi_function_def],
 309 [$2
 310 $1 (b4_c_ansi_formals(m4_shiftn(2, $@)))[]dnl
 311 ])
 312
 313
 314 # b4_c_ansi_formals([DECL1, NAME1], ...)
 315 # --------------------------------------
 316 # Output the arguments ANSI-C definition.
 317 m4_define([b4_c_ansi_formals],
 318 [m4_case([$@],
 319          [],   [void],
 320          [[]], [void],
 321                [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])])
 322
 323 m4_define([b4_c_ansi_formal],
 324 [$1])
 325
 326
 327 # b4_c_knr_formal_names([DECL1, NAME1], ...)
 328 # ------------------------------------------
 329 # Output the argument names.
 330 m4_define([b4_c_knr_formal_names],
 331 [m4_map_sep([b4_c_knr_formal_name], [, ], [$@])])
 332
 333 m4_define([b4_c_knr_formal_name],
 334 [$2])
 335
 336
 337 # b4_c_knr_formal_decls([DECL1, NAME1], ...)
 338 # ------------------------------------------
 339 # Output the K&R argument declarations.
 340 m4_define([b4_c_knr_formal_decls],
 341 [m4_map_sep([b4_c_knr_formal_decl],
 342             [
 343 ],
 344             [$@])])
 345
 346 m4_define([b4_c_knr_formal_decl],
 347 [    $1;])
 348
 349
 350
 351 ## ------------------------------------------------------------ ##
 352 ## Declaring (prototyping) C functions in both K&R and ANSI-C.  ##
 353 ## ------------------------------------------------------------ ##
 354
 355
 356 # b4_c_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
 357 # -----------------------------------------------------------
 358 # Declare the function NAME.
 359 m4_define([b4_c_function_decl],
 360 [#if defined __STDC__ || defined __cplusplus
 361 b4_c_ansi_function_decl($@)
 362 #else
 363 $2 $1 ();
 364 #endif[]dnl
 365 ])
 366
 367
 368 # b4_c_ansi_function_decl(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
 369 # ----------------------------------------------------------------
 370 # Declare the function NAME.
 371 m4_define([b4_c_ansi_function_decl],
 372 [$2 $1 (b4_c_ansi_formals(m4_shiftn(2, $@)));[]dnl
 373 ])
 374
 375
 376
 377
 378 ## --------------------- ##
 379 ## Calling C functions.  ##
 380 ## --------------------- ##
 381
 382
 383 # b4_c_function_call(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
 384 # -----------------------------------------------------------
 385 # Call the function NAME with arguments NAME1, NAME2 etc.
 386 m4_define([b4_c_function_call],
 387 [$1 (b4_c_args(m4_shiftn(2, $@)))[]dnl
 388 ])
 389
 390
 391 # b4_c_args([DECL1, NAME1], ...)
 392 # ------------------------------
 393 # Output the arguments NAME1, NAME2...
 394 m4_define([b4_c_args],
 395 [m4_map_sep([b4_c_arg], [, ], [$@])])
 396
 397 m4_define([b4_c_arg],
 398 [$2])
 399
 400
 401 ## ----------- ##
 402 ## Synclines.  ##
 403 ## ----------- ##
 404
 405 # b4_syncline(LINE, FILE)
 406 # -----------------------
 407 m4_define([b4_syncline],
 408 [b4_flag_if([synclines], [[#]line $1 $2])])
 409
 410
 411
 412 ## -------------- ##
 413 ## User actions.  ##
 414 ## -------------- ##
 415
 416 # b4_symbol_actions(FILENAME, LINENO,
 417 #                   SYMBOL-TAG, SYMBOL-NUM,
 418 #                   SYMBOL-ACTION, SYMBOL-TYPENAME)
 419 # -------------------------------------------------
 420 m4_define([b4_symbol_actions],
 421 [m4_pushdef([b4_dollar_dollar],
 422    [m4_ifval([$6], [(yyvaluep->$6)], [(*yyvaluep)])])dnl
 423 m4_pushdef([b4_at_dollar], [(*yylocationp)])dnl
 424       case $4: /* $3 */
 425 b4_syncline([$2], [$1])
 426         $5;
 427 b4_syncline([@oline@], [@ofile@])
 428         break;
 429 m4_popdef([b4_at_dollar])dnl
 430 m4_popdef([b4_dollar_dollar])dnl
 431 ])
 432
 433
 434 # b4_yydestruct_generate(FUNCTION-DECLARATOR)
 435 # -------------------------------------------
 436 # Generate the "yydestruct" function, which declaration is issued using
 437 # FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C
 438 # or "b4_c_function_def" for K&R.
 439 m4_define_default([b4_yydestruct_generate],
 440 [[/*-----------------------------------------------.
 441 | Release the memory associated to this symbol.  |
 442 `-----------------------------------------------*/
 443
 444 /*ARGSUSED*/
 445 ]$1([yydestruct],
 446     [static void],
 447     [[const char *yymsg],    [yymsg]],
 448     [[int yytype],           [yytype]],
 449     [[YYSTYPE *yyvaluep],    [yyvaluep]][]dnl
 450 b4_locations_if(            [, [[YYLTYPE *yylocationp], [yylocationp]]])[]dnl
 451 m4_ifset([b4_parse_param], [, b4_parse_param]))[
 452 {
 453   YYUSE (yyvaluep);
 454 ]b4_locations_if([  YYUSE (yylocationp);
 455 ])dnl
 456 b4_parse_param_use[]dnl
 457 [
 458   if (!yymsg)
 459     yymsg = "Deleting";
 460   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
 461
 462   switch (yytype)
 463     {
 464 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
 465       default:
 466         break;
 467     }
 468 }]dnl
 469 ])
 470
 471
 472 # b4_yy_symbol_print_generate(FUNCTION-DECLARATOR)
 473 # ------------------------------------------------
 474 # Generate the "yy_symbol_print" function, which declaration is issued using
 475 # FUNCTION-DECLARATOR, which may be "b4_c_ansi_function_def" for ISO C
 476 # or "b4_c_function_def" for K&R.
 477 m4_define_default([b4_yy_symbol_print_generate],
 478 [[
 479 /*--------------------------------.
 480 | Print this symbol on YYOUTPUT.  |
 481 `--------------------------------*/
 482
 483 /*ARGSUSED*/
 484 ]$1([yy_symbol_value_print],
 485     [static void],
 486                [[FILE *yyoutput],                       [yyoutput]],
 487                [[int yytype],                           [yytype]],
 488                [[YYSTYPE const * const yyvaluep],       [yyvaluep]][]dnl
 489 b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl
 490 m4_ifset([b4_parse_param], [, b4_parse_param]))[
 491 {
 492   if (!yyvaluep)
 493     return;
 494 ]b4_locations_if([  YYUSE (yylocationp);
 495 ])dnl
 496 b4_parse_param_use[]dnl
 497 [# ifdef YYPRINT
 498   if (yytype < YYNTOKENS)
 499     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
 500 # else
 501   YYUSE (yyoutput);
 502 # endif
 503   switch (yytype)
 504     {
 505 ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
 506 [      default:
 507         break;
 508     }
 509 }
 510
 511
 512 /*--------------------------------.
 513 | Print this symbol on YYOUTPUT.  |
 514 `--------------------------------*/
 515
 516 ]$1([yy_symbol_print],
 517     [static void],
 518                [[FILE *yyoutput],                       [yyoutput]],
 519                [[int yytype],                           [yytype]],
 520                [[YYSTYPE const * const yyvaluep],       [yyvaluep]][]dnl
 521 b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl
 522 m4_ifset([b4_parse_param], [, b4_parse_param]))[
 523 {
 524   if (yytype < YYNTOKENS)
 525     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
 526   else
 527     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
 528
 529 ]b4_locations_if([  YY_LOCATION_PRINT (yyoutput, *yylocationp);
 530   YYFPRINTF (yyoutput, ": ");
 531 ])dnl
 532 [  yy_symbol_value_print (yyoutput, yytype, yyvaluep]dnl
 533 b4_locations_if([, yylocationp])[]b4_user_args[);
 534   YYFPRINTF (yyoutput, ")");
 535 }]dnl
 536 ])