git.saurik.com Git - bison.git/blame_incremental

... / ...

Commit	Line	Data
	1	# Process this -- Autotest -- file with autom4te.
	2
	3	# Macros for the GNU Bison Test suite.
	4
	5	# Copyright (C) 2003-2012 Free Software Foundation, Inc.
	6
	7	# This program is free software: you can redistribute it and/or modify
	8	# it under the terms of the GNU General Public License as published by
	9	# the Free Software Foundation, either version 3 of the License, or
	10	# (at your option) any later version.
	11	#
	12	# This program is distributed in the hope that it will be useful,
	13	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	# GNU General Public License for more details.
	16	#
	17	# You should have received a copy of the GNU General Public License
	18	# along with this program. If not, see <http://www.gnu.org/licenses/>.
	19
	20	m4_version_prereq([2.58])
	21
	22
	23	# m4_null_if(VAL, IF-TRUE, IF-FALSE)
	24	# ----------------------------------
	25	# If VAL evaluates to empty or 0, run IF-TRUE, otherwise IF-FALSE.
	26	m4_define([m4_null_if],
	27	[m4_case(m4_quote($1),
	28	[0], [$2],
	29	[], [$2],
	30	[$3])])
	31
	32	## ------------- ##
	33	## Basic tests. ##
	34	## ------------- ##
	35
	36	# AT_MATCHES_CHECK(FILE, PERL-REGEXP, COUNT)
	37	# ------------------------------------------
	38	# Expect COUNT matches of the PERL-REGEXP in FILE. The file is
	39	# taken in "slurp" mode, i.e., one can match end-of-lines.
	40	m4_define([AT_MATCHES_CHECK],
	41	[AT_CHECK([$PERL -0777 -ne '
	42	my $count = 0;
	43	s{$2}{ ++$count; "" }gem;
	44	printf "$count\n";' $1], [0], [$3
	45	])])
	46
	47
	48	# AT_SAVE_SPECIAL_FILES / AT_RESTORE_SPECIAL_FILES
	49	# ------------------------------------------------
	50	# Don't interfere with caller's files.
	51	m4_divert_text([PREPARE_TESTS],
	52	[at_save_special_files ()
	53	{
	54	for at_save_file in stderr experr expout
	55	do
	56	test ! -f at-bison-check-$at_save_file.bak \|\|
	57	as_fn_error 1 "fatal error: back-up on top of a back-up"
	58	test ! -f $at_save_file \|\| mv $at_save_file at-bison-check-$at_save_file.bak
	59	done
	60	}
	61
	62	at_restore_special_files ()
	63	{
	64	for at_save_file in stderr experr expout
	65	do
	66	test ! -f at-bison-check-$at_save_file.bak \|\|
	67	mv at-bison-check-$at_save_file.bak $at_save_file
	68	done
	69	}
	70	])
	71
	72	m4_define([AT_SAVE_SPECIAL_FILES], [at_save_special_files])
	73	m4_define([AT_RESTORE_SPECIAL_FILES], [at_restore_special_files])
	74
	75
	76
	77	## ------------------------------- ##
	78	## Macros decoding Bison options. ##
	79	## ------------------------------- ##
	80
	81	# AT_LOC_PUSHDEF(FIRST-LINE, FIRST-COLUMN, LAST-LINE, LAST-COLUMN)
	82	# ----------------------------------------------------------------
	83	# Pushdef AT_LOC_(FIRST\|LAST)_(LINE\|COLUMN).
	84	m4_define([AT_LOC_PUSHDEF],
	85	[m4_pushdef([AT_LOC_FIRST_LINE], [AT_LOC.$1])
	86	m4_pushdef([AT_LOC_FIRST_COLUMN], [AT_LOC.$2])
	87	m4_pushdef([AT_LOC_LAST_LINE], [AT_LOC.$3])
	88	m4_pushdef([AT_LOC_LAST_COLUMN], [AT_LOC.$4])])
	89
	90	# AT_LOC_POPDEF
	91	# -------------
	92	# Popdef AT_LOC_(FIRST\|LAST)_(LINE\|COL).
	93	m4_define([AT_LOC_POPDEF],
	94	[m4_popdef([AT_LOC_FIRST_LINE])
	95	m4_popdef([AT_LOC_FIRST_COLUMN])
	96	m4_popdef([AT_LOC_LAST_LINE])
	97	m4_popdef([AT_LOC_LAST_COLUMN])])
	98
	99
	100
	101	# AT_BISON_OPTION_PUSHDEFS([BISON-OPTIONS])
	102	# -----------------------------------------
	103	m4_define([AT_BISON_OPTION_PUSHDEFS],
	104	[m4_divert_text([KILL],
	105	[_AT_BISON_OPTION_PUSHDEFS($[1], $[2], [$1])])])
	106
	107
	108	# _AT_BISON_OPTION_PUSHDEFS($1, $2, [BISON-OPTIONS])
	109	# --------------------------------------------------
	110	# This macro works around the impossibility to define macros
	111	# inside macros, because issuing `[$1]' is not possible in M4 :(.
	112	# This sucks hard, GNU M4 should really provide M5 like $$1.
	113	m4_define([_AT_BISON_OPTION_PUSHDEFS],
	114	[m4_if([$1$2], $[1]$[2], [],
	115	[m4_fatal([$0: Invalid arguments: $@])])dnl
	116	m4_pushdef([AT_DEFINES_IF],
	117	[m4_bmatch([$3], [%defines], [$1], [$2])])
	118	m4_pushdef([AT_SKEL_CC_IF],
	119	[m4_bmatch([$3], [%language "[Cc]\+\+"\\|%skeleton "[a-z0-9]+\.cc"], [$1], [$2])])
	120	m4_pushdef([AT_SKEL_JAVA_IF],
	121	[m4_bmatch([$3], [%language "[Jj][Aa][Vv][Aa]"\\|%skeleton "[a-z0-9]+\.java"], [$1], [$2])])
	122	# The target language: "c", "c++", or "java".
	123	m4_pushdef([AT_LANG],
	124	[AT_SKEL_JAVA_IF([java],
	125	[AT_SKEL_CC_IF([c++],
	126	[c])])])
	127	m4_pushdef([AT_GLR_IF],
	128	[m4_bmatch([$3], [%glr-parser\\|%skeleton "glr\..*"], [$1], [$2])])
	129	m4_pushdef([AT_LALR1_CC_IF],
	130	[AT_SKEL_CC_IF([AT_GLR_IF([$2], [$1])], [$2])])
	131	m4_pushdef([AT_GLR_CC_IF],
	132	[AT_SKEL_CC_IF([AT_GLR_IF([$1], [$2])], [$2])])
	133	# Using yacc.c?
	134	m4_pushdef([AT_YACC_IF],
	135	[m4_bmatch([$3], [%language\\|%glr-parser\\|%skeleton], [$2], [$1])])
	136	m4_pushdef([AT_LEXPARAM_IF],
	137	[m4_bmatch([$3], [%lex-param], [$1], [$2])])
	138	m4_pushdef([AT_LOCATION_IF],
	139	[m4_bmatch([$3], [%locations], [$1], [$2])])
	140	m4_pushdef([AT_LOCATION_TYPE_IF],
	141	[m4_bmatch([$3], [%define location_type], [$1], [$2])])
	142	m4_pushdef([AT_PARAM_IF],
	143	[m4_bmatch([$3], [%parse-param], [$1], [$2])])
	144	# Comma-terminated list of formals parse-parameters.
	145	# E.g., %parse-param { int x } {int y} -> "int x, int y, ".
	146	m4_pushdef([AT_PARSE_PARAMS])
	147	m4_bpatsubst([$3], [%parse-param { $[^{}][^{} ]$ *}],
	148	[m4_append([AT_PARSE_PARAMS], [\1, ])])
	149
	150	m4_pushdef([AT_PURE_IF],
	151	[m4_bmatch([$3], [%define *api\.pure\\|%pure-parser],
	152	[m4_bmatch([$3], [%define api\.pure "?false"?], [$2], [$1])],
	153	[$2])])
	154	m4_pushdef([AT_PURE_AND_LOC_IF],
	155	[m4_bmatch([$3], [%locations], [AT_PURE_IF($@)], [$2])])
	156	m4_pushdef([AT_GLR_OR_PARAM_IF],
	157	[m4_bmatch([$3], [%glr-parser\\|%parse-param], [$1], [$2])])
	158	m4_pushdef([AT_NAME_PREFIX],
	159	[m4_bmatch([$3], [$%define api\.prefix\\|%name-prefix$ ".*"],
	160	[m4_bregexp([$3], [$%define api\.prefix\\|%name-prefix$ "$[^""]*$"], [\2])],
	161	[yy])])
	162	m4_pushdef([AT_API_prefix],
	163	[m4_bmatch([$3], [%define api\.prefix ".*"],
	164	[m4_bregexp([$3], [%define api\.prefix "$[^""]*$"], [\1])],
	165	[yy])])
	166	m4_pushdef([AT_API_PREFIX],
	167	[m4_toupper(AT_API_prefix)])
	168	# yyerror receives the location if %location & %pure & (%glr or %parse-param).
	169	m4_pushdef([AT_YYERROR_ARG_LOC_IF],
	170	[AT_GLR_OR_PARAM_IF([AT_PURE_AND_LOC_IF([$1], [$2])],
	171	[$2])])
	172	# yyerror always sees the locations (when activated), except if
	173	# (yacc & pure & !param). FIXME: This is wrong. See the manual.
	174	m4_pushdef([AT_YYERROR_SEES_LOC_IF],
	175	[AT_LOCATION_IF([AT_YACC_IF([AT_PURE_IF([AT_PARAM_IF([$1], [$2])],
	176	[$1])],
	177	[$1])],
	178	[$2])])
	179
	180	# The interface is pure: either because %define api.pure, or because we
	181	# are using the C++ parsers.
	182	m4_pushdef([AT_PURE_LEX_IF],
	183	[AT_PURE_IF([$1],
	184	[AT_SKEL_CC_IF([$1], [$2])])])
	185
	186	m4_pushdef([AT_YYSTYPE],
	187	[AT_SKEL_CC_IF([AT_NAME_PREFIX[::parser::semantic_type]],
	188	[AT_API_PREFIX[STYPE]])])
	189	m4_pushdef([AT_YYLTYPE],
	190	[AT_SKEL_CC_IF([AT_NAME_PREFIX[::parser::location_type]],
	191	[AT_API_PREFIX[LTYPE]])])
	192
	193
	194	AT_PURE_LEX_IF(
	195	[m4_pushdef([AT_LOC], [(*llocp)])
	196	m4_pushdef([AT_VAL], [(*lvalp)])
	197	m4_pushdef([AT_YYLEX_FORMALS],
	198	[AT_YYSTYPE lvalp[]AT_LOCATION_IF([, AT_YYLTYPE llocp])])
	199	m4_pushdef([AT_YYLEX_ARGS],
	200	[lvalp[]AT_LOCATION_IF([, llocp])])
	201	m4_pushdef([AT_USE_LEX_ARGS],
	202	[(void) lvalp;AT_LOCATION_IF([(void) llocp])])
	203	m4_pushdef([AT_YYLEX_PRE_FORMALS],
	204	[AT_YYLEX_FORMALS, ])
	205	m4_pushdef([AT_YYLEX_PRE_ARGS],
	206	[AT_YYLEX_ARGS, ])
	207	],
	208	[m4_pushdef([AT_LOC], [[(]AT_NAME_PREFIX[lloc)]])
	209	m4_pushdef([AT_VAL], [[(]AT_NAME_PREFIX[lval)]])
	210	m4_pushdef([AT_YYLEX_FORMALS], [void])
	211	m4_pushdef([AT_YYLEX_ARGS], [])
	212	m4_pushdef([AT_USE_LEX_ARGS], [])
	213	m4_pushdef([AT_YYLEX_PRE_FORMALS], [])
	214	m4_pushdef([AT_YYLEX_PRE_ARGS], [])
	215	])
	216
	217	# Handle the different types of location components.
	218
	219	AT_SKEL_CC_IF(
	220	[AT_LOCATION_TYPE_IF(
	221	[AT_LOC_PUSHDEF([first.l], [first.c], [last.l], [last.c])],
	222	[AT_LOC_PUSHDEF([begin.line], [begin.column], [end.line], [end.column])])],
	223	[AT_LOC_PUSHDEF([first_line], [first_column], [last_line], [last_column])])
	224
	225	])# _AT_BISON_OPTION_PUSHDEFS
	226
	227
	228	# AT_BISON_OPTION_POPDEFS
	229	# -----------------------
	230	m4_define([AT_BISON_OPTION_POPDEFS],
	231	[m4_divert_text([KILL],
	232	[m4_popdef([AT_YYLEX_PRE_ARGS])
	233	m4_popdef([AT_YYLEX_PRE_FORMALS])
	234	m4_popdef([AT_USE_LEX_ARGS])
	235	m4_popdef([AT_YYLEX_ARGS])
	236	m4_popdef([AT_YYLEX_FORMALS])
	237	m4_popdef([AT_YYLTYPE])
	238	m4_popdef([AT_YYSTYPE])
	239	m4_popdef([AT_VAL])
	240	m4_popdef([AT_LOC])
	241	m4_popdef([AT_PURE_LEX_IF])
	242	m4_popdef([AT_YYERROR_SEES_LOC_IF])
	243	m4_popdef([AT_YYERROR_ARG_LOC_IF])
	244	m4_popdef([AT_API_PREFIX])
	245	m4_popdef([AT_API_prefix])
	246	m4_popdef([AT_NAME_PREFIX])
	247	m4_popdef([AT_GLR_OR_PARAM_IF])
	248	m4_popdef([AT_PURE_AND_LOC_IF])
	249	m4_popdef([AT_LOCATION_TYPE_IF])
	250	m4_popdef([AT_LOCATION_IF])
	251	m4_popdef([AT_PARSE_PARAMS])
	252	m4_popdef([AT_PARAM_IF])
	253	m4_popdef([AT_LEXPARAM_IF])
	254	m4_popdef([AT_YACC_IF])
	255	m4_popdef([AT_GLR_IF])
	256	m4_popdef([AT_SKEL_CC_IF])
	257	m4_popdef([AT_LANG])
	258	m4_popdef([AT_SKEL_JAVA_IF])
	259	m4_popdef([AT_GLR_CC_IF])
	260	m4_popdef([AT_LALR1_CC_IF])
	261	m4_popdef([AT_DEFINES_IF])
	262	AT_LOC_POPDEF])dnl
	263	])# AT_BISON_OPTION_POPDEFS
	264
	265
	266
	267	## -------------------------- ##
	268	## Generating Grammar Files. ##
	269	## -------------------------- ##
	270
	271	# AT_DATA_SOURCE_PROLOGUE
	272	# ------------------------
	273	# The prologue that should be included in any source code that is
	274	# meant to be compiled.
	275	m4_define([AT_DATA_SOURCE_PROLOGUE],
	276	[[#include <config.h>
	277	/* We don't need perfect functions for these tests. */
	278	#undef malloc
	279	#undef memcmp
	280	#undef realloc
	281	]])
	282
	283	# AT_DATA_GRAMMAR_PROLOGUE
	284	# ------------------------
	285	# The prologue that should be included in any grammar which parser is
	286	# meant to be compiled.
	287	m4_define([AT_DATA_GRAMMAR_PROLOGUE],
	288	[[%code top {
	289	]AT_DATA_SOURCE_PROLOGUE[]dnl
	290	[}
	291	]])
	292
	293	# AT_DATA_SOURCE(NAME, CONTENT)
	294	# -----------------------------
	295	# Generate the file NAME, which CONTENT is preceded by
	296	# AT_DATA_SOURCE_PROLOGUE.
	297	m4_define([AT_DATA_SOURCE],
	298	[AT_DATA([$1],
	299	[AT_DATA_SOURCE_PROLOGUE
	300	$2])
	301	])
	302
	303	# AT_DATA_GRAMMAR(NAME, CONTENT)
	304	# ------------------------------
	305	# Generate the file NAME, which CONTENT is preceded by
	306	# AT_DATA_GRAMMAR_PROLOGUE.
	307	m4_define([AT_DATA_GRAMMAR],
	308	[AT_DATA([$1],
	309	[AT_DATA_GRAMMAR_PROLOGUE
	310	$2])
	311	])
	312
	313	# AT_YYLEX_PROTOTYPE
	314	# AT_YYLEX_DECLARE_EXTERN
	315	# AT_YYLEX_DECLARE
	316	# AT_YYLEX_DEFINE([INPUT], [ACTION])
	317	# ----------------------------------
	318	# INPUT can be empty, or in double quotes, or a list (in braces).
	319	# ACTION may compute yylval for instance, using "res" as token type,
	320	# and "toknum" as the number of calls to yylex (starting at 0).
	321	m4_define([AT_YYLEX_PROTOTYPE],
	322	[int AT_NAME_PREFIX[]lex (]AT_YYLEX_FORMALS[)[]dnl
	323	])
	324
	325	m4_define([AT_YYLEX_DECLARE_EXTERN],
	326	[AT_YYLEX_PROTOTYPE;dnl
	327	])
	328
	329	m4_define([AT_YYLEX_DECLARE],
	330	[static AT_YYLEX_DECLARE_EXTERN[]dnl
	331	])
	332
	333	m4_define([AT_YYLEX_DEFINE],
	334	[[#include <assert.h>
	335	static
	336	]AT_YYLEX_PROTOTYPE[
	337	{
	338	]m4_bmatch([$1], [^$".*"$?$],
	339	[[static char const input[] = ]m4_default([$1], [""])],
	340	[[static int const input[] = ]$1])[;
	341	static size_t toknum = 0;
	342	int res;
	343	]AT_USE_LEX_ARGS[;
	344	assert (toknum < sizeof input / sizeof input[0]);
	345	res = input[toknum++];
	346	]$2[;]AT_LOCATION_IF([[
	347	]AT_LOC_FIRST_LINE[ = ]AT_LOC_LAST_LINE[ = 1;
	348	]AT_LOC_FIRST_COLUMN[ = ]AT_LOC_LAST_COLUMN[ = toknum;]])[
	349	return res;
	350	}]dnl
	351	])
	352
	353	# AT_YYERROR_PROTOTYPE
	354	# AT_YYERROR_DECLARE_EXTERN
	355	# AT_YYERROR_DECLARE
	356	# AT_YYERROR_DEFINE
	357	# -------------------------
	358	# Must be called inside a AT_BISON_OPTION_PUSHDEFS/POPDEFS pair.
	359	m4_define([AT_YYERROR_FORMALS],
	360	[m4_case(AT_LANG,
	361	[c], [AT_YYERROR_ARG_LOC_IF([AT_YYLTYPE llocp, ])AT_PARSE_PARAMS [const char msg]])[]dnl
	362	])
	363
	364	m4_define([AT_YYERROR_PROTOTYPE],
	365	[m4_case(AT_LANG,
	366	[c], [[void ]AT_NAME_PREFIX[error (]AT_YYERROR_FORMALS[)]])[]dnl
	367	])
	368
	369	m4_define([AT_YYERROR_DECLARE_EXTERN],
	370	[m4_case(AT_LANG,
	371	[c], [AT_YYERROR_PROTOTYPE;])[]dnl
	372	])
	373
	374	m4_define([AT_YYERROR_DECLARE],
	375	[m4_case(AT_LANG,
	376	[c], [static AT_YYERROR_DECLARE_EXTERN])[]dnl
	377	])
	378
	379	m4_define([AT_YYERROR_DEFINE],
	380	[m4_case(AT_LANG,
	381	[c], [[#include <stdio.h>
	382	/* A C error reporting function. */
	383	static
	384	]AT_YYERROR_PROTOTYPE[
	385	{]m4_bpatsubst(m4_defn([AT_PARSE_PARAMS]),
	386	[[^,]+[^A-Za-z_0-9]$[A-Za-z_][A-Za-z_0-9]$, ], [
	387	YYUSE(\1);])dnl
	388	AT_YYERROR_SEES_LOC_IF([[
	389	YY_LOCATION_PRINT (stderr, ]AT_LOC[);
	390	fprintf (stderr, ": ");]])[
	391	fprintf (stderr, "%s\n", msg);
	392	}]],
	393	[c++], [[/* A C++ error reporting function. */
	394	void
	395	]AT_NAME_PREFIX[::parser::error (const location_type& l, const std::string& m)
	396	{
	397	(void) l;
	398	std::cerr << ]AT_LOCATION_IF([l << ": " << ])[m << std::endl;
	399	}]],
	400	[java], [AT_LOCATION_IF([[public void yyerror (Calc.Location l, String s)
	401	{
	402	if (l == null)
	403	System.err.println (s);
	404	else
	405	System.err.println (l + ": " + s);
	406	}
	407	]], [[
	408	public void yyerror (String s)
	409	{
	410	System.err.println (s);
	411	}]])],
	412	[m4_fatal([$0: invalid language: ]AT_LANG)])dnl
	413	])
	414
	415
	416	## --------------- ##
	417	## Running Bison. ##
	418	## --------------- ##
	419
	420	# AT_BISON_CHECK(BISON_ARGS, [OTHER_AT_CHECK_ARGS])
	421	# -------------------------------------------------
	422	# High-level routine that may call bison several times, under different
	423	# conditions.
	424	#
	425	# Check Bison by invoking `bison BISON_ARGS'. BISON_ARGS should not contain
	426	# shell constructs (such as redirection or pipes) that would prevent
	427	# appending additional command-line arguments for bison. OTHER_AT_CHECK_ARGS
	428	# are the usual remaining arguments to AT_CHECK: STATUS, STDOUT, etc.
	429	#
	430	# This macro or AT_BISON_CHECK_NO_XML should always be used whenever invoking
	431	# Bison in the test suite. For now it ensures that:
	432	#
	433	# 1. Valgrind doesn't report reachable memory when Bison is expected to have
	434	# a non-zero exit status since Bison doesn't always try to free all memory
	435	# in that case.
	436	#
	437	# 2. In the case of maintainer-xml-check, XML/XSLT output is compared with
	438	# --graph and --report=all output for every working grammar.
	439	#
	440	# 3. If stderr contains a warning, -Werror and --warnings=error
	441	# convert the warning to an error.
	442	#
	443	# 4. If stderr contains a warning, -Wnone and --warnings=none suppress it.
	444	m4_define([AT_BISON_CHECK],
	445	[m4_null_if([$2], [AT_BISON_CHECK_XML($@)])
	446	AT_BISON_CHECK_NO_XML($@)])
	447
	448	m4_define([AT_BISON_WERROR_MSG],
	449	[[bison: warnings being treated as errors]])
	450
	451
	452	# AT_BISON_CHECK_(BISON_ARGS, [OTHER_AT_CHECK_ARGS])
	453	# --------------------------------------------------
	454	# Low-level macro to run bison once.
	455	m4_define([AT_BISON_CHECK_],
	456	[AT_CHECK(AT_QUELL_VALGRIND[[ bison ]]$@)])
	457
	458
	459	# AT_BISON_CHECK_WARNINGS(BISON_ARGS, [OTHER_AT_CHECK_ARGS])
	460	# ----------------------------------------------------------
	461	# Check that warnings (if some are expected) are correctly
	462	# turned into errors with -Werror, etc.
	463	m4_define([AT_BISON_CHECK_WARNINGS],
	464	[m4_if(m4_bregexp([$4], [: warning: ]), [-1], [],
	465	[m4_null_if([$2], [AT_BISON_CHECK_WARNINGS_($@)])])])
	466
	467	m4_define([AT_BISON_CHECK_WARNINGS_],
	468	[[# Defining POSIXLY_CORRECT causes bison to complain if options are
	469	# added after the grammar file name, so skip these checks in that
	470	# case.
	471	if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then
	472	]AT_SAVE_SPECIAL_FILES[
	473
	474	# To avoid expanding it repeatedly, store specified stdout.
	475	]AT_DATA([expout], [$3])[
	476
	477	# Run with -Werror.
	478	]AT_BISON_CHECK_([$1[ -Werror]], [[1]], [expout], [stderr])[
	479
	480	# Build expected stderr up to and including the "warnings being
	481	# treated as errors" message.
	482	]AT_DATA([[at-bison-check-warnings]], [$4])[
	483	at_bison_check_first=`sed -n \
	484	'/: warning: /{=;q;}' at-bison-check-warnings`
	485	: ${at_bison_check_first:=1}
	486	at_bison_check_first_tmp=`sed -n \
	487	'/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings`
	488	: ${at_bison_check_first_tmp:=1}
	489	if test $at_bison_check_first_tmp -lt $at_bison_check_first; then
	490	at_bison_check_first=$at_bison_check_first_tmp
	491	fi
	492	if test $at_bison_check_first -gt 1; then
	493	sed -n "1,`expr $at_bison_check_first - 1`"p \
	494	at-bison-check-warnings > experr
	495	fi
	496	echo ']AT_BISON_WERROR_MSG[' >> experr
	497
	498	# Finish building expected stderr and check. Unlike warnings,
	499	# complaints cause bison to exit early. Thus, with -Werror, bison
	500	# does not necessarily report all warnings that it does without
	501	# -Werror, but it at least reports one.
	502	at_bison_check_last=`sed -n '$=' stderr`
	503	: ${at_bison_check_last:=1}
	504	at_bison_check_last=`expr $at_bison_check_last - 1`
	505	sed -n "$at_bison_check_first,$at_bison_check_last"p \
	506	at-bison-check-warnings >> experr
	507	]AT_CHECK([[sed 's,.*/$]AT_BISON_WERROR_MSG[$$,\1,' \
	508	stderr 1>&2]], [[0]], [[]], [experr])[
	509
	510	# Now check --warnings=error.
	511	cp stderr experr
	512	]AT_BISON_CHECK_([$1[ --warnings=error]], [[1]], [expout], [experr])[
	513
	514	# Now check -Wnone and --warnings=none by making sure that
	515	# -Werror doesn't change the exit status when -Wnone or
	516	# --warnings=none is specified.
	517	]AT_BISON_CHECK_([$1[ -Wnone -Werror]], [[0]], [expout])[
	518	]AT_BISON_CHECK_([$1[ --warnings=none -Werror]], [[0]], [expout])[
	519
	520	]AT_RESTORE_SPECIAL_FILES[
	521	fi]dnl
	522	])
	523
	524	# AT_BISON_CHECK_NO_XML(BISON_ARGS, [OTHER_AT_CHECK_ARGS])
	525	# --------------------------------------------------------
	526	# Same as AT_BISON_CHECK except don't perform XML/XSLT checks. This is useful
	527	# when a tortured grammar's XML is known to be too large for xsltproc to
	528	# handle.
	529	m4_define([AT_BISON_CHECK_NO_XML],
	530	[AT_CHECK(m4_null_if([$2], [], [AT_QUELL_VALGRIND ])[[bison ]]$@)
	531	AT_BISON_CHECK_WARNINGS($@)])
	532
	533	# AT_BISON_CHECK_XML(BISON_ARGS, [OTHER_AT_CHECK_ARGS])
	534	# -----------------------------------------------------
	535	# Run AT_BISON_CHECK's XML/XSLT checks if $BISON_TEST_XML=1 and $XSLTPROC is
	536	# defined. It doesn't make sense to invoke this macro if Bison is expected to
	537	# have a non-zero exit status.
	538	m4_define([AT_BISON_CHECK_XML],
	539	[[if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then]
	540	AT_SAVE_SPECIAL_FILES
	541	[mkdir xml-tests]
	542	m4_pushdef([AT_BISON_ARGS],
	543	[m4_bpatsubsts([[$1]],
	544	[--report(-file)?=[^][ ]*], [],
	545	[--graph=[^][ ]*], [],
	546	[--xml=[^][ ]*], [])])dnl
	547	# Don't combine these Bison invocations since we want to be sure that
	548	# --report=all isn't required to get the full XML file.
	549	AT_BISON_CHECK_([[--report=all --report-file=xml-tests/test.output \
	550	--graph=xml-tests/test.dot ]]AT_BISON_ARGS,
	551	[[0]], [ignore], [ignore])
	552	AT_BISON_CHECK_([[--xml=xml-tests/test.xml ]]AT_BISON_ARGS,
	553	[[0]], [ignore], [ignore])
	554	m4_popdef([AT_BISON_ARGS])dnl
	555	[cp xml-tests/test.output expout]
	556	AT_CHECK([[$XSLTPROC \
	557	`]]AT_QUELL_VALGRIND[[ bison --print-datadir`/xslt/xml2text.xsl \
	558	xml-tests/test.xml]], [[0]], [expout])
	559	[cp xml-tests/test.dot expout]
	560	AT_CHECK([[$XSLTPROC \
	561	`]]AT_QUELL_VALGRIND[[ bison --print-datadir`/xslt/xml2dot.xsl \
	562	xml-tests/test.xml]], [[0]], [expout])
	563	[rm -rf xml-tests expout]
	564	AT_RESTORE_SPECIAL_FILES
	565	[fi]])
	566
	567	# AT_QUELL_VALGRIND
	568	# -----------------
	569	# Put this before a Bison invocation to keep Valgrind from complaining about
	570	# reachable memory.
	571	#
	572	# Do not quote invocations of this macro within the first argument of AT_CHECK.
	573	# The triple quoting below will cause test cases to fail if you do. If you do
	574	# so anyway but also decrease the quoting below to avoid that problem, AT_CHECK
	575	# will then fail to shell-escape its contents when attempting to print them.
	576	# The testsuite verbose output, at least, will be incorrect, but nothing may
	577	# fail to make sure you notice.
	578	m4_define([AT_QUELL_VALGRIND],
	579	[[[VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS;]]])
	580
	581
	582
	583	## ------------------------ ##
	584	## Compiling C, C++ Files. ##
	585	## ------------------------ ##
	586
	587
	588	# AT_COMPILE(OUTPUT, [SOURCES = OUTPUT.c])
	589	# ----------------------------------------
	590	# Compile SOURCES into OUTPUT.
	591	#
	592	# If OUTPUT does not contain '.', assume that we are linking too,
	593	# otherwise pass "-c"; this is a hack. The default SOURCES is OUTPUT
	594	# with trailing .o removed, and ".c" appended.
	595	m4_define([AT_COMPILE],
	596	[AT_CHECK([case $POSIXLY_CORRECT_IS_EXPORTED:$C_COMPILER_POSIXLY_CORRECT in
	597	true:false) echo 'cannot compile properly with POSIXLY_CORRECT' && exit 77;;
	598	esac])
	599	AT_CHECK(m4_join([ ],
	600	[$CC $CFLAGS $CPPFLAGS],
	601	[m4_bmatch([$1], [[.]], [-c], [$LDFLAGS])],
	602	[-o $1],
	603	[m4_default([$2], [m4_bpatsubst([$1], [\.o$]).c])],
	604	[m4_bmatch([$1], [[.]], [], [$LIBS])]),
	605	0, [ignore], [ignore])])
	606
	607	# AT_COMPILE_CXX(OUTPUT, [SOURCES = OUTPUT.cc])
	608	# ---------------------------------------------
	609	# Compile SOURCES into OUTPUT. If the C++ compiler does not work,
	610	# ignore the test.
	611	#
	612	# If OUTPUT does not contain '.', assume that we are linking too,
	613	# otherwise pass "-c"; this is a hack. The default SOURCES is OUTPUT
	614	# with trailing .o removed, and ".cc" appended.
	615	m4_define([AT_COMPILE_CXX],
	616	[AT_KEYWORDS(c++)
	617	AT_CHECK([$BISON_CXX_WORKS], 0, ignore, ignore)
	618	AT_CHECK(m4_join([ ],
	619	[$CXX $CXXFLAGS $CPPFLAGS],
	620	[m4_bmatch([$1], [[.]], [-c], [$LDFLAGS])],
	621	[-o $1],
	622	[m4_default([$2], [m4_bpatsubst([$1], [\.o$]).cc])],
	623	[m4_bmatch([$1], [[.]], [], [$LIBS])]),
	624	0, [ignore], [ignore])])
	625
	626	# AT_JAVA_COMPILE(SOURCES)
	627	# ------------------------
	628	# Compile SOURCES into Java class files. Skip the test if java or javac
	629	# is not installed.
	630	m4_define([AT_JAVA_COMPILE],
	631	[AT_KEYWORDS(java)
	632	AT_SKIP_IF([[test -z "$CONF_JAVAC"]])
	633	AT_SKIP_IF([[test -z "$CONF_JAVA"]])
	634	AT_CHECK([[$SHELL ../../../javacomp.sh ]$1],
	635	[[0]], [ignore], [ignore])])
	636
	637	# AT_LANG_COMPILE(OUTPUT, [SOURCES = OUTPUT.c]
	638	# --------------------------------------------
	639	# Compile SOURCES into OUTPUT. Skip if compiler does not work.
	640	#
	641	# If OUTPUT does not contain '.', assume that we are linking too,
	642	# otherwise pass "-c"; this is a hack. The default SOURCES is OUTPUT
	643	# with trailing .o removed, and ".c"/".cc" appended.
	644	m4_define([AT_LANG_COMPILE],
	645	[m4_case(AT_LANG,
	646	[c], [AT_COMPILE([$1], [$2])],
	647	[c++], [AT_COMPILE_CXX([$1], [$2])],
	648	[java], [AT_JAVA_COMPILE([$1.java], [$2])],
	649	[m4_fatal([unknown language: ]m4_defn([AT_LANG]))])[]dnl
	650	])
	651
	652	# AT_FULL_COMPILE(OUTPUT, [OTHER1], [OTHER2])
	653	# -------------------------------------------
	654	# Compile OUTPUT.y to OUTPUT.c, OUTPUT.cc, or OUTPUT.java, and then
	655	# compile it to OUTPUT or OUTPUT.class. If OTHER is specified, compile
	656	# OUTPUT-OTHER.c, OUTPUT-OTHER.cc, or OUTPUT-OTHER.java to OUTPUT or
	657	# OUTPUT.java along with it. Relies on AT_SKEL_CC_IF and
	658	# AT_SKEL_JAVA_IF.
	659	m4_define([AT_FULL_COMPILE],
	660	[m4_case(AT_LANG,
	661	[java],
	662	[AT_BISON_CHECK([-o $1.java $1.y])
	663	AT_LANG_COMPILE([$1],
	664	m4_join([ ],
	665	[$1.java],
	666	m4_ifval($2, [[$1-$2.java]]),
	667	m4_ifval($3, [[$1-$3.java]])))],
	668	[c++],
	669	[AT_BISON_CHECK([-o $1.cc $1.y])
	670	AT_LANG_COMPILE([$1],
	671	m4_join([ ],
	672	[$1.cc],
	673	m4_ifval($2, [[$1-$2.cc]]),
	674	m4_ifval($3, [[$1-$3.cc]])))],
	675	[c],
	676	[AT_BISON_CHECK([-o $1.c $1.y])
	677	AT_LANG_COMPILE([$1],
	678	m4_join([ ],
	679	[$1.c],
	680	m4_ifval($2, [[$1-$2.c]]),
	681	m4_ifval($3, [[$1-$3.c]])))])
	682	])
	683
	684
	685
	686	# AT_SKIP_IF_CANNOT_LINK_C_AND_CXX
	687	# --------------------------------
	688	# Check that we can link together C and C++ objects.
	689	m4_define([AT_SKIP_IF_CANNOT_LINK_C_AND_CXX],
	690	[AT_DATA([c-and-cxx.h],
	691	[[#ifdef __cplusplus
	692	extern "C"
	693	{
	694	#endif
	695	int fortytwo (void);
	696	#ifdef __cplusplus
	697	}
	698	#endif
	699	]])
	700	AT_DATA([c-only.c],
	701	[[#include "c-and-cxx.h"
	702	int
	703	main (void)
	704	{
	705	return fortytwo () == 42 ? 0 : 1;
	706	}
	707	]])
	708	AT_DATA([cxx-only.cc],
	709	[[#include "c-and-cxx.h"
	710	int fortytwo ()
	711	{
	712	return 42;
	713	}
	714	]])
	715	AT_COMPILE([c-only.o], [c-only.c])
	716	AT_COMPILE_CXX([cxx-only.o], [cxx-only.cc])
	717	AT_CHECK([$CXX $CXXFLAGS $CPPFLAGS $LDFLAGS c-only.o cxx-only.o -o c-and-cxx \|\|
	718	exit 77], [ignore], [ignore])
	719	AT_CHECK([./c-and-cxx])
	720	])
	721
	722
	723	## ---------------------------- ##
	724	## Running a generated parser. ##
	725	## ---------------------------- ##
	726
	727
	728	# AT_PARSER_CHECK(COMMAND, EXIT-STATUS, EXPOUT, EXPERR, [PRE])
	729	# ------------------------------------------------------------
	730	# So that we can run `./testsuite PREPARSER='valgrind -q' for instance.
	731	#
	732	# Get rid of spurious messages when compiled with --coverage:
	733	# +profiling:/[...]/lib/fprintf.gcda:Merge mismatch for summaries
	734	m4_define([AT_PARSER_CHECK],
	735	[AT_CHECK([$5 $PREPARSER $1], [$2], [$3], [stderr])
	736	AT_CHECK([sed >&2 -e '/^profiling:.*:Merge mismatch for summaries/d' stderr],
	737	[0], [], [$4])
	738	])
	739
	740
	741	# AT_JAVA_PARSER_CHECK(COMMAND, EXIT-STATUS, EXPOUT, EXPERR, [PRE])
	742	# -----------------------------------------------------------------
	743	m4_define([AT_JAVA_PARSER_CHECK],
	744	[AT_CHECK([$5[ $SHELL ../../../javaexec.sh ]$1], [$2], [$3], [$4])])
	745
	746
	747	# AT_TEST_TABLES_AND_PARSE(TITLE, COND-VALUE, TEST-SPEC,
	748	# DECLS, GRAMMAR, INPUT,
	749	# BISON-STDERR, TABLES-OR-LAST-STATE,
	750	# [OTHER-CHECKS],
	751	# [PARSER-EXIT-VALUE],
	752	# [PARSER-STDOUT], [PARSER-STDERR])
	753	# -------------------------------------------------------------
	754	# Using TITLE as the test group title, check the generated parser tables
	755	# and parser for a specified grammar file under a condition labeled by
	756	# COND-VALUE.
	757	#
	758	# TEST-SPEC is a comma-delimited list of attributes of this test. Each
	759	# recognized attribute is described below where it is relevant.
	760	#
	761	# Insert DECLS and GRAMMAR into the declarations and grammar section of
	762	# the grammar file. Insert basic yyerror, yylex, and main function
	763	# definitions as well. Hardcode yylex to return the (possibly empty)
	764	# comma-delimited series of tokens in INPUT followed by token 0.
	765	#
	766	# If TEST-SPEC contains the attribute no-xml, then invoke bison using
	767	# AT_BISON_CHECK_NO_XML. Otherwise, invoke bison using AT_BISON_CHECK.
	768	# On the bison command-line, specify `--report=all --defines'. Check
	769	# that Bison exits with value 0, has no stdout, and has stderr
	770	# BISON-STDERR.
	771	#
	772	# If TEST-SPEC contains the attribute `last-state', check that the value
	773	# of TABLES-OR-LAST-STATE is the index of the last state generated for
	774	# the grammar; in other words, check the number of states (minus one).
	775	# Otherwise, check that everything in the `.output' file starting with
	776	# the definition of state 0 is the same as the entire value of
	777	# TABLES-OR-LAST-STATE.
	778	#
	779	# Expand the M4 in OTHER-CHECKS to perform additional checks of the
	780	# `.output' file, which is named `input.output', and/or grammar file,
	781	# which is named `input.y'.
	782	#
	783	# Finally, compile the generated parser and then run it using
	784	# AT_PARSER_CHECK with PARSER-EXIT-VALUE, PARSER-STDOUT, and
	785	# PARSER-STDERR as the 2nd-4th arguments.
	786	#
	787	# As a precondition, you must properly double-quote all arguments that
	788	# are to be interpreted as strings.
	789	#
	790	# AT_COND_CASE (when appearing in single-quoted segments of arguments)
	791	# invokes m4_case with its own arguments but COND-VALUE inserted as the
	792	# first argument. This is useful, for example, when wrapping multiple
	793	# AT_TEST_TABLES_AND_PARSE invocations, each representing a different
	794	# condition, in another macro.
	795	#
	796	# For example:
	797	#
	798	# # AT_TEST_SYNTAX_ERROR(DESCRIPTION, DECLS, GRAMMAR, INPUT, LAST-STATE,
	799	# # PARSER-EXIT-VALUE, PARSER-STDOUT, PARSER-STDERR)
	800	# # ---------------------------------------------------------------------
	801	# m4_define([AT_TEST_SYNTAX_ERROR],
	802	# [
	803	# AT_TEST_TABLES_AND_PARSE([$1[ with %error-verbose]], [[verbose]],
	804	# [[last-state]],
	805	# [[%error-verbose ]$2], [$3], [$4],
	806	# [[]], [$5], [], [$6], [$7], [$8])
	807	# AT_TEST_TABLES_AND_PARSE([$1[ with no %error-verbose]], [[no verbose]],
	808	# [[last-state]],
	809	# [$2], [$3], [$4],
	810	# [[]], [$5], [], [$6], [$7], [$8])
	811	# ])
	812	#
	813	# AT_TEST_SYNTAX_ERROR([[Single Char Grammar]],
	814	# [[%token 'b']], [[start: 'a' ;]], [['a', 'b']],
	815	# [[3]],
	816	# [[1]], [[]],
	817	# [AT_COND_CASE([[no verbose]],
	818	# [[syntax error
	819	# ]],
	820	# [[syntax error, unexpected 'b', expecting $end
	821	# ]])])
	822	m4_define([AT_TEST_TABLES_AND_PARSE],
	823	[m4_pushdef([AT_COND_CASE], [m4_case([$2], $][@)])
	824
	825	AT_SETUP([$1])
	826	AT_BISON_OPTION_PUSHDEFS([$4])
	827	AT_DATA_GRAMMAR([[input.y]],
	828	[[%code {
	829	#include <stdio.h>
	830	]AT_YYERROR_DECLARE[
	831	]AT_YYLEX_DECLARE[
	832	}
	833
	834	]$4[
	835
	836	%%
	837
	838	]$5[
	839
	840	%%
	841	]AT_YYERROR_DEFINE[
	842	static int
	843	yylex (void)
	844	{
	845	static int const input[] = {
	846	]m4_if([$6], [], [], [$6], [[]], [], [$6[, ]])[0
	847	};
	848	static int const *inputp = input;
	849	return *inputp++;
	850	}
	851
	852	int
	853	main (void)
	854	{
	855	return yyparse ();
	856	}
	857	]])
	858
	859	# In some versions of Autoconf, AT_CHECK invokes AS_ESCAPE before
	860	# expanding macros, so it corrupts some special characters in the
	861	# macros. To avoid this, expand now and pass it the result with proper
	862	# string quotation. Assume args 7 through 12 expand to properly quoted
	863	# strings.
	864
	865	m4_if(m4_index(m4_quote($3), [no-xml]), -1,
	866	[AT_BISON_CHECK],
	867	[AT_BISON_CHECK_NO_XML])([[--report=all --defines -o input.c input.y]],
	868	[0], [], m4_dquote($7))
	869
	870	m4_if(m4_index(m4_quote($3), [last-state]), -1,
	871	[AT_CHECK([[sed -n '/^state 0$/,$p' input.output]], [[0]],
	872	m4_dquote($8))],
	873	[AT_CHECK([[sed -n 's/^state //p' input.output \| tail -1]], [[0]],
	874	m4_dquote($8)[[
	875	]])])
	876
	877	$9
	878
	879	# Canonical LR generates very large tables, resulting in very long
	880	# files with #line directives that may overflow what the standards
	881	# (C90 and C++98) guarantee: 32767. In that case, GCC's -pedantic
	882	# will issue an error.
	883	#
	884	# There is no "" around `wc` since some indent the result.
	885	m4_bmatch([$4], [%define lr.type canonical-lr],
	886	[if test 32767 -lt `wc -l < input.c`; then
	887	CFLAGS=`echo " $CFLAGS " \| sed -e 's/ -pedantic //'`
	888	CXXFLAGS=`echo " $CXXFLAGS " \| sed -e 's/ -pedantic //'`
	889	fi])
	890	AT_COMPILE([[input]])
	891
	892	AT_PARSER_CHECK([[./input]],
	893	m4_ifval([$10], [m4_dquote($10)]),
	894	m4_ifval([$11], [m4_dquote($11)]),
	895	m4_ifval([$12], [m4_dquote($12)]))
	896
	897	AT_BISON_OPTION_POPDEFS
	898	AT_CLEANUP
	899
	900	m4_popdef([AT_COND_CASE])])
	901
	902
	903
	904	## ----------------------- ##
	905	## Launch the test suite. ##
	906	## ----------------------- ##
	907
	908	AT_INIT
	909
	910	# Cannot assign CC and CFLAGS here, since atlocal is loaded after
	911	# options are processed, so we don't know the value of CXX and
	912	# CXXFLAGS yet.
	913	#
	914	# Note that it also means that command line values for CXX and
	915	# CXXFLAGS will not be propagated to CC and CFLAGS.
	916	AT_ARG_OPTION([compile-c-with-cxx],
	917	[compile C parsers with the C++ compiler])
	918
	919	AT_COLOR_TESTS
	920
	921	AT_TESTED([bison])