src/bison/2.4.1/bison-2.4.1-src/tests/local.at - chromium/deps/bison - Git at Google

 # Process this -*- Autotest -*- file with autom4te.

 # Macros for the GNU Bison Test suite.
 # Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 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/>.

 # We want a recent Autotest.
 m4_version_prereq([2.58])


 ## ------------------------------- ##
 ## Macros decoding Bison options.  ##
 ## ------------------------------- ##


 # AT_BISON_OPTION_PUSHDEFS([BISON-OPTIONS])
 # -----------------------------------------
 m4_define([AT_BISON_OPTION_PUSHDEFS],
 [_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_if([$1$2], $[1]$[2], [],
        [m4_fatal([$0: Invalid arguments: $@])])dnl
 m4_pushdef([AT_DEFINES_IF],
 [m4_bmatch([$3], [%defines], [$1], [$2])])
 m4_pushdef([AT_SKEL_CC_IF],
 [m4_bmatch([$3], [%language "[Cc]\+\+"\|%skeleton "[a-z0-9]+\.cc"], [$1], [$2])])
 m4_pushdef([AT_GLR_IF],
 [m4_bmatch([$3], [%glr-parser\|%skeleton "glr\.], [$1], [$2])])
 m4_pushdef([AT_LALR1_CC_IF],
 [AT_SKEL_CC_IF([AT_GLR_IF([$2], [$1])], [$2])])
 m4_pushdef([AT_GLR_CC_IF],
 [AT_SKEL_CC_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_PARAM_IF],
 [m4_bmatch([$3], [%parse-param], [$1], [$2])])
 m4_pushdef([AT_LOCATION_IF],
 [m4_bmatch([$3], [%locations], [$1], [$2])])
 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_PURE_AND_LOC_IF],
 [m4_bmatch([$3], [%locations], [AT_PURE_IF($@)], [$2])])
 m4_pushdef([AT_GLR_OR_PARAM_IF],
 [m4_bmatch([$3], [%glr-parser\|%parse-param], [$1], [$2])])
 m4_pushdef([AT_NAME_PREFIX],
 [m4_bmatch([$3], [%name-prefix ".*"],
            [m4_bregexp([$3], [name-prefix "\([^"]*\)"], [\1])],
            [yy])])
 # yyerror receives the location if %location & %pure & (%glr or %parse-param).
 m4_pushdef([AT_YYERROR_ARG_LOC_IF],
 [AT_GLR_OR_PARAM_IF([AT_PURE_AND_LOC_IF([$1], [$2])],
 		    [$2])])
 # yyerror always sees the locations (when activated), except if
 # (yacc & pure & !param).  FIXME: This is wrong.  See the manual.
 m4_pushdef([AT_YYERROR_SEES_LOC_IF],
 [AT_LOCATION_IF([AT_YACC_IF([AT_PURE_IF([AT_PARAM_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_SKEL_CC_IF([$1], [$2])])])

 AT_PURE_LEX_IF(
 [m4_pushdef([AT_LOC], [(*llocp)])
  m4_pushdef([AT_VAL], [(*lvalp)])
  m4_pushdef([AT_LEX_FORMALS],
 	    [YYSTYPE *lvalp[]AT_LOCATION_IF([, YYLTYPE *llocp])])
  m4_pushdef([AT_LEX_ARGS],
 	    [lvalp[]AT_LOCATION_IF([, llocp])])
  m4_pushdef([AT_USE_LEX_ARGS],
 	    [(void) lvalp;AT_LOCATION_IF([(void) llocp])])
  m4_pushdef([AT_LEX_PRE_FORMALS],
 	    [AT_LEX_FORMALS, ])
  m4_pushdef([AT_LEX_PRE_ARGS],
 	    [AT_LEX_ARGS, ])
 ],
 [m4_pushdef([AT_LOC], [[(]AT_NAME_PREFIX[lloc)]])
  m4_pushdef([AT_VAL], [[(]AT_NAME_PREFIX[lval)]])
  m4_pushdef([AT_LEX_FORMALS],     [void])
  m4_pushdef([AT_LEX_ARGS],        [])
  m4_pushdef([AT_USE_LEX_ARGS],    [])
  m4_pushdef([AT_LEX_PRE_FORMALS], [])
  m4_pushdef([AT_LEX_PRE_ARGS],    [])
 ])
 ])# _AT_BISON_OPTION_PUSHDEFS


 # AT_BISON_OPTION_POPDEFS
 # -----------------------
 m4_define([AT_BISON_OPTION_POPDEFS],
 [m4_popdef([AT_LEX_PRE_ARGS])
 m4_popdef([AT_LEX_PRE_FORMALS])
 m4_popdef([AT_USE_LEX_ARGS])
 m4_popdef([AT_LEX_ARGS])
 m4_popdef([AT_LEX_FORMALS])
 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_NAME_PREFIX])
 m4_popdef([AT_GLR_OR_PARAM_IF])
 m4_popdef([AT_PURE_AND_LOC_IF])
 m4_popdef([AT_LOCATION_IF])
 m4_popdef([AT_PARAM_IF])
 m4_popdef([AT_LEXPARAM_IF])
 m4_popdef([AT_YACC_IF])
 m4_popdef([AT_GLR_IF])
 m4_popdef([AT_SKEL_CC_IF])
 m4_popdef([AT_GLR_CC_IF])
 m4_popdef([AT_LALR1_CC_IF])
 m4_popdef([AT_DEFINES_IF])
 ])# AT_BISON_OPTION_POPDEFS


 ## -------------------------- ##
 ## Generating Grammar Files.  ##
 ## -------------------------- ##

 # AT_DATA_SOURCE_PROLOGUE
 # ------------------------
 # The prologue that should be included in any source code that is
 # meant to be compiled.
 m4_define([AT_DATA_SOURCE_PROLOGUE],
 [[#include <config.h>
 /* We don't need perfect functions for these tests. */
 #undef malloc
 #undef memcmp
 #undef realloc
 ]])

 # AT_DATA_GRAMMAR_PROLOGUE
 # ------------------------
 # The prologue that should be included in any grammar which 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, which 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, which CONTENT is preceded by
 # AT_DATA_GRAMMAR_PROLOGUE.
 m4_define([AT_DATA_GRAMMAR],
 [AT_DATA([$1],
 [AT_DATA_GRAMMAR_PROLOGUE
 $2])
 ])

 # AT_BISON_CHECK(BISON_ARGS, [OTHER_AT_CHECK_ARGS])
 # -------------------------------------------------
 # Check Bison by invoking `bison BISON_ARGS'.  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.
 m4_define([AT_BISON_CHECK],
 [m4_if(m4_quote($2), [0], [AT_BISON_CHECK_XML($@)],
        m4_quote($2), [], [AT_BISON_CHECK_XML($@)])
 AT_BISON_CHECK_NO_XML($@)])

 # 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(m4_if(m4_quote($2), [0], [], m4_quote($2), [], [],
                 [AT_QUELL_VALGRIND ])[[bison ]]$@)])

 # 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
   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_CHECK([[bison --report=all --report-file=xml-tests/test.output \
              --graph=xml-tests/test.dot ]]AT_BISON_ARGS,
            [[0]], [ignore], [ignore])
   AT_CHECK([[bison --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_QUELL_VALGRIND[[ bison --print-datadir`/xslt/xml2text.xsl \
              xml-tests/test.xml]], [[0]], [expout])
   [cp xml-tests/test.dot expout]
   AT_CHECK([[$XSLTPROC \
              `]]AT_QUELL_VALGRIND[[ bison --print-datadir`/xslt/xml2dot.xsl \
              xml-tests/test.xml]], [[0]], [expout])
   [rm -rf xml-tests expout
 fi]])

 # AT_QUELL_VALGRIND
 # -----------------
 # Put this before a Bison invocation to keep Valgrind from complaining about
 # reachable memory.
 #
 # 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_QUELL_VALGRIND],
 [[[VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS;]]])

 ## ------------------------ ##
 ## Compiling C, C++ Files.  ##
 ## ------------------------ ##


 # AT_COMPILE(OUTPUT, [SOURCES = OUTPUT.c])
 # ----------------------------------------
 # Compile SOURCES into OUTPUT.  If OUTPUT does not contain '.',
 # assume that we are linking too; this is a hack.
 m4_define([AT_COMPILE],
 [AT_CHECK([$CC $CFLAGS $CPPFLAGS m4_bmatch([$1], [[.]], [], [$LDFLAGS ])-o $1 m4_default([$2], [$1.c])[]m4_bmatch([$1], [[.]], [], [ $LIBS])],
 	   0, [ignore], [ignore])])

 # AT_COMPILE_CXX(OUTPUT, [SOURCES = OUTPUT.cc])
 # --------------------------------------------
 # Compile SOURCES into OUTPUT.  If OUTPUT does not contain '.',
 # assume that we are linking too; this is a hack.
 # If the C++ compiler does not work, ignore the test.
 m4_define([AT_COMPILE_CXX],
 [AT_KEYWORDS(c++)
 AT_CHECK([$BISON_CXX_WORKS], 0, ignore, ignore)
 AT_CHECK([$CXX $CXXFLAGS $CPPFLAGS m4_bmatch([$1], [[.]], [], [$LDFLAGS ])-o $1 m4_default([$2], [$1.cc])[]m4_bmatch([$1], [[.]], [], [ $LIBS])],
 	 0, [ignore], [ignore])])


 # AT_FULL_COMPILE(OUTPUT, [OTHER])
 # --------------------------------
 # Compile OUTPUT.y to OUTPUT.c or OUTPUT.cc, and compile it to OUTPUT.
 # If OTHER is specified, compile OUTPUT-OTHER.c or OUTPUT-OTHER.cc to OUTPUT
 # along with it.
 # Relies on AT_SKEL_CC_IF.
 m4_define([AT_FULL_COMPILE],
 [AT_SKEL_CC_IF(
   [AT_BISON_CHECK([-o $1.cc $1.y])
    AT_COMPILE_CXX([$1]m4_ifval($2, [, [$1.cc $1-$2.cc]]))],
   [AT_BISON_CHECK([-o $1.c $1.y])
    AT_COMPILE([$1]m4_ifval($2, [, [$1.c $1-$2.c]]))])
 ])


 ## ---------------------------- ##
 ## Running a generated parser.  ##
 ## ---------------------------- ##

 # AT_PARSER_CHECK(COMMAND, EXIT-STATUS, EXPOUT, EXPERR, [PRE])
 # ------------------------------------------------------------
 # So that we can run `./testsuite PREPARSER='valgrind -q' for instance.
 m4_define([AT_PARSER_CHECK],
 [AT_CHECK([$5 $PREPARSER $1], [$2], [$3], [$4])])


 ## ----------------------- ##
 ## Launch the test suite.  ##
 ## ----------------------- ##

 AT_INIT

 AT_TESTED([bison])
	# Process this -- Autotest -- file with autom4te.

	# Macros for the GNU Bison Test suite.
	# Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 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/>.

	# We want a recent Autotest.
	m4_version_prereq([2.58])


	## ------------------------------- ##
	## Macros decoding Bison options. ##
	## ------------------------------- ##


	# AT_BISON_OPTION_PUSHDEFS([BISON-OPTIONS])
	# -----------------------------------------
	m4_define([AT_BISON_OPTION_PUSHDEFS],
	[_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_if([$1$2], $[1]$[2], [],
	[m4_fatal([$0: Invalid arguments: $@])])dnl
	m4_pushdef([AT_DEFINES_IF],
	[m4_bmatch([$3], [%defines], [$1], [$2])])
	m4_pushdef([AT_SKEL_CC_IF],
	[m4_bmatch([$3], [%language "[Cc]\+\+"\\|%skeleton "[a-z0-9]+\.cc"], [$1], [$2])])
	m4_pushdef([AT_GLR_IF],
	[m4_bmatch([$3], [%glr-parser\\|%skeleton "glr\.], [$1], [$2])])
	m4_pushdef([AT_LALR1_CC_IF],
	[AT_SKEL_CC_IF([AT_GLR_IF([$2], [$1])], [$2])])
	m4_pushdef([AT_GLR_CC_IF],
	[AT_SKEL_CC_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_PARAM_IF],
	[m4_bmatch([$3], [%parse-param], [$1], [$2])])
	m4_pushdef([AT_LOCATION_IF],
	[m4_bmatch([$3], [%locations], [$1], [$2])])
	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_PURE_AND_LOC_IF],
	[m4_bmatch([$3], [%locations], [AT_PURE_IF($@)], [$2])])
	m4_pushdef([AT_GLR_OR_PARAM_IF],
	[m4_bmatch([$3], [%glr-parser\\|%parse-param], [$1], [$2])])
	m4_pushdef([AT_NAME_PREFIX],
	[m4_bmatch([$3], [%name-prefix ".*"],
	[m4_bregexp([$3], [name-prefix "\([^"]*\)"], [\1])],
	[yy])])
	# yyerror receives the location if %location & %pure & (%glr or %parse-param).
	m4_pushdef([AT_YYERROR_ARG_LOC_IF],
	[AT_GLR_OR_PARAM_IF([AT_PURE_AND_LOC_IF([$1], [$2])],
	[$2])])
	# yyerror always sees the locations (when activated), except if
	# (yacc & pure & !param). FIXME: This is wrong. See the manual.
	m4_pushdef([AT_YYERROR_SEES_LOC_IF],
	[AT_LOCATION_IF([AT_YACC_IF([AT_PURE_IF([AT_PARAM_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_SKEL_CC_IF([$1], [$2])])])

	AT_PURE_LEX_IF(
	[m4_pushdef([AT_LOC], [(*llocp)])
	m4_pushdef([AT_VAL], [(*lvalp)])
	m4_pushdef([AT_LEX_FORMALS],
	[YYSTYPE lvalp[]AT_LOCATION_IF([, YYLTYPE llocp])])
	m4_pushdef([AT_LEX_ARGS],
	[lvalp[]AT_LOCATION_IF([, llocp])])
	m4_pushdef([AT_USE_LEX_ARGS],
	[(void) lvalp;AT_LOCATION_IF([(void) llocp])])
	m4_pushdef([AT_LEX_PRE_FORMALS],
	[AT_LEX_FORMALS, ])
	m4_pushdef([AT_LEX_PRE_ARGS],
	[AT_LEX_ARGS, ])
	],
	[m4_pushdef([AT_LOC], [[(]AT_NAME_PREFIX[lloc)]])
	m4_pushdef([AT_VAL], [[(]AT_NAME_PREFIX[lval)]])
	m4_pushdef([AT_LEX_FORMALS], [void])
	m4_pushdef([AT_LEX_ARGS], [])
	m4_pushdef([AT_USE_LEX_ARGS], [])
	m4_pushdef([AT_LEX_PRE_FORMALS], [])
	m4_pushdef([AT_LEX_PRE_ARGS], [])
	])
	])# _AT_BISON_OPTION_PUSHDEFS


	# AT_BISON_OPTION_POPDEFS
	# -----------------------
	m4_define([AT_BISON_OPTION_POPDEFS],
	[m4_popdef([AT_LEX_PRE_ARGS])
	m4_popdef([AT_LEX_PRE_FORMALS])
	m4_popdef([AT_USE_LEX_ARGS])
	m4_popdef([AT_LEX_ARGS])
	m4_popdef([AT_LEX_FORMALS])
	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_NAME_PREFIX])
	m4_popdef([AT_GLR_OR_PARAM_IF])
	m4_popdef([AT_PURE_AND_LOC_IF])
	m4_popdef([AT_LOCATION_IF])
	m4_popdef([AT_PARAM_IF])
	m4_popdef([AT_LEXPARAM_IF])
	m4_popdef([AT_YACC_IF])
	m4_popdef([AT_GLR_IF])
	m4_popdef([AT_SKEL_CC_IF])
	m4_popdef([AT_GLR_CC_IF])
	m4_popdef([AT_LALR1_CC_IF])
	m4_popdef([AT_DEFINES_IF])
	])# AT_BISON_OPTION_POPDEFS



	## -------------------------- ##
	## Generating Grammar Files. ##
	## -------------------------- ##

	# AT_DATA_SOURCE_PROLOGUE
	# ------------------------
	# The prologue that should be included in any source code that is
	# meant to be compiled.
	m4_define([AT_DATA_SOURCE_PROLOGUE],
	[[#include <config.h>
	/* We don't need perfect functions for these tests. */
	#undef malloc
	#undef memcmp
	#undef realloc
	]])

	# AT_DATA_GRAMMAR_PROLOGUE
	# ------------------------
	# The prologue that should be included in any grammar which 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, which 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, which CONTENT is preceded by
	# AT_DATA_GRAMMAR_PROLOGUE.
	m4_define([AT_DATA_GRAMMAR],
	[AT_DATA([$1],
	[AT_DATA_GRAMMAR_PROLOGUE
	$2])
	])

	# AT_BISON_CHECK(BISON_ARGS, [OTHER_AT_CHECK_ARGS])
	# -------------------------------------------------
	# Check Bison by invoking `bison BISON_ARGS'. 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.
	m4_define([AT_BISON_CHECK],
	[m4_if(m4_quote($2), [0], [AT_BISON_CHECK_XML($@)],
	m4_quote($2), [], [AT_BISON_CHECK_XML($@)])
	AT_BISON_CHECK_NO_XML($@)])

	# 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(m4_if(m4_quote($2), [0], [], m4_quote($2), [], [],
	[AT_QUELL_VALGRIND ])[[bison ]]$@)])

	# 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
	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_CHECK([[bison --report=all --report-file=xml-tests/test.output \
	--graph=xml-tests/test.dot ]]AT_BISON_ARGS,
	[[0]], [ignore], [ignore])
	AT_CHECK([[bison --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_QUELL_VALGRIND[[ bison --print-datadir`/xslt/xml2text.xsl \
	xml-tests/test.xml]], [[0]], [expout])
	[cp xml-tests/test.dot expout]
	AT_CHECK([[$XSLTPROC \
	`]]AT_QUELL_VALGRIND[[ bison --print-datadir`/xslt/xml2dot.xsl \
	xml-tests/test.xml]], [[0]], [expout])
	[rm -rf xml-tests expout
	fi]])

	# AT_QUELL_VALGRIND
	# -----------------
	# Put this before a Bison invocation to keep Valgrind from complaining about
	# reachable memory.
	#
	# 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_QUELL_VALGRIND],
	[[[VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS;]]])

	## ------------------------ ##
	## Compiling C, C++ Files. ##
	## ------------------------ ##


	# AT_COMPILE(OUTPUT, [SOURCES = OUTPUT.c])
	# ----------------------------------------
	# Compile SOURCES into OUTPUT. If OUTPUT does not contain '.',
	# assume that we are linking too; this is a hack.
	m4_define([AT_COMPILE],
	[AT_CHECK([$CC $CFLAGS $CPPFLAGS m4_bmatch([$1], [[.]], [], [$LDFLAGS ])-o $1 m4_default([$2], [$1.c])[]m4_bmatch([$1], [[.]], [], [ $LIBS])],
	0, [ignore], [ignore])])

	# AT_COMPILE_CXX(OUTPUT, [SOURCES = OUTPUT.cc])
	# --------------------------------------------
	# Compile SOURCES into OUTPUT. If OUTPUT does not contain '.',
	# assume that we are linking too; this is a hack.
	# If the C++ compiler does not work, ignore the test.
	m4_define([AT_COMPILE_CXX],
	[AT_KEYWORDS(c++)
	AT_CHECK([$BISON_CXX_WORKS], 0, ignore, ignore)
	AT_CHECK([$CXX $CXXFLAGS $CPPFLAGS m4_bmatch([$1], [[.]], [], [$LDFLAGS ])-o $1 m4_default([$2], [$1.cc])[]m4_bmatch([$1], [[.]], [], [ $LIBS])],
	0, [ignore], [ignore])])


	# AT_FULL_COMPILE(OUTPUT, [OTHER])
	# --------------------------------
	# Compile OUTPUT.y to OUTPUT.c or OUTPUT.cc, and compile it to OUTPUT.
	# If OTHER is specified, compile OUTPUT-OTHER.c or OUTPUT-OTHER.cc to OUTPUT
	# along with it.
	# Relies on AT_SKEL_CC_IF.
	m4_define([AT_FULL_COMPILE],
	[AT_SKEL_CC_IF(
	[AT_BISON_CHECK([-o $1.cc $1.y])
	AT_COMPILE_CXX([$1]m4_ifval($2, [, [$1.cc $1-$2.cc]]))],
	[AT_BISON_CHECK([-o $1.c $1.y])
	AT_COMPILE([$1]m4_ifval($2, [, [$1.c $1-$2.c]]))])
	])


	## ---------------------------- ##
	## Running a generated parser. ##
	## ---------------------------- ##

	# AT_PARSER_CHECK(COMMAND, EXIT-STATUS, EXPOUT, EXPERR, [PRE])
	# ------------------------------------------------------------
	# So that we can run `./testsuite PREPARSER='valgrind -q' for instance.
	m4_define([AT_PARSER_CHECK],
	[AT_CHECK([$5 $PREPARSER $1], [$2], [$3], [$4])])




	## ----------------------- ##
	## Launch the test suite. ##
	## ----------------------- ##

	AT_INIT

	AT_TESTED([bison])