X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/90b9908d8c367fc7d971accec9aebdd50a062ce7..9611cfa20bf95cf06b79c598ae5e69979ea1ff8e:/data/bison.m4 diff --git a/data/bison.m4 b/data/bison.m4 index 6b3d5e86..0aa1efdc 100644 --- a/data/bison.m4 +++ b/data/bison.m4 @@ -1,7 +1,7 @@ -m4_divert(-1) -*- Autoconf -*- + -*- Autoconf -*- # Language-independent M4 Macros for Bison. -# Copyright (C) 2002, 2004, 2005, 2006 Free Software Foundation, Inc. +# Copyright (C) 2002, 2004, 2005, 2006, 2007 Free Software Foundation, Inc. # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -61,11 +61,102 @@ This special exception was added by the Free Software Foundation in version 2.2 of Bison.])]) +## ---------------- ## +## Error handling. ## +## ---------------- ## + +# 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], [], +[m4_foreach([b4_arg], + 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: +# +# m4_define([asdf], [ASDF]) +# m4_define([fsa], [FSA]) +# m4_define([fdsa], [FDSA]) +# b4_warn([[[asdf), asdf]]], [[[fsa), fsa]]], [[[fdsa), fdsa]]]) +# m4_divert(0) +# b4_warn([[asdf), asdf]], [[fsa), fsa]], [[fdsa), fdsa]]) +# m4_divert(0) +# b4_warn([asdf), asdf], [fsa), fsa], [fdsa), fdsa]) +# m4_divert(0) +# b4_warn() +# m4_divert(0) +# b4_warn(1) +# m4_divert(0) +# b4_warn(1, 2) +# +# Should produce this: +# +# @warn([asdf), asdf]@,[fsa), fsa]@,[fdsa), fdsa]@) +# @warn(asdf), asdf@,fsa), fsa@,fdsa), fdsa@) +# @warn(ASDF), ASDF@,FSA), FSA@,FDSA), FDSA@) +# @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], []) @@ -127,8 +218,13 @@ b4_define_flag_if([error_verbose]) # Whether error are verbose. b4_define_flag_if([glr]) # Whether a GLR parser is requested. b4_define_flag_if([locations]) # Whether locations are tracked. b4_define_flag_if([nondeterministic]) # Whether conflicts should be handled. +b4_define_flag_if([pull]) # Whether pull parsing is requested. b4_define_flag_if([pure]) # Whether the interface is pure. -b4_define_flag_if([push]) # Whether push parsing is supported. +b4_define_flag_if([push]) # Whether push parsing is requested. +b4_define_flag_if([use_push_for_pull]) # Whether push parsing should be used + # in place of pull parsing (where + # available) for the sake of the test + # suite. b4_define_flag_if([yacc]) # Whether POSIX Yacc is emulated. @@ -178,14 +274,184 @@ m4_define([b4_define_user_code], # b4_user_actions # b4_user_initial_action # b4_user_post_prologue -# b4_user_start_header +# b4_user_pre_prologue # b4_user_stype # ---------------------- # Macros that issue user code, ending with synclines. b4_define_user_code([actions]) b4_define_user_code([initial_action]) b4_define_user_code([post_prologue]) -b4_define_user_code([start_header]) +b4_define_user_code([pre_prologue]) b4_define_user_code([stype]) +# 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). +# +# 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. +# +# 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_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]]]]]]) +# +# 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 use b4_foo_bison_names for BISON-NAMESPACE and define that +# the names bar and baz are used by Bison: +# +# 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_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) +# ------------------------------- +# 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 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]]) +])