X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/1c7b7e1d87f698efb2e3daad0f6484829563d96f..14462c2b1b55540d78ce1f1dc4fe67fcd1c701ac:/data/bison.m4 diff --git a/data/bison.m4 b/data/bison.m4 index 052dafaa..644b66d7 100644 --- a/data/bison.m4 +++ b/data/bison.m4 @@ -66,7 +66,7 @@ version 2.2 of Bison.])]) ## ---------------- ## # b4_error(KIND, FORMAT, [ARG1], [ARG2], ...) -# --------------------------------------------------------------- +# ------------------------------------------- # Write @KIND(FORMAT@,ARG1@,ARG2@,...@) to diversion 0. m4_define([b4_error], [m4_divert_push(0)[@]$1[(]$2[]m4_if([$#], [2], [], @@ -74,8 +74,17 @@ m4_define([b4_error], m4_dquote(m4_shift(m4_shift($@))), [[@,]b4_arg])])[@)]m4_divert_pop(0)]) +# b4_error_at(KIND, START, END, FORMAT, [ARG1], [ARG2], ...) +# ---------------------------------------------------------- +# Write @KIND(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to diversion 0. +m4_define([b4_error_at], +[m4_divert_push(0)[@]$1[_at(]$2[@,]$3[@,]$4[]m4_if([$#], [4], [], +[m4_foreach([b4_arg], + m4_dquote(m4_shift(m4_shift(m4_shift(m4_shift($@))))), + [[@,]b4_arg])])[@)]m4_divert_pop(0)]) + # b4_warn(FORMAT, [ARG1], [ARG2], ...) -# -------------------------------------------------------- +# ------------------------------------ # Write @warn(FORMAT@,ARG1@,ARG2@,...@) to diversion 0. # # As a simple test suite, this: @@ -89,8 +98,6 @@ m4_define([b4_error], # m4_divert(0) # b4_warn([asdf), asdf], [fsa), fsa], [fdsa), fdsa]) # m4_divert(0) -# b4_warn -# m4_divert(0) # b4_warn() # m4_divert(0) # b4_warn(1) @@ -103,34 +110,53 @@ m4_define([b4_error], # @warn(asdf), asdf@,fsa), fsa@,fdsa), fdsa@) # @warn(ASDF), ASDF@,FSA), FSA@,FDSA), FDSA@) # @warn(@) -# @warn(@) # @warn(1@) # @warn(1@,2@) m4_define([b4_warn], [b4_error([[warn]], $@)]) +# b4_warn_at(START, END, FORMAT, [ARG1], [ARG2], ...) +# --------------------------------------------------- +# Write @warn(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to diversion 0. +m4_define([b4_warn_at], +[b4_error_at([[warn]], $@)]) + # b4_complain(FORMAT, [ARG1], [ARG2], ...) -# ------------------------------------------------------------ +# ---------------------------------------- # Write @complain(FORMAT@,ARG1@,ARG2@,...@) to diversion 0. # # See the test suite for b4_warn above. m4_define([b4_complain], [b4_error([[complain]], $@)]) +# b4_complain_at(START, END, FORMAT, [ARG1], [ARG2], ...) +# ------------------------------------------------------- +# Write @complain(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to diversion 0. +m4_define([b4_complain_at], +[b4_error_at([[complain]], $@)]) + # b4_fatal(FORMAT, [ARG1], [ARG2], ...) -# --------------------------------------------------------- +# ------------------------------------- # Write @fatal(FORMAT@,ARG1@,ARG2@,...@) to diversion 0. # # See the test suite for b4_warn above. m4_define([b4_fatal], [b4_error([[fatal]], $@)]) +# b4_fatal_at(START, END, FORMAT, [ARG1], [ARG2], ...) +# ---------------------------------------------------- +# Write @fatal(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to diversion 0. +m4_define([b4_fatal_at], +[b4_error_at([[fatal]], $@)]) + ## ---------------- ## ## Default values. ## ## ---------------- ## # m4_define_default([b4_lex_param], []) dnl breaks other skeletons +m4_define_default([b4_pre_prologue], []) +m4_define_default([b4_post_prologue], []) m4_define_default([b4_epilogue], []) m4_define_default([b4_parse_param], []) @@ -259,46 +285,175 @@ b4_define_user_code([pre_prologue]) b4_define_user_code([stype]) -# b4_check_percent_code_qualifiers([VAILD_QUALIFIER], [VALID_QUALIFIER], ...) -# --------------------------------------------------------------------------- -# Complain if any %code qualifier used in the grammar is not a valid qualifier. +# b4_check_user_names(WHAT, USER-LIST, BISON-NAMESPACE) +# -------------------------------------------------------- +# Warn if any name of type WHAT is used by the user (as recorded in USER-LIST) +# but is not used by Bison (as recorded by macros in the namespace +# BISON-NAMESPACE). # -# If no %code qualifiers are used in the grammar, -# b4_used_percent_code_qualifiers must be undefined or expand to the empty -# string. Otherwise, it must expand to a comma-delimited list specifying all -# %code qualifiers used in the grammar. Each item in the list must expand to -# text that expands to one of those qualifiers. For example, to define -# b4_used_percent_code_qualifiers with two qualifiers with correct quoting: +# USER-LIST must expand to a list specifying all grammar occurrences of all +# names of type WHAT. Each item in the list must be a triplet specifying one +# occurrence: name, start boundary, and end boundary. Empty string names are +# fine. An empty list is fine. # -# m4_define([b4_used_percent_code_qualifiers], -# [[[[requires]], [[provides]]]]) +# For example, to define b4_foo_user_names to be used for USER-LIST with three +# name occurrences and with correct quoting: # -# Multiple occurrences of the same qualifier are fine. Empty string qualifiers -# are fine. +# m4_define([b4_foo_user_names], +# [[[[[[bar]], [[parser.y:1.7]], [[parser.y:1.16]]]], +# [[[[bar]], [[parser.y:5.7]], [[parser.y:5.16]]]], +# [[[[baz]], [[parser.y:8.7]], [[parser.y:8.16]]]]]]) # -# Each VALID_QUALIFIER must expand to a valid qualifier. For example, -# b4_check_percent_code_qualifiers might be invoked with: +# The macro BISON-NAMESPACE(bar) must be defined iff the name bar of type WHAT +# is used by Bison (in the front-end or in the skeleton). Empty string names +# are fine, but it would be ugly for Bison to actually use one. # -# b4_check_percent_code_qualifiers([[requires]], [[provides]]) +# For example, to use b4_foo_bison_names for BISON-NAMESPACE and define that +# the names bar and baz are used by Bison: # -# Multiple occurrences of the same valid qualifier are fine. A VALID_QUALIFIER -# that expands to the empty string will correctly define the empty string as a -# valid qualifier, but it would be ugly for a Bison skeleton to actually use -# that. If b4_used_percent_code_qualifiers is invoked with empty parens, then -# there is one valid qualifier and it is the empty string. To specify that -# there are no valid qualifiers, invoke b4_check_percent_code_qualifiers -# without parens. +# m4_define([b4_foo_bison_names(bar)]) +# m4_define([b4_foo_bison_names(baz)]) # -# Qualifiers and valid qualifiers must not contain the character `,'. -m4_define([b4_check_percent_code_qualifiers], -[m4_ifdef([b4_used_percent_code_qualifiers], [ -m4_foreach([b4_qualifier], - b4_used_percent_code_qualifiers, - [m4_if(m4_index(m4_if($#, 0, [], [[,]m4_quote($*)[,]]), - [,]b4_qualifier[,]), - [-1], - [b4_complain([[`%s' is not a recognized %%code qualifier]], - [b4_qualifier]) - ]) - ]) +# To invoke b4_check_user_names with TYPE foo, with USER-LIST +# b4_foo_user_names, with BISON-NAMESPACE b4_foo_bison_names, and with correct +# quoting: +# +# b4_check_user_names([[foo]], [b4_foo_user_names], +# [[b4_foo_bison_names]]) +m4_define([b4_check_user_names], +[m4_foreach([b4_occurrence], $2, +[m4_pushdef([b4_occurrence], b4_occurrence)dnl +m4_pushdef([b4_user_name], m4_car(b4_occurrence))dnl +m4_pushdef([b4_start], m4_car(m4_shift(b4_occurrence)))dnl +m4_pushdef([b4_end], m4_shift(m4_shift(b4_occurrence)))dnl +m4_ifndef($3[(]m4_quote(b4_user_name)[)], + [b4_warn_at([b4_start], [b4_end], + [[%s `%s' is not used]], + [$1], [b4_user_name])])[]dnl +m4_popdef([b4_occurrence])dnl +m4_popdef([b4_user_name])dnl +m4_popdef([b4_start])dnl +m4_popdef([b4_end])dnl ])]) + +# b4_percent_define_get(VARIABLE) +# ------------------------------- +# Mimic muscle_percent_define_get in ../src/muscle_tab.h exactly. That is, if +# the %define variable VARIABLE is defined, emit its value. Also, record +# Bison's usage of VARIABLE by defining +# b4_percent_define_bison_variables(VARIABLE). +# +# For example: +# +# b4_percent_define_get([[foo]]) +m4_define([b4_percent_define_get], +[m4_define([b4_percent_define_bison_variables(]$1[)])dnl +m4_ifdef([b4_percent_define(]$1[)], [m4_indir([b4_percent_define(]$1[)])])]) + +# b4_percent_define_ifdef(VARIABLE, IF-TRUE, [IF-FALSE]) +# ------------------------------------------------------ +# Mimic muscle_percent_define_ifdef in ../src/muscle_tab.h exactly. That is, +# if the %define variable VARIABLE is defined, expand IF-TRUE, else expand +# IF-FALSE. Also, record Bison's usage of VARIABLE by defining +# b4_percent_define_bison_variables(VARIABLE). +# +# For example: +# +# b4_percent_define_ifdef([[foo]], [[it's defined]], [[it's undefined]]) +m4_define([b4_percent_define_ifdef], +[m4_ifdef([b4_percent_define(]$1[)], + [m4_define([b4_percent_define_bison_variables(]$1[)])$2], + [$3])]) + +# b4_percent_define_flag_if(VARIABLE, IF-TRUE, [IF-FALSE]) +# -------------------------------------------------------- +# Mimic muscle_percent_define_flag_if in ../src/muscle_tab.h exactly. That is, +# if the %define variable VARIABLE is defined to "" or "true", expand IF-TRUE. +# If it is defined to "false", expand IF-FALSE. Complain if it is undefined +# (a Bison or skeleton error since the default value should have been set +# already) or defined to any other value (possibly a user error). Also, record +# Bison's usage of VARIABLE by defining +# b4_percent_define_bison_variables(VARIABLE). +# +# For example: +# +# b4_percent_define_flag_if([[foo]], [[it's true]], [[it's false]]) +m4_define([b4_percent_define_flag_if], +[b4_percent_define_ifdef([$1], + [m4_case(b4_percent_define_get([$1]), + [], [$2], [true], [$2], [false], [$3], + [m4_expand_once([dnl + m4_pushdef([b4_loc], m4_indir([b4_percent_define_loc(]$1[)]))dnl + b4_complain_at(b4_loc, + [[invalid value for %%define boolean variable `%s']], + [$1])dnl + m4_popdef([b4_loc])], + [[b4_percent_define_flag_if($1)]])])], + [b4_fatal([[undefined %%define variable `%s' passed to b4_percent_define_flag_if]], [$1])])]) + +# b4_percent_define_default(VARIABLE, DEFAULT) +# -------------------------------------------- +# Mimic muscle_percent_define_default in ../src/muscle_tab.h exactly. That is, +# if the %define variable VARIABLE is undefined, set its value to DEFAULT. +# Don't record this as a Bison usage of VARIABLE as there's no reason to +# suspect that the value has yet influenced the output. +# +# For example: +# +# b4_percent_define_default([[foo]], [[default value]]) +m4_define([b4_percent_define_default], +[m4_ifndef([b4_percent_define(]$1[)], + [m4_define([b4_percent_define(]$1[)], [$2])dnl + m4_define([b4_percent_define_loc(]$1[)], + [[[[[Bison:b4_percent_define_default]:0.0]], [[[Bison:b4_percent_define_default]:0.0]]]])])]) + +# b4_percent_code_get([QUALIFIER]) +# -------------------------------- +# If any %code blocks for QUALIFIER are defined, emit them beginning with a +# comment and ending with synclines and a newline. If QUALIFIER is not +# specified or empty, do this for the unqualified %code blocks. Also, record +# Bison's usage of QUALIFIER (if specified) by defining +# b4_percent_code_bison_qualifiers(QUALIFIER). +# +# For example, to emit any unqualified %code blocks followed by any %code +# blocks for the qualifier foo: +# +# b4_percent_code_get +# b4_percent_code_get([[foo]]) +m4_define([b4_percent_code_get], +[m4_pushdef([b4_macro_name], [[b4_percent_code(]$1[)]])dnl +m4_ifval([$1], [m4_define([b4_percent_code_bison_qualifiers(]$1[)])])dnl +m4_ifdef(b4_macro_name, +[b4_comment([m4_if([$#], [0], [[Unqualified %code]], + [[%code "]$1["]])[ blocks.]]) +b4_user_code([m4_indir(b4_macro_name)]) +])dnl +m4_popdef([b4_macro_name])]) + +# b4_percent_code_ifdef(QUALIFIER, IF-TRUE, [IF-FALSE]) +# ----------------------------------------------------- +# If any %code blocks for QUALIFIER (or unqualified %code blocks if +# QUALIFIER is empty) are defined, expand IF-TRUE, else expand IF-FALSE. +# Also, record Bison's usage of QUALIFIER (if specified) by defining +# b4_percent_code_bison_qualifiers(QUALIFIER). +m4_define([b4_percent_code_ifdef], +[m4_ifdef([b4_percent_code(]$1[)], + [m4_ifval([$1], [m4_define([b4_percent_code_bison_qualifiers(]$1[)])])$2], + [$3])]) + + +## ----------------------------------------------------------- ## +## After processing the skeletons, check that all the user's ## +## %define variables and %code qualifiers were used by Bison. ## +## ----------------------------------------------------------- ## + +m4_define([b4_check_user_names_wrap], +[m4_ifdef([b4_percent_]$1[_user_]$2[s], + [b4_check_user_names([[%]$1 $2], + [b4_percent_]$1[_user_]$2[s], + [[b4_percent_]$1[_bison_]$2[s]])])]) + +m4_wrap([ +b4_check_user_names_wrap([[define]], [[variable]]) +b4_check_user_names_wrap([[code]], [[qualifier]]) +])