#! /bin/sh

# Avoid depending upon Character Ranges.
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits

# Sed expression to map a string onto a valid variable name.
as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g"

# Sed expression to map a string onto a valid CPP name.
as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"


## --------------------- ##
## M4sh Initialization.  ##
## --------------------- ##

# Be Bourne compatible
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  emulate sh
  NULLCMD=:
elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  set -o posix
fi

# Name of the executable.
as_me=`echo "$0" |sed 's,.*[\\/],,'`

if expr a : '\(a\)' >/dev/null 2>&1; then
  as_expr=expr
else
  as_expr=false
fi

rm -f conf$$ conf$$.exe conf$$.file
echo >conf$$.file
if ln -s conf$$.file conf$$ 2>/dev/null; then
  # We could just check for DJGPP; but this test a) works b) is more generic
  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
  if test -f conf$$.exe; then
    # Don't use ln at all; we don't have any links
    as_ln_s='cp -p'
  else
    as_ln_s='ln -s'
  fi
elif ln conf$$.file conf$$ 2>/dev/null; then
  as_ln_s=ln
else
  as_ln_s='cp -p'
fi
rm -f conf$$ conf$$.exe conf$$.file

as_executable_p="test -f"

# Support unset when possible.
if (FOO=FOO; unset FOO) >/dev/null 2>&1; then
  as_unset=unset
else
  as_unset=false
fi



# NLS nuisances.
$as_unset LANG || test "${LANG+set}" != set || { LANG=C; export LANG; }
$as_unset LC_ALL || test "${LC_ALL+set}" != set || { LC_ALL=C; export LC_ALL; }
$as_unset LC_TIME || test "${LC_TIME+set}" != set || { LC_TIME=C; export LC_TIME; }
$as_unset LC_CTYPE || test "${LC_CTYPE+set}" != set || { LC_CTYPE=C; export LC_CTYPE; }
$as_unset LANGUAGE || test "${LANGUAGE+set}" != set || { LANGUAGE=C; export LANGUAGE; }
$as_unset LC_COLLATE || test "${LC_COLLATE+set}" != set || { LC_COLLATE=C; export LC_COLLATE; }
$as_unset LC_NUMERIC || test "${LC_NUMERIC+set}" != set || { LC_NUMERIC=C; export LC_NUMERIC; }
$as_unset LC_MESSAGES || test "${LC_MESSAGES+set}" != set || { LC_MESSAGES=C; export LC_MESSAGES; }

# IFS
# We need space, tab and new line, in precisely that order.
as_nl='
'
IFS=" 	$as_nl"

# CDPATH.
$as_unset CDPATH || test "${CDPATH+set}" != set || { CDPATH=:; export CDPATH; }

SHELL=${CONFIG_SHELL-/bin/sh}

# How were we run?
at_cli_args=${1+"$@"}

# Who are we?
at_testsuite_name='bison'
at_bugreport=''

# Load the config file.
for at_file in atconfig atlocal
do
  test -r $at_file || continue
  . ./$at_file || { echo "$as_me: error: invalid content: $at_file" >&2
   { (exit 1); exit 1; }; }
done

# Use absolute file notations, as the test might change directories.
at_srcdir=`cd "$srcdir" && pwd`
at_top_srcdir=`cd "$top_srcdir" && pwd`

# Not all shells have the 'times' builtin; the subshell is needed to make
# sure we discard the 'times: not found' message from the shell.
at_times=:
(times) >/dev/null 2>&1 && at_times=times

# CLI Arguments to pass to the debugging scripts.
at_debug_args=
# -e sets to true
at_stop_on_error=false
# Shall we be verbose?
at_verbose=:
at_quiet=echo
# Shall we keep the debug scripts?  Must be `:' when test suite is
# run by a debug script, so that the script doesn't remove itself.
at_debug=false
# Display help message?
at_help=false
# Tests to run
at_tests=
# List of the tests.
at_tests_all=" banner-1 1 2 3 4 5 6 7 8 9 10 11 12 banner-2 13 14 15 16 17 18 19 20 21 22 23 banner-3 24 25 "
# List of the output files.
at_data_files="stdout expout at-* stderr experr foo.y foo.yy calc.y input calc calc.c calc.h calc.output duplicate.y duplicate.* union.y union.*  "


while test $# -gt 0; do
  case $1 in
    --help | -h) at_help=: ;;
    --version)
        if test -n "$at_package_string"; then
          echo "$as_me ($at_package_string)"
          echo "Embedded test suite."
        else
          echo "$as_me ($at_testsuite_name)"
          echo "Stand-alone test suite."
        fi
        exit 0 ;;
    --clean | -c )
        rm -rf $at_data_files debug-*.sh $as_me.log devnull
	exit 0;;

    -d) at_debug=:;;
    -e) at_debug=:
        at_stop_on_error=:;;
    -v) at_verbose=echo; at_quiet=:;;
    -x) at_traceon='set -vx'; at_traceoff='set +vx';;

    [0-9] | [0-9][0-9] | [0-9][0-9][0-9] | [0-9][0-9][0-9][0-9])
        at_tests="$at_tests$1 ";;

    # Ranges
    [0-9]- | [0-9][0-9]- | [0-9][0-9][0-9]- | [0-9][0-9][0-9][0-9]-)
        at_range_start=`echo $1 |tr -d '-'`
        at_range=`echo " $at_tests_all " | \
          sed -e 's,^.* '$at_range_start' ,'$at_range_start' ,'`
        at_tests="$at_tests$at_range ";;

    -[0-9] | -[0-9][0-9] | -[0-9][0-9][0-9] | -[0-9][0-9][0-9][0-9])
        at_range_end=`echo $1 |tr -d '-'`
        at_range=`echo " $at_tests_all " | \
          sed -e 's, '$at_range_end' .*$, '$at_range_end','`
        at_tests="$at_tests$at_range ";;

    [0-9]-[0-9] | [0-9]-[0-9][0-9] | [0-9]-[0-9][0-9][0-9] | \
    [0-9]-[0-9][0-9][0-9][0-9] | [0-9][0-9]-[0-9][0-9] | \
    [0-9][0-9]-[0-9][0-9][0-9] | [0-9][0-9]-[0-9][0-9][0-9][0-9] | \
    [0-9][0-9][0-9]-[0-9][0-9][0-9] | \
    [0-9][0-9][0-9]-[0-9][0-9][0-9][0-9] | \
    [0-9][0-9][0-9][0-9]-[0-9][0-9][0-9][0-9] )
        at_range_start=`echo $1 |sed 's,-.*,,'`
        at_range_end=`echo $1 |sed 's,.*-,,'`
        # Maybe test to make sure start <= end?
        at_range=`echo " $at_tests_all " | \
          sed -e 's,^.* '$at_range_start' ,'$at_range_start' ,' \
              -e 's, '$at_range_end' .*$, '$at_range_end','`
        at_tests="$at_tests$at_range ";;

    *=*)
      at_debug_args="bison"
      at_envvar=`expr "x$1" : 'x\([^=]*\)='`
      # Reject names that are not valid shell variable names.
      expr "x$at_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
  	{ echo "$as_me: error: invalid variable name: $at_envvar" >&2
   { (exit 1); exit 1; }; }
      at_value=`expr "x$1" : 'x[^=]*=\(.*\)'`
      at_value=`echo "$at_value" | sed "s/'/'\\\\\\\\''/g"`
      eval "$at_envvar='$at_value'"
      export $at_envvar ;;

     *) echo "$as_me: invalid option: $1" >&2
        echo "Try \`$0 --help' for more information." >&2
        exit 1 ;;
  esac
  shift
done

# Help message.
if $at_help; then
  # If tests were specified, display only their title.
  if test -z "$at_tests"; then
    cat <<_ATEOF
Usage: $0 [OPTION]... [TESTS] [VAR=VALUE]

Run all the tests, or the selected TESTS.

Options:
  -h  Display this help message and the description of TESTS
  -c  Remove all the files this test suite might create and exit
  -e  Abort the test suite as soon as a test fails; implies -d
  -v  Force more detailed output, default for debugging scripts
  -d  Inhibit clean up and debug script creation, default for debugging scripts
  -x  Have the shell trace command execution

Tests:
_ATEOF
  else
    # "  1 42  45 " => " (1|42|45): "
    at_tests_pattern=`echo "$at_tests" | sed 's/^  *//;s/  *$//;s/  */|/g'`
    at_tests_pattern=" (${at_tests_pattern}): "
  fi
  egrep -e "$at_tests_pattern" <<_ATEOF
   1: output.at:37    Output files: .
   2: output.at:38    Output files: -o foo.c.
   3: output.at:39    Output files: -o foo.tab.c.
   4: output.at:40    Output files: -y.
   5: output.at:41    Output files: -b bar.
   6: output.at:42    Output files: -g -o foo.c.
   7: output.at:63    Output files: .
   8: output.at:66    Output files: %yacc.
   9: output.at:91    Output files: .
  10: output.at:95    Output files: .
  11: output.at:99    Output files: %source_extension ".cpp" %header_extension ".hhh".
  12: output.at:103   Output files: %source_extension ".cc" %header_extension ".hh".
  13: calc.at:359     Calculator
  14: calc.at:361     Calculator --defines
  15: calc.at:362     Calculator --locations
  16: calc.at:363     Calculator --name-prefix=calc
  17: calc.at:364     Calculator --verbose
  18: calc.at:365     Calculator --yacc
  19: calc.at:366     Calculator --yyerror-verbose
  20: calc.at:368     Calculator --locations --yyerror-verbose
  21: calc.at:370     Calculator --defines --locations --name-prefix=calc --verbose --yacc --yyerror-verbose
  22: calc.at:372     Calculator --debug
  23: calc.at:373     Calculator --debug --defines --locations --name-prefix=calc --verbose --yacc --yyerror-verbose
  24: regression.at:26 Duplicate string
  25: regression.at:52 %union and --defines
Report bugs to <$at_bugreport>.
_ATEOF
  exit 0
fi

# Tests to run.
test -z "$at_tests" && at_tests=$at_tests_all

# Don't take risks: use only absolute directories in PATH.
#
# For stand-alone test suites, AUTOTEST_PATH is relative to `.'.
#
# For embedded test suites, AUTOTEST_PATH is relative to the top level
# of the package.  Then expand it into build/src parts, since users
# may create executables in both places.
#
# There might be directories that don't exist, but don't redirect
# builtins' (eg., cd) stderr directly: Ultrix's sh hates that.
at_IFS_save=$IFS
IFS=$PATH_SEPARATOR
at_path=
for at_dir in $AUTOTEST_PATH $PATH
do
  case $at_dir in
    [\\/]* | ?:[\\/]* )
      at_path=$at_path$PATH_SEPARATOR$at_dir
      ;;
    * )
      if test -z "$top_builddir"; then
        # Stand-alone test suite.
        at_path=$at_path$PATH_SEPARATOR$at_dir
      else
        # Embedded test suite.
        at_path=$at_path$PATH_SEPARATOR$top_builddir/$at_dir
        at_path=$at_path$PATH_SEPARATOR$top_srcdir/$at_dir
      fi
      ;;
  esac
done
# Now build and simplify PATH.
at_sep=
PATH=
for at_dir in $at_path
do
  at_dir=`(cd "$at_dir" && pwd) 2>/dev/null`
  test -d "$at_dir" || continue
  case $PATH in
                    $at_dir                 | \
                    $at_dir$PATH_SEPARATOR* | \
    *$PATH_SEPARATOR$at_dir                 | \
    *$PATH_SEPARATOR$at_dir$PATH_SEPARATOR* ) ;;
    *) PATH=$PATH$at_sep$at_dir
       at_sep=$PATH_SEPARATOR;;
  esac
done
IFS=$at_IFS_save
export PATH

# Can we diff with `/dev/null'?  DU 5.0 refuses.
if diff /dev/null /dev/null >/dev/null 2>&1; then
  at_devnull=/dev/null
else
  at_devnull=devnull
  cp /dev/null $at_devnull
fi

# Use `diff -u' when possible.
if diff -u $at_devnull $at_devnull >/dev/null 2>&1; then
  at_diff='diff -u'
else
  at_diff=diff
fi

# Setting up the FDs.
# 5 is stdout conditioned by verbosity.
if test $at_verbose = echo; then
  exec 5>&1
else
  exec 5>/dev/null
fi

# 6 is the log file.  To be preserved if `-d'.

if $at_debug; then
  exec 6>/dev/null
else
  exec 6>$as_me.log
fi

# Banners and logs.
if test -n "$at_package_string"; then
  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## $at_package_string test suite. ##
_ASBOX
else
  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## $at_testsuite_name test suite. ##
