data/bison.m4

   1                                                             -*- Autoconf -*-
   2
   3 # Language-independent 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
  20
  21 ## ---------------- ##
  22 ## Identification.  ##
  23 ## ---------------- ##
  24
  25 # b4_copyright(TITLE, [YEARS])
  26 # ----------------------------
  27 # If YEARS are not defined, use b4_copyright_years.
  28 m4_define([b4_copyright],
  29 [b4_comment([A Bison parser, made by GNU Bison b4_version.])
  30
  31 b4_comment([$1
  32
  33 ]m4_dquote(m4_text_wrap([Copyright (C)
  34 ]m4_ifval([$2], [[$2]], [m4_defn([b4_copyright_years])])[
  35 Free Software Foundation, Inc.]))[
  36
  37 This program is free software: you can redistribute it and/or modify
  38 it under the terms of the GNU General Public License as published by
  39 the Free Software Foundation, either version 3 of the License, or
  40 (at your option) any later version.
  41
  42 This program is distributed in the hope that it will be useful,
  43 but WITHOUT ANY WARRANTY; without even the implied warranty of
  44 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  45 GNU General Public License for more details.
  46
  47 You should have received a copy of the GNU General Public License
  48 along with this program.  If not, see <http://www.gnu.org/licenses/>.])
  49
  50 b4_comment([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 ## -------- ##
  65 ## Output.  ##
  66 ## -------- ##
  67
  68 # b4_output_begin(FILE)
  69 # ---------------------
  70 # Enable output, i.e., send to diversion 0, expand after "#", and
  71 # generate the tag to output into FILE.  Must be followed by EOL.
  72 m4_define([b4_output_begin],
  73 [m4_changecom()
  74 m4_divert_push(0)dnl
  75 @output(m4_unquote([$1])@)@dnl
  76 ])
  77
  78
  79 # b4_output_end()
  80 # ---------------
  81 # Output nothing, restore # as comment character (no expansions after #).
  82 m4_define([b4_output_end],
  83 [m4_divert_pop(0)
  84 m4_changecom([#])
  85 ])
  86
  87
  88 ## ---------------- ##
  89 ## Error handling.  ##
  90 ## ---------------- ##
  91
  92 # The following error handling macros print error directives that should not
  93 # become arguments of other macro invocations since they would likely then be
  94 # mangled.  Thus, they print to stdout directly.
  95
  96 # b4_cat(TEXT)
  97 # ------------
  98 # Write TEXT to stdout.  Precede the final newline with an @ so that it's
  99 # escaped.  For example:
 100 #
 101 #   b4_cat([[@complain(invalid input@)]])
 102 m4_define([b4_cat],
 103 [m4_syscmd([cat <<'_m4eof'
 104 ]m4_bpatsubst(m4_dquote($1), [_m4eof], [_m4@`eof])[@
 105 _m4eof
 106 ])dnl
 107 m4_if(m4_sysval, [0], [], [m4_fatal([$0: cannot write to stdout])])])
 108
 109 # b4_error(KIND, START, END, FORMAT, [ARG1], [ARG2], ...)
 110 # -------------------------------------------------------
 111 # Write @KIND(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout.
 112 #
 113 # For example:
 114 #
 115 #   b4_error([[complain]], [[input.y:2.3]], [[input.y:5.4]],
 116 #            [[invalid %s]], [[foo]])
 117 m4_define([b4_error],
 118 [b4_cat([[@complain][(]$1[@,]$2[@,]$3[@,]$4[]]dnl
 119 [m4_if([$#], [4], [],
 120        [m4_foreach([b4_arg],
 121                    m4_dquote(m4_shift(m4_shift(m4_shift(m4_shift($@))))),
 122                    [[@,]b4_arg])])[@)]])])
 123
 124 # b4_warn(FORMAT, [ARG1], [ARG2], ...)
 125 # ------------------------------------
 126 # Write @warn(FORMAT@,ARG1@,ARG2@,...@) to stdout.
 127 #
 128 # For example:
 129 #
 130 #   b4_warn([[invalid value for '%s': %s]], [[foo]], [[3]])
 131 #
 132 # As a simple test suite, this:
 133 #
 134 #   m4_divert(-1)
 135 #   m4_define([asdf], [ASDF])
 136 #   m4_define([fsa], [FSA])
 137 #   m4_define([fdsa], [FDSA])
 138 #   b4_warn_at([[[asdf), asdf]]], [[[fsa), fsa]]], [[[fdsa), fdsa]]])
 139 #   b4_warn_at([[asdf), asdf]], [[fsa), fsa]], [[fdsa), fdsa]])
 140 #   b4_warn_at()
 141 #   b4_warn_at(1)
 142 #   b4_warn_at(1, 2)
 143 #
 144 # Should produce this without newlines:
 145 #
 146 #   @warn_at([asdf), asdf]@,@,@,[fsa), fsa]@,[fdsa), fdsa]@)
 147 #   @warn(asdf), asdf@,@,@,fsa), fsa@,fdsa), fdsa@)
 148 #   @warn(@)
 149 #   @warn(1@)
 150 #   @warn(1@,2@)
 151 m4_define([b4_warn],
 152 [b4_error([[warn]], [], [], $@)])
 153
 154 # b4_warn_at(START, END, FORMAT, [ARG1], [ARG2], ...)
 155 # ---------------------------------------------------
 156 # Write @warn(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout.
 157 #
 158 # For example:
 159 #
 160 #   b4_warn_at([[input.y:2.3]], [[input.y:5.4]], [[invalid %s]], [[foo]])
 161 m4_define([b4_warn_at],
 162 [b4_error([[warn]], $@)])
 163
 164 # b4_complain(FORMAT, [ARG1], [ARG2], ...)
 165 # ----------------------------------------
 166 # Bounce to b4_complain_at.
 167 #
 168 # See b4_warn example.
 169 m4_define([b4_complain],
 170 [b4_error([[complain]], [], [], $@)])
 171
 172 # b4_complain_at(START, END, FORMAT, [ARG1], [ARG2], ...)
 173 # -------------------------------------------------------
 174 # Write @complain(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout.
 175 #
 176 # See b4_warn_at example.
 177 m4_define([b4_complain_at],
 178 [b4_error([[complain]], $@)])
 179
 180 # b4_fatal(FORMAT, [ARG1], [ARG2], ...)
 181 # -------------------------------------
 182 # Bounce to b4_fatal_at.
 183 #
 184 # See b4_warn example.
 185 m4_define([b4_fatal],
 186 [b4_error([[fatal]], [], [], $@)dnl
 187 m4_exit(1)])
 188
 189 # b4_fatal_at(START, END, FORMAT, [ARG1], [ARG2], ...)
 190 # ----------------------------------------------------
 191 # Write @fatal(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout and exit.
 192 #
 193 # See b4_warn_at example.
 194 m4_define([b4_fatal_at],
 195 [b4_error([[fatal]], $@)dnl
 196 m4_exit(1)])
 197
 198
 199 ## ------------ ##
 200 ## Data Types.  ##
 201 ## ------------ ##
 202
 203 # b4_ints_in(INT1, INT2, LOW, HIGH)
 204 # ---------------------------------
 205 # Return 1 iff both INT1 and INT2 are in [LOW, HIGH], 0 otherwise.
 206 m4_define([b4_ints_in],
 207 [m4_eval([$3 <= $1 && $1 <= $4 && $3 <= $2 && $2 <= $4])])
 208
 209
 210 # b4_subtract(LHS, RHS)
 211 # ---------------------
 212 # Evaluate LHS - RHS if they are integer literals, otherwise expand
 213 # to (LHS) - (RHS).
 214 m4_define([b4_subtract],
 215 [m4_bmatch([$1$2], [^[0123456789]*$],
 216            [m4_eval([$1 - $2])],
 217            [($1) - ($2)])])
 218
 219 # b4_join(ARG1, ...)
 220 # _b4_join(ARG1, ...)
 221 # -------------------
 222 # Join with comma, skipping empty arguments.
 223 # b4_join calls itself recursively until it sees the first non-empty
 224 # argument, then calls _b4_join which prepends each non-empty argument
 225 # with a comma.
 226 m4_define([b4_join],
 227 [m4_if([$#$1],
 228        [1], [],
 229        [m4_ifval([$1],
 230                  [$1[]_$0(m4_shift($@))],
 231                  [$0(m4_shift($@))])])])
 232
 233 # _b4_join(ARGS1, ...)
 234 # --------------------
 235 m4_define([_b4_join],
 236 [m4_if([$#$1],
 237        [1], [],
 238        [m4_ifval([$1], [, $1])[]$0(m4_shift($@))])])
 239
 240
 241
 242
 243 # b4_integral_parser_tables_map(MACRO)
 244 # -------------------------------------
 245 # Map MACRO on all the integral tables.  MACRO is expected to have
 246 # the signature MACRO(TABLE-NAME, CONTENT, COMMENT).
 247 m4_define([b4_integral_parser_tables_map],
 248 [$1([pact], [b4_pact],
 249     [[YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 250 STATE-NUM.]])
 251
 252 $1([defact], [b4_defact],
 253    [[YYDEFACT[S] -- default reduction number in state S.  Performed when
 254 YYTABLE does not specify something else to do.  Zero means the default
 255 is an error.]])
 256
 257 $1([pgoto], [b4_pgoto], [[YYPGOTO[NTERM-NUM].]])
 258
 259 $1([defgoto], [b4_defgoto], [[YYDEFGOTO[NTERM-NUM].]])
 260
 261 $1([table], [b4_table],
 262    [[YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 263 positive, shift that token.  If negative, reduce the rule which
 264 number is the opposite.  If YYTABLE_NINF, syntax error.]])
 265
 266 $1([check], [b4_check])
 267
 268 $1([stos], [b4_stos],
 269    [[STOS_[STATE-NUM] -- The (internal number of the) accessing
 270 symbol of state STATE-NUM.]])
 271
 272 $1([r1], [b4_r1],
 273    [[YYR1[YYN] -- Symbol number of symbol that rule YYN derives.]])
 274
 275 $1([r2], [b4_r2],
 276    [[YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.]])
 277 ])
 278
 279
 280 # b4_parser_tables_declare
 281 # b4_parser_tables_define
 282 # ------------------------
 283 # Define/declare the (deterministic) parser tables.
 284 m4_define([b4_parser_tables_declare],
 285 [b4_integral_parser_tables_map([b4_integral_parser_table_declare])])
 286
 287 m4_define([b4_parser_tables_define],
 288 [b4_integral_parser_tables_map([b4_integral_parser_table_define])])
 289
 290
 291
 292 ## ------------------ ##
 293 ## Decoding options.  ##
 294 ## ------------------ ##
 295
 296 # b4_flag_if(FLAG, IF-TRUE, IF-FALSE)
 297 # -----------------------------------
 298 # Run IF-TRUE if b4_FLAG_flag is 1, IF-FALSE if FLAG is 0, otherwise fail.
 299 m4_define([b4_flag_if],
 300 [m4_case(b4_$1_flag,
 301          [0], [$3],
 302          [1], [$2],
 303          [m4_fatal([invalid $1 value: ]b4_$1_flag)])])
 304
 305
 306 # b4_define_flag_if(FLAG)
 307 # -----------------------
 308 # Define "b4_FLAG_if(IF-TRUE, IF-FALSE)" that depends on the
 309 # value of the Boolean FLAG.
 310 m4_define([b4_define_flag_if],
 311 [_b4_define_flag_if($[1], $[2], [$1])])
 312
 313 # _b4_define_flag_if($1, $2, FLAG)
 314 # --------------------------------
 315 # Work around the impossibility to define macros inside macros,
 316 # because issuing `[$1]' is not possible in M4.  GNU M4 should provide
 317 # $$1 a la M5/TeX.
 318 m4_define([_b4_define_flag_if],
 319 [m4_if([$1$2], $[1]$[2], [],
 320        [m4_fatal([$0: Invalid arguments: $@])])dnl
 321 m4_define([b4_$3_if],
 322           [b4_flag_if([$3], [$1], [$2])])])
 323
 324
 325 # b4_FLAG_if(IF-TRUE, IF-FALSE)
 326 # -----------------------------
 327 # Expand IF-TRUE, if FLAG is true, IF-FALSE otherwise.
 328 b4_define_flag_if([defines])            # Whether headers are requested.
 329 b4_define_flag_if([glr])                # Whether a GLR parser is requested.
 330 b4_define_flag_if([nondeterministic])   # Whether conflicts should be handled.
 331 b4_define_flag_if([token_table])        # Whether yytoken_table is demanded.
 332 b4_define_flag_if([yacc])               # Whether POSIX Yacc is emulated.
 333
 334
 335 ## --------- ##
 336 ## Symbols.  ##
 337 ## --------- ##
 338
 339 # In order to unify the handling of the various aspects of symbols
 340 # (tag, type_name, whether terminal, etc.), bison.exe defines one
 341 # macro per (token, field), where field can has_id, id, etc.: see
 342 # src/output.c:prepare_symbols_definitions().
 343 #
 344 # The following macros provide access to these values.
 345
 346 # b4_symbol_(NUM, FIELD)
 347 # ----------------------
 348 # Recover a FIELD about symbol #NUM.  Thanks to m4_indir, fails if
 349 # undefined.
 350 m4_define([b4_symbol_],
 351 [m4_indir([b4_symbol($1, $2)])])
 352
 353
 354 # b4_symbol(NUM, FIELD)
 355 # ---------------------
 356 # Recover a FIELD about symbol #NUM.  Thanks to m4_indir, fails if
 357 # undefined.  If FIELD = id, prepend the prefix.
 358 m4_define([b4_symbol],
 359 [m4_case([$2],
 360          [id],    [m4_do([b4_percent_define_get([api.token.prefix])],
 361                          [b4_symbol_([$1], [id])])],
 362          [b4_symbol_($@)])])
 363
 364
 365 # b4_symbol_if(NUM, FIELD, IF-TRUE, IF-FALSE)
 366 # -------------------------------------------
 367 # If FIELD about symbol #NUM is 1 expand IF-TRUE, if is 0, expand IF-FALSE.
 368 # Otherwise an error.
 369 m4_define([b4_symbol_if],
 370 [m4_case(b4_symbol([$1], [$2]),
 371          [1], [$3],
 372          [0], [$4],
 373          [m4_fatal([$0: field $2 of $1 is not a Boolean:] b4_symbol([$1], [$2]))])])
 374
 375
 376 # b4_symbol_action_location(SYMBOL-NUM, KIND)
 377 # -------------------------------------------
 378 # Report the location of the KIND action as FILE:LINE.
 379 m4_define([b4_symbol_action_location],
 380 [b4_symbol([$1], [$2_file]):b4_syncline([b4_symbol([$1], [$2_line])])])
 381
 382
 383 # b4_symbol_action(SYMBOL-NUM, KIND)
 384 # ----------------------------------
 385 # Run the action KIND (destructor or printer) for SYMBOL-NUM.
 386 # Same as in C, but using references instead of pointers.
 387 m4_define([b4_symbol_action],
 388 [b4_symbol_if([$1], [has_$2],
 389 [b4_dollar_pushdef([(*yyvaluep)],
 390                    b4_symbol_if([$1], [has_type],
 391                                 [m4_dquote(b4_symbol([$1], [type]))]),
 392                    [(*yylocationp)])dnl
 393       b4_symbol_case_([$1])[]dnl
 394 b4_syncline([b4_symbol([$1], [$2_line])], ["b4_symbol([$1], [$2_file])"])
 395         b4_symbol([$1], [$2])
 396 b4_syncline([@oline@], [@ofile@])
 397         break;
 398
 399 b4_dollar_popdef[]dnl
 400 ])])
 401
 402
 403 # b4_symbol_destructor(SYMBOL-NUM)
 404 # b4_symbol_printer(SYMBOL-NUM)
 405 # --------------------------------
 406 m4_define([b4_symbol_destructor], [b4_symbol_action([$1], [destructor])])
 407 m4_define([b4_symbol_printer],    [b4_symbol_action([$1], [printer])])
 408
 409
 410 # b4_symbol_case_(SYMBOL-NUM)
 411 # ---------------------------
 412 # Issue a "case NUM" for SYMBOL-NUM.
 413 m4_define([b4_symbol_case_],
 414 [      case b4_symbol([$1], [number]): // b4_symbol([$1], [tag])
 415 ])
 416
 417
 418 # b4_symbol_foreach(MACRO)
 419 # ------------------------
 420 # Invoke MACRO(SYMBOL-NUM) for each SYMBOL-NUM.
 421 m4_define([b4_symbol_foreach],
 422           [m4_map([$1], m4_defn([b4_symbol_numbers]))])
 423
 424 # b4_symbol_map(MACRO)
 425 # --------------------
 426 # Return a list (possibly empty elements) of MACRO invoked for each
 427 # SYMBOL-NUM.
 428 m4_define([b4_symbol_map],
 429 [m4_map_args_sep([$1(], [)], [,], b4_symbol_numbers)])
 430
 431
 432 # b4_token_visible_if(NUM, IF-TRUE, IF-FALSE)
 433 # -------------------------------------------
 434 # Whether NUM denotes a token that has an exported definition (i.e.,
 435 # shows in enum yytokentype).
 436 m4_define([b4_token_visible_if],
 437 [b4_symbol_if([$1], [is_token],
 438               [b4_symbol_if([$1], [has_id], [$2], [$3])],
 439               [$3])])
 440
 441 # b4_token_has_definition(NUM)
 442 # ----------------------------
 443 # 1 if NUM is visible, nothing otherwise.
 444 m4_define([b4_token_has_definition],
 445 [b4_token_visible_if([$1], [1])])
 446
 447 # b4_any_token_visible_if([IF-TRUE], [IF-FALSE])
 448 # ----------------------------------------------
 449 # Whether there is a token that needs to be defined.
 450 m4_define([b4_any_token_visible_if],
 451 [m4_ifval(b4_symbol_foreach([b4_token_has_definition]),
 452           [$1], [$2])])
 453
 454
 455 # b4_token_format(FORMAT, NUM)
 456 # ----------------------------
 457 m4_define([b4_token_format],
 458 [b4_token_visible_if([$2],
 459 [m4_quote(m4_format([$1],
 460                      [b4_symbol([$2], [id])],
 461                      [b4_symbol([$2], [user_number])]))])])
 462
 463
 464 ## ------- ##
 465 ## Types.  ##
 466 ## ------- ##
 467
 468 # b4_type_action_(NUMS)
 469 # ---------------------
 470 # Run actions for the symbol NUMS that all have the same type-name.
 471 # Skip NUMS that have no type-name.
 472 m4_define([b4_type_action_],
 473 [b4_symbol_if([$1], [has_type],
 474 [m4_map([b4_symbol_case_], [$@])[]dnl
 475         b4_dollar_dollar([b4_symbol([$1], [number])],
 476                          [b4_symbol([$1], [tag])],
 477                          [b4_symbol([$1], [type])]);
 478         break;
 479
 480 ])])
 481
 482 # b4_type_foreach(MACRO)
 483 # ----------------------
 484 # Invoke MACRO(SYMBOL-NUMS) for each set of SYMBOL-NUMS for each type set.
 485 m4_define([b4_type_foreach],
 486           [m4_map([$1], m4_defn([b4_type_names]))])
 487
 488
 489
 490 ## ----------- ##
 491 ## Synclines.  ##
 492 ## ----------- ##
 493
 494 # b4_basename(NAME)
 495 # -----------------
 496 # Similar to POSIX basename; the differences don't matter here.
 497 # Beware that NAME is not evaluated.
 498 m4_define([b4_basename],
 499 [m4_bpatsubst([$1], [^.*/\([^/]+\)/*$], [\1])])
 500
 501
 502 # b4_syncline(LINE, FILE)
 503 # -----------------------
 504 m4_define([b4_syncline],
 505 [b4_flag_if([synclines],
 506 [b4_sync_end([__line__], [b4_basename(m4_quote(__file__))])
 507 b4_sync_start([$1], [$2])])])
 508
 509 m4_define([b4_sync_end], [b4_comment([Line $1 of $2])])
 510 m4_define([b4_sync_start], [b4_comment([Line $1 of $2])])
 511
 512 # b4_user_code(USER-CODE)
 513 # -----------------------
 514 # Emit code from the user, ending it with synclines.
 515 m4_define([b4_user_code],
 516 [$1
 517 b4_syncline([@oline@], [@ofile@])])
 518
 519
 520 # b4_define_user_code(MACRO)
 521 # --------------------------
 522 # From b4_MACRO, build b4_user_MACRO that includes the synclines.
 523 m4_define([b4_define_user_code],
 524 [m4_define([b4_user_$1],
 525 [b4_user_code([b4_$1])])])
 526
 527
 528 # b4_user_actions
 529 # b4_user_initial_action
 530 # b4_user_post_prologue
 531 # b4_user_pre_prologue
 532 # b4_user_stype
 533 # ----------------------
 534 # Macros that issue user code, ending with synclines.
 535 b4_define_user_code([actions])
 536 b4_define_user_code([initial_action])
 537 b4_define_user_code([post_prologue])
 538 b4_define_user_code([pre_prologue])
 539 b4_define_user_code([stype])
 540
 541
 542 # b4_check_user_names(WHAT, USER-LIST, BISON-NAMESPACE)
 543 # -----------------------------------------------------
 544 # Complain if any name of type WHAT is used by the user (as recorded in
 545 # USER-LIST) but is not used by Bison (as recorded by macros in the
 546 # namespace BISON-NAMESPACE).
 547 #
 548 # USER-LIST must expand to a list specifying all user occurrences of all names
 549 # of type WHAT.   Each item in the list must be a triplet specifying one
 550 # occurrence: name, start boundary, and end boundary.  Empty string names are
 551 # fine.  An empty list is fine.
 552 #
 553 # For example, to define b4_foo_user_names to be used for USER-LIST with three
 554 # name occurrences and with correct quoting:
 555 #
 556 #   m4_define([b4_foo_user_names],
 557 #             [[[[[[bar]], [[parser.y:1.7]], [[parser.y:1.16]]]],
 558 #               [[[[bar]], [[parser.y:5.7]], [[parser.y:5.16]]]],
 559 #               [[[[baz]], [[parser.y:8.7]], [[parser.y:8.16]]]]]])
 560 #
 561 # The macro BISON-NAMESPACE(bar) must be defined iff the name bar of type WHAT
 562 # is used by Bison (in the front-end or in the skeleton).  Empty string names
 563 # are fine, but it would be ugly for Bison to actually use one.
 564 #
 565 # For example, to use b4_foo_bison_names for BISON-NAMESPACE and define that
 566 # the names bar and baz are used by Bison:
 567 #
 568 #   m4_define([b4_foo_bison_names(bar)])
 569 #   m4_define([b4_foo_bison_names(baz)])
 570 #
 571 # To invoke b4_check_user_names with TYPE foo, with USER-LIST
 572 # b4_foo_user_names, with BISON-NAMESPACE b4_foo_bison_names, and with correct
 573 # quoting:
 574 #
 575 #   b4_check_user_names([[foo]], [b4_foo_user_names],
 576 #                       [[b4_foo_bison_names]])
 577 m4_define([b4_check_user_names],
 578 [m4_foreach([b4_occurrence], $2,
 579 [m4_pushdef([b4_occurrence], b4_occurrence)dnl
 580 m4_pushdef([b4_user_name], m4_car(b4_occurrence))dnl
 581 m4_pushdef([b4_start], m4_car(m4_shift(b4_occurrence)))dnl
 582 m4_pushdef([b4_end], m4_shift(m4_shift(b4_occurrence)))dnl
 583 m4_ifndef($3[(]m4_quote(b4_user_name)[)],
 584           [b4_complain_at([b4_start], [b4_end],
 585                           [[%s '%s' is not used]],
 586                           [$1], [b4_user_name])])[]dnl
 587 m4_popdef([b4_occurrence])dnl
 588 m4_popdef([b4_user_name])dnl
 589 m4_popdef([b4_start])dnl
 590 m4_popdef([b4_end])dnl
 591 ])])
 592
 593
 594
 595 ## --------------------- ##
 596 ## b4_percent_define_*.  ##
 597 ## --------------------- ##
 598
 599
 600 # b4_percent_define_use(VARIABLE)
 601 # -------------------------------
 602 # Declare that VARIABLE was used.
 603 m4_define([b4_percent_define_use],
 604 [m4_define([b4_percent_define_bison_variables(]$1[)])dnl
 605 ])
 606
 607 # b4_percent_define_get(VARIABLE, [DEFAULT])
 608 # ------------------------------------------
 609 # Mimic muscle_percent_define_get in ../src/muscle-tab.h.  That is, if
 610 # the %define variable VARIABLE is defined, emit its value.  Contrary
 611 # to its C counterpart, return DEFAULT otherwise.  Also, record
 612 # Bison's usage of VARIABLE by defining
 613 # b4_percent_define_bison_variables(VARIABLE).
 614 #
 615 # For example:
 616 #
 617 #   b4_percent_define_get([[foo]])
 618 m4_define([b4_percent_define_get],
 619 [b4_percent_define_use([$1])dnl
 620 m4_ifdef([b4_percent_define(]$1[)],
 621          [m4_indir([b4_percent_define(]$1[)])],
 622          [$2])])
 623
 624 # b4_percent_define_get_loc(VARIABLE)
 625 # -----------------------------------
 626 # Mimic muscle_percent_define_get_loc in ../src/muscle-tab.h exactly.  That is,
 627 # if the %define variable VARIABLE is undefined, complain fatally since that's
 628 # a Bison or skeleton error.  Otherwise, return its definition location in a
 629 # form approriate for the first two arguments of b4_warn_at, b4_complain_at, or
 630 # b4_fatal_at.  Don't record this as a Bison usage of VARIABLE as there's no
 631 # reason to suspect that the user-supplied value has yet influenced the output.
 632 #
 633 # For example:
 634 #
 635 #   b4_complain_at(b4_percent_define_get_loc([[foo]]), [[invalid foo]])
 636 m4_define([b4_percent_define_get_loc],
 637 [m4_ifdef([b4_percent_define_loc(]$1[)],
 638           [m4_pushdef([b4_loc], m4_indir([b4_percent_define_loc(]$1[)]))dnl
 639 b4_loc[]dnl
 640 m4_popdef([b4_loc])],
 641           [b4_fatal([[b4_percent_define_get_loc: undefined %%define variable '%s']], [$1])])])
 642
 643 # b4_percent_define_get_syncline(VARIABLE)
 644 # ----------------------------------------
 645 # Mimic muscle_percent_define_get_syncline in ../src/muscle-tab.h exactly.
 646 # That is, if the %define variable VARIABLE is undefined, complain fatally
 647 # since that's a Bison or skeleton error.  Otherwise, return its definition
 648 # location as a b4_syncline invocation.  Don't record this as a Bison usage of
 649 # VARIABLE as there's no reason to suspect that the user-supplied value has yet
 650 # influenced the output.
 651 #
 652 # For example:
 653 #
 654 #   b4_percent_define_get_syncline([[foo]])
 655 m4_define([b4_percent_define_get_syncline],
 656 [m4_ifdef([b4_percent_define_syncline(]$1[)],
 657           [m4_indir([b4_percent_define_syncline(]$1[)])],
 658           [b4_fatal([[b4_percent_define_get_syncline: undefined %%define variable '%s']], [$1])])])
 659
 660 # b4_percent_define_ifdef(VARIABLE, IF-TRUE, [IF-FALSE])
 661 # ------------------------------------------------------
 662 # Mimic muscle_percent_define_ifdef in ../src/muscle-tab.h exactly.  That is,
 663 # if the %define variable VARIABLE is defined, expand IF-TRUE, else expand
 664 # IF-FALSE.  Also, record Bison's usage of VARIABLE by defining
 665 # b4_percent_define_bison_variables(VARIABLE).
 666 #
 667 # For example:
 668 #
 669 #   b4_percent_define_ifdef([[foo]], [[it's defined]], [[it's undefined]])
 670 m4_define([b4_percent_define_ifdef],
 671 [m4_ifdef([b4_percent_define(]$1[)],
 672           [b4_percent_define_use([$1])$2],
 673           [$3])])
 674
 675
 676 ## --------- ##
 677 ## Options.  ##
 678 ## --------- ##
 679
 680
 681 # b4_percent_define_flag_if(VARIABLE, IF-TRUE, [IF-FALSE])
 682 # --------------------------------------------------------
 683 # Mimic muscle_percent_define_flag_if in ../src/muscle-tab.h exactly.  That is,
 684 # if the %define variable VARIABLE is defined to "" or "true", expand IF-TRUE.
 685 # If it is defined to "false", expand IF-FALSE.  Complain if it is undefined
 686 # (a Bison or skeleton error since the default value should have been set
 687 # already) or defined to any other value (possibly a user error).  Also, record
 688 # Bison's usage of VARIABLE by defining
 689 # b4_percent_define_bison_variables(VARIABLE).
 690 #
 691 # For example:
 692 #
 693 #   b4_percent_define_flag_if([[foo]], [[it's true]], [[it's false]])
 694 m4_define([b4_percent_define_flag_if],
 695 [b4_percent_define_ifdef([$1],
 696   [m4_case(b4_percent_define_get([$1]),
 697            [], [$2], [true], [$2], [false], [$3],
 698            [m4_expand_once([b4_complain_at(b4_percent_define_get_loc([$1]),
 699                                            [[invalid value for %%define Boolean variable '%s']],
 700                                            [$1])],
 701                            [[b4_percent_define_flag_if($1)]])])],
 702   [b4_fatal([[b4_percent_define_flag_if: undefined %%define variable '%s']], [$1])])])
 703
 704
 705 # b4_percent_define_default(VARIABLE, DEFAULT)
 706 # --------------------------------------------
 707 # Mimic muscle_percent_define_default in ../src/muscle-tab.h exactly.  That is,
 708 # if the %define variable VARIABLE is undefined, set its value to DEFAULT.
 709 # Don't record this as a Bison usage of VARIABLE as there's no reason to
 710 # suspect that the value has yet influenced the output.
 711 #
 712 # For example:
 713 #
 714 #   b4_percent_define_default([[foo]], [[default value]])
 715 m4_define([b4_percent_define_default],
 716 [m4_ifndef([b4_percent_define(]$1[)],
 717            [m4_define([b4_percent_define(]$1[)], [$2])dnl
 718             m4_define([b4_percent_define_loc(]$1[)],
 719                       [[[[<skeleton default value>:-1.-1]],
 720                         [[<skeleton default value>:-1.-1]]]])dnl
 721             m4_define([b4_percent_define_syncline(]$1[)], [[]])])])
 722
 723
 724 # b4_percent_define_if_define(NAME, [VARIABLE = NAME])
 725 # ----------------------------------------------------
 726 # Define b4_NAME_if that executes its $1 or $2 depending whether
 727 # VARIABLE was %defined.  The characters `.' and `-' in VARIABLE are mapped
 728 # to `_'.
 729 m4_define([b4_percent_define_if_define_],
 730 [m4_define(m4_bpatsubst([b4_$1_if], [[-.]], [_]),
 731            [b4_percent_define_flag_if(m4_default([$2], [$1]),
 732                                       [$3], [$4])])])
 733 m4_define([b4_percent_define_if_define],
 734 [b4_percent_define_default([m4_default([$2], [$1])], [[false]])
 735 b4_percent_define_if_define_([$1], [$2], $[1], $[2])])
 736
 737
 738 # b4_percent_define_check_values(VALUES)
 739 # --------------------------------------
 740 # Mimic muscle_percent_define_check_values in ../src/muscle-tab.h exactly
 741 # except that the VALUES structure is more appropriate for M4.  That is, VALUES
 742 # is a list of sublists of strings.  For each sublist, the first string is the
 743 # name of a %define variable, and all remaining strings in that sublist are the
 744 # valid values for that variable.  Complain if such a variable is undefined (a
 745 # Bison error since the default value should have been set already) or defined
 746 # to any other value (possibly a user error).  Don't record this as a Bison
 747 # usage of the variable as there's no reason to suspect that the value has yet
 748 # influenced the output.
 749 #
 750 # For example:
 751 #
 752 #   b4_percent_define_check_values([[[[foo]], [[foo-value1]], [[foo-value2]]]],
 753 #                                  [[[[bar]], [[bar-value1]]]])
 754 m4_define([b4_percent_define_check_values],
 755 [m4_foreach([b4_sublist], m4_quote($@),
 756             [_b4_percent_define_check_values(b4_sublist)])])
 757
 758 m4_define([_b4_percent_define_check_values],
 759 [m4_ifdef([b4_percent_define(]$1[)],
 760   [m4_pushdef([b4_good_value], [0])dnl
 761    m4_if($#, 1, [],
 762          [m4_foreach([b4_value], m4_dquote(m4_shift($@)),
 763                      [m4_if(m4_indir([b4_percent_define(]$1[)]), b4_value,
 764                             [m4_define([b4_good_value], [1])])])])dnl
 765    m4_if(b4_good_value, [0],
 766          [b4_complain_at(b4_percent_define_get_loc([$1]),
 767                          [[invalid value for %%define variable '%s': '%s']],
 768                          [$1],
 769                          m4_dquote(m4_indir([b4_percent_define(]$1[)])))
 770           m4_foreach([b4_value], m4_dquote(m4_shift($@)),
 771                      [b4_error([[note]], b4_percent_define_get_loc([$1]), []
 772                                      [[accepted value: '%s']],
 773                                      m4_dquote(b4_value))])])dnl
 774    m4_popdef([b4_good_value])],
 775   [b4_fatal([[b4_percent_define_check_values: undefined %%define variable '%s']], [$1])])])
 776
 777 # b4_percent_code_get([QUALIFIER])
 778 # --------------------------------
 779 # If any %code blocks for QUALIFIER are defined, emit them beginning with a
 780 # comment and ending with synclines and a newline.  If QUALIFIER is not
 781 # specified or empty, do this for the unqualified %code blocks.  Also, record
 782 # Bison's usage of QUALIFIER (if specified) by defining
 783 # b4_percent_code_bison_qualifiers(QUALIFIER).
 784 #
 785 # For example, to emit any unqualified %code blocks followed by any %code
 786 # blocks for the qualifier foo:
 787 #
 788 #   b4_percent_code_get
 789 #   b4_percent_code_get([[foo]])
 790 m4_define([b4_percent_code_get],
 791 [m4_pushdef([b4_macro_name], [[b4_percent_code(]$1[)]])dnl
 792 m4_ifval([$1], [m4_define([b4_percent_code_bison_qualifiers(]$1[)])])dnl
 793 m4_ifdef(b4_macro_name,
 794 [b4_comment([m4_if([$#], [0], [[Unqualified %code]],
 795                    [["%code ]$1["]])[ blocks.]])
 796 b4_user_code([m4_indir(b4_macro_name)])
 797 ])dnl
 798 m4_popdef([b4_macro_name])])
 799
 800 # b4_percent_code_ifdef(QUALIFIER, IF-TRUE, [IF-FALSE])
 801 # -----------------------------------------------------
 802 # If any %code blocks for QUALIFIER (or unqualified %code blocks if
 803 # QUALIFIER is empty) are defined, expand IF-TRUE, else expand IF-FALSE.
 804 # Also, record Bison's usage of QUALIFIER (if specified) by defining
 805 # b4_percent_code_bison_qualifiers(QUALIFIER).
 806 m4_define([b4_percent_code_ifdef],
 807 [m4_ifdef([b4_percent_code(]$1[)],
 808           [m4_ifval([$1], [m4_define([b4_percent_code_bison_qualifiers(]$1[)])])$2],
 809           [$3])])
 810
 811
 812 ## ------------------ ##
 813 ## Common variables.  ##
 814 ## ------------------ ##
 815
 816 # Default values for %define.
 817 # ---------------------------
 818 # If the api.token.prefix, it is empty.
 819 m4_percent_define_default([[api.token.prefix]], [[]])
 820
 821 # b4_parse_assert_if([IF-ASSERTIONS-ARE-USED], [IF-NOT])
 822 # b4_parse_trace_if([IF-DEBUG-TRACES-ARE-ENABLED], [IF-NOT])
 823 # b4_token_ctor_if([IF-YYLEX-RETURNS-A-TOKEN], [IF-NOT])
 824 # ----------------------------------------------
 825 b4_percent_define_if_define([token_ctor], [api.token.constructor])
 826 b4_percent_define_if_define([locations])     # Whether locations are tracked.
 827 b4_percent_define_if_define([parse.assert])
 828 b4_percent_define_if_define([parse.trace])
 829
 830
 831 # b4_bison_locations_if([IF-TRUE])
 832 # --------------------------------
 833 # Expand IF-TRUE if using locations, and using the default location
 834 # type.
 835 m4_define([b4_bison_locations_if],
 836 [b4_locations_if([b4_percent_define_ifdef([[api.location.type]], [], [$1])])])
 837
 838
 839 # b4_error_verbose_if([IF-ERRORS-ARE-VERBOSE], [IF-NOT])
 840 # ------------------------------------------------------
 841 # Map %define parse.error "(simple|verbose)" to b4_error_verbose_if and
 842 # b4_error_verbose_flag.
 843 b4_percent_define_default([[parse.error]], [[simple]])
 844 b4_percent_define_check_values([[[[parse.error]],
 845                                  [[simple]], [[verbose]]]])
 846 m4_define([b4_error_verbose_flag],
 847           [m4_case(b4_percent_define_get([[parse.error]]),
 848                    [simple],  [[0]],
 849                    [verbose], [[1]])])
 850 b4_define_flag_if([error_verbose])
 851
 852 # yytoken_table is needed to support verbose errors.
 853 b4_error_verbose_if([m4_define([b4_token_table_flag], [1])])
 854
 855
 856 # b4_variant_if([IF-VARIANT-ARE-USED], [IF-NOT])
 857 # ----------------------------------------------
 858 b4_percent_define_if_define([variant])
 859 m4_case(b4_percent_define_get([[api.value.type]]),
 860         [variant], [m4_define([b4_variant_flag], [[1]])],
 861                    [m4_define([b4_variant_flag], [[0]])])
 862 b4_define_flag_if([variant])
 863
 864
 865 ## ----------------------------------------------------------- ##
 866 ## After processing the skeletons, check that all the user's   ##
 867 ## %define variables and %code qualifiers were used by Bison.  ##
 868 ## ----------------------------------------------------------- ##
 869
 870 m4_define([b4_check_user_names_wrap],
 871 [m4_ifdef([b4_percent_]$1[_user_]$2[s],
 872           [b4_check_user_names([[%]$1 $2],
 873                                [b4_percent_]$1[_user_]$2[s],
 874                                [[b4_percent_]$1[_bison_]$2[s]])])])
 875
 876 m4_wrap_lifo([
 877 b4_check_user_names_wrap([[define]], [[variable]])
 878 b4_check_user_names_wrap([[code]], [[qualifier]])
 879 ])
 880
 881
 882 ## ---------------- ##
 883 ## Default values.  ##
 884 ## ---------------- ##
 885
 886 # m4_define_default([b4_lex_param], [])   dnl breaks other skeletons
 887 m4_define_default([b4_pre_prologue], [])
 888 m4_define_default([b4_post_prologue], [])
 889 m4_define_default([b4_epilogue], [])
 890 m4_define_default([b4_parse_param], [])
 891
 892 # The initial column and line.
 893 m4_define_default([b4_location_initial_column], [1])
 894 m4_define_default([b4_location_initial_line],   [1])
 895
 896 # Sanity checks.
 897 b4_percent_define_ifdef([api.prefix],
 898 [m4_ifdef([b4_prefix],
 899 [b4_complain_at(b4_percent_define_get_loc([api.prefix]),
 900                 [['%s' and '%s' cannot be used together]],
 901                 [%name-prefix],
 902                 [%define api.prefix])])])