#! /bin/sh
# Generated from run.at by GNU Autoconf 2.63.
#
# Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
# Free Software Foundation, Inc.
# This test suite is free software; the Free Software Foundation gives
# unlimited permission to copy, distribute and modify it.
## --------------------- ##
## M4sh Initialization.  ##
## --------------------- ##

# Be more Bourne compatible
DUALCASE=1; export DUALCASE # for MKS sh
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '${1+"$@"}'='"$@"'
  setopt NO_GLOB_SUBST
else
  case `(set -o) 2>/dev/null` in
  *posix*) set -o posix ;;
esac

fi




# PATH needs CR
# 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

as_nl='
'
export as_nl
# Printing a long string crashes Solaris 7 /usr/bin/printf.
as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
if (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='printf %s\n'
  as_echo_n='printf %s'
else
  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
    as_echo_n='/usr/ucb/echo -n'
  else
    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
    as_echo_n_body='eval
      arg=$1;
      case $arg in
      *"$as_nl"*)
	expr "X$arg" : "X\\(.*\\)$as_nl";
	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
      esac;
      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
    '
    export as_echo_n_body
    as_echo_n='sh -c $as_echo_n_body as_echo'
  fi
  export as_echo_body
  as_echo='sh -c $as_echo_body as_echo'
fi

# The user is always right.
if test "${PATH_SEPARATOR+set}" != set; then
  PATH_SEPARATOR=:
  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
      PATH_SEPARATOR=';'
  }
fi

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


# IFS
# We need space, tab and new line, in precisely that order.  Quoting is
# there to prevent editors from complaining about space-tab.
# (If _AS_PATH_WALK were called with IFS unset, it would disable word
# splitting by setting IFS to empty value.)
IFS=" ""	$as_nl"

# Find who we are.  Look in the path if we contain no directory separator.
case $0 in
  *[\\/]* ) as_myself=$0 ;;
  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
done
IFS=$as_save_IFS

     ;;
esac
# We did not find ourselves, most probably we were run as `sh COMMAND'
# in which case we are not to be found in the path.
if test "x$as_myself" = x; then
  as_myself=$0
fi
if test ! -f "$as_myself"; then
  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
  { (exit 1); exit 1; }
fi

# Work around bugs in pre-3.0 UWIN ksh.
for as_var in ENV MAIL MAILPATH
do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
done
PS1='$ '
PS2='> '
PS4='+ '

# NLS nuisances.
LC_ALL=C
export LC_ALL
LANGUAGE=C
export LANGUAGE

# Required to use basename.
if expr a : '\(a\)' >/dev/null 2>&1 &&
   test "X`expr 00001 : '.*\(...\)'`" = X001; then
  as_expr=expr
else
  as_expr=false
fi

if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
  as_basename=basename
else
  as_basename=false
fi


# Name of the executable.
as_me=`$as_basename -- "$0" ||
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
	 X"$0" : 'X\(//\)$' \| \
	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X/"$0" |
    sed '/^.*\/\([^/][^/]*\)\/*$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`

# CDPATH.
$as_unset CDPATH


if test "x$CONFIG_SHELL" = x; then
  if (eval ":") 2>/dev/null; then
  as_have_required=yes
else
  as_have_required=no
fi

  if test $as_have_required = yes &&	 (eval ":
(as_func_return () {
  (exit \$1)
}
as_func_success () {
  as_func_return 0
}
as_func_failure () {
  as_func_return 1
}
as_func_ret_success () {
  return 0
}
as_func_ret_failure () {
  return 1
}

exitcode=0
if as_func_success; then
  :
else
  exitcode=1
  echo as_func_success failed.
fi

if as_func_failure; then
  exitcode=1
  echo as_func_failure succeeded.
fi

if as_func_ret_success; then
  :
else
  exitcode=1
  echo as_func_ret_success failed.
fi

if as_func_ret_failure; then
  exitcode=1
  echo as_func_ret_failure succeeded.
fi

if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
  :
else
  exitcode=1
  echo positional parameters were not saved.
fi

test \$exitcode = 0) || { (exit 1); exit 1; }

(
  as_lineno_1=\$LINENO
  as_lineno_2=\$LINENO
  test \"x\$as_lineno_1\" != \"x\$as_lineno_2\" &&
  test \"x\`expr \$as_lineno_1 + 1\`\" = \"x\$as_lineno_2\") || { (exit 1); exit 1; }
") 2> /dev/null; then
  :
else
  as_candidate_shells=
    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  case $as_dir in
	 /*)
	   for as_base in sh bash ksh sh5; do
	     as_candidate_shells="$as_candidate_shells $as_dir/$as_base"
	   done;;
       esac
done
IFS=$as_save_IFS


      for as_shell in $as_candidate_shells $SHELL; do
	 # Try only shells that exist, to save several forks.
	 if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
		{ ("$as_shell") 2> /dev/null <<\_ASEOF
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '${1+"$@"}'='"$@"'
  setopt NO_GLOB_SUBST
else
  case `(set -o) 2>/dev/null` in
  *posix*) set -o posix ;;
esac

fi


:
_ASEOF
}; then
  CONFIG_SHELL=$as_shell
	       as_have_required=yes
	       if { "$as_shell" 2> /dev/null <<\_ASEOF
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '${1+"$@"}'='"$@"'
  setopt NO_GLOB_SUBST
else
  case `(set -o) 2>/dev/null` in
  *posix*) set -o posix ;;
esac

fi


:
(as_func_return () {
  (exit $1)
}
as_func_success () {
  as_func_return 0
}
as_func_failure () {
  as_func_return 1
}
as_func_ret_success () {
  return 0
}
as_func_ret_failure () {
  return 1
}

exitcode=0
if as_func_success; then
  :
else
  exitcode=1
  echo as_func_success failed.
fi

if as_func_failure; then
  exitcode=1
  echo as_func_failure succeeded.
fi

if as_func_ret_success; then
  :
else
  exitcode=1
  echo as_func_ret_success failed.
fi

if as_func_ret_failure; then
  exitcode=1
  echo as_func_ret_failure succeeded.
fi

if ( set x; as_func_ret_success y && test x = "$1" ); then
  :
else
  exitcode=1
  echo positional parameters were not saved.
fi

test $exitcode = 0) || { (exit 1); exit 1; }

(
  as_lineno_1=$LINENO
  as_lineno_2=$LINENO
  test "x$as_lineno_1" != "x$as_lineno_2" &&
  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2") || { (exit 1); exit 1; }

_ASEOF
}; then
  break
fi

fi

      done

      if test "x$CONFIG_SHELL" != x; then
  for as_var in BASH_ENV ENV
	do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
	done
	export CONFIG_SHELL
	exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}
fi


    if test $as_have_required = no; then
  echo This script requires a shell more modern than all the
      echo shells that I found on your system.  Please install a
      echo modern shell, or manually run the script under such a
      echo shell if you do have one.
      { (exit 1); exit 1; }
fi


fi

fi



(eval "as_func_return () {
  (exit \$1)
}
as_func_success () {
  as_func_return 0
}
as_func_failure () {
  as_func_return 1
}
as_func_ret_success () {
  return 0
}
as_func_ret_failure () {
  return 1
}

exitcode=0
if as_func_success; then
  :
else
  exitcode=1
  echo as_func_success failed.
fi

if as_func_failure; then
  exitcode=1
  echo as_func_failure succeeded.
fi

if as_func_ret_success; then
  :
else
  exitcode=1
  echo as_func_ret_success failed.
fi

if as_func_ret_failure; then
  exitcode=1
  echo as_func_ret_failure succeeded.
fi

if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
  :
else
  exitcode=1
  echo positional parameters were not saved.
fi

test \$exitcode = 0") || {
  echo No shell found that supports shell functions.
  echo Please tell bug-autoconf@gnu.org about your system,
  echo including any error possibly output before this message.
  echo This can help us improve future autoconf versions.
  echo Configuration will now proceed without shell functions.
}



  as_lineno_1=$LINENO
  as_lineno_2=$LINENO
  test "x$as_lineno_1" != "x$as_lineno_2" &&
  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {

  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
  # uniformly replaced by the line number.  The first 'sed' inserts a
  # line-number line after each line using $LINENO; the second 'sed'
  # does the real work.  The second script uses 'N' to pair each
  # line-number line with the line containing $LINENO, and appends
  # trailing '-' during substitution so that $LINENO is not a special
  # case at line end.
  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
  # scripts with optimization help from Paolo Bonzini.  Blame Lee
  # E. McMahon (1931-1989) for sed's syntax.  :-)
  sed -n '
    p
    /[$]LINENO/=
  ' <$as_myself |
    sed '
      s/[$]LINENO.*/&-/
      t lineno
      b
      :lineno
      N
      :loop
      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
      t loop
      s/-\n.*//
    ' >$as_me.lineno &&
  chmod +x "$as_me.lineno" ||
    { { $as_echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
$as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
   { (exit 1); exit 1; }; }

  # Don't try to exec as it changes $[0], causing all sort of problems
  # (the dirname of $[0] is not the place where we might find the
  # original and so on.  Autoconf is especially sensitive to this).
  . "./$as_me.lineno"
  # Exit status is that of the last command.
  exit
}


if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
  as_dirname=dirname
else
  as_dirname=false
fi

ECHO_C= ECHO_N= ECHO_T=
case `echo -n x` in
-n*)
  case `echo 'x\c'` in
  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
  *)   ECHO_C='\c';;
  esac;;
*)
  ECHO_N='-n';;
esac
if expr a : '\(a\)' >/dev/null 2>&1 &&
   test "X`expr 00001 : '.*\(...\)'`" = X001; then
  as_expr=expr
else
  as_expr=false
fi

rm -f conf$$ conf$$.exe conf$$.file
if test -d conf$$.dir; then
  rm -f conf$$.dir/conf$$.file
else
  rm -f conf$$.dir
  mkdir conf$$.dir 2>/dev/null
fi
if (echo >conf$$.file) 2>/dev/null; then
  if ln -s conf$$.file conf$$ 2>/dev/null; then
    as_ln_s='ln -s'
    # ... but there are two gotchas:
    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
    # In both cases, we have to default to `cp -p'.
    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
      as_ln_s='cp -p'
  elif ln conf$$.file conf$$ 2>/dev/null; then
    as_ln_s=ln
  else
    as_ln_s='cp -p'
  fi
else
  as_ln_s='cp -p'
fi
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
rmdir conf$$.dir 2>/dev/null

if mkdir -p . 2>/dev/null; then
  as_mkdir_p=:
else
  test -d ./-p && rmdir ./-p
  as_mkdir_p=false
fi

if test -x / >/dev/null 2>&1; then
  as_test_x='test -x'
else
  if ls -dL / >/dev/null 2>&1; then
    as_ls_L_option=L
  else
    as_ls_L_option=
  fi
  as_test_x='
    eval sh -c '\''
      if test -d "$1"; then
	test -d "$1/.";
      else
	case $1 in
	-*)set "./$1";;
	esac;
	case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
	???[sx]*):;;*)false;;esac;fi
    '\'' sh
  '
fi
as_executable_p=$as_test_x

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

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





SHELL=${CONFIG_SHELL-/bin/sh}

# How were we run?
at_cli_args="$@"


# 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_p=false
(times) >/dev/null 2>&1 && at_times_p=:

# CLI Arguments to pass to the debugging scripts.
at_debug_args=
# -e sets to true
at_errexit_p=false
# Shall we be verbose?  ':' means no, empty means yes.
at_verbose=:
at_quiet=

# Shall we keep the debug scripts?  Must be `:' when the suite is
# run by a debug script, so that the script doesn't remove itself.
at_debug_p=false
# Display help message?
at_help_p=false
# Display the version message?
at_version_p=false
# List test groups?
at_list_p=false
# --clean
at_clean=false
# Test groups to run
at_groups=
# Whether a write failure occurred
at_write_fail=0

# The directory we run the suite in.  Default to . if no -C option.
at_dir=`pwd`
# An absolute reference to this testsuite script.
case $as_myself in
  [\\/]* | ?:[\\/]* ) at_myself=$as_myself ;;
  * ) at_myself=$at_dir/$as_myself ;;
esac
# Whether -C is in effect.
at_change_dir=false

# List of the tested programs.
at_tested='cobc'
# List of the all the test groups.
at_groups_all=' 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210'
# As many question marks as there are digits in the last test group number.
# Used to normalize the test group numbers so that `ls' lists them in
# numerical order.
at_format='???'
# Description of all the test groups.
at_help_all="1;fundamental.at:23;DISPLAY literals;;
2;fundamental.at:60;DISPLAY literals, DECIMAL-POINT is COMMA;;
3;fundamental.at:88;Hexadecimal literal;;
4;fundamental.at:124;DISPLAY data items with VALUE clause;;
5;fundamental.at:169;DISPLAY data items with MOVE statement;;
6;fundamental.at:215;GLOBAL at same level;;
7;fundamental.at:263;GLOBAL at lower level;;
8;subscripts.at:28;non-numeric subscript;;
9;subscripts.at:56;The range of subscripts;;
10;subscripts.at:96;Subscript out of bounds (1);;
11;subscripts.at:120;Subscript out of bounds (2);;
12;subscripts.at:143;Subscript out of bounds (3-1);;
13;subscripts.at:166;Subscript out of bounds (3-2);;
14;subscripts.at:189;Subscript out of bounds (3-3);;
15;subscripts.at:212;Subscript out of bounds (3-4);;
16;subscripts.at:235;Value of DEPENDING ON N out of bounds (lower);;
17;subscripts.at:259;Value of DEPENDING ON N out of bounds (upper);;
18;subscripts.at:283;Subscript bounds with ODO (lower);;
19;subscripts.at:306;Subscript bounds with ODO (upper);;
20;subscripts.at:329;Subscript bounds with ODO;;
21;subscripts.at:355;Subscript by arithmetic expression;;
22;subscripts.at:378;Subscript out of bounds in MOVE (1);;
23;subscripts.at:402;Subscript out of bounds in MOVE (2);;
24;ref-mod.at:35;Separate sign positions;;
25;ref-mod.at:60;Static reference modification;;
26;ref-mod.at:90;Dynamic reference modification;;
27;ref-mod.at:121;Static out of bounds;;
28;ref-mod.at:150;Offset underflow;;
29;ref-mod.at:172;Offset overflow;;
30;ref-mod.at:194;Length underflow;;
31;ref-mod.at:216;Length overflow;;
32;ref-mod.at:241;Offset out of bounds in MOVE (1);;
33;ref-mod.at:264;Offset out of bounds in MOVE (2);;
34;accept.at:23;ACCEPT;;
35;initialize.at:27;INITIALIZE group entry with OCCURS;;
36;initialize.at:52;INITIALIZE OCCURS with numeric edited;;
37;initialize.at:75;INITIALIZE complex group (1);;
38;initialize.at:99;INITIALIZE complex group (2);;
39;initialize.at:123;INITIALIZE with REDEFINES;;
40;misc.at:21;Source file not found;;
41;misc.at:30;Comma separator without space;;
42;misc.at:47;LOCAL-STORAGE;;
43;misc.at:89;EXTERNAL data item;;
44;misc.at:131;EXTERNAL AS data item;;
45;misc.at:177;cobcrun validation;;
46;misc.at:221;MOVE to itself;;
47;misc.at:241;MOVE with refmod;;
48;misc.at:261;MOVE with refmod (variable);;
49;misc.at:283;MOVE with group refmod;;
50;misc.at:304;MOVE indexes;;
51;misc.at:326;MOVE X'00';;
52;misc.at:361;Level 01 subscripts;;
53;misc.at:382;Class check with reference modification;;
54;misc.at:403;Index and parenthesized expression;;
55;misc.at:423;String concatenation;;
56;misc.at:457;Alphanumeric and binary numeric;;
57;misc.at:481;Dynamic call with static linking;;
58;misc.at:506;CALL m1. CALL m2. CALL m1.;;
59;misc.at:559;CANCEL ALL;;
60;misc.at:608;CALL binary literal parameter/LENGTH OF - so;;
61;misc.at:662;CALL binary literal parameter/LENGTH OF - DLL;;
62;misc.at:721;INSPECT REPLACING LEADING ZEROS BY SPACES;;
63;misc.at:741;INSPECT: No repeat conversion check;;
64;misc.at:762;INSPECT CONVERTING spaces;;
65;misc.at:783;INSPECT CONVERTING different length;;
66;misc.at:805;INSPECT: REPLACING figurative constant;;
67;misc.at:826;INSPECT: TALLYING BEFORE;;
68;misc.at:856;INSPECT: TALLYING AFTER;;
69;misc.at:885;INSPECT REPLACING TRAILING ZEROS BY SPACES;;
70;misc.at:905;INSPECT REPLACING complex;;
71;misc.at:927;SWITCHES;;
72;misc.at:985;Nested PERFORM;;
73;misc.at:1010;EXIT PERFORM;;
74;misc.at:1034;EXIT PERFORM CYCLE;;
75;misc.at:1058;EXIT PARAGRAPH;;
76;misc.at:1089;EXIT SECTION;;
77;misc.at:1123;88 with FILLER;;
78;misc.at:1150;Non-overflow after overflow;;
79;misc.at:1177;PERFORM ... CONTINUE;;
80;misc.at:1193;STRING with subscript reference;;
81;misc.at:1216;UNSTRING DELIMITED ALL LOW-VALUE;;
82;misc.at:1249;READ INTO AT-END sequence;;
83;misc.at:1283;First READ on empty SEQUENTIAL INDEXED file;;
84;misc.at:1320;REWRITE a RELATIVE file with RANDOM access;;
85;misc.at:1374;SORT: table sort;;
86;misc.at:1411;SORT: EBCDIC table sort;;
87;misc.at:1455;SORT nonexistent file;;
88;misc.at:1489;PIC ZZZ-, ZZZ+;;
89;misc.at:1527;Larger REDEFINES lengths;;
90;misc.at:1567;PERFORM type OSVS;;
91;misc.at:1608;Sticky LINKAGE;;
92;misc.at:1658;COB_PRE_LOAD test;;
93;misc.at:1682;COB_LOAD_CASE=UPPER test;;
94;misc.at:1706;88 level with FALSE IS clause;;
95;misc.at:1731;ALLOCATE/FREE with BASED item;;
96;misc.at:1755;INITIZIALIZE with reference modification;;
97;misc.at:1778;CALL with OMITTED parameter;;
98;misc.at:1816;ANY LENGTH;;
99;misc.at:1856;READ - KEY ignored with sequential READ;;
100;misc.at:1889;SORT - missing fcd in variable-length WRITE;;
101;misc.at:1976;READ - missing fcd in variable-length WRITE;;
102;extensions.at:24;COMP-5;;
103;extensions.at:71;Hexadecimal numeric literal;;
104;extensions.at:99;Semi-parenthesized condition;;
105;extensions.at:120;ADDRESS OF;;
106;extensions.at:183;LENGTH OF;;
107;extensions.at:217;WHEN-COMPILED;;
108;extensions.at:240;Complex OCCURS DEPENDING ON;;
109;extensions.at:268;MOVE NON-INTEGER TO ALPHA-NUMERIC;;
110;extensions.at:359;CALL USING file-name - so;;
111;extensions.at:403;CALL USING file-name - dll;;
112;extensions.at:449;CALL unusual PROGRAM-ID.;;
113;extensions.at:512;Case independent PROGRAM-ID;;
114;extensions.at:535;PROGRAM-ID AS clause;;
115;extensions.at:558;Quoted PROGRAM-ID;;
116;extensions.at:583;ASSIGN MF;;
117;extensions.at:615;ASSIGN IBM;;
118;extensions.at:645;ASSIGN mapping;;
119;extensions.at:681;ASSIGN expansion;;
120;extensions.at:711;ASSIGN with COB_FILE_PATH;;
121;extensions.at:744;NUMBER-OF-CALL-PARAMETERS;;
122;extensions.at:800;PROCEDURE DIVISION USING BY ...;;
123;extensions.at:849;PROCEDURE DIVISION CHAINING ...;;
124;extensions.at:877;STOP RUN RETURNING;;
125;extensions.at:894;ENTRY;;
126;extensions.at:940;LINE SEQUENTIAL write;;
127;extensions.at:981;LINE SEQUENTIAL read;;
128;extensions.at:1041;ASSIGN to KEYBOARD/DISPLAY;;
129;extensions.at:1097;Environment/Argument variable;;
130;extensions.at:1142;DECIMAL-POINT is COMMA (1);;
131;extensions.at:1168;DECIMAL-POINT is COMMA (2);;
132;extensions.at:1194;DECIMAL-POINT is COMMA (3);;
133;extensions.at:1220;DECIMAL-POINT is COMMA (4);;
134;extensions.at:1246;DECIMAL-POINT is COMMA (5);;
135;extensions.at:1278;78 Level (1);;
136;extensions.at:1299;78 Level (2);;
137;extensions.at:1323;78 Level (3);;
138;extensions.at:1345;Unreachable statement;;
139;return-code.at:23;RETURN-CODE moving;;
140;return-code.at:46;RETURN-CODE passing;;
141;return-code.at:89;RETURN-CODE nested;;
142;functions.at:22;FUNCTION ABS;;
143;functions.at:43;FUNCTION ACOS;;
144;functions.at:72;FUNCTION ANNUITY;;
145;functions.at:102;FUNCTION ASIN;;
146;functions.at:131;FUNCTION ATAN;;
147;functions.at:160;FUNCTION CHAR;;
148;functions.at:181;FUNCTION COMBINED-DATETIME;;
149;functions.at:201;FUNCTION CONCATENATE;;
150;functions.at:223;FUNCTION CONCATENATE with reference modding;;
151;functions.at:246;FUNCTION COS;;
152;functions.at:275;FUNCTION DATE-OF-INTEGER;;
153;functions.at:295;FUNCTION DATE-TO-YYYYMMDD;;
154;functions.at:315;FUNCTION DAY-OF-INTEGER;;
155;functions.at:335;FUNCTION DAY-TO-YYYYDDD;;
156;functions.at:355;FUNCTION E;;
157;functions.at:375;FUNCTION EXCEPTION-FILE;;
158;functions.at:405;FUNCTION EXCEPTION-LOCATION;;
159;functions.at:439;FUNCTION EXCEPTION-STATEMENT;;
160;functions.at:469;FUNCTION EXCEPTION-STATUS;;
161;functions.at:499;FUNCTION EXP;;
162;functions.at:527;FUNCTION FACTORIAL;;
163;functions.at:547;FUNCTION FRACTION-PART;;
164;functions.at:570;FUNCTION INTEGER;;
165;functions.at:591;FUNCTION INTEGER-OF-DATE;;
166;functions.at:611;FUNCTION INTEGER-OF-DAY;;
167;functions.at:631;FUNCTION INTEGER-PART;;
168;functions.at:652;FUNCTION LENGTH;;
169;functions.at:673;FUNCTION LOCALE-DATE;;
170;functions.at:697;FUNCTION LOCALE-TIME;;
171;functions.at:721;FUNCTION LOCALE-TIME-FROM-SECONDS;;
172;functions.at:745;FUNCTION LOG;;
173;functions.at:774;FUNCTION LOG10;;
174;functions.at:803;FUNCTION LOWER-CASE;;
175;functions.at:824;FUNCTION LOWER-CASE with reference modding;;
176;functions.at:845;FUNCTION MAX;;
177;functions.at:865;FUNCTION MEAN;;
178;functions.at:885;FUNCTION MEDIAN;;
179;functions.at:905;FUNCTION MIDRANGE;;
180;functions.at:925;FUNCTION MIN;;
181;functions.at:945;FUNCTION MOD;;
182;functions.at:965;FUNCTION NUMVAL;;
183;functions.at:986;FUNCTION NUMVAL-C;;
184;functions.at:1007;FUNCTION ORD;;
185;functions.at:1027;FUNCTION ORD-MAX;;
186;functions.at:1047;FUNCTION ORD-MIN;;
187;functions.at:1067;FUNCTION PI;;
188;functions.at:1087;FUNCTION PRESENT-VALUE;;
189;functions.at:1107;FUNCTION RANGE;;
190;functions.at:1127;FUNCTION REM;;
191;functions.at:1147;FUNCTION REVERSE;;
192;functions.at:1168;FUNCTION REVERSE with reference modding;;
193;functions.at:1189;FUNCTION SECONDS-FROM-FORMATTED-TIME;;
194;functions.at:1218;FUNCTION SECONDS-PAST-MIDNIGHT;;
195;functions.at:1245;FUNCTION SIGN;;
196;functions.at:1274;FUNCTION SIN;;
197;functions.at:1303;FUNCTION SQRT;;
198;functions.at:1332;FUNCTION STANDARD-DEVIATION;;
199;functions.at:1360;FUNCTION STORED-CHAR-LENGTH;;
200;functions.at:1382;FUNCTION SUBSTITUTE;;
201;functions.at:1404;FUNCTION SUBSTITUTE with reference modding;;
202;functions.at:1427;FUNCTION SUBSTITUTE-CASE;;
203;functions.at:1449;FUNCTION SUBSTITUTE-CASE with reference mod;;
204;functions.at:1472;FUNCTION TAN;;
205;functions.at:1501;FUNCTION TRIM;;
206;functions.at:1525;FUNCTION TRIM with reference modding;;
207;functions.at:1549;FUNCTION UPPER-CASE;;
208;functions.at:1570;FUNCTION UPPER-CASE with reference modding;;
209;functions.at:1591;FUNCTION VARIANCE;;
210;functions.at:1611;FUNCTION WHEN-COMPILED;;
"

# at_func_validate_ranges [NAME...]
# ---------------------------------
# Validate and normalize the test group number contained in each
# variable NAME.  Leading zeroes are treated as decimal.
at_func_validate_ranges ()
{
  for at_grp
  do
    eval at_value=\$$at_grp
    if test $at_value -lt 1 || test $at_value -gt 210; then
      $as_echo "invalid test group: $at_value" >&2
      exit 1
    fi
    case $at_value in
      0*) # We want to treat leading 0 as decimal, like expr and test, but
	  # at_func_arith treats it as octal if it uses $(( )).
	  # With XSI shells, ${at_value#${at_value%%[1-9]*}} avoids the
	  # expr fork, but it is not worth the effort to determine if the
	  # shell supports XSI when the user can just avoid leading 0.
	  eval $at_grp='`expr $at_value + 0`' ;;
    esac
  done
}

at_prev=
for at_option
do
  # If the previous option needs an argument, assign it.
  if test -n "$at_prev"; then
    at_option=$at_prev=$at_option
    at_prev=
  fi

  case $at_option in
  *=*) at_optarg=`expr "x$at_option" : 'x[^=]*=\(.*\)'` ;;
  *)   at_optarg= ;;
  esac

  # Accept the important Cygnus configure options, so we can diagnose typos.

  case $at_option in
    --help | -h )
	at_help_p=:
	;;

    --list | -l )
	at_list_p=:
	;;

    --version | -V )
	at_version_p=:
	;;

    --clean | -c )
	at_clean=:
	;;

    --debug | -d )
	at_debug_p=:
	;;

    --errexit | -e )
	at_debug_p=:
	at_errexit_p=:
	;;

    --verbose | -v )
	at_verbose=; at_quiet=:
	;;

    --trace | -x )
	at_traceon='set -x'; at_traceoff='set +x'
	;;

    [0-9] | [0-9][0-9] | [0-9][0-9][0-9] | [0-9][0-9][0-9][0-9])
	at_func_validate_ranges at_option
	at_groups="$at_groups$at_option "
	;;

    # 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 $at_option |tr -d X-`
	at_func_validate_ranges at_range_start
	at_range=`$as_echo " $at_groups_all " | \
	  sed -e 's/^.* \('$at_range_start' \)/\1/'`
	at_groups="$at_groups$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 $at_option |tr -d X-`
	at_func_validate_ranges at_range_end
	at_range=`$as_echo " $at_groups_all " | \
	  sed -e 's/\( '$at_range_end'\) .*$/\1/'`
	at_groups="$at_groups$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=`expr $at_option : '\(.*\)-'`
	at_range_end=`expr $at_option : '.*-\(.*\)'`
	if test $at_range_start -gt $at_range_end; then
	  at_tmp=$at_range_end
	  at_range_end=$at_range_start
	  at_range_start=$at_tmp
	fi
	at_func_validate_ranges at_range_start at_range_end
	at_range=`$as_echo " $at_groups_all " | \
	  sed -e 's/^.*\( '$at_range_start' \)/\1/' \
	      -e 's/\( '$at_range_end'\) .*$/\1/'`
	at_groups="$at_groups$at_range "
	;;

    # Directory selection.
    --directory | -C )
	at_prev=--directory
	;;
    --directory=* )
	at_change_dir=:
	at_dir=$at_optarg
	;;

    # Keywords.
    --keywords | -k )
	at_prev=--keywords
	;;
    --keywords=* )
	at_groups_selected=$at_help_all
	at_save_IFS=$IFS
	IFS=,
	set X $at_optarg
	shift
	IFS=$at_save_IFS
	for at_keyword
	do
	  at_invert=
	  case $at_keyword in
	  '!'*)
	    at_invert="-v"
	    at_keyword=`expr "X$at_keyword" : 'X!\(.*\)'`
	    ;;
	  esac
	  # It is on purpose that we match the test group titles too.
	  at_groups_selected=`$as_echo "$at_groups_selected" |
	      grep -i $at_invert "^[1-9][^;]*;.*[; ]$at_keyword[ ;]"`
	done
	# Smash the newlines.
	at_groups_selected=`$as_echo "$at_groups_selected" | sed 's/;.*//' |
	  tr "$as_nl" ' '
	`
	at_groups="$at_groups$at_groups_selected "
	;;

    *=*)
	at_envvar=`expr "x$at_option" : 'x\([^=]*\)='`
	# Reject names that are not valid shell variable names.
	case $at_envvar in
	  '' | [0-9]* | *[!_$as_cr_alnum]* )
	    { { $as_echo "$as_me:$LINENO: error: invalid variable name: $at_envvar" >&5
$as_echo "$as_me: error: invalid variable name: $at_envvar" >&2;}
   { (exit 1); exit 1; }; } ;;
	esac
	at_value=`$as_echo "$at_optarg" | sed "s/'/'\\\\\\\\''/g"`
	# Export now, but save eval for later and for debug scripts.
	export $at_envvar
	at_debug_args="$at_debug_args $at_envvar='$at_value'"
	;;

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

# Verify our last option didn't require an argument
if test -n "$at_prev"; then
  { { $as_echo "$as_me:$LINENO: error: \`$at_prev' requires an argument." >&5
$as_echo "$as_me: error: \`$at_prev' requires an argument." >&2;}
   { (exit 1); exit 1; }; }
fi


# Selected test groups.
if test -z "$at_groups"; then
  at_groups=$at_groups_all
else
  # Sort the tests, removing duplicates.
  at_groups=`$as_echo "$at_groups" | tr ' ' "$as_nl" | sort -nu`
fi

# Help message.
if $at_help_p; then
  cat <<_ATEOF || at_write_fail=1
Usage: $0 [OPTION]... [VARIABLE=VALUE]... [TESTS]

Run all the tests, or the selected TESTS, given by numeric ranges, and
save a detailed log file.  Upon failure, create debugging scripts.