_ASBOX
fi
{
  if test -n "$at_package_string"; then
    sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## Embedded $at_package_string test suite. ##
_ASBOX
  else
    sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## $at_testsuite_name test suite. ##
_ASBOX
  fi
  echo

  echo "$as_me: command line was:"
  echo "  $ $0 $at_cli_args"
  echo

  # Try to find a few ChangeLogs in case it might help determining the
  # exact version.  Use the relative dir: if the top dir is a symlink,
  # find will not follow it (and options to follow the links are not
  # portable), which would result in no output here.

  if test -n "$top_srcdir"; then
    cat <<\_ASBOX
## ----------- ##
## ChangeLogs. ##
## ----------- ##
_ASBOX
    echo
    find "$top_srcdir" -name ChangeLog \
      -exec echo "$as_me: {}:" ';' \
      -exec sed 's/^/| /;10q' {} ';' \
      -exec echo ';'

    {
cat <<_ASUNAME
## --------- ##
## Platform. ##
## --------- ##

hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
uname -m = `(uname -m) 2>/dev/null || echo unknown`
uname -r = `(uname -r) 2>/dev/null || echo unknown`
uname -s = `(uname -s) 2>/dev/null || echo unknown`
uname -v = `(uname -v) 2>/dev/null || echo unknown`

/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`

/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`

_ASUNAME

as_save_IFS=$IFS
IFS=:
for as_dir in $PATH
do
  echo "PATH: $as_dir"
done
IFS=$as_save_IFS
}
    echo

    cat <<\_ASBOX
## ------------------- ##
## Configuration logs. ##
## ------------------- ##
_ASBOX
    echo
    find "$top_srcdir" -name config.log \
      -exec echo "$as_me: {}:" ';' \
      -exec sed 's/^/| /' {} ';' \
      -exec echo ';'
  fi

  # Inform about the contents of the config files.
  for at_file in atconfig atlocal
  do
    test -r $at_file || continue
    echo "$as_me: $at_file:"
    sed 's/^/| /' $at_file
    echo
  done

  cat <<\_ASBOX
## -------- ##
## Victims. ##
## -------- ##
_ASBOX
} >&6

# If we are an embedded test suite, be sure to check we are running
# the proper version of the programs.  And in either case, report
# what program is being used.
for at_program in $at_victims
do
  (
    echo "testsuite.at:24: $at_program --version"
    $at_program --version
    echo
  ) >&6 2>&1
  if test -n "$at_package_name" && test -n "$at_package_version"; then
    ($at_program --version |
      grep "$at_package_name.*$at_package_version") >/dev/null 2>&1 ||
      { { echo "$as_me:461: error: version mismatch (need $at_package_name $at_package_version): $at_program" >&6
echo "$as_me: error: version mismatch (need $at_package_name $at_package_version): $at_program" >&2;}
   { (exit 1); exit 1; }; }
  fi
done

{
  cat <<\_ASBOX
## --------------------------- ##
## Silently running the tests. ##
## --------------------------- ##
_ASBOX
} >&6

at_start_date=`date`
at_start_time=`(date +%s) 2>/dev/null`
echo "$as_me: starting at: $at_start_date" >&6
at_fail_list=
at_skip_list=
at_test_count=0

for at_test in $at_tests
do
  at_status=0
  rm -rf $at_data_files
  # Clearly separate the tests when verbose.
  test $at_test_count != 0 && $at_verbose
  case $at_test in
  banner-1 ) # Banner 1. output.at:19
    cat <<\_ATEOF

Output file names.

