Annotation of win32/tools/cygwin/usr/share/bison/bison.m4, revision 1.1
1.1 ! misha 1: -*- Autoconf -*-
! 2:
! 3: # Language-independent M4 Macros for Bison.
! 4: # Copyright (C) 2002, 2004-2010 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: # The following error handling macros print error directives that should not
! 65: # become arguments of other macro invocations since they would likely then be
! 66: # mangled. Thus, they print to stdout directly.
! 67:
! 68: # b4_cat(TEXT)
! 69: # ------------
! 70: # Write TEXT to stdout. Precede the final newline with an @ so that it's
! 71: # escaped. For example:
! 72: #
! 73: # b4_cat([[@complain(invalid input@)]])
! 74: m4_define([b4_cat],
! 75: [m4_syscmd([cat <<'_m4eof'
! 76: ]m4_bpatsubst(m4_dquote($1), [_m4eof], [_m4@`eof])[@
! 77: _m4eof
! 78: ])dnl
! 79: m4_if(m4_sysval, [0], [], [m4_fatal([$0: cannot write to stdout])])])
! 80:
! 81: # b4_error(KIND, FORMAT, [ARG1], [ARG2], ...)
! 82: # -------------------------------------------
! 83: # Write @KIND(FORMAT@,ARG1@,ARG2@,...@) to stdout.
! 84: #
! 85: # For example:
! 86: #
! 87: # b4_error([[warn]], [[invalid value for `%s': %s]], [[foo]], [[3]])
! 88: m4_define([b4_error],
! 89: [b4_cat([[@]$1[(]$2[]]dnl
! 90: [m4_if([$#], [2], [],
! 91: [m4_foreach([b4_arg],
! 92: m4_dquote(m4_shift(m4_shift($@))),
! 93: [[@,]b4_arg])])[@)]])])
! 94:
! 95: # b4_error_at(KIND, START, END, FORMAT, [ARG1], [ARG2], ...)
! 96: # ----------------------------------------------------------
! 97: # Write @KIND_at(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout.
! 98: #
! 99: # For example:
! 100: #
! 101: # b4_error_at([[complain]], [[input.y:2.3]], [[input.y:5.4]],
! 102: # [[invalid %s]], [[foo]])
! 103: m4_define([b4_error_at],
! 104: [b4_cat([[@]$1[_at(]$2[@,]$3[@,]$4[]]dnl
! 105: [m4_if([$#], [4], [],
! 106: [m4_foreach([b4_arg],
! 107: m4_dquote(m4_shift(m4_shift(m4_shift(m4_shift($@))))),
! 108: [[@,]b4_arg])])[@)]])])
! 109:
! 110: # b4_warn(FORMAT, [ARG1], [ARG2], ...)
! 111: # ------------------------------------
! 112: # Write @warn(FORMAT@,ARG1@,ARG2@,...@) to stdout.
! 113: #
! 114: # For example:
! 115: #
! 116: # b4_warn([[invalid value for `%s': %s]], [[foo]], [[3]])
! 117: #
! 118: # As a simple test suite, this:
! 119: #
! 120: # m4_divert(-1)
! 121: # m4_define([asdf], [ASDF])
! 122: # m4_define([fsa], [FSA])
! 123: # m4_define([fdsa], [FDSA])
! 124: # b4_warn([[[asdf), asdf]]], [[[fsa), fsa]]], [[[fdsa), fdsa]]])
! 125: # b4_warn([[asdf), asdf]], [[fsa), fsa]], [[fdsa), fdsa]])
! 126: # b4_warn()
! 127: # b4_warn(1)
! 128: # b4_warn(1, 2)
! 129: #
! 130: # Should produce this without newlines:
! 131: #
! 132: # @warn([asdf), asdf]@,[fsa), fsa]@,[fdsa), fdsa]@)
! 133: # @warn(asdf), asdf@,fsa), fsa@,fdsa), fdsa@)
! 134: # @warn(@)
! 135: # @warn(1@)
! 136: # @warn(1@,2@)
! 137: m4_define([b4_warn],
! 138: [b4_error([[warn]], $@)])
! 139:
! 140: # b4_warn_at(START, END, FORMAT, [ARG1], [ARG2], ...)
! 141: # ---------------------------------------------------
! 142: # Write @warn(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout.
! 143: #
! 144: # For example:
! 145: #
! 146: # b4_warn_at([[input.y:2.3]], [[input.y:5.4]], [[invalid %s]], [[foo]])
! 147: m4_define([b4_warn_at],
! 148: [b4_error_at([[warn]], $@)])
! 149:
! 150: # b4_complain(FORMAT, [ARG1], [ARG2], ...)
! 151: # ----------------------------------------
! 152: # Write @complain(FORMAT@,ARG1@,ARG2@,...@) to stdout.
! 153: #
! 154: # See b4_warn example.
! 155: m4_define([b4_complain],
! 156: [b4_error([[complain]], $@)])
! 157:
! 158: # b4_complain_at(START, END, FORMAT, [ARG1], [ARG2], ...)
! 159: # -------------------------------------------------------
! 160: # Write @complain(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout.
! 161: #
! 162: # See b4_warn_at example.
! 163: m4_define([b4_complain_at],
! 164: [b4_error_at([[complain]], $@)])
! 165:
! 166: # b4_fatal(FORMAT, [ARG1], [ARG2], ...)
! 167: # -------------------------------------
! 168: # Write @fatal(FORMAT@,ARG1@,ARG2@,...@) to stdout and exit.
! 169: #
! 170: # See b4_warn example.
! 171: m4_define([b4_fatal],
! 172: [b4_error([[fatal]], $@)dnl
! 173: m4_exit(1)])
! 174:
! 175: # b4_fatal_at(START, END, FORMAT, [ARG1], [ARG2], ...)
! 176: # ----------------------------------------------------
! 177: # Write @fatal(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout and exit.
! 178: #
! 179: # See b4_warn_at example.
! 180: m4_define([b4_fatal_at],
! 181: [b4_error_at([[fatal]], $@)dnl
! 182: m4_exit(1)])
! 183:
! 184:
! 185: ## ---------------- ##
! 186: ## Default values. ##
! 187: ## ---------------- ##
! 188:
! 189: # m4_define_default([b4_lex_param], []) dnl breaks other skeletons
! 190: m4_define_default([b4_pre_prologue], [])
! 191: m4_define_default([b4_post_prologue], [])
! 192: m4_define_default([b4_epilogue], [])
! 193: m4_define_default([b4_parse_param], [])
! 194:
! 195: # The initial column and line.
! 196: m4_define_default([b4_location_initial_column], [1])
! 197: m4_define_default([b4_location_initial_line], [1])
! 198:
! 199:
! 200: ## ------------ ##
! 201: ## Data Types. ##
! 202: ## ------------ ##
! 203:
! 204: # b4_ints_in(INT1, INT2, LOW, HIGH)
! 205: # ---------------------------------
! 206: # Return 1 iff both INT1 and INT2 are in [LOW, HIGH], 0 otherwise.
! 207: m4_define([b4_ints_in],
! 208: [m4_eval([$3 <= $1 && $1 <= $4 && $3 <= $2 && $2 <= $4])])
! 209:
! 210:
! 211:
! 212: ## ------------------ ##
! 213: ## Decoding options. ##
! 214: ## ------------------ ##
! 215:
! 216: # b4_flag_if(FLAG, IF-TRUE, IF-FALSE)
! 217: # -----------------------------------
! 218: # Run IF-TRUE if b4_FLAG_flag is 1, IF-FALSE if FLAG is 0, otherwise fail.
! 219: m4_define([b4_flag_if],
! 220: [m4_case(b4_$1_flag,
! 221: [0], [$3],
! 222: [1], [$2],
! 223: [m4_fatal([invalid $1 value: ]$1)])])
! 224:
! 225:
! 226: # b4_define_flag_if(FLAG)
! 227: # -----------------------
! 228: # Define "b4_FLAG_if(IF-TRUE, IF-FALSE)" that depends on the
! 229: # value of the Boolean FLAG.
! 230: m4_define([b4_define_flag_if],
! 231: [_b4_define_flag_if($[1], $[2], [$1])])
! 232:
! 233: # _b4_define_flag_if($1, $2, FLAG)
! 234: # --------------------------------
! 235: # This macro works around the impossibility to define macros
! 236: # inside macros, because issuing `[$1]' is not possible in M4 :(.
! 237: # This sucks hard, GNU M4 should really provide M5 like $$1.
! 238: m4_define([_b4_define_flag_if],
! 239: [m4_if([$1$2], $[1]$[2], [],
! 240: [m4_fatal([$0: Invalid arguments: $@])])dnl
! 241: m4_define([b4_$3_if],
! 242: [b4_flag_if([$3], [$1], [$2])])])
! 243:
! 244:
! 245: # b4_FLAG_if(IF-TRUE, IF-FALSE)
! 246: # -----------------------------
! 247: # Expand IF-TRUE, if FLAG is true, IF-FALSE otherwise.
! 248: b4_define_flag_if([defines]) # Whether headers are requested.
! 249: b4_define_flag_if([error_verbose]) # Whether error are verbose.
! 250: b4_define_flag_if([glr]) # Whether a GLR parser is requested.
! 251: b4_define_flag_if([locations]) # Whether locations are tracked.
! 252: b4_define_flag_if([nondeterministic]) # Whether conflicts should be handled.
! 253: b4_define_flag_if([yacc]) # Whether POSIX Yacc is emulated.
! 254:
! 255:
! 256: ## ------------------------- ##
! 257: ## Assigning token numbers. ##
! 258: ## ------------------------- ##
! 259:
! 260:
! 261: ## ----------- ##
! 262: ## Synclines. ##
! 263: ## ----------- ##
! 264:
! 265: # b4_basename(NAME)
! 266: # -----------------
! 267: # Similar to POSIX basename; the differences don't matter here.
! 268: # Beware that NAME is not evaluated.
! 269: m4_define([b4_basename],
! 270: [m4_bpatsubst([$1], [^.*/\([^/]+\)/*$], [\1])])
! 271:
! 272:
! 273: # b4_syncline(LINE, FILE)
! 274: # -----------------------
! 275: m4_define([b4_syncline],
! 276: [b4_flag_if([synclines], [
! 277: b4_sync_end([__line__], [b4_basename(m4_quote(__file__))])
! 278: b4_sync_start([$1], [$2])])])
! 279:
! 280: m4_define([b4_sync_end], [b4_comment([Line $1 of $2])])
! 281: m4_define([b4_sync_start], [b4_comment([Line $1 of $2])])
! 282:
! 283: # b4_user_code(USER-CODE)
! 284: # -----------------------
! 285: # Emit code from the user, ending it with synclines.
! 286: m4_define([b4_user_code],
! 287: [$1
! 288: b4_syncline([@oline@], [@ofile@])])
! 289:
! 290:
! 291: # b4_define_user_code(MACRO)
! 292: # --------------------------
! 293: # From b4_MACRO, build b4_user_MACRO that includes the synclines.
! 294: m4_define([b4_define_user_code],
! 295: [m4_define([b4_user_$1],
! 296: [b4_user_code([b4_$1])])])
! 297:
! 298:
! 299: # b4_user_actions
! 300: # b4_user_initial_action
! 301: # b4_user_post_prologue
! 302: # b4_user_pre_prologue
! 303: # b4_user_stype
! 304: # ----------------------
! 305: # Macros that issue user code, ending with synclines.
! 306: b4_define_user_code([actions])
! 307: b4_define_user_code([initial_action])
! 308: b4_define_user_code([post_prologue])
! 309: b4_define_user_code([pre_prologue])
! 310: b4_define_user_code([stype])
! 311:
! 312:
! 313: # b4_check_user_names(WHAT, USER-LIST, BISON-NAMESPACE)
! 314: # --------------------------------------------------------
! 315: # Warn if any name of type WHAT is used by the user (as recorded in USER-LIST)
! 316: # but is not used by Bison (as recorded by macros in the namespace
! 317: # BISON-NAMESPACE).
! 318: #
! 319: # USER-LIST must expand to a list specifying all grammar occurrences of all
! 320: # names of type WHAT. Each item in the list must be a triplet specifying one
! 321: # occurrence: name, start boundary, and end boundary. Empty string names are
! 322: # fine. An empty list is fine.
! 323: #
! 324: # For example, to define b4_foo_user_names to be used for USER-LIST with three
! 325: # name occurrences and with correct quoting:
! 326: #
! 327: # m4_define([b4_foo_user_names],
! 328: # [[[[[[bar]], [[parser.y:1.7]], [[parser.y:1.16]]]],
! 329: # [[[[bar]], [[parser.y:5.7]], [[parser.y:5.16]]]],
! 330: # [[[[baz]], [[parser.y:8.7]], [[parser.y:8.16]]]]]])
! 331: #
! 332: # The macro BISON-NAMESPACE(bar) must be defined iff the name bar of type WHAT
! 333: # is used by Bison (in the front-end or in the skeleton). Empty string names
! 334: # are fine, but it would be ugly for Bison to actually use one.
! 335: #
! 336: # For example, to use b4_foo_bison_names for BISON-NAMESPACE and define that
! 337: # the names bar and baz are used by Bison:
! 338: #
! 339: # m4_define([b4_foo_bison_names(bar)])
! 340: # m4_define([b4_foo_bison_names(baz)])
! 341: #
! 342: # To invoke b4_check_user_names with TYPE foo, with USER-LIST
! 343: # b4_foo_user_names, with BISON-NAMESPACE b4_foo_bison_names, and with correct
! 344: # quoting:
! 345: #
! 346: # b4_check_user_names([[foo]], [b4_foo_user_names],
! 347: # [[b4_foo_bison_names]])
! 348: m4_define([b4_check_user_names],
! 349: [m4_foreach([b4_occurrence], $2,
! 350: [m4_pushdef([b4_occurrence], b4_occurrence)dnl
! 351: m4_pushdef([b4_user_name], m4_car(b4_occurrence))dnl
! 352: m4_pushdef([b4_start], m4_car(m4_shift(b4_occurrence)))dnl
! 353: m4_pushdef([b4_end], m4_shift(m4_shift(b4_occurrence)))dnl
! 354: m4_ifndef($3[(]m4_quote(b4_user_name)[)],
! 355: [b4_warn_at([b4_start], [b4_end],
! 356: [[%s `%s' is not used]],
! 357: [$1], [b4_user_name])])[]dnl
! 358: m4_popdef([b4_occurrence])dnl
! 359: m4_popdef([b4_user_name])dnl
! 360: m4_popdef([b4_start])dnl
! 361: m4_popdef([b4_end])dnl
! 362: ])])
! 363:
! 364: # b4_percent_define_get(VARIABLE)
! 365: # -------------------------------
! 366: # Mimic muscle_percent_define_get in ../src/muscle_tab.h exactly. That is, if
! 367: # the %define variable VARIABLE is defined, emit its value. Also, record
! 368: # Bison's usage of VARIABLE by defining
! 369: # b4_percent_define_bison_variables(VARIABLE).
! 370: #
! 371: # For example:
! 372: #
! 373: # b4_percent_define_get([[foo]])
! 374: m4_define([b4_percent_define_get],
! 375: [m4_define([b4_percent_define_bison_variables(]$1[)])dnl
! 376: m4_ifdef([b4_percent_define(]$1[)], [m4_indir([b4_percent_define(]$1[)])])])
! 377:
! 378: # b4_percent_define_get_loc(VARIABLE)
! 379: # -----------------------------------
! 380: # Mimic muscle_percent_define_get_loc in ../src/muscle_tab.h exactly. That is,
! 381: # if the %define variable VARIABLE is undefined, complain fatally since that's
! 382: # a Bison or skeleton error. Otherwise, return its definition location in a
! 383: # form approriate for the first two arguments of b4_warn_at, b4_complain_at, or
! 384: # b4_fatal_at. Don't record this as a Bison usage of VARIABLE as there's no
! 385: # reason to suspect that the user-supplied value has yet influenced the output.
! 386: #
! 387: # For example:
! 388: #
! 389: # b4_complain_at(b4_percent_define_get_loc([[foo]]), [[invalid foo]])
! 390: m4_define([b4_percent_define_get_loc],
! 391: [m4_ifdef([b4_percent_define_loc(]$1[)],
! 392: [m4_pushdef([b4_loc], m4_indir([b4_percent_define_loc(]$1[)]))dnl
! 393: b4_loc[]dnl
! 394: m4_popdef([b4_loc])],
! 395: [b4_fatal([[undefined %%define variable `%s' passed to b4_percent_define_get_loc]], [$1])])])
! 396:
! 397: # b4_percent_define_get_syncline(VARIABLE)
! 398: # ----------------------------------------
! 399: # Mimic muscle_percent_define_get_syncline in ../src/muscle_tab.h exactly.
! 400: # That is, if the %define variable VARIABLE is undefined, complain fatally
! 401: # since that's a Bison or skeleton error. Otherwise, return its definition
! 402: # location as a b4_syncline invocation. Don't record this as a Bison usage of
! 403: # VARIABLE as there's no reason to suspect that the user-supplied value has yet
! 404: # influenced the output.
! 405: #
! 406: # For example:
! 407: #
! 408: # b4_percent_define_get_syncline([[foo]])
! 409: m4_define([b4_percent_define_get_syncline],
! 410: [m4_ifdef([b4_percent_define_syncline(]$1[)],
! 411: [m4_indir([b4_percent_define_syncline(]$1[)])],
! 412: [b4_fatal([[undefined %%define variable `%s' passed to b4_percent_define_get_syncline]], [$1])])])
! 413:
! 414: # b4_percent_define_ifdef(VARIABLE, IF-TRUE, [IF-FALSE])
! 415: # ------------------------------------------------------
! 416: # Mimic muscle_percent_define_ifdef in ../src/muscle_tab.h exactly. That is,
! 417: # if the %define variable VARIABLE is defined, expand IF-TRUE, else expand
! 418: # IF-FALSE. Also, record Bison's usage of VARIABLE by defining
! 419: # b4_percent_define_bison_variables(VARIABLE).
! 420: #
! 421: # For example:
! 422: #
! 423: # b4_percent_define_ifdef([[foo]], [[it's defined]], [[it's undefined]])
! 424: m4_define([b4_percent_define_ifdef],
! 425: [m4_ifdef([b4_percent_define(]$1[)],
! 426: [m4_define([b4_percent_define_bison_variables(]$1[)])$2],
! 427: [$3])])
! 428:
! 429: # b4_percent_define_flag_if(VARIABLE, IF-TRUE, [IF-FALSE])
! 430: # --------------------------------------------------------
! 431: # Mimic muscle_percent_define_flag_if in ../src/muscle_tab.h exactly. That is,
! 432: # if the %define variable VARIABLE is defined to "" or "true", expand IF-TRUE.
! 433: # If it is defined to "false", expand IF-FALSE. Complain if it is undefined
! 434: # (a Bison or skeleton error since the default value should have been set
! 435: # already) or defined to any other value (possibly a user error). Also, record
! 436: # Bison's usage of VARIABLE by defining
! 437: # b4_percent_define_bison_variables(VARIABLE).
! 438: #
! 439: # For example:
! 440: #
! 441: # b4_percent_define_flag_if([[foo]], [[it's true]], [[it's false]])
! 442: m4_define([b4_percent_define_flag_if],
! 443: [b4_percent_define_ifdef([$1],
! 444: [m4_case(b4_percent_define_get([$1]),
! 445: [], [$2], [true], [$2], [false], [$3],
! 446: [m4_expand_once([b4_complain_at(b4_percent_define_get_loc([$1]),
! 447: [[invalid value for %%define Boolean variable `%s']],
! 448: [$1])],
! 449: [[b4_percent_define_flag_if($1)]])])],
! 450: [b4_fatal([[undefined %%define variable `%s' passed to b4_percent_define_flag_if]], [$1])])])
! 451:
! 452: # b4_percent_define_default(VARIABLE, DEFAULT)
! 453: # --------------------------------------------
! 454: # Mimic muscle_percent_define_default in ../src/muscle_tab.h exactly. That is,
! 455: # if the %define variable VARIABLE is undefined, set its value to DEFAULT.
! 456: # Don't record this as a Bison usage of VARIABLE as there's no reason to
! 457: # suspect that the value has yet influenced the output.
! 458: #
! 459: # For example:
! 460: #
! 461: # b4_percent_define_default([[foo]], [[default value]])
! 462: m4_define([b4_percent_define_default],
! 463: [m4_ifndef([b4_percent_define(]$1[)],
! 464: [m4_define([b4_percent_define(]$1[)], [$2])dnl
! 465: m4_define([b4_percent_define_loc(]$1[)],
! 466: [[[[<skeleton default value>:-1.-1]],
! 467: [[<skeleton default value>:-1.-1]]]])dnl
! 468: m4_define([b4_percent_define_syncline(]$1[)], [[]])])])
! 469:
! 470: # b4_percent_define_check_values(VALUES)
! 471: # --------------------------------------
! 472: # Mimic muscle_percent_define_check_values in ../src/muscle_tab.h exactly
! 473: # except that the VALUES structure is more appropriate for M4. That is, VALUES
! 474: # is a list of sublists of strings. For each sublist, the first string is the
! 475: # name of a %define variable, and all remaining strings in that sublist are the
! 476: # valid values for that variable. Complain if such a variable is undefined (a
! 477: # Bison error since the default value should have been set already) or defined
! 478: # to any other value (possibly a user error). Don't record this as a Bison
! 479: # usage of the variable as there's no reason to suspect that the value has yet
! 480: # influenced the output.
! 481: #
! 482: # For example:
! 483: #
! 484: # b4_percent_define_check_values([[[[foo]], [[foo-value1]], [[foo-value2]]]],
! 485: # [[[[bar]], [[bar-value1]]]])
! 486: m4_define([b4_percent_define_check_values],
! 487: [m4_foreach([b4_sublist], m4_quote($@),
! 488: [_b4_percent_define_check_values(b4_sublist)])])
! 489:
! 490: m4_define([_b4_percent_define_check_values],
! 491: [m4_ifdef([b4_percent_define(]$1[)],
! 492: [m4_pushdef([b4_good_value], [0])dnl
! 493: m4_if($#, 1, [],
! 494: [m4_foreach([b4_value], m4_dquote(m4_shift($@)),
! 495: [m4_if(m4_indir([b4_percent_define(]$1[)]), b4_value,
! 496: [m4_define([b4_good_value], [1])])])])dnl
! 497: m4_if(b4_good_value, [0],
! 498: [b4_complain_at(b4_percent_define_get_loc([$1]),
! 499: [[invalid value for %%define variable `%s': `%s']],
! 500: [$1],
! 501: m4_dquote(m4_indir([b4_percent_define(]$1[)])))])dnl
! 502: m4_popdef([b4_good_value])],
! 503: [b4_fatal([[undefined %%define variable `%s' passed to b4_percent_define_check_values]], [$1])])])
! 504:
! 505: # b4_percent_code_get([QUALIFIER])
! 506: # --------------------------------
! 507: # If any %code blocks for QUALIFIER are defined, emit them beginning with a
! 508: # comment and ending with synclines and a newline. If QUALIFIER is not
! 509: # specified or empty, do this for the unqualified %code blocks. Also, record
! 510: # Bison's usage of QUALIFIER (if specified) by defining
! 511: # b4_percent_code_bison_qualifiers(QUALIFIER).
! 512: #
! 513: # For example, to emit any unqualified %code blocks followed by any %code
! 514: # blocks for the qualifier foo:
! 515: #
! 516: # b4_percent_code_get
! 517: # b4_percent_code_get([[foo]])
! 518: m4_define([b4_percent_code_get],
! 519: [m4_pushdef([b4_macro_name], [[b4_percent_code(]$1[)]])dnl
! 520: m4_ifval([$1], [m4_define([b4_percent_code_bison_qualifiers(]$1[)])])dnl
! 521: m4_ifdef(b4_macro_name,
! 522: [b4_comment([m4_if([$#], [0], [[Unqualified %code]],
! 523: [["%code ]$1["]])[ blocks.]])
! 524: b4_user_code([m4_indir(b4_macro_name)])
! 525: ])dnl
! 526: m4_popdef([b4_macro_name])])
! 527:
! 528: # b4_percent_code_ifdef(QUALIFIER, IF-TRUE, [IF-FALSE])
! 529: # -----------------------------------------------------
! 530: # If any %code blocks for QUALIFIER (or unqualified %code blocks if
! 531: # QUALIFIER is empty) are defined, expand IF-TRUE, else expand IF-FALSE.
! 532: # Also, record Bison's usage of QUALIFIER (if specified) by defining
! 533: # b4_percent_code_bison_qualifiers(QUALIFIER).
! 534: m4_define([b4_percent_code_ifdef],
! 535: [m4_ifdef([b4_percent_code(]$1[)],
! 536: [m4_ifval([$1], [m4_define([b4_percent_code_bison_qualifiers(]$1[)])])$2],
! 537: [$3])])
! 538:
! 539:
! 540: ## ----------------------------------------------------------- ##
! 541: ## After processing the skeletons, check that all the user's ##
! 542: ## %define variables and %code qualifiers were used by Bison. ##
! 543: ## ----------------------------------------------------------- ##
! 544:
! 545: m4_define([b4_check_user_names_wrap],
! 546: [m4_ifdef([b4_percent_]$1[_user_]$2[s],
! 547: [b4_check_user_names([[%]$1 $2],
! 548: [b4_percent_]$1[_user_]$2[s],
! 549: [[b4_percent_]$1[_bison_]$2[s]])])])
! 550:
! 551: m4_wrap_lifo([
! 552: b4_check_user_names_wrap([[define]], [[variable]])
! 553: b4_check_user_names_wrap([[code]], [[qualifier]])
! 554: ])
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bison.m4 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / win32 / tools / cygwin / usr / share / bison