tests: simplify AT_PARSER_CHECK usage

Currently the caller must specify the ./ prefix to its command. Let's avoid that: it will be nicer to read, make it easier to have a version that works for Java and C/C++. * tests/local.at (AT_PARSER_CHECK): Prefix the command with ./. Adjust callers.
2026-03-09 20:33:03 +00:00 · 2019-02-20 17:37:46 +01:00
parent 4848092bf8
commit a11c144609
15 changed files with 129 additions and 129 deletions
--- a/tests/actions.at
+++ b/tests/actions.at
@@ -58,7 +58,7 @@ AT_BISON_OPTION_POPDEFS

 AT_BISON_CHECK([-d -v -o input.c input.y])
 AT_COMPILE([input])
-AT_PARSER_CHECK([./input], 0,
+AT_PARSER_CHECK([input], 0,
 [[0123456789
 ]])

@@ -107,7 +107,7 @@ AT_BISON_OPTION_POPDEFS

 AT_BISON_CHECK([-d -v -o input.c input.y])
 AT_COMPILE([input])
-AT_PARSER_CHECK([./input], 0,
+AT_PARSER_CHECK([input], 0,
 [[66
 ]])

@@ -254,7 +254,7 @@ exp: %empty {}
 ]])

 AT_FULL_COMPILE([input])
-AT_PARSER_CHECK([./input])
+AT_PARSER_CHECK([input])
 AT_BISON_OPTION_POPDEFS
 AT_CLEANUP

@@ -309,7 +309,7 @@ main (void)
 ]])

 AT_FULL_COMPILE([input])
-AT_PARSER_CHECK([./input], 1, [],
+AT_PARSER_CHECK([input], 1, [],
 [m4_default([$4], [1.1])
 m4_default([$4], [1.1])[: syntax error
 ]])
@@ -416,7 +416,7 @@ main (void)
 ]])

 AT_FULL_COMPILE([input])
