data/bison.m4

   1                                                             -*- Autoconf -*-
   2
   3 # Language-independent M4 Macros for Bison.
   4 # Copyright (C) 2002, 2004, 2005, 2006, 2007 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 3 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, see <http://www.gnu.org/licenses/>.
  18
  19
  20 ## ---------------- ##
  21 ## Identification.  ##
  22 ## ---------------- ##
  23
  24 # b4_copyright(TITLE, YEARS)
  25 # --------------------------
  26 m4_define([b4_copyright],
  27 [b4_comment([A Bison parser, made by GNU Bison b4_version.])
  28
  29 b4_comment([$1
  30
  31 m4_text_wrap([Copyright (C) $2 Free Software Foundation, Inc.], [   ])
  32
  33 This program is free software: you can redistribute it and/or modify
  34 it under the terms of the GNU General Public License as published by
  35 the Free Software Foundation, either version 3 of the License, or
  36 (at your option) any later version.
  37
  38 This program is distributed in the hope that it will be useful,
  39 but WITHOUT ANY WARRANTY; without even the implied warranty of
  40 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  41 GNU General Public License for more details.
  42
  43 You should have received a copy of the GNU General Public License
  44 along with this program.  If not, see <http://www.gnu.org/licenses/>.])
  45
  46 b4_comment([As a special exception, you may create a larger work that contains
  47 part or all of the Bison parser skeleton and distribute that work
  48 under terms of your choice, so long as that work isn't itself a
  49 parser generator using the skeleton or a modified version thereof
  50 as a parser skeleton.  Alternatively, if you modify or redistribute
  51 the parser skeleton itself, you may (at your option) remove this
  52 special exception, which will cause the skeleton and the resulting
  53 Bison output files to be licensed under the GNU General Public
  54 License without this special exception.
  55
  56 This special exception was added by the Free Software Foundation in
  57 version 2.2 of Bison.])])
  58
  59
  60 ## ---------------- ##
  61 ## Error handling.  ##
  62 ## ---------------- ##
  63
  64 # b4_error(KIND, FORMAT, [ARG1], [ARG2], ...)
  65 # -------------------------------------------
  66 # Write @KIND(FORMAT@,ARG1@,ARG2@,...@) to diversion 0.
  67 m4_define([b4_error],
  68 [m4_divert_push(0)[@]$1[(]$2[]m4_if([$#], [2], [],
  69 [m4_foreach([b4_arg],
  70             m4_dquote(m4_shift(m4_shift($@))),
  71             [[@,]b4_arg])])[@)]m4_divert_pop(0)])
  72
  73 # b4_error_at(KIND, START, END, FORMAT, [ARG1], [ARG2], ...)
  74 # ----------------------------------------------------------
  75 # Write @KIND(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to diversion 0.
  76 m4_define([b4_error_at],
  77 [m4_divert_push(0)[@]$1[_at(]$2[@,]$3[@,]$4[]m4_if([$#], [4], [],
  78 [m4_foreach([b4_arg],
  79             m4_dquote(m4_shift(m4_shift(m4_shift(m4_shift($@))))),
  80             [[@,]b4_arg])])[@)]m4_divert_pop(0)])
  81
  82 # b4_warn(FORMAT, [ARG1], [ARG2], ...)
  83 # ------------------------------------
  84 # Write @warn(FORMAT@,ARG1@,ARG2@,...@) to diversion 0.
  85 #
  86 # As a simple test suite, this:
  87 #
  88 #   m4_define([asdf], [ASDF])
  89 #   m4_define([fsa], [FSA])
  90 #   m4_define([fdsa], [FDSA])
  91 #   b4_warn([[[asdf), asdf]]], [[[fsa), fsa]]], [[[fdsa), fdsa]]])
  92 #   m4_divert(0)
  93 #   b4_warn([[asdf), asdf]], [[fsa), fsa]], [[fdsa), fdsa]])
  94 #   m4_divert(0)
  95 #   b4_warn([asdf), asdf], [fsa), fsa], [fdsa), fdsa])
  96 #   m4_divert(0)
  97 #   b4_warn()
  98 #   m4_divert(0)
  99 #   b4_warn(1)
 100 #   m4_divert(0)
 101 #   b4_warn(1, 2)
 102 #
 103 # Should produce this:
 104 #
 105 #   @warn([asdf), asdf]@,[fsa), fsa]@,[fdsa), fdsa]@)
 106 #   @warn(asdf), asdf@,fsa), fsa@,fdsa), fdsa@)
 107 #   @warn(ASDF), ASDF@,FSA), FSA@,FDSA), FDSA@)
 108 #   @warn(@)
 109 #   @warn(1@)
 110 #   @warn(1@,2@)
 111 m4_define([b4_warn],
 112 [b4_error([[warn]], $@)])
 113
 114 # b4_warn_at(START, END, FORMAT, [ARG1], [ARG2], ...)
 115 # ---------------------------------------------------
 116 # Write @warn(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to diversion 0.
 117 m4_define([b4_warn_at],
 118 [b4_error_at([[warn]], $@)])
 119
 120 # b4_complain(FORMAT, [ARG1], [ARG2], ...)
 121 # ----------------------------------------
 122 # Write @complain(FORMAT@,ARG1@,ARG2@,...@) to diversion 0.
 123 #
 124 # See the test suite for b4_warn above.
 125 m4_define([b4_complain],
 126 [b4_error([[complain]], $@)])
 127
 128 # b4_complain_at(START, END, FORMAT, [ARG1], [ARG2], ...)
 129 # -------------------------------------------------------
 130 # Write @complain(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to diversion 0.
 131 m4_define([b4_complain_at],
 132 [b4_error_at([[complain]], $@)])
 133
 134 # b4_fatal(FORMAT, [ARG1], [ARG2], ...)
 135 # -------------------------------------
 136 # Write @fatal(FORMAT@,ARG1@,ARG2@,...@) to diversion 0.
 137 #
 138 # See the test suite for b4_warn above.
 139 m4_define([b4_fatal],
 140 [b4_error([[fatal]], $@)])
 141
 142 # b4_fatal_at(START, END, FORMAT, [ARG1], [ARG2], ...)
 143 # ----------------------------------------------------
 144 # Write @fatal(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to diversion 0.
 145 m4_define([b4_fatal_at],
 146 [b4_error_at([[fatal]], $@)])
 147
 148
 149 ## ---------------- ##
 150 ## Default values.  ##
 151 ## ---------------- ##
 152
 153 # m4_define_default([b4_lex_param], [])   dnl breaks other skeletons
 154 m4_define_default([b4_pre_prologue], [])
 155 m4_define_default([b4_post_prologue], [])
 156 m4_define_default([b4_epilogue], [])
 157 m4_define_default([b4_parse_param], [])
 158
 159 # The initial column and line.
 160 m4_define_default([b4_location_initial_column], [1])
 161 m4_define_default([b4_location_initial_line],   [1])
 162
 163
 164 ## ------------ ##
 165 ## Data Types.  ##
 166 ## ------------ ##
 167
 168 # b4_ints_in(INT1, INT2, LOW, HIGH)
 169 # ---------------------------------
 170 # Return 1 iff both INT1 and INT2 are in [LOW, HIGH], 0 otherwise.
 171 m4_define([b4_ints_in],
 172 [m4_eval([$3 <= $1 && $1 <= $4 && $3 <= $2 && $2 <= $4])])
 173
 174
 175
 176 ## ------------------ ##
 177 ## Decoding options.  ##
 178 ## ------------------ ##
 179
 180 # b4_flag_if(FLAG, IF-TRUE, IF-FALSE)
 181 # -----------------------------------
 182 # Run IF-TRUE if b4_FLAG_flag is 1, IF-FALSE if FLAG is 0, otherwise fail.
 183 m4_define([b4_flag_if],
 184 [m4_case(b4_$1_flag,
 185          [0], [$3],
 186          [1], [$2],
 187          [m4_fatal([invalid $1 value: ]$1)])])
 188
 189
 190 # b4_define_flag_if(FLAG)
 191 # -----------------------
 192 # Define "b4_FLAG_if(IF-TRUE, IF-FALSE)" that depends on the
 193 # value of the Boolean FLAG.
 194 m4_define([b4_define_flag_if],
 195 [_b4_define_flag_if($[1], $[2], [$1])])
 196
 197 # _b4_define_flag_if($1, $2, FLAG)
 198 # --------------------------------
 199 # This macro works around the impossibility to define macros
 200 # inside macros, because issuing `[$1]' is not possible in M4 :(.
 201 # This sucks hard, GNU M4 should really provide M5 like $$1.
 202 m4_define([_b4_define_flag_if],
 203 [m4_if([$1$2], $[1]$[2], [],
 204        [m4_fatal([$0: Invalid arguments: $@])])dnl
 205 m4_define([b4_$3_if],
 206           [b4_flag_if([$3], [$1], [$2])])])
 207
 208
 209 # b4_FLAG_if(IF-TRUE, IF-FALSE)
 210 # -----------------------------
 211 # Expand IF-TRUE, if FLAG is true, IF-FALSE otherwise.
 212 b4_define_flag_if([defines])            # Whether headers are requested.
 213 b4_define_flag_if([error_verbose])      # Whether error are verbose.
 214 b4_define_flag_if([glr])                # Whether a GLR parser is requested.
 215 b4_define_flag_if([locations])          # Whether locations are tracked.
 216 b4_define_flag_if([nondeterministic])   # Whether conflicts should be handled.
 217 b4_define_flag_if([pull])               # Whether pull parsing is requested.
 218 b4_define_flag_if([pure])               # Whether the interface is pure.
 219 b4_define_flag_if([push])               # Whether push parsing is requested.
 220 b4_define_flag_if([use_push_for_pull])  # Whether push parsing should be used
 221                                         # in place of pull parsing (where
 222                                         # available) for the sake of the test
 223                                         # suite.
 224 b4_define_flag_if([yacc])               # Whether POSIX Yacc is emulated.
 225
 226
 227 ## ------------------------- ##
 228 ## Assigning token numbers.  ##
 229 ## ------------------------- ##
 230
 231
 232 ## ----------- ##
 233 ## Synclines.  ##
 234 ## ----------- ##
 235
 236 # b4_basename(NAME)
 237 # -----------------
 238 # Similar to POSIX basename; the differences don't matter here.
 239 # Beware that NAME is not evaluated.
 240 m4_define([b4_basename],
 241 [m4_bpatsubst([$1], [^.*/\([^/]+\)/*$], [\1])])
 242
 243
 244 # b4_syncline(LINE, FILE)
 245 # -----------------------
 246 m4_define([b4_syncline],
 247 [b4_flag_if([synclines], [
 248 b4_sync_end([__line__], [b4_basename(m4_quote(__file__))])
 249 b4_sync_start([$1], [$2])])])
 250
 251 m4_define([b4_sync_end], [b4_comment([Line $1 of $2])])
 252 m4_define([b4_sync_start], [b4_comment([Line $1 of $2])])
 253
 254 # b4_user_code(USER-CODE)
 255 # -----------------------
 256 # Emit code from the user, ending it with synclines.
 257 m4_define([b4_user_code],
 258 [$1
 259 b4_syncline([@oline@], [@ofile@])])
 260
 261
 262 # b4_define_user_code(MACRO)
 263 # --------------------------
 264 # From b4_MACRO, build b4_user_MACRO that includes the synclines.
 265 m4_define([b4_define_user_code],
 266 [m4_define([b4_user_$1],
 267 [b4_user_code([b4_$1])])])
 268
 269
 270 # b4_user_actions
 271 # b4_user_initial_action
 272 # b4_user_post_prologue
 273 # b4_user_pre_prologue
 274 # b4_user_stype
 275 # ----------------------
 276 # Macros that issue user code, ending with synclines.
 277 b4_define_user_code([actions])
 278 b4_define_user_code([initial_action])
 279 b4_define_user_code([post_prologue])
 280 b4_define_user_code([pre_prologue])
 281 b4_define_user_code([stype])
 282
 283
 284 # b4_check_user_names(WHAT, USER-LIST, BISON-NAMESPACE)
 285 # --------------------------------------------------------
 286 # Warn if any name of type WHAT is used by the user (as recorded in USER-LIST)
 287 # but is not used by Bison (as recorded by macros in the namespace
 288 # BISON-NAMESPACE).
 289 #
 290 # USER-LIST must expand to a list specifying all grammar occurrences of all
 291 # names of type WHAT.   Each item in the list must be a triplet specifying one
 292 # occurrence: name, start boundary, and end boundary.  Empty string names are
 293 # fine.  An empty list is fine.
 294 #
 295 # For example, to define b4_foo_user_names to be used for USER-LIST with three
 296 # name occurrences and with correct quoting:
 297 #
 298 #   m4_define([b4_foo_user_names],
 299 #             [[[[[[bar]], [[parser.y:1.7]], [[parser.y:1.16]]]],
 300 #               [[[[bar]], [[parser.y:5.7]], [[parser.y:5.16]]]],
 301 #               [[[[baz]], [[parser.y:8.7]], [[parser.y:8.16]]]]]])
 302 #
 303 # The macro BISON-NAMESPACE(bar) must be defined iff the name bar of type WHAT
 304 # is used by Bison (in the front-end or in the skeleton).  Empty string names
 305 # are fine, but it would be ugly for Bison to actually use one.
 306 #
 307 # For example, to use b4_foo_bison_names for BISON-NAMESPACE and define that
 308 # the names bar and baz are used by Bison:
 309 #
 310 #   m4_define([b4_foo_bison_names(bar)])
 311 #   m4_define([b4_foo_bison_names(baz)])
 312 #
 313 # To invoke b4_check_user_names with TYPE foo, with USER-LIST
 314 # b4_foo_user_names, with BISON-NAMESPACE b4_foo_bison_names, and with correct
 315 # quoting:
 316 #
 317 #   b4_check_user_names([[foo]], [b4_foo_user_names],
 318 #                       [[b4_foo_bison_names]])
 319 m4_define([b4_check_user_names],
 320 [m4_foreach([b4_occurrence], $2,
 321 [m4_pushdef([b4_occurrence], b4_occurrence)dnl
 322 m4_pushdef([b4_user_name], m4_car(b4_occurrence))dnl
 323 m4_pushdef([b4_start], m4_car(m4_shift(b4_occurrence)))dnl
 324 m4_pushdef([b4_end], m4_shift(m4_shift(b4_occurrence)))dnl
 325 m4_ifndef($3[(]m4_quote(b4_user_name)[)],
 326           [b4_warn_at([b4_start], [b4_end],
 327                       [[%s `%s' is not used]],
 328                       [$1], [b4_user_name])])[]dnl
 329 m4_popdef([b4_occurrence])dnl
 330 m4_popdef([b4_user_name])dnl
 331 m4_popdef([b4_start])dnl
 332 m4_popdef([b4_end])dnl
 333 ])])
 334
 335 # b4_percent_define_get(VARIABLE)
 336 # -------------------------------
 337 # Mimic muscle_percent_define_get in ../src/muscle_tab.h exactly.  That is, if
 338 # the %define variable VARIABLE is defined, emit its value.  Also, record
 339 # Bison's usage of VARIABLE by defining
 340 # b4_percent_define_bison_variables(VARIABLE).
 341 #
 342 # For example:
 343 #
 344 #   b4_percent_define_get([[foo]])
 345 m4_define([b4_percent_define_get],
 346 [m4_define([b4_percent_define_bison_variables(]$1[)])dnl
 347 m4_ifdef([b4_percent_define(]$1[)], [m4_indir([b4_percent_define(]$1[)])])])
 348
 349 # b4_percent_define_ifdef(VARIABLE, IF-TRUE, [IF-FALSE])
 350 # ------------------------------------------------------
 351 # Mimic muscle_percent_define_ifdef in ../src/muscle_tab.h exactly.  That is,
 352 # if the %define variable VARIABLE is defined, expand IF-TRUE, else expand
 353 # IF-FALSE.  Also, record Bison's usage of VARIABLE by defining
 354 # b4_percent_define_bison_variables(VARIABLE).
 355 #
 356 # For example:
 357 #
 358 #   b4_percent_define_ifdef([[foo]], [[it's defined]], [[it's undefined]])
 359 m4_define([b4_percent_define_ifdef],
 360 [m4_ifdef([b4_percent_define(]$1[)],
 361           [m4_define([b4_percent_define_bison_variables(]$1[)])$2],
 362           [$3])])
 363
 364 # b4_percent_define_flag_if(VARIABLE, IF-TRUE, [IF-FALSE])
 365 # --------------------------------------------------------
 366 # Mimic muscle_percent_define_flag_if in ../src/muscle_tab.h exactly.  That is,
 367 # if the %define variable VARIABLE is defined to "" or "true", expand IF-TRUE.
 368 # If it is defined to "false", expand IF-FALSE.  Complain if it is undefined
 369 # (a Bison or skeleton error since the default value should have been set
 370 # already) or defined to any other value (possibly a user error).  Also, record
 371 # Bison's usage of VARIABLE by defining
 372 # b4_percent_define_bison_variables(VARIABLE).
 373 #
 374 # For example:
 375 #
 376 #   b4_percent_define_flag_if([[foo]], [[it's true]], [[it's false]])
 377 m4_define([b4_percent_define_flag_if],
 378 [b4_percent_define_ifdef([$1],
 379   [m4_case(b4_percent_define_get([$1]),
 380            [], [$2], [true], [$2], [false], [$3],
 381            [m4_expand_once([dnl
 382              m4_pushdef([b4_loc], m4_indir([b4_percent_define_loc(]$1[)]))dnl
 383              b4_complain_at(b4_loc,
 384                             [[invalid value for %%define Boolean variable `%s']],
 385                             [$1])dnl
 386              m4_popdef([b4_loc])],
 387              [[b4_percent_define_flag_if($1)]])])],
 388   [b4_fatal([[undefined %%define variable `%s' passed to b4_percent_define_flag_if]], [$1])])])
 389
 390 # b4_percent_define_default(VARIABLE, DEFAULT)
 391 # --------------------------------------------
 392 # Mimic muscle_percent_define_default in ../src/muscle_tab.h exactly.  That is,
 393 # if the %define variable VARIABLE is undefined, set its value to DEFAULT.
 394 # Don't record this as a Bison usage of VARIABLE as there's no reason to
 395 # suspect that the value has yet influenced the output.
 396 #
 397 # For example:
 398 #
 399 #   b4_percent_define_default([[foo]], [[default value]])
 400 m4_define([b4_percent_define_default],
 401 [m4_ifndef([b4_percent_define(]$1[)],
 402            [m4_define([b4_percent_define(]$1[)], [$2])dnl
 403             m4_define([b4_percent_define_loc(]$1[)],
 404                       [[[[[Bison:b4_percent_define_default]:0.0]], [[[Bison:b4_percent_define_default]:0.0]]]])])])
 405
 406 # b4_percent_code_get([QUALIFIER])
 407 # --------------------------------
 408 # If any %code blocks for QUALIFIER are defined, emit them beginning with a
 409 # comment and ending with synclines and a newline.  If QUALIFIER is not
 410 # specified or empty, do this for the unqualified %code blocks.  Also, record
 411 # Bison's usage of QUALIFIER (if specified) by defining
 412 # b4_percent_code_bison_qualifiers(QUALIFIER).
 413 #
 414 # For example, to emit any unqualified %code blocks followed by any %code
 415 # blocks for the qualifier foo:
 416 #
 417 #   b4_percent_code_get
 418 #   b4_percent_code_get([[foo]])
 419 m4_define([b4_percent_code_get],
 420 [m4_pushdef([b4_macro_name], [[b4_percent_code(]$1[)]])dnl
 421 m4_ifval([$1], [m4_define([b4_percent_code_bison_qualifiers(]$1[)])])dnl
 422 m4_ifdef(b4_macro_name,
 423 [b4_comment([m4_if([$#], [0], [[Unqualified %code]],
 424                    [[%code "]$1["]])[ blocks.]])
 425 b4_user_code([m4_indir(b4_macro_name)])
 426 ])dnl
 427 m4_popdef([b4_macro_name])])
 428
 429 # b4_percent_code_ifdef(QUALIFIER, IF-TRUE, [IF-FALSE])
 430 # -----------------------------------------------------
 431 # If any %code blocks for QUALIFIER (or unqualified %code blocks if
 432 # QUALIFIER is empty) are defined, expand IF-TRUE, else expand IF-FALSE.
 433 # Also, record Bison's usage of QUALIFIER (if specified) by defining
 434 # b4_percent_code_bison_qualifiers(QUALIFIER).
 435 m4_define([b4_percent_code_ifdef],
 436 [m4_ifdef([b4_percent_code(]$1[)],
 437           [m4_ifval([$1], [m4_define([b4_percent_code_bison_qualifiers(]$1[)])])$2],
 438           [$3])])
 439
 440
 441 ## ----------------------------------------------------------- ##
 442 ## After processing the skeletons, check that all the user's   ##
 443 ## %define variables and %code qualifiers were used by Bison.  ##
 444 ## ----------------------------------------------------------- ##
 445
 446 m4_define([b4_check_user_names_wrap],
 447 [m4_ifdef([b4_percent_]$1[_user_]$2[s],
 448           [b4_check_user_names([[%]$1 $2],
 449                                [b4_percent_]$1[_user_]$2[s],
 450                                [[b4_percent_]$1[_bison_]$2[s]])])])
 451
 452 m4_wrap([
 453 b4_check_user_names_wrap([[define]], [[variable]])
 454 b4_check_user_names_wrap([[code]], [[qualifier]])
 455 ])