You should not change environment variables unless explicitly passed
as command line arguments.  Set \`AUTOTEST_PATH' to select the executables
to exercise.  Each relative directory is expanded as build and source
directories relatively to the top level of this distribution.  E.g.,

  $ $0 AUTOTEST_PATH=bin

possibly amounts into

  PATH=/tmp/foo-1.0/bin:/src/foo-1.0/bin:\$PATH
_ATEOF
cat <<_ATEOF || at_write_fail=1

Operation modes:
  -h, --help     print the help message, then exit
  -V, --version  print version number, then exit
  -c, --clean    remove all the files this test suite might create and exit
  -l, --list     describes all the tests, or the selected TESTS
_ATEOF
cat <<_ATEOF || at_write_fail=1

Execution tuning:
  -C, --directory=DIR
                 change to directory DIR before starting
  -k, --keywords=KEYWORDS
                 select the tests matching all the comma-separated KEYWORDS
                 multiple \`-k' accumulate; prefixed \`!' negates a KEYWORD
  -e, --errexit  abort as soon as a test fails; implies --debug
  -v, --verbose  force more detailed output
                 default for debugging scripts
  -d, --debug    inhibit clean up and top-level logging
                 default for debugging scripts
  -x, --trace    enable tests shell tracing
_ATEOF
cat <<_ATEOF || at_write_fail=1

Report bugs to <open-cobol-list@lists.sourceforge.net>.
_ATEOF
  exit $at_write_fail
fi

# List of tests.
if $at_list_p; then
  cat <<_ATEOF || at_write_fail=1
OpenCOBOL 1.1 test suite: Run Tests test groups:

 NUM: FILE-NAME:LINE     TEST-GROUP-NAME
      KEYWORDS

_ATEOF
  # Passing at_groups is tricky.  We cannot use it to form a literal string
  # or regexp because of the limitation of AIX awk.  And Solaris' awk
  # doesn't grok more than 99 fields in a record, so we have to use `split'.
  # at_groups needs to be space-separated for this script to work.
  case $at_groups in
    *"$as_nl"* )
      at_groups=`$as_echo "$at_groups" | tr "$as_nl" ' '` ;;
  esac
  $as_echo "$at_groups$as_nl$at_help_all" |
    awk 'BEGIN { FS = ";" }
	 NR == 1 {
	   for (n = split($ 0, a, " "); n; n--) selected[a[n]] = 1
	   next
	 }
	 {
	   if (selected[$ 1]) {
	     printf " %3d: %-18s %s\n", $ 1, $ 2, $ 3
	     if ($ 4) printf "      %s\n", $ 4
	   }
	 }' || at_write_fail=1
  exit $at_write_fail
fi
if $at_version_p; then
  $as_echo "$as_me (OpenCOBOL 1.1)" &&
  cat <<\_ACEOF || at_write_fail=1

Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
Free Software Foundation, Inc.
This test suite is free software; the Free Software Foundation gives
unlimited permission to copy, distribute and modify it.
_ACEOF
  exit $at_write_fail
fi

# Should we print banners?  at_groups is space-separated for entire test,
# newline-separated if only a subset of the testsuite is run.
case $at_groups in
  *' '*' '* | *"$as_nl"*"$as_nl"* )
      at_print_banners=: ;;
  * ) at_print_banners=false ;;
esac
# Text for banner N, set to empty once printed.

# Take any -C into account.
if $at_change_dir ; then
  if test x- = "x$at_dir" ; then
    at_dir=./-
  fi
  test x != "x$at_dir" && cd "$at_dir" \
    || { { $as_echo "$as_me:$LINENO: error: unable to change directory" >&5
$as_echo "$as_me: error: unable to change directory" >&2;}
   { (exit 1); exit 1; }; }
  at_dir=`pwd`
fi

# Load the config files for any default variable assignments.
for at_file in atconfig atlocal
do
  test -r $at_file || continue
  . ./$at_file || { { $as_echo "$as_me:$LINENO: error: invalid content: $at_file" >&5
$as_echo "$as_me: error: invalid content: $at_file" >&2;}
   { (exit 1); exit 1; }; }
done

# Autoconf <=2.59b set at_top_builddir instead of at_top_build_prefix:
: ${at_top_build_prefix=$at_top_builddir}

# Perform any assignments requested during argument parsing.
eval "$at_debug_args"

# atconfig delivers names relative to the directory the test suite is
# in, but the groups themselves are run in testsuite-dir/group-dir.
if test -n "$at_top_srcdir"; then
  builddir=../..
  for at_dir_var in srcdir top_srcdir top_build_prefix
  do
    at_val=`eval 'as_val=${'at_$at_dir_var'}
		 $as_echo "$as_val"'`
    case $at_val in
      [\\/$]* | ?:[\\/]* ) at_prefix= ;;
      *) at_prefix=../../ ;;
    esac
    eval "$at_dir_var=\$at_prefix\$at_val"
  done
fi

## ------------------- ##
## Directory structure ##
## ------------------- ##

# This is the set of directories and files used by this script
# (non-literals are capitalized):
#
# TESTSUITE         - the testsuite
# TESTSUITE.log     - summarizes the complete testsuite run
# TESTSUITE.dir/    - created during a run, remains after -d or failed test
# + at-groups/      - during a run: status of all groups in run
# | + NNN/          - during a run: meta-data about test group NNN
# | | + check-line  - location (source file and line) of current AT_CHECK
# | | + status      - exit status of current AT_CHECK
# | | + stdout      - stdout of current AT_CHECK
# | | + stder1      - stderr, including trace
# | | + stderr      - stderr, with trace filtered out
# | | + test-source - portion of testsuite that defines group
# | | + times       - timestamps for computing duration
# | | + pass        - created if group passed
# | | + xpass       - created if group xpassed
# | | + fail        - created if group failed
# | | + xfail       - created if group xfailed
# | | + skip        - created if group skipped
# + at-stop         - during a run: end the run if this file exists
# + at-source-lines - during a run: cache of TESTSUITE line numbers for extraction
# + 0..NNN/         - created for each group NNN, remains after -d or failed test
# | + TESTSUITE.log - summarizes the group results
# | + ...           - files created during the group

# The directory the whole suite works in.
# Should be absolute to let the user `cd' at will.
at_suite_dir=$at_dir/$as_me.dir
# The file containing the suite.
at_suite_log=$at_dir/$as_me.log
# The directory containing helper files per test group.
at_helper_dir=$at_suite_dir/at-groups
# Stop file: if it exists, do not start new jobs.
at_stop_file=$at_suite_dir/at-stop

if $at_clean; then
  test -d "$at_suite_dir" &&
    find "$at_suite_dir" -type d ! -perm -700 -exec chmod u+rwx \{\} \;
  rm -f -r "$at_suite_dir" "$at_suite_log"
  exit $?
fi

# Don't take risks: use only absolute directories in PATH.
#
# For stand-alone test suites (ie. atconfig was not found),
# 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.
AUTOTEST_PATH=`$as_echo "$AUTOTEST_PATH" | sed "s|:|$PATH_SEPARATOR|g"`
at_path=
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $AUTOTEST_PATH $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  test -n "$at_path" && at_path=$at_path$PATH_SEPARATOR
case $as_dir in
  [\\/]* | ?:[\\/]* )
    at_path=$at_path$as_dir
    ;;
  * )
    if test -z "$at_top_build_prefix"; then
      # Stand-alone test suite.
      at_path=$at_path$as_dir
    else
      # Embedded test suite.
      at_path=$at_path$at_top_build_prefix$as_dir$PATH_SEPARATOR
      at_path=$at_path$at_top_srcdir/$as_dir
    fi
    ;;
esac
done
IFS=$as_save_IFS


# Now build and simplify PATH.
#
# There might be directories that don't exist, but don't redirect
# builtins' (eg., cd) stderr directly: Ultrix's sh hates that.
at_new_path=
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $at_path
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  test -d "$as_dir" || continue
case $as_dir in
  [\\/]* | ?:[\\/]* ) ;;
  * ) as_dir=`(cd "$as_dir" && pwd) 2>/dev/null` ;;
esac
case $PATH_SEPARATOR$at_new_path$PATH_SEPARATOR in
  *$PATH_SEPARATOR$as_dir$PATH_SEPARATOR*) ;;
  $PATH_SEPARATOR$PATH_SEPARATOR) at_new_path=$as_dir ;;
  *) at_new_path=$at_new_path$PATH_SEPARATOR$as_dir ;;
esac
done
IFS=$as_save_IFS

PATH=$at_new_path
export PATH

# Setting up the FDs.
# 5 is the log file.  Not to be overwritten if `-d'.
if $at_debug_p; then
  at_suite_log=/dev/null
else
  : >"$at_suite_log"
fi
exec 5>>"$at_suite_log"

# Banners and logs.
cat <<\_ASBOX
## ------------------------------------ ##
## OpenCOBOL 1.1 test suite: Run Tests. ##
## ------------------------------------ ##
_ASBOX
{
  cat <<\_ASBOX
## ------------------------------------ ##
## OpenCOBOL 1.1 test suite: Run Tests. ##
## ------------------------------------ ##
_ASBOX
  echo

  $as_echo "$as_me: command line was:"
  $as_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.  Prune directories
  # matching the package tarname, since they tend to be leftovers from
  # `make dist' or `make distcheck' and contain redundant or stale logs.
  if test -n "$at_top_srcdir"; then
    cat <<\_ASBOX
## ----------- ##
## ChangeLogs. ##
## ----------- ##
_ASBOX
    echo
    for at_file in `find "$at_top_srcdir" -name "opensource-cobol-1.5.0J-*" -prune -o -name ChangeLog -print`
    do
      $as_echo "$as_me: $at_file:"
      sed 's/^/| /;10q' $at_file
      echo
    done

  fi

  {
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`
/usr/bin/hostinfo      = `(/usr/bin/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=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  $as_echo "PATH: $as_dir"
done
IFS=$as_save_IFS

}
  echo

  # Contents of the config files.
  for at_file in atconfig atlocal
  do
    test -r $at_file || continue
    $as_echo "$as_me: $at_file:"
    sed 's/^/| /' $at_file
    echo
  done
} >&5


## --------------- ##
## Shell functions ##
## --------------- ##

# at_func_banner NUMBER
# ---------------------
# Output banner NUMBER, provided the testsuite is running multiple groups
# and this particular banner has not yet been printed.
at_func_banner ()
{
  $at_print_banners || return 0
  eval at_banner_text=\$at_banner_text_$1
  test "x$at_banner_text" = x && return 0
  eval at_banner_text_$1=
  $as_echo "$as_nl$at_banner_text$as_nl"
} # at_func_banner

# at_func_check_newline COMMAND
# -----------------------------
# Test if COMMAND includes a newline and, if so, print a message and return
# exit code 1
at_func_check_newline ()
{
  case "$1" in
 *'
'*) echo 'Not enabling shell tracing (command contains an embedded newline)'
    return 1 ;;
 *) return 0 ;;
  esac
}

# at_func_filter_trace EXIT-CODE
# ------------------------------
# Split the contents of file "$at_stder1" into the "set -x" trace (on stderr)
# and the other lines (on file "$at_stderr").  Return the exit code EXIT-CODE.
at_func_filter_trace ()
{
  grep '^ *+' "$at_stder1" >&2
  grep -v '^ *+' "$at_stder1" >"$at_stderr"
  return $1
}

# at_func_log_failure FILE-LIST
# -----------------------------
# Copy the files in the list on stdout with a "> " prefix, and exit the shell
# with a failure exit code.
at_func_log_failure ()
{
  for file
    do $as_echo "$file:"; sed 's/^/> /' "$file"; done
  echo 1 > "$at_status_file"
  exit 1
}

# at_func_check_skip EXIT-CODE
# ----------------------------
# Check whether EXIT-CODE is the special exit code 77, and if so exit the shell
# with that same exit code.
at_func_check_skip ()
{
  case $1 in
    77) echo 77 > "$at_status_file"; exit 77;;
  esac
}

# at_func_check_status EXPECTED EXIT-CODE LINE
# --------------------------------------------
# Check whether EXIT-CODE is the expected exit code, and if so do nothing.
# Otherwise, if it is 77 exit the shell with that same exit code; if it is
# anything else print an error message and fail the test.
at_func_check_status ()
{
  case $2 in
    $1 ) ;;
    77) echo 77 > "$at_status_file"; exit 77;;
    *) $as_echo "$3: exit code was $2, expected $1"
      at_failed=:;;
  esac
}

# at_func_diff_devnull FILE
# -------------------------
# Emit a diff between /dev/null and FILE.  Uses "test -s" to avoid useless
# diff invocations.
at_func_diff_devnull ()
{
  test -s "$1" || return 0
  $at_diff "$at_devnull" "$1"
}

# at_func_test NUMBER
# -------------------
# Parse out test NUMBER from the tail of this file.
at_func_test ()
{
  eval at_sed=\$at_sed$1
  sed "$at_sed" "$at_myself" > "$at_test_source"
}

# at_func_create_debugging_script
# -------------------------------
# Create the debugging script $at_group_dir/run which will reproduce the
# current test group.
at_func_create_debugging_script ()
{
  {
    echo "#! /bin/sh" &&
    echo 'test "${ZSH_VERSION+set}" = set && alias -g '\''${1+"$@"}'\''='\''"$@"'\''' &&
    $as_echo "cd '$at_dir'" &&
    $as_echo "exec \${CONFIG_SHELL-$SHELL} \"$at_myself\" -v -d $at_debug_args $at_group \${1+\"\$@\"}" &&
    echo 'exit 1'
  } >"$at_group_dir/run" &&
  chmod +x "$at_group_dir/run"
}

# at_func_arith
# -------------
# Arithmetic evaluation, avoids expr if the shell is sane.  The
# interpretation of leading zeroes is unspecified.
#
# subshell and eval are needed to keep Solaris sh from bailing out:
if ( eval 'test $(( 1 + 1 )) = 2' ) 2>/dev/null; then
  # With "$@", bash does not split positional parameters:
  eval 'at_func_arith ()
  {
    at_func_arith_result=$(( $* ))
  }'
else
  at_func_arith ()
  {
    at_func_arith_result=`expr "$@"`
  }
fi

## ---------------------- ##
## End of shell functions ##
## ---------------------- ##
{
  cat <<\_ASBOX
## ---------------- ##
## Tested programs. ##
## ---------------- ##
_ASBOX
  echo
} >&5

# Report what programs are being tested.
for at_program in : $at_tested
do
  test "$at_program" = : && continue
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  test -f "$as_dir/$at_program" && break
done
IFS=$as_save_IFS

  if test -f "$as_dir/$at_program"; then
    {
      $as_echo "$at_srcdir/run.at:21: $as_dir/$at_program --version"
      "$as_dir/$at_program" --version </dev/null
      echo
    } >&5 2>&1
  else
    { { $as_echo "$as_me:$LINENO: error: cannot find $at_program" >&5
$as_echo "$as_me: error: cannot find $at_program" >&2;}
   { (exit 1); exit 1; }; }
  fi
done

{
  cat <<\_ASBOX
## ------------------ ##
## Running the tests. ##
## ------------------ ##
_ASBOX
} >&5

at_start_date=`date`
at_start_time=`date +%s 2>/dev/null`
$as_echo "$as_me: starting at: $at_start_date" >&5

# Create the master directory if it doesn't already exist.
test -d "$at_suite_dir" ||
  mkdir "$at_suite_dir" ||
  { { $as_echo "$as_me:$LINENO: error: cannot create '$at_suite_dir'" >&5
$as_echo "$as_me: error: cannot create '$at_suite_dir'" >&2;}
   { (exit 1); exit 1; }; }

# 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=$at_suite_dir/devnull
  >"$at_devnull"
fi

# Use `diff -u' when possible.
if at_diff=`diff -u "$at_devnull" "$at_devnull" 2>&1` && test -z "$at_diff"
then
  at_diff='diff -u'
else
  at_diff=diff
fi

# Get the last needed group.
for at_group in : $at_groups; do :; done

# Extract the start and end lines of each test group at the tail
# of this file
awk '
BEGIN { FS="" }
/^#AT_START_/ {
  start = NR
}
/^#AT_STOP_/ {
  test = substr ($ 0, 10)
  print "at_sed" test "=\"1," start "d;" (NR-1) "q\""
  if (test == "'"$at_group"'") exit
}' "$at_myself" > "$at_suite_dir/at-source-lines" &&
. "$at_suite_dir/at-source-lines" ||
  { { $as_echo "$as_me:$LINENO: error: cannot create test line number cache" >&5
$as_echo "$as_me: error: cannot create test line number cache" >&2;}
   { (exit 1); exit 1; }; }
rm -f "$at_suite_dir/at-source-lines"

# Set up helper dirs.
rm -rf "$at_helper_dir" &&
mkdir "$at_helper_dir" &&
cd "$at_helper_dir" &&
{ test -z "$at_groups" || mkdir $at_groups; } ||
{ { $as_echo "$as_me:$LINENO: error: testsuite directory setup failed" >&5
$as_echo "$as_me: error: testsuite directory setup failed" >&2;}
   { (exit 1); exit 1; }; }

# Functions for running a test group.  We leave the actual
# test group execution outside of a shell function in order
# to avoid hitting zsh 4.x exit status bugs.

# at_func_group_prepare
# ---------------------
# Prepare running a test group
at_func_group_prepare ()
{
  # The directory for additional per-group helper files.
  at_job_dir=$at_helper_dir/$at_group
  # The file containing the location of the last AT_CHECK.
  at_check_line_file=$at_job_dir/check-line
  # The file containing the exit status of the last command.
  at_status_file=$at_job_dir/status
  # The files containing the output of the tested commands.
  at_stdout=$at_job_dir/stdout
  at_stder1=$at_job_dir/stder1
  at_stderr=$at_job_dir/stderr
  # The file containing the code for a test group.
  at_test_source=$at_job_dir/test-source
  # The file containing dates.
  at_times_file=$at_job_dir/times

  # Be sure to come back to the top test directory.
  cd "$at_suite_dir"

  # Clearly separate the test groups when verbose.
  $at_first || $at_verbose echo

  at_group_normalized=$at_group

  eval 'while :; do
    case $at_group_normalized in #(
    '"$at_format"'*) break;;
    esac
    at_group_normalized=0$at_group_normalized
  done'


  # Create a fresh directory for the next test group, and enter.
  at_group_dir=$at_suite_dir/$at_group_normalized
  at_group_log=$at_group_dir/$as_me.log
  if test -d "$at_group_dir"; then
    find "$at_group_dir" -type d ! -perm -700 -exec chmod u+rwx \{\} \;
    rm -fr "$at_group_dir" ||
    { $as_echo "$as_me:$LINENO: WARNING: test directory for $at_group_normalized could not be cleaned." >&5
$as_echo "$as_me: WARNING: test directory for $at_group_normalized could not be cleaned." >&2;}
  fi
  # Be tolerant if the above `rm' was not able to remove the directory.
  { as_dir="$at_group_dir"
  case $as_dir in #(
  -*) as_dir=./$as_dir;;
  esac
  test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {
    as_dirs=
    while :; do
      case $as_dir in #(
      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
      *) as_qdir=$as_dir;;
      esac
      as_dirs="'$as_qdir' $as_dirs"
      as_dir=`$as_dirname -- "$as_dir" ||
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$as_dir" : 'X\(//\)[^/]' \| \
	 X"$as_dir" : 'X\(//\)$' \| \
	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$as_dir" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
      test -d "$as_dir" && break
    done
    test -z "$as_dirs" || eval "mkdir $as_dirs"
  } || test -d "$as_dir" || { { $as_echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5
$as_echo "$as_me: error: cannot create directory $as_dir" >&2;}
   { (exit 1); exit 1; }; }; }

  echo 0 > "$at_status_file"

  # In verbose mode, append to the log file *and* show on
  # the standard output; in quiet mode only write to the log.
  if test -z "$at_verbose"; then
    at_tee_pipe='tee -a "$at_group_log"'
  else
    at_tee_pipe='cat >> "$at_group_log"'
  fi
}

# at_func_group_postprocess
# -------------------------
at_func_group_postprocess ()
{
  # Be sure to come back to the suite directory, in particular
  # since below we might `rm' the group directory we are in currently.
  cd "$at_suite_dir"

  if test ! -f "$at_check_line_file"; 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 <open-cobol-list@lists.sourceforge.net>.
_ATEOF
    $as_echo "$at_setup_line" >"$at_check_line_file"
  fi
  $at_verbose $as_echo_n "$at_group. $at_setup_line: "
  $as_echo_n "$at_group. $at_setup_line: " >> "$at_group_log"
  case $at_xfail:$at_status in
    yes:0)
	at_msg="UNEXPECTED PASS"
	at_res=xpass
	at_errexit=$at_errexit_p
	;;
    no:0)
	at_msg="ok"
	at_res=pass
	at_errexit=false
	;;
    *:77)
	at_msg='skipped ('`cat "$at_check_line_file"`')'
	at_res=skip
	at_errexit=false
	;;
    yes:*)
	at_msg='expected failure ('`cat "$at_check_line_file"`')'
	at_res=xfail
	at_errexit=false
	;;
    no:*)
	at_msg='FAILED ('`cat "$at_check_line_file"`')'
	at_res=fail
	at_errexit=$at_errexit_p
	;;
  esac
  echo "$at_res" > "$at_job_dir/$at_res"
  # Make sure there is a separator even with long titles.
  $as_echo " $at_msg"
  at_log_msg="$at_group. $at_desc ($at_setup_line): $at_msg"
  case $at_status in
    0|77)
      # $at_times_file is only available if the group succeeded.
      # We're not including the group log, so the success message
      # is written in the global log separately.  But we also
      # write to the group log in case they're using -d.
      if test -f "$at_times_file"; then
	at_log_msg="$at_log_msg     ("`sed 1d "$at_times_file"`')'
	rm -f "$at_times_file"
      fi
      $as_echo "$at_log_msg" >> "$at_group_log"
      $as_echo "$at_log_msg" >&5

      # Cleanup the group directory, unless the user wants the files.
      if $at_debug_p; then
	at_func_create_debugging_script
      else
	if test -d "$at_group_dir"; then
	  find "$at_group_dir" -type d ! -perm -700 -exec chmod u+rwx \{\} \;
	  rm -fr "$at_group_dir"
	fi
	rm -f "$at_test_source"
      fi
      ;;
    *)
      # Upon failure, include the log into the testsuite's global
      # log.  The failure message is written in the group log.  It
      # is later included in the global log.
      $as_echo "$at_log_msg" >> "$at_group_log"

      # Upon failure, keep the group directory for autopsy, and create
      # the debugging script.  With -e, do not start any further tests.
      at_func_create_debugging_script
      if $at_errexit; then
	echo stop > "$at_stop_file"
      fi
      ;;
  esac
}


## ------------ ##
## Driver loop. ##
## ------------ ##

rm -f "$at_stop_file"
at_first=:

for at_group in $at_groups; do
  at_func_group_prepare
  if cd "$at_group_dir" &&
     at_func_test $at_group &&
     . "$at_test_source"; then :; else
    { $as_echo "$as_me:$LINENO: WARNING: unable to parse test group: $at_group" >&5
$as_echo "$as_me: WARNING: unable to parse test group: $at_group" >&2;}
    at_failed=:
  fi
  at_func_group_postprocess
  test -f "$at_stop_file" && break
  at_first=false
done

# Wrap up the test suite with summary statistics.
cd "$at_helper_dir"

# Use ?..???? when the list must remain sorted, the faster * otherwise.
at_pass_list=`for f in */pass; do echo $f; done | sed '/\*/d; s,/pass,,'`
at_skip_list=`for f in */skip; do echo $f; done | sed '/\*/d; s,/skip,,'`
at_xfail_list=`for f in */xfail; do echo $f; done | sed '/\*/d; s,/xfail,,'`
at_xpass_list=`for f in ?/xpass ??/xpass ???/xpass ????/xpass; do
		 echo $f; done | sed '/?/d; s,/xpass,,'`
at_fail_list=`for f in ?/fail ??/fail ???/fail ????/fail; do
		echo $f; done | sed '/?/d; s,/fail,,'`

set X $at_pass_list $at_xpass_list $at_xfail_list $at_fail_list $at_skip_list
shift; at_group_count=$#
set X $at_xpass_list; shift; at_xpass_count=$#; at_xpass_list=$*
set X $at_xfail_list; shift; at_xfail_count=$#
set X $at_fail_list; shift; at_fail_count=$#; at_fail_list=$*
set X $at_skip_list; shift; at_skip_count=$#

at_func_arith $at_group_count - $at_skip_count
at_run_count=$at_func_arith_result
at_func_arith $at_xpass_count + $at_fail_count
at_unexpected_count=$at_func_arith_result
at_func_arith $at_xfail_count + $at_fail_count
at_total_fail_count=$at_func_arith_result

# Back to the top directory.
cd "$at_dir"
rm -rf "$at_helper_dir"

# Compute the duration of the suite.
at_stop_date=`date`
at_stop_time=`date +%s 2>/dev/null`
$as_echo "$as_me: ending at: $at_stop_date" >&5
case $at_start_time,$at_stop_time in
  [0-9]*,[0-9]*)
    at_func_arith $at_stop_time - $at_start_time
    at_duration_s=$at_func_arith_result
    at_func_arith $at_duration_s / 60
    at_duration_m=$at_func_arith_result
    at_func_arith $at_duration_m / 60
    at_duration_h=$at_func_arith_result
    at_func_arith $at_duration_s % 60
    at_duration_s=$at_func_arith_result
    at_func_arith $at_duration_m % 60
    at_duration_m=$at_func_arith_result
    at_duration="${at_duration_h}h ${at_duration_m}m ${at_duration_s}s"
    $as_echo "$as_me: test suite duration: $at_duration" >&5
    ;;
esac

echo
cat <<\_ASBOX
## ------------- ##
## Test results. ##
## ------------- ##
_ASBOX
echo
{
  echo
  cat <<\_ASBOX
## ------------- ##
## Test results. ##
## ------------- ##
_ASBOX
  echo
} >&5

if test $at_run_count = 1; then
  at_result="1 test"
  at_were=was
else
  at_result="$at_run_count tests"
  at_were=were
fi
if $at_errexit_p && test $at_unexpected_count != 0; then
  if test $at_xpass_count = 1; then
    at_result="$at_result $at_were run, one passed"
  else
    at_result="$at_result $at_were run, one failed"
  fi
  at_result="$at_result unexpectedly and inhibited subsequent tests."
else
  # Don't you just love exponential explosion of the number of cases?
  case $at_xpass_count:$at_fail_count:$at_xfail_count in
    # So far, so good.
    0:0:0) at_result="$at_result $at_were successful." ;;
    0:0:*) at_result="$at_result behaved as expected." ;;

    # Some unexpected failures
    0:*:0) at_result="$at_result $at_were run,
$at_fail_count failed unexpectedly." ;;

    # Some failures, both expected and unexpected
    0:*:1) at_result="$at_result $at_were run,
$at_total_fail_count failed ($at_xfail_count expected failure)." ;;
    0:*:*) at_result="$at_result $at_were run,
$at_total_fail_count failed ($at_xfail_count expected failures)." ;;

    # No unexpected failures, but some xpasses
    *:0:*) at_result="$at_result $at_were run,
$at_xpass_count passed unexpectedly." ;;

    # No expected failures, but failures and xpasses
    *:1:0) at_result="$at_result $at_were run,
$at_unexpected_count did not behave as expected ($at_fail_count unexpected failure)." ;;
    *:*:0) at_result="$at_result $at_were run,
$at_unexpected_count did not behave as expected ($at_fail_count unexpected failures)." ;;

    # All of them.
    *:*:1) at_result="$at_result $at_were run,
$at_xpass_count passed unexpectedly,
$at_total_fail_count failed ($at_xfail_count expected failure)." ;;
    *:*:*) at_result="$at_result $at_were run,
$at_xpass_count passed unexpectedly,
$at_total_fail_count failed ($at_xfail_count expected failures)." ;;
  esac

  if test $at_skip_count = 0 && test $at_run_count -gt 1; then
    at_result="All $at_result"
  fi
fi

# Now put skips in the mix.
case $at_skip_count in
  0) ;;
  1) at_result="$at_result
1 test was skipped." ;;
  *) at_result="$at_result
$at_skip_count tests were skipped." ;;
esac

if test $at_unexpected_count = 0; then
  echo "$at_result"
  echo "$at_result" >&5
else
  echo "ERROR: $at_result" >&2
  echo "ERROR: $at_result" >&5
  {
    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 "$at_myself" $at_fail_list --list
      echo
    fi
    if test $at_skip_count != 0; then
      echo "Skipped tests:"
      $SHELL "$at_myself" $at_skip_list --list
      echo
    fi
    if test $at_xpass_count != 0; then
      echo "Unexpected passes:"
      $SHELL "$at_myself" $at_xpass_list --list
      echo
    fi
    if test $at_fail_count != 0; then
      cat <<\_ASBOX
## ---------------------- ##
## Detailed failed tests. ##
## ---------------------- ##
_ASBOX
      echo
      for at_group in $at_fail_list
      do
	at_group_normalized=$at_group

  eval 'while :; do
    case $at_group_normalized in #(
    '"$at_format"'*) break;;
    esac
    at_group_normalized=0$at_group_normalized
  done'

	cat "$at_suite_dir/$at_group_normalized/$as_me.log"
	echo
      done
      echo
    fi
    if test -n "$at_top_srcdir"; then
      sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## ${at_top_build_prefix}config.log ##
_ASBOX
      sed 's/^/| /' ${at_top_build_prefix}config.log
      echo
    fi
  } >&5

  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## $as_me.log was created. ##
_ASBOX

  echo
  $as_echo "Please send \`${at_testdir+${at_testdir}/}$as_me.log' and all information you think might help:

   To: <open-cobol-list@lists.sourceforge.net>
   Subject: [OpenCOBOL 1.1] $as_me: $at_fail_list${at_fail_list:+ failed${at_xpass_list:+, }}$at_xpass_list${at_xpass_list:+ passed unexpectedly}
"
  if test $at_debug_p = false; then
    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.  Its output may'
    $as_echo "be found below \`${at_testdir+${at_testdir}/}$as_me.dir'."
    echo
  fi
    exit 1
fi

exit 0

## ------------- ##
## Actual tests. ##
## ------------- ##
#AT_START_1
# 1. fundamental.at:23: DISPLAY literals
at_setup_line='fundamental.at:23'
at_desc="DISPLAY literals"
$at_quiet $as_echo_n "  1: $at_desc                               "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "1. fundamental.at:23: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       PROCEDURE        DIVISION.
           DISPLAY "abc"
           END-DISPLAY.
           DISPLAY  123
           END-DISPLAY.
           DISPLAY +123
           END-DISPLAY.
           DISPLAY -123
           END-DISPLAY.
           DISPLAY  12.3
           END-DISPLAY.
           DISPLAY +12.3
           END-DISPLAY.
           DISPLAY -12.3
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/fundamental.at:46: \${COMPILE} prog.cob"
echo fundamental.at:46 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/fundamental.at:46"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/fundamental.at:47: ./prog"
echo fundamental.at:47 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "abc
123
+123
-123
12.3
+12.3
-12.3
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/fundamental.at:47"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_1
#AT_START_2
# 2. fundamental.at:60: DISPLAY literals, DECIMAL-POINT is COMMA
at_setup_line='fundamental.at:60'
at_desc="DISPLAY literals, DECIMAL-POINT is COMMA"
$at_quiet $as_echo_n "  2: $at_desc       "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "2. fundamental.at:60: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       CONFIGURATION    SECTION.
       SPECIAL-NAMES.
           DECIMAL-POINT    IS COMMA.
       PROCEDURE        DIVISION.
           DISPLAY  12,3
           END-DISPLAY.
           DISPLAY +12,3
           END-DISPLAY.
           DISPLAY -12,3
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/fundamental.at:79: \${COMPILE} prog.cob"
echo fundamental.at:79 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/fundamental.at:79"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/fundamental.at:80: ./prog"
echo fundamental.at:80 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "12,3
+12,3
-12,3
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/fundamental.at:80"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_2
#AT_START_3
# 3. fundamental.at:88: Hexadecimal literal
at_setup_line='fundamental.at:88'
at_desc="Hexadecimal literal"
$at_quiet $as_echo_n "  3: $at_desc                            "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "3. fundamental.at:88: testing ..."
  $at_traceon


cat >dump.c <<'_ATEOF'