-AT_PARSER_CHECK([./input], 0,
+AT_PARSER_CHECK([input], 0,
 [[1.1
 2.1-9
 3.1-4.0
@@ -485,7 +485,7 @@ sum_of_the_five_previous_values:

 AT_BISON_CHECK([-d -v -o input.c input.y], 0)
 AT_COMPILE([input])
-AT_PARSER_CHECK([./input], 0,
+AT_PARSER_CHECK([input], 0,
 [[15
 ]])

@@ -514,7 +514,7 @@ sum: { printf ("%d\n", $0.val + $-1.val + $-2.val); } ;
 ]])

 AT_FULL_COMPILE([input])
-AT_PARSER_CHECK([[./input]], [[0]],
+AT_PARSER_CHECK([[input]], [[0]],
 [[6
 ]])

@@ -774,7 +774,7 @@ AT_FULL_COMPILE([input])
 # I.e., epsilon-reductions, as in "(x)" which ends by reducing
 # an empty "line" nterm.
 # FIXME: This location is not satisfying.  Depend on the lookahead?
-AT_PARSER_CHECK([./input '(x)'], 0, [],
+AT_PARSER_CHECK([input '(x)'], 0, [],
 [[sending: '(' (0@0-9)
 sending: 'x' (1@10-19)
 thing (1@10-19): 'x' (1@10-19)
@@ -795,7 +795,7 @@ Successful parse.
 # ends where starts the next token: END@10-19.
 #
 # So error recovery reports error@9-19.
-AT_PARSER_CHECK([./input '!'], 0, [],
+AT_PARSER_CHECK([input '!'], 0, [],
 [[sending: '!' (0@0-9)
 sending: END (1@10-19)
 raise (4@9-9): %empty
@@ -809,7 +809,7 @@ Successful parse.
 # -----------------------------------------------------------
 # This time the error is raised from a rule with 2 rhs symbols: @10-29.
 # It is recovered @10-29.
-AT_PARSER_CHECK([[./input '!!!']], 0, [],
+AT_PARSER_CHECK([[input '!!!']], 0, [],
 [[sending: '!' (0@0-9)
 sending: '!' (1@10-19)
 sending: '!' (2@20-29)
@@ -825,7 +825,7 @@ Successful parse.
 # ---------------------------------
 # '(y)' is an error, but can be recovered from.  But what's the location
 # of the error itself ('y'), and of the resulting reduction ('(error)').
-AT_PARSER_CHECK([./input '(y)'], 0, [],
+AT_PARSER_CHECK([input '(y)'], 0, [],
 [[sending: '(' (0@0-9)
 sending: 'y' (1@10-19)
 10.10-19.18: syntax error, unexpected 'y', expecting 'x'
@@ -855,7 +855,7 @@ Successful parse.
 #     '(', 'x', ')',
 #     '(', 'x', ')',
 #     'y'
-AT_PARSER_CHECK([./input '(xxxxx)(x)(x)y'], 1, [],
+AT_PARSER_CHECK([input '(xxxxx)(x)(x)y'], 1, [],
 [[sending: '(' (0@0-9)
 sending: 'x' (1@10-19)
 thing (1@10-19): 'x' (1@10-19)
@@ -903,7 +903,7 @@ Parsing FAILED.
 #     '(', 'x', ')',
 #     '(', 'x', ')',
 #     'x'
-AT_PARSER_CHECK([./input '(x)(x)x'], 1, [],
+AT_PARSER_CHECK([input '(x)(x)x'], 1, [],
 [[sending: '(' (0@0-9)
 sending: 'x' (1@10-19)
 thing (1@10-19): 'x' (1@10-19)
@@ -931,7 +931,7 @@ Parsing FAILED.
 # Upon stack overflow, all symbols on the stack should be destroyed.
 # Only check for yacc.c.
 AT_YACC_IF([
-AT_PARSER_CHECK([./input '(x)(x)(x)(x)(x)(x)(x)'], 2, [],
+AT_PARSER_CHECK([input '(x)(x)(x)(x)(x)(x)(x)'], 2, [],
 [[sending: '(' (0@0-9)
 sending: 'x' (1@10-19)
 thing (1@10-19): 'x' (1@10-19)
@@ -1070,7 +1070,7 @@ AT_BISON_CHECK([-o input.c input.y], [], [],
 input.y:30.3-5: warning: useless %printer for type <*> [-Wother]
 ]])
 AT_COMPILE([input])
-AT_PARSER_CHECK([./input --debug], 1,
+AT_PARSER_CHECK([input --debug], 1,
 [[<> destructor for 'd' @ 4.
 'b'/'c' destructor for 'c' @ 3.
 'b'/'c' destructor for 'b' @ 2.
@@ -1177,7 +1177,7 @@ AT_BISON_CHECK([-o input.c input.y], [], [],
 input.y:22.3-4: warning: useless %printer for type <> [-Wother]
 ]])
 AT_COMPILE([input])
-AT_PARSER_CHECK([./input --debug], 1,
+AT_PARSER_CHECK([input --debug], 1,
 [[<*>/<field2>/e destructor.
 <*>/<field2>/e destructor.
 'd' destructor.
@@ -1307,7 +1307,7 @@ input1.y:30.3-4: warning: useless %printer for type <> [-Wother]

 AT_COMPILE([input$1])

-AT_PARSER_CHECK([./input$1 --debug], 0,
+AT_PARSER_CHECK([input$1 --debug], 0,
 [[<]]kind[[> for 'E' @ 1.
 <]]kind[[> for 'S' @ 1.
 ]],
@@ -1392,7 +1392,7 @@ AT_BISON_CHECK([-o input.c input.y], [], [],
 input.y:23.6-8: warning: useless %printer for type <*> [-Wother]
 ]])
 AT_COMPILE([input])
-AT_PARSER_CHECK([./input --debug], [1], [],
+AT_PARSER_CHECK([input --debug], [1], [],
 [[Starting parse
 Entering state 0
 Reading a token: Next token is token 'a' ('a')
@@ -1560,7 +1560,7 @@ input.y:32.3-23: warning: unused value: $3 [-Wother]
 ]])

 AT_COMPILE([input])
-AT_PARSER_CHECK([./input --debug], 1,,
+AT_PARSER_CHECK([input --debug], 1,,
 [[Starting parse
 Entering state 0
 Reducing stack by rule 1 (line 30):
@@ -1739,7 +1739,7 @@ float: UNTYPED INT
 ]])

 AT_FULL_COMPILE([[input]])
-AT_PARSER_CHECK([./input --debug], 0, [], [stderr])
+AT_PARSER_CHECK([input --debug], 0, [], [stderr])
 # Don't be too picky on the traces, GLR is not exactly the same.  Keep
 # only the lines from the printer.
 AT_CHECK([[sed -ne '/ival:/p' stderr]], 0,
@@ -1810,7 +1810,7 @@ accept: %empty {
 AT_BISON_OPTION_POPDEFS
 AT_BISON_CHECK([[-o input.c input.y]])
 AT_COMPILE([[input]])
-AT_PARSER_CHECK([[./input]], [[0]], [],
+AT_PARSER_CHECK([[input]], [[0]], [],
 [['b' destructor
 'a' destructor
 ]])
@@ -1858,7 +1858,7 @@ AT_BISON_OPTION_POPDEFS

 AT_BISON_CHECK([[-o input.c input.y]])
 AT_COMPILE([[input]])
-AT_PARSER_CHECK([[./input]], [[0]],
+AT_PARSER_CHECK([[input]], [[0]],
 [[a: 123
 a: 456
 ]])
--- a/tests/c++.at
+++ b/tests/c++.at
@@ -84,7 +84,7 @@ main (void)

 AT_FOR_EACH_CXX([
  AT_FULL_COMPILE([input])
-  AT_PARSER_CHECK([./input], 0)
+  AT_PARSER_CHECK([input], 0)
 ])
 AT_BISON_OPTION_POPDEFS
 AT_CLEANUP
@@ -220,7 +220,7 @@ int main()
 AT_BISON_CHECK([[-o list.cc list.yy]])
 AT_FOR_EACH_CXX([
  AT_COMPILE_CXX([list])
-  AT_PARSER_CHECK([./list])
+  AT_PARSER_CHECK([list])
 ])

 AT_BISON_OPTION_POPDEFS
@@ -491,7 +491,7 @@ else
 fi

 if AT_AUTOMOVE_IF([$modern], [false]); then
-  AT_PARSER_CHECK([./list], 0,
+  AT_PARSER_CHECK([list], 0,
 [[(0, 1, 2, 4, 6)
 ]],
 [[Destroy: ""
@@ -517,7 +517,7 @@ Destroy: ()
 Destroy: (0, 1, 2, 4, 6)
 ]])
 else
-  AT_PARSER_CHECK([./list], 0,
+  AT_PARSER_CHECK([list], 0,
 [[(0, 1, 2, 4, 6)
 ]],
 [[Destroy: "0"
@@ -645,7 +645,7 @@ int main()
 AT_FOR_EACH_CXX([
 AT_FULL_COMPILE([[input]])
 # This used to print "Discarding 'a'." again at the end.
-AT_PARSER_CHECK([[./input]], [[0]], [[]],
+AT_PARSER_CHECK([[input]], [[0]], [[]],
 [[Starting parse
 Entering state 0
 Reading a token: Next token is token NUMBER (1)
@@ -821,7 +821,7 @@ AT_BISON_CHECK([[-o input.cc input.yy]])
 m4_if([$#], [1],
 [AT_FOR_EACH_CXX([
  AT_COMPILE_CXX([[input]])
-  AT_PARSER_CHECK([[./input]])])])
+  AT_PARSER_CHECK([[input]])])])
 AT_BISON_OPTION_POPDEFS
 ])

@@ -921,7 +921,7 @@ yy::parser::error (const std::string &m)
 AT_FOR_EACH_CXX([
 AT_FULL_COMPILE([[input]])
 # This used to print "Discarding 'a'." again at the end.
-AT_PARSER_CHECK([[./input]], [[1]], [[]],
+AT_PARSER_CHECK([[input]], [[1]], [[]],
 [[syntax error
 Discarding 'a'.
 Reducing 'a'.
@@ -1016,7 +1016,7 @@ AT_FOR_EACH_CXX([
  # previous error, otherwise we might hide some error messages
  # (discarded during error recoevery).
  echo "asaaalaa" >in
-  AT_PARSER_CHECK([[./input < in]], [[0]], [[]],
+  AT_PARSER_CHECK([[input < in]], [[0]], [[]],
 [[error: invalid expression
 caught error
 error: invalid character
@@ -1024,12 +1024,12 @@ caught error
 ]])

  echo "!as" >in
-  AT_PARSER_CHECK([[./input < in]], [1], [],
+  AT_PARSER_CHECK([[input < in]], [1], [],
 [[error: invalid expression
 ]])

  echo "!al" >in
-  AT_PARSER_CHECK([[./input < in]], [1], [],
+  AT_PARSER_CHECK([[input < in]], [1], [],
 [[error: invalid character
 ]])

@@ -1299,34 +1299,34 @@ AT_BISON_CHECK([[-o input.cc --report=all input.yy]])
 AT_FOR_EACH_CXX([
 AT_COMPILE_CXX([[input]])

-AT_PARSER_CHECK([[./input aaaas]], [[2]], [[]],
+AT_PARSER_CHECK([[input aaaas]], [[2]], [[]],
 [[exception caught: reduction
 ]])

-AT_PARSER_CHECK([[./input aaaal]], [[2]], [[]],
+AT_PARSER_CHECK([[input aaaal]], [[2]], [[]],
 [[exception caught: yylex
 ]])

-AT_PARSER_CHECK([[./input i]], [[2]], [[]],
+AT_PARSER_CHECK([[input i]], [[2]], [[]],
 [[exception caught: initial-action
 ]])

-AT_PARSER_CHECK([[./input aaaap]])
+AT_PARSER_CHECK([[input aaaap]])

-AT_PARSER_CHECK([[./input --debug aaaap]], [[2]], [[]], [[stderr]])
+AT_PARSER_CHECK([[input --debug aaaap]], [[2]], [[]], [[stderr]])
 AT_CHECK([[grep '^exception caught: printer$' stderr]], [], [ignore])

-AT_PARSER_CHECK([[./input aaaae]], [[2]], [[]],
+AT_PARSER_CHECK([[input aaaae]], [[2]], [[]],
 [[exception caught: syntax error
 ]])

-AT_PARSER_CHECK([[./input aaaaE]], [[2]], [[]],
+AT_PARSER_CHECK([[input aaaaE]], [[2]], [[]],
 [[exception caught: syntax error, unexpected $end, expecting 'a'
 ]])

-AT_PARSER_CHECK([[./input aaaaT]], [[1]])
+AT_PARSER_CHECK([[input aaaaT]], [[1]])

-AT_PARSER_CHECK([[./input aaaaR]], [m4_if([$2], [with], [0], [1])])
+AT_PARSER_CHECK([[input aaaaR]], [m4_if([$2], [with], [0], [1])])
 ])

 AT_BISON_OPTION_POPDEFS
@@ -1476,6 +1476,6 @@ main (void)


 AT_COMPILE_CXX([parser], [[x[12].o main.cc]], [-Iinclude])
-AT_PARSER_CHECK([./parser], [0])
+AT_PARSER_CHECK([parser], [0])

 AT_CLEANUP
--- a/tests/calc.at
+++ b/tests/calc.at
@@ -392,7 +392,7 @@ m4_define([_AT_CHECK_CALC],
 [AT_DATA([[input]],
 [[$2
 ]])
-AT_PARSER_CHECK([./calc input], 0, [], [stderr])
+AT_PARSER_CHECK([calc input], 0, [], [stderr])
 ])


@@ -419,11 +419,11 @@ AT_PARSER_CHECK([./calc input], 0, [], [stderr])
 # is the number of expected lines on stderr.
 m4_define([_AT_CHECK_CALC_ERROR],
 [m4_bmatch([$3], [^/],
-           [AT_PARSER_CHECK([./calc $3], $2, [], [stderr])],
+           [AT_PARSER_CHECK([calc $3], $2, [], [stderr])],
           [AT_DATA([[input]],
 [[$3
 ]])
-AT_PARSER_CHECK([./calc input], $2, [], [stderr])])
+AT_PARSER_CHECK([calc input], $2, [], [stderr])])

 # Normalize the observed and expected error messages, depending upon the
 # options.
--- a/tests/conflicts.at
+++ b/tests/conflicts.at
@@ -81,7 +81,7 @@ int main (void)
 AT_BISON_CHECK([-o input.c input.y])
 AT_COMPILE([input])

-AT_PARSER_CHECK([./input])
+AT_PARSER_CHECK([input])

 AT_BISON_OPTION_POPDEFS

@@ -347,17 +347,17 @@ AT_COMPILE([input])

 m4_pushdef([AT_EXPECTING], [m4_if($2, [correct], [[, expecting $end]])])

-AT_PARSER_CHECK([./input '0<0'])
-AT_PARSER_CHECK([./input '0<0<0'], [1], [],
+AT_PARSER_CHECK([input '0<0'])
+AT_PARSER_CHECK([input '0<0<0'], [1], [],
         [syntax error, unexpected '<'AT_EXPECTING
 ])

-AT_PARSER_CHECK([./input '0>0'])
-AT_PARSER_CHECK([./input '0>0>0'], [1], [],
+AT_PARSER_CHECK([input '0>0'])
+AT_PARSER_CHECK([input '0>0>0'], [1], [],
         [syntax error, unexpected '>'AT_EXPECTING
 ])

-AT_PARSER_CHECK([./input '0<0>0'], [1], [],
+AT_PARSER_CHECK([input '0<0>0'], [1], [],
         [syntax error, unexpected '>'AT_EXPECTING
 ])

@@ -461,11 +461,11 @@ m4_pushdef([AT_EXPECTING], [m4_if($5, [ab], [[, expecting 'a' or 'b']],
                                  $5, [a],  [[, expecting 'a']],
                                  $5, [b],  [[, expecting 'b']])])

-AT_JAVA_IF([AT_JAVA_PARSER_CHECK([[input]], [[0]]],
-           [AT_PARSER_CHECK([[./input]], [[1]]]),
+AT_JAVA_IF([AT_JAVA_PARSER_CHECK([[input]], [[0]])],
+           [AT_PARSER_CHECK([[input]], [[1]],
 [[]],
 [[syntax error, unexpected ]$4[]AT_EXPECTING[
-]])
+]])])

 m4_popdef([AT_EXPECTING])
 AT_BISON_OPTION_POPDEFS
@@ -714,7 +714,7 @@ AT_BISON_CHECK([[-Dlr.type=canonical-lr -o input.c input.y]],
 [[input.y: warning: 2 shift/reduce conflicts [-Wconflicts-sr]
 ]])
 AT_COMPILE([[input]])
-AT_PARSER_CHECK([[./input]], [[1]], [[]],
+AT_PARSER_CHECK([[input]], [[1]], [[]],
 [[syntax error, unexpected 'a', expecting 'b'
 ]])

@@ -724,7 +724,7 @@ AT_BISON_CHECK([[-Dlr.type=canonical-lr -Dparse.lac=full \
 [[input.y: warning: 2 shift/reduce conflicts [-Wconflicts-sr]
 ]])
 AT_COMPILE([[input]])
-AT_PARSER_CHECK([[./input]], [[1]], [[]],
+AT_PARSER_CHECK([[input]], [[1]], [[]],
 [[syntax error, unexpected 'a', expecting 'b' or 'c'
 ]])

@@ -734,7 +734,7 @@ AT_BISON_CHECK([[-Dlr.type=ielr -Dparse.lac=full -o input.c input.y]],
 [[input.y: warning: 2 shift/reduce conflicts [-Wconflicts-sr]
 ]])
 AT_COMPILE([[input]])
-AT_PARSER_CHECK([[./input]], [[1]], [[]],
+AT_PARSER_CHECK([[input]], [[1]], [[]],
 [[syntax error, unexpected 'a', expecting 'b' or 'c'
 ]])

--- a/tests/cxx-type.at
+++ b/tests/cxx-type.at
@@ -393,60 +393,60 @@ m4_define([_AT_VERBOSE_GLR_STDERR_WITH_LOC],
 AT_SETUP([GLR: Resolve ambiguity, impure, no locations])
 _AT_TEST_GLR_CXXTYPES([],
                      [%dprec 1], [%dprec 2])
-AT_PARSER_CHECK([[./types test-input]], 0,
+AT_PARSER_CHECK([[types test-input]], 0,
                [_AT_RESOLVED_GLR_OUTPUT], [_AT_GLR_STDERR])
 AT_CLEANUP

 AT_SETUP([GLR: Resolve ambiguity, impure, locations])
 _AT_TEST_GLR_CXXTYPES([%locations],[%dprec 1],[%dprec 2])
-AT_PARSER_CHECK([[./types test-input]], 0,
+AT_PARSER_CHECK([[types test-input]], 0,
                [_AT_RESOLVED_GLR_OUTPUT_WITH_LOC], [_AT_GLR_STDERR_WITH_LOC])
 AT_CLEANUP

 AT_SETUP([GLR: Resolve ambiguity, pure, no locations])
 _AT_TEST_GLR_CXXTYPES([%define api.pure],
                      [%dprec 1], [%dprec 2])
-AT_PARSER_CHECK([[./types test-input]], 0,
+AT_PARSER_CHECK([[types test-input]], 0,
                [_AT_RESOLVED_GLR_OUTPUT], [_AT_GLR_STDERR])
 AT_CLEANUP

 AT_SETUP([GLR: Resolve ambiguity, pure, locations])
 _AT_TEST_GLR_CXXTYPES([%define api.pure %locations],
                      [%dprec 1], [%dprec 2])
-AT_PARSER_CHECK([[./types test-input]], 0,
+AT_PARSER_CHECK([[types test-input]], 0,
                [_AT_RESOLVED_GLR_OUTPUT_WITH_LOC], [_AT_GLR_STDERR_WITH_LOC])
 AT_CLEANUP

 AT_SETUP([GLR: Merge conflicting parses, impure, no locations])
 _AT_TEST_GLR_CXXTYPES([],
                      [%merge <stmtMerge>], [%merge <stmtMerge>])
-AT_PARSER_CHECK([[./types test-input]], 0,
+AT_PARSER_CHECK([[types test-input]], 0,
                [_AT_AMBIG_GLR_OUTPUT], [_AT_GLR_STDERR])
 AT_CLEANUP

 AT_SETUP([GLR: Merge conflicting parses, impure, locations])
 _AT_TEST_GLR_CXXTYPES([%locations],
                      [%merge <stmtMerge>], [%merge <stmtMerge>])
-AT_PARSER_CHECK([[./types test-input]], 0,
+AT_PARSER_CHECK([[types test-input]], 0,
                [_AT_AMBIG_GLR_OUTPUT_WITH_LOC], [_AT_GLR_STDERR_WITH_LOC])
 AT_CLEANUP

 AT_SETUP([GLR: Merge conflicting parses, pure, no locations])
 _AT_TEST_GLR_CXXTYPES([%define api.pure],
                      [%merge <stmtMerge>], [%merge <stmtMerge>])
-AT_PARSER_CHECK([[./types test-input]], 0,
+AT_PARSER_CHECK([[types test-input]], 0,
                [_AT_AMBIG_GLR_OUTPUT], [_AT_GLR_STDERR])
 AT_CLEANUP
 AT_SETUP([GLR: Merge conflicting parses, pure, locations])
 _AT_TEST_GLR_CXXTYPES([%define api.pure %locations],
                      [%merge <stmtMerge>],[%merge <stmtMerge>])
-AT_PARSER_CHECK([[./types test-input]], 0,
+AT_PARSER_CHECK([[types test-input]], 0,
                [_AT_AMBIG_GLR_OUTPUT_WITH_LOC], [_AT_GLR_STDERR_WITH_LOC])
 AT_CLEANUP

 AT_SETUP([GLR: Verbose messages, resolve ambiguity, impure, no locations])
 _AT_TEST_GLR_CXXTYPES([%define parse.error verbose],
                      [%merge <stmtMerge>], [%merge <stmtMerge>])
-AT_PARSER_CHECK([[./types test-input]], 0,
+AT_PARSER_CHECK([[types test-input]], 0,
                [_AT_AMBIG_GLR_OUTPUT], [_AT_VERBOSE_GLR_STDERR])
 AT_CLEANUP
--- a/tests/glr-regression.at
+++ b/tests/glr-regression.at
@@ -91,7 +91,7 @@ AT_BISON_CHECK([[-o glr-regr1.c -rall glr-regr1.y]], 0, [],
 [[glr-regr1.y: warning: 1 shift/reduce conflict [-Wconflicts-sr]
 ]])
 AT_COMPILE([glr-regr1])
-AT_PARSER_CHECK([[./glr-regr1 BPBPB]], 0,
+AT_PARSER_CHECK([[glr-regr1 BPBPB]], 0,
 [[E -> 'B'
 E -> 'B'
 E -> E 'P' E
@@ -215,14 +215,14 @@ AT_COMPILE([glr-regr2a])
 AT_DATA([input1.txt],
 [[s VARIABLE_1 t v x q
 ]])
-AT_PARSER_CHECK([[./glr-regr2a input1.txt]], 0,
+AT_PARSER_CHECK([[glr-regr2a input1.txt]], 0,
 [[Variable: 'VARIABLE_1'
 ]])

 AT_DATA([input2.txt],
 [[s VARIABLE_1 , ANOTHER_VARIABLE_2 t e
 ]])
-AT_PARSER_CHECK([[./glr-regr2a input2.txt]],
+AT_PARSER_CHECK([[glr-regr2a input2.txt]],
 0,
 [[Varlist: 'VARIABLE_1,ANOTHER_VARIABLE_2'
 ]])
@@ -230,7 +230,7 @@ AT_PARSER_CHECK([[./glr-regr2a input2.txt]],
 AT_DATA([input3.txt],
 [[s VARIABLE_3 t v x
 ]])
-AT_PARSER_CHECK([[./glr-regr2a input3.txt]], 0,
+AT_PARSER_CHECK([[glr-regr2a input3.txt]], 0,
 [[Variable: 'VARIABLE_3'
 ]])

@@ -349,7 +349,7 @@ AT_COMPILE([glr-regr3])
 AT_DATA([input.txt],
 [[p1 t4 o2 p1 p1 t1 o1 t2 p2 o1 t3 p2 p2
 ]])
-AT_PARSER_CHECK([[./glr-regr3 input.txt]],
+AT_PARSER_CHECK([[glr-regr3 input.txt]],
 0,
 [[Result: 1c04
 ]])
@@ -441,7 +441,7 @@ AT_BISON_CHECK([[-o glr-regr4.c -rall glr-regr4.y]], 0, [],
 ]])
 AT_COMPILE([glr-regr4])

-AT_PARSER_CHECK([[./glr-regr4]], 0,
+AT_PARSER_CHECK([[glr-regr4]], 0,
 [[merge{ S <- merge{ A <- A1 <- 'a' and A <- A2 <- 'a' } and S <- B <- 'a' }
 ]], [])

@@ -497,7 +497,7 @@ AT_BISON_CHECK([[-o glr-regr5.c -rall glr-regr5.y]], 0, [],
 ]])
 AT_COMPILE([glr-regr5])

-AT_PARSER_CHECK([[./glr-regr5]], 1, [],
+AT_PARSER_CHECK([[glr-regr5]], 1, [],
 [syntax is ambiguous
 ])

@@ -545,7 +545,7 @@ AT_BISON_CHECK([[-o glr-regr6.c -rall glr-regr6.y]], 0, [],
 ]])
 AT_COMPILE([glr-regr6])

-AT_PARSER_CHECK([[./glr-regr6]], 1,
+AT_PARSER_CHECK([[glr-regr6]], 1,
 [Destructor called.
 ],
 [syntax is ambiguous
@@ -634,7 +634,7 @@ AT_BISON_CHECK([[-o glr-regr7.c -rall glr-regr7.y]], 0, [],
 ]])
 AT_COMPILE([glr-regr7])

-AT_PARSER_CHECK([[./glr-regr7]], 2, [],
+AT_PARSER_CHECK([[glr-regr7]], 2, [],
 [memory exhausted
 ])

@@ -723,7 +723,7 @@ AT_BISON_CHECK([[-o glr-regr8.c -rall glr-regr8.y]], 0, [],
 ]])
 AT_COMPILE([glr-regr8])

-AT_PARSER_CHECK([[./glr-regr8]], 0,
+AT_PARSER_CHECK([[glr-regr8]], 0,
 [empty: 9/9
 1/9 - 9/9 - 13/17
 ],
@@ -803,7 +803,7 @@ AT_BISON_CHECK([[-o glr-regr9.c -rall glr-regr9.y]], 0, [],
 ]])
 AT_COMPILE([glr-regr9])

-AT_PARSER_CHECK([[./glr-regr9]], 0, [],
+AT_PARSER_CHECK([[glr-regr9]], 0, [],
 [memory exhausted
 ])

@@ -859,7 +859,7 @@ AT_BISON_CHECK([[-o glr-regr10.c -rall glr-regr10.y]], 0, [],
 ]])
 AT_COMPILE([glr-regr10])

-AT_PARSER_CHECK([[./glr-regr10]], 0, [], [])
+AT_PARSER_CHECK([[glr-regr10]], 0, [], [])

 AT_CLEANUP

@@ -917,7 +917,7 @@ AT_BISON_CHECK([[-o glr-regr11.c -rall glr-regr11.y]], 0, [],
 ]])
 AT_COMPILE([glr-regr11])

-AT_PARSER_CHECK([[./glr-regr11]], 0, [], [])
+AT_PARSER_CHECK([[glr-regr11]], 0, [], [])

 AT_CLEANUP

@@ -1038,7 +1038,7 @@ glr-regr12.y: warning: 1 reduce/reduce conflict [-Wconflicts-rr]
 ]])
 AT_COMPILE([glr-regr12])

-AT_PARSER_CHECK([[./glr-regr12]], 0, [], [])
+AT_PARSER_CHECK([[glr-regr12]], 0, [], [])

 AT_CLEANUP

@@ -1153,7 +1153,7 @@ AT_BISON_OPTION_POPDEFS
 AT_BISON_CHECK([[-o glr-regr13.c -rall glr-regr13.y]], 0, [], [])
 AT_COMPILE([glr-regr13])

-AT_PARSER_CHECK([[./glr-regr13]], 0,
+AT_PARSER_CHECK([[glr-regr13]], 0,
 [defstate_init <- empty string:
  yychar=YYEMPTY
 nondefstate <- empty string:
@@ -1367,7 +1367,7 @@ AT_BISON_CHECK([[-o glr-regr14.c -rall glr-regr14.y]], 0, [],
 ]])
 AT_COMPILE([glr-regr14])

-AT_PARSER_CHECK([[./glr-regr14]], 0,
+AT_PARSER_CHECK([[glr-regr14]], 0,
 [conflict <- empty string:
  yychar='a', yylval='A', yylloc=(1,1),(1,1)
 defstate_look <- empty string:
@@ -1460,7 +1460,7 @@ AT_BISON_CHECK([[-o glr-regr15.c -rall glr-regr15.y]], 0, [],
 ]])
 AT_COMPILE([glr-regr15])

-AT_PARSER_CHECK([[./glr-regr15]], 0, [],
+AT_PARSER_CHECK([[glr-regr15]], 0, [],
 [syntax is ambiguous
 ])

@@ -1520,7 +1520,7 @@ AT_BISON_CHECK([[-o glr-regr16.c -rall glr-regr16.y]], 0, [],
 ]])
 AT_COMPILE([glr-regr16])

-AT_PARSER_CHECK([[./glr-regr16]], 0, [],
+AT_PARSER_CHECK([[glr-regr16]], 0, [],
 [syntax error
 ])

@@ -1594,7 +1594,7 @@ AT_BISON_CHECK([[-o glr-regr17.c -rall glr-regr17.y]], 0, [],
 ]])
 AT_COMPILE([glr-regr17])

-AT_PARSER_CHECK([[./glr-regr17]], 1, [],
+AT_PARSER_CHECK([[glr-regr17]], 1, [],
 [1.1-2.2: syntax is ambiguous
 ])

@@ -1688,7 +1688,7 @@ AT_BISON_CHECK([[-o input.c input.y]], 0, [],
 ]])
 AT_COMPILE([input])

-AT_PARSER_CHECK([[./input --debug]], 1, [],
+AT_PARSER_CHECK([[input --debug]], 1, [],
 [Starting parse
 Entering state 0
 Reading a token: Next token is token 'a' ()
@@ -1802,11 +1802,11 @@ main (int argc, const char* argv[])

 AT_BISON_CHECK([[-o input.c input.y]])
 AT_COMPILE([input])
-AT_PARSER_CHECK([[./input Nwin]], [0], [new])
-AT_PARSER_CHECK([[./input Owin]], [1], [], [[syntax error, unexpected 'n', expecting 'o'
+AT_PARSER_CHECK([[input Nwin]], [0], [new])
+AT_PARSER_CHECK([[input Owin]], [1], [], [[syntax error, unexpected 'n', expecting 'o'
 ]])
-AT_PARSER_CHECK([[./input Owio]], [0], [old])
-AT_PARSER_CHECK([[./input Nwio]], [1], [], [[syntax error, unexpected 'o', expecting 'n'
+AT_PARSER_CHECK([[input Owio]], [0], [old])
+AT_PARSER_CHECK([[input Nwio]], [1], [], [[syntax error, unexpected 'o', expecting 'n'
 ]])

 AT_CLEANUP
--- a/tests/headers.at
+++ b/tests/headers.at
@@ -104,7 +104,7 @@ int my_parse (void);
 AT_COMPILE([caller.o])
 AT_COMPILE([input.o])
 AT_COMPILE([caller], [caller.o input.o])
-AT_PARSER_CHECK([./caller])
+AT_PARSER_CHECK([caller])
 AT_BISON_OPTION_POPDEFS
 AT_CLEANUP

@@ -352,7 +352,7 @@ AT_CHECK([[$PERL -n -0777 -e '
 AT_SKIP_IF_CANNOT_LINK_C_AND_CXX

 AT_COMPILE_CXX([parser], [[x[1-9].o -DCC_IS_CXX=$CC_IS_CXX main.cc]])
-AT_PARSER_CHECK([./parser], [0], [[expout]])
+AT_PARSER_CHECK([parser], [0], [[expout]])

 m4_popdef([AT_TEST])

--- a/tests/input.at
+++ b/tests/input.at
@@ -1299,7 +1299,7 @@ AT_BISON_CHECK([-d -v -o input.c input.y])
 AT_COMPILE([input.o])
 AT_COMPILE([main.o])
 AT_COMPILE([input], [input.o main.o])
-AT_PARSER_CHECK([./input], 0,
+AT_PARSER_CHECK([input], 0,
 [[[@<:@],
 ]])

@@ -1725,7 +1725,7 @@ int main (void)
 }
 ]])
 AT_FULL_COMPILE([input])
-AT_PARSER_CHECK([./input])
+AT_PARSER_CHECK([input])

 AT_BISON_OPTION_POPDEFS
 AT_CLEANUP
--- a/tests/local.at
+++ b/tests/local.at
@@ -1020,7 +1020,7 @@ AT_COMPILE([c-only.o], [c-only.c])
 AT_COMPILE_CXX([cxx-only.o], [cxx-only.cc])
 AT_CHECK([$CXX $CXXFLAGS $CPPFLAGS $LDFLAGS c-only.o cxx-only.o -o c-and-cxx ||
          exit 77], [0], [ignore], [ignore])
-AT_PARSER_CHECK([./c-and-cxx])
+AT_PARSER_CHECK([c-and-cxx])
 ])


@@ -1111,7 +1111,7 @@ AT_CHECK([@&t@./exception || exit 77], [0], [], [ignore])
 # Get rid of spurious messages when compiled with --coverage:
 # +profiling:/[...]/lib/fprintf.gcda:Merge mismatch for summaries
 m4_define([AT_PARSER_CHECK],
-[AT_CHECK([$5 $PREPARSER $1], [$2], [$3], [stderr])
+[AT_CHECK([$5 $PREPARSER ./$1], [$2], [$3], [stderr])
 AT_CHECK([sed >&2 -e '/^profiling:.*:Merge mismatch for summaries/d' stderr],
         [0], [], [$4])
 ])
@@ -1263,7 +1263,7 @@ m4_bmatch([$4], [%define lr.type canonical-lr],
 fi])
 AT_COMPILE([[input]])

-AT_PARSER_CHECK([[./input]],
+AT_PARSER_CHECK([[input]],
                m4_ifval([$10], [m4_dquote($10)]),
                m4_ifval([$11], [m4_dquote($11)]),
                m4_ifval([$12], [m4_dquote($12)]))
--- a/tests/named-refs.at
+++ b/tests/named-refs.at
@@ -182,7 +182,7 @@ AT_DATA([input.txt],
 ]])

 AT_FULL_COMPILE([[test]])
-AT_PARSER_CHECK([./test input.txt], 0, [], [stderr])
+AT_PARSER_CHECK([test input.txt], 0, [], [stderr])
 AT_BISON_OPTION_POPDEFS
 AT_CLEANUP

--- a/tests/push.at
+++ b/tests/push.at
@@ -73,7 +73,7 @@ AT_BISON_OPTION_POPDEFS

 AT_BISON_CHECK([[-o input.c input.y]])
 AT_COMPILE([[input]])
-AT_PARSER_CHECK([[./input]])
+AT_PARSER_CHECK([[input]])

 AT_CLEANUP

@@ -127,7 +127,7 @@ main (void)

 AT_BISON_CHECK([[-o input.c input.y]])
 AT_COMPILE([[input]])
-AT_PARSER_CHECK([[./input]])
+AT_PARSER_CHECK([[input]])
 AT_BISON_OPTION_POPDEFS
 ])

--- a/tests/regression.at
+++ b/tests/regression.at
@@ -471,7 +471,7 @@ AT_COMPILE([input])
 AT_DATA([experr],
 [[syntax error, unexpected "\\'?\"\a\b\f\n\r\t\v\001\201\001\201??!", expecting a
 ]])
-AT_PARSER_CHECK([./input], 1, [], [experr])
+AT_PARSER_CHECK([input], 1, [], [experr])
 AT_CLEANUP


@@ -877,7 +877,7 @@ m4_define([AT_CHECK_DANCER],
 AT_BISON_OPTION_PUSHDEFS([$1])
 _AT_DATA_DANCER_Y([$1])
 AT_FULL_COMPILE([dancer])
-AT_PARSER_CHECK([./dancer], 1, [],
+AT_PARSER_CHECK([dancer], 1, [],
 [syntax error, unexpected ':'
 ])
 AT_BISON_OPTION_POPDEFS
@@ -954,7 +954,7 @@ m4_define([AT_CHECK_EXPECT2],
 AT_BISON_OPTION_PUSHDEFS([$1])
 _AT_DATA_EXPECT2_Y([$1])
 AT_FULL_COMPILE([expect2])
-AT_PARSER_CHECK([./expect2], 1, [],
+AT_PARSER_CHECK([expect2], 1, [],
 [syntax error, unexpected '+', expecting A or B
 ])
 AT_BISON_OPTION_POPDEFS
@@ -1004,7 +1004,7 @@ AT_BISON_OPTION_POPDEFS

 AT_BISON_CHECK([-o input.c input.y])
 AT_COMPILE([input])
-AT_PARSER_CHECK([./input --debug], 1,
+AT_PARSER_CHECK([input --debug], 1,
 [[Bison would once convert this action to a midrule because of the subsequent braced code.
 ]],
 [[Starting parse
@@ -1133,7 +1133,7 @@ input.y:28.5-19: warning: rule useless in parser due to conflicts [-Wother]
 input.y:18.1-5: warning: useless precedence and associativity for TK1 [-Wprecedence]
 ]])
 AT_COMPILE([[input]])
-AT_PARSER_CHECK([[./input]])
+AT_PARSER_CHECK([[input]])
 AT_BISON_OPTION_POPDEFS

 AT_CLEANUP
@@ -1222,7 +1222,7 @@ AT_BISON_OPTION_POPDEFS

 AT_BISON_CHECK([[-o input.c input.y]])
 AT_COMPILE([[input]])
-AT_PARSER_CHECK([[./input]], [[1]], [],
+AT_PARSER_CHECK([[input]], [[1]], [],
 [[syntax error, unexpected 'a', expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B
 syntax error, unexpected $end, expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B
 ]])
@@ -1339,7 +1339,7 @@ AT_BISON_CHECK([[-o input.c input.y]])
 [CFLAGS="$NO_WERROR_CFLAGS"]
 AT_COMPILE([[input]])

-AT_PARSER_CHECK([[./input]], [[2]], [],
+AT_PARSER_CHECK([[input]], [[2]], [],
 [[syntax error, unexpected 'a', expecting 123456789112345678921234567893123456789412345678951234567896123A or 123456789112345678921234567893123456789412345678951234567896123B or 123456789112345678921234567893123456789412345678951234567896123C
 syntax error
 memory exhausted
@@ -1400,7 +1400,7 @@ AT_BISON_CHECK([[-Dparse.lac=full -Dparse.lac.es-capacity-initial=1 \
 [[input.y: warning: 21 shift/reduce conflicts [-Wconflicts-sr]
 ]])
 AT_COMPILE([[input]])
-AT_PARSER_CHECK([[./input --debug > stdout.txt 2> stderr.txt]], [[1]])
+AT_PARSER_CHECK([[input --debug > stdout.txt 2> stderr.txt]], [[1]])

 # Make sure syntax error doesn't forget that 'a' is expected.  It would
 # be forgotten without lookahead correction.
@@ -1475,7 +1475,7 @@ AT_BISON_OPTION_POPDEFS

 # Check for memory exhaustion during parsing.
 AT_LAC_CHECK([])
-AT_PARSER_CHECK([[./input --debug]], [[2]], [],
+AT_PARSER_CHECK([[input --debug]], [[2]], [],
 [[Starting parse
 Entering state 0
 Reading a token: Now at end of input.
@@ -1489,7 +1489,7 @@ Stack now 0
 # Induce an immediate syntax error with an undefined token, and check
 # for memory exhaustion while building syntax error message.
 AT_LAC_CHECK([z], [[0]])
-AT_PARSER_CHECK([[./input --debug]], [[2]], [],
+AT_PARSER_CHECK([[input --debug]], [[2]], [],
 [[Starting parse
 Entering state 0
 Reading a token: Next token is token $undefined ()
@@ -1563,7 +1563,7 @@ main (void)
 ]])

 AT_FULL_COMPILE([input])
-AT_PARSER_CHECK([./input], 0, [[x: 1, y: 2
+AT_PARSER_CHECK([input], 0, [[x: 1, y: 2
 ]])
 AT_BISON_OPTION_POPDEFS

--- a/tests/skeletons.at
+++ b/tests/skeletons.at
@@ -119,13 +119,13 @@ AT_GRAM])

 AT_BISON_CHECK([[--skeleton=yacc.c -o input-cmd-line.c input-cmd-line.y]])
 AT_COMPILE([[input-cmd-line]])
-AT_PARSER_CHECK([[./input-cmd-line]], [[1]], [],
+AT_PARSER_CHECK([[input-cmd-line]], [[1]], [],
 [[syntax error, unexpected 'a', expecting $end
 ]])

 AT_BISON_CHECK([[-o input-gram.c input-gram.y]])
 AT_COMPILE([[input-gram]])
-AT_PARSER_CHECK([[./input-gram]], [[1]], [],
+AT_PARSER_CHECK([[input-gram]], [[1]], [],
 [[syntax error, unexpected 'a', expecting $end
 ]])

--- a/tests/torture.at
+++ b/tests/torture.at
@@ -138,7 +138,7 @@ AT_SETUP([Big triangle])
 AT_DATA_TRIANGULAR_GRAMMAR([input.y], [200])
 AT_BISON_CHECK_NO_XML([-v -o input.c input.y])
 AT_COMPILE([input])
-AT_PARSER_CHECK([./input])
+AT_PARSER_CHECK([input])

 AT_CLEANUP

@@ -235,7 +235,7 @@ AT_INCREASE_DATA_SIZE(204000)

 AT_BISON_CHECK_NO_XML([-v -o input.c input.y])
 AT_COMPILE([input])
-AT_PARSER_CHECK([./input])
+AT_PARSER_CHECK([input])

 AT_CLEANUP

@@ -355,7 +355,7 @@ AT_INCREASE_DATA_SIZE(204000)

 AT_BISON_CHECK([-v -o input.c input.y])
 AT_COMPILE([input])
-AT_PARSER_CHECK([./input])
+AT_PARSER_CHECK([input])

 AT_CLEANUP

@@ -459,14 +459,14 @@ m4_pushdef([AT_USE_ALLOCA], [[
 AT_DATA_STACK_TORTURE([AT_USE_ALLOCA])

 # Below the limit of 200.
-AT_PARSER_CHECK([./input 20], 0, [], [ignore],
+AT_PARSER_CHECK([input 20], 0, [], [ignore],
                [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
 # Two enlargements: 2 * 2 * 200.
-AT_PARSER_CHECK([./input 900], 0, [], [ignore],
+AT_PARSER_CHECK([input 900], 0, [], [ignore],
                [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
 # Fails: beyond the limit of 10,000 (which we don't reach anyway since we
 # multiply by two starting at 200 => 5120 is the last possible).
-AT_PARSER_CHECK([./input 10000], 2, [], [ignore],
+AT_PARSER_CHECK([input 10000], 2, [], [ignore],
                [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])

 # The push parser can't use alloca since the stacks can't be locals.  This test
@@ -475,11 +475,11 @@ AT_PARSER_CHECK([./input 10000], 2, [], [ignore],
 AT_DATA_STACK_TORTURE([AT_USE_ALLOCA],
 [[%define api.push-pull both
 ]])
-AT_PARSER_CHECK([./input 20], 0, [], [ignore],
+AT_PARSER_CHECK([input 20], 0, [], [ignore],
                [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
-AT_PARSER_CHECK([./input 900], 0, [], [ignore],
+AT_PARSER_CHECK([input 900], 0, [], [ignore],
                [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
-AT_PARSER_CHECK([./input 10000], 2, [], [ignore],
+AT_PARSER_CHECK([input 10000], 2, [], [ignore],
                [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])

 m4_popdef([AT_USE_ALLOCA])
@@ -500,24 +500,24 @@ m4_pushdef([AT_USE_ALLOCA], [[#define YYSTACK_USE_ALLOCA 0]])
 AT_DATA_STACK_TORTURE([AT_USE_ALLOCA])

 # Below the limit of 200.
-AT_PARSER_CHECK([./input 20], 0, [], [ignore],
+AT_PARSER_CHECK([input 20], 0, [], [ignore],
                [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
 # Two enlargements: 2 * 2 * 200.
-AT_PARSER_CHECK([./input 900], 0, [], [ignore],
+AT_PARSER_CHECK([input 900], 0, [], [ignore],
                [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
 # Fails: beyond the limit of 10,000 (which we don't reach anyway since we
 # multiply by two starting at 200 => 5120 is the possible).
-AT_PARSER_CHECK([./input 10000], 2, [], [ignore],
+AT_PARSER_CHECK([input 10000], 2, [], [ignore],
                [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])

 AT_DATA_STACK_TORTURE([AT_USE_ALLOCA],
 [[%define api.push-pull both
 ]])
-AT_PARSER_CHECK([./input 20], 0, [], [ignore],
+AT_PARSER_CHECK([input 20], 0, [], [ignore],
                [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
-AT_PARSER_CHECK([./input 900], 0, [], [ignore],
+AT_PARSER_CHECK([input 900], 0, [], [ignore],
                [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])
-AT_PARSER_CHECK([./input 10000], 2, [], [ignore],
+AT_PARSER_CHECK([input 10000], 2, [], [ignore],
                [[VALGRIND_OPTS="$VALGRIND_OPTS --log-fd=1"]])

 m4_popdef([AT_USE_ALLOCA])
--- a/tests/types.at
+++ b/tests/types.at
@@ -107,7 +107,7 @@ start: $3;
 AT_LANG_FOR_EACH_STD([
  $7
  AT_FULL_COMPILE([[test]])
-  AT_PARSER_CHECK([[./test]], 0, [[$6
+  AT_PARSER_CHECK([[test]], 0, [[$6
 ]])
 ])