X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/575619af5e1f61a5f78fb3910bee424ead5fe5a6..f6b561d9f9cbc6fc95bbb86518372a5cb52f45a6:/data/bison.m4 diff --git a/data/bison.m4 b/data/bison.m4 index bbf90aae..1907e42e 100644 --- a/data/bison.m4 +++ b/data/bison.m4 @@ -2,7 +2,7 @@ # Language-independent M4 Macros for Bison. -# Copyright (C) 2002, 2004-2011 Free Software Foundation, Inc. +# Copyright (C) 2002, 2004-2012 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 @@ -82,30 +82,16 @@ _m4eof ])dnl m4_if(m4_sysval, [0], [], [m4_fatal([$0: cannot write to stdout])])]) -# b4_error(KIND, FORMAT, [ARG1], [ARG2], ...) -# ------------------------------------------- -# Write @KIND(FORMAT@,ARG1@,ARG2@,...@) to stdout. +# b4_error(KIND, START, END, FORMAT, [ARG1], [ARG2], ...) +# ------------------------------------------------------- +# Write @KIND(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout. # # For example: # -# b4_error([[warn]], [[invalid value for `%s': %s]], [[foo]], [[3]]) +# b4_error([[complain]], [[input.y:2.3]], [[input.y:5.4]], +# [[invalid %s]], [[foo]]) m4_define([b4_error], -[b4_cat([[@]$1[(]$2[]]dnl -[m4_if([$#], [2], [], - [m4_foreach([b4_arg], - m4_dquote(m4_shift(m4_shift($@))), - [[@,]b4_arg])])[@)]])]) - -# b4_error_at(KIND, START, END, FORMAT, [ARG1], [ARG2], ...) -# ---------------------------------------------------------- -# Write @KIND_at(START@,END@,FORMAT@,ARG1@,ARG2@,...@) to stdout. -# -# For example: -# -# b4_error_at([[complain]], [[input.y:2.3]], [[input.y:5.4]], -# [[invalid %s]], [[foo]]) -m4_define([b4_error_at], -[b4_cat([[@]$1[_at(]$2[@,]$3[@,]$4[]]dnl +[b4_cat([[@complain][(]$1[@,]$2[@,]$3[@,]$4[]]dnl [m4_if([$#], [4], [], [m4_foreach([b4_arg], m4_dquote(m4_shift(m4_shift(m4_shift(m4_shift($@))))), @@ -117,7 +103,7 @@ m4_define([b4_error_at], # # For example: # -# b4_warn([[invalid value for `%s': %s]], [[foo]], [[3]]) +# b4_warn([[invalid value for '%s': %s]], [[foo]], [[3]]) # # As a simple test suite, this: # @@ -125,21 +111,21 @@ m4_define([b4_error_at], # m4_define([asdf], [ASDF]) # m4_define([fsa], [FSA]) # m4_define([fdsa], [FDSA]) -# b4_warn([[[asdf), asdf]]], [[[fsa), fsa]]], [[[fdsa), fdsa]]]) -# b4_warn([[asdf), asdf]], [[fsa), fsa]], [[fdsa), fdsa]]) -# b4_warn() -# b4_warn(1) -# b4_warn(1, 2) +# b4_warn_at([[[asdf), asdf]]], [[[fsa), fsa]]], [[[fdsa), fdsa]]]) +# b4_warn_at([[asdf), asdf]], [[fsa), fsa]], [[fdsa), fdsa]]) +# b4_warn_at() +# b4_warn_at(1) +# b4_warn_at(1, 2) # # Should produce this without newlines: # -# @warn([asdf), asdf]@,[fsa), fsa]@,[fdsa), fdsa]@) -# @warn(asdf), asdf@,fsa), fsa@,fdsa), fdsa@) +# @warn_at([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_error([[warn]], [], [], $@)]) # b4_warn_at(START, END, FORMAT, [ARG1], [ARG2], ...) # --------------------------------------------------- @@ -149,15 +135,15 @@ m4_define([b4_warn], # # b4_warn_at([[input.y:2.3]], [[input.y:5.4]], [[invalid %s]], [[foo]]) m4_define([b4_warn_at], -[b4_error_at([[warn]], $@)]) +[b4_error([[warn]], $@)]) # b4_complain(FORMAT, [ARG1], [ARG2], ...) # ---------------------------------------- -# Write @complain(FORMAT@,ARG1@,ARG2@,...@) to stdout. +# Bounce to b4_complain_at. # # See b4_warn example. m4_define([b4_complain], -[b4_error([[complain]], $@)]) +[b4_error([[complain]], [], [], $@)]) # b4_complain_at(START, END, FORMAT, [ARG1], [ARG2], ...) # ------------------------------------------------------- @@ -165,15 +151,15 @@ m4_define([b4_complain], # # See b4_warn_at example. m4_define([b4_complain_at], -[b4_error_at([[complain]], $@)]) +[b4_error([[complain]], $@)]) # b4_fatal(FORMAT, [ARG1], [ARG2], ...) # ------------------------------------- -# Write @fatal(FORMAT@,ARG1@,ARG2@,...@) to stdout and exit. +# Bounce to b4_fatal_at. # # See b4_warn example. m4_define([b4_fatal], -[b4_error([[fatal]], $@)dnl +[b4_error([[fatal]], [], [], $@)dnl m4_exit(1)]) # b4_fatal_at(START, END, FORMAT, [ARG1], [ARG2], ...) @@ -182,25 +168,10 @@ m4_exit(1)]) # # See b4_warn_at example. m4_define([b4_fatal_at], -[b4_error_at([[fatal]], $@)dnl +[b4_error([[fatal]], $@)dnl m4_exit(1)]) -## ---------------- ## -## 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], []) - -# The initial column and line. -m4_define_default([b4_location_initial_column], [1]) -m4_define_default([b4_location_initial_line], [1]) - - ## ------------ ## ## Data Types. ## ## ------------ ## @@ -221,23 +192,23 @@ m4_define([b4_subtract], [m4_eval([$1 - $2])], [($1) - ($2)])]) -# b4_args(ARG1, ...) -# _b4_args(ARG1, ...) +# b4_join(ARG1, ...) +# _b4_join(ARG1, ...) # ------------------- # Join with comma, skipping empty arguments. -# b4_args calls itself recursively until it sees the first non-empty -# argument, then calls _b4_args which prepends each non-empty argument +# b4_join calls itself recursively until it sees the first non-empty +# argument, then calls _b4_join which prepends each non-empty argument # with a comma. -m4_define([b4_args], +m4_define([b4_join], [m4_if([$#$1], [1], [], [m4_ifval([$1], [$1[]_$0(m4_shift($@))], [$0(m4_shift($@))])])]) -# _b4_args(ARGS1, ...) +# _b4_join(ARGS1, ...) # -------------------- -m4_define([_b4_args], +m4_define([_b4_join], [m4_if([$#$1], [1], [], [m4_ifval([$1], [, $1])[]$0(m4_shift($@))])]) @@ -304,8 +275,8 @@ m4_define([b4_parser_tables_define], m4_define([b4_flag_if], [m4_case(b4_$1_flag, [0], [$3], - [1], [$2], - [m4_fatal([invalid $1 value: ]$1)])]) + [1], [$2], + [m4_fatal([invalid $1 value: ]$1)])]) # b4_define_flag_if(FLAG) @@ -317,9 +288,9 @@ m4_define([b4_define_flag_if], # _b4_define_flag_if($1, $2, FLAG) # -------------------------------- -# This macro works around the impossibility to define macros -# inside macros, because issuing `[$1]' is not possible in M4 :(. -# This sucks hard, GNU M4 should really provide M5 like $$1. +# Work around the impossibility to define macros inside macros, +# because issuing `[$1]' is not possible in M4. GNU M4 should provide +# $$1 a la M5/TeX. m4_define([_b4_define_flag_if], [m4_if([$1$2], $[1]$[2], [], [m4_fatal([$0: Invalid arguments: $@])])dnl @@ -330,16 +301,24 @@ m4_define([b4_$3_if], # b4_FLAG_if(IF-TRUE, IF-FALSE) # ----------------------------- # Expand IF-TRUE, if FLAG is true, IF-FALSE otherwise. -b4_define_flag_if([defines]) # Whether headers are requested. -b4_define_flag_if([glr]) # Whether a GLR parser is requested. -b4_define_flag_if([nondeterministic]) # Whether conflicts should be handled. -b4_define_flag_if([yacc]) # Whether POSIX Yacc is emulated. +b4_define_flag_if([defines]) # Whether headers are requested. +b4_define_flag_if([glr]) # Whether a GLR parser is requested. +b4_define_flag_if([nondeterministic]) # Whether conflicts should be handled. +b4_define_flag_if([token_table]) # Whether yytoken_table is demanded. +b4_define_flag_if([yacc]) # Whether POSIX Yacc is emulated. ## --------- ## ## Symbols. ## ## --------- ## +# In order to unify the handling of the various aspects of symbols +# (tag, type_name, whether terminal, etc.), bison.exe defines one +# macro per (token, field), where field can has_id, id, etc.: see +# src/output.c:prepare_symbols_definitions(). +# +# The following macros provide access to these values. + # b4_symbol_(NUM, FIELD) # ---------------------- # Recover a FIELD about symbol #NUM. Thanks to m4_indir, fails if @@ -383,19 +362,17 @@ m4_define([b4_symbol_action_location], # Same as in C, but using references instead of pointers. m4_define([b4_symbol_action], [b4_symbol_if([$1], [has_$2], -[m4_pushdef([b4_dollar_dollar], - [b4_symbol_value([(*yyvaluep)], - b4_symbol_if([$1], [has_type], - [b4_symbol([$1], [type])]))])dnl -m4_pushdef([b4_at_dollar], [(*yylocationp)])dnl - b4_symbol_case_([$1]) +[b4_dollar_pushdef([(*yyvaluep)], + b4_symbol_if([$1], [has_type], + [m4_dquote(b4_symbol([$1], [type]))]), + [(*yylocationp)])dnl + b4_symbol_case_([$1])[]dnl b4_syncline([b4_symbol([$1], [$2_line])], ["b4_symbol([$1], [$2_file])"]) b4_symbol([$1], [$2]) b4_syncline([@oline@], [@ofile@]) break; -m4_popdef([b4_at_dollar])dnl -m4_popdef([b4_dollar_dollar])dnl +b4_dollar_popdef[]dnl ])]) @@ -420,6 +397,45 @@ m4_define([b4_symbol_case_], m4_define([b4_symbol_foreach], [m4_map([$1], m4_defn([b4_symbol_numbers]))]) +# b4_symbol_map(MACRO) +# -------------------- +# Return a list (possibly empty elements) of MACRO invoked for each +# SYMBOL-NUM. +m4_define([b4_symbol_map], +[m4_map_args_sep([$1(], [)], [,], b4_symbol_numbers)]) + + +# b4_token_visible_if(NUM, IF-TRUE, IF-FALSE) +# ------------------------------------------- +# Whether NUM denotes a token that has an exported definition (i.e., +# shows in enum yytokentype). +m4_define([b4_token_visible_if], +[b4_symbol_if([$1], [is_token], + [b4_symbol_if([$1], [has_id], [$2], [$3])], + [$3])]) + +# b4_token_has_definition(NUM) +# ---------------------------- +# 1 if NUM is visible, nothing otherwise. +m4_define([b4_token_has_definition], +[b4_token_visible_if([$1], [1])]) + +# b4_any_token_visible_if([IF-TRUE], [IF-FALSE]) +# ---------------------------------------------- +# Whether there is a token that needs to be defined. +m4_define([b4_any_token_visible_if], +[m4_ifval(b4_symbol_foreach([b4_token_has_definition]), + [$1], [$2])]) + + +# b4_token_format(FORMAT, NUM) +# ---------------------------- +m4_define([b4_token_format], +[b4_token_visible_if([$2], +[m4_quote(m4_format([$1], + [b4_symbol([$2], [id])], + [b4_symbol([$2], [user_number])]))])]) + ## ------- ## ## Types. ## @@ -435,7 +451,7 @@ m4_define([b4_type_action_], b4_dollar_dollar([b4_symbol([$1], [number])], [b4_symbol([$1], [tag])], [b4_symbol([$1], [type])]); - break; + break; ])]) @@ -542,7 +558,7 @@ 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_complain_at([b4_start], [b4_end], - [[%s `%s' is not used]], + [[%s '%s' is not used]], [$1], [b4_user_name])])[]dnl m4_popdef([b4_occurrence])dnl m4_popdef([b4_user_name])dnl @@ -598,7 +614,7 @@ m4_define([b4_percent_define_get_loc], [m4_pushdef([b4_loc], m4_indir([b4_percent_define_loc(]$1[)]))dnl b4_loc[]dnl m4_popdef([b4_loc])], - [b4_fatal([[undefined %%define variable `%s' passed to b4_percent_define_get_loc]], [$1])])]) + [b4_fatal([[b4_percent_define_get_loc: undefined %%define variable '%s']], [$1])])]) # b4_percent_define_get_syncline(VARIABLE) # ---------------------------------------- @@ -615,7 +631,7 @@ m4_popdef([b4_loc])], m4_define([b4_percent_define_get_syncline], [m4_ifdef([b4_percent_define_syncline(]$1[)], [m4_indir([b4_percent_define_syncline(]$1[)])], - [b4_fatal([[undefined %%define variable `%s' passed to b4_percent_define_get_syncline]], [$1])])]) + [b4_fatal([[b4_percent_define_get_syncline: undefined %%define variable '%s']], [$1])])]) # b4_percent_define_ifdef(VARIABLE, IF-TRUE, [IF-FALSE]) # ------------------------------------------------------ @@ -629,8 +645,8 @@ m4_define([b4_percent_define_get_syncline], # b4_percent_define_ifdef([[foo]], [[it's defined]], [[it's undefined]]) m4_define([b4_percent_define_ifdef], [m4_ifdef([b4_percent_define(]$1[)], - [b4_percent_define_use([$1])$2], - [$3])]) + [b4_percent_define_use([$1])$2], + [$3])]) ## --------- ## @@ -656,10 +672,10 @@ m4_define([b4_percent_define_flag_if], [m4_case(b4_percent_define_get([$1]), [], [$2], [true], [$2], [false], [$3], [m4_expand_once([b4_complain_at(b4_percent_define_get_loc([$1]), - [[invalid value for %%define Boolean variable `%s']], + [[invalid value for %%define Boolean variable '%s']], [$1])], [[b4_percent_define_flag_if($1)]])])], - [b4_fatal([[undefined %%define variable `%s' passed to b4_percent_define_flag_if]], [$1])])]) + [b4_fatal([[b4_percent_define_flag_if: undefined %%define variable '%s']], [$1])])]) # b4_percent_define_default(VARIABLE, DEFAULT) @@ -723,15 +739,15 @@ m4_define([_b4_percent_define_check_values], [m4_define([b4_good_value], [1])])])])dnl m4_if(b4_good_value, [0], [b4_complain_at(b4_percent_define_get_loc([$1]), - [[invalid value for %%define variable `%s': `%s']], + [[invalid value for %%define variable '%s': '%s']], [$1], m4_dquote(m4_indir([b4_percent_define(]$1[)]))) m4_foreach([b4_value], m4_dquote(m4_shift($@)), - [b4_complain_at(b4_percent_define_get_loc([$1]), - [[accepted value: `%s']], + [b4_error([[note]], b4_percent_define_get_loc([$1]), [] + [[accepted value: '%s']], m4_dquote(b4_value))])])dnl m4_popdef([b4_good_value])], - [b4_fatal([[undefined %%define variable `%s' passed to b4_percent_define_check_values]], [$1])])]) + [b4_fatal([[b4_percent_define_check_values: undefined %%define variable '%s']], [$1])])]) # b4_percent_code_get([QUALIFIER]) # -------------------------------- @@ -765,7 +781,7 @@ m4_popdef([b4_macro_name])]) 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])]) + [$3])]) ## ------------------ ## @@ -802,6 +818,9 @@ m4_define([b4_error_verbose_flag], [verbose], [[1]])]) b4_define_flag_if([error_verbose]) +# yytoken_table is needed to support verbose errors. +b4_error_verbose_if([m4_define([b4_token_table_flag], [1])]) + ## ----------------------------------------------------------- ## ## After processing the skeletons, check that all the user's ## @@ -818,3 +837,26 @@ m4_wrap_lifo([ b4_check_user_names_wrap([[define]], [[variable]]) b4_check_user_names_wrap([[code]], [[qualifier]]) ]) + + +## ---------------- ## +## 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], []) + +# The initial column and line. +m4_define_default([b4_location_initial_column], [1]) +m4_define_default([b4_location_initial_line], [1]) + +# Sanity checks. +b4_percent_define_ifdef([api.prefix], +[m4_ifdef([b4_prefix], +[b4_complain_at(b4_percent_define_get_loc([api.prefix]), + [['%s' and '%s' cannot be used together]], + [%name-prefix], + [%define api.prefix])])])