#include <stdio.h>
int dump (unsigned char *data);
int dump (unsigned char *data)
{
  int i;
  for (i = 0; i < 4; i++)
    printf ("%02x", data[i]);
  puts ("");
  return 0;
}
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/fundamental.at:103: \${CC} \${SHROPT} -o dump.\${SHREXT} dump.c"
echo fundamental.at:103 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${CC} ${SHROPT} -o dump.${SHREXT} dump.c ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${CC} ${SHROPT} -o dump.${SHREXT} dump.c ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/fundamental.at:103"

$at_failed && at_func_log_failure
$at_traceon; }


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       PROCEDURE        DIVISION.
           DISPLAY X"313233"
           END-DISPLAY.
           CALL "dump" USING X"000102"
           END-CALL.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/fundamental.at:116: \${COMPILE} prog.cob"
echo fundamental.at:116 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/fundamental.at:116"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/fundamental.at:117: ./prog"
echo fundamental.at:117 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "123
00010200
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/fundamental.at:117"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_3
#AT_START_4
# 4. fundamental.at:124: DISPLAY data items with VALUE clause
at_setup_line='fundamental.at:124'
at_desc="DISPLAY data items with VALUE clause"
$at_quiet $as_echo_n "  4: $at_desc           "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "4. fundamental.at:124: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X-ABC         PIC XXX   VALUE "abc".
       01 X-123         PIC 999   VALUE  123.
       01 X-P123        PIC S999  VALUE +123.
       01 X-N123        PIC S999  VALUE -123.
       01 X-12-3        PIC 99V9  VALUE  12.3.
       01 X-P12-3       PIC S99V9 VALUE +12.3.
       01 X-N12-3       PIC S99V9 VALUE -12.3.
       PROCEDURE        DIVISION.
           DISPLAY X-ABC
           END-DISPLAY.
           DISPLAY X-123
           END-DISPLAY.
           DISPLAY X-P123
           END-DISPLAY.
           DISPLAY X-N123
           END-DISPLAY.
           DISPLAY X-12-3
           END-DISPLAY.
           DISPLAY X-P12-3
           END-DISPLAY.
           DISPLAY X-N12-3
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/fundamental.at:156: \${COMPILE} prog.cob"
echo fundamental.at:156 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/fundamental.at:156"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/fundamental.at:157: ./prog"
echo fundamental.at:157 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "abc
123
+123
-123
12.3
+12.3
-12.3
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/fundamental.at:157"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_4
#AT_START_5
# 5. fundamental.at:169: DISPLAY data items with MOVE statement
at_setup_line='fundamental.at:169'
at_desc="DISPLAY data items with MOVE statement"
$at_quiet $as_echo_n "  5: $at_desc         "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "5. fundamental.at:169: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X-ABC         PIC XXX   VALUE "abc".
       01 X-123         PIC 999   VALUE  123.
       01 X-P123        PIC S999  VALUE +123.
       01 X-N123        PIC S999  VALUE -123.
       01 X-12-3        PIC 99V9  VALUE  12.3.
       01 X-P12-3       PIC S99V9 VALUE +12.3.
       01 X-N12-3       PIC S99V9 VALUE -12.3.
       PROCEDURE        DIVISION.
           MOVE "abc" TO X-ABC.    DISPLAY X-ABC
           END-DISPLAY.
           MOVE  123  TO X-123.    DISPLAY X-123
           END-DISPLAY.
           MOVE +123  TO X-P123.   DISPLAY X-P123
           END-DISPLAY.
           MOVE -123  TO X-N123.   DISPLAY X-N123
           END-DISPLAY.
           MOVE  12.3 TO X-12-3.   DISPLAY X-12-3
           END-DISPLAY.
           MOVE +12.3 TO X-P12-3.  DISPLAY X-P12-3
           END-DISPLAY.
           MOVE -12.3 TO X-N12-3.  DISPLAY X-N12-3
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/fundamental.at:201: \${COMPILE} prog.cob"
echo fundamental.at:201 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/fundamental.at:201"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/fundamental.at:202: ./prog"
echo fundamental.at:202 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "abc
123
+123
-123
12.3
+12.3
-12.3
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/fundamental.at:202"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_5
#AT_START_6
# 6. fundamental.at:215: GLOBAL at same level
at_setup_line='fundamental.at:215'
at_desc="GLOBAL at same level"
$at_quiet $as_echo_n "  6: $at_desc                           "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "6. fundamental.at:215: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01  X   PIC X(5) GLOBAL  VALUE "prog1".
       PROCEDURE        DIVISION.
           DISPLAY X
           END-DISPLAY.
           CALL "prog2"
           END-CALL
           CALL "prog3"
           END-CALL
           STOP RUN.
        IDENTIFICATION   DIVISION.
        PROGRAM-ID.      prog2.
        DATA DIVISION.
        WORKING-STORAGE SECTION.
        01  X   PIC X(5) GLOBAL  VALUE "prog2".
        PROCEDURE        DIVISION.
            DISPLAY X
            END-DISPLAY.
            EXIT PROGRAM.
        END PROGRAM prog2.
        IDENTIFICATION   DIVISION.
        PROGRAM-ID.      prog3.
        DATA DIVISION.
        WORKING-STORAGE SECTION.
        PROCEDURE        DIVISION.
            DISPLAY X
            END-DISPLAY.
            EXIT PROGRAM.
        END PROGRAM prog3.
       END PROGRAM prog.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/fundamental.at:253: \${COMPILE} prog.cob"
echo fundamental.at:253 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/fundamental.at:253"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/fundamental.at:254: ./prog"
echo fundamental.at:254 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "prog1
prog2
prog1
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/fundamental.at:254"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_6
#AT_START_7
# 7. fundamental.at:263: GLOBAL at lower level
at_setup_line='fundamental.at:263'
at_desc="GLOBAL at lower level"
$at_quiet $as_echo_n "  7: $at_desc                          "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "7. fundamental.at:263: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01  X   PIC X(5) GLOBAL  VALUE "prog1".
       PROCEDURE        DIVISION.
           DISPLAY X
           END-DISPLAY.
           CALL "prog2"
           END-CALL
           CALL "prog3"
           END-CALL
           STOP RUN.
        IDENTIFICATION   DIVISION.
        PROGRAM-ID.      prog2.
        DATA DIVISION.
        WORKING-STORAGE SECTION.
        01  X   PIC X(5) GLOBAL  VALUE "prog2".
        PROCEDURE        DIVISION.
            DISPLAY X
            END-DISPLAY.
            EXIT PROGRAM.
         IDENTIFICATION   DIVISION.
         PROGRAM-ID.      prog3.
         DATA DIVISION.
         WORKING-STORAGE SECTION.
         PROCEDURE        DIVISION.
             DISPLAY X
             END-DISPLAY.
             EXIT PROGRAM.
         END PROGRAM prog3.
        END PROGRAM prog2.
       END PROGRAM prog.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/fundamental.at:301: \${COMPILE} prog.cob"
echo fundamental.at:301 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/fundamental.at:301"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/fundamental.at:302: ./prog"
echo fundamental.at:302 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "prog1
prog2
prog2
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/fundamental.at:302"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_7
#AT_START_8
# 8. subscripts.at:28: non-numeric subscript
at_setup_line='subscripts.at:28'
at_desc="non-numeric subscript"
$at_quiet $as_echo_n "  8: $at_desc                          "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "8. subscripts.at:28: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G1.
         02 X           PIC X OCCURS 10.
       01 I             PIC X.
       PROCEDURE        DIVISION.
           DISPLAY X(I)
           END-DISPLAY.
           DISPLAY X(I + 1)
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:46: \${COMPILE_ONLY} prog.cob"
echo subscripts.at:46 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_ONLY} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_ONLY} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:10: Error: 'I' is not an integer value
prog.cob:12: Error: 'I' is not a numeric value
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/subscripts.at:46"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_8
#AT_START_9
# 9. subscripts.at:56: The range of subscripts
at_setup_line='subscripts.at:56'
at_desc="The range of subscripts"
$at_quiet $as_echo_n "  9: $at_desc                        "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "9. subscripts.at:56: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G1.
         02 X           OCCURS 2.
           03 Y         PIC X OCCURS 3.
       PROCEDURE        DIVISION.
           DISPLAY X(0)
           END-DISPLAY.
           DISPLAY X(1)
           END-DISPLAY.
           DISPLAY X(2)
           END-DISPLAY.
           DISPLAY X(3)
           END-DISPLAY.
           DISPLAY Y(1, 0)
           END-DISPLAY.
           DISPLAY Y(1, 1)
           END-DISPLAY.
           DISPLAY Y(1, 3)
           END-DISPLAY.
           DISPLAY Y(1, 4)
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:86: \${COMPILE_ONLY} prog.cob"
echo subscripts.at:86 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_ONLY} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_ONLY} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:10: Error: Subscript of 'X' out of bounds: 0
prog.cob:16: Error: Subscript of 'X' out of bounds: 3
prog.cob:18: Error: Subscript of 'Y' out of bounds: 0
prog.cob:24: Error: Subscript of 'Y' out of bounds: 4
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/subscripts.at:86"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_9
#AT_START_10
# 10. subscripts.at:96: Subscript out of bounds (1)
at_setup_line='subscripts.at:96'
at_desc="Subscript out of bounds (1)"
$at_quiet $as_echo_n " 10: $at_desc                    "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "10. subscripts.at:96: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G.
         02 X           PIC X OCCURS 10.
       01 I             PIC 9 VALUE 0.
       PROCEDURE        DIVISION.
           DISPLAY X(I)
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:112: \${COMPILE} -o prog prog.cob"
echo subscripts.at:112 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/subscripts.at:112"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:113: ./prog"
echo subscripts.at:113 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:10: libcob: Subscript of 'X' out of bounds: 0
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/subscripts.at:113"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_10
#AT_START_11
# 11. subscripts.at:120: Subscript out of bounds (2)
at_setup_line='subscripts.at:120'
at_desc="Subscript out of bounds (2)"
$at_quiet $as_echo_n " 11: $at_desc                    "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "11. subscripts.at:120: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G.
         02 X           PIC X OCCURS 10.
       01 I             PIC 99 VALUE 11.
       PROCEDURE        DIVISION.
           DISPLAY X(I)
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:136: \${COMPILE} -o prog prog.cob"
echo subscripts.at:136 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/subscripts.at:136"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:137: ./prog"
echo subscripts.at:137 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:10: libcob: Subscript of 'X' out of bounds: 11
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/subscripts.at:137"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_11
#AT_START_12
# 12. subscripts.at:143: Subscript out of bounds (3-1)
at_setup_line='subscripts.at:143'
at_desc="Subscript out of bounds (3-1)"
$at_quiet $as_echo_n " 12: $at_desc                  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "12. subscripts.at:143: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G.
         02 X           PIC X OCCURS 10.
       01 I             PIC 99 VALUE 11.
       PROCEDURE        DIVISION.
           IF "A" NOT = X(I)
               DISPLAY "DIFFER".
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:159: \${COMPILE} -o prog prog.cob"
echo subscripts.at:159 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/subscripts.at:159"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:160: ./prog"
echo subscripts.at:160 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:10: libcob: Subscript of 'X' out of bounds: 11
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/subscripts.at:160"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_12
#AT_START_13
# 13. subscripts.at:166: Subscript out of bounds (3-2)
at_setup_line='subscripts.at:166'
at_desc="Subscript out of bounds (3-2)"
$at_quiet $as_echo_n " 13: $at_desc                  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "13. subscripts.at:166: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G.
         02 X           PIC X OCCURS 10.
       01 I             PIC 99 VALUE 11.
       PROCEDURE        DIVISION.
           IF X(I) NOT = "A"
               DISPLAY "DIFFER".
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:182: \${COMPILE} -o prog prog.cob"
echo subscripts.at:182 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/subscripts.at:182"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:183: ./prog"
echo subscripts.at:183 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:10: libcob: Subscript of 'X' out of bounds: 11
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/subscripts.at:183"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_13
#AT_START_14
# 14. subscripts.at:189: Subscript out of bounds (3-3)
at_setup_line='subscripts.at:189'
at_desc="Subscript out of bounds (3-3)"
$at_quiet $as_echo_n " 14: $at_desc                  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "14. subscripts.at:189: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G.
         02 X           PIC XX OCCURS 10.
       01 I             PIC 99 VALUE 11.
       PROCEDURE        DIVISION.
           IF X(I) NOT = "AA"
               DISPLAY "DIFFER".
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:205: \${COMPILE} -o prog prog.cob"
echo subscripts.at:205 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/subscripts.at:205"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:206: ./prog"
echo subscripts.at:206 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:10: libcob: Subscript of 'X' out of bounds: 11
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/subscripts.at:206"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_14
#AT_START_15
# 15. subscripts.at:212: Subscript out of bounds (3-4)
at_setup_line='subscripts.at:212'
at_desc="Subscript out of bounds (3-4)"
$at_quiet $as_echo_n " 15: $at_desc                  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "15. subscripts.at:212: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G.
         02 X           PIC 9  BINARY OCCURS 10.
       01 I             PIC 99 VALUE 11.
       PROCEDURE        DIVISION.
           IF 5 NOT = X(I)
               DISPLAY "DIFFER".
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:228: \${COMPILE} -o prog prog.cob"
echo subscripts.at:228 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/subscripts.at:228"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:229: ./prog"
echo subscripts.at:229 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:10: libcob: Subscript of 'X' out of bounds: 11
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/subscripts.at:229"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_15
#AT_START_16
# 16. subscripts.at:235: Value of DEPENDING ON N out of bounds (lower)
at_setup_line='subscripts.at:235'
at_desc="Value of DEPENDING ON N out of bounds (lower)"
$at_quiet $as_echo_n " 16: $at_desc  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "16. subscripts.at:235: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G.
         02 X           PIC X OCCURS 4 TO 6 DEPENDING ON N.
       01 N             PIC 9 VALUE 3.
       PROCEDURE        DIVISION.
           DISPLAY X(5)
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:251: \${COMPILE} -o prog prog.cob"
echo subscripts.at:251 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/subscripts.at:251"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:252: ./prog"
echo subscripts.at:252 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:10: libcob: OCCURS DEPENDING ON 'N' out of bounds: 3
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/subscripts.at:252"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_16
#AT_START_17
# 17. subscripts.at:259: Value of DEPENDING ON N out of bounds (upper)
at_setup_line='subscripts.at:259'
at_desc="Value of DEPENDING ON N out of bounds (upper)"
$at_quiet $as_echo_n " 17: $at_desc  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "17. subscripts.at:259: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G.
         02 X           PIC X OCCURS 4 TO 6 DEPENDING ON N.
       01 N             PIC 9 VALUE 7.
       PROCEDURE        DIVISION.
           DISPLAY X(5)
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:275: \${COMPILE} -o prog prog.cob"
echo subscripts.at:275 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/subscripts.at:275"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:276: ./prog"
echo subscripts.at:276 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:10: libcob: OCCURS DEPENDING ON 'N' out of bounds: 7
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/subscripts.at:276"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_17
#AT_START_18
# 18. subscripts.at:283: Subscript bounds with ODO (lower)
at_setup_line='subscripts.at:283'
at_desc="Subscript bounds with ODO (lower)"
$at_quiet $as_echo_n " 18: $at_desc              "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "18. subscripts.at:283: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G.
         02 X           PIC X OCCURS 4 TO 6 DEPENDING ON N.
       01 N             PIC 9 VALUE 4.
       PROCEDURE        DIVISION.
           DISPLAY X(0)
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:299: \${COMPILE} -o prog prog.cob"
echo subscripts.at:299 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:10: Error: Subscript of 'X' out of bounds: 0
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/subscripts.at:299"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_18
#AT_START_19
# 19. subscripts.at:306: Subscript bounds with ODO (upper)
at_setup_line='subscripts.at:306'
at_desc="Subscript bounds with ODO (upper)"
$at_quiet $as_echo_n " 19: $at_desc              "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "19. subscripts.at:306: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G.
         02 X           PIC X OCCURS 4 TO 6 DEPENDING ON N.
       01 N             PIC 9 VALUE 4.
       PROCEDURE        DIVISION.
           DISPLAY X(7)
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:322: \${COMPILE} -o prog prog.cob"
echo subscripts.at:322 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:10: Error: Subscript of 'X' out of bounds: 7
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/subscripts.at:322"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_19
#AT_START_20
# 20. subscripts.at:329: Subscript bounds with ODO
at_setup_line='subscripts.at:329'
at_desc="Subscript bounds with ODO"
$at_quiet $as_echo_n " 20: $at_desc                      "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "20. subscripts.at:329: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G.
         02 X           PIC X OCCURS 4 TO 6 DEPENDING ON N.
       01 N             PIC 9 VALUE 4.
       PROCEDURE        DIVISION.
           DISPLAY X(5)
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:345: \${COMPILE} -o prog prog.cob"
echo subscripts.at:345 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/subscripts.at:345"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:346: ./prog"
echo subscripts.at:346 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:10: libcob: Subscript of 'X' out of bounds: 5
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/subscripts.at:346"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_20
#AT_START_21
# 21. subscripts.at:355: Subscript by arithmetic expression
at_setup_line='subscripts.at:355'
at_desc="Subscript by arithmetic expression"
$at_quiet $as_echo_n " 21: $at_desc             "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "21. subscripts.at:355: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G             VALUE "1234".
         02 X           PIC X OCCURS 4.
       PROCEDURE        DIVISION.
           DISPLAY X((3 + 1) / 2) NO ADVANCING
           END-DISPLAY.
           DISPLAY X(2 ** 2) NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:372: \${COMPILE} -o prog prog.cob"
echo subscripts.at:372 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/subscripts.at:372"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:373: ./prog"
echo subscripts.at:373 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "24" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/subscripts.at:373"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_21
#AT_START_22
# 22. subscripts.at:378: Subscript out of bounds in MOVE (1)
at_setup_line='subscripts.at:378'
at_desc="Subscript out of bounds in MOVE (1)"
$at_quiet $as_echo_n " 22: $at_desc            "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "22. subscripts.at:378: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G.
         02 X           PIC X OCCURS 10.
       01 I             PIC 9 VALUE 0.
       01 Z             PIC X.
       PROCEDURE        DIVISION.
           MOVE X(I) TO Z.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:394: \${COMPILE} -o prog prog.cob"
echo subscripts.at:394 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/subscripts.at:394"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:395: ./prog"
echo subscripts.at:395 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:11: libcob: Subscript of 'X' out of bounds: 0
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/subscripts.at:395"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_22
#AT_START_23
# 23. subscripts.at:402: Subscript out of bounds in MOVE (2)
at_setup_line='subscripts.at:402'
at_desc="Subscript out of bounds in MOVE (2)"
$at_quiet $as_echo_n " 23: $at_desc            "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "23. subscripts.at:402: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G.
         02 X           PIC X OCCURS 10.
       01 I             PIC 9 VALUE 0.
       01 Z             PIC X.
       PROCEDURE        DIVISION.
           MOVE Z TO X(I).
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:418: \${COMPILE} -o prog prog.cob"
echo subscripts.at:418 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/subscripts.at:418"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/subscripts.at:419: ./prog"
echo subscripts.at:419 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:11: libcob: Subscript of 'X' out of bounds: 0
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/subscripts.at:419"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_23
#AT_START_24
# 24. ref-mod.at:35: Separate sign positions
at_setup_line='ref-mod.at:35'
at_desc="Separate sign positions"
$at_quiet $as_echo_n " 24: $at_desc                        "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "24. ref-mod.at:35: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC S9 VALUE -1 SIGN LEADING SEPARATE.
       01 Y             PIC S9 VALUE -1 SIGN TRAILING SEPARATE.
       PROCEDURE        DIVISION.
           DISPLAY X(1:1) X(2:1) NO ADVANCING
           END-DISPLAY.
           DISPLAY Y(1:1) Y(2:1) NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/ref-mod.at:52: \${COMPILE} -o prog prog.cob"
echo ref-mod.at:52 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/ref-mod.at:52"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/ref-mod.at:53: ./prog"
echo ref-mod.at:53 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "-11-" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/ref-mod.at:53"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_24
#AT_START_25
# 25. ref-mod.at:60: Static reference modification
at_setup_line='ref-mod.at:60'
at_desc="Static reference modification"
$at_quiet $as_echo_n " 25: $at_desc                  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "25. ref-mod.at:60: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(4) VALUE "abcd".
       PROCEDURE        DIVISION.
           DISPLAY X(1:1) ":" X(1:2) ":" X(1:3) ":" X(1:4) ":" X(1:)
           END-DISPLAY.
           DISPLAY X(2:1) ":" X(2:2) ":" X(2:3) ":" X(2:)
           END-DISPLAY.
           DISPLAY X(3:1) ":" X(3:2) ":" X(3:)
           END-DISPLAY.
           DISPLAY X(4:1) ":" X(4:)
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/ref-mod.at:80: \${COMPILE} -o prog prog.cob"
echo ref-mod.at:80 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/ref-mod.at:80"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/ref-mod.at:81: ./prog"
echo ref-mod.at:81 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "a:ab:abc:abcd:abcd
b:bc:bcd:bcd
c:cd:cd
d:d
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/ref-mod.at:81"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_25
#AT_START_26
# 26. ref-mod.at:90: Dynamic reference modification
at_setup_line='ref-mod.at:90'
at_desc="Dynamic reference modification"
$at_quiet $as_echo_n " 26: $at_desc                 "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "26. ref-mod.at:90: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(4) VALUE "abcd".
       01 I             PIC 9.
       PROCEDURE        DIVISION.
           MOVE 1 TO I. DISPLAY X(I:1)
           END-DISPLAY.
           MOVE 4 TO I. DISPLAY X(I:1)
           END-DISPLAY.
           MOVE 1 TO I. DISPLAY X(1:I)
           END-DISPLAY.
           MOVE 4 TO I. DISPLAY X(1:I)
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/ref-mod.at:111: \${COMPILE} -o prog prog.cob"
echo ref-mod.at:111 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/ref-mod.at:111"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/ref-mod.at:112: ./prog"
echo ref-mod.at:112 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "a
d
a
abcd
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/ref-mod.at:112"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_26
#AT_START_27
# 27. ref-mod.at:121: Static out of bounds
at_setup_line='ref-mod.at:121'
at_desc="Static out of bounds"
$at_quiet $as_echo_n " 27: $at_desc                           "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "27. ref-mod.at:121: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(4).
       PROCEDURE        DIVISION.
           DISPLAY X(0:1)
           END-DISPLAY.
           DISPLAY X(5:1)
           END-DISPLAY.
           DISPLAY X(1:0)
           END-DISPLAY.
           DISPLAY X(1:5)
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/ref-mod.at:141: \${COMPILE_ONLY} prog.cob"
echo ref-mod.at:141 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_ONLY} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_ONLY} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:8: Error: Offset of 'X' out of bounds: 0
prog.cob:10: Error: Offset of 'X' out of bounds: 5
prog.cob:12: Error: Length of 'X' out of bounds: 0
prog.cob:14: Error: Length of 'X' out of bounds: 5
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/ref-mod.at:141"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_27
#AT_START_28
# 28. ref-mod.at:150: Offset underflow
at_setup_line='ref-mod.at:150'
at_desc="Offset underflow"
$at_quiet $as_echo_n " 28: $at_desc                               "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "28. ref-mod.at:150: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(4) VALUE "abcd".
       01 I             PIC 9 VALUE 0.
       PROCEDURE        DIVISION.
           DISPLAY X(I:1) NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/ref-mod.at:165: \${COMPILE} -o prog prog.cob"
echo ref-mod.at:165 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/ref-mod.at:165"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/ref-mod.at:166: ./prog"
echo ref-mod.at:166 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:9: libcob: Offset of 'X' out of bounds: 0
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/ref-mod.at:166"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_28
#AT_START_29
# 29. ref-mod.at:172: Offset overflow
at_setup_line='ref-mod.at:172'
at_desc="Offset overflow"
$at_quiet $as_echo_n " 29: $at_desc                                "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "29. ref-mod.at:172: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(4) VALUE "abcd".
       01 I             PIC 9 VALUE 5.
       PROCEDURE        DIVISION.
           DISPLAY X(I:1) NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/ref-mod.at:187: \${COMPILE} -o prog prog.cob"
echo ref-mod.at:187 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/ref-mod.at:187"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/ref-mod.at:188: ./prog"
echo ref-mod.at:188 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:9: libcob: Offset of 'X' out of bounds: 5
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/ref-mod.at:188"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_29
#AT_START_30
# 30. ref-mod.at:194: Length underflow
at_setup_line='ref-mod.at:194'
at_desc="Length underflow"
$at_quiet $as_echo_n " 30: $at_desc                               "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "30. ref-mod.at:194: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(4) VALUE "abcd".
       01 I             PIC 9 VALUE 0.
       PROCEDURE        DIVISION.
           DISPLAY X(1:I) NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/ref-mod.at:209: \${COMPILE} -o prog prog.cob"
echo ref-mod.at:209 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/ref-mod.at:209"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/ref-mod.at:210: ./prog"
echo ref-mod.at:210 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:9: libcob: Length of 'X' out of bounds: 0
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/ref-mod.at:210"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_30
#AT_START_31
# 31. ref-mod.at:216: Length overflow
at_setup_line='ref-mod.at:216'
at_desc="Length overflow"
$at_quiet $as_echo_n " 31: $at_desc                                "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "31. ref-mod.at:216: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(4) VALUE "abcd".
       01 I             PIC 9 VALUE 5.
       PROCEDURE        DIVISION.
           DISPLAY X(1:I) NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/ref-mod.at:231: \${COMPILE} -o prog prog.cob"
echo ref-mod.at:231 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/ref-mod.at:231"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/ref-mod.at:232: ./prog"
echo ref-mod.at:232 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:9: libcob: Length of 'X' out of bounds: 5
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/ref-mod.at:232"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_31
#AT_START_32
# 32. ref-mod.at:241: Offset out of bounds in MOVE (1)
at_setup_line='ref-mod.at:241'
at_desc="Offset out of bounds in MOVE (1)"
$at_quiet $as_echo_n " 32: $at_desc               "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "32. ref-mod.at:241: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(4) VALUE "abcd".
       01 I             PIC 9 VALUE 0.
       01 Z             PIC X(4).
       PROCEDURE        DIVISION.
           MOVE X(I:4) TO Z.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/ref-mod.at:256: \${COMPILE} -o prog prog.cob"
echo ref-mod.at:256 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/ref-mod.at:256"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/ref-mod.at:257: ./prog"
echo ref-mod.at:257 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:10: libcob: Offset of 'X' out of bounds: 0
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/ref-mod.at:257"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_32
#AT_START_33
# 33. ref-mod.at:264: Offset out of bounds in MOVE (2)
at_setup_line='ref-mod.at:264'
at_desc="Offset out of bounds in MOVE (2)"
$at_quiet $as_echo_n " 33: $at_desc               "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "33. ref-mod.at:264: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(4).
       01 I             PIC 9 VALUE 0.
       01 Z             PIC X(4) VALUE "abcd".
       PROCEDURE        DIVISION.
           MOVE Z TO X(I:4).
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/ref-mod.at:279: \${COMPILE} -o prog prog.cob"
echo ref-mod.at:279 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/ref-mod.at:279"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/ref-mod.at:280: ./prog"
echo ref-mod.at:280 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:10: libcob: Offset of 'X' out of bounds: 0
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/ref-mod.at:280"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_33
#AT_START_34
# 34. accept.at:23: ACCEPT
at_setup_line='accept.at:23'
at_desc="ACCEPT"
$at_quiet $as_echo_n " 34: $at_desc                                         "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "34. accept.at:23: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(8).
       PROCEDURE        DIVISION.
           ACCEPT X FROM DATE
           END-ACCEPT.
           INSPECT X CONVERTING "012345678" TO "999999999".
           DISPLAY "(" X ")"
           END-DISPLAY.
           ACCEPT X FROM DATE YYYYMMDD
           END-ACCEPT.
           INSPECT X CONVERTING "012345678" TO "999999999".
           DISPLAY "(" X ")"
           END-DISPLAY.
           ACCEPT X FROM DAY
           END-ACCEPT.
           INSPECT X CONVERTING "012345678" TO "999999999".
           DISPLAY "(" X ")"
           END-DISPLAY.
           ACCEPT X FROM DAY YYYYDDD
           END-ACCEPT.
           INSPECT X CONVERTING "012345678" TO "999999999".
           DISPLAY "(" X ")"
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/accept.at:55: \${COMPILE} -o prog prog.cob"
echo accept.at:55 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/accept.at:55"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/accept.at:56: ./prog"
echo accept.at:56 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "(999999  )
(99999999)
(99999   )
(9999999 )
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/accept.at:56"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_34
#AT_START_35
# 35. initialize.at:27: INITIALIZE group entry with OCCURS
at_setup_line='initialize.at:27'
at_desc="INITIALIZE group entry with OCCURS"
$at_quiet $as_echo_n " 35: $at_desc             "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "35. initialize.at:27: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G1.
         02 G2          OCCURS 2.
           03 X1        PIC X.
           03 X2        PIC 9.
       PROCEDURE        DIVISION.
           MOVE SPACE TO G1.
           INITIALIZE G2 (2).
           DISPLAY G1 NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/initialize.at:46: \${COMPILE} -o prog prog.cob"
echo initialize.at:46 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/initialize.at:46"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/initialize.at:47: ./prog"
echo initialize.at:47 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "   0" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/initialize.at:47"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_35
#AT_START_36
# 36. initialize.at:52: INITIALIZE OCCURS with numeric edited
at_setup_line='initialize.at:52'
at_desc="INITIALIZE OCCURS with numeric edited"
$at_quiet $as_echo_n " 36: $at_desc          "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "36. initialize.at:52: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G1.
         02 G2          OCCURS 5.
           03 X         PIC Z9.
       PROCEDURE        DIVISION.
           INITIALIZE G1.
           DISPLAY G1 NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/initialize.at:69: \${COMPILE} -o prog prog.cob"
echo initialize.at:69 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/initialize.at:69"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/initialize.at:70: ./prog"
echo initialize.at:70 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo " 0 0 0 0 0" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/initialize.at:70"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_36
#AT_START_37
# 37. initialize.at:75: INITIALIZE complex group (1)
at_setup_line='initialize.at:75'
at_desc="INITIALIZE complex group (1)"
$at_quiet $as_echo_n " 37: $at_desc                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "37. initialize.at:75: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G1.
         02 X           PIC X.
         02 G2          OCCURS 2.
           03 Y         PIC 9.
         02 Z           PIC 9.
       PROCEDURE        DIVISION.
           INITIALIZE G1.
           DISPLAY G1 NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/initialize.at:94: \${COMPILE} -o prog prog.cob"
echo initialize.at:94 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/initialize.at:94"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/initialize.at:95: ./prog"
echo initialize.at:95 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo " 000" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/initialize.at:95"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_37
#AT_START_38
# 38. initialize.at:99: INITIALIZE complex group (2)
at_setup_line='initialize.at:99'
at_desc="INITIALIZE complex group (2)"
$at_quiet $as_echo_n " 38: $at_desc                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "38. initialize.at:99: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G1.
         02 G2          OCCURS 2.
           03 X         PIC 9.
           03 Y         PIC X OCCURS 2.
           03 Z         PIC X.
       PROCEDURE        DIVISION.
           INITIALIZE G1.
           DISPLAY G1 NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/initialize.at:118: \${COMPILE} -o prog prog.cob"
echo initialize.at:118 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/initialize.at:118"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/initialize.at:119: ./prog"
echo initialize.at:119 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "0   0   " | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/initialize.at:119"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_38
#AT_START_39
# 39. initialize.at:123: INITIALIZE with REDEFINES
at_setup_line='initialize.at:123'
at_desc="INITIALIZE with REDEFINES"
$at_quiet $as_echo_n " 39: $at_desc                      "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "39. initialize.at:123: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G1.
         02 X           PIC X.
         02 Y           REDEFINES X PIC 9.
         02 Z           PIC 9.
       PROCEDURE        DIVISION.
           INITIALIZE G1.
           DISPLAY G1 NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/initialize.at:141: \${COMPILE} -o prog prog.cob"
