X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/7ecec4ddf9e1640c7133e0be0788b1d30ece20ec..75ad86eebd3f49dff81976eb83036eb7b7793e68:/data/bison.m4 diff --git a/data/bison.m4 b/data/bison.m4 index 6ac4d9b0..0aa1efdc 100644 --- a/data/bison.m4 +++ b/data/bison.m4 @@ -285,107 +285,173 @@ b4_define_user_code([pre_prologue]) b4_define_user_code([stype]) -# b4_check_user_names(WHAT, USER-LIST, SKELETON-LIST) -# --------------------------------------------------- +# 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 the skeleton (as recorded in SKELETON-LIST). +# but is not used by Bison (as recorded by macros in the namespace +# BISON-NAMESPACE). # # USER-LIST must expand to a list specifying all grammar occurrences of all -# names of type WHAT. Each item in the list is a triplet specifying one +# 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. # -# For example, to define b4_user_foo_names to be used for USER-LIST with three +# For example, to define b4_foo_user_names to be used for USER-LIST with three # name occurrences and with correct quoting: # -# m4_define([b4_user_foo_names], +# 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]]]]]]) # -# SKELETON-LIST must expand to a list specifying all names of type WHAT that -# are used by the skeleton. Multiple occurrences of the same name are fine. -# Empty string names are fine, but it would be ugly for a Bison skeleton to -# actually use one. An empty list is fine. +# 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. # -# For example, to define b4_skeleton_foo_names to be used for SKELETON-LIST -# with two names and with correct quoting: +# For example, to use b4_foo_bison_names for BISON-NAMESPACE and define that +# the names bar and baz are used by Bison: # -# m4_define([b4_skeleton_foo_names], -# [[[[bar]], [[baz]]]]) +# m4_define([b4_foo_bison_names(bar)]) +# m4_define([b4_foo_bison_names(baz)]) # # To invoke b4_check_user_names with TYPE foo, with USER-LIST -# b4_user_foo_names, with SKELETON-LIST b4_skeleton_foo_names, and with correct +# b4_foo_user_names, with BISON-NAMESPACE b4_foo_bison_names, and with correct # quoting: # -# b4_check_user_names([[foo]], [b4_user_foo_names], [b4_skeleton_foo_names]) +# 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_pushdef([b4_found], [[0]])dnl -m4_foreach([b4_skeleton_name], $3, - [m4_if(m4_quote(b4_user_name), - m4_quote(b4_skeleton_name), - [m4_define([b4_found], [[1]])])])dnl -m4_if(b4_found, [0], [b4_warn_at([b4_start], [b4_end], - [[%s `%s' is not used]], - [$1], [b4_user_name])])[]dnl -m4_popdef([b4_found])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_get_percent_define(VARIABLE) -# -------------------------------- -# If the %define variable VARIABLE is defined, emit it. Also, record VARIABLE -# in b4_skeleton_percent_define_variables. -m4_define([b4_get_percent_define], -[m4_append([b4_skeleton_percent_define_variables], [[$1]], [[, ]])dnl -m4_ifdef([b4_percent_define_]$1, [b4_percent_define_]$1)]) - -# b4_get_percent_code([QUALIFIER]) +# b4_percent_define_get(VARIABLE) +# ------------------------------- +# 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]) +# ------------------------------------------------------ +# 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 (thus, b4_get_percent_code is invoked without parens), do this for -# the unqualified %code blocks. Also, record QUALIFIER (if specified) in -# b4_skeleton_percent_code_qualifiers. -m4_define([b4_get_percent_code], -[m4_pushdef([b4_macro_name], [[b4_percent_code]]m4_if([$#], [1], [[[_]$1]]))dnl -m4_if([$#], [1], - [m4_append([b4_skeleton_percent_code_qualifiers], [[$1]], [[, ]])])dnl +# 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(b4_macro_name)])dnl +b4_user_code([m4_indir(b4_macro_name)]) +])dnl m4_popdef([b4_macro_name])]) - -## --------------------------------------------------------- ## -## After processing the skeletons, check that all the user's ## -## %define variables and %code qualifiers were used. ## -## --------------------------------------------------------- ## +# 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([ -m4_pushdef([b4_check_user_names_wrap], -[m4_ifdef([b4_skeleton_percent_$1], - [m4_define([b4_skeleton_percent_$1], - m4_dquote(m4_dquote(b4_skeleton_percent_$1)))], - [m4_define([b4_skeleton_percent_$1], [[]])]) - -m4_ifdef([b4_user_percent_$1], - [b4_check_user_names([$2], - [b4_user_percent_$1], - [b4_skeleton_percent_$1])]) -]) - -b4_check_user_names_wrap([define_variables], [[%define variable]]) -b4_check_user_names_wrap([code_qualifiers], [[%code qualifier]]) - -m4_popdef([b4_check_user_names_wrap]) +b4_check_user_names_wrap([[define]], [[variable]]) +b4_check_user_names_wrap([[code]], [[qualifier]]) ])