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