echo initialize.at:141 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/initialize.at:141"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/initialize.at:142: ./prog"
echo initialize.at:142 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo " 0" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/initialize.at:142"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_39
#AT_START_40
# 40. misc.at:21: Source file not found
at_setup_line='misc.at:21'
at_desc="Source file not found"
$at_quiet $as_echo_n " 40: $at_desc                          "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "40. misc.at:21: testing ..."
  $at_traceon


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:23: \${COMPILE_ONLY} prog.cob"
echo misc.at:23 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_ONLY} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_ONLY} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "cobc: prog.cob: No such file or directory
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/misc.at:23"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_40
#AT_START_41
# 41. misc.at:30: Comma separator without space
at_setup_line='misc.at:30'
at_desc="Comma separator without space"
$at_quiet $as_echo_n " 41: $at_desc                  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "41. misc.at:30: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       PROCEDURE        DIVISION.
           DISPLAY 1,1,1 NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:41: \${COMPILE} -o prog prog.cob"
echo misc.at:41 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:41"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:42: ./prog"
echo misc.at:42 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "111" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:42"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_41
#AT_START_42
# 42. misc.at:47: LOCAL-STORAGE
at_setup_line='misc.at:47'
at_desc="LOCAL-STORAGE"
$at_quiet $as_echo_n " 42: $at_desc                                  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "42. misc.at:47: testing ..."
  $at_traceon


cat >callee.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      callee.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 WRK-X         PIC XXX VALUE "abc".
       LOCAL-STORAGE    SECTION.
       01 LCL-X         PIC XXX VALUE "abc".
       PROCEDURE        DIVISION.
           DISPLAY "WRK-X = " WRK-X
           END-DISPLAY.
           DISPLAY "LCL-X = " LCL-X
           END-DISPLAY.
           MOVE ZERO TO WRK-X LCL-X.
           EXIT PROGRAM.
_ATEOF


cat >caller.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      caller.
       PROCEDURE        DIVISION.
           CALL "callee"
           END-CALL.
           CALL "callee"
           END-CALL.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:77: \${COMPILE_MODULE} callee.cob"
echo misc.at:77 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} callee.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} callee.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:77"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:78: \${COMPILE} -o prog caller.cob"
echo misc.at:78 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog caller.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog caller.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:78"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:79: ./prog"
echo misc.at:79 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "WRK-X = abc
LCL-X = abc
WRK-X = 000
LCL-X = abc
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:79"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_42
#AT_START_43
# 43. misc.at:89: EXTERNAL data item
at_setup_line='misc.at:89'
at_desc="EXTERNAL data item"
$at_quiet $as_echo_n " 43: $at_desc                             "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "43. misc.at:89: testing ..."
  $at_traceon


cat >callee.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      callee.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 WRK-VAR       PIC X(5).
       01 EXT-VAR       PIC X(5) EXTERNAL.
       PROCEDURE        DIVISION.
           DISPLAY EXT-VAR
           END-DISPLAY.
           MOVE "World" TO EXT-VAR.
           EXIT PROGRAM.
_ATEOF


cat >caller.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      caller.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 EXT-VAR       PIC X(5) EXTERNAL.
       01 WRK-VAR       PIC X(5).
       PROCEDURE        DIVISION.
           MOVE "Hello" TO EXT-VAR.
           CALL "callee"
           END-CALL.
           DISPLAY EXT-VAR
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:121: \${COMPILE_MODULE} callee.cob"
echo misc.at:121 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} callee.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} callee.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:121"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:122: \${COMPILE} -o prog caller.cob"
echo misc.at:122 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog caller.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog caller.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:122"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:123: ./prog"
echo misc.at:123 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "Hello
World
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:123"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_43
#AT_START_44
# 44. misc.at:131: EXTERNAL AS data item
at_setup_line='misc.at:131'
at_desc="EXTERNAL AS data item"
$at_quiet $as_echo_n " 44: $at_desc                          "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "44. misc.at:131: testing ..."
  $at_traceon


cat >callee.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      callee.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 PRG-VAR       PIC X(5) EXTERNAL AS "WRK-VAR".
       01 EXT-VAR       PIC X(5) EXTERNAL.
       PROCEDURE        DIVISION.
           DISPLAY PRG-VAR
           END-DISPLAY.
           DISPLAY EXT-VAR
           END-DISPLAY.
           MOVE "World" TO EXT-VAR.
           EXIT PROGRAM.
_ATEOF


cat >caller.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      caller.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 MYVAR         PIC X(5) EXTERNAL AS "EXT-VAR".
       01 WRK-VAR       PIC X(5) EXTERNAL.
       PROCEDURE        DIVISION.
           MOVE "Extrn" TO WRK-VAR.
           MOVE "Hello" TO MYVAR.
           CALL "callee"
           END-CALL.
           DISPLAY MYVAR
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:166: \${COMPILE_MODULE} callee.cob"
echo misc.at:166 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} callee.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} callee.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:166"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:167: \${COMPILE} -o prog caller.cob"
echo misc.at:167 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog caller.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog caller.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:167"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:168: ./prog"
echo misc.at:168 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "Extrn
Hello
World
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:168"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_44
#AT_START_45
# 45. misc.at:177: cobcrun validation
at_setup_line='misc.at:177'
at_desc="cobcrun validation"
$at_quiet $as_echo_n " 45: $at_desc                             "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "45. misc.at:177: testing ..."
  $at_traceon


cat >callee.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      callee.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 WRK-VAR       PIC X(5).
       01 EXT-VAR       PIC X(5) EXTERNAL.
       PROCEDURE        DIVISION.
           DISPLAY EXT-VAR
           END-DISPLAY.
           MOVE "World" TO EXT-VAR.
           EXIT PROGRAM.
_ATEOF


cat >caller.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      caller.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 EXT-VAR       PIC X(5) EXTERNAL.
       01 WRK-VAR       PIC X(5).
       PROCEDURE        DIVISION.
           MOVE "Hello" TO EXT-VAR.
           CALL "callee"
           END-CALL.
           DISPLAY EXT-VAR
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:209: \${COMPILE_MODULE} callee.cob"
echo misc.at:209 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} callee.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} callee.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:209"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:210: \${COMPILE_MODULE} caller.cob"
echo misc.at:210 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} caller.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} caller.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:210"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:211: \${COBCRUN} caller"
echo misc.at:211 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COBCRUN} caller ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COBCRUN} caller ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "Hello
World
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:211"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_45
#AT_START_46
# 46. misc.at:221: MOVE to itself
at_setup_line='misc.at:221'
at_desc="MOVE to itself"
$at_quiet $as_echo_n " 46: $at_desc                                 "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "46. misc.at:221: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC 99 VALUE 12.
       PROCEDURE        DIVISION.
           MOVE X TO X.
           DISPLAY X NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:236: \${COMPILE} -o prog prog.cob"
echo misc.at:236 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:236"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:237: ./prog"
echo misc.at:237 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "12" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:237"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_46
#AT_START_47
# 47. misc.at:241: MOVE with refmod
at_setup_line='misc.at:241'
at_desc="MOVE with refmod"
$at_quiet $as_echo_n " 47: $at_desc                               "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "47. misc.at:241: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC 9(4) VALUE 0.
       PROCEDURE        DIVISION.
           MOVE "1" TO X(1:1).
           DISPLAY X NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:256: \${COMPILE} -o prog prog.cob"
echo misc.at:256 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:256"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:257: ./prog"
echo misc.at:257 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "1000" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:257"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_47
#AT_START_48
# 48. misc.at:261: MOVE with refmod (variable)
at_setup_line='misc.at:261'
at_desc="MOVE with refmod (variable)"
$at_quiet $as_echo_n " 48: $at_desc                    "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "48. misc.at:261: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(4) VALUE "1234".
       01 Y             PIC X(4) VALUE "abcd".
       01 I             PIC 9 VALUE 1.
       PROCEDURE        DIVISION.
           MOVE X(1:I) TO Y.
           DISPLAY Y NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:278: \${COMPILE} -o prog prog.cob"
echo misc.at:278 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:278"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:279: ./prog"
echo misc.at:279 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "1   " | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:279"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_48
#AT_START_49
# 49. misc.at:283: MOVE with group refmod
at_setup_line='misc.at:283'
at_desc="MOVE with group refmod"
$at_quiet $as_echo_n " 49: $at_desc                         "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "49. misc.at:283: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G.
         02 X           PIC 9999 VALUE 1234.
       PROCEDURE        DIVISION.
           MOVE "99" TO G(3:2).
           DISPLAY G NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:299: \${COMPILE} -o prog prog.cob"
echo misc.at:299 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:299"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:300: ./prog"
echo misc.at:300 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "1299" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:300"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_49
#AT_START_50
# 50. misc.at:304: MOVE indexes
at_setup_line='misc.at:304'
at_desc="MOVE indexes"
$at_quiet $as_echo_n " 50: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "50. misc.at:304: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G.
         02 X           PIC X OCCURS 10 INDEXED I.
       PROCEDURE        DIVISION.
           SET I TO ZERO.
           MOVE I TO X(1).
           DISPLAY X(1) NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:321: \${COMPILE} -o prog prog.cob"
echo misc.at:321 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:321"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:322: ./prog"
echo misc.at:322 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "0" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:322"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_50
#AT_START_51
# 51. misc.at:326: MOVE X'00'
at_setup_line='misc.at:326'
at_desc="MOVE X'00'"
$at_quiet $as_echo_n " 51: $at_desc                                     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "51. misc.at:326: testing ..."
  $at_traceon


cat >dump.c <<'_ATEOF'

#include <stdio.h>
int dump (unsigned char *data);
int dump (unsigned char *data)
{
  printf ("%02x%02x%02x", data[0], data[1], data[2]);
  return 0;
}
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:338: \${CC} \${SHROPT} -o dump.\${SHREXT} dump.c"
echo misc.at:338 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${CC} ${SHROPT} -o dump.${SHREXT} dump.c ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${CC} ${SHROPT} -o dump.${SHREXT} dump.c ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:338"

$at_failed && at_func_log_failure
$at_traceon; }


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC XXX.
       PROCEDURE        DIVISION.
           MOVE X"000102" TO X.
           CALL "dump" USING X
           END-CALL.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:353: \${COMPILE} -o prog prog.cob"
echo misc.at:353 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:353"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:354: ./prog"
echo misc.at:354 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "000102" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:354"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_51
#AT_START_52
# 52. misc.at:361: Level 01 subscripts
at_setup_line='misc.at:361'
at_desc="Level 01 subscripts"
$at_quiet $as_echo_n " 52: $at_desc                            "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "52. misc.at:361: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X OCCURS 10.
       PROCEDURE        DIVISION.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:373: \${COMPILE_ONLY} prog.cob"
echo misc.at:373 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_ONLY} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_ONLY} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:6: Error: Level 01 item 'X' cannot have OCCURS clause
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/misc.at:373"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_52
#AT_START_53
# 53. misc.at:382: Class check with reference modification
at_setup_line='misc.at:382'
at_desc="Class check with reference modification"
$at_quiet $as_echo_n " 53: $at_desc        "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "53. misc.at:382: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(6) VALUE "123   ".
       PROCEDURE        DIVISION.
           IF X(1:3) NUMERIC
               DISPLAY "OK" NO ADVANCING
               END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:398: \${COMPILE} -o prog prog.cob"
echo misc.at:398 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:398"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:399: ./prog"
echo misc.at:399 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:399"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_53
#AT_START_54
# 54. misc.at:403: Index and parenthesized expression
at_setup_line='misc.at:403'
at_desc="Index and parenthesized expression"
$at_quiet $as_echo_n " 54: $at_desc             "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "54. misc.at:403: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G.
         02 X           PIC X OCCURS 1 INDEXED BY I.
       PROCEDURE        DIVISION.
         IF I < (I + 2)
           DISPLAY "OK"
           END-DISPLAY
         END-IF.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:419: \${COMPILE_ONLY} -o prog prog.cob"
echo misc.at:419 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_ONLY} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_ONLY} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:419"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_54
#AT_START_55
# 55. misc.at:423: String concatenation
at_setup_line='misc.at:423'
at_desc="String concatenation"
$at_quiet $as_echo_n " 55: $at_desc                           "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "55. misc.at:423: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(333) VALUE
           '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWX
      -    'YZ0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUV
      -    'WXYZ0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRST
      -    'UVWXYZ0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQR
      -    'STUVWXYZ0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOP
      -    'QRSTUVWXYZ'.
       PROCEDURE        DIVISION.
           DISPLAY X NO ADVANCING
           END-DISPLAY.
           MOVE
           'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567
      -    '89abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012345
      -    '6789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123
      -    '456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01
      -    '23456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
      -    '0123456789' TO X.
           DISPLAY X NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:452: \${COMPILE} -o prog prog.cob"
echo misc.at:452 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:452"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:453: ./prog"
echo misc.at:453 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ                       abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789                       " | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:453"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_55
#AT_START_56
# 56. misc.at:457: Alphanumeric and binary numeric
at_setup_line='misc.at:457'
at_desc="Alphanumeric and binary numeric"
$at_quiet $as_echo_n " 56: $at_desc                "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "56. misc.at:457: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X-X           PIC XXXX VALUE "0001".
       01 X-9           PIC 9999 COMP VALUE 1.
       PROCEDURE        DIVISION.
         IF X-X = X-9
           DISPLAY "OK" NO ADVANCING
           END-DISPLAY
         END-IF.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:473: \${COMPILE} -o prog prog.cob"
echo misc.at:473 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:473"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:474: ./prog"
echo misc.at:474 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:474"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_56
#AT_START_57
# 57. misc.at:481: Dynamic call with static linking
at_setup_line='misc.at:481'
at_desc="Dynamic call with static linking"
$at_quiet $as_echo_n " 57: $at_desc               "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "57. misc.at:481: testing ..."
  $at_traceon


cat >callee.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      callee.
       PROCEDURE        DIVISION.
           DISPLAY "OK" NO ADVANCING
           END-DISPLAY.
_ATEOF


cat >caller.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      caller.
       PROCEDURE        DIVISION.
           CALL "callee"
           END-CALL.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:499: \${COMPILE_MODULE} -c callee.cob"
echo misc.at:499 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} -c callee.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} -c callee.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:499"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:500: \${COMPILE} -c caller.cob"
echo misc.at:500 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -c caller.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -c caller.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:500"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:501: \${COMPILE} -o prog caller.\${OBJEXT} callee.\${OBJEXT}"
echo misc.at:501 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog caller.${OBJEXT} callee.${OBJEXT} ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog caller.${OBJEXT} callee.${OBJEXT} ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:501"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:502: ./prog"
echo misc.at:502 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:502"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_57
#AT_START_58
# 58. misc.at:506: CALL m1. CALL m2. CALL m1.
at_setup_line='misc.at:506'
at_desc="CALL m1. CALL m2. CALL m1."
$at_quiet $as_echo_n " 58: $at_desc                     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "58. misc.at:506: testing ..."
  $at_traceon


cat >m1.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      m1.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC 9(4).
       PROCEDURE        DIVISION.
           COMPUTE X = 1 + 2
           END-COMPUTE.
           DISPLAY X
           END-DISPLAY.
_ATEOF


cat >m2.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      m2.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC 9(4).
       PROCEDURE        DIVISION.
           COMPUTE X = 3 + 4
           END-COMPUTE.
           DISPLAY X
           END-DISPLAY.
_ATEOF


cat >caller.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      caller.
       PROCEDURE        DIVISION.
           CALL "m1"
           END-CALL.
           CALL "m2"
           END-CALL.
           CALL "m1"
           END-CALL.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:547: \${COMPILE_MODULE} m1.cob"
echo misc.at:547 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} m1.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} m1.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:547"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:548: \${COMPILE_MODULE} m2.cob"
echo misc.at:548 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} m2.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} m2.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:548"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:549: \${COMPILE} -o caller caller.cob"
echo misc.at:549 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o caller caller.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o caller caller.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:549"

$at_failed && at_func_log_failure
$at_traceon; }


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:551: ./caller"
echo misc.at:551 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./caller ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./caller ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "0003
0007
0003
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:551"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_58
#AT_START_59
# 59. misc.at:559: CANCEL ALL
at_setup_line='misc.at:559'
at_desc="CANCEL ALL"
$at_quiet $as_echo_n " 59: $at_desc                                     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "59. misc.at:559: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       PROCEDURE        DIVISION.
           CALL "call01"
           END-CALL.
           CANCEL ALL.
           CALL "call01"
           END-CALL.
           STOP RUN.
_ATEOF


cat >call01.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      call01.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           CALL "call02"
           END-CALL.
           GOBACK.
_ATEOF


cat >call02.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      call02.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC 9.
       PROCEDURE        DIVISION.
           ADD 1 TO X.
           DISPLAY X
           END-DISPLAY.
           EXIT PROGRAM.
           GOBACK.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:598: \${COMPILE} -o prog prog.cob"
echo misc.at:598 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:598"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:599: \${COMPILE_MODULE} call01.cob"
echo misc.at:599 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} call01.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} call01.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:599"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:600: \${COMPILE_MODULE} call02.cob"
echo misc.at:600 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} call02.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} call02.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:600"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:601: ./prog"
echo misc.at:601 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "1
1
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:601"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_59
#AT_START_60
# 60. misc.at:608: CALL binary literal parameter/LENGTH OF - so
at_setup_line='misc.at:608'
at_desc="CALL binary literal parameter/LENGTH OF - so"
$at_quiet $as_echo_n " 60: $at_desc   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "60. misc.at:608: testing ..."
  $at_traceon


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:610: test \$SHREXT != \"dll\" || exit 77"
echo misc.at:610 >"$at_check_line_file"

if test -n "$at_traceon" \
  && at_func_check_newline "test $SHREXT != \"dll\" || exit 77"; then
  ( $at_traceon; test $SHREXT != "dll" || exit 77 ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; test $SHREXT != "dll" || exit 77 ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:610"

$at_failed && at_func_log_failure
$at_traceon; }


cat >test.conf <<'_ATEOF'

include "default.conf"
binary-byteorder: native
_ATEOF


cat >dump.c <<'_ATEOF'

#include <stdio.h>
int dump (int *p)
{
  printf ("%8.8d\n", *p);
  return 0;
}
_ATEOF


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  MYOCC        PIC 9(8) COMP.
       01  MYTAB.
           03  MYBYTE   PIC X OCCURS 1 TO 20
                        DEPENDING ON MYOCC.
       PROCEDURE        DIVISION.
           MOVE 9 TO MYOCC.
           CALL "dump" USING BY CONTENT 1
           END-CALL.
           CALL "dump" USING BY CONTENT LENGTH OF MYTAB
           END-CALL.
           CALL "dump" USING BY CONTENT LENGTH OF MYOCC
           END-CALL.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:646: \${COMPILE_MODULE} dump.c"
echo misc.at:646 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} dump.c ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} dump.c ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:646"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:647: \${COMPILE} -o prog prog.cob"
echo misc.at:647 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:647"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:648: ./prog"
echo misc.at:648 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "00000001
00000009
00000004
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:648"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:653: \${COMPILE} -conf=test.conf -o prog prog.cob"
echo misc.at:653 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -conf=test.conf -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -conf=test.conf -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:653"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:654: ./prog"
echo misc.at:654 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "00000001
00000009
00000004
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:654"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_60
#AT_START_61
# 61. misc.at:662: CALL binary literal parameter/LENGTH OF - DLL
at_setup_line='misc.at:662'
at_desc="CALL binary literal parameter/LENGTH OF - DLL"
$at_quiet $as_echo_n " 61: $at_desc  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "61. misc.at:662: testing ..."
  $at_traceon


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:664: test \$SHREXT = \"dll\" || exit 77"
echo misc.at:664 >"$at_check_line_file"

if test -n "$at_traceon" \
  && at_func_check_newline "test $SHREXT = \"dll\" || exit 77"; then
  ( $at_traceon; test $SHREXT = "dll" || exit 77 ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; test $SHREXT = "dll" || exit 77 ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:664"

$at_failed && at_func_log_failure
$at_traceon; }


cat >test.conf <<'_ATEOF'

include "default.conf"
binary-byteorder: native
_ATEOF


cat >dump.c <<'_ATEOF'

#include <stdio.h>
#define DllExport __declspec (dllexport)
DllExport int dump ();
int dump (int *p)
{
  printf ("%8.8d\n", *p);
  return 0;
}
_ATEOF


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  MYOCC        PIC 9(8) COMP.
       01  MYTAB.
           03  MYBYTE   PIC X OCCURS 1 TO 20
                        DEPENDING ON MYOCC.
       PROCEDURE        DIVISION.
           MOVE 9 TO MYOCC.
           CALL "dump" USING BY CONTENT 1
           END-CALL.
           CALL "dump" USING BY CONTENT LENGTH OF MYTAB
           END-CALL.
           CALL "dump" USING BY CONTENT LENGTH OF MYOCC
           END-CALL.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:702: \${COMPILE_MODULE} dump.c"
echo misc.at:702 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} dump.c ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} dump.c ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:702"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:703: \${COMPILE} -o prog prog.cob"
echo misc.at:703 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:703"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:704: ./prog"
echo misc.at:704 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "00000001
00000009
00000004
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:704"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:709: \${COMPILE} -conf=test.conf -o prog prog.cob"
echo misc.at:709 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -conf=test.conf -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -conf=test.conf -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:709"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:710: ./prog"
echo misc.at:710 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "00000001
00000009
00000004
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:710"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_61
#AT_START_62
# 62. misc.at:721: INSPECT REPLACING LEADING ZEROS BY SPACES
at_setup_line='misc.at:721'
at_desc="INSPECT REPLACING LEADING ZEROS BY SPACES"
$at_quiet $as_echo_n " 62: $at_desc      "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "62. misc.at:721: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(4) VALUE "0001".
       PROCEDURE        DIVISION.
           INSPECT X REPLACING LEADING ZEROS BY SPACES.
           DISPLAY X NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:736: \${COMPILE} prog.cob"
echo misc.at:736 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:736"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:737: ./prog"
echo misc.at:737 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "   1" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:737"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_62
#AT_START_63
# 63. misc.at:741: INSPECT: No repeat conversion check
at_setup_line='misc.at:741'
at_desc="INSPECT: No repeat conversion check"
$at_quiet $as_echo_n " 63: $at_desc            "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "63. misc.at:741: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(3) VALUE "BCA".
       PROCEDURE        DIVISION.
           INSPECT X CONVERTING "ABC" TO "BCD".
           DISPLAY X NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:756: \${COMPILE} prog.cob"
echo misc.at:756 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:756"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:757: ./prog"
echo misc.at:757 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "CDB" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:757"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_63
#AT_START_64
# 64. misc.at:762: INSPECT CONVERTING spaces
at_setup_line='misc.at:762'
at_desc="INSPECT CONVERTING spaces"
$at_quiet $as_echo_n " 64: $at_desc                      "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "64. misc.at:762: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(10) VALUE X'2020200d0a0d0a'.
       PROCEDURE        DIVISION.
           INSPECT X CONVERTING X'0D0A' TO SPACES.
           DISPLAY X NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:777: \${COMPILE} prog.cob"
echo misc.at:777 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:777"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:778: ./prog"
echo misc.at:778 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "          " | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:778"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_64
#AT_START_65
# 65. misc.at:783: INSPECT CONVERTING different length
at_setup_line='misc.at:783'
at_desc="INSPECT CONVERTING different length"
$at_quiet $as_echo_n " 65: $at_desc            "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "65. misc.at:783: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(8) VALUE 'abcdefgh'.
       PROCEDURE        DIVISION.
           INSPECT X CONVERTING 'bc' TO 'Z'.
           DISPLAY X NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:798: \${COMPILE} prog.cob"
echo misc.at:798 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:8: Error: 'bc' and 'Z' have not same size!
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/misc.at:798"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_65
#AT_START_66
# 66. misc.at:805: INSPECT: REPLACING figurative constant
at_setup_line='misc.at:805'
at_desc="INSPECT: REPLACING figurative constant"
$at_quiet $as_echo_n " 66: $at_desc         "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "66. misc.at:805: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(3) VALUE "BCA".
       PROCEDURE        DIVISION.
           INSPECT X REPLACING ALL "BC" BY SPACE.
           DISPLAY X NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:820: \${COMPILE} prog.cob"
echo misc.at:820 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:820"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:821: ./prog"
echo misc.at:821 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "  A" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:821"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_66
#AT_START_67
# 67. misc.at:826: INSPECT: TALLYING BEFORE
at_setup_line='misc.at:826'
at_desc="INSPECT: TALLYING BEFORE"
$at_quiet $as_echo_n " 67: $at_desc                       "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "67. misc.at:826: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(4) VALUE "ABC ".
       01 TAL           PIC 999 VALUE 0.
       PROCEDURE        DIVISION.
           MOVE 0 TO TAL.
           INSPECT X TALLYING TAL FOR CHARACTERS
                     BEFORE INITIAL " ".
           DISPLAY TAL NO ADVANCING
           END-DISPLAY.
           MOVE 0 TO TAL.
           MOVE " ABC" TO X.
           INSPECT X TALLYING TAL FOR CHARACTERS
                     BEFORE INITIAL " ".
           DISPLAY TAL NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:850: \${COMPILE} prog.cob"
echo misc.at:850 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:850"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:851: ./prog"
echo misc.at:851 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "003000" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:851"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_67
#AT_START_68
# 68. misc.at:856: INSPECT: TALLYING AFTER
at_setup_line='misc.at:856'
at_desc="INSPECT: TALLYING AFTER"
$at_quiet $as_echo_n " 68: $at_desc                        "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "68. misc.at:856: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(4) VALUE "ABC ".
       01 TAL           PIC 999 VALUE 0.
       PROCEDURE        DIVISION.
           MOVE 0 TO TAL.
           INSPECT X TALLYING TAL FOR CHARACTERS
                     AFTER INITIAL " ".
           DISPLAY TAL NO ADVANCING
           END-DISPLAY.
           MOVE 0 TO TAL.
           MOVE " ABC" TO X.
           INSPECT X TALLYING TAL FOR CHARACTERS
                     AFTER INITIAL " ".
           DISPLAY TAL NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:880: \${COMPILE} prog.cob"
echo misc.at:880 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:880"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:881: ./prog"
echo misc.at:881 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "000003" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:881"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_68
#AT_START_69
# 69. misc.at:885: INSPECT REPLACING TRAILING ZEROS BY SPACES
at_setup_line='misc.at:885'
at_desc="INSPECT REPLACING TRAILING ZEROS BY SPACES"
$at_quiet $as_echo_n " 69: $at_desc     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "69. misc.at:885: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(4) VALUE "1000".
       PROCEDURE        DIVISION.
           INSPECT X REPLACING TRAILING ZEROS BY SPACES.
           DISPLAY X NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:900: \${COMPILE} prog.cob"
echo misc.at:900 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:900"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:901: ./prog"
echo misc.at:901 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "1   " | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:901"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_69
#AT_START_70
# 70. misc.at:905: INSPECT REPLACING complex
at_setup_line='misc.at:905'
at_desc="INSPECT REPLACING complex"
$at_quiet $as_echo_n " 70: $at_desc                      "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "70. misc.at:905: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(12) VALUE "AAABBCDCCCCC".
       PROCEDURE        DIVISION.
           INSPECT X REPLACING
             ALL      "A" BY "Z"
                      "B" BY "Y"
             TRAILING "C" BY "X".
           DISPLAY X NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:923: \${COMPILE} prog.cob"
echo misc.at:923 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:923"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:924: ./prog"
echo misc.at:924 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "ZZZYYCDXXXXX" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:924"

$at_failed && at_func_log_failure
$at_traceon; }

  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_70
#AT_START_71
# 71. misc.at:927: SWITCHES
at_setup_line='misc.at:927'
at_desc="SWITCHES"
$at_quiet $as_echo_n " 71: $at_desc                                       "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "71. misc.at:927: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT DIVISION.
       CONFIGURATION SECTION.
       SPECIAL-NAMES.
           SWITCH-1 IS SWIT1
             ON IS SWIT1-ON
             OFF IS SWIT1-OFF
           SWITCH-2 IS SWIT2
             ON IS SWIT2-ON
             OFF IS SWIT2-OFF.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           IF SWIT1-ON
              DISPLAY "ON" NO ADVANCING
              END-DISPLAY
           ELSE
              DISPLAY "OFF" NO ADVANCING
              END-DISPLAY
           END-IF.
           IF SWIT2-ON
              DISPLAY "ON" NO ADVANCING
              END-DISPLAY
           ELSE
              DISPLAY "OFF" NO ADVANCING
              END-DISPLAY
           END-IF.
           SET SWIT1 TO OFF.
           SET SWIT2 TO ON.
           IF SWIT1-ON
              DISPLAY "ON" NO ADVANCING
              END-DISPLAY
           ELSE
              DISPLAY "OFF" NO ADVANCING
              END-DISPLAY
           END-IF.
           IF SWIT2-ON
              DISPLAY "ON" NO ADVANCING
              END-DISPLAY
           ELSE
              DISPLAY "OFF" NO ADVANCING
              END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:977: \${COMPILE} prog.cob"
echo misc.at:977 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:977"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:978: COB_SWITCH_1=ON COB_SWITCH_2=OFF ./prog"
echo misc.at:978 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; COB_SWITCH_1=ON COB_SWITCH_2=OFF ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; COB_SWITCH_1=ON COB_SWITCH_2=OFF ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "ONOFFOFFON" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:978"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_71
#AT_START_72
# 72. misc.at:985: Nested PERFORM
at_setup_line='misc.at:985'
at_desc="Nested PERFORM"
$at_quiet $as_echo_n " 72: $at_desc                                 "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "72. misc.at:985: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       PROCEDURE        DIVISION.
           PERFORM 2 TIMES
             PERFORM 2 TIMES
               DISPLAY "X" NO ADVANCING
               END-DISPLAY
             END-PERFORM
           END-PERFORM.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1001: \${COMPILE} -o prog prog.cob"
