Small speedup (1%) on the list grammar. And makes yytranslate_ available
in non member functions.
* data/lalr1.cc (yytranslate_): Does not need to be a instance
function.
* data/c.m4: b4_comment(TEXT): Don't indent empty lines.
* data/lalr1.cc: Don't indent before rule and symbol actions, as
they can be empty, and anyway this incorrectly indents the first
action.
This is just nicer to read, I observed no speedup.
* data/lalr1.cc (yyeof_, yylast_, yynnts_, yyempty_, yyfinal_)
(yterror_, yyerrcode_, yyntokens_): Define as members of an enum.
(yyuser_token_number_max_, yyundef_token_): Move into...
(yytranslate_): here.
Before we were using tables which lines were the symbols and which
columns were things like number, tag, type-name etc. It is was
difficult to extend: each time a column was added, all the numbers had
to be updated (you asked for colon $2, not for "tag"). Also, it was
hard to filter these tables when only a subset of the symbols (say the
tokens, or the nterms, or the tokens that have and external number
*and* a type-name) was of interest.
Now instead of monolithic tables, we define one macro per cell. For
instance "b4_symbol(0, tag)" is a macro name which contents is
self-decriptive. The macro "b4_symbol" provides easier access to
these cells.
* src/output.c (type_names_output): Remove.
(symbol_numbers_output, symbol_definitions_output): New.
(muscles_output): Call them.
(prepare_symbols): Define b4_symbols_number.
This improves the "list" bench by 2%.
* data/lalr1.cc (variant::build): Add an overloaded version with
an argument.
* tests/c++.at (AT_CHECK_VARIANT): Check it.
* data/lalr1.cc (symbol_base_type, symbol_type): New.
(data_type): Rename as...
(stack_symbol_type): this.
Derive from symbol_base_type.
(yy_symbol_value_print_): Merge into...
(yy_symbol_print_): this.
Rename as...
(yy_print_): this.
(yydestruct_): Rename as...
(yy_destroy_): this.
(b4_symbols_actions, YY_SYMBOL_PRINT): Adjust.
(parser::parse): yyla is now of symbol_type.
Use its type member instead of yytoken.
* data/lalr1.cc (b4_symbol_actions): Bounce $$ and @$ to
yydata.value and yydata.location.
(yy_symbol_value_print_, yy_symbol_print_, yydestruct_)
(YY_SYMBOL_PRINT): Now take semantic value and location as a
single arg.
Adjust all callers.
(yydestruct_): New overload for a stack symbol.
To display rhs symbols before a reduction, we used information about the rule
reduced, which required the tables yyrhs and yyprhs. Now use rely only on the
state stack to get the same information.
* data/lalr1.cc (b4_rhs_data, b4_rhs_state): New.
Use them.
(parser::yyrhs_, parser::yyprhs_): Remove.
(parser::yy_reduce_print_): Use the state stack.
* data/lalr1.cc (b4_lhs_value, b4_lhs_location): Adjust to using
yylhs.
(parse): Replace yyval and yyloc with yylhs.value and
yylhs.location.
After a user action, compute yylhs.state earlier.
(yyerrlab1): Do not play tricks with yylhs.location, rather, use a
fresh error_token.
* data/bison.m4 (b4_copyright): Fix the indentation of the
copyright year paragraph.
Use b4_copyright_years when no years are given.
* data/lalr1.cc, data/lalr1-fusion.cc, data/location.cc
(b4_copyright_years): New.
Use it.
This is needed to prepare a forthcoming patch that fuses the three
stacks into one.
* data/lalr1.cc (parser::yypush_): New.
(parser::yynewstate): Change the semantics: instead of arriving to
this label when value and location have been pushed, but yystate
is to be pushed on the state stack, now the three of them must
have been pushed before. yystate still must be the new state.
This allows to use yypush_ everywhere instead of individual
handling of the stacks.
* data/lalr1.cc (b4_symbol_actions): New, overrides the default C
definition to use references instead of pointers.
(yy_symbol_value_print_, yy_symbol_print_, yydestruct_):
Take the value and location as references.
Adjust callers.
This patch was inspired by work by Michiel De Wilde. But he used Boost
variants which (i) requires Boost on the user side, (ii) is slow, and
(iii) has useless overhead (the parser knows the type of the semantic value
there is no reason to duplicate this information as Boost.Variants do).
This implementation reserves a buffer large enough to store the largest
objects. yy::variant implements this buffer. It was implemented with
Quentin Hocquet.
* src/output.c (type_names_output): New.
(output_skeleton): Invoke it.
* data/c++.m4 (b4_variant_if): New.
(b4_symbol_value): If needed, provide a definition for variants.
* data/lalr1.cc (b4_symbol_value, b4_symbol_action_)
(b4_symbol_variant, _b4_char_sizeof_counter, _b4_char_sizeof_dummy)
(b4_char_sizeof, yy::variant): New.
(parser::parse): If variants are requested, define
parser::union_type, parser::variant, change the definition of
semantic_type, construct $$ before running the user action instead
of performing a default $$ = $1.
* examples/variant.yy: New.
Based on an example by Michiel De Wilde.
* data/lalr1.cc (debug_stream, set_debug_stream)
(debug_level_type, debug_level, set_debug_level): Don't
declare them when YYDEBUG is not defined.
The implementation are already YYDEBUG-aware.
<http://lists.gnu.org/archive/html/help-bison/2007-09/msg00016.html>.
* data/c++.m4: (b4_namespace_ref, b4_namespace_open,
b4_namespace_close): New macros that interpret the %define variable
"namespace" so its value can contain "::" to indicate nested
namespaces.
* data/glr.cc (b4_namespace): Don't define, and replace all uses with
the above macros.
* data/lalr1.cc (b4_namespace): Likewise.
* data/location.cc (b4_namespace): Likewise.
* doc/bison.texinfo (Decl Summary): Move `%define push_pull' entry
inside a new table in the general %define entry. Document `%define
namespace' there as well. Point the %name-prefix entry to it since it
explains it more completely in the case of C++.
(C++ Bison Interface): Mention `%define namespace' instead of
%name-prefix.
(Table of Symbols): Remove the `%define push_pull' entry. The %define
entry suffices.
* tests/c++.at (Relative namespace references): New test case.
(Absolute namespace references): New test case.
(Syntactically invalid namespace references): New test case.
* tests/input.at (C++ namespace reference errors): New test case.
can be used anywhere including inside arguments of directives of the
form @foo(...@). Eventually, it should be possible to write an
xgettext-like utility to extract @gettext<...@> text from skeletons.
* data/bison.m4 (b4_check_user_names): Use @gettext<...@> when invoking
b4_warn_at since b4_warn_at doesn't invoke gettext anymore.
* data/glr.cc, data/lalr1.cc: Likewise but for b4_fatal and
b4_complain reporting a push-parsing request or a missing %defines.
* src/scan-skel.l (INITIAL): Recognize `@gettext<' to start...
(SC_AT_GETTEXT_ARG): ... this new start condition where gettext is
invoked.
(SC_AT_DIRECTIVE_ARG): Rename to...
(SC_AT_DIRECTIVE_ARGS): ... this, and recognize `@gettext<' to start
SC_AT_GETTEXT_ARG.
(at_directive_perform): Don't invoke gettext for @warn(...@),
@warn_at(...@), etc. Instead, let the skeletons decide what should be
passed to @gettext<...@>.
* tests/skeletons.at (@gettext<...@>): New test case.
* tests/skeletons.at (installed skeleton file name): Rename to...
(installed skeleton file names): ... this.
importantly, rename all related macros to be in the b4_percent_define
and b4_percent_code namespaces. Also, complete support for `.' in
%define variable names and %code qualifiers.
* data/bison.m4 (b4_check_user_names): Check for special
"SKELETON-NAMESPACE(name)" macros instead of using two nested
m4_foreach loops.
(b4_get_percent_define, b4_get_percent_code): Rename to...
(b4_percent_define_get, b4_percent_code_get): ... these.
Extend documentation with examples.
For SKELETON-NAMESPACE (as documented for b4_check_user_names), use
b4_percent_define_skeleton_variables and
b4_percent_code_skeleton_qualifiers.
Expect any value for the %define variable `foo' to be stored in the
macro named `b4_percent_define(foo)'; expect any %code blocks for the
qualifier `foo' to be stored in a macro named `b4_percent_code(foo)';
expect any unqualified %code blocks to be stored in a macro named
`b4_percent_code_unqualified'.
Use m4_indir so that %define variable names and %code qualifiers can
contain `.', which is allowed by the grammar parser.
(b4_percent_define_default): New macro to set a default value for a
%define variable.
(m4_wrap): Update wrapped code, and fix some underquoting.
(b4_check_user_names_wrap): Update and define outside the m4_wrap.
Expect grammar uses of %define variables and %code qualifiers to be
defined in b4_percent_define_user_variables and
b4_percent_code_user_qualifiers.
* data/c++.m4: Use b4_percent_define_default rather than
m4_define_default. Fix some underquoting. Skeleton usage of %define
variable define_location_comparison now implies skeleton usage of
%define variable filename_type.
* data/glr.c, data/glr.cc, data/lalr1.cc, data/location.cc,
data/push.c, data/yacc.c: Update macro names.
* src/parse-gram.y (prologue_declaration, grammar_declaration): Update
muscle names.
params with digraphs.
* data/bison.m4 (b4_pre_prologue, b4_post_prologue): Set their default
values to the empty string since these are no longer guaranteed
initialized by the front-end.
* data/glr.c, data/glr.cc, data/lalr1.cc, data/push.c, data/yacc.c: Add
braces around b4_user_stype since this is no longer done by the
front-end.
* src/files.c, src/files.h (pre_prologue_obstack,
post_prologue_obstack): Remove.
* src/muscle_tab.c (muscle_pair_list_grow): Don't duplicate header
comments here. Use MUSCLE_OBSTACK_SGROW so that values are escaped
with digraphs. This fixes lex params and parse params.
* src/muscle_tab.h (muscle_pair_list_grow): Update comments.
* src/output.c (prepare): Remove muscle insertion of the prologues.
(output): Remove freeing of pre_prologue_obstack and
post_prologue_obstack.
* src/parse-gram.y (prologue_declaration): Use muscle_code_grow rather
than prologue_augment for prologue parsing so you don't need prologue
obstacks.
(grammar_declaration): Use `braceless' instead of "{...}" so that
braces are already stripped and code is escaped with digraphs.
* src/reader.c (prologue_augment): Remove.
(reader): Remove initialization of pre_prologue_obstack and
post_prologue_obstack.
* src/reader.h (prologue_augment): Remove.
* data/c.m4: Remove stray parenthesis.
%code qualifiers, provide macros that retrieve the associated values
and build these lists automatically. Thus Bison will now warn when a
variable or qualifier is not used by the skeleton in the current
invocation regardless of whether it might sometimes be used by that
skeleton in other invocations. Also, move all %define value macros to
the b4_percent_define_ namespace, and remove the %define "NAME" {CODE}
form, which is replaced by %code.
* data/bison.m4 (b4_check_for_unrecognized_names): Rename to...
(b4_check_user_names): ... this, and change the series of valid name
arguments to a single list argument for names used in the skeleton
similar to the existing list argument for names used in the grammar.
Warn instead of complaining.
(b4_get_percent_define, b4_get_percent_code): New to retrieve %define
values and %code code, to format %code code properly, and to build
lists of all %define variables and %code qualifiers used in the
skeleton: b4_skeleton_percent_define_variables and
b4_skeleton_percent_code_qualifiers.
(b4_check_percent_define_variables, b4_check_percent_code_qualifiers):
Remove, and...
(m4_wrap): ... m4_wrap b4_check_user_names invocations instead so that
the skeleton names lists can finish building first. In place of
b4_used_percent_define_variables and b4_used_percent_code_qualifiers,
expect the lists b4_user_percent_define_variables and
b4_user_percent_code_qualifiers.
* data/c++.m4: Where setting default values for b4_parser_class_name,
b4_location_type, b4_filename_type, b4_namespace, and
b4_define_location_comparison, update their names to the
b4_percent_define_ namespace.
* data/glr.c: Don't use b4_check_percent_define_variables and
b4_check_percent_code_qualifiers. Use b4_get_percent_code.
* data/glr.cc, data/lalr1.cc: Likewise, and use b4_get_percent_define.
(b4_parser_class_name, b4_namespace): Define these using
b4_get_percent_define for parser_class_name and namespace. Normally
this would be a bad idea since there might be cases when the variables
aren't used, but these variables are too pervasive in these skeletons
for that to be a problem.
* data/location.cc: Use b4_get_percent_define.
* data/push.c: Don't use b4_check_percent_define_variables and
b4_check_percent_code_qualifiers. Use b4_get_percent_code.
* data/yacc.c: Likewise, and don't call m4_exit in
b4_use_push_for_pull_if or m4_wrap code will never execute.
* src/muscle_tab.c, src/muscle_tab.h (muscle_grow_used_name_list):
Rename to...
(muscle_grow_user_name_list): ... this for consistency with the
terminology used in bison.m4.
* src/parse-gram.y (prologue_declaration): Prepend "percent_define_" to
%define variable names, and rename muscle used_percent_define_variables
to user_percent_define_variables.
(grammar_declaration): Rename muscle used_percent_code_qualifiers to
user_percent_code_qualifiers.
(content): Remove.
(content.opt): Replace content RHS with STRING RHS so %define "NAME"
{CODE} form is no longer accepted.
* tests/input.at (Reject bad %code qualifiers): Rename to...
(Reject unused %code qualifiers): ... this, and update test output.
(%define error): Update test output.
unrecognized %code qualifiers. Check for redefined %define variables.
* data/bison.m4 (b4_check_for_unrecognized_names): New macro that
generalizes...
(b4_check_percent_code_qualifiers): ... this, which now wraps it.
(b4_check_percent_define_variables): New, also wraps it.
* data/glr.c: Unless glr.cc is wrapping glr.c, declare no valid %define
variables using b4_check_percent_define_variables.
* data/glr.cc, data/lalr1.cc: Declare the valid %define variables as
all those exercised in the test suite and all those listed in the
`Default values' section of c++.m4. Are there others?
* data/push.c, data/yacc.c: Declare no valid %define variables.
* src/muscle_tab.c, src/muscle_tab.h (muscle_find_const): New function,
similar to muscle_find, but it works even when the muscle stores a
const value.
(muscle_grow_used_name_list): New function for constructing the used
name list muscles that b4_check_for_unrecognized_names requires.
* src/parse-gram.y (prologue_declaration): Warn if a variable is
%define'd more than once. Define the b4_used_percent_define_variables
muscle with muscle_grow_used_name_list.
(grammar_declaration): Abbreviate %code code with
muscle_grow_used_name_list.
* tests/input.at (%define errors): New.
unreliable -- especially when they're hidden inside another macro.
* data/bison.m4, data/c++-skel.m4, data/c++.m4, data/c-skel.m4,
data/c.m4: Remove m4_divert(-1).
* data/glr.c, data/glr.cc, data/lalr1.cc, data/location.cc,
data/push.c, data/yacc.c: Likewise, and replace m4_divert(0) with
m4_divert_push(0) and m4_divert_pop(0).
* data/output.c (output_skeleton): Don't add an m4_divert_push(0) and
an m4_wrap([m4_divert_pop(0)]) to the M4. Diversion -1, which is
pushed and popped by m4sugar, should be first on the stack.
Provide warn, complain, and fatal function callbacks to the skeletons.
This provides more flexibility than m4_fatal, improves the error
message format, and captures messages for translation. Discussed
starting at
<http://lists.gnu.org/archive/html/bison-patches/2006-12/msg00063.html>.
* data/bison.m4 (b4_error): New, invoked by...
(b4_warn, b4_complain, b4_fatal): ... these new macros to wrap the
skeleton scanner's new @warn(...@), @complain(...@), and @fatal(...@)
directives. Because these M4 macros might be called when the current
diversion is -1 or 0, m4_divert_push and m4_divert_pop is used; thus
the previous removal of uses of m4_divert, which caused trouble.
(b4_check_percent_code_qualifiers): Use b4_complain instead of
m4_fatal to report unrecognized %code qualifiers.
* data/c++-skel.m4: Use b4_complain instead of m4_fatal to report C++
push parser requests.
* data/glr.c: Use b4_complain instead of m4_fatal to report
non-deterministic push parser requests.
Update @output usage to @output(...@) form.
* data/glr.cc, data/lalr1.cc: Use b4_fatal instead of m4_fatal to
report missing %defines. Update @output usage to @output(...@) form.
* data/location.cc, data/push.c, data/yacc.c: Update @output usage to
@output(...@) form.
* src/main.c (main): Invoke skel_scanner_free.
* src/scan-skel.h (skel_scanner_free): Prototype new function.
* src/scan-skel.l (FLEX_NO_OBSTACK): Don't define; we now need the
obstack_for_string from flex-scanner.h.
(YY_DECL): Use to declare skel_lex static.
(decode_at_digraphs): Remove; now handled in the new
SC_AT_DIRECTIVE_ARG start condition.
(fail_for_at_directive_too_many_args, fail_for_invalid_at): New static
functions.
(at_directive_name, AT_DIRECTIVE_ARGC_MAX, at_directive_argc,
at_directive_argv): New static globals.
(INITIAL): Use fail_for_invalid_at.
Don't parse `@output file_name\n' or `@basename(...@)'. Instead,
recognize the start of a generalized `@directive(...@)' form and
start...
(SC_AT_DIRECTIVE_ARG): ... this new start condition to parse the
directive args (using the new obstack_for_string), to decode the
contained @ diagraphs, and to perform the directive. It recognizes
@basename(...@), @warn(...@), @complain(...@), @fatal(...@), and
@output(...@).
(SC_AT_DIRECTIVE_SKIP_WS): New start condition started by
SC_AT_DIRECTIVE_ARG to skip whitespace after the argument delimiter,
`@,'.
(scan_skel): Initialize obstack_for_string on the first call.
(skel_scanner_free): New function to free obstack_for_string.
* tests/input.at (Reject bad %code qualifiers): Update test output.
%provides, and %code-top) into a single %code directive with an
optional qualifier field. Discussed at
<http://lists.gnu.org/archive/html/bison-patches/2007-01/msg00012.html>.
* NEWS (2.3a+): Rewrite the existing entry for the prologue
alternatives.
* doc/bison.texinfo (Prologue Alternatives): Update.
(Decl Summary): Update to %code "requires" and %code "provides".
(Calc++ Parser): Update to %code "requires".
(Bison Symbols): Remove entries for %requires, %provides, and
%code-top. Rewrite %code entry, and add a %code "QUALIFIER" entry.
* data/bison.m4 (b4_user_provides, b4_user_requires): Remove as these
are replaced by b4_percent_code_provides and b4_percent_code_requires,
which are skeleton-specific.
(b4_check_percent_code_qualifiers): New. A skeleton can use this to
declare what %code qualifiers it supports and to complain if any other
qualifiers were used in the grammar.
* data/glr.cc: Update to use b4_user_code([b4_percent_code_requires])
and b4_user_code([b4_percent_code_provides]) in place of
b4_user_requires and b4_user_provides.
* data/glr.c, data/lalr1.cc, data/push.c, data/yacc.c: Likewise.
Add b4_user_code([b4_percent_code_top]) and
b4_user_code([b4_percent_code]).
Invoke b4_check_percent_code_qualifiers.
* src/parse-gram.y (PERCENT_CODE_TOP, PERCENT_PROVIDES,
PERCENT_REQUIRES): Remove.
(grammar_declaration): Remove RHS's for %code-top, %provides, and
%requires. Rewrite the %code RHS as the unqualified form defining the
muscle b4_percent_code. Add another RHS for the qualified %code form,
which defines muscles of the form b4_percent_code_QUALIFIER and the
b4_used_percent_code_qualifiers muscle.
* src/scan-gram.l (PERCENT_CODE_TOP, PERCENT_PROVIDES,
PERCENT_REQUIRES): Remove.
* tests/actions.at (_AT_CHECK_PRINTER_AND_DESTRUCTOR): Update to use
%code "requires" and %code "provides".
* tests/input.at (Reject bad %code qualifiers): New.
`bison ', use m4_index instead of m4_substr since chopping up a string
containing M4-special characters causes problems here.
Fix a couple of bugs related to special characters in user-specified
file names, and make it easier for skeletons to compute output file
names with the same file name prefix as Bison-computed output file
names.
* data/glr.cc, data/push.c, data/yacc.c: In @output, use
b4_parser_file_name and b4_spec_defines_file instead of
@output_parser_name@ and @output_header_name@, which are now redundant.
* data/glr.c, data/lalr1.cc: Likewise. Also, in header #include's, use
b4_parser_file_name, b4_spec_defines_file, and the new
@basename(FILENAME@) instead of @output_parser_name@ and
@output_header_name@, which inappropriately escaped the file names as
C string literals.
* src/files.c (all_but_ext): Remove static qualifier.
(compute_output_file_names): Move `free (all_but_ext)' to...
(output_file_names_free): ... here since all_but_ext is needed later.
* src/files.h (all_but_ext): Extern.
* src/muscle_tab.h (MUSCLE_INSERT_STRING_RAW): New macro that does
exactly what MUSCLE_INSERT_STRING used to do.
(MUSCLE_INSERT_STRING): Use MUSCLE_OBSTACK_SGROW so that M4-special
characters are escaped properly.
* src/output.c (prepare): Define muscle file_name_all_but_ext as
all_but_ext.
For pkgdatadir muscle, maintain previous functionality by using
MUSCLE_INSERT_STRING_RAW instead of MUSCLE_INSERT_STRING. The problem
is that b4_pkgdatadir is used inside m4_include in the skeletons, so
digraphs would never be expanded. Hopefully no one has M4-special
characters in his Bison installation path.
* src/scan-skel.l: Don't parse @output_header_name@ and
@output_parser_name@ anymore since they're now redundant.
In @output, use decode_at_digraphs.
Parse a new @basename command that invokes last_component.
(decode_at_digraphs): New.
(BASE_QPUTS): Remove unused.
* tests/output.at (AT_CHECK_OUTPUT_FILE_NAME): New macro.
(Output file name): New tests.
runtime cost when YYDEBUG is not defined, and so that some tests
that used to fail now work. Problem and initial suggestion by
Paolo Bonzini.
* data/c++.m4 (b4_parse_param_cons): Omit leading ','.
* data/glr.cc (b4_parser_class_name):
Initialize yycdebug_ only if YYDEBUG. Also, initialize yydebug_.
(debug_level, set_debug_level): Affect yydebug_, not ::yydebug.
(yydebug_) [YYDEBUG]: New member.
(yycdebug_): Now defined only if YYDEBUG.
* data/lalr1.cc (yydebug_, yycdebug_): Now defined only if YYDEBUG.
(YYCDEBUG) [!YYDEBUG]: Don't use yydebug_ and yycdebug_.
(b4_parser_class_name): Initialize yydebug_ and yycdebug_ only
if YYYDEBUG.
(debug_stream, set_debug_stream, debug_level, set_debug_level):
Define only if YYDEBUG.
* tests/calc.at (_AT_DATA_CALC_Y) [!YYDEBUG]: Omit call to
set_debug_level.
* tests/regression.at (_AT_DATA_DANCER_Y) [!YYDEBUG]: Likewise.
* tests/calc.at (AT_CHECK_CALC_GLR_CC): Uncomment calls to
AT_CHECK_CALC_GLR_CC that are working now.
before any #includes that we generate, so that feature-test
macros work. Problem reported by Michael Deutschmann in
<http://lists.gnu.org/archive/html/bug-bison/2006-09/msg00004.html>.
* data/lalr1.cc: Likewise.
* doc/bison.texinfo (Prologue): Document that feature-test macros
should be defined before any Bison declarations.
* tests/actions.at (_AT_CHECK_PRINTER_AND_DESTRUCTOR): Put defns
that depend on location.hh after, not before, Bison decls, since
we now include location.hh after the first user prologue.
rather than -W, so we don't get bogus warnings about sign comparisons.
Add -Wpointer-arith, since that warning is useful (it reports code
that does not conform to C89 and that some compilers reject).
* data/c.m4, data/glr.c, data/lalr1.cc, data/yacc.c: Undo latest change,
since it's no longer needed.
* data/c.m4 (b4_safest_int_type): New macro.
* data/glr.c, data/lalr1.cc: Wherever you compare yycheck[i] against
a signed int type, cast it to b4_safest_int_type first.
* data/yacc.c: Likewise.
(b4_safest_int_type): Overwrite the one from c.m4 since b4_int_type is
also overwritten.
