mirror of
https://git.savannah.gnu.org/git/bison.git
synced 2026-03-09 12:23:04 +00:00
f41e0cf73c
Currently we face test suite failures in different environments,
because of a conflict between the definitions of isnan by gnulib, and
by the C++ library:
262. headers.at:186: testing Sane headers: %locations %debug c++ ...
./headers.at:186: COLUMNS=1000; export COLUMNS; bison --color=no -fno-caret -d -o input.cc input.y
./headers.at:186: $CXX $CXXFLAGS $CPPFLAGS -c -o input.o input.cc
stderr:
In file included from /usr/include/c++/4.8.2/cmath:44:0,
from /usr/include/c++/4.8.2/random:38,
from /usr/include/c++/4.8.2/bits/stl_algo.h:65,
from /usr/include/c++/4.8.2/algorithm:62,
from location.hh:41,
from input.hh:90,
from input.cc:50:
/u/cs/fac/eggert/src/gnu/bison/lib/math.h: In function 'bool isnan(double)':
/u/cs/fac/eggert/src/gnu/bison/lib/math.h:2849:1: error: new declaration 'bool isnan(double)'
_GL_MATH_CXX_REAL_FLOATING_DECL_2 (isnan, isnan, bool)
^
In file included from /usr/include/features.h:375:0,
from /usr/include/c++/4.8.2/x86_64-redhat-linux/bits/os_defines.h:39,
from /usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++config.h:2097,
from /usr/include/c++/4.8.2/cstdlib:41,
from input.hh:48,
from input.cc:50:
/usr/include/bits/mathcalls.h:235:1: error: ambiguates old declaration 'int isnan(double)'
__MATHDECL_1 (int,isnan,, (_Mdouble_ __value)) __attribute__ ((__const__));
^
There might be something to do in gnulib about this, but I believe
that gnulib should not be used in the test suite in the first place.
The test suite should work with other compilers than the one used to
compile the package. For a start, Bison sources are more
demanding (C99) than the generated parsers. Last time I tried, tcc
for example, was not able to compile Bison, yet our generated parsers
should compile cleanly with it.
Besides the problem at hand is with the C++ compiler, with is not the
one used to set up gnulib at configuration-time (config.h is mainly
built from probing the C compiler).
We should really not depend on gnulib in tests.
This was introduced in 2001 to check whether including
stdlib.h/string.h is safe thanks to STDC_HEADERS
(2ce1014469). Today, we assume at least
a C90 compiler, it should be safe enough.
* tests/local.at, tests/testsuite.h: Do not include config.h.
* tests/atlocal.in (conftest.cc): Likewise.
(CPPFLAGS): Do not expose lib/, as because of this we might picked up
gnulib replacement headers for system headers.
* tests/input.at: Use int instead of ptrdiff_t, for easier portability
(some machine on the CI did not find ptrdiff_t).
* tests/c++.at: Add missing include for getchar.
1429 lines
44 KiB
Plaintext
1429 lines
44 KiB
Plaintext
# Process this -*- Autotest -*- file with autom4te.
|
|
|
|
# Macros for the GNU Bison Test suite.
|
|
|
|
# Copyright (C) 2003-2015, 2018-2019 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
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
m4_version_prereq([2.58])
|
|
|
|
|
|
# m4_null_if(VAL, IF-TRUE, IF-FALSE)
|
|
# ----------------------------------
|
|
# If VAL evaluates to empty or 0, run IF-TRUE, otherwise IF-FALSE.
|
|
m4_define([m4_null_if],
|
|
[m4_case(m4_quote($1),
|
|
[0], [$2],
|
|
[], [$2],
|
|
[$3])])
|
|
|
|
# AT_SETUP_STRIP(TITLE)
|
|
# ---------------------
|
|
# Abbreviate the TITLE to be passed to AT_SETUP. Remove new-lines
|
|
# that completely break AT_SETUP.
|
|
m4_define([AT_SETUP_STRIP],
|
|
[m4_bpatsubsts([$1],
|
|
[%\(language\|skeleton\) "?\([^\" ]*\)"?],
|
|
[\2],
|
|
[%define "?\([-A-Za-z0-9_.]+\)"? \({[^\}]+}\|"[^\"]+"\|[-A-Za-z0-9_.]+\)],
|
|
[\1=\2],
|
|
[%define "?\([-A-Za-z0-9_.]+\)"?],
|
|
[\1],
|
|
[ *
|
|
+ *], [ ])dnl
|
|
])
|
|
|
|
|
|
## ------------- ##
|
|
## Basic tests. ##
|
|
## ------------- ##
|
|
|
|
# AT_MATCHES_CHECK(FILE, PERL-REGEXP, COUNT)
|
|
# ------------------------------------------
|
|
# Expect COUNT matches of the PERL-REGEXP in FILE. The file is
|
|
# taken in "slurp" mode, i.e., one can match end-of-lines.
|
|
m4_define([AT_MATCHES_CHECK],
|
|
[AT_CHECK([$PERL -0777 -ne '
|
|
my $count = 0;
|
|
s{$2}{ ++$count; "" }gem;
|
|
printf "$count\n";' $1], [0], [$3
|
|
])])
|
|
|
|
|
|
# AT_SAVE_SPECIAL_FILES / AT_RESTORE_SPECIAL_FILES
|
|
# ------------------------------------------------
|
|
# Don't interfere with caller's files.
|
|
m4_divert_text([PREPARE_TESTS],
|
|
[at_save_special_files ()
|
|
{
|
|
for at_save_file in stderr experr expout
|
|
do
|
|
test ! -f at-bison-check-$at_save_file.bak ||
|
|
as_fn_error 1 "fatal error: back-up on top of a back-up"
|
|
test ! -f $at_save_file || mv $at_save_file at-bison-check-$at_save_file.bak
|
|
done
|
|
}
|
|
|
|
at_restore_special_files ()
|
|
{
|
|
for at_save_file in stderr experr expout
|
|
do
|
|
test ! -f at-bison-check-$at_save_file.bak ||
|
|
mv at-bison-check-$at_save_file.bak $at_save_file
|
|
done
|
|
}
|
|
])
|
|
|
|
m4_define([AT_SAVE_SPECIAL_FILES], [at_save_special_files])
|
|
m4_define([AT_RESTORE_SPECIAL_FILES], [at_restore_special_files])
|
|
|
|
|
|
|
|
## ------------------------------- ##
|
|
## Macros decoding Bison options. ##
|
|
## ------------------------------- ##
|
|
|
|
# AT_LOC_PUSHDEF(FIRST-LINE, FIRST-COLUMN, LAST-LINE, LAST-COLUMN)
|
|
# ----------------------------------------------------------------
|
|
# Pushdef AT(_LOC)?_(FIRST|LAST)_(LINE|COLUMN).
|
|
m4_define([AT_LOC_PUSHDEF],
|
|
[m4_pushdef([AT_FIRST_LINE], [$1])
|
|
m4_pushdef([AT_FIRST_COLUMN], [$2])
|
|
m4_pushdef([AT_LAST_LINE], [$3])
|
|
m4_pushdef([AT_LAST_COLUMN], [$4])
|
|
m4_pushdef([AT_LOC_FIRST_LINE], [AT_LOC.AT_FIRST_LINE])
|
|
m4_pushdef([AT_LOC_FIRST_COLUMN], [AT_LOC.AT_FIRST_COLUMN])
|
|
m4_pushdef([AT_LOC_LAST_LINE], [AT_LOC.AT_LAST_LINE])
|
|
m4_pushdef([AT_LOC_LAST_COLUMN], [AT_LOC.AT_LAST_COLUMN])])
|
|
|
|
# AT_LOC_POPDEF
|
|
# -------------
|
|
# Popdef AT(_LOC)?_(FIRST|LAST)_(LINE|COLUMN).
|
|
m4_define([AT_LOC_POPDEF],
|
|
[m4_popdef([AT_LOC_FIRST_LINE])
|
|
m4_popdef([AT_LOC_FIRST_COLUMN])
|
|
m4_popdef([AT_LOC_LAST_LINE])
|
|
m4_popdef([AT_LOC_LAST_COLUMN])
|
|
m4_popdef([AT_FIRST_LINE])
|
|
m4_popdef([AT_FIRST_COLUMN])
|
|
m4_popdef([AT_LAST_LINE])
|
|
m4_popdef([AT_LAST_COLUMN])
|
|
])
|
|
|
|
|
|
|
|
# AT_BISON_OPTION_PUSHDEFS([BISON-OPTIONS])
|
|
# -----------------------------------------
|
|
m4_define([AT_BISON_OPTION_PUSHDEFS],
|
|
[m4_divert_text([KILL],
|
|
[_AT_BISON_OPTION_PUSHDEFS($[1], $[2], [$1])])])
|
|
|
|
|
|
# _AT_BISON_OPTION_PUSHDEFS($1, $2, [BISON-OPTIONS])
|
|
# --------------------------------------------------
|
|
# 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.
|
|
m4_define([_AT_BISON_OPTION_PUSHDEFS],
|
|
[m4_pushdef([AT_BISON_OPTIONS], [$3])
|
|
|
|
m4_if([$1$2], $[1]$[2], [],
|
|
[m4_fatal([$0: invalid arguments: $@])])dnl
|
|
m4_pushdef([AT_AUTOMOVE_IF],
|
|
[m4_bmatch([$3], [%define api\.value\.automove], [$1], [$2])])
|
|
m4_pushdef([AT_DEFINES_IF],
|
|
[m4_bmatch([$3], [%defines], [$1], [$2])])
|
|
m4_pushdef([AT_DEBUG_IF],
|
|
[m4_bmatch([$3], [%debug\|%define parse.trace], [$1], [$2])])
|
|
m4_pushdef([AT_CXX_IF],
|
|
[m4_bmatch([$3], [%language "[Cc]\+\+"\|%skeleton "[a-z0-9]+\.cc"], [$1], [$2])])
|
|
m4_pushdef([AT_D_IF],
|
|
[m4_bmatch([$3], [%language "[Dd]"\|%skeleton "[a-z0-9]+\.d"], [$1], [$2])])
|
|
m4_pushdef([AT_JAVA_IF],
|
|
[m4_bmatch([$3], [%language "[Jj][Aa][Vv][Aa]"\|%skeleton "[a-z0-9]+\.java"], [$1], [$2])])
|
|
# The target language: "c", "c++", or "java".
|
|
m4_pushdef([AT_LANG],
|
|
[AT_JAVA_IF([java],
|
|
[AT_CXX_IF([c++],
|
|
[AT_D_IF([d],
|
|
[c])])])])
|
|
m4_pushdef([AT_C_IF],
|
|
[m4_if(AT_LANG, [c], [$1], [$2])])
|
|
m4_pushdef([AT_GLR_IF],
|
|
[m4_bmatch([$3], [%glr-parser\|%skeleton "glr\..*"], [$1], [$2])])
|
|
m4_pushdef([AT_LALR1_CC_IF],
|
|
[AT_CXX_IF([AT_GLR_IF([$2], [$1])], [$2])])
|
|
m4_pushdef([AT_GLR_CC_IF],
|
|
[AT_CXX_IF([AT_GLR_IF([$1], [$2])], [$2])])
|
|
# Using yacc.c?
|
|
m4_pushdef([AT_YACC_IF],
|
|
[m4_bmatch([$3], [%language\|%glr-parser\|%skeleton], [$2], [$1])])
|
|
m4_pushdef([AT_LEXPARAM_IF],
|
|
[m4_bmatch([$3], [%lex-param], [$1], [$2])])
|
|
m4_pushdef([AT_LOCATION_IF],
|
|
[m4_bmatch([$3], [%locations], [$1], [$2])])
|
|
# Whether we use the Span location type (see calc.at), whose members are
|
|
# not named like those of the default location type (on purpose, to make
|
|
# sure we can use a user type).
|
|
m4_pushdef([AT_LOCATION_TYPE_SPAN_IF],
|
|
[m4_bmatch([$3], [%define \(api\.location\.type\|location_type\) \{Span\}], [$1], [$2])])
|
|
m4_pushdef([AT_PARAM_IF],
|
|
[m4_bmatch([$3], [%parse-param], [$1], [$2])])
|
|
# Comma-terminated list of formals parse-parameters.
|
|
# E.g., %parse-param { int x } %parse-param {int y} -> "int x, int y, ".
|
|
# FIXME: Support grouped parse-param.
|
|
m4_pushdef([AT_PARSE_PARAMS])
|
|
m4_bpatsubst([$3], [%parse-param { *\([^{}]*[^{} ]\) *}],
|
|
[m4_append([AT_PARSE_PARAMS], [\1, ])])
|
|
|
|
m4_pushdef([AT_PURE_IF],
|
|
[m4_bmatch([$3], [%define *api\.pure\|%pure-parser],
|
|
[m4_bmatch([$3], [%define *api\.pure *false], [$2], [$1])],
|
|
[$2])])
|
|
m4_pushdef([AT_PUSH_IF],
|
|
[m4_bmatch([$3], [%define api.push-pull \(both\|pull\)], [$1], [$2])])
|
|
# AT_NAME_PREFIX.
|
|
m4_pushdef([AT_NAME_PREFIX],
|
|
[m4_bmatch([$3], [\(%define api\.prefix\|%name-prefix\) .*],
|
|
[m4_bregexp([$3],
|
|
[\(%define api\.prefix\|%name-prefix\) [\{\"]\([^\"\}]*\)[\"\}]],
|
|
[\2])],
|
|
[AT_JAVA_IF([YY], [yy])])])
|
|
# AT_NAMESPACE: also consider api.prefix. FIXME: Stop that confusion.
|
|
m4_pushdef([AT_NAMESPACE],
|
|
[m4_bmatch([$3], [\(%define api\.\(namespace\|prefix\)\|%name-prefix\) .*],
|
|
[m4_bregexp([$3],
|
|
[\(%define api\.\(namespace\|prefix\)\|%name-prefix\) [\{\"]\([^\"\}]*\)[\"\}]],
|
|
[\3])],
|
|
[yy])])
|
|
m4_pushdef([AT_TOKEN_CTOR_IF],
|
|
[m4_bmatch([$3], [%define api\.token\.constructor], [$1], [$2])])
|
|
m4_pushdef([AT_TOKEN_PREFIX],
|
|
[m4_bmatch([$3], [%define api\.token\.prefix {.*}],
|
|
[m4_bregexp([$3], [%define api\.token\.prefix {\(.*\)}], [\1])])])
|
|
m4_pushdef([AT_TOKEN_RAW_IF],
|
|
[m4_bmatch([$3], [%define api\.token\.raw], [$1], [$2])])
|
|
m4_pushdef([AT_VARIANT_IF],
|
|
[m4_bmatch([$3], [%define api\.value\.type variant], [$1], [$2])])
|
|
m4_pushdef([AT_API_prefix],
|
|
[m4_bmatch([$3], [%define api\.prefix {.*}],
|
|
[m4_bregexp([$3], [%define api\.prefix {\([^\}]*\)}], [\1])],
|
|
[AT_JAVA_IF([YY], [yy])])])
|
|
m4_pushdef([AT_API_PREFIX],
|
|
[m4_toupper(AT_API_prefix)])
|
|
# yyerror receives the location if %location, and if the parser is pure. For
|
|
# historical reasons, with the "yacc.c" skeleton, the location is not passed
|
|
# unless an additional "%parse-param" is present, or if the purity is defined
|
|
# as "full".
|
|
m4_pushdef([AT_YYERROR_ARG_LOC_IF],
|
|
[AT_LOCATION_IF([AT_PURE_IF([m4_bmatch([$3],
|
|
m4_quote(m4_join([\|],
|
|
[%define api\.pure full],
|
|
[%glr-parser],
|
|
[%parse-param],
|
|
[%skeleton "?glr.c"?])),
|
|
[$1], [$2])],
|
|
[$2])],
|
|
[$2])])
|
|
|
|
# yyerror always sees the locations (when activated) if the parser is impure.
|
|
# When the parser is pure, yyerror sees the location if it is received as an
|
|
# argument.
|
|
m4_pushdef([AT_YYERROR_SEES_LOC_IF],
|
|
[AT_LOCATION_IF([AT_YACC_IF([AT_PURE_IF([AT_YYERROR_ARG_LOC_IF([$1], [$2])],
|
|
[$1])],
|
|
[$1])],
|
|
[$2])])
|
|
|
|
# The interface is pure: either because %define api.pure, or because we
|
|
# are using the C++ parsers.
|
|
m4_pushdef([AT_PURE_LEX_IF],
|
|
[AT_PURE_IF([$1],
|
|
[AT_CXX_IF([$1], [$2])])])
|
|
|
|
m4_pushdef([AT_YYSTYPE],
|
|
[AT_CXX_IF([AT_NAMESPACE[::parser::semantic_type]],
|
|
[AT_API_PREFIX[STYPE]])])
|
|
m4_pushdef([AT_YYLTYPE],
|
|
[AT_CXX_IF([AT_NAMESPACE[::parser::location_type]],
|
|
[AT_API_PREFIX[LTYPE]])])
|
|
|
|
AT_TOKEN_CTOR_IF(
|
|
[m4_pushdef([AT_LOC], [[(]AT_NAME_PREFIX[lloc)]])
|
|
m4_pushdef([AT_VAL], [[(]AT_NAME_PREFIX[lval)]])
|
|
m4_pushdef([AT_YYLEX_FORMALS], [])
|
|
m4_pushdef([AT_YYLEX_RETURN], [yy::parser::symbol_type])
|
|
m4_pushdef([AT_YYLEX_ARGS], [])
|
|
m4_pushdef([AT_USE_LEX_ARGS], [])
|
|
m4_pushdef([AT_YYLEX_PRE_FORMALS], [])
|
|
m4_pushdef([AT_YYLEX_PRE_ARGS], [])],
|
|
[AT_PURE_LEX_IF(
|
|
[m4_pushdef([AT_LOC], [(*llocp)])
|
|
m4_pushdef([AT_VAL], [(*lvalp)])
|
|
m4_pushdef([AT_YYLEX_FORMALS],
|
|
[AT_YYSTYPE *lvalp[]AT_LOCATION_IF([, AT_YYLTYPE *llocp])])
|
|
m4_pushdef([AT_YYLEX_RETURN], [int])
|
|
m4_pushdef([AT_YYLEX_ARGS],
|
|
[lvalp[]AT_LOCATION_IF([, llocp])])
|
|
m4_pushdef([AT_USE_LEX_ARGS],
|
|
[(void) lvalp;AT_LOCATION_IF([(void) llocp;])])
|
|
m4_pushdef([AT_YYLEX_PRE_FORMALS],
|
|
[AT_YYLEX_FORMALS, ])
|
|
m4_pushdef([AT_YYLEX_PRE_ARGS],
|
|
[AT_YYLEX_ARGS, ])
|
|
],
|
|
[m4_pushdef([AT_LOC], [[(]AT_NAME_PREFIX[lloc)]])
|
|
m4_pushdef([AT_VAL], [[(]AT_NAME_PREFIX[lval)]])
|
|
m4_pushdef([AT_YYLEX_FORMALS], [void])
|
|
m4_pushdef([AT_YYLEX_RETURN], [int])
|
|
m4_pushdef([AT_YYLEX_ARGS], [])
|
|
m4_pushdef([AT_USE_LEX_ARGS], [])
|
|
m4_pushdef([AT_YYLEX_PRE_FORMALS], [])
|
|
m4_pushdef([AT_YYLEX_PRE_ARGS], [])
|
|
])])
|
|
|
|
|
|
# Handle the different types of location components.
|
|
AT_LOCATION_TYPE_SPAN_IF(
|
|
[AT_LOC_PUSHDEF([first.l], [first.c], [last.l], [last.c])],
|
|
[AT_CXX_IF([AT_LOC_PUSHDEF([begin.line], [begin.column], [end.line], [end.column])],
|
|
[AT_LOC_PUSHDEF([first_line], [first_column], [last_line], [last_column])])])
|
|
|
|
|
|
AT_GLR_IF([AT_KEYWORDS([glr])])
|
|
])# _AT_BISON_OPTION_PUSHDEFS
|
|
|
|
|
|
# AT_BISON_OPTION_POPDEFS
|
|
# -----------------------
|
|
m4_define([AT_BISON_OPTION_POPDEFS],
|
|
[m4_divert_text([KILL],
|
|
[m4_popdef([AT_BISON_OPTIONS])
|
|
|
|
m4_popdef([AT_YYLEX_PRE_ARGS])
|
|
m4_popdef([AT_YYLEX_PRE_FORMALS])
|
|
m4_popdef([AT_USE_LEX_ARGS])
|
|
m4_popdef([AT_YYLEX_ARGS])
|
|
m4_popdef([AT_YYLEX_FORMALS])
|
|
m4_popdef([AT_YYLTYPE])
|
|
m4_popdef([AT_YYSTYPE])
|
|
m4_popdef([AT_VAL])
|
|
m4_popdef([AT_LOC])
|
|
m4_popdef([AT_PURE_LEX_IF])
|
|
m4_popdef([AT_YYERROR_SEES_LOC_IF])
|
|
m4_popdef([AT_YYERROR_ARG_LOC_IF])
|
|
m4_popdef([AT_API_PREFIX])
|
|
m4_popdef([AT_API_prefix])
|
|
m4_popdef([AT_VARIANT_IF])
|
|
m4_popdef([AT_TOKEN_RAW_IF])
|
|
m4_popdef([AT_TOKEN_PREFIX])
|
|
m4_popdef([AT_TOKEN_CTOR_IF])
|
|
m4_popdef([AT_NAMESPACE])
|
|
m4_popdef([AT_NAME_PREFIX])
|
|
m4_popdef([AT_LOCATION_TYPE_SPAN_IF])
|
|
m4_popdef([AT_LOCATION_IF])
|
|
m4_popdef([AT_PARSE_PARAMS])
|
|
m4_popdef([AT_PUSH_IF])
|
|
m4_popdef([AT_PURE_IF])
|
|
m4_popdef([AT_PARAM_IF])
|
|
m4_popdef([AT_LEXPARAM_IF])
|
|
m4_popdef([AT_YACC_IF])
|
|
m4_popdef([AT_GLR_IF])
|
|
m4_popdef([AT_CXX_IF])
|
|
m4_popdef([AT_C_IF])
|
|
m4_popdef([AT_LANG])
|
|
m4_popdef([AT_JAVA_IF])
|
|
m4_popdef([AT_GLR_CC_IF])
|
|
m4_popdef([AT_LALR1_CC_IF])
|
|
m4_popdef([AT_DEFINES_IF])
|
|
m4_popdef([AT_DEBUG_IF])
|
|
AT_LOC_POPDEF])dnl
|
|
])# AT_BISON_OPTION_POPDEFS
|
|
|
|
|
|
|
|
## -------------------------- ##
|
|
## Generating Grammar Files. ##
|
|
## -------------------------- ##
|
|
|
|
# AT_LANG_CASE(LANG1, IF-LANG1, LANG2, IF-LANG2, ..., DEFAULT)
|
|
# ------------------------------------------------------------
|
|
m4_define([AT_LANG_CASE],
|
|
[m4_case(AT_LANG, $@)])
|
|
|
|
|
|
# _AT_LANG_DISPATCH(LANG, MACRO, ARGS)
|
|
# ------------------------------------
|
|
# Call the specialization of MACRO for LANG with ARGS. Complain if
|
|
# unavailable.
|
|
m4_define([_AT_LANG_DISPATCH],
|
|
[m4_ifdef([$2($1)],
|
|
[m4_indir([$2($1)], m4_shift2($@))],
|
|
[m4_fatal([$2: unknown language: $1])])])
|
|
|
|
|
|
# AT_LANG_DISPATCH(MACRO, ARGS)
|
|
# -----------------------------
|
|
# Call the specialization of MACRO for AT_LANG with ARGS. Complain if
|
|
# unavailable.
|
|
m4_define([AT_LANG_DISPATCH],
|
|
[_AT_LANG_DISPATCH(AT_LANG, $@)])
|
|
|
|
|
|
|
|
# AT_DATA_SOURCE_PROLOGUE
|
|
# -----------------------
|
|
# The prologue that should be included in any source code that is
|
|
# meant to be compiled. Keep atlocal.in sync (BISON_CXX_WORKS).
|
|
m4_define([AT_DATA_SOURCE_PROLOGUE],
|
|
[[/* Adjust to the compiler.
|
|
We used to do it here, but each time we add a new line,
|
|
we have to adjust all the line numbers in error messages.
|
|
It's simpler to use a constant include to a varying file. */
|
|
#include <testsuite.h>
|
|
]])
|
|
|
|
# AT_DATA_GRAMMAR_PROLOGUE
|
|
# ------------------------
|
|
# The prologue that should be included in any grammar whose parser is
|
|
# meant to be compiled.
|
|
m4_define([AT_DATA_GRAMMAR_PROLOGUE],
|
|
[[%code top {
|
|
]AT_DATA_SOURCE_PROLOGUE[]dnl
|
|
[}
|
|
]])
|
|
|
|
# AT_DATA_SOURCE(NAME, CONTENT)
|
|
# -----------------------------
|
|
# Generate the file NAME, whose CONTENT is preceded by
|
|
# AT_DATA_SOURCE_PROLOGUE.
|
|
m4_define([AT_DATA_SOURCE],
|
|
[AT_DATA([$1],
|
|
[AT_DATA_SOURCE_PROLOGUE
|
|
$2])
|
|
])
|
|
|
|
|
|
# AT_DATA_GRAMMAR(NAME, CONTENT)
|
|
# ------------------------------
|
|
# Generate the file NAME, whose CONTENT is preceded by
|
|
# AT_DATA_GRAMMAR_PROLOGUE.
|
|
m4_define([AT_DATA_GRAMMAR], [AT_LANG_DISPATCH([$0], $@)])
|
|
|
|
|
|
# AT_YYLEX_PROTOTYPE
|
|
# AT_YYLEX_DECLARE_EXTERN
|
|
# AT_YYLEX_DECLARE
|
|
# AT_YYLEX_DEFINE([INPUT], [ACTION])
|
|
# ----------------------------------
|
|
# INPUT can be empty, or in double quotes, or a list (in braces).
|
|
# ACTION may compute yylval for instance, using "res" as token type,
|
|
# and "toknum" as the number of calls to yylex (starting at 0).
|
|
m4_define([AT_YYLEX_PROTOTYPE],
|
|
[AT_YYLEX_RETURN AT_NAME_PREFIX[]lex (]AT_YYLEX_FORMALS[)[]dnl
|
|
])
|
|
|
|
m4_define([AT_YYLEX_DECLARE_EXTERN],
|
|
[AT_YYLEX_PROTOTYPE;dnl
|
|
])
|
|
|
|
m4_define([AT_YYLEX_DECLARE],
|
|
[static AT_YYLEX_DECLARE_EXTERN[]dnl
|
|
])
|
|
|
|
|
|
# AT_YYLEX_DEFINE([INPUT], [ACTION])
|
|
m4_define([AT_YYLEX_DEFINE], [AT_LANG_DISPATCH([$0], $@)])
|
|
|
|
|
|
# AT_YYERROR_FORMALS
|
|
# AT_YYERROR_PROTOTYPE
|
|
# AT_YYERROR_DECLARE_EXTERN
|
|
# AT_YYERROR_DECLARE
|
|
# AT_YYERROR_DEFINE
|
|
# -------------------------
|
|
# Must be called inside a AT_BISON_OPTION_PUSHDEFS/POPDEFS pair.
|
|
m4_define([AT_YYERROR_FORMALS], [AT_LANG_DISPATCH([$0], $@)])
|
|
m4_define([AT_YYERROR_PROTOTYPE],[AT_LANG_DISPATCH([$0], $@)])
|
|
m4_define([AT_YYERROR_DECLARE_EXTERN], [AT_LANG_DISPATCH([$0], $@)])
|
|
m4_define([AT_YYERROR_DECLARE], [AT_LANG_DISPATCH([$0], $@)])
|
|
m4_define([AT_YYERROR_DEFINE], [AT_LANG_DISPATCH([$0], $@)])
|
|
|
|
# AT_MAIN_DEFINE
|
|
# --------------
|
|
m4_define([AT_MAIN_DEFINE], [AT_LANG_DISPATCH([$0], $@)])
|
|
|
|
|
|
|
|
## --- ##
|
|
## C. ##
|
|
## --- ##
|
|
|
|
# AT_DATA_GRAMMAR(c)(NAME, CONTENT)
|
|
# ---------------------------------
|
|
# Generate the file NAME, with CONTENT.
|
|
m4_define([AT_DATA_GRAMMAR(c)],
|
|
[AT_DATA([$1],
|
|
[AT_DATA_GRAMMAR_PROLOGUE
|
|
$2])
|
|
])
|
|
|
|
m4_define([AT_YYERROR_FORMALS(c)],
|
|
[AT_YYERROR_ARG_LOC_IF([AT_YYLTYPE const * const llocp, ])AT_PARSE_PARAMS[const char *msg]])
|
|
|
|
m4_define([AT_YYERROR_PROTOTYPE(c)],
|
|
[[void ]AT_NAME_PREFIX[error (]AT_YYERROR_FORMALS[)]])
|
|
|
|
m4_define([AT_YYERROR_DECLARE_EXTERN(c)],
|
|
[AT_YYERROR_PROTOTYPE;])
|
|
|
|
m4_define([AT_YYERROR_DECLARE(c)],
|
|
[#include <stdio.h>
|
|
]AT_LOCATION_IF([[
|
|
#if defined ]AT_YYLTYPE[_IS_TRIVIAL && ]AT_YYLTYPE[_IS_TRIVIAL
|
|
static int location_print (FILE *yyo, ]AT_YYLTYPE[ const * const yylocp);
|
|
# ifndef LOCATION_PRINT
|
|
# define LOCATION_PRINT(File, Loc) location_print (File, &(Loc))
|
|
# endif
|
|
#endif
|
|
]])[
|
|
static AT_YYERROR_DECLARE_EXTERN])
|
|
|
|
|
|
m4_define([AT_YYERROR_DEFINE(c)],
|
|
[[
|
|
]AT_LOCATION_IF([[
|
|
# if defined ]AT_YYLTYPE[_IS_TRIVIAL && ]AT_YYLTYPE[_IS_TRIVIAL
|
|
/* Print *YYLOCP on YYO. */
|
|
__attribute__((__unused__))
|
|
static int
|
|
location_print (FILE *yyo, ]AT_YYLTYPE[ const * const yylocp)
|
|
{
|
|
int res = 0;
|
|
int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
|
|
if (0 <= yylocp->first_line)
|
|
{
|
|
res += fprintf (yyo, "%d", yylocp->first_line);
|
|
if (0 <= yylocp->first_column)
|
|
res += fprintf (yyo, ".%d", yylocp->first_column);
|
|
}
|
|
if (0 <= yylocp->last_line)
|
|
{
|
|
if (yylocp->first_line < yylocp->last_line)
|
|
{
|
|
res += fprintf (yyo, "-%d", yylocp->last_line);
|
|
if (0 <= end_col)
|
|
res += fprintf (yyo, ".%d", end_col);
|
|
}
|
|
else if (0 <= end_col && yylocp->first_column < end_col)
|
|
res += fprintf (yyo, "-%d", end_col);
|
|
}
|
|
return res;
|
|
}
|
|
#endif
|
|
]])[
|
|
/* A C error reporting function. */
|
|
static
|
|
]AT_YYERROR_PROTOTYPE[
|
|
{]m4_bpatsubst(m4_defn([AT_PARSE_PARAMS]),
|
|
[[^,]+[^A-Za-z_0-9]\([A-Za-z_][A-Za-z_0-9]*\), *], [
|
|
YYUSE(\1);])dnl
|
|
AT_YYERROR_SEES_LOC_IF([[
|
|
LOCATION_PRINT (stderr, ]AT_LOC[);
|
|
fprintf (stderr, ": ");]])[
|
|
fprintf (stderr, "%s\n", msg);
|
|
}]])
|
|
|
|
|
|
m4_define([AT_YYLEX_DEFINE(c)],
|
|
[[#include <assert.h>
|
|
static
|
|
]AT_YYLEX_PROTOTYPE[
|
|
{
|
|
]m4_bmatch([$1], [^\(".*"\)?$],
|
|
[[static char const input[] = ]m4_default([$1], [""])],
|
|
[[static int const input[] = ]$1])[;
|
|
static int toknum = 0;
|
|
int res;
|
|
]AT_USE_LEX_ARGS[
|
|
enum { input_elts = sizeof input / sizeof input[0] };
|
|
(void) input_elts;
|
|
assert (0 <= toknum && toknum < input_elts);
|
|
res = input[toknum++];
|
|
]$2[;]AT_TOKEN_CTOR_IF([], [[
|
|
]AT_LOCATION_IF([[
|
|
]AT_LOC_FIRST_LINE[ = ]AT_LOC_LAST_LINE[ = 1;
|
|
]AT_LOC_FIRST_COLUMN[ = ]AT_LOC_LAST_COLUMN[ = toknum;]])[
|
|
return res;]])[
|
|
}]])
|
|
|
|
|
|
m4_define([AT_MAIN_DEFINE(c)],
|
|
[[#include <stdlib.h> /* getenv. */
|
|
#include <string.h> /* strcmp. */
|
|
int
|
|
main (int argc, char const* argv[])
|
|
{]AT_DEBUG_IF([[
|
|
yydebug = !!getenv ("YYDEBUG");
|
|
for (int i = 1; i < argc; ++i)
|
|
if (!strcmp (argv[i], "-p")
|
|
|| !strcmp (argv[i], "-d") || !strcmp (argv[i], "--debug"))
|
|
yydebug |= 1;
|
|
else if (!strcmp (argv[i], "-s") || !strcmp (argv[i], "--stat"))
|
|
yydebug |= 2;]], [[
|
|
(void) argc;
|
|
(void) argv;]])[
|
|
return ]AT_NAME_PREFIX[parse ();
|
|
}]])
|
|
|
|
m4_define([AT_LANG_FOR_EACH_STD(c)],
|
|
[$1])
|
|
|
|
|
|
## ----- ##
|
|
## C++. ##
|
|
## ----- ##
|
|
|
|
|
|
# AT_DATA_GRAMMAR(NAME, CONTENT)
|
|
# ------------------------------
|
|
m4_copy([AT_DATA_GRAMMAR(c)], [AT_DATA_GRAMMAR(c++)])
|
|
|
|
# No need to declare, it's part of the class interface.
|
|
m4_define([AT_YYERROR_DECLARE(c++)], [])
|
|
m4_define([AT_YYERROR_DECLARE_EXTERN(c++)], [])
|
|
|
|
m4_define([AT_YYERROR_DEFINE(c++)],
|
|
[[/* A C++ error reporting function. */
|
|
void
|
|
]AT_NAMESPACE[::parser::error (]AT_LOCATION_IF([[const location_type& l, ]])[const std::string& m)
|
|
{
|
|
std::cerr << ]AT_LOCATION_IF([l << ": " << ])[m << '\n';
|
|
}]])
|
|
|
|
|
|
# AT_YYERROR_DEFINE(c++)([INPUT], [ACTION])
|
|
# -----------------------------------------
|
|
# Same as in C.
|
|
m4_copy([AT_YYLEX_DEFINE(c)], [AT_YYLEX_DEFINE(c++)])
|
|
|
|
|
|
m4_define([AT_MAIN_DEFINE(c++)],
|
|
[[#include <cstdlib> // getenv.
|
|
#include <cstring> // strcmp.
|
|
int
|
|
main (int argc, char const* argv[])
|
|
{
|
|
]AT_NAMESPACE[::parser p;]AT_DEBUG_IF([[
|
|
int debug = !!getenv ("YYDEBUG");
|
|
for (int i = 1; i < argc; ++i)
|
|
if (!strcmp (argv[i], "-p")
|
|
|| !strcmp (argv[i], "-d") || !strcmp (argv[i], "--debug"))
|
|
debug |= 1;
|
|
else if (!strcmp (argv[i], "-s") || !strcmp (argv[i], "--stat"))
|
|
debug |= 2;
|
|
p.set_debug_level (debug);]], [[
|
|
(void) argc;
|
|
(void) argv;]])[
|
|
return p.parse ();
|
|
}]])
|
|
|
|
m4_define([AT_LANG_FOR_EACH_STD(c++)],
|
|
[AT_FOR_EACH_CXX([$1])])
|
|
|
|
m4_define([AT_FOR_EACH_CXX],
|
|
[[at_for_each_std_CXXFLAGS_save=$CXXFLAGS
|
|
for at_std in '' \
|
|
${CXX98_CXXFLAGS:+"$CXX98_CXXFLAGS"} \
|
|
${CXX03_CXXFLAGS:+"$CXX03_CXXFLAGS"} \
|
|
${CXX11_CXXFLAGS:+"$CXX11_CXXFLAGS"} \
|
|
${CXX14_CXXFLAGS:+"$CXX14_CXXFLAGS"} \
|
|
${CXX17_CXXFLAGS:+"$CXX17_CXXFLAGS"} \
|
|
${CXX2A_CXXFLAGS:+"$CXX2A_CXXFLAGS"}
|
|
do
|
|
]AS_ECHO(["======== Testing with C++ standard flags: '$at_cxx_std'"])[
|
|
CXXFLAGS="$at_for_each_std_CXXFLAGS_save $at_std"
|
|
]$1[
|
|
done
|
|
CXXFLAGS=$at_for_each_std_CXXFLAGS_save
|
|
]])
|
|
|
|
|
|
|
|
## --- ##
|
|
## D. ##
|
|
## --- ##
|
|
|
|
# AT_DATA_GRAMMAR(NAME, CONTENT)
|
|
# ------------------------------
|
|
m4_copy([AT_DATA], [AT_DATA_GRAMMAR(d)])
|
|
|
|
|
|
# No need to declare, it's part of the class interface.
|
|
m4_define([AT_YYERROR_DECLARE(d)], [])
|
|
m4_define([AT_YYERROR_DECLARE_EXTERN(d)], [])
|
|
|
|
m4_define([AT_YYERROR_DEFINE(d)],
|
|
[[/* An error reporting function. */
|
|
public void yyerror (]AT_LOCATION_IF([[YYLocation l, ]])[string m)
|
|
{
|
|
stderr.writeln (]AT_LOCATION_IF([[l, ": ", ]])[m);
|
|
}]])
|
|
|
|
|
|
m4_define([AT_MAIN_DEFINE(d)],
|
|
[[int main ()
|
|
{
|
|
auto l = new ]AT_API_prefix[Lexer ();
|
|
auto p = new ]AT_API_PREFIX[Parser (l);
|
|
return p.parse ();
|
|
}]])
|
|
|
|
|
|
|
|
## ------ ##
|
|
## Java. ##
|
|
## ------ ##
|
|
|
|
|
|
# AT_DATA_GRAMMAR(NAME, CONTENT)
|
|
# ------------------------------
|
|
m4_copy([AT_DATA], [AT_DATA_GRAMMAR(java)])
|
|
|
|
|
|
# AT_JAVA_POSITION_DEFINE
|
|
# -----------------------
|
|
m4_define([AT_JAVA_POSITION_DEFINE],
|
|
[[class Position {
|
|
public int line;
|
|
public int token;
|
|
|
|
public Position ()
|
|
{
|
|
line = 0;
|
|
token = 0;
|
|
}
|
|
|
|
public Position (int l, int t)
|
|
{
|
|
line = l;
|
|
token = t;
|
|
}
|
|
|
|
public boolean equals (Position l)
|
|
{
|
|
return l.line == line && l.token == token;
|
|
}
|
|
|
|
public String toString ()
|
|
{
|
|
return Integer.toString (line) + "." + Integer.toString(token);
|
|
}
|
|
|
|
public int lineno ()
|
|
{
|
|
return line;
|
|
}
|
|
|
|
public int token ()
|
|
{
|
|
return token;
|
|
}
|
|
}]])
|
|
|
|
|
|
m4_define([AT_YYERROR_DEFINE(java)],
|
|
[AT_LOCATION_IF([[public void yyerror (Calc.Location l, String m)
|
|
{
|
|
if (l == null)
|
|
System.err.println (m);
|
|
else
|
|
System.err.println (l + ": " + m);
|
|
}
|
|
]], [[
|
|
public void yyerror (String m)
|
|
{
|
|
System.err.println (m);
|
|
}
|
|
]])
|
|
])
|
|
|
|
m4_define([AT_YYLEX_DEFINE(java)],
|
|
[[
|
|
/*--------.
|
|
| yylex. |
|
|
`--------*/
|
|
|
|
public String input = "]$1[";
|
|
public int index = 0;
|
|
public int yylex ()
|
|
{
|
|
if (index < input.length ())
|
|
return input.charAt (index++);
|
|
else
|
|
return 0;
|
|
}
|
|
public Object getLVal ()
|
|
{
|
|
]$2[;
|
|
}
|
|
]])
|
|
|
|
m4_define([AT_MAIN_DEFINE(java)],
|
|
[[class input
|
|
{
|
|
public static void main (String args[]) throws IOException
|
|
{
|
|
]AT_API_prefix[Parser p = new ]AT_API_prefix[Parser ();
|
|
System.exit (p.parse () ? 0 : 1);
|
|
}
|
|
}]])
|
|
|
|
m4_define([AT_LANG_FOR_EACH_STD(java)],
|
|
[$1])
|
|
|
|
## --------------- ##
|
|
## Running Bison. ##
|
|
## --------------- ##
|
|
|
|
# AT_BISON_CHECK(BISON_ARGS, [OTHER_AT_CHECK_ARGS])
|
|
# -------------------------------------------------
|
|
# High-level routine that may call bison several times, under different
|
|
# conditions.
|
|
#
|
|
# Check Bison by invoking 'bison BISON_ARGS'. BISON_ARGS should not contain
|
|
# shell constructs (such as redirection or pipes) that would prevent
|
|
# appending additional command-line arguments for bison. OTHER_AT_CHECK_ARGS
|
|
# are the usual remaining arguments to AT_CHECK: STATUS, STDOUT, etc.
|
|
#
|
|
# This macro or AT_BISON_CHECK_NO_XML should always be used whenever invoking
|
|
# Bison in the test suite. For now it ensures that:
|
|
#
|
|
# 1. Valgrind doesn't report reachable memory when Bison is expected to have
|
|
# a non-zero exit status since Bison doesn't always try to free all memory
|
|
# in that case.
|
|
#
|
|
# 2. In the case of maintainer-xml-check, XML/XSLT output is compared with
|
|
# --graph and --report=all output for every working grammar.
|
|
#
|
|
# 3. If stderr contains a warning, -Werror and --warnings=error
|
|
# convert the warning to an error.
|
|
#
|
|
# 4. If stderr contains a warning, -Wnone and --warnings=none suppress it.
|
|
m4_define([AT_BISON_CHECK],
|
|
[m4_null_if([$2], [AT_BISON_CHECK_XML($@)])
|
|
AT_BISON_CHECK_NO_XML($@)])
|
|
|
|
# AT_BISON_CHECK_(BISON_ARGS, [OTHER_AT_CHECK_ARGS])
|
|
# --------------------------------------------------
|
|
# Low-level macro to run bison once.
|
|
m4_define([AT_BISON_CHECK_],
|
|
[AT_CHECK(AT_SET_ENV[[ bison --color=no -fno-caret ]]$@)])
|
|
|
|
|
|
# AT_BISON_CHECK_WARNINGS(BISON_ARGS, [OTHER_AT_CHECK_ARGS])
|
|
# ----------------------------------------------------------
|
|
# Check that warnings (if some are expected) are correctly
|
|
# turned into errors with -Werror, etc.
|
|
#
|
|
# When -Wno-error is used, the rules are really different, don't try.
|
|
m4_define([AT_BISON_CHECK_WARNINGS],
|
|
[m4_if(m4_bregexp([$4], [: warning: ]), [-1], [],
|
|
m4_bregexp([$1], [-Wno-error=]), [-1],
|
|
[m4_null_if([$2], [AT_BISON_CHECK_WARNINGS_($@)])])])
|
|
|
|
m4_define([AT_BISON_CHECK_WARNINGS_],
|
|
[[# Defining POSIXLY_CORRECT causes bison to complain if options are
|
|
# added after the grammar file name, so skip these checks in that
|
|
# case.
|
|
if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then
|
|
]AT_SAVE_SPECIAL_FILES[
|
|
|
|
# To avoid expanding it repeatedly, store specified stdout.
|
|
]AT_DATA([expout], [$3])[
|
|
|
|
# Run with -Werror.
|
|
]AT_BISON_CHECK_([$1[ -Werror]], [[1]], [expout], [stderr])[
|
|
|
|
# Build expected stderr up to and including the "warnings being
|
|
# treated as errors" message.
|
|
]AT_DATA([[experr]], [$4])[
|
|
$PERL -pi -e 's{(.*): warning:}{$][1: error:};' \
|
|
-e 's{\[-W(.*)\]$}{@<:@-Werror=$][1@:>@}' \
|
|
experr
|
|
]AT_CHECK([[sed 's,.*/$,,' stderr 1>&2]], [[0]], [[]], [experr])[
|
|
|
|
# Now check --warnings=error.
|
|
cp stderr experr
|
|
]AT_BISON_CHECK_([$1[ --warnings=error]], [[1]], [expout], [experr])[
|
|
|
|
# Now check -Wnone and --warnings=none by making sure that
|
|
# -Werror doesn't change the exit status when -Wnone or
|
|
# --warnings=none is specified. With traces disabled, there should
|
|
# be no output on stderr.
|
|
]AT_BISON_CHECK_([$1[ -Wnone,none -Werror --trace=none]], [[0]], [expout])[
|
|
]AT_BISON_CHECK_([$1[ --warnings=none -Werror --trace=none]], [[0]], [expout])[
|
|
|
|
]AT_RESTORE_SPECIAL_FILES[
|
|
fi]dnl
|
|
])
|
|
|
|
# AT_BISON_CHECK_NO_XML(BISON_ARGS, [OTHER_AT_CHECK_ARGS])
|
|
# --------------------------------------------------------
|
|
# Same as AT_BISON_CHECK except don't perform XML/XSLT checks. This is useful
|
|
# when a tortured grammar's XML is known to be too large for xsltproc to
|
|
# handle.
|
|
m4_define([AT_BISON_CHECK_NO_XML],
|
|
[AT_CHECK(AT_SET_ENV_IF([$2]) [[bison --color=no -fno-caret ]]$@)
|
|
AT_BISON_CHECK_WARNINGS($@)])
|
|
|
|
# AT_BISON_CHECK_XML(BISON_ARGS, [OTHER_AT_CHECK_ARGS])
|
|
# -----------------------------------------------------
|
|
# Run AT_BISON_CHECK's XML/XSLT checks if $BISON_TEST_XML=1 and $XSLTPROC is
|
|
# defined. It doesn't make sense to invoke this macro if Bison is expected to
|
|
# have a non-zero exit status.
|
|
m4_define([AT_BISON_CHECK_XML],
|
|
[[if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then]
|
|
AT_SAVE_SPECIAL_FILES
|
|
[mkdir xml-tests]
|
|
m4_pushdef([AT_BISON_ARGS],
|
|
[m4_bpatsubsts([[$1]],
|
|
[--report(-file)?=[^][ ]*], [],
|
|
[--graph=[^][ ]*], [],
|
|
[--xml=[^][ ]*], [])])dnl
|
|
# Don't combine these Bison invocations since we want to be sure that
|
|
# --report=all isn't required to get the full XML file.
|
|
AT_BISON_CHECK_([[--report=all --report-file=xml-tests/test.output \
|
|
--graph=xml-tests/test.gv ]]AT_BISON_ARGS,
|
|
[[0]], [ignore], [ignore])
|
|
AT_BISON_CHECK_([[--xml=xml-tests/test.xml ]]AT_BISON_ARGS,
|
|
[[0]], [ignore], [ignore])
|
|
m4_popdef([AT_BISON_ARGS])dnl
|
|
[cp xml-tests/test.output expout]
|
|
AT_CHECK([[$XSLTPROC \
|
|
`]]AT_SET_ENV[[ bison --print-datadir`/xslt/xml2text.xsl \
|
|
xml-tests/test.xml]], [[0]], [expout])
|
|
[sort xml-tests/test.gv > expout]
|
|
AT_CHECK([[$XSLTPROC \
|
|
`]]AT_SET_ENV[[ bison --print-datadir`/xslt/xml2dot.xsl \
|
|
xml-tests/test.xml | sort]], [[0]], [expout])
|
|
[rm -rf xml-tests expout]
|
|
AT_RESTORE_SPECIAL_FILES
|
|
[fi]])
|
|
|
|
|
|
# AT_SET_ENV_IF(EXIT-STATUS)
|
|
# --------------------------
|
|
# Put this before a Bison invocation to set the environment to:
|
|
# - define COLUMNS to make the test suite independant of the user's
|
|
# environment;
|
|
# - keep Valgrind from complaining about reachable memory (when
|
|
# EXIT-STATUS is not 0).
|
|
#
|
|
# Do not quote invocations of this macro within the first argument of AT_CHECK.
|
|
# The triple quoting below will cause test cases to fail if you do. If you do
|
|
# so anyway but also decrease the quoting below to avoid that problem, AT_CHECK
|
|
# will then fail to shell-escape its contents when attempting to print them.
|
|
# The testsuite verbose output, at least, will be incorrect, but nothing may
|
|
# fail to make sure you notice.
|
|
m4_define([AT_SET_ENV_IF],
|
|
[[[COLUMNS=1000; export COLUMNS;]] m4_null_if($1, [], [[[VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; ]]])])
|
|
|
|
|
|
# AT_SET_ENV
|
|
# ----------
|
|
# See above.
|
|
m4_define([AT_SET_ENV],
|
|
[AT_SET_ENV_IF([1])])
|
|
|
|
## ------------------------ ##
|
|
## Compiling C, C++ Files. ##
|
|
## ------------------------ ##
|
|
|
|
|
|
# AT_COMPILE(OUTPUT, [SOURCES = OUTPUT.c], [EXTRA-COMPILER-FLAGS])
|
|
# ----------------------------------------------------------------
|
|
# Compile SOURCES into OUTPUT.
|
|
#
|
|
# If OUTPUT does not contain '.', assume that we are linking too,
|
|
# otherwise pass "-c"; this is a hack. The default SOURCES is OUTPUT
|
|
# with trailing .o removed, and ".c" appended.
|
|
m4_define([AT_COMPILE],
|
|
[AT_SKIP_IF([[! $BISON_C_WORKS]])
|
|
AT_CHECK(m4_join([ ],
|
|
[$CC $CFLAGS $CPPFLAGS $3],
|
|
[m4_bmatch([$1], [[.]], [-c], [$LDFLAGS])],
|
|
[-o $1],
|
|
[m4_default([$2], [m4_bpatsubst([$1], [\.o$]).c])],
|
|
[m4_bmatch([$1], [[.]], [], [$LIBS])]),
|
|
0, [ignore], [ignore])])
|
|
|
|
|
|
# AT_COMPILE_CXX(OUTPUT, [SOURCES = OUTPUT.cc], [EXTRA-COMPILER-FLAGS])
|
|
# ---------------------------------------------------------------------
|
|
# Compile SOURCES into OUTPUT. If the C++ compiler does not work,
|
|
# ignore the test.
|
|
#
|
|
# If OUTPUT does not contain '.', assume that we are linking too,
|
|
# otherwise pass "-c"; this is a hack. The default SOURCES is OUTPUT
|
|
# with trailing ".o" removed, and ".cc" appended.
|
|
m4_define([AT_COMPILE_CXX],
|
|
[AT_KEYWORDS(c++)
|
|
AT_SKIP_IF([[! $BISON_CXX_WORKS]])
|
|
AT_CHECK(m4_join([ ],
|
|
[$CXX $CXXFLAGS $CPPFLAGS $3],
|
|
[m4_bmatch([$1], [[.]], [-c], [$LDFLAGS])],
|
|
[-o $1],
|
|
[m4_default([$2], [m4_bpatsubst([$1], [\.o$]).cc])],
|
|
[m4_bmatch([$1], [[.]], [], [$LIBS])]),
|
|
0, [ignore], [ignore])])
|
|
|
|
|
|
# AT_COMPILE_D(OUTPUT, [SOURCES = OUTPUT.d], [EXTRA-COMPILER-FLAGS])
|
|
# -------------------------------------------------------------------
|
|
# Compile SOURCES into OUTPUT. If the C++ compiler does not work,
|
|
# ignore the test.
|
|
#
|
|
# If OUTPUT does not contain '.', assume that we are linking too,
|
|
# otherwise pass "-c"; this is a hack. The default SOURCES is OUTPUT
|
|
# with trailing ".o" removed, and ".cc" appended.
|
|
m4_define([AT_COMPILE_D],
|
|
[AT_KEYWORDS(d)
|
|
AT_SKIP_IF([[! $BISON_DC_WORKS]])
|
|
AT_CHECK(m4_join([ ],
|
|
[$DC $DCFLAGS $3],
|
|
[m4_bmatch([$1], [[.]], [-c])],
|
|
[-of$1],
|
|
[m4_default([$2], [m4_bpatsubst([$1], [\.o$]).d])]),
|
|
0, [ignore], [ignore])])
|
|
|
|
|
|
# AT_JAVA_COMPILE(SOURCES)
|
|
# ------------------------
|
|
# Compile SOURCES into Java class files. Skip the test if java or javac
|
|
# is not installed.
|
|
m4_define([AT_JAVA_COMPILE],
|
|
[AT_KEYWORDS(java)
|
|
AT_SKIP_IF([[test -z "$CONF_JAVAC"]])
|
|
AT_SKIP_IF([[test -z "$CONF_JAVA"]])
|
|
AT_CHECK([[$SHELL ../../../javacomp.sh ]$1],
|
|
[[0]], [ignore], [ignore])])
|
|
|
|
|
|
# AT_LANG_FOR_EACH_STD(BODY)
|
|
# --------------------------
|
|
m4_define([AT_LANG_FOR_EACH_STD], [AT_LANG_DISPATCH([$0], $@)])
|
|
|
|
|
|
# AT_LANG_COMPILE(OUTPUT, [SOURCES = OUTPUT.c], [EXTRA-COMPILER-FLAGS])
|
|
# ---------------------------------------------------------------------
|
|
# Compile SOURCES into OUTPUT. Skip if compiler does not work.
|
|
#
|
|
# If OUTPUT does not contain '.', assume that we are linking too,
|
|
# otherwise pass "-c"; this is a hack. The default SOURCES is OUTPUT
|
|
# with trailing .o removed, and ".c"/".cc" appended.
|
|
m4_define([AT_LANG_COMPILE], [AT_LANG_DISPATCH([$0], $@)])
|
|
m4_define([AT_LANG_COMPILE(c)], [AT_COMPILE([$1], [$2], [$3])])
|
|
m4_define([AT_LANG_COMPILE(c++)], [AT_COMPILE_CXX([$1], [$2], [$3])])
|
|
m4_define([AT_LANG_COMPILE(d)], [AT_COMPILE_D([$1], [$2], [$3])])
|
|
m4_define([AT_LANG_COMPILE(java)], [AT_JAVA_COMPILE([$1.java], [$2], [$3])])
|
|
|
|
|
|
# AT_LANG_EXT
|
|
# -----------
|
|
# The file extension corresponding to the language: c, cc, or java.
|
|
m4_define([AT_LANG_EXT], [AT_LANG_DISPATCH([$0], $@)])
|
|
m4_define([AT_LANG_EXT(c)], [c])
|
|
m4_define([AT_LANG_EXT(c++)], [cc])
|
|
m4_define([AT_LANG_EXT(d)], [d])
|
|
m4_define([AT_LANG_EXT(java)], [java])
|
|
|
|
|
|
# AT_LANG_HDR
|
|
# -----------
|
|
# The header file extension corresponding to the language: c, cc.
|
|
m4_define([AT_LANG_HDR], [AT_LANG_DISPATCH([$0], $@)])
|
|
m4_define([AT_LANG_HDR(c)], [h])
|
|
m4_define([AT_LANG_HDR(c++)], [hh])
|
|
|
|
|
|
# AT_FULL_COMPILE(OUTPUT, [OTHER1], [OTHER2],
|
|
# [$4: EXTRA-COMPILER-FLAGS, [$5: EXTRA-BISON-FLAGS])
|
|
# -------------------------------------------------------------------
|
|
# Compile OUTPUT.y to OUTPUT.c, OUTPUT.cc, or OUTPUT.java, and then
|
|
# compile it to OUTPUT or OUTPUT.class. If OTHER is specified, compile
|
|
# OUTPUT-OTHER.c, OUTPUT-OTHER.cc, or OUTPUT-OTHER.java to OUTPUT or
|
|
# OUTPUT.java along with it. Relies on AT_CXX_IF and
|
|
# AT_JAVA_IF.
|
|
m4_define([AT_FULL_COMPILE],
|
|
[AT_BISON_CHECK([$5 -o $1.AT_LANG_EXT $1.y])
|
|
AT_LANG_COMPILE([$1],
|
|
m4_join([ ],
|
|
[$1.AT_LANG_EXT],
|
|
m4_ifval($2, [[$1-$2.]AT_LANG_EXT]),
|
|
m4_ifval($3, [[$1-$3.]AT_LANG_EXT])),
|
|
[$4])])
|
|
|
|
|
|
|
|
# AT_SKIP_IF_CANNOT_LINK_C_AND_CXX
|
|
# --------------------------------
|
|
# Check that we can link together C and C++ objects.
|
|
m4_define([AT_SKIP_IF_CANNOT_LINK_C_AND_CXX],
|
|
[AT_DATA([c-and-cxx.h],
|
|
[[#ifdef __cplusplus
|
|
extern "C"
|
|
{
|
|
#endif
|
|
int fortytwo (void);
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
]])
|
|
AT_DATA([c-only.c],
|
|
[[#include "c-and-cxx.h"
|
|
int
|
|
main (void)
|
|
{
|
|
return fortytwo () == 42 ? 0 : 1;
|
|
}
|
|
]])
|
|
AT_DATA([cxx-only.cc],
|
|
[[#include "c-and-cxx.h"
|
|
int fortytwo ()
|
|
{
|
|
return 42;
|
|
}
|
|
]])
|
|
AT_COMPILE([c-only.o], [c-only.c])
|
|
AT_COMPILE_CXX([cxx-only.o], [cxx-only.cc])
|
|
AT_CHECK([$CXX $CXXFLAGS $CPPFLAGS $LDFLAGS c-only.o cxx-only.o -o c-and-cxx ||
|
|
exit 77], [0], [ignore], [ignore])
|
|
AT_C_PARSER_CHECK([c-and-cxx])
|
|
])
|
|
|
|
|
|
# AT_REQUIRE_CXX_STD(STD, [IF-FAIL = SKIP])
|
|
# -----------------------------------------
|
|
# Skip unless this compiler supports at least C++ STD (e.g., "11",
|
|
# "14", etc.).
|
|
m4_define([AT_REQUIRE_CXX_STD],
|
|
[AT_DATA([check.cc],
|
|
[[int main ()
|
|
{
|
|
#if !defined __cplusplus || __cplusplus < ]m4_case([$1],
|
|
[98], [199711],
|
|
[03], [199711],
|
|
[11], [201103],
|
|
[14], [201402],
|
|
[17], [201703],
|
|
[2a], [201709],
|
|
[m4_fatal([$0: invalid arguments: $@])])[
|
|
return 1;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
]])
|
|
AT_COMPILE_CXX([check])
|
|
AT_CHECK([@&t@./check], [ignore])
|
|
m4_ifval([$2],
|
|
[if test $at_status != 0; then
|
|
$2
|
|
fi],
|
|
[AT_SKIP_IF([test $at_status != 0])])
|
|
])
|
|
|
|
|
|
# AT_SKIP_IF_EXCEPTION_SUPPORT_IS_POOR
|
|
# ------------------------------------
|
|
# Check that we can expect exceptions to be handled properly.
|
|
# GCC 4.3 and 4.4 fail https://trac.macports.org/ticket/40853.
|
|
m4_define([AT_SKIP_IF_EXCEPTION_SUPPORT_IS_POOR],
|
|
[AT_DATA_SOURCE([exception.cc],
|
|
[[#include <iostream>
|
|
#include <stdexcept>
|
|
|
|
void foo ()
|
|
{
|
|
try
|
|
{
|
|
throw std::runtime_error ("foo");
|
|
}
|
|
catch (...)
|
|
{
|
|
std::cerr << "Inner caught\n";
|
|
throw;
|
|
}
|
|
}
|
|
|
|
int main ()
|
|
{
|
|
try
|
|
{
|
|
foo ();
|
|
}
|
|
catch (...)
|
|
{
|
|
std::cerr << "Outer caught\n";
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
]])
|
|
AT_COMPILE_CXX([exception])
|
|
# The "empty" quadrigraph is to protect from cfg.mk's
|
|
# sc_at_parser_check.
|
|
AT_CHECK([@&t@./exception || exit 77], [0], [], [ignore])
|
|
])
|
|
|
|
|
|
## ---------------------------- ##
|
|
## Running a generated parser. ##
|
|
## ---------------------------- ##
|
|
|
|
|
|
# AT_C_PARSER_CHECK(COMMAND, EXIT-STATUS, EXPOUT, EXPERR, [PRE])
|
|
# --------------------------------------------------------------
|
|
# So that we can run './testsuite PREPARSER='valgrind -q' for instance.
|
|
#
|
|
# Get rid of spurious messages when compiled with --coverage:
|
|
# +profiling:/[...]/lib/fprintf.gcda:Merge mismatch for summaries
|
|
m4_define([AT_C_PARSER_CHECK],
|
|
[AT_CHECK([$5 $PREPARSER ./$1], [$2], [$3], [stderr])
|
|
AT_CHECK([sed >&2 -e '/^profiling:.*:Merge mismatch for summaries/d' stderr],
|
|
[0], [], [$4])
|
|
])
|
|
|
|
|
|
# AT_JAVA_PARSER_CHECK(COMMAND, EXIT-STATUS, EXPOUT, EXPERR, [PRE])
|
|
# -----------------------------------------------------------------
|
|
m4_define([AT_JAVA_PARSER_CHECK],
|
|
[AT_CHECK([$5[ $SHELL ../../../javaexec.sh ]$1], [$2], [$3], [$4])])
|
|
|
|
|
|
# AT_PARSER_CHECK(COMMAND, EXIT-STATUS, EXPOUT, EXPERR, [PRE])
|
|
# ------------------------------------------------------------
|
|
# If we know we are in Java (via AT_BISON_OPTION_PUSHDEFS/POPDEFS),
|
|
# run AT_JAVA_PARSER_CHECK, otherwise AT_C_PARSER_CHECK.
|
|
m4_define([AT_PARSER_CHECK],
|
|
[m4_ifdef([AT_JAVA_IF],
|
|
[AT_JAVA_IF([AT_JAVA_PARSER_CHECK($@)],
|
|
[AT_C_PARSER_CHECK($@)])],
|
|
[AT_C_PARSER_CHECK($@)])])
|
|
|
|
|
|
# AT_TEST_TABLES_AND_PARSE(TITLE, COND-VALUE, TEST-SPEC,
|
|
# DECLS, GRAMMAR, INPUT,
|
|
# BISON-STDERR, TABLES-OR-LAST-STATE,
|
|
# [OTHER-CHECKS],
|
|
# [PARSER-EXIT-VALUE],
|
|
# [PARSER-STDOUT], [PARSER-STDERR])
|
|
# -------------------------------------------------------------
|
|
# Using TITLE as the test group title, check the generated parser tables
|
|
# and parser for a specified grammar file under a condition labeled by
|
|
# COND-VALUE.
|
|
#
|
|
# TEST-SPEC is a comma-delimited list of attributes of this test. Each
|
|
# recognized attribute is described below where it is relevant.
|
|
#
|
|
# Insert DECLS and GRAMMAR into the declarations and grammar section of
|
|
# the grammar file. Insert basic yyerror, yylex, and main function
|
|
# definitions as well. Hardcode yylex to return the (possibly empty)
|
|
# comma-delimited series of tokens in INPUT followed by token 0.
|
|
#
|
|
# If TEST-SPEC contains the attribute no-xml, then invoke bison using
|
|
# AT_BISON_CHECK_NO_XML. Otherwise, invoke bison using AT_BISON_CHECK.
|
|
# On the bison command-line, specify `--report=all --defines'. Check
|
|
# that Bison exits with value 0, has no stdout, and has stderr
|
|
# BISON-STDERR.
|
|
#
|
|
# If TEST-SPEC contains the attribute 'last-state', check that the value
|
|
# of TABLES-OR-LAST-STATE is the index of the last state generated for
|
|
# the grammar; in other words, check the number of states (minus one).
|
|
# Otherwise, check that everything in the '.output' file starting with
|
|
# the definition of state 0 is the same as the entire value of
|
|
# TABLES-OR-LAST-STATE.
|
|
#
|
|
# Expand the M4 in OTHER-CHECKS to perform additional checks of the
|
|
# '.output' file, which is named 'input.output', and/or grammar file,
|
|
# which is named 'input.y'.
|
|
#
|
|
# Finally, compile the generated parser and then run it using
|
|
# AT_PARSER_CHECK with PARSER-EXIT-VALUE, PARSER-STDOUT, and
|
|
# PARSER-STDERR as the 2nd-4th arguments.
|
|
#
|
|
# As a precondition, you must properly double-quote all arguments that
|
|
# are to be interpreted as strings.
|
|
#
|
|
# AT_COND_CASE (when appearing in single-quoted segments of arguments)
|
|
# invokes m4_case with its own arguments but COND-VALUE inserted as the
|
|
# first argument. This is useful, for example, when wrapping multiple
|
|
# AT_TEST_TABLES_AND_PARSE invocations, each representing a different
|
|
# condition, in another macro.
|
|
#
|
|
# For example:
|
|
#
|
|
# # AT_TEST_SYNTAX_ERROR(DESCRIPTION, DECLS, GRAMMAR, INPUT, LAST-STATE,
|
|
# # PARSER-EXIT-VALUE, PARSER-STDOUT, PARSER-STDERR)
|
|
# # ---------------------------------------------------------------------
|
|
# m4_define([AT_TEST_SYNTAX_ERROR],
|
|
# [
|
|
# AT_TEST_TABLES_AND_PARSE([$1[ with %define parse.error verbose]], [[verbose]],
|
|
# [[last-state]],
|
|
# [[%define parse.error verbose ]$2], [$3], [$4],
|
|
# [[]], [$5], [], [$6], [$7], [$8])
|
|
# AT_TEST_TABLES_AND_PARSE([$1[ with no %define parse.error verbose]], [[no verbose]],
|
|
# [[last-state]],
|
|
# [$2], [$3], [$4],
|
|
# [[]], [$5], [], [$6], [$7], [$8])
|
|
# ])
|
|
#
|
|
# AT_TEST_SYNTAX_ERROR([[Single Char Grammar]],
|
|
# [[%token 'b']], [[start: 'a' ;]], [['a', 'b']],
|
|
# [[3]],
|
|
# [[1]], [[]],
|
|
# [AT_COND_CASE([[no verbose]],
|
|
# [[syntax error
|
|
# ]],
|
|
# [[syntax error, unexpected 'b', expecting $end
|
|
# ]])])
|
|
m4_define([AT_TEST_TABLES_AND_PARSE],
|
|
[m4_pushdef([AT_COND_CASE], [m4_case([$2], $][@)])
|
|
|
|
AT_SETUP([$1])
|
|
AT_BISON_OPTION_PUSHDEFS([$4])
|
|
AT_DATA_GRAMMAR([[input.y]],
|
|
[[%code {
|
|
]AT_YYERROR_DECLARE[
|
|
]AT_YYLEX_DECLARE[
|
|
}
|
|
|
|
]$4[
|
|
|
|
%%
|
|
|
|
]$5[
|
|
|
|
%%
|
|
]AT_YYERROR_DEFINE[
|
|
static int
|
|
yylex (void)
|
|
{
|
|
static int const input[] = {
|
|
]m4_if([$6], [], [], [$6], [[]], [], [$6[, ]])[0
|
|
};
|
|
static int const *inputp = input;
|
|
return *inputp++;
|
|
}
|
|
|
|
]AT_MAIN_DEFINE[
|
|
]])
|
|
|
|
# In some versions of Autoconf, AT_CHECK invokes AS_ESCAPE before
|
|
# expanding macros, so it corrupts some special characters in the
|
|
# macros. To avoid this, expand now and pass it the result with proper
|
|
# string quotation. Assume args 7 through 12 expand to properly quoted
|
|
# strings.
|
|
|
|
m4_if(m4_index(m4_quote($3), [no-xml]), -1,
|
|
[AT_BISON_CHECK],
|
|
[AT_BISON_CHECK_NO_XML])([[-Wall --report=all --defines -o input.c input.y]],
|
|
[0], [], m4_dquote($7))
|
|
|
|
m4_if(m4_index(m4_quote($3), [last-state]), -1,
|
|
[AT_CHECK([[sed -n '/^State 0$/,$p' input.output]], [[0]],
|
|
m4_dquote($8))],
|
|
[AT_CHECK([[sed -n 's/^State //p' input.output | tail -1]], [[0]],
|
|
m4_dquote($8)[[
|
|
]])])
|
|
|
|
$9
|
|
|
|
# Canonical LR generates very large tables, resulting in very long
|
|
# files with #line directives that may overflow what the standards
|
|
# (C90 and C++98) guarantee: 32767. In that case, GCC's -pedantic
|
|
# will issue an error.
|
|
#
|
|
# There is no "" around `wc` since some indent the result.
|
|
m4_bmatch([$4], [%define lr.type canonical-lr],
|
|
[if test 32767 -lt `wc -l < input.c`; then
|
|
CFLAGS=`echo " $CFLAGS " | sed -e 's/ -pedantic / /'`
|
|
CXXFLAGS=`echo " $CXXFLAGS " | sed -e 's/ -pedantic / /'`
|
|
fi])
|
|
AT_COMPILE([[input]])
|
|
|
|
AT_PARSER_CHECK([[input]],
|
|
m4_ifval([$10], [m4_dquote($10)]),
|
|
m4_ifval([$11], [m4_dquote($11)]),
|
|
m4_ifval([$12], [m4_dquote($12)]))
|
|
|
|
AT_BISON_OPTION_POPDEFS
|
|
AT_CLEANUP
|
|
|
|
m4_popdef([AT_COND_CASE])])
|
|
|
|
|
|
|
|
# AT_SETS_CHECK(INPUT, SETS, EXPECTED)
|
|
# ------------------------------------
|
|
# Extract the information about the grammar sets from a bison
|
|
# trace output (INPUT), and compare to EXPECTED.
|
|
#
|
|
# And remember, there is no alternation in portable sed.
|
|
m4_define([AT_SETS_CHECK],
|
|
[AT_DATA([extract.sed],
|
|
[[#n
|
|
]m4_foreach([m4_Set], [$2], [[
|
|
/^]m4_Set[/ {
|
|
:]m4_Set[
|
|
p
|
|
n
|
|
/^ *$/ !b ]m4_Set[
|
|
}
|
|
]])])
|
|
|
|
AT_CHECK([sed -f extract.sed $1], 0, [$3])
|
|
])
|
|
|
|
|
|
|
|
|
|
## ----------------------- ##
|
|
## Launch the test suite. ##
|
|
## ----------------------- ##
|
|
|
|
AT_INIT
|
|
|
|
# AT_SETUP([TITLE])
|
|
# -----------------
|
|
# Redefine AT_SETUP to be more concise. Must be done after AT_INIT.
|
|
m4_copy_force([AT_SETUP], [B4_SETUP])
|
|
m4_define([AT_SETUP],
|
|
[B4_SETUP(m4_expand([AT_SETUP_STRIP([[$1]])]))])
|
|
|
|
# Cannot assign CC and CFLAGS here, since atlocal is loaded after
|
|
# options are processed, so we don't know the value of CXX and
|
|
# CXXFLAGS yet.
|
|
#
|
|
# Note that it also means that command line values for CXX and
|
|
# CXXFLAGS will not be propagated to CC and CFLAGS.
|
|
AT_ARG_OPTION([compile-c-with-cxx],
|
|
[compile C parsers with the C++ compiler])
|
|
|
|
AT_COLOR_TESTS
|
|
|
|
AT_TESTED([bison])
|