echo misc.at:1001 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1001"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1002: ./prog"
echo misc.at:1002 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "XXXX" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1002"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_72
#AT_START_73
# 73. misc.at:1010: EXIT PERFORM
at_setup_line='misc.at:1010'
at_desc="EXIT PERFORM"
$at_quiet $as_echo_n " 73: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "73. misc.at:1010: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       PROCEDURE        DIVISION.
           PERFORM 2 TIMES
             DISPLAY "OK" NO ADVANCING
             END-DISPLAY
             EXIT PERFORM
             DISPLAY "NOT REACHED"
             END-DISPLAY
           END-PERFORM
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1026: \${COMPILE} -o prog prog.cob"
echo misc.at:1026 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1026"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1027: ./prog"
echo misc.at:1027 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1027"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_73
#AT_START_74
# 74. misc.at:1034: EXIT PERFORM CYCLE
at_setup_line='misc.at:1034'
at_desc="EXIT PERFORM CYCLE"
$at_quiet $as_echo_n " 74: $at_desc                             "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "74. misc.at:1034: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       PROCEDURE        DIVISION.
           PERFORM 2 TIMES
             DISPLAY "OK" NO ADVANCING
             END-DISPLAY
             EXIT PERFORM CYCLE
             DISPLAY "NOT REACHED"
             END-DISPLAY
           END-PERFORM
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1050: \${COMPILE} -o prog prog.cob"
echo misc.at:1050 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1050"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1051: ./prog"
echo misc.at:1051 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OKOK" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1051"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_74
#AT_START_75
# 75. misc.at:1058: EXIT PARAGRAPH
at_setup_line='misc.at:1058'
at_desc="EXIT PARAGRAPH"
$at_quiet $as_echo_n " 75: $at_desc                                 "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "75. misc.at:1058: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 INDVAL        PIC 9(4).
       PROCEDURE        DIVISION.
       A01.
           PERFORM VARYING INDVAL FROM 1 BY 1 UNTIL INDVAL > 10
            IF INDVAL > 2
               EXIT PARAGRAPH
            END-IF
           END-PERFORM
           .
       A02.
           DISPLAY INDVAL NO ADVANCING
           END-DISPLAY
           STOP RUN
           .
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1081: \${COMPILE} -o prog prog.cob"
echo misc.at:1081 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1081"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1082: ./prog"
echo misc.at:1082 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "0003" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1082"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_75
#AT_START_76
# 76. misc.at:1089: EXIT SECTION
at_setup_line='misc.at:1089'
at_desc="EXIT SECTION"
$at_quiet $as_echo_n " 76: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "76. misc.at:1089: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 INDVAL        PIC 9(4).
       PROCEDURE        DIVISION.
       A01 SECTION.
       A011.
           PERFORM VARYING INDVAL FROM 1 BY 1 UNTIL INDVAL > 10
            IF INDVAL > 2
               EXIT SECTION
            END-IF
           END-PERFORM
           .
       A012.
           DISPLAY INDVAL NO ADVANCING
           END-DISPLAY
           .
       A02 SECTION.
           DISPLAY INDVAL NO ADVANCING
           END-DISPLAY
           STOP RUN
           .
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1117: \${COMPILE} -o prog prog.cob"
echo misc.at:1117 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1117"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1118: ./prog"
echo misc.at:1118 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "0003" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1118"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_76
#AT_START_77
# 77. misc.at:1123: 88 with FILLER
at_setup_line='misc.at:1123'
at_desc="88 with FILLER"
$at_quiet $as_echo_n " 77: $at_desc                                 "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "77. misc.at:1123: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 FILLER        PIC X VALUE SPACE.
         88 X           VALUE "X".
       PROCEDURE        DIVISION.
           IF X
               DISPLAY "NO" NO ADVANCING
               END-DISPLAY
           END-IF.
           SET X TO TRUE.
           IF X
               DISPLAY "OK" NO ADVANCING
               END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1145: \${COMPILE} -o prog prog.cob"
echo misc.at:1145 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1145"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1146: ./prog"
echo misc.at:1146 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1146"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_77
#AT_START_78
# 78. misc.at:1150: Non-overflow after overflow
at_setup_line='misc.at:1150'
at_desc="Non-overflow after overflow"
$at_quiet $as_echo_n " 78: $at_desc                    "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "78. misc.at:1150: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC 9(2) VALUE 0.
       01 Y             PIC 9(2) VALUE 0.
       PROCEDURE        DIVISION.
           COMPUTE X = 100
           END-COMPUTE.
           COMPUTE Y = 99
           END-COMPUTE.
           DISPLAY Y NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1169: \${COMPILE} -o prog prog.cob"
echo misc.at:1169 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1169"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1170: ./prog"
echo misc.at:1170 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "99" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1170"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_78
#AT_START_79
# 79. misc.at:1177: PERFORM ... CONTINUE
at_setup_line='misc.at:1177'
at_desc="PERFORM ... CONTINUE"
$at_quiet $as_echo_n " 79: $at_desc                           "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "79. misc.at:1177: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       PROCEDURE        DIVISION.
           PERFORM 2 TIMES
             CONTINUE
           END-PERFORM.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1188: \${COMPILE_ONLY} prog.cob"
echo misc.at:1188 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_ONLY} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_ONLY} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1188"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_79
#AT_START_80
# 80. misc.at:1193: STRING with subscript reference
at_setup_line='misc.at:1193'
at_desc="STRING with subscript reference"
$at_quiet $as_echo_n " 80: $at_desc                "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "80. misc.at:1193: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G.
         02 X           PIC X(3) OCCURS 3.
       PROCEDURE        DIVISION.
           STRING "abc" INTO X(1)
           END-STRING.
           DISPLAY X(1) NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1210: \${COMPILE} -o prog prog.cob"
echo misc.at:1210 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1210"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1211: ./prog"
echo misc.at:1211 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "abc" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1211"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_80
#AT_START_81
# 81. misc.at:1216: UNSTRING DELIMITED ALL LOW-VALUE
at_setup_line='misc.at:1216'
at_desc="UNSTRING DELIMITED ALL LOW-VALUE"
$at_quiet $as_echo_n " 81: $at_desc               "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "81. misc.at:1216: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  G.
           03 FILLER    PIC XXX VALUE "ABC".
           03 FILLER    PIC XX  VALUE LOW-VALUES.
           03 FILLER    PIC XXX VALUE "DEF".
       01  A            PIC XXX.
       01  B            PIC XXX.
       PROCEDURE        DIVISION.
           UNSTRING G DELIMITED BY ALL LOW-VALUES
                      INTO A B
           END-UNSTRING.
           DISPLAY A
           END-DISPLAY.
           DISPLAY B
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1240: \${COMPILE} -o prog prog.cob"
echo misc.at:1240 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1240"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1241: ./prog"
echo misc.at:1241 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "ABC
DEF
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1241"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_81
#AT_START_82
# 82. misc.at:1249: READ INTO AT-END sequence
at_setup_line='misc.at:1249'
at_desc="READ INTO AT-END sequence"
$at_quiet $as_echo_n " 82: $at_desc                      "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "82. misc.at:1249: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       INPUT-OUTPUT     SECTION.
       FILE-CONTROL.
       SELECT TEST-FILE ASSIGN "./TEST-FILE".
       DATA             DIVISION.
       FILE             SECTION.
       FD TEST-FILE.
       01 TEST-REC      PIC X(10).
       WORKING-STORAGE  SECTION.
       01 X             PIC X(10).
       PROCEDURE        DIVISION.
           OPEN  OUTPUT TEST-FILE.
           CLOSE TEST-FILE.
           OPEN  INPUT  TEST-FILE.
           READ  TEST-FILE INTO X
               AT END MOVE ZERO TO X
           END-READ.
           CLOSE TEST-FILE.
           DISPLAY X NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1277: \${COMPILE} -o prog prog.cob"
echo misc.at:1277 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1277"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1278: ./prog"
echo misc.at:1278 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "0000000000" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1278"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_82
#AT_START_83
# 83. misc.at:1283: First READ on empty SEQUENTIAL INDEXED file
at_setup_line='misc.at:1283'
at_desc="First READ on empty SEQUENTIAL INDEXED file"
$at_quiet $as_echo_n " 83: $at_desc    "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "83. misc.at:1283: testing ..."
  $at_traceon


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1285: test \"\$COB_HAS_ISAM\" = \"yes\" || exit 77"
echo misc.at:1285 >"$at_check_line_file"

if test -n "$at_traceon" \
  && at_func_check_newline "test \"$COB_HAS_ISAM\" = \"yes\" || exit 77"; then
  ( $at_traceon; test "$COB_HAS_ISAM" = "yes" || exit 77 ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; test "$COB_HAS_ISAM" = "yes" || exit 77 ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1285"

$at_failed && at_func_log_failure
$at_traceon; }


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       INPUT-OUTPUT     SECTION.
       FILE-CONTROL.
       SELECT TEST-FILE ASSIGN       "./TEST-FILE"
                        ORGANIZATION IS  INDEXED
                        ACCESS MODE  IS  SEQUENTIAL
                        RECORD KEY   IS  TEST-KEY.
       DATA             DIVISION.
       FILE             SECTION.
       FD TEST-FILE.
       01 TEST-KEY      PIC X(10).
       PROCEDURE        DIVISION.
           OPEN  OUTPUT TEST-FILE.
           CLOSE TEST-FILE.
           OPEN  INPUT  TEST-FILE.
           READ  TEST-FILE
               AT END
                   DISPLAY "OK" NO ADVANCING
                   END-DISPLAY
           END-READ.
           CLOSE TEST-FILE.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1314: \${COMPILE} -o prog prog.cob"
echo misc.at:1314 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1314"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1315: ./prog"
echo misc.at:1315 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1315"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_83
#AT_START_84
# 84. misc.at:1320: REWRITE a RELATIVE file with RANDOM access
at_setup_line='misc.at:1320'
at_desc="REWRITE a RELATIVE file with RANDOM access"
$at_quiet $as_echo_n " 84: $at_desc     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "84. misc.at:1320: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       INPUT-OUTPUT     SECTION.
       FILE-CONTROL.
       SELECT TEST-FILE ASSIGN       "./TEST-FILE"
                        ORGANIZATION IS RELATIVE
                        ACCESS MODE  IS RANDOM
                        RELATIVE KEY IS TEST-KEY.
       DATA             DIVISION.
       FILE             SECTION.
       FD TEST-FILE.
       01 TEST-REC      PIC X.
       WORKING-STORAGE  SECTION.
       01 TEST-KEY      PIC 9.
       PROCEDURE        DIVISION.
      *
           OPEN OUTPUT TEST-FILE.
           MOVE 1 TO TEST-KEY. MOVE "A" TO TEST-REC. WRITE TEST-REC
           END-WRITE.
           MOVE 2 TO TEST-KEY. MOVE "B" TO TEST-REC. WRITE TEST-REC
           END-WRITE.
           CLOSE TEST-FILE.
      *
           OPEN I-O TEST-FILE.
           MOVE 1 TO TEST-KEY. READ TEST-FILE
           END-READ.
           MOVE 2 TO TEST-KEY. MOVE "C" TO TEST-REC. REWRITE TEST-REC
           END-REWRITE.
           CLOSE TEST-FILE.
      *
           OPEN INPUT TEST-FILE.
           MOVE 1 TO TEST-KEY. READ TEST-FILE
           END-READ. DISPLAY TEST-REC
           END-DISPLAY.
           MOVE 2 TO TEST-KEY. READ TEST-FILE
           END-READ. DISPLAY TEST-REC
           END-DISPLAY.
           CLOSE TEST-FILE.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1365: \${COMPILE} -o prog prog.cob"
echo misc.at:1365 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1365"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1366: ./prog"
echo misc.at:1366 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "A
C
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1366"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_84
#AT_START_85
# 85. misc.at:1374: SORT: table sort
at_setup_line='misc.at:1374'
at_desc="SORT: table sort"
$at_quiet $as_echo_n " 85: $at_desc                               "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "85. misc.at:1374: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 G             VALUE "d4b2e1a3c5".
         02 TBL         OCCURS 5.
           03 X         PIC X.
           03 Y         PIC 9.
       PROCEDURE        DIVISION.
           SORT TBL ASCENDING KEY X.
           DISPLAY G
           END-DISPLAY.
           SORT TBL DESCENDING KEY Y.
           DISPLAY G
           END-DISPLAY.
           SORT TBL ASCENDING KEY TBL.
           DISPLAY G
           END-DISPLAY.
           SORT TBL DESCENDING KEY.
           DISPLAY G
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1401: \${COMPILE} -o prog prog.cob"
echo misc.at:1401 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1401"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1402: ./prog"
echo misc.at:1402 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "a3b2c5d4e1
c5d4a3b2e1
a3b2c5d4e1
e1d4c5b2a3
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1402"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_85
#AT_START_86
# 86. misc.at:1411: SORT: EBCDIC table sort
at_setup_line='misc.at:1411'
at_desc="SORT: EBCDIC table sort"
$at_quiet $as_echo_n " 86: $at_desc                        "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "86. misc.at:1411: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT DIVISION.
       CONFIGURATION SECTION.
       SPECIAL-NAMES.
           ALPHABET ALPHA IS EBCDIC.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 Z  PIC X(10)  VALUE "d4b2e1a3c5".
       01 G             VALUE "d4b2e1a3c5".
         02 TBL         OCCURS 10.
           03 X         PIC X.
       PROCEDURE        DIVISION.
           SORT TBL ASCENDING KEY X.
           DISPLAY G
           END-DISPLAY.
           MOVE Z TO G.
           SORT TBL DESCENDING KEY X.
           DISPLAY G
           END-DISPLAY.
           MOVE Z TO G.
           SORT TBL ASCENDING KEY X SEQUENCE ALPHA.
           DISPLAY G
           END-DISPLAY.
           MOVE Z TO G.
           SORT TBL DESCENDING KEY X SEQUENCE ALPHA.
           DISPLAY G
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1445: \${COMPILE} -o prog prog.cob"
echo misc.at:1445 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1445"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1446: ./prog"
echo misc.at:1446 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "12345abcde
edcba54321
abcde12345
54321edcba
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1446"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_86
#AT_START_87
# 87. misc.at:1455: SORT nonexistent file
at_setup_line='misc.at:1455'
at_desc="SORT nonexistent file"
$at_quiet $as_echo_n " 87: $at_desc                          "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "87. misc.at:1455: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       INPUT-OUTPUT     SECTION.
       FILE-CONTROL.
       SELECT SORT-IN   ASSIGN "SORT-IN".
       SELECT SORT-OUT  ASSIGN "SORT-OUT".
       SELECT SORT-WRK  ASSIGN "SORT-WRK".
       DATA             DIVISION.
       FILE             SECTION.
       FD SORT-IN.
       01 IN-REC        PIC X(100).
       FD SORT-OUT.
       01 OUT-REC       PIC X(100).
       SD SORT-WRK.
       01 WRK-REC       PIC X(100).
       PROCEDURE        DIVISION.
           SORT SORT-WRK
                ASCENDING KEY WRK-REC
                USING  SORT-IN
                GIVING SORT-OUT.
             STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1482: \${COMPILE} -o prog prog.cob"
echo misc.at:1482 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1482"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1483: ./prog"
echo misc.at:1483 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1483"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1484: cat SORT-OUT"
echo misc.at:1484 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; cat SORT-OUT ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; cat SORT-OUT ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1484"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_87
#AT_START_88
# 88. misc.at:1489: PIC ZZZ-, ZZZ+
at_setup_line='misc.at:1489'
at_desc="PIC ZZZ-, ZZZ+"
$at_quiet $as_echo_n " 88: $at_desc                                 "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "88. misc.at:1489: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X-ZZZN        PIC ZZZ-.
       01 X-ZZZP        PIC ZZZ+.
       PROCEDURE        DIVISION.
           MOVE -1 TO X-ZZZN. DISPLAY "(" X-ZZZN ")"
           END-DISPLAY.
           MOVE  0 TO X-ZZZN. DISPLAY "(" X-ZZZN ")"
           END-DISPLAY.
           MOVE +1 TO X-ZZZN. DISPLAY "(" X-ZZZN ")"
           END-DISPLAY.
           MOVE -1 TO X-ZZZP. DISPLAY "(" X-ZZZP ")"
           END-DISPLAY.
           MOVE  0 TO X-ZZZP. DISPLAY "(" X-ZZZP ")"
           END-DISPLAY.
           MOVE +1 TO X-ZZZP. DISPLAY "(" X-ZZZP ")"
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1514: \${COMPILE} -o prog prog.cob"
echo misc.at:1514 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1514"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1515: ./prog"
echo misc.at:1515 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "(  1-)
(    )
(  1 )
(  1-)
(    )
(  1+)
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1515"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_88
#AT_START_89
# 89. misc.at:1527: Larger REDEFINES lengths
at_setup_line='misc.at:1527'
at_desc="Larger REDEFINES lengths"
$at_quiet $as_echo_n " 89: $at_desc                       "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "89. misc.at:1527: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  XMAIN        PIC X(8).
       01  XMAINRED REDEFINES XMAIN.
           03  FILLER         PIC X(4).
           03  XMAIN03.
               05  XMAIN0501  PIC X(4).
               05  XMAIN0502 REDEFINES XMAIN0501 PIC X(5).
       PROCEDURE        DIVISION.
           DISPLAY LENGTH OF XMAIN
           END-DISPLAY.
           DISPLAY LENGTH OF XMAINRED
           END-DISPLAY.
           DISPLAY LENGTH OF XMAIN03
           END-DISPLAY.
           DISPLAY LENGTH OF XMAIN0501
           END-DISPLAY.
           DISPLAY LENGTH OF XMAIN0502
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1554: \${COMPILE} -std=mf -o prog prog.cob"
echo misc.at:1554 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -std=mf -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -std=mf -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:11: Warning: Size of 'XMAIN0502' larger than size of 'XMAIN0501'
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1554"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1557: ./prog"
echo misc.at:1557 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "8
9
5
4
5
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1557"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_89
#AT_START_90
# 90. misc.at:1567: PERFORM type OSVS
at_setup_line='misc.at:1567'
at_desc="PERFORM type OSVS"
$at_quiet $as_echo_n " 90: $at_desc                              "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "90. misc.at:1567: testing ..."
  $at_traceon


cat >test.conf <<'_ATEOF'

include "default.conf"
perform-osvs: yes
_ATEOF


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  MYOCC        PIC 9(8) COMP VALUE 0.
       PROCEDURE        DIVISION.
       ASTART SECTION.
       A01.
           PERFORM BTEST.
           DISPLAY "OK"
           END-DISPLAY.
           STOP RUN.
       BTEST SECTION.
       B01.
           PERFORM B02 VARYING MYOCC FROM 1 BY 1
                   UNTIL MYOCC > 5.
           GO TO B99.
       B02.
           IF MYOCC > 1
              GO TO B99
           END-IF.
       B99.
           EXIT.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1600: \${COMPILE} -conf=test.conf -o prog prog.cob"
echo misc.at:1600 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -conf=test.conf -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -conf=test.conf -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1600"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1601: ./prog"
echo misc.at:1601 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1601"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_90
#AT_START_91
# 91. misc.at:1608: Sticky LINKAGE
at_setup_line='misc.at:1608'
at_desc="Sticky LINKAGE"
$at_quiet $as_echo_n " 91: $at_desc                                 "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "91. misc.at:1608: testing ..."
  $at_traceon


cat >test.conf <<'_ATEOF'

include "default.conf"
sticky-linkage: yes
_ATEOF


cat >callee.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      callee.
       DATA             DIVISION.
       LINKAGE          SECTION.
       01 P1            PIC X.
       01 P2            PIC X(6).
       01 P3            PIC X(6).
       PROCEDURE        DIVISION USING P1 P2.
           IF P1 = "A"
              SET ADDRESS OF P3 TO ADDRESS OF P2
           ELSE
              DISPLAY P3
              END-DISPLAY
           END-IF.
           EXIT PROGRAM.
_ATEOF


cat >caller.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      caller.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 P1            PIC X    VALUE "A".
       01 P2            PIC X(6) VALUE "NOT OK".
       PROCEDURE        DIVISION.
           CALL "callee" USING P1 P2
           END-CALL.
           MOVE "B"      TO P1.
           MOVE "OKOKOK" TO P2.
           CALL "callee" USING P1
           END-CALL.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1650: \${COMPILE_MODULE} -conf=test.conf callee.cob"
echo misc.at:1650 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} -conf=test.conf callee.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} -conf=test.conf callee.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1650"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1651: \${COMPILE} -conf=test.conf -o caller caller.cob"
echo misc.at:1651 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -conf=test.conf -o caller caller.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -conf=test.conf -o caller caller.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1651"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1652: ./caller"
echo misc.at:1652 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./caller ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./caller ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OKOKOK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1652"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_91
#AT_START_92
# 92. misc.at:1658: COB_PRE_LOAD test
at_setup_line='misc.at:1658'
at_desc="COB_PRE_LOAD test"
$at_quiet $as_echo_n " 92: $at_desc                              "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "92. misc.at:1658: testing ..."
  $at_traceon


cat >callee.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      callee2.
       PROCEDURE        DIVISION.
           DISPLAY "OK" NO ADVANCING
           END-DISPLAY.
_ATEOF


cat >caller.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      caller.
       PROCEDURE        DIVISION.
           CALL "callee2"
           END-CALL.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1676: \${COMPILE_MODULE} callee.cob"
echo misc.at:1676 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} callee.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} callee.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1676"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1677: \${COMPILE} caller.cob"
echo misc.at:1677 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} caller.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} caller.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1677"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1678: export COB_PRE_LOAD=callee; ./caller"
echo misc.at:1678 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; export COB_PRE_LOAD=callee; ./caller ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; export COB_PRE_LOAD=callee; ./caller ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1678"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_92
#AT_START_93
# 93. misc.at:1682: COB_LOAD_CASE=UPPER test
at_setup_line='misc.at:1682'
at_desc="COB_LOAD_CASE=UPPER test"
$at_quiet $as_echo_n " 93: $at_desc                       "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "93. misc.at:1682: testing ..."
  $at_traceon


cat >CALLEE.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      callee.
       PROCEDURE        DIVISION.
           DISPLAY "OK" NO ADVANCING
           END-DISPLAY.
_ATEOF


cat >caller.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      caller.
       PROCEDURE        DIVISION.
           CALL "callee"
           END-CALL.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1700: \${COMPILE_MODULE} CALLEE.cob"
echo misc.at:1700 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} CALLEE.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} CALLEE.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1700"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1701: \${COMPILE} caller.cob"
echo misc.at:1701 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} caller.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} caller.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1701"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1702: export COB_LOAD_CASE=UPPER; ./caller"
echo misc.at:1702 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; export COB_LOAD_CASE=UPPER; ./caller ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; export COB_LOAD_CASE=UPPER; ./caller ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1702"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_93
#AT_START_94
# 94. misc.at:1706: 88 level with FALSE IS clause
at_setup_line='misc.at:1706'
at_desc="88 level with FALSE IS clause"
$at_quiet $as_echo_n " 94: $at_desc                  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "94. misc.at:1706: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  MYFLD        PIC X(6) VALUE "ABCDEF".
           88  MYFLD88  VALUE "ABCDEF"
               FALSE IS "OKOKOK".
       PROCEDURE        DIVISION.
       ASTART SECTION.
       A01.
           SET MYFLD88 TO FALSE.
           DISPLAY MYFLD
           END-DISPLAY.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1724: \${COMPILE} prog.cob"
echo misc.at:1724 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1724"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1725: ./prog"
echo misc.at:1725 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OKOKOK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1725"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_94
#AT_START_95
# 95. misc.at:1731: ALLOCATE/FREE with BASED item
at_setup_line='misc.at:1731'
at_desc="ALLOCATE/FREE with BASED item"
$at_quiet $as_echo_n " 95: $at_desc                  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "95. misc.at:1731: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       LINKAGE          SECTION.
       01  MYFLD        PIC X(6) BASED VALUE "ABCDEF".
       PROCEDURE        DIVISION.
       ASTART SECTION.
       A01.
           ALLOCATE MYFLD INITIALIZED.
           DISPLAY MYFLD
           END-DISPLAY.
           FREE ADDRESS OF MYFLD.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1748: \${COMPILE} prog.cob"
echo misc.at:1748 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1748"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1749: ./prog"
echo misc.at:1749 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "ABCDEF
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1749"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_95
#AT_START_96
# 96. misc.at:1755: INITIZIALIZE with reference modification
at_setup_line='misc.at:1755'
at_desc="INITIZIALIZE with reference modification"
$at_quiet $as_echo_n " 96: $at_desc       "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "96. misc.at:1755: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  MYFLD        PIC X(6) VALUE "ABCDEF".
       PROCEDURE        DIVISION.
       ASTART SECTION.
       A01.
           INITIALIZE MYFLD (1:2).
           DISPLAY MYFLD
           END-DISPLAY.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1771: \${COMPILE} prog.cob"
echo misc.at:1771 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1771"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1772: ./prog"
echo misc.at:1772 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "  CDEF
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1772"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_96
#AT_START_97
# 97. misc.at:1778: CALL with OMITTED parameter
at_setup_line='misc.at:1778'
at_desc="CALL with OMITTED parameter"
$at_quiet $as_echo_n " 97: $at_desc                    "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "97. misc.at:1778: testing ..."
  $at_traceon


cat >callee.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      callee.
       DATA             DIVISION.
       LINKAGE          SECTION.
       01 P1            PIC X.
       01 P2            PIC X(6).
       PROCEDURE        DIVISION USING P1 P2.
           IF P2 OMITTED
              DISPLAY "OKOKOK"
              END-DISPLAY
           END-IF.
           EXIT PROGRAM.
_ATEOF


cat >caller.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      caller.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 P1            PIC X    VALUE "A".
       01 P2            PIC X(6) VALUE "NOT OK".
       PROCEDURE        DIVISION.
           CALL "callee" USING P1 OMITTED
           END-CALL.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1808: \${COMPILE_MODULE} callee.cob"
echo misc.at:1808 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} callee.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} callee.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1808"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1809: \${COMPILE} -o caller caller.cob"
echo misc.at:1809 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o caller caller.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o caller caller.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1809"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1810: ./caller"
echo misc.at:1810 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./caller ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./caller ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OKOKOK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1810"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_97
#AT_START_98
# 98. misc.at:1816: ANY LENGTH
at_setup_line='misc.at:1816'
at_desc="ANY LENGTH"
$at_quiet $as_echo_n " 98: $at_desc                                     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "98. misc.at:1816: testing ..."
  $at_traceon


cat >callee.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      callee.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 P2            PIC 99.
       LINKAGE          SECTION.
       01 P1            PIC X ANY LENGTH.
       PROCEDURE        DIVISION USING P1.
           MOVE LENGTH OF P1 TO P2.
           DISPLAY P2
           END-DISPLAY.
           DISPLAY P1
           END-DISPLAY.
           EXIT PROGRAM.
_ATEOF


cat >caller.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      caller.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 P1            PIC X(6) VALUE "OKOKOK".
       PROCEDURE        DIVISION.
           CALL "callee" USING P1
           END-CALL.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1847: \${COMPILE_MODULE} callee.cob"
echo misc.at:1847 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} callee.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} callee.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1847"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1848: \${COMPILE} -o caller caller.cob"
echo misc.at:1848 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o caller caller.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o caller caller.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1848"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1849: ./caller"
echo misc.at:1849 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./caller ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./caller ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "06
OKOKOK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1849"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_98
#AT_START_99
# 99. misc.at:1856: READ - KEY ignored with sequential READ
at_setup_line='misc.at:1856'
at_desc="READ - KEY ignored with sequential READ"
$at_quiet $as_echo_n " 99: $at_desc        "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "99. misc.at:1856: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       INPUT-OUTPUT     SECTION.
       FILE-CONTROL.
       SELECT TEST-FILE ASSIGN       "./TEST-FILE"
                        ORGANIZATION IS  INDEXED
                        ACCESS MODE  IS  SEQUENTIAL
                        RECORD KEY   IS  TEST-KEY.
       DATA             DIVISION.
       FILE             SECTION.
       FD TEST-FILE.
       01 TEST-KEY      PIC X(4).
       PROCEDURE        DIVISION.
           OPEN  OUTPUT TEST-FILE.
           CLOSE TEST-FILE.
           OPEN  INPUT  TEST-FILE.
           START TEST-FILE KEY IS EQUAL TO TEST-KEY.
           READ TEST-FILE KEY IS TEST-KEY.
           DISPLAY TEST-KEY NO ADVANCING.
           CLOSE TEST-FILE.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1883: \${COMPILE} -o prog prog.cob"
echo misc.at:1883 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:20: Warning: KEY ignored with sequential READ
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1883"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_99
#AT_START_100
# 100. misc.at:1889: SORT - missing fcd in variable-length WRITE
at_setup_line='misc.at:1889'
at_desc="SORT - missing fcd in variable-length WRITE"
$at_quiet $as_echo_n "100: $at_desc    "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "100. misc.at:1889: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION    DIVISION.
       PROGRAM-ID.       prog.
       ENVIRONMENT       DIVISION.
       INPUT-OUTPUT      SECTION.
       FILE-CONTROL.
       SELECT MAKE-F     ASSIGN TO "./TEST-FILE"
                         ORGANIZATION LINE SEQUENTIAL
                         FILE STATUS M-STATUS.
       SELECT SIN-F      ASSIGN TO "./TEST-FILE"
                         ORGANIZATION LINE SEQUENTIAL
                         FILE STATUS I-STATUS.
       SELECT SOUT-F     ASSIGN TO DISK
                         ORGANIZATION SEQUENTIAL
                         FILE STATUS O-STATUS.
       DATA              DIVISION.
       FILE              SECTION.
       FD MAKE-F
           RECORD IS VARYING IN SIZE FROM 1 TO 50 CHARACTERS
           DEPENDING ON M-RECL.
       01 MAKE-REC       PIC X(50).
       FD SIN-F
           RECORD IS VARYING IN SIZE FROM 1 TO 50 CHARACTERS
           DEPENDING ON I-RECL.
       01 SIN-REC        PIC X(50).
       SD SOUT-F
           RECORD IS VARYING IN SIZE FROM 1 TO 50 CHARACTERS
           DEPENDING ON O-RECL.
       01 SOUT-REC.
          05  SOUT-KEY1  PIC X(5).
          05  SOUT-KEY2  PIC X(5).
          05  SOUT-VAL   PIC X(40).
       WORKING-STORAGE   SECTION.
       01 M-STATUS       PIC XX.
       01 I-STATUS       PIC XX.
       01 O-STATUS       PIC XX.
       01 M-RECL         PIC 9(3) VALUE 50.
       01 I-RECL         PIC 9(3) VALUE 50.
       01 O-RECL         PIC 9(3) VALUE 50.
       PROCEDURE         DIVISION.
       MAIN-01.
           PERFORM MAKE-PROC.
           SORT SOUT-F ON ASCENDING  KEY SOUT-KEY1
                      ON DESCENDING KEY SOUT-KEY2
                      INPUT  PROCEDURE SIN-PROC
                      OUTPUT PROCEDURE SOT-PROC.
       MAIN-EXIT.
           GOBACK.
       MAKE-PROC.
           OPEN OUTPUT MAKE-F.
           MOVE 21 TO M-RECL.
           MOVE "aaaaa111111aaaaaaaaaa" TO MAKE-REC.
           WRITE MAKE-REC.
           MOVE 27 TO M-RECL.
           MOVE "aaaaa666666xxxxxxxxxxxxxxxx" TO MAKE-REC.
           WRITE MAKE-REC.
           MOVE 13 TO M-RECL.
           MOVE "ccccc555555ll" TO MAKE-REC.
           write MAKE-REC.
           CLOSE MAKE-F.
       SIN-PROC.
           OPEN INPUT SIN-F.
           PERFORM FOREVER
              MOVE 0 TO I-RECL
              MOVE SPACE TO SIN-REC
              READ SIN-F AT END EXIT PERFORM END-READ
              MOVE I-RECL TO O-RECL
              MOVE SIN-REC TO SOUT-REC
              RELEASE SOUT-REC
           END-PERFORM.
           CLOSE SIN-F.
       SOT-PROC.
           PERFORM FOREVER
              MOVE 0 TO O-RECL
              MOVE SPACE TO SOUT-REC
              RETURN SOUT-F AT END EXIT PERFORM END-RETURN
              DISPLAY O-RECL NO ADVANCING
           END-PERFORM.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1971: \${COMPILE} -o prog prog.cob"
