X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/6d55954743c7243ba46680f368c76ee70b1112f8..37cfa1195debf4261cac67fb2875d04da589a88f:/tests/local.at diff --git a/tests/local.at b/tests/local.at index 02093938..4499e13f 100644 --- a/tests/local.at +++ b/tests/local.at @@ -20,6 +20,15 @@ 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])]) + ## ------------- ## ## Basic tests. ## ## ------------- ## @@ -44,6 +53,8 @@ m4_divert_text([PREPARE_TESTS], { 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 } @@ -90,14 +101,15 @@ m4_popdef([AT_LOC_LAST_COLUMN])]) # AT_BISON_OPTION_PUSHDEFS([BISON-OPTIONS]) # ----------------------------------------- m4_define([AT_BISON_OPTION_PUSHDEFS], -[_AT_BISON_OPTION_PUSHDEFS($[1], $[2], [$1])]) +[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. +# 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 @@ -137,52 +149,65 @@ m4_pushdef([AT_PURE_AND_LOC_IF], 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])], +[m4_bmatch([$3], [\(%define api\.prefix\|%name-prefix\) ".*"], + [m4_bregexp([$3], [\(%define api\.prefix\|%name-prefix\) "\([^""]*\)"], [\2])], [yy])]) -m4_pushdef([AT_API_PREFIX], +m4_pushdef([AT_TOKEN_PREFIX], +[m4_bmatch([$3], [%define api.tokens.prefix ".*"], + [m4_bregexp([$3], [%define api.tokens.prefix "\(.*\)"], [\1])])]) +m4_pushdef([AT_API_prefix], [m4_bmatch([$3], [%define api\.prefix ".*"], [m4_bregexp([$3], [%define api\.prefix "\([^""]*\)"], [\1])], [yy])]) +m4_pushdef([AT_API_PREFIX], +[m4_toupper(AT_API_prefix)]) # 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])]) + [$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])]) + [$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_SKEL_CC_IF([$1], [$2])])]) + +m4_pushdef([AT_YYSTYPE], +[AT_SKEL_CC_IF([AT_NAME_PREFIX[::parser::semantic_type]], + [AT_API_PREFIX[STYPE]])]) +m4_pushdef([AT_YYLTYPE], +[AT_SKEL_CC_IF([AT_NAME_PREFIX[::parser::location_type]], + [AT_API_PREFIX[LTYPE]])]) + 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_YYLEX_FORMALS], + [AT_YYSTYPE *lvalp[]AT_LOCATION_IF([, AT_YYLTYPE *llocp])]) + 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_LEX_PRE_FORMALS], - [AT_LEX_FORMALS, ]) - m4_pushdef([AT_LEX_PRE_ARGS], - [AT_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_LEX_FORMALS], [void]) - m4_pushdef([AT_LEX_ARGS], []) + m4_pushdef([AT_YYLEX_FORMALS], [void]) + m4_pushdef([AT_YYLEX_ARGS], []) m4_pushdef([AT_USE_LEX_ARGS], []) - m4_pushdef([AT_LEX_PRE_FORMALS], []) - m4_pushdef([AT_LEX_PRE_ARGS], []) + m4_pushdef([AT_YYLEX_PRE_FORMALS], []) + m4_pushdef([AT_YYLEX_PRE_ARGS], []) ]) # Handle the different types of location components. @@ -193,23 +218,29 @@ AT_SKEL_CC_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_popdef([AT_LEX_PRE_ARGS]) -m4_popdef([AT_LEX_PRE_FORMALS]) +[m4_divert_text([KILL], +[m4_popdef([AT_YYLEX_PRE_ARGS]) +m4_popdef([AT_YYLEX_PRE_FORMALS]) m4_popdef([AT_USE_LEX_ARGS]) -m4_popdef([AT_LEX_ARGS]) -m4_popdef([AT_LEX_FORMALS]) +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_NAME_PREFIX]) m4_popdef([AT_GLR_OR_PARAM_IF]) m4_popdef([AT_PURE_AND_LOC_IF]) @@ -225,7 +256,7 @@ m4_popdef([AT_SKEL_JAVA_IF]) m4_popdef([AT_GLR_CC_IF]) m4_popdef([AT_LALR1_CC_IF]) m4_popdef([AT_DEFINES_IF]) -AT_LOC_POPDEF +AT_LOC_POPDEF])dnl ])# AT_BISON_OPTION_POPDEFS @@ -276,12 +307,20 @@ m4_define([AT_DATA_GRAMMAR], $2]) ]) +# AT_YYLEX_PROTOTYPE # AT_YYLEX_DECLARE_EXTERN # AT_YYLEX_DECLARE -# AT_YYLEX_DEFINE(INPUT-STRING, [ACTION]) -# --------------------------------------- +# 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], +[int AT_NAME_PREFIX[]lex (]AT_YYLEX_FORMALS[)[]dnl +]) + m4_define([AT_YYLEX_DECLARE_EXTERN], -[int AT_API_PREFIX[]lex (]AT_LEX_FORMALS[);dnl +[AT_YYLEX_PROTOTYPE;dnl ]) m4_define([AT_YYLEX_DECLARE], @@ -289,19 +328,21 @@ m4_define([AT_YYLEX_DECLARE], ]) m4_define([AT_YYLEX_DEFINE], -[[#include /* abort */ -static int -]AT_API_PREFIX[lex (]AT_LEX_FORMALS[) +[[#include +static +]AT_YYLEX_PROTOTYPE[ { - static char const input[] = "$1"; + ]m4_bmatch([$1], [^\(".*"\)?$], + [[static char const input[] = ]m4_default([$1], [""])], + [[static int const input[] = ]$1])[; static size_t toknum = 0; int res; - if (! (toknum < sizeof input)) - abort (); + ]AT_USE_LEX_ARGS[; + assert (toknum < sizeof input / sizeof input[0]); res = input[toknum++]; - ]$2;[]AT_LOCATION_IF([[ - ]AT_API_PREFIX[lloc.first_line = ]AT_API_PREFIX[lloc.last_line = 1; - ]AT_API_PREFIX[lloc.first_column = ]AT_API_PREFIX[lloc.last_column = toknum;]])[ + ]$2[;]AT_LOCATION_IF([[ + ]AT_LOC_FIRST_LINE[ = ]AT_LOC_LAST_LINE[ = 1; + ]AT_LOC_FIRST_COLUMN[ = ]AT_LOC_LAST_COLUMN[ = toknum;]])[ return res; }]dnl ]) @@ -312,9 +353,14 @@ static int # AT_YYERROR_DEFINE # ------------------------- # Must be called inside a AT_BISON_OPTION_PUSHDEFS/POPDEFS pair. +m4_define([AT_YYERROR_FORMALS], +[m4_case(AT_LANG, +[c], [AT_YYERROR_ARG_LOC_IF([AT_YYLTYPE *llocp, ])[const char *msg]])[]dnl +]) + m4_define([AT_YYERROR_PROTOTYPE], [m4_case(AT_LANG, -[c], [[void ]AT_API_PREFIX[error (]AT_YYERROR_ARG_LOC_IF([YYLTYPE *llocp, ])[const char *msg)]])[]dnl +[c], [[void ]AT_NAME_PREFIX[error (]AT_YYERROR_FORMALS[)]])[]dnl ]) m4_define([AT_YYERROR_DECLARE_EXTERN], @@ -348,13 +394,11 @@ static }]], [c++], [[/* A C++ error reporting function. */ void -]AT_NAME_PREFIX[::parser::error (const location_type& l, const std::string& m) -{ - (void) l; - std::cerr << ]AT_LOCATION_IF([l << ": " << ])[m << std::endl; +]AT_NAME_PREFIX[::parser::error (]AT_LOCATION_IF([[const location_type& l, ]])[const std::string& m) +{ std::cerr << ]AT_LOCATION_IF([l << ": " << ])[m << std::endl; }]], [java], [AT_LOCATION_IF([[public void yyerror (Calc.Location l, String s) - { +{ if (l == null) System.err.println (s); else @@ -364,7 +408,7 @@ void public void yyerror (String s) { System.err.println (s); - }]])])dnl +}]])])dnl ]) @@ -374,6 +418,9 @@ void # 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 @@ -394,24 +441,30 @@ void # # 4. If stderr contains a warning, -Wnone and --warnings=none suppress it. m4_define([AT_BISON_CHECK], -[m4_if(m4_quote($2), [0], [AT_BISON_CHECK_XML($@)], - m4_quote($2), [], [AT_BISON_CHECK_XML($@)]) +[m4_null_if([$2], [AT_BISON_CHECK_XML($@)]) AT_BISON_CHECK_NO_XML($@)]) m4_define([AT_BISON_WERROR_MSG], [[bison: warnings being treated as errors]]) -# 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 ]]$@) -m4_if(m4_bregexp([$4], [: warning: ]), [-1], [], - m4_quote(m4_if(m4_quote($2), [], [0], [$2])), [0], [[ - # Defining POSIXLY_CORRECT causes bison to complain if options + +# AT_BISON_CHECK_(BISON_ARGS, [OTHER_AT_CHECK_ARGS]) +# -------------------------------------------------- +# Low-level macro to run bison once. +m4_define([AT_BISON_CHECK_], +[AT_CHECK(AT_QUELL_VALGRIND[[ bison ]]$@)]) + + +# 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. +m4_define([AT_BISON_CHECK_WARNINGS], +[m4_if(m4_bregexp([$4], [: warning: ]), [-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 -z "${POSIXLY_CORRECT+set}"; then @@ -421,8 +474,7 @@ m4_if(m4_bregexp([$4], [: warning: ]), [-1], [], ]AT_DATA([expout], [$3])[ # Run with -Werror. - ]AT_CHECK(AT_QUELL_VALGRIND[[ bison ]$1[ -Werror]], - [[1]], [expout], [stderr])[ + ]AT_BISON_CHECK_([$1[ -Werror]], [[1]], [expout], [stderr])[ # Build expected stderr up to and including the "warnings being # treated as errors" message. @@ -456,22 +508,27 @@ m4_if(m4_bregexp([$4], [: warning: ]), [-1], [], # Now check --warnings=error. cp stderr experr - ]AT_CHECK(AT_QUELL_VALGRIND[[ bison ]$1[ --warnings=error]], - [[1]], [expout], [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. - ]AT_CHECK(AT_QUELL_VALGRIND[[ bison ]$1[ -Wnone -Werror]], - [[0]], [expout])[ - ]AT_CHECK(AT_QUELL_VALGRIND[[ bison ]$1[ --warnings=none \ - -Werror]], [[0]], [expout])[ + ]AT_BISON_CHECK_([$1[ -Wnone -Werror]], [[0]], [expout])[ + ]AT_BISON_CHECK_([$1[ --warnings=none -Werror]], [[0]], [expout])[ ]AT_RESTORE_SPECIAL_FILES[ - fi - ]]) +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(m4_null_if([$2], [], [AT_QUELL_VALGRIND ])[[bison ]]$@) +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 @@ -488,10 +545,10 @@ m4_define([AT_BISON_CHECK_XML], [--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 \ + AT_BISON_CHECK_([[--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, + 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] @@ -520,6 +577,8 @@ m4_define([AT_BISON_CHECK_XML], m4_define([AT_QUELL_VALGRIND], [[[VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS;]]]) + + ## ------------------------ ## ## Compiling C, C++ Files. ## ## ------------------------ ## @@ -527,22 +586,38 @@ m4_define([AT_QUELL_VALGRIND], # 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. +# 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_CHECK([$CC $CFLAGS $CPPFLAGS m4_bmatch([$1], [[.]], [], [$LDFLAGS ])-o $1 m4_default([$2], [$1.c])[]m4_bmatch([$1], [[.]], [], [ $LIBS])], - 0, [ignore], [ignore])]) +[AT_CHECK(m4_join([ ], + [$CC $CFLAGS $CPPFLAGS], + [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]) -# -------------------------------------------- -# 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. +# --------------------------------------------- +# 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_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_CHECK(m4_join([ ], + [$CXX $CXXFLAGS $CPPFLAGS], + [m4_bmatch([$1], [[.]], [-c], [$LDFLAGS])], + [-o $1], + [m4_default([$2], [m4_bpatsubst([$1], [\.o$]).cc])], + [m4_bmatch([$1], [[.]], [], [$LIBS])]), + 0, [ignore], [ignore])]) # AT_JAVA_COMPILE(SOURCES) # ------------------------ @@ -550,12 +625,18 @@ AT_CHECK([$CXX $CXXFLAGS $CPPFLAGS m4_bmatch([$1], [[.]], [], [$LDFLAGS ])-o $1 # is not installed. m4_define([AT_JAVA_COMPILE], [AT_KEYWORDS(java) -AT_SKIP_IF([[test -z "$CONF_JAVA$CONF_JAVAC"]]) +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_COMPILE(OUTPUT, [SOURCES = OUTPUT.c] # -------------------------------------------- +# 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], [m4_case(AT_LANG, [c], [AT_COMPILE([$1], [$2])], @@ -576,23 +657,23 @@ m4_define([AT_FULL_COMPILE], [java], [AT_BISON_CHECK([-o $1.java $1.y]) AT_LANG_COMPILE([$1], - m4_join([ ], - [$1.java], - m4_ifval($2, [[$1-$2.java]]), + m4_join([ ], + [$1.java], + m4_ifval($2, [[$1-$2.java]]), m4_ifval($3, [[$1-$3.java]])))], [c++], [AT_BISON_CHECK([-o $1.cc $1.y]) AT_LANG_COMPILE([$1], - m4_join([ ], - [$1.cc], - m4_ifval($2, [[$1-$2.cc]]), + m4_join([ ], + [$1.cc], + m4_ifval($2, [[$1-$2.cc]]), m4_ifval($3, [[$1-$3.cc]])))], [c], [AT_BISON_CHECK([-o $1.c $1.y]) AT_LANG_COMPILE([$1], - m4_join([ ], - [$1.c], - m4_ifval($2, [[$1-$2.c]]), + m4_join([ ], + [$1.c], + m4_ifval($2, [[$1-$2.c]]), m4_ifval($3, [[$1-$3.c]])))]) ])