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
 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.
 220 m4_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.
 228 m4_define([b4_token_defines],
 229 [m4_if([$@], [[]], [],
 230 [/* Tokens.  */
 231 m4_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.
 238 m4_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.
 245 m4_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 {
 253 m4_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.
 264 m4_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 #
 285 m4_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.
 292 m4_define([b4_c_function_def],
 293 [#if b4_c_modern
 294 b4_c_ansi_function_def($@)
 295 #else
 296 $2
 297 $1 (b4_c_knr_formal_names(m4_shiftn(2, $@)))
 298 b4_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.
 306 m4_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.
 315 m4_define([b4_c_ansi_formals],
 316 [m4_case([$@],
 317          [],   [void],
 318          [[]], [void],
 319                [m4_map_sep([b4_c_ansi_formal], [, ], [$@])])])
 320
 321 m4_define([b4_c_ansi_formal],
 322 [$1])
 323
 324
 325 # b4_c_knr_formal_names([DECL1, NAME1], ...)
 326 # ------------------------------------------
 327 # Output the argument names.
 328 m4_define([b4_c_knr_formal_names],
 329 [m4_map_sep([b4_c_knr_formal_name], [, ], [$@])])
 330
 331 m4_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.
 338 m4_define([b4_c_knr_formal_decls],
 339 [m4_map_sep([b4_c_knr_formal_decl],
 340             [
 341 ],
 342             [$@])])
 343
 344 m4_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.
 357 m4_define([b4_c_function_decl],
 358 [#if defined __STDC__ || defined __cplusplus
 359 b4_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.
 369 m4_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.
 384 m4_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...
 392 m4_define([b4_c_args],
 393 [m4_map_sep([b4_c_arg], [, ], [$@])])
 394
 395 m4_define([b4_c_arg],
 396 [$2])
 397
 398
 399 ## ----------- ##
 400 ## Synclines.  ##
 401 ## ----------- ##
 402
 403 # b4_syncline(LINE, FILE)
 404 # -----------------------
 405 m4_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 # -------------------------------------------------
 418 m4_define([b4_symbol_actions],
 419 [m4_pushdef([b4_dollar_dollar],
 420    [m4_ifval([$6], [(yyvaluep->$6)], [(*yyvaluep)])])dnl
 421 m4_pushdef([b4_at_dollar], [(*yylocationp)])dnl
 422       case $4: /* $3 */
 423 b4_syncline([$2], [$1])
 424         $5;
 425 b4_syncline([@oline@], [@ofile@])
 426         break;
 427 m4_popdef([b4_at_dollar])dnl
 428 m4_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.
 437 m4_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
 448 b4_locations_if(            [, [[YYLTYPE *yylocationp], [yylocationp]]])[]dnl
 449 m4_ifset([b4_parse_param], [, b4_parse_param]))[
 450 {
 451   YYUSE (yyvaluep);
 452 ]b4_locations_if([  YYUSE (yylocationp);
 453 ])dnl
 454 b4_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.
 475 m4_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
 487 b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl
 488 m4_ifset([b4_parse_param], [, b4_parse_param]))[
 489 {
 490   if (!yyvaluep)
 491     return;
 492 ]b4_locations_if([  YYUSE (yylocationp);
 493 ])dnl
 494 b4_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
 519 b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl
 520 m4_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
 531 b4_locations_if([, yylocationp])[]b4_user_args[);
 532   YYFPRINTF (yyoutput, ")");
 533 }]dnl
 534 ])