echo misc.at:1971 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1971"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:1972: ./prog"
echo misc.at:1972 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "027021013" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:1972"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_100
#AT_START_101
# 101. misc.at:1976: READ - missing fcd in variable-length WRITE
at_setup_line='misc.at:1976'
at_desc="READ - missing fcd in variable-length WRITE"
$at_quiet $as_echo_n "101: $at_desc    "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "101. misc.at:1976: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION    DIVISION.
       PROGRAM-ID.       prog.
       ENVIRONMENT       DIVISION.
       INPUT-OUTPUT      SECTION.
       FILE-CONTROL.
       SELECT SIN-F      ASSIGN TO "./TEST-FILE"
                         ORGANIZATION LINE SEQUENTIAL
                         FILE STATUS I-STATUS.
       DATA              DIVISION.
       FILE              SECTION.
       FD SIN-F
           RECORD IS VARYING IN SIZE FROM 1 TO 50 CHARACTERS
           DEPENDING ON I-RECL.
       01 SIN-REC        PIC X(50).
       WORKING-STORAGE   SECTION.
       01 I-STATUS       PIC XX.
       01 I-RECL         PIC 9(3) VALUE 50.
       PROCEDURE         DIVISION.
       MAIN-01.
           PERFORM MAKE-PROC.
           PERFORM READ-PROC.
       MAIN-EXIT.
           GOBACK.
       MAKE-PROC.
           OPEN OUTPUT SIN-F.
           MOVE 21 TO I-RECL.
           MOVE "aaaaa111111aaaaaaaaaa" TO SIN-REC.
           WRITE SIN-REC.
           MOVE 27 TO I-RECL.
           MOVE "aaaaa666666xxxxxxxxxxxxxxxx" TO SIN-REC.
           WRITE SIN-REC.
           MOVE 13 TO I-RECL.
           MOVE "ccccc555555ll" TO SIN-REC.
           WRITE SIN-REC.
           CLOSE SIN-F.
       READ-PROC.
           OPEN INPUT SIN-F.
           PERFORM FOREVER
              MOVE 0 TO I-RECL
              MOVE SPACE TO SIN-REC
              READ SIN-F AT END EXIT PERFORM END-READ
              DISPLAY I-RECL NO ADVANCING
           END-PERFORM.
           CLOSE SIN-F.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/misc.at:2025: \${COMPILE} -o prog prog.cob"
echo misc.at:2025 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:2025"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/misc.at:2026: ./prog"
echo misc.at:2026 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "021027013" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/misc.at:2026"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_101
#AT_START_102
# 102. extensions.at:24: COMP-5
at_setup_line='extensions.at:24'
at_desc="COMP-5"
$at_quiet $as_echo_n "102: $at_desc                                         "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "102. extensions.at:24: testing ..."
  $at_traceon


cat >dump.c <<'_ATEOF'

#include <stdio.h>
int dump (unsigned char *data, int *p);
int dump (unsigned char *data, int *p)
{
  int i;
  if ( *p == 1 ) {
     for (i = 0; i < 4; i++)
       printf ("%02x", data[i]);
  } else {
       printf ("%8.8d", *((int *)data));
  }
  puts ("");
  return 0;
}
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:43: \${CC} \${SHROPT} -o dump.\${SHREXT} dump.c"
echo extensions.at:43 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${CC} ${SHROPT} -o dump.${SHREXT} dump.c ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${CC} ${SHROPT} -o dump.${SHREXT} dump.c ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:43"

$at_failed && at_func_log_failure
$at_traceon; }


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X-1           PIC 9(9) VALUE 4660 COMP.
       01 X-2           PIC 9(9) VALUE 4660 COMP-5.
       PROCEDURE        DIVISION.
           CALL "dump" USING X-1 BY CONTENT 1
           END-CALL.
           CALL "dump" USING X-2 BY CONTENT 2
           END-CALL.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:60: \${COMPILE} -o prog prog.cob"
echo extensions.at:60 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:60"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:61: ./prog"
echo extensions.at:61 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "00001234
00004660
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:61"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_102
#AT_START_103
# 103. extensions.at:71: Hexadecimal numeric literal
at_setup_line='extensions.at:71'
at_desc="Hexadecimal numeric literal"
$at_quiet $as_echo_n "103: $at_desc                    "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "103. extensions.at:71: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X-1           PIC 9(8) VALUE H"012345".
       01 X-2           PIC 9(8) VALUE H"FFFFFF".
       PROCEDURE        DIVISION.
           DISPLAY X-1
           END-DISPLAY.
           DISPLAY X-2
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:88: \${COMPILE} -o prog prog.cob"
echo extensions.at:88 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:88"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:89: ./prog"
echo extensions.at:89 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "00074565
16777215
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:89"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_103
#AT_START_104
# 104. extensions.at:99: Semi-parenthesized condition
at_setup_line='extensions.at:99'
at_desc="Semi-parenthesized condition"
$at_quiet $as_echo_n "104: $at_desc                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "104. extensions.at:99: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       PROCEDURE        DIVISION.
           IF 1 = (1 OR 2)
             DISPLAY "OK" NO ADVANCING
             END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:112: \${COMPILE} -o prog prog.cob"
echo extensions.at:112 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:112"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:113: ./prog"
echo extensions.at:113 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:113"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_104
#AT_START_105
# 105. extensions.at:120: ADDRESS OF
at_setup_line='extensions.at:120'
at_desc="ADDRESS OF"
$at_quiet $as_echo_n "105: $at_desc                                     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "105. extensions.at:120: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X-1           PIC X(3) VALUE "X-1".
       01 X-2           PIC X(3) VALUE "X-2".
       01 G.
         02 PTR-1       USAGE POINTER VALUE NULL.
         02 PTR-2       USAGE POINTER VALUE NULL.
       LINKAGE          SECTION.
       01 Y             PIC X(3).
       PROCEDURE        DIVISION.
         SET ADDRESS OF Y TO ADDRESS OF X-1.
         DISPLAY Y
         END-DISPLAY.
         SET PTR-1 TO ADDRESS OF X-2.
         SET PTR-2 TO PTR-1
         SET ADDRESS OF Y TO PTR-2.
         DISPLAY Y
         END-DISPLAY.
         INITIALIZE PTR-1.
         IF PTR-1 = NULL
           DISPLAY "OK"
           END-DISPLAY
         ELSE
           DISPLAY "NG"
           END-DISPLAY
         END-IF.
         SET ADDRESS OF Y TO NULL.
         IF PTR-1 = ADDRESS OF Y
           DISPLAY "OK"
           END-DISPLAY
         ELSE
           DISPLAY "NG"
           END-DISPLAY
         END-IF.
         IF ADDRESS OF Y = PTR-1
           DISPLAY "OK"
           END-DISPLAY
         ELSE
           DISPLAY "NG"
           END-DISPLAY
         END-IF.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:168: \${COMPILE} -o prog prog.cob"
echo extensions.at:168 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:168"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:169: ./prog"
echo extensions.at:169 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "X-1
X-2
OK
OK
OK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:169"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_105
#AT_START_106
# 106. extensions.at:183: LENGTH OF
at_setup_line='extensions.at:183'
at_desc="LENGTH OF"
$at_quiet $as_echo_n "106: $at_desc                                      "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "106. extensions.at:183: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(2).
       01 G.
         02 Y           PIC X(2) OCCURS 10.
       01 L             PIC 9(4).
       01 I             PIC 9(2) VALUE 10.
       PROCEDURE        DIVISION.
           MOVE LENGTH OF X TO L.  DISPLAY L
           END-DISPLAY.
           MOVE LENGTH OF Y TO L.  DISPLAY L
           END-DISPLAY.
           MOVE LENGTH OF Y(1) TO L.  DISPLAY L
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:205: \${COMPILE} -o prog prog.cob"
echo extensions.at:205 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:205"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:206: ./prog"
echo extensions.at:206 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "0002
0002
0002
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:206"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_106
#AT_START_107
# 107. extensions.at:217: WHEN-COMPILED
at_setup_line='extensions.at:217'
at_desc="WHEN-COMPILED"
$at_quiet $as_echo_n "107: $at_desc                                  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "107. extensions.at:217: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(20).
       PROCEDURE        DIVISION.
           MOVE WHEN-COMPILED TO X.
           INSPECT X CONVERTING "0123456789" TO "9999999999".
           DISPLAY X NO ADVANCING
           END-DISPLAY.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:232: \${COMPILE} -o prog prog.cob"
echo extensions.at:232 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:232"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:233: ./prog"
echo extensions.at:233 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "99/99/9999.99.99    " | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:233"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_107
#AT_START_108
# 108. extensions.at:240: Complex OCCURS DEPENDING ON
at_setup_line='extensions.at:240'
at_desc="Complex OCCURS DEPENDING ON"
$at_quiet $as_echo_n "108: $at_desc                    "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "108. extensions.at:240: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 I PIC 9.
       01 G-1 VALUE "123456789".
         02 G-2.
           03 X PIC X OCCURS 1 TO 3 DEPENDING ON I.
         02 G-3.
           03 G-4.
             04 X PIC X OCCURS 1 TO 3 DEPENDING ON I.
           03 G-5.
             04 X PIC X OCCURS 1 TO 3 DEPENDING ON I.
       PROCEDURE        DIVISION.
           MOVE 2 TO I.
           DISPLAY G-1 ":" G-4 ":" G-5 NO ADVANCING
           END-DISPLAY.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:262: \${COMPILE} -std=mvs -o prog prog.cob"
echo extensions.at:262 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -std=mvs -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -std=mvs -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:262"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:263: ./prog"
echo extensions.at:263 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "123456:34:56" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:263"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_108
#AT_START_109
# 109. extensions.at:268: MOVE NON-INTEGER TO ALPHA-NUMERIC
at_setup_line='extensions.at:268'
at_desc="MOVE NON-INTEGER TO ALPHA-NUMERIC"
$at_quiet $as_echo_n "109: $at_desc              "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "109. extensions.at:268: testing ..."
  $at_traceon

#  see MF - COBOL  Error Messages  1029-E ...
cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
        01 INTEGER             PIC 9(4)   VALUE 1289 .
        01 SIGNED-INTEGER      PIC S9(4)  VALUE -1289 .

        01 ALPHA-FIELD         PIC X(4).

        01 NON-INTEGER           PIC 9(2)V99   VALUE 12.89 .
        01 NON-INTEGER-2         PIC 9(2)V99
                                     USAGE BINARY VALUE 12.89 .
        01 NON-INTEGER-3         PIC 9(2)V99
                                      USAGE PACKED-DECIMAL VALUE 12.89 .
        01 SIGNED-NON-INTEGER    PIC S9(2)V99   VALUE -12.89 .
        01 SIGNED-NON-INTEGER-2  PIC S9(2)V99
                                     USAGE BINARY VALUE -12.89 .
        01 SIGNED-NON-INTEGER-3  PIC S9(2)V99
                                     USAGE PACKED-DECIMAL VALUE -12.89 .

       PROCEDURE        DIVISION.
*     *    1029-E :  MF-COBOL Extension  see ERROR-Messages (2-77) !
*     *    MOVE NON-INTEGER TO ALPHA-NUMERIC --> ignore Decimal Point!
       S-01.
          MOVE SPACES TO ALPHA-FIELD.
          MOVE INTEGER TO ALPHA-FIELD.
          DISPLAY  ALPHA-FIELD NO ADVANCING
          END-DISPLAY.
       S-02.
          MOVE SPACES TO ALPHA-FIELD.
          MOVE SIGNED-INTEGER TO ALPHA-FIELD.
          DISPLAY  ALPHA-FIELD NO ADVANCING
          END-DISPLAY.
       S-03.
          MOVE SPACES TO ALPHA-FIELD.
          MOVE NON-INTEGER TO ALPHA-FIELD.
          DISPLAY  ALPHA-FIELD NO ADVANCING
          END-DISPLAY.
       S-10.
          MOVE SPACES TO ALPHA-FIELD.
          MOVE NON-INTEGER-2 TO ALPHA-FIELD.
          DISPLAY  ALPHA-FIELD NO ADVANCING
          END-DISPLAY.
       S-20.
          MOVE SPACES TO ALPHA-FIELD.
          MOVE NON-INTEGER-3 TO ALPHA-FIELD.
          DISPLAY  ALPHA-FIELD NO ADVANCING
          END-DISPLAY.
       S-30.
          MOVE SPACES TO ALPHA-FIELD.
          MOVE SIGNED-NON-INTEGER TO ALPHA-FIELD.
          DISPLAY  ALPHA-FIELD NO ADVANCING
          END-DISPLAY.
       S-40.
          MOVE SPACES TO ALPHA-FIELD.
          MOVE SIGNED-NON-INTEGER-2 TO ALPHA-FIELD.
          DISPLAY  ALPHA-FIELD NO ADVANCING
          END-DISPLAY.
       S-50.
          MOVE SPACES TO ALPHA-FIELD.
          MOVE SIGNED-NON-INTEGER-3 TO ALPHA-FIELD.
          DISPLAY  ALPHA-FIELD NO ADVANCING
          END-DISPLAY.

          STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:338: \${COMPILE} -std=mf -o prog prog.cob"
echo extensions.at:338 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -std=mf -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -std=mf -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob: In paragraph 'S-03':
prog.cob:37: Warning: Move non-integer to alphanumeric
prog.cob: In paragraph 'S-10':
prog.cob:42: Warning: Move non-integer to alphanumeric
prog.cob: In paragraph 'S-20':
prog.cob:47: Warning: Move non-integer to alphanumeric
prog.cob: In paragraph 'S-30':
prog.cob:52: Warning: Move non-integer to alphanumeric
prog.cob: In paragraph 'S-40':
prog.cob:57: Warning: Move non-integer to alphanumeric
prog.cob: In paragraph 'S-50':
prog.cob:62: Warning: Move non-integer to alphanumeric
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:338"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:352: ./prog"
echo extensions.at:352 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "12891289128912891289128912891289" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:352"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_109
#AT_START_110
# 110. extensions.at:359: CALL USING file-name - so
at_setup_line='extensions.at:359'
at_desc="CALL USING file-name - so"
$at_quiet $as_echo_n "110: $at_desc                      "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "110. extensions.at:359: testing ..."
  $at_traceon


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:361: test \$SHREXT != \"dll\" || exit 77"
echo extensions.at:361 >"$at_check_line_file"

if test -n "$at_traceon" \
  && at_func_check_newline "test $SHREXT != \"dll\" || exit 77"; then
  ( $at_traceon; test $SHREXT != "dll" || exit 77 ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; test $SHREXT != "dll" || exit 77 ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:361"

$at_failed && at_func_log_failure
$at_traceon; }


cat >setfilename.c <<'_ATEOF'

#include <stdio.h>
#include <string.h>
#include <libcob.h>
int setfilename (cob_file *f, unsigned char *name)
{
  memcpy (f->assign->data, name, strlen ((char *)name));
  return 0;
}
_ATEOF


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       INPUT-OUTPUT     SECTION.
       FILE-CONTROL.
       SELECT TEST-FILE ASSIGN FILENAME.
       DATA             DIVISION.
       FILE             SECTION.
       FD TEST-FILE.
       01 TEST-REC      PIC X(4).
       WORKING-STORAGE  SECTION.
       01 FILENAME      PIC X(8).
       PROCEDURE        DIVISION.
           INITIALIZE FILENAME.
           CALL "setfilename" USING TEST-FILE "TESTFILE"
           END-CALL.
           OPEN OUTPUT TEST-FILE.
           CLOSE TEST-FILE.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:396: \${COMPILE_MODULE} setfilename.c"
echo extensions.at:396 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} setfilename.c ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} setfilename.c ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:396"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:397: \${COMPILE} -o prog prog.cob"
echo extensions.at:397 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:397"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:398: ./prog"
echo extensions.at:398 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:398"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:399: test -e TESTFILE"
echo extensions.at:399 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; test -e TESTFILE ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; test -e TESTFILE ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:399"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_110
#AT_START_111
# 111. extensions.at:403: CALL USING file-name - dll
at_setup_line='extensions.at:403'
at_desc="CALL USING file-name - dll"
$at_quiet $as_echo_n "111: $at_desc                     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "111. extensions.at:403: testing ..."
  $at_traceon


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:405: test \$SHREXT = \"dll\" || exit 77"
echo extensions.at:405 >"$at_check_line_file"

if test -n "$at_traceon" \
  && at_func_check_newline "test $SHREXT = \"dll\" || exit 77"; then
  ( $at_traceon; test $SHREXT = "dll" || exit 77 ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; test $SHREXT = "dll" || exit 77 ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:405"

$at_failed && at_func_log_failure
$at_traceon; }


cat >setfilename.c <<'_ATEOF'

#include <stdio.h>
#include <string.h>
#include <libcob.h>
#define DllExport __declspec (dllexport)
DllExport int setfilename ();
int setfilename (cob_file *f, unsigned char *name)
{
  memcpy (f->assign->data, name, strlen ((char *)name));
  return 0;
}
_ATEOF


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       INPUT-OUTPUT     SECTION.
       FILE-CONTROL.
       SELECT TEST-FILE ASSIGN FILENAME.
       DATA             DIVISION.
       FILE             SECTION.
       FD TEST-FILE.
       01 TEST-REC      PIC X(4).
       WORKING-STORAGE  SECTION.
       01 FILENAME      PIC X(8).
       PROCEDURE        DIVISION.
           INITIALIZE FILENAME.
           CALL "setfilename" USING TEST-FILE "TESTFILE"
           END-CALL.
           OPEN OUTPUT TEST-FILE.
           CLOSE TEST-FILE.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:442: \${COMPILE_MODULE} setfilename.c"
echo extensions.at:442 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} setfilename.c ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} setfilename.c ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:442"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:443: \${COMPILE} -o prog prog.cob"
echo extensions.at:443 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:443"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:444: ./prog"
echo extensions.at:444 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:444"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:445: test -e TESTFILE"
echo extensions.at:445 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; test -e TESTFILE ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; test -e TESTFILE ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:445"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_111
#AT_START_112
# 112. extensions.at:449: CALL unusual PROGRAM-ID.
at_setup_line='extensions.at:449'
at_desc="CALL unusual PROGRAM-ID."
$at_quiet $as_echo_n "112: $at_desc                       "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "112. extensions.at:449: testing ..."
  $at_traceon


cat >A@B.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      "A@B".
       PROCEDURE        DIVISION.
           DISPLAY "P1" NO ADVANCING
           END-DISPLAY.
           EXIT PROGRAM.
_ATEOF


cat >A#B.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      "A#B".
       PROCEDURE        DIVISION.
           DISPLAY "P2" NO ADVANCING
           END-DISPLAY.
           EXIT PROGRAM.
_ATEOF


cat >A-B.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      "A-B".
       PROCEDURE        DIVISION.
           DISPLAY "P3" NO ADVANCING
           END-DISPLAY.
           EXIT PROGRAM.
_ATEOF


cat >A_B.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      "A_B".
       PROCEDURE        DIVISION.
           DISPLAY "P4" NO ADVANCING
           END-DISPLAY.
           EXIT PROGRAM.
_ATEOF


cat >caller.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      caller.
       PROCEDURE        DIVISION.
           CALL "A@B"
           END-CALL.
           CALL "A#B"
           END-CALL.
           CALL "A-B"
           END-CALL.
           CALL "A_B"
           END-CALL.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:502: \${COMPILE_MODULE} A@B.cob"
echo extensions.at:502 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} A@B.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} A@B.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:502"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:503: \${COMPILE_MODULE} A#B.cob"
echo extensions.at:503 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} A#B.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} A#B.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:503"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:504: \${COMPILE_MODULE} A-B.cob"
echo extensions.at:504 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} A-B.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} A-B.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:504"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:505: \${COMPILE_MODULE} A_B.cob"
echo extensions.at:505 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} A_B.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} A_B.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:505"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:506: \${COMPILE} -o caller caller.cob"
echo extensions.at:506 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o caller caller.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o caller caller.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:506"

$at_failed && at_func_log_failure
$at_traceon; }


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:508: ./caller"
echo extensions.at:508 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./caller ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./caller ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "P1P2P3P4" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:508"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_112
#AT_START_113
# 113. extensions.at:512: Case independent PROGRAM-ID
at_setup_line='extensions.at:512'
at_desc="Case independent PROGRAM-ID"
$at_quiet $as_echo_n "113: $at_desc                    "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "113. extensions.at:512: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      PROG.
       PROCEDURE        DIVISION.
           CALL "prog"
           END-CALL.
           STOP RUN.
       PROGRAM-ID.      prog.
       PROCEDURE        DIVISION.
           DISPLAY "OK" NO ADVANCING
           END-DISPLAY.
           EXIT PROGRAM.
       END PROGRAM prog.
       END PROGRAM PROG.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:530: \${COMPILE} -o prog prog.cob"
echo extensions.at:530 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:530"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:531: ./prog"
echo extensions.at:531 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:531"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_113
#AT_START_114
# 114. extensions.at:535: PROGRAM-ID AS clause
at_setup_line='extensions.at:535'
at_desc="PROGRAM-ID AS clause"
$at_quiet $as_echo_n "114: $at_desc                           "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "114. extensions.at:535: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      caller AS "PROG".
       PROCEDURE        DIVISION.
           CALL "prog"
           END-CALL.
           STOP RUN.
       PROGRAM-ID.      callee AS "prog".
       PROCEDURE        DIVISION.
           DISPLAY "OK" NO ADVANCING
           END-DISPLAY.
           EXIT PROGRAM.
       END PROGRAM callee.
       END PROGRAM caller.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:553: \${COMPILE} -o prog prog.cob"
echo extensions.at:553 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:553"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:554: ./prog"
echo extensions.at:554 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:554"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_114
#AT_START_115
# 115. extensions.at:558: Quoted PROGRAM-ID
at_setup_line='extensions.at:558'
at_desc="Quoted PROGRAM-ID"
$at_quiet $as_echo_n "115: $at_desc                              "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "115. extensions.at:558: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      "caller".
       PROCEDURE        DIVISION.
           CALL "callee"
           END-CALL.
           STOP RUN.
       PROGRAM-ID.      "callee".
       PROCEDURE        DIVISION.
           DISPLAY "OK" NO ADVANCING
           END-DISPLAY.
           EXIT PROGRAM.
       END PROGRAM callee.
       END PROGRAM caller.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:576: \${COMPILE} -o prog prog.cob"
echo extensions.at:576 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:576"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:577: ./prog"
echo extensions.at:577 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:577"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_115
#AT_START_116
# 116. extensions.at:583: ASSIGN MF
at_setup_line='extensions.at:583'
at_desc="ASSIGN MF"
$at_quiet $as_echo_n "116: $at_desc                                      "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "116. extensions.at:583: testing ..."
  $at_traceon


cat >test.conf <<'_ATEOF'

include "cobol2002.conf"
assign-clause: mf
_ATEOF


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       INPUT-OUTPUT     SECTION.
       FILE-CONTROL.
       SELECT TEST-FILE ASSIGN FILENAME.
       DATA             DIVISION.
       FILE             SECTION.
       FD TEST-FILE.
       01 TEST-REC      PIC X(4).
       PROCEDURE        DIVISION.
           MOVE "TEST-FILE" TO FILENAME.
           OPEN OUTPUT TEST-FILE.
           CLOSE TEST-FILE.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:608: \${COMPILE} -conf=test.conf -o prog prog.cob"
echo extensions.at:608 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -conf=test.conf -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -conf=test.conf -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob:12: Warning: 'FILENAME' will be implicitly defined
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:608"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:611: ./prog"
echo extensions.at:611 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:611"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_116
#AT_START_117
# 117. extensions.at:615: ASSIGN IBM
at_setup_line='extensions.at:615'
at_desc="ASSIGN IBM"
$at_quiet $as_echo_n "117: $at_desc                                     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "117. extensions.at:615: testing ..."
  $at_traceon


cat >test.conf <<'_ATEOF'

include "cobol2002.conf"
assign-clause: ibm
_ATEOF


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       INPUT-OUTPUT     SECTION.
       FILE-CONTROL.
       SELECT TEST-FILE ASSIGN DA-S-FILENAME.
       DATA             DIVISION.
       FILE             SECTION.
       FD TEST-FILE.
       01 TEST-REC      PIC X(4).
       PROCEDURE        DIVISION.
           OPEN OUTPUT TEST-FILE.
           CLOSE TEST-FILE.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:639: \${COMPILE} -conf=test.conf -o prog prog.cob"
echo extensions.at:639 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -conf=test.conf -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -conf=test.conf -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:639"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:640: ./prog"
echo extensions.at:640 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:640"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:641: test -f FILENAME"
echo extensions.at:641 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; test -f FILENAME ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; test -f FILENAME ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:641"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_117
#AT_START_118
# 118. extensions.at:645: ASSIGN mapping
at_setup_line='extensions.at:645'
at_desc="ASSIGN mapping"
$at_quiet $as_echo_n "118: $at_desc                                 "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "118. extensions.at:645: testing ..."
  $at_traceon


cat >test.conf <<'_ATEOF'

include "cobol2002.conf"
filename-mapping: yes
_ATEOF


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       INPUT-OUTPUT     SECTION.
       FILE-CONTROL.
       SELECT TEST-FILE ASSIGN "FILENAME".
       DATA             DIVISION.
       FILE             SECTION.
       FD TEST-FILE.
       01 TEST-REC      PIC X(4).
       PROCEDURE        DIVISION.
           OPEN OUTPUT TEST-FILE.
           CLOSE TEST-FILE.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:669: \${COMPILE} -conf=test.conf -o prog prog.cob"
echo extensions.at:669 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -conf=test.conf -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -conf=test.conf -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:669"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:670: DD_FILENAME=\"x\" ./prog"
echo extensions.at:670 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; DD_FILENAME="x" ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; DD_FILENAME="x" ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:670"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:671: test -f \"x\""
echo extensions.at:671 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; test -f "x" ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; test -f "x" ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:671"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:672: dd_FILENAME=\"y\" ./prog"
echo extensions.at:672 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; dd_FILENAME="y" ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; dd_FILENAME="y" ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:672"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:673: test -f \"y\""
echo extensions.at:673 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; test -f "y" ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; test -f "y" ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:673"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:674: FILENAME=\"z\" ./prog"
echo extensions.at:674 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; FILENAME="z" ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; FILENAME="z" ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:674"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:675: test -f \"z\""
echo extensions.at:675 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; test -f "z" ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; test -f "z" ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:675"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:676: ./prog"
echo extensions.at:676 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:676"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:677: test -f \"FILENAME\""
echo extensions.at:677 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; test -f "FILENAME" ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; test -f "FILENAME" ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:677"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_118
#AT_START_119
# 119. extensions.at:681: ASSIGN expansion
at_setup_line='extensions.at:681'
at_desc="ASSIGN expansion"
$at_quiet $as_echo_n "119: $at_desc                               "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "119. extensions.at:681: testing ..."
  $at_traceon


cat >test.conf <<'_ATEOF'

include "cobol2002.conf"
filename-mapping: yes
_ATEOF


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       INPUT-OUTPUT     SECTION.
       FILE-CONTROL.
       SELECT TEST-FILE ASSIGN "$DIR/FILENAME".
       DATA             DIVISION.
       FILE             SECTION.
       FD TEST-FILE.
       01 TEST-REC      PIC X(4).
       PROCEDURE        DIVISION.
           OPEN OUTPUT TEST-FILE.
           CLOSE TEST-FILE.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:705: \${COMPILE} -conf=test.conf -o prog prog.cob"
echo extensions.at:705 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -conf=test.conf -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -conf=test.conf -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:705"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:706: DIR=\".\" ./prog"
echo extensions.at:706 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; DIR="." ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; DIR="." ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:706"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:707: test -f \"./FILENAME\" && rm -f \"./FILENAME\""
echo extensions.at:707 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; test -f "./FILENAME" && rm -f "./FILENAME" ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; test -f "./FILENAME" && rm -f "./FILENAME" ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:707"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_119
#AT_START_120
# 120. extensions.at:711: ASSIGN with COB_FILE_PATH
at_setup_line='extensions.at:711'
at_desc="ASSIGN with COB_FILE_PATH"
$at_quiet $as_echo_n "120: $at_desc                      "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "120. extensions.at:711: testing ..."
  $at_traceon


cat >test.conf <<'_ATEOF'

include "cobol2002.conf"
filename-mapping: yes
_ATEOF


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       INPUT-OUTPUT     SECTION.
       FILE-CONTROL.
       SELECT TEST-FILE ASSIGN "FILENAMEX".
       DATA             DIVISION.
       FILE             SECTION.
       FD TEST-FILE.
       01 TEST-REC      PIC X(4).
       PROCEDURE        DIVISION.
           OPEN OUTPUT TEST-FILE.
           CLOSE TEST-FILE.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:735: \${COMPILE} -conf=test.conf -o prog prog.cob"
echo extensions.at:735 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -conf=test.conf -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -conf=test.conf -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:735"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:736: COB_FILE_PATH=\"..\" ./prog"
echo extensions.at:736 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; COB_FILE_PATH=".." ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; COB_FILE_PATH=".." ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:736"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:737: test -f \"../FILENAMEX\" && rm -f \"../FILENAMEX\""
echo extensions.at:737 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; test -f "../FILENAMEX" && rm -f "../FILENAMEX" ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; test -f "../FILENAMEX" && rm -f "../FILENAMEX" ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:737"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_120
#AT_START_121
# 121. extensions.at:744: NUMBER-OF-CALL-PARAMETERS
at_setup_line='extensions.at:744'
at_desc="NUMBER-OF-CALL-PARAMETERS"
$at_quiet $as_echo_n "121: $at_desc                      "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "121. extensions.at:744: testing ..."
  $at_traceon


cat >callee.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      callee.
       DATA             DIVISION.
       LINKAGE          SECTION.
       01 W             PIC X.
       01 X             PIC X.
       01 Y             PIC X.
       01 Z             PIC X.
       PROCEDURE        DIVISION
           USING W X Y Z.
           DISPLAY NUMBER-OF-CALL-PARAMETERS
           END-DISPLAY.
           EXIT PROGRAM.
_ATEOF


cat >caller.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      caller.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 W             PIC X.
       01 X             PIC X.
       01 Y             PIC X.
       01 Z             PIC X.
       PROCEDURE        DIVISION.
           CALL "callee"
           END-CALL.
           CALL "callee" USING W
           END-CALL.
           CALL "callee" USING W X
           END-CALL.
           CALL "callee" USING W X Y
           END-CALL.
           CALL "callee" USING W X Y Z
           END-CALL.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:785: \${COMPILE} caller.cob"
echo extensions.at:785 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} caller.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} caller.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:785"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:786: \${COMPILE_MODULE} callee.cob"
echo extensions.at:786 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} callee.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} callee.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:786"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:787: ./caller"
echo extensions.at:787 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./caller ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./caller ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "+000000000
+000000001
+000000002
+000000003
+000000004
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:787"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_121
#AT_START_122
# 122. extensions.at:800: PROCEDURE DIVISION USING BY ...
at_setup_line='extensions.at:800'
at_desc="PROCEDURE DIVISION USING BY ..."
$at_quiet $as_echo_n "122: $at_desc                "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "122. extensions.at:800: testing ..."
  $at_traceon


cat >callee.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      callee.
       DATA             DIVISION.
       LINKAGE          SECTION.
       01 X             PIC X.
       01 Y             PIC 99.
       01 Z             PIC 99 USAGE COMP.
       PROCEDURE        DIVISION
           USING BY VALUE X BY REFERENCE Y Z.
           DISPLAY "X = " X " Y = " Y " Z = " Z
           END-DISPLAY.
           MOVE "Z" TO X.
           MOVE 56 TO Y.
           MOVE 78 TO Z.
           EXIT PROGRAM.
_ATEOF


cat >caller.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      caller.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X.
       01 Y             PIC 99.
       01 Z             PIC 99 USAGE COMP.
       PROCEDURE        DIVISION.
           MOVE "X" TO X.
           MOVE 12 TO Y.
           MOVE 34 TO Z.
           CALL "callee" USING BY CONTENT X BY REFERENCE Y
                BY CONTENT Z
           END-CALL.
           DISPLAY "X = " X " Y = " Y " Z = " Z
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:840: \${COMPILE} caller.cob"
echo extensions.at:840 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} caller.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} caller.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:840"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:841: \${COMPILE_MODULE} callee.cob"
echo extensions.at:841 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} callee.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} callee.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:841"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:842: ./caller"
echo extensions.at:842 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./caller ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./caller ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "X = X Y = 12 Z = 34
X = X Y = 56 Z = 34
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:842"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_122
#AT_START_123
# 123. extensions.at:849: PROCEDURE DIVISION CHAINING ...
at_setup_line='extensions.at:849'
at_desc="PROCEDURE DIVISION CHAINING ..."
$at_quiet $as_echo_n "123: $at_desc                "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "123. extensions.at:849: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X            PIC X.
       01  ABCD         PIC X(4).
       PROCEDURE        DIVISION
                        CHAINING X ABCD.
           DISPLAY X
           END-DISPLAY.
           DISPLAY ABCD
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:867: \${COMPILE} prog.cob"
echo extensions.at:867 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:867"