_ATEOF
    ;;

  1 ) # 1. output.at:37: Output files: .
    at_setup_line='output.at:37'
    $at_verbose "1. output.at:37: testing Output files: ...."
    $at_quiet $at_n "  1: output.at:37      $at_c"
    (
      $at_traceon

cat >foo.y <<'_ATEOF'
%%
foo: {}
_ATEOF

rm -rf foo.output foo.tab.c foo.tab.h
$at_traceoff
$at_verbose "output.at:37: bison -dv foo.y "
echo output.at:37 >at-check-line
( $at_traceon; bison -dv foo.y  ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
(echo stderr:; cat at-stderr) >&5
(echo stdout:; cat at-stdout) >&5
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:37: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "output.at:37: ls foo.output foo.tab.c foo.tab.h | sort | tr '\\n' ' ' | sed 's/.\$//g'"
echo output.at:37 >at-check-line
( $at_traceon; ls foo.output foo.tab.c foo.tab.h | sort | tr '\n' ' ' | sed 's/.$//g' ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
echo >>at-stdout; echo "foo.output foo.tab.c foo.tab.h" | $at_diff - at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:37: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

rm -f foo.output foo.tab.c foo.tab.h
    $at_times >at-times
    )
    at_status=$?
    ;;

  2 ) # 2. output.at:38: Output files: -o foo.c.
    at_setup_line='output.at:38'
    $at_verbose "2. output.at:38: testing Output files: -o foo.c...."
    $at_quiet $at_n "  2: output.at:38      $at_c"
    (
      $at_traceon

cat >foo.y <<'_ATEOF'
%%
foo: {}
_ATEOF

rm -rf foo.c foo.h foo.output
$at_traceoff
$at_verbose "output.at:38: bison -dv foo.y -o foo.c"
echo output.at:38 >at-check-line
( $at_traceon; bison -dv foo.y -o foo.c ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
(echo stderr:; cat at-stderr) >&5
(echo stdout:; cat at-stdout) >&5
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:38: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "output.at:38: ls foo.c foo.h foo.output | sort | tr '\\n' ' ' | sed 's/.\$//g'"
echo output.at:38 >at-check-line
( $at_traceon; ls foo.c foo.h foo.output | sort | tr '\n' ' ' | sed 's/.$//g' ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
echo >>at-stdout; echo "foo.c foo.h foo.output" | $at_diff - at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:38: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

rm -f foo.c foo.h foo.output
    $at_times >at-times
    )
    at_status=$?
    ;;

  3 ) # 3. output.at:39: Output files: -o foo.tab.c.
    at_setup_line='output.at:39'
    $at_verbose "3. output.at:39: testing Output files: -o foo.tab.c...."
    $at_quiet $at_n "  3: output.at:39      $at_c"
    (
      $at_traceon

cat >foo.y <<'_ATEOF'
%%
foo: {}
_ATEOF

rm -rf foo.output foo.tab.c foo.tab.h
$at_traceoff
$at_verbose "output.at:39: bison -dv foo.y -o foo.tab.c"
echo output.at:39 >at-check-line
( $at_traceon; bison -dv foo.y -o foo.tab.c ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
(echo stderr:; cat at-stderr) >&5
(echo stdout:; cat at-stdout) >&5
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:39: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "output.at:39: ls foo.output foo.tab.c foo.tab.h | sort | tr '\\n' ' ' | sed 's/.\$//g'"
echo output.at:39 >at-check-line
( $at_traceon; ls foo.output foo.tab.c foo.tab.h | sort | tr '\n' ' ' | sed 's/.$//g' ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
echo >>at-stdout; echo "foo.output foo.tab.c foo.tab.h" | $at_diff - at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:39: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

rm -f foo.output foo.tab.c foo.tab.h
    $at_times >at-times
    )
    at_status=$?
    ;;

  4 ) # 4. output.at:40: Output files: -y.
    at_setup_line='output.at:40'
    $at_verbose "4. output.at:40: testing Output files: -y...."
    $at_quiet $at_n "  4: output.at:40      $at_c"
    (
      $at_traceon

cat >foo.y <<'_ATEOF'
%%
foo: {}
_ATEOF

rm -rf y.output y.tab.c y.tab.h
$at_traceoff
$at_verbose "output.at:40: bison -dv foo.y -y"
echo output.at:40 >at-check-line
( $at_traceon; bison -dv foo.y -y ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
(echo stderr:; cat at-stderr) >&5
(echo stdout:; cat at-stdout) >&5
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:40: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "output.at:40: ls y.output y.tab.c y.tab.h | sort | tr '\\n' ' ' | sed 's/.\$//g'"
echo output.at:40 >at-check-line
( $at_traceon; ls y.output y.tab.c y.tab.h | sort | tr '\n' ' ' | sed 's/.$//g' ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
echo >>at-stdout; echo "y.output y.tab.c y.tab.h" | $at_diff - at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:40: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

rm -f y.output y.tab.c y.tab.h
    $at_times >at-times
    )
    at_status=$?
    ;;

  5 ) # 5. output.at:41: Output files: -b bar.
    at_setup_line='output.at:41'
    $at_verbose "5. output.at:41: testing Output files: -b bar...."
    $at_quiet $at_n "  5: output.at:41      $at_c"
    (
      $at_traceon

cat >foo.y <<'_ATEOF'
%%
foo: {}
_ATEOF

rm -rf bar.output bar.tab.c bar.tab.h
$at_traceoff
$at_verbose "output.at:41: bison -dv foo.y -b bar"
echo output.at:41 >at-check-line
( $at_traceon; bison -dv foo.y -b bar ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
(echo stderr:; cat at-stderr) >&5
(echo stdout:; cat at-stdout) >&5
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:41: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "output.at:41: ls bar.output bar.tab.c bar.tab.h | sort | tr '\\n' ' ' | sed 's/.\$//g'"
echo output.at:41 >at-check-line
( $at_traceon; ls bar.output bar.tab.c bar.tab.h | sort | tr '\n' ' ' | sed 's/.$//g' ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
echo >>at-stdout; echo "bar.output bar.tab.c bar.tab.h" | $at_diff - at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:41: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

rm -f bar.output bar.tab.c bar.tab.h
    $at_times >at-times
    )
    at_status=$?
    ;;

  6 ) # 6. output.at:42: Output files: -g -o foo.c.
    at_setup_line='output.at:42'
    $at_verbose "6. output.at:42: testing Output files: -g -o foo.c...."
    $at_quiet $at_n "  6: output.at:42      $at_c"
    (
      $at_traceon

cat >foo.y <<'_ATEOF'
%%
foo: {}
_ATEOF

rm -rf foo.c foo.h foo.output foo.vcg
$at_traceoff
$at_verbose "output.at:42: bison -dv foo.y -g -o foo.c"
echo output.at:42 >at-check-line
( $at_traceon; bison -dv foo.y -g -o foo.c ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
(echo stderr:; cat at-stderr) >&5
(echo stdout:; cat at-stdout) >&5
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:42: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "output.at:42: ls foo.c foo.h foo.output foo.vcg | sort | tr '\\n' ' ' | sed 's/.\$//g'"
echo output.at:42 >at-check-line
( $at_traceon; ls foo.c foo.h foo.output foo.vcg | sort | tr '\n' ' ' | sed 's/.$//g' ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
echo >>at-stdout; echo "foo.c foo.h foo.output foo.vcg" | $at_diff - at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:42: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

rm -f foo.c foo.h foo.output foo.vcg
    $at_times >at-times
    )
    at_status=$?
    ;;

  7 ) # 7. output.at:63: Output files: .
    at_setup_line='output.at:63'
    $at_verbose "7. output.at:63: testing Output files: ...."
    $at_quiet $at_n "  7: output.at:63      $at_c"
    (
      $at_traceon

cat >foo.y <<'_ATEOF'

%defines
%verbose
%%
foo: {}
_ATEOF

rm -rf foo.output foo.tab.c foo.tab.h
$at_traceoff
$at_verbose "output.at:63: bison foo.y"
echo output.at:63 >at-check-line
( $at_traceon; bison foo.y ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
(echo stderr:; cat at-stderr) >&5
(echo stdout:; cat at-stdout) >&5
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:63: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "output.at:63: ls foo.output foo.tab.c foo.tab.h | sort | tr '\\n' ' ' | sed 's/.\$//g'"
echo output.at:63 >at-check-line
( $at_traceon; ls foo.output foo.tab.c foo.tab.h | sort | tr '\n' ' ' | sed 's/.$//g' ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
echo >>at-stdout; echo "foo.output foo.tab.c foo.tab.h" | $at_diff - at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:63: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

rm -f foo.output foo.tab.c foo.tab.h
    $at_times >at-times
    )
    at_status=$?
    ;;

  8 ) # 8. output.at:66: Output files: %yacc.
    at_setup_line='output.at:66'
    $at_verbose "8. output.at:66: testing Output files: %yacc...."
    $at_quiet $at_n "  8: output.at:66      $at_c"
    (
      $at_traceon

cat >foo.y <<'_ATEOF'
%yacc
%defines
%verbose
%%
foo: {}
_ATEOF

rm -rf y.output y.tab.c y.tab.h
$at_traceoff
$at_verbose "output.at:66: bison foo.y"
echo output.at:66 >at-check-line
( $at_traceon; bison foo.y ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
(echo stderr:; cat at-stderr) >&5
(echo stdout:; cat at-stdout) >&5
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:66: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "output.at:66: ls y.output y.tab.c y.tab.h | sort | tr '\\n' ' ' | sed 's/.\$//g'"
echo output.at:66 >at-check-line
( $at_traceon; ls y.output y.tab.c y.tab.h | sort | tr '\n' ' ' | sed 's/.$//g' ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
echo >>at-stdout; echo "y.output y.tab.c y.tab.h" | $at_diff - at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:66: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

rm -f y.output y.tab.c y.tab.h
    $at_times >at-times
    )
    at_status=$?
    ;;

  9 ) # 9. output.at:91: Output files: .
    at_setup_line='output.at:91'
    $at_verbose "9. output.at:91: testing Output files: ...."
    $at_quiet $at_n "  9: output.at:91      $at_c"
    (
      $at_traceon

cat >foo.yy <<'_ATEOF'

%defines
%verbose
%%
foo: {}
_ATEOF

rm -rf foo.output foo.tab.cc foo.tab.hh
$at_traceoff
$at_verbose "output.at:91: bison foo.yy "
echo output.at:91 >at-check-line
( $at_traceon; bison foo.yy  ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
(echo stderr:; cat at-stderr) >&5
(echo stdout:; cat at-stdout) >&5
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:91: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "output.at:91: ls foo.output foo.tab.cc foo.tab.hh | sort | tr '\\n' ' ' | sed 's/.\$//g'"
echo output.at:91 >at-check-line
( $at_traceon; ls foo.output foo.tab.cc foo.tab.hh | sort | tr '\n' ' ' | sed 's/.$//g' ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
echo >>at-stdout; echo "foo.output foo.tab.cc foo.tab.hh" | $at_diff - at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:91: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

rm -f foo.output foo.tab.cc foo.tab.hh
    $at_times >at-times
    )
    at_status=$?
    ;;

  10 ) # 10. output.at:95: Output files: .
    at_setup_line='output.at:95'
    $at_verbose "10. output.at:95: testing Output files: ...."
    $at_quiet $at_n " 10: output.at:95      $at_c"
    (
      $at_traceon

cat >foo.yy <<'_ATEOF'

%defines
%verbose
%%
foo: {}
_ATEOF

rm -rf foo.c foo.h foo.output
$at_traceoff
$at_verbose "output.at:95: bison foo.yy -o foo.c"
echo output.at:95 >at-check-line
( $at_traceon; bison foo.yy -o foo.c ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
(echo stderr:; cat at-stderr) >&5
(echo stdout:; cat at-stdout) >&5
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:95: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "output.at:95: ls foo.c foo.h foo.output | sort | tr '\\n' ' ' | sed 's/.\$//g'"
echo output.at:95 >at-check-line
( $at_traceon; ls foo.c foo.h foo.output | sort | tr '\n' ' ' | sed 's/.$//g' ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
echo >>at-stdout; echo "foo.c foo.h foo.output" | $at_diff - at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:95: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

rm -f foo.c foo.h foo.output
    $at_times >at-times
    )
    at_status=$?
    ;;

  11 ) # 11. output.at:99: Output files: %source_extension ".cpp" %header_extension ".hhh".
    at_setup_line='output.at:99'
    $at_verbose "11. output.at:99: testing Output files: %source_extension ".cpp" %header_extension ".hhh"...."
    $at_quiet $at_n " 11: output.at:99      $at_c"
    (
      $at_traceon

cat >foo.yy <<'_ATEOF'
%source_extension ".cpp" %header_extension ".hhh"
%defines
%verbose
%%
foo: {}
_ATEOF

rm -rf foo.output foo.tab.cpp foo.tab.hhh
$at_traceoff
$at_verbose "output.at:99: bison foo.yy "
echo output.at:99 >at-check-line
( $at_traceon; bison foo.yy  ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
(echo stderr:; cat at-stderr) >&5
(echo stdout:; cat at-stdout) >&5
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:99: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "output.at:99: ls foo.output foo.tab.cpp foo.tab.hhh | sort | tr '\\n' ' ' | sed 's/.\$//g'"
echo output.at:99 >at-check-line
( $at_traceon; ls foo.output foo.tab.cpp foo.tab.hhh | sort | tr '\n' ' ' | sed 's/.$//g' ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
echo >>at-stdout; echo "foo.output foo.tab.cpp foo.tab.hhh" | $at_diff - at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:99: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

rm -f foo.output foo.tab.cpp foo.tab.hhh
    $at_times >at-times
    )
    at_status=$?
    ;;

  12 ) # 12. output.at:103: Output files: %source_extension ".cc" %header_extension ".hh".
    at_setup_line='output.at:103'
    $at_verbose "12. output.at:103: testing Output files: %source_extension ".cc" %header_extension ".hh"...."
    $at_quiet $at_n " 12: output.at:103     $at_c"
    (
      $at_traceon

cat >foo.yy <<'_ATEOF'
%source_extension ".cc" %header_extension ".hh"
%defines
%verbose
%%
foo: {}
_ATEOF

rm -rf foo.c foo.h foo.output
$at_traceoff
$at_verbose "output.at:103: bison foo.yy -o foo.c"
echo output.at:103 >at-check-line
( $at_traceon; bison foo.yy -o foo.c ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
(echo stderr:; cat at-stderr) >&5
(echo stdout:; cat at-stdout) >&5
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:103: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "output.at:103: ls foo.c foo.h foo.output | sort | tr '\\n' ' ' | sed 's/.\$//g'"
echo output.at:103 >at-check-line
( $at_traceon; ls foo.c foo.h foo.output | sort | tr '\n' ' ' | sed 's/.$//g' ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
echo >>at-stdout; echo "foo.c foo.h foo.output" | $at_diff - at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "output.at:103: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

rm -f foo.c foo.h foo.output
    $at_times >at-times
    )
    at_status=$?
    ;;

  banner-2 ) # Banner 2. calc.at:19
    cat <<\_ATEOF

Simple Calculator.

_ATEOF
    ;;

  13 ) # 13. calc.at:359: Calculator
    at_setup_line='calc.at:359'
    $at_verbose "13. calc.at:359: testing Calculator ..."
    $at_quiet $at_n " 13: calc.at:359       $at_c"
    (
      $at_traceon


cat >calc.y <<'_ATEOF'
/* Infix notation calculator--calc */

%{
#include <config.h>
#include <stdio.h>

#if STDC_HEADERS
# include <stdlib.h>
# include <string.h>
#else
char *strcat(char *dest, const char *src);
#endif
#include <ctype.h>


static int power (int base, int exponent);
static void yyerror (const char *s);
static int yylex (void);
static int yygetc (void);
static void yyungetc (int c);

extern void perror (const char *s);
%}

/* BISON Declarations */
%token NUM

%nonassoc '=' /* comparison	       */
%left '-' '+'
%left '*' '/'
%left NEG     /* negation--unary minus */
%right '^'    /* exponentiation        */

/* Grammar follows */
%%
input:
  /* empty string */
| input line
;

line:
  '\n'
| exp '\n'
;

exp:
  NUM                { $$ = $1;             }
| exp '=' exp
  {
     if ($1 != $3)
       printf ("calc: error: %d != %d\n", $1, $3);
     $$ = $1 == $3;
  }
| exp '+' exp        { $$ = $1 + $3;        }
| exp '-' exp        { $$ = $1 - $3;        }
| exp '*' exp        { $$ = $1 * $3;        }
| exp '/' exp        { $$ = $1 / $3;        }
| '-' exp  %prec NEG { $$ = -$2;            }
| exp '^' exp        { $$ = power ($1, $3); }
| '(' exp ')'        { $$ = $2;             }
;
%%
/* The input. */
FILE *yyin;

static void
yyerror (const char *s)
{
#if YYLSP_NEEDED
  fprintf (stderr, "%d.%d:%d.%d: ",
	   yylloc.first_line, yylloc.first_column,
	   yylloc.last_line, yylloc.last_column);
#endif
  fprintf (stderr, "%s\n", s);
}

static int
yygetc (void)
{
  int res = getc (yyin);
#if YYLSP_NEEDED
  if (res == '\n')
    {
      yylloc.last_line++;
      yylloc.last_column = 0;
    }
  else
    yylloc.last_column++;
#endif
  return res;
}


static void
yyungetc (int c)
{
#if YYLSP_NEEDED
  /* Wrong when C == `\n'. */
  yylloc.last_column--;
#endif
  ungetc (c, yyin);
}

static int
read_signed_integer (void)
{
  int c = yygetc ();
  int sign = 1;
  int n = 0;

  if (c == '-')
    {
      c = yygetc ();
      sign = -1;
    }

  while (isdigit (c))
    {
      n = 10 * n + (c - '0');
      c = yygetc ();
    }

  yyungetc (c);

  return sign * n;
}



/*---------------------------------------------------------------.
| Lexical analyzer returns an integer on the stack and the token |
| NUM, or the ASCII character read if not a number.  Skips all   |
| blanks and tabs, returns 0 for EOF.                            |
`---------------------------------------------------------------*/

static int
yylex (void)
{
  int c;

#if YYLSP_NEEDED
  yylloc.first_column = yylloc.last_column;
  yylloc.first_line = yylloc.last_line;
#endif

  /* Skip white space.  */
  while ((c = yygetc ()) == ' ' || c == '\t')
    {
#if YYLSP_NEEDED
      yylloc.first_column = yylloc.last_column;
      yylloc.first_line = yylloc.last_line;
#endif
    }

  /* process numbers   */
  if (c == '.' || isdigit (c))
    {
      yyungetc (c);
      yylval = read_signed_integer ();
      return NUM;
    }

  /* Return end-of-file.  */
  if (c == EOF)
    return 0;

  /* Return single chars. */
  return c;
}

static int
power (int base, int exponent)
{
  int res = 1;
  if (exponent < 0)
    exit (1);
  for (/* Niente */; exponent; --exponent)
    res *= base;
  return res;
}

int
main (int argn, const char **argv)
{
  if (argn == 2)
    yyin = fopen (argv[1], "r");
  else
    yyin = stdin;

  if (!stdin)
    {
      perror (argv[1]);
      exit (1);
    }

#if YYDEBUG
  yydebug = 1;
#endif
#if YYLSP_NEEDED
  yylloc.last_column = 0;
  yylloc.last_line = 1;
#endif
  yyparse ();
  return 0;
}
_ATEOF



# Specify the output files to avoid problems on different file systems.
$at_traceoff
$at_verbose "calc.at:359: bison calc.y -o calc.c "
echo calc.at:359 >at-check-line
( $at_traceon; bison calc.y -o calc.c  ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:359: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "calc.at:359: \$CC \$CFLAGS \$CPPFLAGS calc.c -o calc"
echo calc.at:359 >at-check-line
( $at_traceon; $CC $CFLAGS $CPPFLAGS calc.c -o calc ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:359: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Test the priorities.
cat >input <<'_ATEOF'
1 + 2 * 3 = 7
1 + 2 * -3 = -5

-1^2 = -1
(-1)^2 = 1

---1 = -1

1 - 2 - 3 = -4
1 - (2 - 3) = 2

2^2^3 = 256
(2^2)^3 = 64
_ATEOF

$at_traceoff
$at_verbose "calc.at:359: ./calc <input"
echo calc.at:359 >at-check-line
( $at_traceon; ./calc <input ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:359: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Some parse errors.
cat >input <<'_ATEOF'
+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:359: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:359 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:359: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1//2
_ATEOF


$at_traceoff
$at_verbose "calc.at:359: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:359 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:359: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
error
_ATEOF


$at_traceoff
$at_verbose "calc.at:359: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:359 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:359: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1 = 2 = 3
_ATEOF


$at_traceoff
$at_verbose "calc.at:359: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:359 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:359: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'

+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:359: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:359 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:359: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


    $at_times >at-times
    )
    at_status=$?
    ;;

  14 ) # 14. calc.at:361: Calculator --defines
    at_setup_line='calc.at:361'
    $at_verbose "14. calc.at:361: testing Calculator --defines..."
    $at_quiet $at_n " 14: calc.at:361       $at_c"
    (
      $at_traceon


cat >calc.y <<'_ATEOF'
/* Infix notation calculator--calc */

%{
#include <config.h>
#include <stdio.h>

#if STDC_HEADERS
# include <stdlib.h>
# include <string.h>
#else
char *strcat(char *dest, const char *src);
#endif
#include <ctype.h>


static int power (int base, int exponent);
static void yyerror (const char *s);
static int yylex (void);
static int yygetc (void);
static void yyungetc (int c);

extern void perror (const char *s);
%}

/* BISON Declarations */
%token NUM

%nonassoc '=' /* comparison	       */
%left '-' '+'
%left '*' '/'
%left NEG     /* negation--unary minus */
%right '^'    /* exponentiation        */

/* Grammar follows */
%%
input:
  /* empty string */
| input line
;

line:
  '\n'
| exp '\n'
;

exp:
  NUM                { $$ = $1;             }
| exp '=' exp
  {
     if ($1 != $3)
       printf ("calc: error: %d != %d\n", $1, $3);
     $$ = $1 == $3;
  }
| exp '+' exp        { $$ = $1 + $3;        }
| exp '-' exp        { $$ = $1 - $3;        }
| exp '*' exp        { $$ = $1 * $3;        }
| exp '/' exp        { $$ = $1 / $3;        }
| '-' exp  %prec NEG { $$ = -$2;            }
| exp '^' exp        { $$ = power ($1, $3); }
| '(' exp ')'        { $$ = $2;             }
;
%%
/* The input. */
FILE *yyin;

static void
yyerror (const char *s)
{
#if YYLSP_NEEDED
  fprintf (stderr, "%d.%d:%d.%d: ",
	   yylloc.first_line, yylloc.first_column,
	   yylloc.last_line, yylloc.last_column);
#endif
  fprintf (stderr, "%s\n", s);
}

static int
yygetc (void)
{
  int res = getc (yyin);
#if YYLSP_NEEDED
  if (res == '\n')
    {
      yylloc.last_line++;
      yylloc.last_column = 0;
    }
  else
    yylloc.last_column++;
#endif
  return res;
}


static void
yyungetc (int c)
{
#if YYLSP_NEEDED
  /* Wrong when C == `\n'. */
  yylloc.last_column--;
#endif
  ungetc (c, yyin);
}

static int
read_signed_integer (void)
{
  int c = yygetc ();
  int sign = 1;
  int n = 0;

  if (c == '-')
    {
      c = yygetc ();
      sign = -1;
    }

  while (isdigit (c))
    {
      n = 10 * n + (c - '0');
      c = yygetc ();
    }

  yyungetc (c);

  return sign * n;
}



/*---------------------------------------------------------------.
| Lexical analyzer returns an integer on the stack and the token |
| NUM, or the ASCII character read if not a number.  Skips all   |
| blanks and tabs, returns 0 for EOF.                            |
`---------------------------------------------------------------*/

static int
yylex (void)
{
  int c;

#if YYLSP_NEEDED
  yylloc.first_column = yylloc.last_column;
  yylloc.first_line = yylloc.last_line;
#endif

  /* Skip white space.  */
  while ((c = yygetc ()) == ' ' || c == '\t')
    {
#if YYLSP_NEEDED
      yylloc.first_column = yylloc.last_column;
      yylloc.first_line = yylloc.last_line;
#endif
    }

  /* process numbers   */
  if (c == '.' || isdigit (c))
    {
      yyungetc (c);
      yylval = read_signed_integer ();
      return NUM;
    }

  /* Return end-of-file.  */
  if (c == EOF)
    return 0;

  /* Return single chars. */
  return c;
}

static int
power (int base, int exponent)
{
  int res = 1;
  if (exponent < 0)
    exit (1);
  for (/* Niente */; exponent; --exponent)
    res *= base;
  return res;
}

int
main (int argn, const char **argv)
{
  if (argn == 2)
    yyin = fopen (argv[1], "r");
  else
    yyin = stdin;

  if (!stdin)
    {
      perror (argv[1]);
      exit (1);
    }

#if YYDEBUG
  yydebug = 1;
#endif
#if YYLSP_NEEDED
  yylloc.last_column = 0;
  yylloc.last_line = 1;
#endif
  yyparse ();
  return 0;
}
_ATEOF



# Specify the output files to avoid problems on different file systems.
$at_traceoff
$at_verbose "calc.at:361: bison calc.y -o calc.c --defines"
echo calc.at:361 >at-check-line
( $at_traceon; bison calc.y -o calc.c --defines ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:361: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "calc.at:361: \$CC \$CFLAGS \$CPPFLAGS calc.c -o calc"
echo calc.at:361 >at-check-line
( $at_traceon; $CC $CFLAGS $CPPFLAGS calc.c -o calc ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:361: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Test the priorities.
cat >input <<'_ATEOF'
1 + 2 * 3 = 7
1 + 2 * -3 = -5

-1^2 = -1
(-1)^2 = 1

---1 = -1

1 - 2 - 3 = -4
1 - (2 - 3) = 2

2^2^3 = 256
(2^2)^3 = 64
_ATEOF

$at_traceoff
$at_verbose "calc.at:361: ./calc <input"
echo calc.at:361 >at-check-line
( $at_traceon; ./calc <input ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:361: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Some parse errors.
cat >input <<'_ATEOF'
+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:361: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:361 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:361: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1//2
_ATEOF


$at_traceoff
$at_verbose "calc.at:361: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:361 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:361: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
error
_ATEOF


$at_traceoff
$at_verbose "calc.at:361: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:361 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:361: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1 = 2 = 3
_ATEOF


$at_traceoff
$at_verbose "calc.at:361: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:361 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:361: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'

+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:361: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:361 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:361: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


    $at_times >at-times
    )
    at_status=$?
    ;;

  15 ) # 15. calc.at:362: Calculator --locations
    at_setup_line='calc.at:362'
    $at_verbose "15. calc.at:362: testing Calculator --locations..."
    $at_quiet $at_n " 15: calc.at:362       $at_c"
    (
      $at_traceon


cat >calc.y <<'_ATEOF'
/* Infix notation calculator--calc */

%{
#include <config.h>
#include <stdio.h>

#if STDC_HEADERS
# include <stdlib.h>
# include <string.h>
#else
char *strcat(char *dest, const char *src);
#endif
#include <ctype.h>


static int power (int base, int exponent);
static void yyerror (const char *s);
static int yylex (void);
static int yygetc (void);
static void yyungetc (int c);

extern void perror (const char *s);
%}

/* BISON Declarations */
%token NUM

%nonassoc '=' /* comparison	       */
%left '-' '+'
%left '*' '/'
%left NEG     /* negation--unary minus */
%right '^'    /* exponentiation        */

/* Grammar follows */
%%
input:
  /* empty string */
| input line
;

line:
  '\n'
| exp '\n'
;

exp:
  NUM                { $$ = $1;             }
| exp '=' exp
  {
     if ($1 != $3)
       printf ("calc: error: %d != %d\n", $1, $3);
     $$ = $1 == $3;
  }
| exp '+' exp        { $$ = $1 + $3;        }
| exp '-' exp        { $$ = $1 - $3;        }
| exp '*' exp        { $$ = $1 * $3;        }
| exp '/' exp        { $$ = $1 / $3;        }
| '-' exp  %prec NEG { $$ = -$2;            }
| exp '^' exp        { $$ = power ($1, $3); }
| '(' exp ')'        { $$ = $2;             }
;
%%
/* The input. */
FILE *yyin;

static void
yyerror (const char *s)
{
#if YYLSP_NEEDED
  fprintf (stderr, "%d.%d:%d.%d: ",
	   yylloc.first_line, yylloc.first_column,
	   yylloc.last_line, yylloc.last_column);
#endif
  fprintf (stderr, "%s\n", s);
}

static int
yygetc (void)
{
  int res = getc (yyin);
#if YYLSP_NEEDED
  if (res == '\n')
    {
      yylloc.last_line++;
      yylloc.last_column = 0;
    }
  else
    yylloc.last_column++;
#endif
  return res;
}


static void
yyungetc (int c)
{
#if YYLSP_NEEDED
  /* Wrong when C == `\n'. */
  yylloc.last_column--;
#endif
  ungetc (c, yyin);
}

static int
read_signed_integer (void)
{
  int c = yygetc ();
  int sign = 1;
  int n = 0;

  if (c == '-')
    {
      c = yygetc ();
      sign = -1;
    }

  while (isdigit (c))
    {
      n = 10 * n + (c - '0');
      c = yygetc ();
    }

  yyungetc (c);

  return sign * n;
}



/*---------------------------------------------------------------.
| Lexical analyzer returns an integer on the stack and the token |
| NUM, or the ASCII character read if not a number.  Skips all   |
| blanks and tabs, returns 0 for EOF.                            |
`---------------------------------------------------------------*/

static int
yylex (void)
{
  int c;

#if YYLSP_NEEDED
  yylloc.first_column = yylloc.last_column;
  yylloc.first_line = yylloc.last_line;
#endif

  /* Skip white space.  */
  while ((c = yygetc ()) == ' ' || c == '\t')
    {
#if YYLSP_NEEDED
      yylloc.first_column = yylloc.last_column;
      yylloc.first_line = yylloc.last_line;
#endif
    }

  /* process numbers   */
  if (c == '.' || isdigit (c))
    {
      yyungetc (c);
      yylval = read_signed_integer ();
      return NUM;
    }

  /* Return end-of-file.  */
  if (c == EOF)
    return 0;

  /* Return single chars. */
  return c;
}

static int
power (int base, int exponent)
{
  int res = 1;
  if (exponent < 0)
    exit (1);
  for (/* Niente */; exponent; --exponent)
    res *= base;
  return res;
}

int
main (int argn, const char **argv)
{
  if (argn == 2)
    yyin = fopen (argv[1], "r");
  else
    yyin = stdin;

  if (!stdin)
    {
      perror (argv[1]);
      exit (1);
    }

#if YYDEBUG
  yydebug = 1;
#endif
#if YYLSP_NEEDED
  yylloc.last_column = 0;
  yylloc.last_line = 1;
#endif
  yyparse ();
  return 0;
}
_ATEOF



# Specify the output files to avoid problems on different file systems.
$at_traceoff
$at_verbose "calc.at:362: bison calc.y -o calc.c --locations"
echo calc.at:362 >at-check-line
( $at_traceon; bison calc.y -o calc.c --locations ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:362: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "calc.at:362: \$CC \$CFLAGS \$CPPFLAGS calc.c -o calc"
echo calc.at:362 >at-check-line
( $at_traceon; $CC $CFLAGS $CPPFLAGS calc.c -o calc ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:362: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Test the priorities.
cat >input <<'_ATEOF'
1 + 2 * 3 = 7
1 + 2 * -3 = -5

-1^2 = -1
(-1)^2 = 1

---1 = -1

1 - 2 - 3 = -4
1 - (2 - 3) = 2

2^2^3 = 256
(2^2)^3 = 64
_ATEOF

$at_traceoff
$at_verbose "calc.at:362: ./calc <input"
echo calc.at:362 >at-check-line
( $at_traceon; ./calc <input ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:362: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Some parse errors.
cat >input <<'_ATEOF'
+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:362: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:362 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "1.0:1.1: parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:362: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1//2
_ATEOF


$at_traceoff
$at_verbose "calc.at:362: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:362 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "1.2:1.3: parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:362: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
error
_ATEOF


$at_traceoff
$at_verbose "calc.at:362: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:362 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "1.0:1.1: parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:362: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1 = 2 = 3
_ATEOF


$at_traceoff
$at_verbose "calc.at:362: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:362 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "1.6:1.7: parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:362: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'

+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:362: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:362 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "2.0:2.1: parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:362: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


    $at_times >at-times
    )
    at_status=$?
    ;;

  16 ) # 16. calc.at:363: Calculator --name-prefix=calc
    at_setup_line='calc.at:363'
    $at_verbose "16. calc.at:363: testing Calculator --name-prefix=calc..."
    $at_quiet $at_n " 16: calc.at:363       $at_c"
    (
      $at_traceon


cat >calc.y <<'_ATEOF'
/* Infix notation calculator--calc */

%{
#include <config.h>
#include <stdio.h>

#if STDC_HEADERS
# include <stdlib.h>
# include <string.h>
#else
char *strcat(char *dest, const char *src);
#endif
#include <ctype.h>


static int power (int base, int exponent);
static void yyerror (const char *s);
static int yylex (void);
static int yygetc (void);
static void yyungetc (int c);

extern void perror (const char *s);
%}

/* BISON Declarations */
%token NUM

%nonassoc '=' /* comparison	       */
%left '-' '+'
%left '*' '/'
%left NEG     /* negation--unary minus */
%right '^'    /* exponentiation        */

/* Grammar follows */
%%
input:
  /* empty string */
| input line
;

line:
  '\n'
| exp '\n'
;

exp:
  NUM                { $$ = $1;             }
| exp '=' exp
  {
     if ($1 != $3)
       printf ("calc: error: %d != %d\n", $1, $3);
     $$ = $1 == $3;
  }
| exp '+' exp        { $$ = $1 + $3;        }
| exp '-' exp        { $$ = $1 - $3;        }
| exp '*' exp        { $$ = $1 * $3;        }
| exp '/' exp        { $$ = $1 / $3;        }
| '-' exp  %prec NEG { $$ = -$2;            }
| exp '^' exp        { $$ = power ($1, $3); }
| '(' exp ')'        { $$ = $2;             }
;
%%
/* The input. */
FILE *yyin;

static void
yyerror (const char *s)
{
#if YYLSP_NEEDED
  fprintf (stderr, "%d.%d:%d.%d: ",
	   yylloc.first_line, yylloc.first_column,
	   yylloc.last_line, yylloc.last_column);
#endif
  fprintf (stderr, "%s\n", s);
}

static int
yygetc (void)
{
  int res = getc (yyin);
#if YYLSP_NEEDED
  if (res == '\n')
    {
      yylloc.last_line++;
      yylloc.last_column = 0;
    }
  else
    yylloc.last_column++;
#endif
  return res;
}


static void
yyungetc (int c)
{
#if YYLSP_NEEDED
  /* Wrong when C == `\n'. */
  yylloc.last_column--;
#endif
  ungetc (c, yyin);
}

static int
read_signed_integer (void)
{
  int c = yygetc ();
  int sign = 1;
  int n = 0;

  if (c == '-')
    {
      c = yygetc ();
      sign = -1;
    }

  while (isdigit (c))
    {
      n = 10 * n + (c - '0');
      c = yygetc ();
    }

  yyungetc (c);

  return sign * n;
}



/*---------------------------------------------------------------.
| Lexical analyzer returns an integer on the stack and the token |
| NUM, or the ASCII character read if not a number.  Skips all   |
| blanks and tabs, returns 0 for EOF.                            |
`---------------------------------------------------------------*/

static int
yylex (void)
{
  int c;

#if YYLSP_NEEDED
  yylloc.first_column = yylloc.last_column;
  yylloc.first_line = yylloc.last_line;
#endif

  /* Skip white space.  */
  while ((c = yygetc ()) == ' ' || c == '\t')
    {
#if YYLSP_NEEDED
      yylloc.first_column = yylloc.last_column;
      yylloc.first_line = yylloc.last_line;
#endif
    }

  /* process numbers   */
  if (c == '.' || isdigit (c))
    {
      yyungetc (c);
      yylval = read_signed_integer ();
      return NUM;
    }

  /* Return end-of-file.  */
  if (c == EOF)
    return 0;

  /* Return single chars. */
  return c;
}

static int
power (int base, int exponent)
{
  int res = 1;
  if (exponent < 0)
    exit (1);
  for (/* Niente */; exponent; --exponent)
    res *= base;
  return res;
}

int
main (int argn, const char **argv)
{
  if (argn == 2)
    yyin = fopen (argv[1], "r");
  else
    yyin = stdin;

  if (!stdin)
    {
      perror (argv[1]);
      exit (1);
    }

#if YYDEBUG
  yydebug = 1;
#endif
#if YYLSP_NEEDED
  yylloc.last_column = 0;
  yylloc.last_line = 1;
#endif
  yyparse ();
  return 0;
}
_ATEOF



# Specify the output files to avoid problems on different file systems.
$at_traceoff
$at_verbose "calc.at:363: bison calc.y -o calc.c --name-prefix=calc"
echo calc.at:363 >at-check-line
( $at_traceon; bison calc.y -o calc.c --name-prefix=calc ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:363: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "calc.at:363: \$CC \$CFLAGS \$CPPFLAGS calc.c -o calc"
echo calc.at:363 >at-check-line
( $at_traceon; $CC $CFLAGS $CPPFLAGS calc.c -o calc ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:363: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Test the priorities.
cat >input <<'_ATEOF'
1 + 2 * 3 = 7
1 + 2 * -3 = -5

-1^2 = -1
(-1)^2 = 1

---1 = -1

1 - 2 - 3 = -4
1 - (2 - 3) = 2

2^2^3 = 256
(2^2)^3 = 64
_ATEOF

$at_traceoff
$at_verbose "calc.at:363: ./calc <input"
echo calc.at:363 >at-check-line
( $at_traceon; ./calc <input ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:363: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Some parse errors.
cat >input <<'_ATEOF'
+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:363: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:363 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:363: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1//2
_ATEOF


$at_traceoff
$at_verbose "calc.at:363: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:363 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:363: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
error
_ATEOF


$at_traceoff
$at_verbose "calc.at:363: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:363 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:363: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1 = 2 = 3
_ATEOF


$at_traceoff
$at_verbose "calc.at:363: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:363 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:363: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'

+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:363: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:363 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:363: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


    $at_times >at-times
    )
    at_status=$?
    ;;

  17 ) # 17. calc.at:364: Calculator --verbose
    at_setup_line='calc.at:364'
    $at_verbose "17. calc.at:364: testing Calculator --verbose..."
    $at_quiet $at_n " 17: calc.at:364       $at_c"
    (
      $at_traceon


cat >calc.y <<'_ATEOF'
/* Infix notation calculator--calc */

%{
#include <config.h>
#include <stdio.h>

#if STDC_HEADERS
# include <stdlib.h>
# include <string.h>
#else
char *strcat(char *dest, const char *src);
#endif
#include <ctype.h>


static int power (int base, int exponent);
static void yyerror (const char *s);
static int yylex (void);
static int yygetc (void);
static void yyungetc (int c);

extern void perror (const char *s);
%}

/* BISON Declarations */
%token NUM

%nonassoc '=' /* comparison	       */
%left '-' '+'
%left '*' '/'
%left NEG     /* negation--unary minus */
%right '^'    /* exponentiation        */

/* Grammar follows */
%%
input:
  /* empty string */
| input line
;

line:
  '\n'
| exp '\n'
;

exp:
  NUM                { $$ = $1;             }
| exp '=' exp
  {
     if ($1 != $3)
       printf ("calc: error: %d != %d\n", $1, $3);
     $$ = $1 == $3;
  }
| exp '+' exp        { $$ = $1 + $3;        }
| exp '-' exp        { $$ = $1 - $3;        }
| exp '*' exp        { $$ = $1 * $3;        }
| exp '/' exp        { $$ = $1 / $3;        }
| '-' exp  %prec NEG { $$ = -$2;            }
| exp '^' exp        { $$ = power ($1, $3); }
| '(' exp ')'        { $$ = $2;             }
;
%%
/* The input. */
FILE *yyin;

static void
yyerror (const char *s)
{
#if YYLSP_NEEDED
  fprintf (stderr, "%d.%d:%d.%d: ",
	   yylloc.first_line, yylloc.first_column,
	   yylloc.last_line, yylloc.last_column);
#endif
  fprintf (stderr, "%s\n", s);
}

static int
yygetc (void)
{
  int res = getc (yyin);
#if YYLSP_NEEDED
  if (res == '\n')
    {
      yylloc.last_line++;
      yylloc.last_column = 0;
    }
  else
    yylloc.last_column++;
#endif
  return res;
}


static void
yyungetc (int c)
{
#if YYLSP_NEEDED
  /* Wrong when C == `\n'. */
  yylloc.last_column--;
#endif
  ungetc (c, yyin);
}

static int
read_signed_integer (void)
{
  int c = yygetc ();
  int sign = 1;
  int n = 0;

  if (c == '-')
    {
      c = yygetc ();
      sign = -1;
    }

  while (isdigit (c))
    {
      n = 10 * n + (c - '0');
      c = yygetc ();
    }

  yyungetc (c);

  return sign * n;
}



/*---------------------------------------------------------------.
| Lexical analyzer returns an integer on the stack and the token |
| NUM, or the ASCII character read if not a number.  Skips all   |
| blanks and tabs, returns 0 for EOF.                            |
`---------------------------------------------------------------*/

static int
yylex (void)
{
  int c;

#if YYLSP_NEEDED
  yylloc.first_column = yylloc.last_column;
  yylloc.first_line = yylloc.last_line;
#endif

  /* Skip white space.  */
  while ((c = yygetc ()) == ' ' || c == '\t')
    {
#if YYLSP_NEEDED
      yylloc.first_column = yylloc.last_column;
      yylloc.first_line = yylloc.last_line;
#endif
    }

  /* process numbers   */
  if (c == '.' || isdigit (c))
    {
      yyungetc (c);
      yylval = read_signed_integer ();
      return NUM;
    }

  /* Return end-of-file.  */
  if (c == EOF)
    return 0;

  /* Return single chars. */
  return c;
}

static int
power (int base, int exponent)
{
  int res = 1;
  if (exponent < 0)
    exit (1);
  for (/* Niente */; exponent; --exponent)
    res *= base;
  return res;
}

int
main (int argn, const char **argv)
{
  if (argn == 2)
    yyin = fopen (argv[1], "r");
  else
    yyin = stdin;

  if (!stdin)
    {
      perror (argv[1]);
      exit (1);
    }

#if YYDEBUG
  yydebug = 1;
#endif
#if YYLSP_NEEDED
  yylloc.last_column = 0;
  yylloc.last_line = 1;
#endif
  yyparse ();
  return 0;
}
_ATEOF



# Specify the output files to avoid problems on different file systems.
$at_traceoff
$at_verbose "calc.at:364: bison calc.y -o calc.c --verbose"
echo calc.at:364 >at-check-line
( $at_traceon; bison calc.y -o calc.c --verbose ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:364: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "calc.at:364: \$CC \$CFLAGS \$CPPFLAGS calc.c -o calc"
echo calc.at:364 >at-check-line
( $at_traceon; $CC $CFLAGS $CPPFLAGS calc.c -o calc ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:364: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Test the priorities.
cat >input <<'_ATEOF'
1 + 2 * 3 = 7
1 + 2 * -3 = -5

-1^2 = -1
(-1)^2 = 1

---1 = -1

1 - 2 - 3 = -4
1 - (2 - 3) = 2

2^2^3 = 256
(2^2)^3 = 64
_ATEOF

$at_traceoff
$at_verbose "calc.at:364: ./calc <input"
echo calc.at:364 >at-check-line
( $at_traceon; ./calc <input ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:364: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Some parse errors.
cat >input <<'_ATEOF'
+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:364: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:364 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:364: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1//2
_ATEOF


$at_traceoff
$at_verbose "calc.at:364: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:364 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:364: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
error
_ATEOF


$at_traceoff
$at_verbose "calc.at:364: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:364 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:364: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1 = 2 = 3
_ATEOF


$at_traceoff
$at_verbose "calc.at:364: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:364 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:364: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'

+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:364: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:364 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:364: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


    $at_times >at-times
    )
    at_status=$?
    ;;

  18 ) # 18. calc.at:365: Calculator --yacc
    at_setup_line='calc.at:365'
    $at_verbose "18. calc.at:365: testing Calculator --yacc..."
    $at_quiet $at_n " 18: calc.at:365       $at_c"
    (
      $at_traceon


cat >calc.y <<'_ATEOF'
/* Infix notation calculator--calc */

%{
#include <config.h>
#include <stdio.h>

#if STDC_HEADERS
# include <stdlib.h>
# include <string.h>
#else
char *strcat(char *dest, const char *src);
#endif
#include <ctype.h>


static int power (int base, int exponent);
static void yyerror (const char *s);
static int yylex (void);
static int yygetc (void);
static void yyungetc (int c);

extern void perror (const char *s);
%}

/* BISON Declarations */
%token NUM

%nonassoc '=' /* comparison	       */
%left '-' '+'
%left '*' '/'
%left NEG     /* negation--unary minus */
%right '^'    /* exponentiation        */

/* Grammar follows */
%%
input:
  /* empty string */
| input line
;

line:
  '\n'
| exp '\n'
;

exp:
  NUM                { $$ = $1;             }
| exp '=' exp
  {
     if ($1 != $3)
       printf ("calc: error: %d != %d\n", $1, $3);
     $$ = $1 == $3;
  }
| exp '+' exp        { $$ = $1 + $3;        }
| exp '-' exp        { $$ = $1 - $3;        }
| exp '*' exp        { $$ = $1 * $3;        }
| exp '/' exp        { $$ = $1 / $3;        }
| '-' exp  %prec NEG { $$ = -$2;            }
| exp '^' exp        { $$ = power ($1, $3); }
| '(' exp ')'        { $$ = $2;             }
;
%%
/* The input. */
FILE *yyin;

static void
yyerror (const char *s)
{
#if YYLSP_NEEDED
  fprintf (stderr, "%d.%d:%d.%d: ",
	   yylloc.first_line, yylloc.first_column,
	   yylloc.last_line, yylloc.last_column);
#endif
  fprintf (stderr, "%s\n", s);
}

static int
yygetc (void)
{
  int res = getc (yyin);
#if YYLSP_NEEDED
  if (res == '\n')
    {
      yylloc.last_line++;
      yylloc.last_column = 0;
    }
  else
    yylloc.last_column++;
#endif
  return res;
}


static void
yyungetc (int c)
{
#if YYLSP_NEEDED
  /* Wrong when C == `\n'. */
  yylloc.last_column--;
#endif
  ungetc (c, yyin);
}

static int
read_signed_integer (void)
{
  int c = yygetc ();
  int sign = 1;
  int n = 0;

  if (c == '-')
    {
      c = yygetc ();
      sign = -1;
    }

  while (isdigit (c))
    {
      n = 10 * n + (c - '0');
      c = yygetc ();
    }

  yyungetc (c);

  return sign * n;
}



/*---------------------------------------------------------------.
| Lexical analyzer returns an integer on the stack and the token |
| NUM, or the ASCII character read if not a number.  Skips all   |
| blanks and tabs, returns 0 for EOF.                            |
`---------------------------------------------------------------*/

static int
yylex (void)
{
  int c;

#if YYLSP_NEEDED
  yylloc.first_column = yylloc.last_column;
  yylloc.first_line = yylloc.last_line;
#endif

  /* Skip white space.  */
  while ((c = yygetc ()) == ' ' || c == '\t')
    {
#if YYLSP_NEEDED
      yylloc.first_column = yylloc.last_column;
      yylloc.first_line = yylloc.last_line;
#endif
    }

  /* process numbers   */
  if (c == '.' || isdigit (c))
    {
      yyungetc (c);
      yylval = read_signed_integer ();
      return NUM;
    }

  /* Return end-of-file.  */
  if (c == EOF)
    return 0;

  /* Return single chars. */
  return c;
}

static int
power (int base, int exponent)
{
  int res = 1;
  if (exponent < 0)
    exit (1);
  for (/* Niente */; exponent; --exponent)
    res *= base;
  return res;
}

int
main (int argn, const char **argv)
{
  if (argn == 2)
    yyin = fopen (argv[1], "r");
  else
    yyin = stdin;

  if (!stdin)
    {
      perror (argv[1]);
      exit (1);
    }

#if YYDEBUG
  yydebug = 1;
#endif
#if YYLSP_NEEDED
  yylloc.last_column = 0;
  yylloc.last_line = 1;
#endif
  yyparse ();
  return 0;
}
_ATEOF



# Specify the output files to avoid problems on different file systems.
$at_traceoff
$at_verbose "calc.at:365: bison calc.y -o calc.c --yacc"
echo calc.at:365 >at-check-line
( $at_traceon; bison calc.y -o calc.c --yacc ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:365: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "calc.at:365: \$CC \$CFLAGS \$CPPFLAGS calc.c -o calc"
echo calc.at:365 >at-check-line
( $at_traceon; $CC $CFLAGS $CPPFLAGS calc.c -o calc ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:365: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Test the priorities.
cat >input <<'_ATEOF'
1 + 2 * 3 = 7
1 + 2 * -3 = -5

-1^2 = -1
(-1)^2 = 1

---1 = -1

1 - 2 - 3 = -4
1 - (2 - 3) = 2

2^2^3 = 256
(2^2)^3 = 64
_ATEOF

$at_traceoff
$at_verbose "calc.at:365: ./calc <input"
echo calc.at:365 >at-check-line
( $at_traceon; ./calc <input ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:365: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Some parse errors.
cat >input <<'_ATEOF'
+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:365: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:365 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:365: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1//2
_ATEOF


$at_traceoff
$at_verbose "calc.at:365: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:365 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:365: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
error
_ATEOF


$at_traceoff
$at_verbose "calc.at:365: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:365 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:365: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1 = 2 = 3
_ATEOF


$at_traceoff
$at_verbose "calc.at:365: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:365 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:365: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'

+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:365: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:365 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:365: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


    $at_times >at-times
    )
    at_status=$?
    ;;

  19 ) # 19. calc.at:366: Calculator --yyerror-verbose
    at_setup_line='calc.at:366'
    $at_verbose "19. calc.at:366: testing Calculator --yyerror-verbose..."
    $at_quiet $at_n " 19: calc.at:366       $at_c"
    (
      $at_traceon


cat >calc.y <<'_ATEOF'
/* Infix notation calculator--calc */

%{
#include <config.h>
#include <stdio.h>

#if STDC_HEADERS
# include <stdlib.h>
# include <string.h>
#else
char *strcat(char *dest, const char *src);
#endif
#include <ctype.h>
#define YYERROR_VERBOSE

static int power (int base, int exponent);
static void yyerror (const char *s);
static int yylex (void);
static int yygetc (void);
static void yyungetc (int c);

extern void perror (const char *s);
%}

/* BISON Declarations */
%token NUM

%nonassoc '=' /* comparison	       */
%left '-' '+'
%left '*' '/'
%left NEG     /* negation--unary minus */
%right '^'    /* exponentiation        */

/* Grammar follows */
%%
input:
  /* empty string */
| input line
;

line:
  '\n'
| exp '\n'
;

exp:
  NUM                { $$ = $1;             }
| exp '=' exp
  {
     if ($1 != $3)
       printf ("calc: error: %d != %d\n", $1, $3);
     $$ = $1 == $3;
  }
| exp '+' exp        { $$ = $1 + $3;        }
| exp '-' exp        { $$ = $1 - $3;        }
| exp '*' exp        { $$ = $1 * $3;        }
| exp '/' exp        { $$ = $1 / $3;        }
| '-' exp  %prec NEG { $$ = -$2;            }
| exp '^' exp        { $$ = power ($1, $3); }
| '(' exp ')'        { $$ = $2;             }
;
%%
/* The input. */
FILE *yyin;

static void
yyerror (const char *s)
{
#if YYLSP_NEEDED
  fprintf (stderr, "%d.%d:%d.%d: ",
	   yylloc.first_line, yylloc.first_column,
	   yylloc.last_line, yylloc.last_column);
#endif
  fprintf (stderr, "%s\n", s);
}

static int
yygetc (void)
{
  int res = getc (yyin);
#if YYLSP_NEEDED
  if (res == '\n')
    {
      yylloc.last_line++;
      yylloc.last_column = 0;
    }
  else
    yylloc.last_column++;
#endif
  return res;
}


static void
yyungetc (int c)
{
#if YYLSP_NEEDED
  /* Wrong when C == `\n'. */
  yylloc.last_column--;
#endif
  ungetc (c, yyin);
}

static int
read_signed_integer (void)
{
  int c = yygetc ();
  int sign = 1;
  int n = 0;

  if (c == '-')
    {
      c = yygetc ();
      sign = -1;
    }

  while (isdigit (c))
    {
      n = 10 * n + (c - '0');
      c = yygetc ();
    }

  yyungetc (c);

  return sign * n;
}



/*---------------------------------------------------------------.
| Lexical analyzer returns an integer on the stack and the token |
| NUM, or the ASCII character read if not a number.  Skips all   |
| blanks and tabs, returns 0 for EOF.                            |
`---------------------------------------------------------------*/

static int
yylex (void)
{
  int c;

#if YYLSP_NEEDED
  yylloc.first_column = yylloc.last_column;
  yylloc.first_line = yylloc.last_line;
#endif

  /* Skip white space.  */
  while ((c = yygetc ()) == ' ' || c == '\t')
    {
#if YYLSP_NEEDED
      yylloc.first_column = yylloc.last_column;
      yylloc.first_line = yylloc.last_line;
#endif
    }

  /* process numbers   */
  if (c == '.' || isdigit (c))
    {
      yyungetc (c);
      yylval = read_signed_integer ();
      return NUM;
    }

  /* Return end-of-file.  */
  if (c == EOF)
    return 0;

  /* Return single chars. */
  return c;
}

static int
power (int base, int exponent)
{
  int res = 1;
  if (exponent < 0)
    exit (1);
  for (/* Niente */; exponent; --exponent)
    res *= base;
  return res;
}

int
main (int argn, const char **argv)
{
  if (argn == 2)
    yyin = fopen (argv[1], "r");
  else
    yyin = stdin;

  if (!stdin)
    {
      perror (argv[1]);
      exit (1);
    }

#if YYDEBUG
  yydebug = 1;
#endif
#if YYLSP_NEEDED
  yylloc.last_column = 0;
  yylloc.last_line = 1;
#endif
  yyparse ();
  return 0;
}
_ATEOF



# Specify the output files to avoid problems on different file systems.
$at_traceoff
$at_verbose "calc.at:366: bison calc.y -o calc.c "
echo calc.at:366 >at-check-line
( $at_traceon; bison calc.y -o calc.c  ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:366: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "calc.at:366: \$CC \$CFLAGS \$CPPFLAGS calc.c -o calc"
echo calc.at:366 >at-check-line
( $at_traceon; $CC $CFLAGS $CPPFLAGS calc.c -o calc ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:366: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Test the priorities.
cat >input <<'_ATEOF'
1 + 2 * 3 = 7
1 + 2 * -3 = -5

-1^2 = -1
(-1)^2 = 1

---1 = -1

1 - 2 - 3 = -4
1 - (2 - 3) = 2

2^2^3 = 256
(2^2)^3 = 64
_ATEOF

$at_traceoff
$at_verbose "calc.at:366: ./calc <input"
echo calc.at:366 >at-check-line
( $at_traceon; ./calc <input ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:366: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Some parse errors.
cat >input <<'_ATEOF'
+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:366: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:366 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error, unexpected \`'+''
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:366: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1//2
_ATEOF


$at_traceoff
$at_verbose "calc.at:366: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:366 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error, unexpected \`'/'', expecting \`NUM' or \`'-'' or \`'(''
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:366: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
error
_ATEOF


$at_traceoff
$at_verbose "calc.at:366: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:366 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error, unexpected \`\$undefined.'
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:366: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1 = 2 = 3
_ATEOF


$at_traceoff
$at_verbose "calc.at:366: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:366 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error, unexpected \`'=''
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:366: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'

+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:366: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:366 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error, unexpected \`'+''
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:366: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


    $at_times >at-times
    )
    at_status=$?
    ;;

  20 ) # 20. calc.at:368: Calculator --locations --yyerror-verbose
    at_setup_line='calc.at:368'
    $at_verbose "20. calc.at:368: testing Calculator --locations --yyerror-verbose..."
    $at_quiet $at_n " 20: calc.at:368       $at_c"
    (
      $at_traceon


cat >calc.y <<'_ATEOF'
/* Infix notation calculator--calc */

%{
#include <config.h>
#include <stdio.h>

#if STDC_HEADERS
# include <stdlib.h>
# include <string.h>
#else
char *strcat(char *dest, const char *src);
#endif
#include <ctype.h>
#define YYERROR_VERBOSE

static int power (int base, int exponent);
static void yyerror (const char *s);
static int yylex (void);
static int yygetc (void);
static void yyungetc (int c);

extern void perror (const char *s);
%}

/* BISON Declarations */
%token NUM

%nonassoc '=' /* comparison	       */
%left '-' '+'
%left '*' '/'
%left NEG     /* negation--unary minus */
%right '^'    /* exponentiation        */

/* Grammar follows */
%%
input:
  /* empty string */
| input line
;

line:
  '\n'
| exp '\n'
;

exp:
  NUM                { $$ = $1;             }
| exp '=' exp
  {
     if ($1 != $3)
       printf ("calc: error: %d != %d\n", $1, $3);
     $$ = $1 == $3;
  }
| exp '+' exp        { $$ = $1 + $3;        }
| exp '-' exp        { $$ = $1 - $3;        }
| exp '*' exp        { $$ = $1 * $3;        }
| exp '/' exp        { $$ = $1 / $3;        }
| '-' exp  %prec NEG { $$ = -$2;            }
| exp '^' exp        { $$ = power ($1, $3); }
| '(' exp ')'        { $$ = $2;             }
;
%%
/* The input. */
FILE *yyin;

static void
yyerror (const char *s)
{
#if YYLSP_NEEDED
  fprintf (stderr, "%d.%d:%d.%d: ",
	   yylloc.first_line, yylloc.first_column,
	   yylloc.last_line, yylloc.last_column);
#endif
  fprintf (stderr, "%s\n", s);
}

static int
yygetc (void)
{
  int res = getc (yyin);
#if YYLSP_NEEDED
  if (res == '\n')
    {
      yylloc.last_line++;
      yylloc.last_column = 0;
    }
  else
    yylloc.last_column++;
#endif
  return res;
}


static void
yyungetc (int c)
{
#if YYLSP_NEEDED
  /* Wrong when C == `\n'. */
  yylloc.last_column--;
#endif
  ungetc (c, yyin);
}

static int
read_signed_integer (void)
{
  int c = yygetc ();
  int sign = 1;
  int n = 0;

  if (c == '-')
    {
      c = yygetc ();
      sign = -1;
    }

  while (isdigit (c))
    {
      n = 10 * n + (c - '0');
      c = yygetc ();
    }

  yyungetc (c);

  return sign * n;
}



/*---------------------------------------------------------------.
| Lexical analyzer returns an integer on the stack and the token |
| NUM, or the ASCII character read if not a number.  Skips all   |
| blanks and tabs, returns 0 for EOF.                            |
`---------------------------------------------------------------*/

static int
yylex (void)
{
  int c;

#if YYLSP_NEEDED
  yylloc.first_column = yylloc.last_column;
  yylloc.first_line = yylloc.last_line;
#endif

  /* Skip white space.  */
  while ((c = yygetc ()) == ' ' || c == '\t')
    {
#if YYLSP_NEEDED
      yylloc.first_column = yylloc.last_column;
      yylloc.first_line = yylloc.last_line;
#endif
    }

  /* process numbers   */
  if (c == '.' || isdigit (c))
    {
      yyungetc (c);
      yylval = read_signed_integer ();
      return NUM;
    }

  /* Return end-of-file.  */
  if (c == EOF)
    return 0;

  /* Return single chars. */
  return c;
}

static int
power (int base, int exponent)
{
  int res = 1;
  if (exponent < 0)
    exit (1);
  for (/* Niente */; exponent; --exponent)
    res *= base;
  return res;
}

int
main (int argn, const char **argv)
{
  if (argn == 2)
    yyin = fopen (argv[1], "r");
  else
    yyin = stdin;

  if (!stdin)
    {
      perror (argv[1]);
      exit (1);
    }

#if YYDEBUG
  yydebug = 1;
#endif
#if YYLSP_NEEDED
  yylloc.last_column = 0;
  yylloc.last_line = 1;
#endif
  yyparse ();
  return 0;
}
_ATEOF



# Specify the output files to avoid problems on different file systems.
$at_traceoff
$at_verbose "calc.at:368: bison calc.y -o calc.c --locations "
echo calc.at:368 >at-check-line
( $at_traceon; bison calc.y -o calc.c --locations  ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:368: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "calc.at:368: \$CC \$CFLAGS \$CPPFLAGS calc.c -o calc"
echo calc.at:368 >at-check-line
( $at_traceon; $CC $CFLAGS $CPPFLAGS calc.c -o calc ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:368: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Test the priorities.
cat >input <<'_ATEOF'
1 + 2 * 3 = 7
1 + 2 * -3 = -5

-1^2 = -1
(-1)^2 = 1

---1 = -1

1 - 2 - 3 = -4
1 - (2 - 3) = 2

2^2^3 = 256
(2^2)^3 = 64
_ATEOF

$at_traceoff
$at_verbose "calc.at:368: ./calc <input"
echo calc.at:368 >at-check-line
( $at_traceon; ./calc <input ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:368: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Some parse errors.
cat >input <<'_ATEOF'
+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:368: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:368 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "1.0:1.1: parse error, unexpected \`'+''
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:368: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1//2
_ATEOF


$at_traceoff
$at_verbose "calc.at:368: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:368 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "1.2:1.3: parse error, unexpected \`'/'', expecting \`NUM' or \`'-'' or \`'(''
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:368: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
error
_ATEOF


$at_traceoff
$at_verbose "calc.at:368: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:368 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "1.0:1.1: parse error, unexpected \`\$undefined.'
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:368: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1 = 2 = 3
_ATEOF


$at_traceoff
$at_verbose "calc.at:368: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:368 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "1.6:1.7: parse error, unexpected \`'=''
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:368: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'

+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:368: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:368 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "2.0:2.1: parse error, unexpected \`'+''
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:368: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


    $at_times >at-times
    )
    at_status=$?
    ;;

  21 ) # 21. calc.at:370: Calculator --defines --locations --name-prefix=calc --verbose --yacc --yyerror-verbose
    at_setup_line='calc.at:370'
    $at_verbose "21. calc.at:370: testing Calculator --defines --locations --name-prefix=calc --verbose --yacc --yyerror-verbose..."
    $at_quiet $at_n " 21: calc.at:370       $at_c"
    (
      $at_traceon


cat >calc.y <<'_ATEOF'
/* Infix notation calculator--calc */

%{
#include <config.h>
#include <stdio.h>

#if STDC_HEADERS
# include <stdlib.h>
# include <string.h>
#else
char *strcat(char *dest, const char *src);
#endif
#include <ctype.h>
#define YYERROR_VERBOSE

static int power (int base, int exponent);
static void yyerror (const char *s);
static int yylex (void);
static int yygetc (void);
static void yyungetc (int c);

extern void perror (const char *s);
%}

/* BISON Declarations */
%token NUM

%nonassoc '=' /* comparison	       */
%left '-' '+'
%left '*' '/'
%left NEG     /* negation--unary minus */
%right '^'    /* exponentiation        */

/* Grammar follows */
%%
input:
  /* empty string */
| input line
;

line:
  '\n'
| exp '\n'
;

exp:
  NUM                { $$ = $1;             }
| exp '=' exp
  {
     if ($1 != $3)
       printf ("calc: error: %d != %d\n", $1, $3);
     $$ = $1 == $3;
  }
| exp '+' exp        { $$ = $1 + $3;        }
| exp '-' exp        { $$ = $1 - $3;        }
| exp '*' exp        { $$ = $1 * $3;        }
| exp '/' exp        { $$ = $1 / $3;        }
| '-' exp  %prec NEG { $$ = -$2;            }
| exp '^' exp        { $$ = power ($1, $3); }
| '(' exp ')'        { $$ = $2;             }
;
%%
/* The input. */
FILE *yyin;

static void
yyerror (const char *s)
{
#if YYLSP_NEEDED
  fprintf (stderr, "%d.%d:%d.%d: ",
	   yylloc.first_line, yylloc.first_column,
	   yylloc.last_line, yylloc.last_column);
#endif
  fprintf (stderr, "%s\n", s);
}

static int
yygetc (void)
{
  int res = getc (yyin);
#if YYLSP_NEEDED
  if (res == '\n')
    {
      yylloc.last_line++;
      yylloc.last_column = 0;
    }
  else
    yylloc.last_column++;
#endif
  return res;
}


static void
yyungetc (int c)
{
#if YYLSP_NEEDED
  /* Wrong when C == `\n'. */
  yylloc.last_column--;
#endif
  ungetc (c, yyin);
}

static int
read_signed_integer (void)
{
  int c = yygetc ();
  int sign = 1;
  int n = 0;

  if (c == '-')
    {
      c = yygetc ();
      sign = -1;
    }

  while (isdigit (c))
    {
      n = 10 * n + (c - '0');
      c = yygetc ();
    }

  yyungetc (c);

  return sign * n;
}



/*---------------------------------------------------------------.
| Lexical analyzer returns an integer on the stack and the token |
| NUM, or the ASCII character read if not a number.  Skips all   |
| blanks and tabs, returns 0 for EOF.                            |
`---------------------------------------------------------------*/

static int
yylex (void)
{
  int c;

#if YYLSP_NEEDED
  yylloc.first_column = yylloc.last_column;
  yylloc.first_line = yylloc.last_line;
#endif

  /* Skip white space.  */
  while ((c = yygetc ()) == ' ' || c == '\t')
    {
#if YYLSP_NEEDED
      yylloc.first_column = yylloc.last_column;
      yylloc.first_line = yylloc.last_line;
#endif
    }

  /* process numbers   */
  if (c == '.' || isdigit (c))
    {
      yyungetc (c);
      yylval = read_signed_integer ();
      return NUM;
    }

  /* Return end-of-file.  */
  if (c == EOF)
    return 0;

  /* Return single chars. */
  return c;
}

static int
power (int base, int exponent)
{
  int res = 1;
  if (exponent < 0)
    exit (1);
  for (/* Niente */; exponent; --exponent)
    res *= base;
  return res;
}

int
main (int argn, const char **argv)
{
  if (argn == 2)
    yyin = fopen (argv[1], "r");
  else
    yyin = stdin;

  if (!stdin)
    {
      perror (argv[1]);
      exit (1);
    }

#if YYDEBUG
  yydebug = 1;
#endif
#if YYLSP_NEEDED
  yylloc.last_column = 0;
  yylloc.last_line = 1;
#endif
  yyparse ();
  return 0;
}
_ATEOF



# Specify the output files to avoid problems on different file systems.
$at_traceoff
$at_verbose "calc.at:370: bison calc.y -o calc.c --defines --locations --name-prefix=calc --verbose --yacc "
echo calc.at:370 >at-check-line
( $at_traceon; bison calc.y -o calc.c --defines --locations --name-prefix=calc --verbose --yacc  ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:370: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "calc.at:370: \$CC \$CFLAGS \$CPPFLAGS calc.c -o calc"
echo calc.at:370 >at-check-line
( $at_traceon; $CC $CFLAGS $CPPFLAGS calc.c -o calc ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:370: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Test the priorities.
cat >input <<'_ATEOF'
1 + 2 * 3 = 7
1 + 2 * -3 = -5

-1^2 = -1
(-1)^2 = 1

---1 = -1

1 - 2 - 3 = -4
1 - (2 - 3) = 2

2^2^3 = 256
(2^2)^3 = 64
_ATEOF

$at_traceoff
$at_verbose "calc.at:370: ./calc <input"
echo calc.at:370 >at-check-line
( $at_traceon; ./calc <input ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:370: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Some parse errors.
cat >input <<'_ATEOF'
+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:370: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:370 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "1.0:1.1: parse error, unexpected \`'+''
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:370: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1//2
_ATEOF


$at_traceoff
$at_verbose "calc.at:370: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:370 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "1.2:1.3: parse error, unexpected \`'/'', expecting \`NUM' or \`'-'' or \`'(''
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:370: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
error
_ATEOF


$at_traceoff
$at_verbose "calc.at:370: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:370 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "1.0:1.1: parse error, unexpected \`\$undefined.'
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:370: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1 = 2 = 3
_ATEOF


$at_traceoff
$at_verbose "calc.at:370: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:370 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "1.6:1.7: parse error, unexpected \`'=''
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:370: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'

+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:370: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:370 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "2.0:2.1: parse error, unexpected \`'+''
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:370: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


    $at_times >at-times
    )
    at_status=$?
    ;;

  22 ) # 22. calc.at:372: Calculator --debug
    at_setup_line='calc.at:372'
    $at_verbose "22. calc.at:372: testing Calculator --debug..."
    $at_quiet $at_n " 22: calc.at:372       $at_c"
    (
      $at_traceon


cat >calc.y <<'_ATEOF'
/* Infix notation calculator--calc */

%{
#include <config.h>
#include <stdio.h>

#if STDC_HEADERS
# include <stdlib.h>
# include <string.h>
#else
char *strcat(char *dest, const char *src);
#endif
#include <ctype.h>


static int power (int base, int exponent);
static void yyerror (const char *s);
static int yylex (void);
static int yygetc (void);
static void yyungetc (int c);

extern void perror (const char *s);
%}

/* BISON Declarations */
%token NUM

%nonassoc '=' /* comparison	       */
%left '-' '+'
%left '*' '/'
%left NEG     /* negation--unary minus */
%right '^'    /* exponentiation        */

/* Grammar follows */
%%
input:
  /* empty string */
| input line
;

line:
  '\n'
| exp '\n'
;

exp:
  NUM                { $$ = $1;             }
| exp '=' exp
  {
     if ($1 != $3)
       printf ("calc: error: %d != %d\n", $1, $3);
     $$ = $1 == $3;
  }
| exp '+' exp        { $$ = $1 + $3;        }
| exp '-' exp        { $$ = $1 - $3;        }
| exp '*' exp        { $$ = $1 * $3;        }
| exp '/' exp        { $$ = $1 / $3;        }
| '-' exp  %prec NEG { $$ = -$2;            }
| exp '^' exp        { $$ = power ($1, $3); }
| '(' exp ')'        { $$ = $2;             }
;
%%
/* The input. */
FILE *yyin;

static void
yyerror (const char *s)
{
#if YYLSP_NEEDED
  fprintf (stderr, "%d.%d:%d.%d: ",
	   yylloc.first_line, yylloc.first_column,
	   yylloc.last_line, yylloc.last_column);
#endif
  fprintf (stderr, "%s\n", s);
}

static int
yygetc (void)
{
  int res = getc (yyin);
#if YYLSP_NEEDED
  if (res == '\n')
    {
      yylloc.last_line++;
      yylloc.last_column = 0;
    }
  else
    yylloc.last_column++;
#endif
  return res;
}


static void
yyungetc (int c)
{
#if YYLSP_NEEDED
  /* Wrong when C == `\n'. */
  yylloc.last_column--;
#endif
  ungetc (c, yyin);
}

static int
read_signed_integer (void)
{
  int c = yygetc ();
  int sign = 1;
  int n = 0;

  if (c == '-')
    {
      c = yygetc ();
      sign = -1;
    }

  while (isdigit (c))
    {
      n = 10 * n + (c - '0');
      c = yygetc ();
    }

  yyungetc (c);

  return sign * n;
}



/*---------------------------------------------------------------.
| Lexical analyzer returns an integer on the stack and the token |
| NUM, or the ASCII character read if not a number.  Skips all   |
| blanks and tabs, returns 0 for EOF.                            |
`---------------------------------------------------------------*/

static int
yylex (void)
{
  int c;

#if YYLSP_NEEDED
  yylloc.first_column = yylloc.last_column;
  yylloc.first_line = yylloc.last_line;
#endif

  /* Skip white space.  */
  while ((c = yygetc ()) == ' ' || c == '\t')
    {
#if YYLSP_NEEDED
      yylloc.first_column = yylloc.last_column;
      yylloc.first_line = yylloc.last_line;
#endif
    }

  /* process numbers   */
  if (c == '.' || isdigit (c))
    {
      yyungetc (c);
      yylval = read_signed_integer ();
      return NUM;
    }

  /* Return end-of-file.  */
  if (c == EOF)
    return 0;

  /* Return single chars. */
  return c;
}

static int
power (int base, int exponent)
{
  int res = 1;
  if (exponent < 0)
    exit (1);
  for (/* Niente */; exponent; --exponent)
    res *= base;
  return res;
}

int
main (int argn, const char **argv)
{
  if (argn == 2)
    yyin = fopen (argv[1], "r");
  else
    yyin = stdin;

  if (!stdin)
    {
      perror (argv[1]);
      exit (1);
    }

#if YYDEBUG
  yydebug = 1;
#endif
#if YYLSP_NEEDED
  yylloc.last_column = 0;
  yylloc.last_line = 1;
#endif
  yyparse ();
  return 0;
}
_ATEOF



# Specify the output files to avoid problems on different file systems.
$at_traceoff
$at_verbose "calc.at:372: bison calc.y -o calc.c --debug"
echo calc.at:372 >at-check-line
( $at_traceon; bison calc.y -o calc.c --debug ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:372: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "calc.at:372: \$CC \$CFLAGS \$CPPFLAGS calc.c -o calc"
echo calc.at:372 >at-check-line
( $at_traceon; $CC $CFLAGS $CPPFLAGS calc.c -o calc ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:372: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Test the priorities.
cat >input <<'_ATEOF'
1 + 2 * 3 = 7
1 + 2 * -3 = -5

-1^2 = -1
(-1)^2 = 1

---1 = -1

1 - 2 - 3 = -4
1 - (2 - 3) = 2

2^2^3 = 256
(2^2)^3 = 64
_ATEOF

$at_traceoff
$at_verbose "calc.at:372: calc ./input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:372 >at-check-line
( $at_traceon; calc ./input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   1) ;;
   *) $at_verbose "calc.at:372: exit code was $at_status, expected 1" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Some parse errors.
cat >input <<'_ATEOF'
+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:372: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:372 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:372: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1//2
_ATEOF


$at_traceoff
$at_verbose "calc.at:372: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:372 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:372: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
error
_ATEOF


$at_traceoff
$at_verbose "calc.at:372: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:372 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:372: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1 = 2 = 3
_ATEOF


$at_traceoff
$at_verbose "calc.at:372: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:372 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:372: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'

+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:372: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:372 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "parse error
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:372: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


    $at_times >at-times
    )
    at_status=$?
    ;;

  23 ) # 23. calc.at:373: Calculator --debug --defines --locations --name-prefix=calc --verbose --yacc --yyerror-verbose
    at_setup_line='calc.at:373'
    $at_verbose "23. calc.at:373: testing Calculator --debug --defines --locations --name-prefix=calc --verbose --yacc --yyerror-verbose..."
    $at_quiet $at_n " 23: calc.at:373       $at_c"
    (
      $at_traceon


cat >calc.y <<'_ATEOF'
/* Infix notation calculator--calc */

%{
#include <config.h>
#include <stdio.h>

#if STDC_HEADERS
# include <stdlib.h>
# include <string.h>
#else
char *strcat(char *dest, const char *src);
#endif
#include <ctype.h>
#define YYERROR_VERBOSE

static int power (int base, int exponent);
static void yyerror (const char *s);
static int yylex (void);
static int yygetc (void);
static void yyungetc (int c);

extern void perror (const char *s);
%}

/* BISON Declarations */
%token NUM

%nonassoc '=' /* comparison	       */
%left '-' '+'
%left '*' '/'
%left NEG     /* negation--unary minus */
%right '^'    /* exponentiation        */

/* Grammar follows */
%%
input:
  /* empty string */
| input line
;

line:
  '\n'
| exp '\n'
;

exp:
  NUM                { $$ = $1;             }
| exp '=' exp
  {
     if ($1 != $3)
       printf ("calc: error: %d != %d\n", $1, $3);
     $$ = $1 == $3;
  }
| exp '+' exp        { $$ = $1 + $3;        }
| exp '-' exp        { $$ = $1 - $3;        }
| exp '*' exp        { $$ = $1 * $3;        }
| exp '/' exp        { $$ = $1 / $3;        }
| '-' exp  %prec NEG { $$ = -$2;            }
| exp '^' exp        { $$ = power ($1, $3); }
| '(' exp ')'        { $$ = $2;             }
;
%%
/* The input. */
FILE *yyin;

static void
yyerror (const char *s)
{
#if YYLSP_NEEDED
  fprintf (stderr, "%d.%d:%d.%d: ",
	   yylloc.first_line, yylloc.first_column,
	   yylloc.last_line, yylloc.last_column);
#endif
  fprintf (stderr, "%s\n", s);
}

static int
yygetc (void)
{
  int res = getc (yyin);
#if YYLSP_NEEDED
  if (res == '\n')
    {
      yylloc.last_line++;
      yylloc.last_column = 0;
    }
  else
    yylloc.last_column++;
#endif
  return res;
}


static void
yyungetc (int c)
{
#if YYLSP_NEEDED
  /* Wrong when C == `\n'. */
  yylloc.last_column--;
#endif
  ungetc (c, yyin);
}

static int
read_signed_integer (void)
{
  int c = yygetc ();
  int sign = 1;
  int n = 0;

  if (c == '-')
    {
      c = yygetc ();
      sign = -1;
    }

  while (isdigit (c))
    {
      n = 10 * n + (c - '0');
      c = yygetc ();
    }

  yyungetc (c);

  return sign * n;
}



/*---------------------------------------------------------------.
| Lexical analyzer returns an integer on the stack and the token |
| NUM, or the ASCII character read if not a number.  Skips all   |
| blanks and tabs, returns 0 for EOF.                            |
`---------------------------------------------------------------*/

static int
yylex (void)
{
  int c;

#if YYLSP_NEEDED
  yylloc.first_column = yylloc.last_column;
  yylloc.first_line = yylloc.last_line;
#endif

  /* Skip white space.  */
  while ((c = yygetc ()) == ' ' || c == '\t')
    {
#if YYLSP_NEEDED
      yylloc.first_column = yylloc.last_column;
      yylloc.first_line = yylloc.last_line;
#endif
    }

  /* process numbers   */
  if (c == '.' || isdigit (c))
    {
      yyungetc (c);
      yylval = read_signed_integer ();
      return NUM;
    }

  /* Return end-of-file.  */
  if (c == EOF)
    return 0;

  /* Return single chars. */
  return c;
}

static int
power (int base, int exponent)
{
  int res = 1;
  if (exponent < 0)
    exit (1);
  for (/* Niente */; exponent; --exponent)
    res *= base;
  return res;
}

int
main (int argn, const char **argv)
{
  if (argn == 2)
    yyin = fopen (argv[1], "r");
  else
    yyin = stdin;

  if (!stdin)
    {
      perror (argv[1]);
      exit (1);
    }

#if YYDEBUG
  yydebug = 1;
#endif
#if YYLSP_NEEDED
  yylloc.last_column = 0;
  yylloc.last_line = 1;
#endif
  yyparse ();
  return 0;
}
_ATEOF



# Specify the output files to avoid problems on different file systems.
$at_traceoff
$at_verbose "calc.at:373: bison calc.y -o calc.c --debug --defines --locations --name-prefix=calc --verbose --yacc "
echo calc.at:373 >at-check-line
( $at_traceon; bison calc.y -o calc.c --debug --defines --locations --name-prefix=calc --verbose --yacc  ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:373: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

$at_traceoff
$at_verbose "calc.at:373: \$CC \$CFLAGS \$CPPFLAGS calc.c -o calc"
echo calc.at:373 >at-check-line
( $at_traceon; $CC $CFLAGS $CPPFLAGS calc.c -o calc ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:373: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Test the priorities.
cat >input <<'_ATEOF'
1 + 2 * 3 = 7
1 + 2 * -3 = -5

-1^2 = -1
(-1)^2 = 1

---1 = -1

1 - 2 - 3 = -4
1 - (2 - 3) = 2

2^2^3 = 256
(2^2)^3 = 64
_ATEOF

$at_traceoff
$at_verbose "calc.at:373: calc ./input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:373 >at-check-line
( $at_traceon; calc ./input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   1) ;;
   *) $at_verbose "calc.at:373: exit code was $at_status, expected 1" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


# Some parse errors.
cat >input <<'_ATEOF'
+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:373: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:373 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "1.0:1.1: parse error, unexpected \`'+''
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:373: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1//2
_ATEOF


$at_traceoff
$at_verbose "calc.at:373: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:373 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "1.2:1.3: parse error, unexpected \`'/'', expecting \`NUM' or \`'-'' or \`'(''
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:373: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
error
_ATEOF


$at_traceoff
$at_verbose "calc.at:373: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:373 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "1.0:1.1: parse error, unexpected \`\$undefined.'
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:373: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'
1 = 2 = 3
_ATEOF


$at_traceoff
$at_verbose "calc.at:373: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:373 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "1.6:1.7: parse error, unexpected \`'=''
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:373: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon

cat >input <<'_ATEOF'

+1
_ATEOF


$at_traceoff
$at_verbose "calc.at:373: ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2"
echo calc.at:373 >at-check-line
( $at_traceon; ./calc <input 2>&1 >/dev/null | grep 'parse error' >&2 ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
echo >>at-stderr; echo "2.0:2.1: parse error, unexpected \`'+''
" | $at_diff - at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "calc.at:373: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


    $at_times >at-times
    )
    at_status=$?
    ;;

  banner-3 ) # Banner 3. regression.at:19
    cat <<\_ATEOF

Regression tests.

_ATEOF
    ;;

  24 ) # 24. regression.at:26: Duplicate string
    at_setup_line='regression.at:26'
    $at_verbose "24. regression.at:26: testing Duplicate string..."
    $at_quiet $at_n " 24: regression.at:26  $at_c"
    (
      $at_traceon


cat >duplicate.y <<'_ATEOF'
/* `Bison -v' used to dump core when two tokens are defined with the same
   string, as LE and GE below. */

%token NUM
%token LE "<="
%token GE "<="

%%
exp: '(' exp ')' | NUM ;
%%
_ATEOF


$at_traceoff
$at_verbose "regression.at:41: bison -v duplicate.y -o duplicate.c"
echo regression.at:41 >at-check-line
( $at_traceon; bison -v duplicate.y -o duplicate.c ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
(echo stderr:; cat at-stderr) >&5
(echo stdout:; cat at-stdout) >&5
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "regression.at:41: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


    $at_times >at-times
    )
    at_status=$?
    ;;

  25 ) # 25. regression.at:52: %union and --defines
    at_setup_line='regression.at:52'
    $at_verbose "25. regression.at:52: testing %union and --defines..."
    $at_quiet $at_n " 25: regression.at:52  $at_c"
    (
      $at_traceon


cat >union.y <<'_ATEOF'
%union
{
  int   integer;
  char *string ;
}
%%
exp: {};
_ATEOF


$at_traceoff
$at_verbose "regression.at:64: bison --defines union.y"
echo regression.at:64 >at-check-line
( $at_traceon; bison --defines union.y ) >at-stdout 2>at-stder1
at_status=$?
egrep '^ *\+' at-stder1 >&2
egrep -v '^ *\+' at-stder1 >at-stderr
at_failed=false
$at_diff $at_devnull  at-stderr >&5 || at_failed=:
$at_diff $at_devnull  at-stdout >&5 || at_failed=:
case $at_status in
   77) exit 77;;
   0) ;;
   *) $at_verbose "regression.at:64: exit code was $at_status, expected 0" >&2
      at_failed=:;;
esac

$at_failed && exit 1
$at_traceon


    $at_times >at-times
    )
    at_status=$?
    ;;


  * )
    echo $as_me: no such test: $at_test
    continue
    ;;
  esac
  case $at_test in
    banner-*) ;;
    *)
      if test ! -f at-check-line; then
        sed "s/^ */$as_me: warning: /" <<_ATEOF
        A failure happened in a test group before any test could be
        run. This means that test suite is improperly designed.  Please
        report this failure to <$at_bugreport>.
_ATEOF
    	echo "$at_setup_line" >at-check-line
      fi
      at_test_count=`expr 1 + $at_test_count`
      $at_verbose $at_n "$at_test. $at_setup_line: $at_c"
      case $at_status in
        0) at_msg="ok"
           ;;
        77) at_msg="ok (skipped near \``cat at-check-line`')"
            at_skip_list="$at_skip_list $at_test"
            ;;
        *) at_msg="FAILED near \``cat at-check-line`'"
           at_fail_list="$at_fail_list $at_test"
           ;;
      esac
      echo $at_msg
      at_log_msg="$at_test. $at_setup_line: $at_msg"
      # If the test failed, at-times is not available.
      test -f at-times && at_log_msg="$at_log_msg	(`sed 1d at-times`)"
      echo "$at_log_msg" >&6
      $at_stop_on_error && test -n "$at_fail_list" && break
      ;;
  esac
done

at_stop_date=`date`
at_stop_time=`(date +%s) 2>/dev/null`
echo "$as_me: ending at: $at_stop_date" >&6
at_duration_s=`(expr $at_stop_time - $at_start_time) 2>/dev/null`
at_duration_m=`(expr $at_duration_s / 60) 2>/dev/null`
at_duration_h=`(expr $at_duration_m / 60) 2>/dev/null`
at_duration_s=`(expr $at_duration_s % 60) 2>/dev/null`
at_duration_m=`(expr $at_duration_m % 60) 2>/dev/null`
at_duration="${at_duration_h}h ${at_duration_m}m ${at_duration_s}s"
if test "$at_duration" != "h m s"; then
  echo "$as_me: test suite duration: $at_duration" >&6
fi

# Cleanup everything unless the user wants the files.
$at_debug || rm -rf $at_data_files

# Wrap up the test suite with summary statistics.
at_skip_count=`set dummy $at_skip_list; shift; echo $#`
at_fail_count=`set dummy $at_fail_list; shift; echo $#`
if test $at_fail_count = 0; then
  if test $at_skip_count = 0; then
    sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## All $at_test_count tests were successful. ##
_ASBOX
  else
    sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## All $at_test_count tests were successful ($at_skip_count skipped). ##
_ASBOX
  fi
elif test $at_debug = false; then
  if $at_stop_on_error; then
    cat <<\_ASBOX
## ------------------------------------------------------------ ##
## ERROR: One of the tests failed, inhibiting subsequent tests. ##
## ------------------------------------------------------------ ##
_ASBOX
  else
    sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## ERROR: Suite unsuccessful, $at_fail_count of $at_test_count tests failed. ##
_ASBOX
  fi

  # Remove any debugging script resulting from a previous run.
  rm -f debug-*.sh
  echo
  echo $at_n "Writing \`debug-NN.sh' scripts, with NN =$at_c"
  for at_group in $at_fail_list; do
    echo $at_n " $at_group$at_c"
    ( echo "#! /bin/sh"
      echo 'exec ${CONFIG_SHELL-'"$SHELL"'}' "$0" \
           '-v -d' "$at_debug_args" "$at_group" '${1+"$@"}'
      echo 'exit 1'
    ) >debug-$at_group.sh
    chmod +x debug-$at_group.sh
  done
  echo ', done'
  echo
  echo 'You may investigate any problem if you feel able to do so, in which'
  echo 'case the test suite provides a good starting point.'
  echo
  echo 'Now, failed tests will be executed again, verbosely, and logged'
  echo 'in the file '$as_me'.log.'

  {
    echo
    echo
    cat <<\_ASBOX
## ------------------------ ##
## Summary of the failures. ##
## ------------------------ ##
_ASBOX

    # Summary of failed and skipped tests.
    if test $at_fail_count != 0; then
      echo "Failed tests:"
      $SHELL $0 $at_fail_list --help
      echo
    fi
    if test $at_skip_count != 0; then
      echo "Skipped tests:"
      $SHELL $0 $at_skip_list --help
      echo
    fi
    echo

    cat <<\_ASBOX
## -------------------------------------- ##
## Verbosely re-running the failing tests ##
## -------------------------------------- ##
_ASBOX
    echo
  } >&6

  $SHELL $0 -v -d $at_fail_list 2>&1 | tee -a $as_me.log
  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## $as_me.log is created. ##
_ASBOX

  echo
  echo "Please send \`$as_me.log' to <$at_bugreport>, along with all"
  echo "information you think might help."
  exit 1
fi

exit 0