$at_failed && at_func_log_failure
$at_traceon; }


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:869: ./prog X ABCD"
echo extensions.at:869 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog X ABCD ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog X ABCD ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "X
ABCD
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:869"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_123
#AT_START_124
# 124. extensions.at:877: STOP RUN RETURNING
at_setup_line='extensions.at:877'
at_desc="STOP RUN RETURNING"
$at_quiet $as_echo_n "124: $at_desc                             "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "124. extensions.at:877: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       PROCEDURE        DIVISION.
           STOP RUN RETURNING 1.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:886: \${COMPILE} -o prog prog.cob"
echo extensions.at:886 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:886"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:887: ./prog"
echo extensions.at:887 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/extensions.at:887"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_124
#AT_START_125
# 125. extensions.at:894: ENTRY
at_setup_line='extensions.at:894'
at_desc="ENTRY"
$at_quiet $as_echo_n "125: $at_desc                                          "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "125. extensions.at:894: testing ..."
  $at_traceon


cat >caller.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       PROCEDURE        DIVISION.
           CALL "hello" USING "COBOL"
           END-CALL.
           CALL "bye" USING "COBOL"
           END-CALL.
           STOP RUN.
_ATEOF


cat >hello.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      hello.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 MSG-HELLO     PIC X(7) VALUE "Hello, ".
       01 MSG-BYE       PIC X(5) VALUE "Bye, ".
       LINKAGE          SECTION.
       01 X             PIC X(5).
       01 Y             PIC X(5).
       PROCEDURE        DIVISION USING X.
           DISPLAY MSG-HELLO X "!"
           END-DISPLAY.
           EXIT PROGRAM.

           ENTRY "bye" USING Y.
           DISPLAY MSG-BYE Y "!"
           END-DISPLAY.
           EXIT PROGRAM.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:928: \${COMPILE} -std=mvs caller.cob"
echo extensions.at:928 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -std=mvs caller.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -std=mvs caller.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:928"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:929: \${COMPILE_MODULE} -std=mvs hello.cob"
echo extensions.at:929 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} -std=mvs hello.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} -std=mvs hello.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:929"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:930: ./caller"
echo extensions.at:930 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./caller ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./caller ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "Hello, COBOL!
Bye, COBOL!
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:930"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_125
#AT_START_126
# 126. extensions.at:940: LINE SEQUENTIAL write
at_setup_line='extensions.at:940'
at_desc="LINE SEQUENTIAL write"
$at_quiet $as_echo_n "126: $at_desc                          "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "126. extensions.at:940: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       INPUT-OUTPUT     SECTION.
       FILE-CONTROL.
       SELECT TEST-FILE ASSIGN       "./TEST-FILE"
                        ORGANIZATION IS LINE SEQUENTIAL.
       DATA             DIVISION.
       FILE             SECTION.
       FD TEST-FILE.
       01 TEST-REC      PIC X(4).
       PROCEDURE        DIVISION.
           OPEN OUTPUT TEST-FILE.
           MOVE "a"    TO TEST-REC. WRITE TEST-REC
           END-WRITE.
           MOVE "ab"   TO TEST-REC. WRITE TEST-REC AFTER 1 LINES
           END-WRITE.
           MOVE "abc"  TO TEST-REC. WRITE TEST-REC BEFORE 2 LINES
           END-WRITE.
           MOVE "abcd" TO TEST-REC. WRITE TEST-REC
           END-WRITE.
           CLOSE TEST-FILE.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:968: \${COMPILE} -o prog prog.cob"
echo extensions.at:968 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:968"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:969: ./prog"
echo extensions.at:969 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:969"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:970: cat TEST-FILE"
echo extensions.at:970 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; cat TEST-FILE ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; cat TEST-FILE ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "a

ab
abc

abcd
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:970"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_126
#AT_START_127
# 127. extensions.at:981: LINE SEQUENTIAL read
at_setup_line='extensions.at:981'
at_desc="LINE SEQUENTIAL read"
$at_quiet $as_echo_n "127: $at_desc                           "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "127. extensions.at:981: testing ..."
  $at_traceon


cat >TEST-FILE <<'_ATEOF'
a
ab
abc
abcd
abcde
abcdef
_ATEOF


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       INPUT-OUTPUT     SECTION.
       FILE-CONTROL.
       SELECT TEST-FILE ASSIGN       "./TEST-FILE"
                        ORGANIZATION IS LINE SEQUENTIAL.
       DATA             DIVISION.
       FILE             SECTION.
       FD TEST-FILE.
       01 TEST-REC      PIC X(4).
       PROCEDURE        DIVISION.
           OPEN INPUT TEST-FILE.
           READ TEST-FILE
           END-READ. DISPLAY "(" TEST-REC ")"
           END-DISPLAY.
           READ TEST-FILE
           END-READ. DISPLAY "(" TEST-REC ")"
           END-DISPLAY.
           READ TEST-FILE
           END-READ. DISPLAY "(" TEST-REC ")"
           END-DISPLAY.
           READ TEST-FILE
           END-READ. DISPLAY "(" TEST-REC ")"
           END-DISPLAY.
           READ TEST-FILE
           END-READ. DISPLAY "(" TEST-REC ")"
           END-DISPLAY.
           READ TEST-FILE
           END-READ. DISPLAY "(" TEST-REC ")"
           END-DISPLAY.
           CLOSE TEST-FILE.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1028: \${COMPILE} -o prog prog.cob"
echo extensions.at:1028 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1028"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1029: ./prog"
echo extensions.at:1029 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "(a   )
(ab  )
(abc )
(abcd)
(abcd)
(abcd)
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1029"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_127
#AT_START_128
# 128. extensions.at:1041: ASSIGN to KEYBOARD/DISPLAY
at_setup_line='extensions.at:1041'
at_desc="ASSIGN to KEYBOARD/DISPLAY"
$at_quiet $as_echo_n "128: $at_desc                     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "128. extensions.at:1041: testing ..."
  $at_traceon


cat >TEST-FILE <<'_ATEOF'
a
ab
abc
abcd
abcde
abcdef
_ATEOF


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       INPUT-OUTPUT     SECTION.
       FILE-CONTROL.
       SELECT TEST-FILE ASSIGN  KEYBOARD
                        ORGANIZATION IS LINE SEQUENTIAL.
       SELECT TEST-OUT  ASSIGN  DISPLAY
                        ORGANIZATION IS LINE SEQUENTIAL.
       DATA             DIVISION.
       FILE             SECTION.
       FD TEST-FILE.
       01 TEST-REC      PIC X(80).
       FD TEST-OUT.
       01 TEST-REC-OUT  PIC X(80).
       PROCEDURE        DIVISION.
       A00.
           OPEN INPUT  TEST-FILE.
           OPEN OUTPUT TEST-OUT.
       A01.
           READ TEST-FILE AT END
                GO TO Z99
           END-READ.
           WRITE TEST-REC-OUT FROM TEST-REC
           END-WRITE.
           GO TO A01.
       Z99.
           CLOSE TEST-FILE.
           CLOSE TEST-OUT.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1085: \${COMPILE} -o prog prog.cob"
echo extensions.at:1085 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1085"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1086: cat TEST-FILE | ./prog"
echo extensions.at:1086 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; cat TEST-FILE | ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; cat TEST-FILE | ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "a
ab
abc
abcd
abcde
abcdef
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1086"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_128
#AT_START_129
# 129. extensions.at:1097: Environment/Argument variable
at_setup_line='extensions.at:1097'
at_desc="Environment/Argument variable"
$at_quiet $as_echo_n "129: $at_desc                  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "129. extensions.at:1097: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 X             PIC X(4).
       01 Y             PIC X(8).
       01 Z             PIC 9(4).
       PROCEDURE        DIVISION.
           DISPLAY "TEST_ENV" UPON ENVIRONMENT-NAME
           END-DISPLAY.
           ACCEPT X FROM ENVIRONMENT-VALUE
           END-ACCEPT.
           DISPLAY "(" X ")"
           END-DISPLAY.
           DISPLAY "RXW" UPON ENVIRONMENT-VALUE
           END-DISPLAY.
           ACCEPT X FROM ENVIRONMENT-VALUE
           END-ACCEPT.
           DISPLAY "(" X ")"
           END-DISPLAY.
           ACCEPT Y FROM ARGUMENT-VALUE
           END-ACCEPT.
           DISPLAY "(" Y ")"
           END-DISPLAY.
           ACCEPT Z FROM ARGUMENT-NUMBER
           END-ACCEPT.
           DISPLAY "(" Z ")"
           END-DISPLAY.
           STOP RUN.
_ATEOF


export TEST_ENV=OK
{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1132: \${COMPILE} -o prog prog.cob"
echo extensions.at:1132 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1132"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1133: ./prog CHECKPAR"
echo extensions.at:1133 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog CHECKPAR ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog CHECKPAR ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "(OK  )
(RXW )
(CHECKPAR)
(0001)
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1133"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_129
#AT_START_130
# 130. extensions.at:1142: DECIMAL-POINT is COMMA (1)
at_setup_line='extensions.at:1142'
at_desc="DECIMAL-POINT is COMMA (1)"
$at_quiet $as_echo_n "130: $at_desc                     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "130. extensions.at:1142: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       CONFIGURATION    SECTION.
       SPECIAL-NAMES.
           DECIMAL-POINT    IS COMMA.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X            PIC 99V99.
       PROCEDURE        DIVISION.
           MOVE FUNCTION MIN (3,,,,,,5) TO X.
           DISPLAY X
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1161: \${COMPILE} prog.cob"
echo extensions.at:1161 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1161"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1162: ./prog"
echo extensions.at:1162 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "00,50
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1162"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_130
#AT_START_131
# 131. extensions.at:1168: DECIMAL-POINT is COMMA (2)
at_setup_line='extensions.at:1168'
at_desc="DECIMAL-POINT is COMMA (2)"
$at_quiet $as_echo_n "131: $at_desc                     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "131. extensions.at:1168: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       CONFIGURATION    SECTION.
       SPECIAL-NAMES.
           DECIMAL-POINT    IS COMMA.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X            PIC 99V99.
       PROCEDURE        DIVISION.
           MOVE FUNCTION MIN (3,,,,,, 5) TO X.
           DISPLAY X
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1187: \${COMPILE} prog.cob"
echo extensions.at:1187 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1187"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1188: ./prog"
echo extensions.at:1188 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "03,00
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1188"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_131
#AT_START_132
# 132. extensions.at:1194: DECIMAL-POINT is COMMA (3)
at_setup_line='extensions.at:1194'
at_desc="DECIMAL-POINT is COMMA (3)"
$at_quiet $as_echo_n "132: $at_desc                     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "132. extensions.at:1194: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       CONFIGURATION    SECTION.
       SPECIAL-NAMES.
           DECIMAL-POINT    IS COMMA.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X            PIC 99V99.
       PROCEDURE        DIVISION.
           MOVE FUNCTION MIN (3,,,,,, 1,5) TO X.
           DISPLAY X
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1213: \${COMPILE} prog.cob"
echo extensions.at:1213 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1213"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1214: ./prog"
echo extensions.at:1214 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "01,50
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1214"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_132
#AT_START_133
# 133. extensions.at:1220: DECIMAL-POINT is COMMA (4)
at_setup_line='extensions.at:1220'
at_desc="DECIMAL-POINT is COMMA (4)"
$at_quiet $as_echo_n "133: $at_desc                     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "133. extensions.at:1220: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       CONFIGURATION    SECTION.
       SPECIAL-NAMES.
           DECIMAL-POINT    IS COMMA.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X            PIC 99V99.
       PROCEDURE        DIVISION.
           MOVE FUNCTION MIN (3,,,,,,1,5) TO X.
           DISPLAY X
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1239: \${COMPILE} prog.cob"
echo extensions.at:1239 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1239"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1240: ./prog"
echo extensions.at:1240 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "00,10
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1240"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_133
#AT_START_134
# 134. extensions.at:1246: DECIMAL-POINT is COMMA (5)
at_setup_line='extensions.at:1246'
at_desc="DECIMAL-POINT is COMMA (5)"
$at_quiet $as_echo_n "134: $at_desc                     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "134. extensions.at:1246: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       CONFIGURATION    SECTION.
       SPECIAL-NAMES.
           DECIMAL-POINT    IS COMMA.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X            PIC 99V99.
       PROCEDURE        DIVISION.
           COMPUTE X=1 + ,1
           END-COMPUTE
           DISPLAY X
           END-DISPLAY.
           COMPUTE X=1*,1
           END-COMPUTE
           DISPLAY X
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1270: \${COMPILE} prog.cob"
echo extensions.at:1270 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1270"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1271: ./prog"
echo extensions.at:1271 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "01,10
00,10
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1271"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_134
#AT_START_135
# 135. extensions.at:1278: 78 Level (1)
at_setup_line='extensions.at:1278'
at_desc="78 Level (1)"
$at_quiet $as_echo_n "135: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "135. extensions.at:1278: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       78  X            VALUE "OK".
       PROCEDURE        DIVISION.
           DISPLAY X
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1292: \${COMPILE} prog.cob"
echo extensions.at:1292 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1292"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1293: ./prog"
echo extensions.at:1293 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1293"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_135
#AT_START_136
# 136. extensions.at:1299: 78 Level (2)
at_setup_line='extensions.at:1299'
at_desc="78 Level (2)"
$at_quiet $as_echo_n "136: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "136. extensions.at:1299: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  Z.
       78  X            VALUE "OK".
       78  Y            VALUE "OK".
           03  FILLER   PIC XX VALUE "OK".
       PROCEDURE        DIVISION.
           DISPLAY X Z Y
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1316: \${COMPILE} prog.cob"
echo extensions.at:1316 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1316"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1317: ./prog"
echo extensions.at:1317 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OKOKOK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1317"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_136
#AT_START_137
# 137. extensions.at:1323: 78 Level (3)
at_setup_line='extensions.at:1323'
at_desc="78 Level (3)"
$at_quiet $as_echo_n "137: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "137. extensions.at:1323: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       78  X            VALUE "OK".
       01  Z            PIC XX VALUE "OK".
       PROCEDURE        DIVISION.
           DISPLAY Z X
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1338: \${COMPILE} prog.cob"
echo extensions.at:1338 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1338"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1339: ./prog"
echo extensions.at:1339 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OKOK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1339"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_137
#AT_START_138
# 138. extensions.at:1345: Unreachable statement
at_setup_line='extensions.at:1345'
at_desc="Unreachable statement"
$at_quiet $as_echo_n "138: $at_desc                          "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "138. extensions.at:1345: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
       P01.
           GO TO P02.
           DISPLAY "INVALID"
           END-DISPLAY.
       P02.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/extensions.at:1361: \${COMPILE} -Wunreachable prog.cob"
echo extensions.at:1361 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -Wunreachable prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -Wunreachable prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
echo >>"$at_stderr"; $as_echo "prog.cob: In paragraph 'P01':
prog.cob:9: Warning: Unreachable statement 'DISPLAY'
" | \
  $at_diff - "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/extensions.at:1361"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_138
#AT_START_139
# 139. return-code.at:23: RETURN-CODE moving
at_setup_line='return-code.at:23'
at_desc="RETURN-CODE moving"
$at_quiet $as_echo_n "139: $at_desc                             "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "139. return-code.at:23: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01 I             PIC 99 COMP.
       PROCEDURE        DIVISION.
           INITIALIZE RETURN-CODE.
           MOVE ZERO TO RETURN-CODE.
           MOVE 1 TO RETURN-CODE.
           MOVE RETURN-CODE TO I.
           DISPLAY I NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/return-code.at:41: \${COMPILE} -o prog prog.cob"
echo return-code.at:41 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/return-code.at:41"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/return-code.at:42: ./prog"
echo return-code.at:42 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "01" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 1 $at_status "$at_srcdir/return-code.at:42"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_139
#AT_START_140
# 140. return-code.at:46: RETURN-CODE passing
at_setup_line='return-code.at:46'
at_desc="RETURN-CODE passing"
$at_quiet $as_echo_n "140: $at_desc                            "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "140. return-code.at:46: testing ..."
  $at_traceon


cat >mod1.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      mod1.
       PROCEDURE        DIVISION.
           DISPLAY RETURN-CODE NO ADVANCING
           END-DISPLAY.
           MOVE 1 TO RETURN-CODE.
           DISPLAY RETURN-CODE NO ADVANCING
           END-DISPLAY.
           EXIT PROGRAM.
_ATEOF


cat >mod2.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      mod2.
       PROCEDURE        DIVISION.
           EXIT PROGRAM.
_ATEOF


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       PROCEDURE        DIVISION.
           CALL "mod1"
           END-CALL.
           DISPLAY RETURN-CODE NO ADVANCING
           END-DISPLAY.
           CALL "mod2"
           END-CALL.
           DISPLAY RETURN-CODE NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/return-code.at:82: \${COMPILE_MODULE} mod1.cob"
echo return-code.at:82 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} mod1.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} mod1.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/return-code.at:82"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/return-code.at:83: \${COMPILE_MODULE} mod2.cob"
echo return-code.at:83 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE_MODULE} mod2.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE_MODULE} mod2.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/return-code.at:83"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/return-code.at:84: \${COMPILE} -o prog prog.cob"
echo return-code.at:84 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/return-code.at:84"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/return-code.at:85: ./prog"
echo return-code.at:85 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "+000000000+000000001+000000001+000000000" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/return-code.at:85"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_140
#AT_START_141
# 141. return-code.at:89: RETURN-CODE nested
at_setup_line='return-code.at:89'
at_desc="RETURN-CODE nested"
$at_quiet $as_echo_n "141: $at_desc                             "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "141. return-code.at:89: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       PROCEDURE        DIVISION.
           MOVE 1 TO RETURN-CODE.
           DISPLAY RETURN-CODE NO ADVANCING
           END-DISPLAY.
           CALL "mod1"
           END-CALL.
           DISPLAY RETURN-CODE NO ADVANCING
           END-DISPLAY.
           MOVE ZERO TO RETURN-CODE.
           STOP RUN.
       PROGRAM-ID.      mod1.
       PROCEDURE        DIVISION.
           DISPLAY RETURN-CODE NO ADVANCING
           END-DISPLAY.
           MOVE 2 TO RETURN-CODE.
           EXIT PROGRAM.
       END PROGRAM mod1.
       END PROGRAM prog.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/return-code.at:114: \${COMPILE} -o prog prog.cob"
echo return-code.at:114 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/return-code.at:114"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/return-code.at:115: ./prog"
echo return-code.at:115 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "+000000001+000000001+000000002" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/return-code.at:115"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_141
#AT_START_142
# 142. functions.at:22: FUNCTION ABS
at_setup_line='functions.at:22'
at_desc="FUNCTION ABS"
$at_quiet $as_echo_n "142: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "142. functions.at:22: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   S9(4)V9(4) VALUE -1.2345.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION ABS ( X )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:36: \${COMPILE} -o prog prog.cob"
echo functions.at:36 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:36"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:37: ./prog"
echo functions.at:37 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "+0001.2345
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:37"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_142
#AT_START_143
# 143. functions.at:43: FUNCTION ACOS
at_setup_line='functions.at:43'
at_desc="FUNCTION ACOS"
$at_quiet $as_echo_n "143: $at_desc                                  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "143. functions.at:43: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   S9(4)V9(4) VALUE -0.2345.
       01  Z   PIC   S9V9(17)   COMP.
       PROCEDURE        DIVISION.
           MOVE FUNCTION ACOS ( X ) TO Z.
           IF Z >= 1.80750052110824325 AND
              Z <= 1.80750052110824345
                   DISPLAY "OK"
                   END-DISPLAY
           ELSE
                   DISPLAY Z
                   END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:65: \${COMPILE} -o prog prog.cob"
echo functions.at:65 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:65"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:66: ./prog"
echo functions.at:66 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:66"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_143
#AT_START_144
# 144. functions.at:72: FUNCTION ANNUITY
at_setup_line='functions.at:72'
at_desc="FUNCTION ANNUITY"
$at_quiet $as_echo_n "144: $at_desc                               "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "144. functions.at:72: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   S9(4) VALUE 3.
       01  Y   PIC   S9(4) VALUE 5.
       01  Z   PIC   S9V9(17)   COMP.
       PROCEDURE        DIVISION.
           MOVE FUNCTION ANNUITY ( X, Y ) TO Z.
           IF Z >= 3.002932551319648080 AND
              Z <= 3.002932551319648110
                   DISPLAY "OK"
                   END-DISPLAY
           ELSE
                   DISPLAY Z
                   END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:95: \${COMPILE} -o prog prog.cob"
echo functions.at:95 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:95"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:96: ./prog"
echo functions.at:96 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:96"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_144
#AT_START_145
# 145. functions.at:102: FUNCTION ASIN
at_setup_line='functions.at:102'
at_desc="FUNCTION ASIN"
$at_quiet $as_echo_n "145: $at_desc                                  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "145. functions.at:102: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   S9(4)V9(4) VALUE -0.2345.
       01  Y   PIC   S9V9(17)   COMP.
       PROCEDURE        DIVISION.
           MOVE FUNCTION ASIN ( X ) TO Y.
           IF Y >= -0.23670419431334685 AND
              Y <= -0.23670419431334675
                   DISPLAY "OK"
                   END-DISPLAY
           ELSE
                   DISPLAY Y
                   END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:124: \${COMPILE} -o prog prog.cob"
echo functions.at:124 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:124"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:125: ./prog"
echo functions.at:125 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:125"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_145
#AT_START_146
# 146. functions.at:131: FUNCTION ATAN
at_setup_line='functions.at:131'
at_desc="FUNCTION ATAN"
$at_quiet $as_echo_n "146: $at_desc                                  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "146. functions.at:131: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   S9(4)V9(4) VALUE 1.
       01  Y   PIC   S9V9(17)   COMP.
       PROCEDURE        DIVISION.
           MOVE FUNCTION ATAN ( X ) TO Y.
           IF Y >= 0.78539816339744825 AND
              Y <= 0.78539816339744835
                   DISPLAY "OK"
                   END-DISPLAY
           ELSE
                   DISPLAY Y
                   END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:153: \${COMPILE} -o prog prog.cob"
echo functions.at:153 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:153"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:154: ./prog"
echo functions.at:154 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:154"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_146
#AT_START_147
# 147. functions.at:160: FUNCTION CHAR
at_setup_line='functions.at:160'
at_desc="FUNCTION CHAR"
$at_quiet $as_echo_n "147: $at_desc                                  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "147. functions.at:160: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   S9(4)V9(4) VALUE 108.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION CHAR ( X )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:174: \${COMPILE} -o prog prog.cob"
echo functions.at:174 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:174"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:175: ./prog"
echo functions.at:175 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "k
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:175"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_147
#AT_START_148
# 148. functions.at:181: FUNCTION COMBINED-DATETIME
at_setup_line='functions.at:181'
at_desc="FUNCTION COMBINED-DATETIME"
$at_quiet $as_echo_n "148: $at_desc                     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "148. functions.at:181: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION COMBINED-DATETIME ( 987, 345 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:194: \${COMPILE} -o prog prog.cob"
echo functions.at:194 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:194"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:195: ./prog"
echo functions.at:195 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "0000987.00345
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:195"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_148
#AT_START_149
# 149. functions.at:201: FUNCTION CONCATENATE
at_setup_line='functions.at:201'
at_desc="FUNCTION CONCATENATE"
$at_quiet $as_echo_n "149: $at_desc                           "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "149. functions.at:201: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  Y   PIC   X(4).
       PROCEDURE        DIVISION.
           MOVE "defx" TO Y.
           DISPLAY FUNCTION CONCATENATE ( Y "abc" "zz" "55" "666" )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:216: \${COMPILE} -o prog prog.cob"
echo functions.at:216 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:216"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:217: ./prog"
echo functions.at:217 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "defxabczz55666
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:217"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_149
#AT_START_150
# 150. functions.at:223: FUNCTION CONCATENATE with reference modding
at_setup_line='functions.at:223'
at_desc="FUNCTION CONCATENATE with reference modding"
$at_quiet $as_echo_n "150: $at_desc    "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "150. functions.at:223: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  Y   PIC   X(4).
       PROCEDURE        DIVISION.
           MOVE "defx" TO Y.
           DISPLAY FUNCTION CONCATENATE
                   ( Y "abc" "zz" "55" "666" ) (2 : 9)
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:239: \${COMPILE} -o prog prog.cob"
echo functions.at:239 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:239"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:240: ./prog"
echo functions.at:240 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "efxabczz5
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:240"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_150
#AT_START_151
# 151. functions.at:246: FUNCTION COS
at_setup_line='functions.at:246'
at_desc="FUNCTION COS"
$at_quiet $as_echo_n "151: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "151. functions.at:246: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   S9(4)V9(4) VALUE -0.2345.
       01  Y   PIC   S9V9(17)   COMP.
       PROCEDURE        DIVISION.
           MOVE FUNCTION COS ( X ) TO Y.
           IF Y >= 0.97263064125625815 AND
              Y <= 0.97263064125625825
                   DISPLAY "OK"
                   END-DISPLAY
           ELSE
                   DISPLAY Y
                   END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:268: \${COMPILE} -o prog prog.cob"
echo functions.at:268 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:268"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:269: ./prog"
echo functions.at:269 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:269"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_151
#AT_START_152
# 152. functions.at:275: FUNCTION DATE-OF-INTEGER
at_setup_line='functions.at:275'
at_desc="FUNCTION DATE-OF-INTEGER"
$at_quiet $as_echo_n "152: $at_desc                       "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "152. functions.at:275: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION DATE-OF-INTEGER ( 146000 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:288: \${COMPILE} -o prog prog.cob"
echo functions.at:288 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:288"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:289: ./prog"
echo functions.at:289 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "20000925
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:289"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_152
#AT_START_153
# 153. functions.at:295: FUNCTION DATE-TO-YYYYMMDD
at_setup_line='functions.at:295'
at_desc="FUNCTION DATE-TO-YYYYMMDD"
$at_quiet $as_echo_n "153: $at_desc                      "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "153. functions.at:295: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION DATE-TO-YYYYMMDD ( 981002, -10, 1994 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:308: \${COMPILE} -o prog prog.cob"
echo functions.at:308 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:308"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:309: ./prog"
echo functions.at:309 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "18981002
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:309"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_153
#AT_START_154
# 154. functions.at:315: FUNCTION DAY-OF-INTEGER
at_setup_line='functions.at:315'
at_desc="FUNCTION DAY-OF-INTEGER"
$at_quiet $as_echo_n "154: $at_desc                        "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "154. functions.at:315: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION DAY-OF-INTEGER ( 146000 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:328: \${COMPILE} -o prog prog.cob"
echo functions.at:328 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:328"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:329: ./prog"
echo functions.at:329 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "2000269
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:329"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_154
#AT_START_155
# 155. functions.at:335: FUNCTION DAY-TO-YYYYDDD
at_setup_line='functions.at:335'
at_desc="FUNCTION DAY-TO-YYYYDDD"
$at_quiet $as_echo_n "155: $at_desc                        "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "155. functions.at:335: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION DAY-TO-YYYYDDD ( 95005, -10, 2013 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:348: \${COMPILE} -o prog prog.cob"
echo functions.at:348 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:348"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:349: ./prog"
echo functions.at:349 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "01995005
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:349"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_155
#AT_START_156
# 156. functions.at:355: FUNCTION E
at_setup_line='functions.at:355'
at_desc="FUNCTION E"
$at_quiet $as_echo_n "156: $at_desc                                     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "156. functions.at:355: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION E
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:368: \${COMPILE} -o prog prog.cob"
echo functions.at:368 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:368"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:369: ./prog"
echo functions.at:369 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "2.7182818284590452353602874713526625
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:369"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_156
#AT_START_157
# 157. functions.at:375: FUNCTION EXCEPTION-FILE
at_setup_line='functions.at:375'
at_desc="FUNCTION EXCEPTION-FILE"
$at_quiet $as_echo_n "157: $at_desc                        "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "157. functions.at:375: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       INPUT-OUTPUT     SECTION.
       FILE-CONTROL.
           SELECT TEST-FILE ASSIGN "NOTEXIST"
           FILE STATUS IS TEST-STATUS.
       DATA             DIVISION.
       FILE             SECTION.
       FD  TEST-FILE.
       01  TEST-REC      PIC X(4).
       WORKING-STORAGE SECTION.
       01  TEST-STATUS  PIC XX.
       PROCEDURE        DIVISION.
           OPEN INPUT TEST-FILE.
           DISPLAY FUNCTION EXCEPTION-FILE
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:398: \${COMPILE} -o prog prog.cob"
echo functions.at:398 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:398"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:399: ./prog"
echo functions.at:399 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "35TEST-FILE
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:399"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_157
#AT_START_158
# 158. functions.at:405: FUNCTION EXCEPTION-LOCATION
at_setup_line='functions.at:405'
at_desc="FUNCTION EXCEPTION-LOCATION"
$at_quiet $as_echo_n "158: $at_desc                    "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "158. functions.at:405: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       INPUT-OUTPUT     SECTION.
       FILE-CONTROL.
           SELECT TEST-FILE ASSIGN "NOTEXIST"
           FILE STATUS IS TEST-STATUS.
       DATA             DIVISION.
       FILE             SECTION.
       FD  TEST-FILE.
       01  TEST-REC      PIC X(4).
       WORKING-STORAGE SECTION.
       01  TEST-STATUS  PIC XX.
       PROCEDURE        DIVISION.
       A00-MAIN SECTION.
       A00.
           OPEN INPUT TEST-FILE.
       B00-MAIN SECTION.
       B00.
           DISPLAY FUNCTION EXCEPTION-LOCATION
                   NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:433: \${COMPILE} -debug -o prog prog.cob"
echo functions.at:433 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -debug -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -debug -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:433"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:434: ./prog"
echo functions.at:434 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "prog; A00 OF A00-MAIN; 18" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:434"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_158
#AT_START_159
# 159. functions.at:439: FUNCTION EXCEPTION-STATEMENT
at_setup_line='functions.at:439'
at_desc="FUNCTION EXCEPTION-STATEMENT"
$at_quiet $as_echo_n "159: $at_desc                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "159. functions.at:439: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       INPUT-OUTPUT     SECTION.
       FILE-CONTROL.
           SELECT TEST-FILE ASSIGN "NOTEXIST"
           FILE STATUS IS TEST-STATUS.
       DATA             DIVISION.
       FILE             SECTION.
       FD  TEST-FILE.
       01  TEST-REC      PIC X(4).
       WORKING-STORAGE SECTION.
       01  TEST-STATUS  PIC XX.
       PROCEDURE        DIVISION.
           OPEN INPUT TEST-FILE.
           DISPLAY FUNCTION EXCEPTION-STATEMENT
                   NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:463: \${COMPILE} -debug -o prog prog.cob"
echo functions.at:463 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -debug -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -debug -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:463"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:464: ./prog"
echo functions.at:464 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OPEN                           " | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:464"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_159
#AT_START_160
# 160. functions.at:469: FUNCTION EXCEPTION-STATUS
at_setup_line='functions.at:469'
at_desc="FUNCTION EXCEPTION-STATUS"
$at_quiet $as_echo_n "160: $at_desc                      "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "160. functions.at:469: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       ENVIRONMENT      DIVISION.
       INPUT-OUTPUT     SECTION.
       FILE-CONTROL.
           SELECT TEST-FILE ASSIGN "NOTEXIST"
           FILE STATUS IS TEST-STATUS.
       DATA             DIVISION.
       FILE             SECTION.
       FD  TEST-FILE.
       01  TEST-REC      PIC X(4).
       WORKING-STORAGE SECTION.
       01  TEST-STATUS  PIC XX.
       PROCEDURE        DIVISION.
           OPEN INPUT TEST-FILE.
           DISPLAY FUNCTION EXCEPTION-STATUS
                   NO ADVANCING
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:493: \${COMPILE} -o prog prog.cob"
echo functions.at:493 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:493"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:494: ./prog"
echo functions.at:494 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "EC-I-O-PERMANENT-ERROR         " | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:494"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_160
#AT_START_161
# 161. functions.at:499: FUNCTION EXP
at_setup_line='functions.at:499'
at_desc="FUNCTION EXP"
$at_quiet $as_echo_n "161: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "161. functions.at:499: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  Y   PIC   S99V9(16)   COMP.
       PROCEDURE        DIVISION.
           MOVE FUNCTION EXP ( 3 ) TO Y.
           IF Y >= 20.0855369231876636 AND
              Y <= 20.0855369231876644
                   DISPLAY "OK"
                   END-DISPLAY
           ELSE
                   DISPLAY Y
                   END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:520: \${COMPILE} -o prog prog.cob"
echo functions.at:520 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:520"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:521: ./prog"
echo functions.at:521 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:521"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_161
#AT_START_162
# 162. functions.at:527: FUNCTION FACTORIAL
at_setup_line='functions.at:527'
at_desc="FUNCTION FACTORIAL"
$at_quiet $as_echo_n "162: $at_desc                             "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "162. functions.at:527: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION FACTORIAL ( 6 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:540: \${COMPILE} -o prog prog.cob"
echo functions.at:540 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:540"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:541: ./prog"
echo functions.at:541 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "000000000000000720
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:541"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_162
#AT_START_163
# 163. functions.at:547: FUNCTION FRACTION-PART
at_setup_line='functions.at:547'
at_desc="FUNCTION FRACTION-PART"
$at_quiet $as_echo_n "163: $at_desc                         "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "163. functions.at:547: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION FRACTION-PART ( 3.12345 )
           END-DISPLAY.
           DISPLAY FUNCTION FRACTION-PART ( -3.12345 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:562: \${COMPILE} -o prog prog.cob"
echo functions.at:562 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:562"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:563: ./prog"
echo functions.at:563 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "+.123450000000000000
-.123450000000000000
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:563"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_163
#AT_START_164
# 164. functions.at:570: FUNCTION INTEGER
at_setup_line='functions.at:570'
at_desc="FUNCTION INTEGER"
$at_quiet $as_echo_n "164: $at_desc                               "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "164. functions.at:570: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   S9(4)V9(4) VALUE -1.5.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION INTEGER ( X )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:584: \${COMPILE} -o prog prog.cob"
echo functions.at:584 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:584"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:585: ./prog"
echo functions.at:585 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "-000000000000000002
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:585"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_164
#AT_START_165
# 165. functions.at:591: FUNCTION INTEGER-OF-DATE
at_setup_line='functions.at:591'
at_desc="FUNCTION INTEGER-OF-DATE"
$at_quiet $as_echo_n "165: $at_desc                       "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "165. functions.at:591: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION INTEGER-OF-DATE ( 20000925 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:604: \${COMPILE} -o prog prog.cob"
echo functions.at:604 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:604"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:605: ./prog"
echo functions.at:605 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "00146000
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:605"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_165
#AT_START_166
# 166. functions.at:611: FUNCTION INTEGER-OF-DAY
at_setup_line='functions.at:611'
at_desc="FUNCTION INTEGER-OF-DAY"
$at_quiet $as_echo_n "166: $at_desc                        "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "166. functions.at:611: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION INTEGER-OF-DAY ( 2000269 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:624: \${COMPILE} -o prog prog.cob"
echo functions.at:624 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:624"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:625: ./prog"
echo functions.at:625 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "00146000
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:625"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_166
#AT_START_167
# 167. functions.at:631: FUNCTION INTEGER-PART
at_setup_line='functions.at:631'
at_desc="FUNCTION INTEGER-PART"
$at_quiet $as_echo_n "167: $at_desc                          "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "167. functions.at:631: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   S9(4)V9(4) VALUE -1.5.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION INTEGER-PART ( X )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:645: \${COMPILE} -o prog prog.cob"
echo functions.at:645 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:645"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:646: ./prog"
echo functions.at:646 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "-000000000000000001
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:646"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_167
#AT_START_168
# 168. functions.at:652: FUNCTION LENGTH
at_setup_line='functions.at:652'
at_desc="FUNCTION LENGTH"
$at_quiet $as_echo_n "168: $at_desc                                "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "168. functions.at:652: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   S9(4)V9(4) VALUE -1.5.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION LENGTH ( X )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:666: \${COMPILE} -o prog prog.cob"
echo functions.at:666 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:666"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:667: ./prog"
echo functions.at:667 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "8
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:667"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_168
#AT_START_169
# 169. functions.at:673: FUNCTION LOCALE-DATE
at_setup_line='functions.at:673'
at_desc="FUNCTION LOCALE-DATE"
$at_quiet $as_echo_n "169: $at_desc                           "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "169. functions.at:673: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   X(32)   VALUE SPACES.
       PROCEDURE        DIVISION.
           MOVE FUNCTION LOCALE-DATE ( "19630302" ) TO X.
           IF X NOT = SPACES
                DISPLAY "OK"
                END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:690: \${COMPILE} -o prog prog.cob"
echo functions.at:690 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:690"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:691: ./prog"
echo functions.at:691 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:691"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_169
#AT_START_170
# 170. functions.at:697: FUNCTION LOCALE-TIME
at_setup_line='functions.at:697'
at_desc="FUNCTION LOCALE-TIME"
$at_quiet $as_echo_n "170: $at_desc                           "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "170. functions.at:697: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   X(32)   VALUE SPACES.
       PROCEDURE        DIVISION.
           MOVE FUNCTION LOCALE-TIME ( "233012" ) TO X.
           IF X NOT = SPACES
                DISPLAY "OK"
                END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:714: \${COMPILE} -o prog prog.cob"
echo functions.at:714 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:714"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:715: ./prog"
echo functions.at:715 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:715"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_170
#AT_START_171
# 171. functions.at:721: FUNCTION LOCALE-TIME-FROM-SECONDS
at_setup_line='functions.at:721'
at_desc="FUNCTION LOCALE-TIME-FROM-SECONDS"
$at_quiet $as_echo_n "171: $at_desc              "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "171. functions.at:721: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   X(32)   VALUE SPACES.
       PROCEDURE        DIVISION.
           MOVE FUNCTION LOCALE-TIME-FROM-SECONDS ( 33012 ) TO X.
           IF X NOT = SPACES
                DISPLAY "OK"
                END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:738: \${COMPILE} -o prog prog.cob"
echo functions.at:738 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:738"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:739: ./prog"
echo functions.at:739 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:739"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_171
#AT_START_172
# 172. functions.at:745: FUNCTION LOG
at_setup_line='functions.at:745'
at_desc="FUNCTION LOG"
$at_quiet $as_echo_n "172: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "172. functions.at:745: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   S9(4)V9(4) VALUE 1.5.
       01  Y   PIC   S9V9(17)   COMP.
       PROCEDURE        DIVISION.
           MOVE FUNCTION LOG ( X ) TO Y.
           IF Y >= 0.40546510810816435 AND
              Y <= 0.40546510810816445
                   DISPLAY "OK"
                   END-DISPLAY
           ELSE
                   DISPLAY Y
                   END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:767: \${COMPILE} -o prog prog.cob"
echo functions.at:767 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:767"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:768: ./prog"
echo functions.at:768 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:768"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_172
#AT_START_173
# 173. functions.at:774: FUNCTION LOG10
at_setup_line='functions.at:774'
at_desc="FUNCTION LOG10"
$at_quiet $as_echo_n "173: $at_desc                                 "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "173. functions.at:774: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   S9(4)V9(4) VALUE 1.5.
       01  Y   PIC   S9V9(17)   COMP.
       PROCEDURE        DIVISION.
           MOVE FUNCTION LOG10 ( X ) TO Y.
           IF Y >= 0.17609125905568120 AND
              Y <= 0.17609125905568128
                   DISPLAY "OK"
                   END-DISPLAY
           ELSE
                   DISPLAY Y
                   END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:796: \${COMPILE} -o prog prog.cob"
echo functions.at:796 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:796"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:797: ./prog"
echo functions.at:797 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:797"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_173
#AT_START_174
# 174. functions.at:803: FUNCTION LOWER-CASE
at_setup_line='functions.at:803'
at_desc="FUNCTION LOWER-CASE"
$at_quiet $as_echo_n "174: $at_desc                            "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "174. functions.at:803: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   X(10) VALUE "A#B.C%D+E$".
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION LOWER-CASE ( X )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:817: \${COMPILE} -o prog prog.cob"
echo functions.at:817 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:817"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:818: ./prog"
echo functions.at:818 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "a#b.c%d+e\$
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:818"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_174
#AT_START_175
# 175. functions.at:824: FUNCTION LOWER-CASE with reference modding
at_setup_line='functions.at:824'
at_desc="FUNCTION LOWER-CASE with reference modding"
$at_quiet $as_echo_n "175: $at_desc     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "175. functions.at:824: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   X(10) VALUE "A#B.C%D+E$".
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION LOWER-CASE ( X ) (1 : 3)
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:838: \${COMPILE} -o prog prog.cob"
echo functions.at:838 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:838"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:839: ./prog"
echo functions.at:839 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "a#b
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:839"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_175
#AT_START_176
# 176. functions.at:845: FUNCTION MAX
at_setup_line='functions.at:845'
at_desc="FUNCTION MAX"
$at_quiet $as_echo_n "176: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "176. functions.at:845: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION MAX ( 3 -14 0 8 -3 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:858: \${COMPILE} -o prog prog.cob"
echo functions.at:858 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:858"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:859: ./prog"
echo functions.at:859 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "8
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:859"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_176
#AT_START_177
# 177. functions.at:865: FUNCTION MEAN
at_setup_line='functions.at:865'
at_desc="FUNCTION MEAN"
$at_quiet $as_echo_n "177: $at_desc                                  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "177. functions.at:865: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION MEAN ( 3 -14 0 8 -3 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:878: \${COMPILE} -o prog prog.cob"
echo functions.at:878 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:878"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:879: ./prog"
echo functions.at:879 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "-1.20000000000000000
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:879"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_177
#AT_START_178
# 178. functions.at:885: FUNCTION MEDIAN
at_setup_line='functions.at:885'
at_desc="FUNCTION MEDIAN"
$at_quiet $as_echo_n "178: $at_desc                                "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "178. functions.at:885: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION MEDIAN ( 3 -14 0 8 -3 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:898: \${COMPILE} -o prog prog.cob"
echo functions.at:898 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:898"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:899: ./prog"
echo functions.at:899 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "0
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:899"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_178
#AT_START_179
# 179. functions.at:905: FUNCTION MIDRANGE
at_setup_line='functions.at:905'
at_desc="FUNCTION MIDRANGE"
$at_quiet $as_echo_n "179: $at_desc                              "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "179. functions.at:905: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION MIDRANGE ( 3 -14 0 8 -3 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:918: \${COMPILE} -o prog prog.cob"
echo functions.at:918 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:918"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:919: ./prog"
echo functions.at:919 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "-3.000000000000000000
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:919"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_179
#AT_START_180
# 180. functions.at:925: FUNCTION MIN
at_setup_line='functions.at:925'
at_desc="FUNCTION MIN"
$at_quiet $as_echo_n "180: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "180. functions.at:925: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION MIN ( 3 -14 0 8 -3 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:938: \${COMPILE} -o prog prog.cob"
echo functions.at:938 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:938"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:939: ./prog"
echo functions.at:939 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "-14
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:939"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_180
#AT_START_181
# 181. functions.at:945: FUNCTION MOD
at_setup_line='functions.at:945'
at_desc="FUNCTION MOD"
$at_quiet $as_echo_n "181: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "181. functions.at:945: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION MOD ( -11 5 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:958: \${COMPILE} -o prog prog.cob"
echo functions.at:958 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:958"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:959: ./prog"
echo functions.at:959 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "+000000000000000004
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:959"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_181
#AT_START_182
# 182. functions.at:965: FUNCTION NUMVAL
at_setup_line='functions.at:965'
at_desc="FUNCTION NUMVAL"
$at_quiet $as_echo_n "182: $at_desc                                "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "182. functions.at:965: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   X(12) VALUE " -9876.1234 ".
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION NUMVAL ( X )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:979: \${COMPILE} -o prog prog.cob"
echo functions.at:979 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:979"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:980: ./prog"
echo functions.at:980 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "-00000000009876.1234
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:980"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_182
#AT_START_183
# 183. functions.at:986: FUNCTION NUMVAL-C
at_setup_line='functions.at:986'
at_desc="FUNCTION NUMVAL-C"
$at_quiet $as_echo_n "183: $at_desc                              "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "183. functions.at:986: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   X(14) VALUE " % -9876.1234 ".
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION NUMVAL-C ( X , "%" )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1000: \${COMPILE} -o prog prog.cob"
echo functions.at:1000 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1000"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1001: ./prog"
echo functions.at:1001 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "-00000000009876.1234
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1001"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_183
#AT_START_184
# 184. functions.at:1007: FUNCTION ORD
at_setup_line='functions.at:1007'
at_desc="FUNCTION ORD"
$at_quiet $as_echo_n "184: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "184. functions.at:1007: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION ORD ( "k" )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1020: \${COMPILE} -o prog prog.cob"
echo functions.at:1020 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1020"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1021: ./prog"
echo functions.at:1021 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "00000108
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1021"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_184
#AT_START_185
# 185. functions.at:1027: FUNCTION ORD-MAX
at_setup_line='functions.at:1027'
at_desc="FUNCTION ORD-MAX"
$at_quiet $as_echo_n "185: $at_desc                               "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "185. functions.at:1027: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION ORD-MAX ( 3 -14 0 8 -3 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1040: \${COMPILE} -o prog prog.cob"
echo functions.at:1040 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1040"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1041: ./prog"
echo functions.at:1041 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "00000004
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1041"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_185
#AT_START_186
# 186. functions.at:1047: FUNCTION ORD-MIN
at_setup_line='functions.at:1047'
at_desc="FUNCTION ORD-MIN"
$at_quiet $as_echo_n "186: $at_desc                               "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "186. functions.at:1047: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION ORD-MIN ( 3 -14 0 8 -3 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1060: \${COMPILE} -o prog prog.cob"
echo functions.at:1060 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1060"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1061: ./prog"
echo functions.at:1061 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "00000002
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1061"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_186
#AT_START_187
# 187. functions.at:1067: FUNCTION PI
at_setup_line='functions.at:1067'
at_desc="FUNCTION PI"
$at_quiet $as_echo_n "187: $at_desc                                    "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "187. functions.at:1067: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION PI
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1080: \${COMPILE} -o prog prog.cob"
echo functions.at:1080 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1080"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1081: ./prog"
echo functions.at:1081 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "3.1415926535897932384626433832795029
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1081"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_187
#AT_START_188
# 188. functions.at:1087: FUNCTION PRESENT-VALUE
at_setup_line='functions.at:1087'
at_desc="FUNCTION PRESENT-VALUE"
$at_quiet $as_echo_n "188: $at_desc                         "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "188. functions.at:1087: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION PRESENT-VALUE ( 3 2 1 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1100: \${COMPILE} -o prog prog.cob"
echo functions.at:1100 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1100"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1101: ./prog"
echo functions.at:1101 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "0.562500000000000000
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1101"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_188
#AT_START_189
# 189. functions.at:1107: FUNCTION RANGE
at_setup_line='functions.at:1107'
at_desc="FUNCTION RANGE"
$at_quiet $as_echo_n "189: $at_desc                                 "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "189. functions.at:1107: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION RANGE ( 3 -14 0 8 -3 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1120: \${COMPILE} -o prog prog.cob"
echo functions.at:1120 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1120"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1121: ./prog"
echo functions.at:1121 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "+000000000000000022
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1121"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_189
#AT_START_190
# 190. functions.at:1127: FUNCTION REM
at_setup_line='functions.at:1127'
at_desc="FUNCTION REM"
$at_quiet $as_echo_n "190: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "190. functions.at:1127: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION REM ( -11 5 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1140: \${COMPILE} -o prog prog.cob"
echo functions.at:1140 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1140"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1141: ./prog"
echo functions.at:1141 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "-000000000000000001
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1141"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_190
#AT_START_191
# 191. functions.at:1147: FUNCTION REVERSE
at_setup_line='functions.at:1147'
at_desc="FUNCTION REVERSE"
$at_quiet $as_echo_n "191: $at_desc                               "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "191. functions.at:1147: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   X(10) VALUE "A#B.C%D+E$".
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION REVERSE ( X )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1161: \${COMPILE} -o prog prog.cob"
echo functions.at:1161 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1161"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1162: ./prog"
echo functions.at:1162 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "\$E+D%C.B#A
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1162"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_191
#AT_START_192
# 192. functions.at:1168: FUNCTION REVERSE with reference modding
at_setup_line='functions.at:1168'
at_desc="FUNCTION REVERSE with reference modding"
$at_quiet $as_echo_n "192: $at_desc        "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "192. functions.at:1168: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   X(10) VALUE "A#B.C%D+E$".
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION REVERSE ( X ) (1 : 4)
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1182: \${COMPILE} -o prog prog.cob"
echo functions.at:1182 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1182"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1183: ./prog"
echo functions.at:1183 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "\$E+D
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1183"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_192
#AT_START_193
# 193. functions.at:1189: FUNCTION SECONDS-FROM-FORMATTED-TIME
at_setup_line='functions.at:1189'
at_desc="FUNCTION SECONDS-FROM-FORMATTED-TIME"
$at_quiet $as_echo_n "193: $at_desc           "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "193. functions.at:1189: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC      X(6)   VALUE "hhmmss".
       01  Y   PIC      9(8)   COMP-5.
       01  Z   PIC      X(6)   VALUE "010203".
       PROCEDURE        DIVISION.
           MOVE FUNCTION SECONDS-FROM-FORMATTED-TIME (X, Z) TO Y.
           IF Y = 3723
                   DISPLAY "OK"
                   END-DISPLAY
           ELSE
                   DISPLAY Y
                   END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1211: \${COMPILE} -o prog prog.cob"
echo functions.at:1211 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1211"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1212: ./prog"
echo functions.at:1212 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1212"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_193
#AT_START_194
# 194. functions.at:1218: FUNCTION SECONDS-PAST-MIDNIGHT
at_setup_line='functions.at:1218'
at_desc="FUNCTION SECONDS-PAST-MIDNIGHT"
$at_quiet $as_echo_n "194: $at_desc                 "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "194. functions.at:1218: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  Y   PIC      9(8)   COMP-5.
       PROCEDURE        DIVISION.
           MOVE FUNCTION SECONDS-PAST-MIDNIGHT TO Y.
           IF Y < 86402
                   DISPLAY "OK"
                   END-DISPLAY
           ELSE
                   DISPLAY Y
                   END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1238: \${COMPILE} -o prog prog.cob"
echo functions.at:1238 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1238"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1239: ./prog"
echo functions.at:1239 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1239"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_194
#AT_START_195
# 195. functions.at:1245: FUNCTION SIGN
at_setup_line='functions.at:1245'
at_desc="FUNCTION SIGN"
$at_quiet $as_echo_n "195: $at_desc                                  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "195. functions.at:1245: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION SIGN ( 3.12345 )
           END-DISPLAY.
           DISPLAY FUNCTION SIGN ( -0.0 )
           END-DISPLAY.
           DISPLAY FUNCTION SIGN ( 0.0 )
           END-DISPLAY.
           DISPLAY FUNCTION SIGN ( -3.12345 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1264: \${COMPILE} -o prog prog.cob"
echo functions.at:1264 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1264"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1265: ./prog"
echo functions.at:1265 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "+00000001
+00000000
+00000000
-00000001
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1265"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_195
#AT_START_196
# 196. functions.at:1274: FUNCTION SIN
at_setup_line='functions.at:1274'
at_desc="FUNCTION SIN"
$at_quiet $as_echo_n "196: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "196. functions.at:1274: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   S9(4)V9(4) VALUE 1.5.
       01  Y   PIC   S9V9(17)   COMP.
       PROCEDURE        DIVISION.
           MOVE FUNCTION SIN ( X ) TO Y.
           IF Y >= 0.99749498660405440 AND
              Y <= 0.99749498660405450
                   DISPLAY "OK"
                   END-DISPLAY
           ELSE
                   DISPLAY Y
                   END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1296: \${COMPILE} -o prog prog.cob"
echo functions.at:1296 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1296"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1297: ./prog"
echo functions.at:1297 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1297"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_196
#AT_START_197
# 197. functions.at:1303: FUNCTION SQRT
at_setup_line='functions.at:1303'
at_desc="FUNCTION SQRT"
$at_quiet $as_echo_n "197: $at_desc                                  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "197. functions.at:1303: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   S9(4)V9(4) VALUE 1.5.
       01  Y   PIC   S9V9(17)   COMP.
       PROCEDURE        DIVISION.
           MOVE FUNCTION SQRT ( X ) TO Y.
           IF Y >= 1.22474487139158890 AND
              Y <= 1.22474487139158899
                   DISPLAY "OK"
                   END-DISPLAY
           ELSE
                   DISPLAY Y
                   END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1325: \${COMPILE} -o prog prog.cob"
echo functions.at:1325 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1325"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1326: ./prog"
echo functions.at:1326 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1326"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_197
#AT_START_198
# 198. functions.at:1332: FUNCTION STANDARD-DEVIATION
at_setup_line='functions.at:1332'
at_desc="FUNCTION STANDARD-DEVIATION"
$at_quiet $as_echo_n "198: $at_desc                    "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "198. functions.at:1332: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  Y   PIC   S9V9(17)   COMP.
       PROCEDURE        DIVISION.
           MOVE FUNCTION STANDARD-DEVIATION ( 3 -14 0 8 -3 ) TO Y.
           IF Y >= 7.35934779718963925 AND
              Y <= 7.35934779718964025
                   DISPLAY "OK"
                   END-DISPLAY
           ELSE
                   DISPLAY Y
                   END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1353: \${COMPILE} -o prog prog.cob"
echo functions.at:1353 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1353"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1354: ./prog"
echo functions.at:1354 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1354"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_198
#AT_START_199
# 199. functions.at:1360: FUNCTION STORED-CHAR-LENGTH
at_setup_line='functions.at:1360'
at_desc="FUNCTION STORED-CHAR-LENGTH"
$at_quiet $as_echo_n "199: $at_desc                    "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "199. functions.at:1360: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  Y   PIC   X(24).
       PROCEDURE        DIVISION.
           MOVE "123456789012" TO Y.
           DISPLAY FUNCTION STORED-CHAR-LENGTH ( Y )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1375: \${COMPILE} -o prog prog.cob"
echo functions.at:1375 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1375"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1376: ./prog"
echo functions.at:1376 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "00000012
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1376"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_199
#AT_START_200
# 200. functions.at:1382: FUNCTION SUBSTITUTE
at_setup_line='functions.at:1382'
at_desc="FUNCTION SUBSTITUTE"
$at_quiet $as_echo_n "200: $at_desc                            "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "200. functions.at:1382: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  Y   PIC   X(20).
       PROCEDURE        DIVISION.
           MOVE "abc111444555defxxabc" TO Y.
           DISPLAY FUNCTION SUBSTITUTE ( Y "abc" "zz" "55" "666" )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1397: \${COMPILE} -o prog prog.cob"
echo functions.at:1397 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1397"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1398: ./prog"
echo functions.at:1398 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "zz1114446665defxxzz
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1398"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_200
#AT_START_201
# 201. functions.at:1404: FUNCTION SUBSTITUTE with reference modding
at_setup_line='functions.at:1404'
at_desc="FUNCTION SUBSTITUTE with reference modding"
$at_quiet $as_echo_n "201: $at_desc     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "201. functions.at:1404: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  Y   PIC   X(20).
       PROCEDURE        DIVISION.
           MOVE "abc111444555defxxabc" TO Y.
           DISPLAY FUNCTION SUBSTITUTE
                   ( Y "abc" "zz" "55" "666" ) (2 : 9)
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1420: \${COMPILE} -o prog prog.cob"
echo functions.at:1420 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1420"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1421: ./prog"
echo functions.at:1421 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "z11144466
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1421"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_201
#AT_START_202
# 202. functions.at:1427: FUNCTION SUBSTITUTE-CASE
at_setup_line='functions.at:1427'
at_desc="FUNCTION SUBSTITUTE-CASE"
$at_quiet $as_echo_n "202: $at_desc                       "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "202. functions.at:1427: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  Y   PIC   X(20).
       PROCEDURE        DIVISION.
           MOVE "ABC111444555defxxabc" TO Y.
           DISPLAY FUNCTION SUBSTITUTE-CASE (Y "abc" "zz" "55" "666")
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1442: \${COMPILE} -o prog prog.cob"
echo functions.at:1442 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1442"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1443: ./prog"
echo functions.at:1443 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "zz1114446665defxxzz
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1443"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_202
#AT_START_203
# 203. functions.at:1449: FUNCTION SUBSTITUTE-CASE with reference mod
at_setup_line='functions.at:1449'
at_desc="FUNCTION SUBSTITUTE-CASE with reference mod"
$at_quiet $as_echo_n "203: $at_desc    "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "203. functions.at:1449: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  Y   PIC   X(20).
       PROCEDURE        DIVISION.
           MOVE "abc111444555defxxabc" TO Y.
           DISPLAY FUNCTION SUBSTITUTE-CASE
                   ( Y "ABC" "zz" "55" "666" ) (2 : 9)
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1465: \${COMPILE} -o prog prog.cob"
echo functions.at:1465 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1465"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1466: ./prog"
echo functions.at:1466 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "z11144466
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1466"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_203
#AT_START_204
# 204. functions.at:1472: FUNCTION TAN
at_setup_line='functions.at:1472'
at_desc="FUNCTION TAN"
$at_quiet $as_echo_n "204: $at_desc                                   "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "204. functions.at:1472: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   S9(4)V9(4) VALUE 1.5.
       01  Y   PIC   S99V9(16)   COMP.
       PROCEDURE        DIVISION.
           MOVE FUNCTION TAN ( X ) TO Y.
           IF Y >= 14.1014199471717185 AND
              Y <= 14.1014199471717205
                   DISPLAY "OK"
                   END-DISPLAY
           ELSE
                   DISPLAY Y
                   END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1494: \${COMPILE} -o prog prog.cob"
echo functions.at:1494 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1494"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1495: ./prog"
echo functions.at:1495 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1495"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_204
#AT_START_205
# 205. functions.at:1501: FUNCTION TRIM
at_setup_line='functions.at:1501'
at_desc="FUNCTION TRIM"
$at_quiet $as_echo_n "205: $at_desc                                  "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "205. functions.at:1501: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   X(12) VALUE " a#b.c%d+e$ ".
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION TRIM ( X )
           END-DISPLAY.
           DISPLAY FUNCTION TRIM ( X TRAILING )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1517: \${COMPILE} -o prog prog.cob"
echo functions.at:1517 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1517"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1518: ./prog"
echo functions.at:1518 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "a#b.c%d+e\$
 a#b.c%d+e\$
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1518"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_205
#AT_START_206
# 206. functions.at:1525: FUNCTION TRIM with reference modding
at_setup_line='functions.at:1525'
at_desc="FUNCTION TRIM with reference modding"
$at_quiet $as_echo_n "206: $at_desc           "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "206. functions.at:1525: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   X(12) VALUE " a#b.c%d+e$ ".
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION TRIM ( X ) (2 : 3)
           END-DISPLAY.
           DISPLAY FUNCTION TRIM ( X TRAILING ) (2 : 3)
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1541: \${COMPILE} -o prog prog.cob"
echo functions.at:1541 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1541"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1542: ./prog"
echo functions.at:1542 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "#b.
a#b
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1542"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_206
#AT_START_207
# 207. functions.at:1549: FUNCTION UPPER-CASE
at_setup_line='functions.at:1549'
at_desc="FUNCTION UPPER-CASE"
$at_quiet $as_echo_n "207: $at_desc                            "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "207. functions.at:1549: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   X(10) VALUE "a#b.c%d+e$".
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION UPPER-CASE ( X )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1563: \${COMPILE} -o prog prog.cob"
echo functions.at:1563 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1563"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1564: ./prog"
echo functions.at:1564 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "A#B.C%D+E\$
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1564"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_207
#AT_START_208
# 208. functions.at:1570: FUNCTION UPPER-CASE with reference modding
at_setup_line='functions.at:1570'
at_desc="FUNCTION UPPER-CASE with reference modding"
$at_quiet $as_echo_n "208: $at_desc     "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "208. functions.at:1570: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  X   PIC   X(10) VALUE "a#b.c%d+e$".
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION UPPER-CASE ( X ) (1 : 3)
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1584: \${COMPILE} -o prog prog.cob"
echo functions.at:1584 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1584"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1585: ./prog"
echo functions.at:1585 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "A#B
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1585"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_208
#AT_START_209
# 209. functions.at:1591: FUNCTION VARIANCE
at_setup_line='functions.at:1591'
at_desc="FUNCTION VARIANCE"
$at_quiet $as_echo_n "209: $at_desc                              "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "209. functions.at:1591: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       PROCEDURE        DIVISION.
           DISPLAY FUNCTION VARIANCE ( 3 -14 0 8 -3 )
           END-DISPLAY.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1604: \${COMPILE} -o prog prog.cob"
echo functions.at:1604 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1604"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1605: ./prog"
echo functions.at:1605 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "+54.1600000000000000
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1605"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_209
#AT_START_210
# 210. functions.at:1611: FUNCTION WHEN-COMPILED
at_setup_line='functions.at:1611'
at_desc="FUNCTION WHEN-COMPILED"
$at_quiet $as_echo_n "210: $at_desc                         "
at_xfail=no
echo "#                             -*- compilation -*-" >> "$at_group_log"
(
  $as_echo "210. functions.at:1611: testing ..."
  $at_traceon


cat >prog.cob <<'_ATEOF'

       IDENTIFICATION   DIVISION.
       PROGRAM-ID.      prog.
       DATA             DIVISION.
       WORKING-STORAGE  SECTION.
       01  XYZ.
           03 X         PIC X.
           03 FILLER    PIC X(20).
       PROCEDURE        DIVISION.
           MOVE FUNCTION WHEN-COMPILED TO XYZ.
           IF X = "2"
              DISPLAY "OK"
              END-DISPLAY
           ELSE
              DISPLAY "NOT OK"
              END-DISPLAY
           END-IF.
           STOP RUN.
_ATEOF


{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1633: \${COMPILE} -o prog prog.cob"
echo functions.at:1633 >"$at_check_line_file"

if { echo 'Not enabling shell tracing (command contains a ${...} parameter expansion)'
   false; }; then
  ( $at_traceon; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ${COMPILE} -o prog prog.cob ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
at_func_diff_devnull "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1633"

$at_failed && at_func_log_failure
$at_traceon; }

{ $at_traceoff
$as_echo "$at_srcdir/functions.at:1634: ./prog"
echo functions.at:1634 >"$at_check_line_file"

if test -n "$at_traceon"; then
  ( $at_traceon; ./prog ) >"$at_stdout" 2>"$at_stder1"
  at_func_filter_trace $?
else
  ( :; ./prog ) >"$at_stdout" 2>"$at_stderr"
fi
at_status=$?
at_failed=false
at_func_diff_devnull "$at_stderr" || at_failed=:
echo >>"$at_stdout"; $as_echo "OK
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_func_check_status 0 $at_status "$at_srcdir/functions.at:1634"

$at_failed && at_func_log_failure
$at_traceon; }


  $at_traceoff
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 | eval $at_tee_pipe
at_status=`cat "$at_status_file"`
#AT_STOP_210
