1 #! /bin/sh 2 # Generated from ../../../tests/local.at by GNU Autoconf 2.69. 3 # 4 # Copyright (C) 2009-2012 Free Software Foundation, Inc. 5 # 6 # This test suite is free software; the Free Software Foundation gives 7 # unlimited permission to copy, distribute and modify it. 8 ## -------------------- ## 9 ## M4sh Initialization. ## 10 ## -------------------- ## 11 12 # Be more Bourne compatible 13 DUALCASE=1; export DUALCASE # for MKS sh 14 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : 15 emulate sh 16 NULLCMD=: 17 # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which 18 # is contrary to our usage. Disable this feature. 19 alias -g '${1+"$@"}'='"$@"' 20 setopt NO_GLOB_SUBST 21 else 22 case `(set -o) 2>/dev/null` in #( 23 *posix*) : 24 set -o posix ;; #( 25 *) : 26 ;; 27 esac 28 fi 29 30 31 as_nl=' 32 ' 33 export as_nl 34 # Printing a long string crashes Solaris 7 /usr/bin/printf. 35 as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' 36 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo 37 as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo 38 # Prefer a ksh shell builtin over an external printf program on Solaris, 39 # but without wasting forks for bash or zsh. 40 if test -z "$BASH_VERSION$ZSH_VERSION" \ 41 && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then 42 as_echo='print -r --' 43 as_echo_n='print -rn --' 44 elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then 45 as_echo='printf %s\n' 46 as_echo_n='printf %s' 47 else 48 if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then 49 as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' 50 as_echo_n='/usr/ucb/echo -n' 51 else 52 as_echo_body='eval expr "X$1" : "X\\(.*\\)"' 53 as_echo_n_body='eval 54 arg=$1; 55 case $arg in #( 56 *"$as_nl"*) 57 expr "X$arg" : "X\\(.*\\)$as_nl"; 58 arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; 59 esac; 60 expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" 61 ' 62 export as_echo_n_body 63 as_echo_n='sh -c $as_echo_n_body as_echo' 64 fi 65 export as_echo_body 66 as_echo='sh -c $as_echo_body as_echo' 67 fi 68 69 # The user is always right. 70 if test "${PATH_SEPARATOR+set}" != set; then 71 PATH_SEPARATOR=: 72 (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { 73 (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || 74 PATH_SEPARATOR=';' 75 } 76 fi 77 78 79 # IFS 80 # We need space, tab and new line, in precisely that order. Quoting is 81 # there to prevent editors from complaining about space-tab. 82 # (If _AS_PATH_WALK were called with IFS unset, it would disable word 83 # splitting by setting IFS to empty value.) 84 IFS=" "" $as_nl" 85 86 # Find who we are. Look in the path if we contain no directory separator. 87 as_myself= 88 case $0 in #(( 89 *[\\/]* ) as_myself=$0 ;; 90 *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR 91 for as_dir in $PATH 92 do 93 IFS=$as_save_IFS 94 test -z "$as_dir" && as_dir=. 95 test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break 96 done 97 IFS=$as_save_IFS 98 99 ;; 100 esac 101 # We did not find ourselves, most probably we were run as `sh COMMAND' 102 # in which case we are not to be found in the path. 103 if test "x$as_myself" = x; then 104 as_myself=$0 105 fi 106 if test ! -f "$as_myself"; then 107 $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 108 exit 1 109 fi 110 111 # Unset variables that we do not need and which cause bugs (e.g. in 112 # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" 113 # suppresses any "Segmentation fault" message there. '((' could 114 # trigger a bug in pdksh 5.2.14. 115 for as_var in BASH_ENV ENV MAIL MAILPATH 116 do eval test x\${$as_var+set} = xset \ 117 && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : 118 done 119 PS1='$ ' 120 PS2='> ' 121 PS4='+ ' 122 123 # NLS nuisances. 124 LC_ALL=C 125 export LC_ALL 126 LANGUAGE=C 127 export LANGUAGE 128 129 # CDPATH. 130 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH 131 132 if test "x$CONFIG_SHELL" = x; then 133 as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : 134 emulate sh 135 NULLCMD=: 136 # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which 137 # is contrary to our usage. Disable this feature. 138 alias -g '\${1+\"\$@\"}'='\"\$@\"' 139 setopt NO_GLOB_SUBST 140 else 141 case \`(set -o) 2>/dev/null\` in #( 142 *posix*) : 143 set -o posix ;; #( 144 *) : 145 ;; 146 esac 147 fi 148 " 149 as_required="as_fn_return () { (exit \$1); } 150 as_fn_success () { as_fn_return 0; } 151 as_fn_failure () { as_fn_return 1; } 152 as_fn_ret_success () { return 0; } 153 as_fn_ret_failure () { return 1; } 154 155 exitcode=0 156 as_fn_success || { exitcode=1; echo as_fn_success failed.; } 157 as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } 158 as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } 159 as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } 160 if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : 161 162 else 163 exitcode=1; echo positional parameters were not saved. 164 fi 165 test x\$exitcode = x0 || exit 1 166 test -x / || exit 1" 167 as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO 168 as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO 169 eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && 170 test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 171 test \$(( 1 + 1 )) = 2 || exit 1" 172 if (eval "$as_required") 2>/dev/null; then : 173 as_have_required=yes 174 else 175 as_have_required=no 176 fi 177 if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : 178 179 else 180 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR 181 as_found=false 182 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH 183 do 184 IFS=$as_save_IFS 185 test -z "$as_dir" && as_dir=. 186 as_found=: 187 case $as_dir in #( 188 /*) 189 for as_base in sh bash ksh sh5; do 190 # Try only shells that exist, to save several forks. 191 as_shell=$as_dir/$as_base 192 if { test -f "$as_shell" || test -f "$as_shell.exe"; } && 193 { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : 194 CONFIG_SHELL=$as_shell as_have_required=yes 195 if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : 196 break 2 197 fi 198 fi 199 done;; 200 esac 201 as_found=false 202 done 203 $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && 204 { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : 205 CONFIG_SHELL=$SHELL as_have_required=yes 206 fi; } 207 IFS=$as_save_IFS 208 209 210 if test "x$CONFIG_SHELL" != x; then : 211 export CONFIG_SHELL 212 # We cannot yet assume a decent shell, so we have to provide a 213 # neutralization value for shells without unset; and this also 214 # works around shells that cannot unset nonexistent variables. 215 # Preserve -v and -x to the replacement shell. 216 BASH_ENV=/dev/null 217 ENV=/dev/null 218 (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV 219 case $- in # (((( 220 *v*x* | *x*v* ) as_opts=-vx ;; 221 *v* ) as_opts=-v ;; 222 *x* ) as_opts=-x ;; 223 * ) as_opts= ;; 224 esac 225 exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} 226 # Admittedly, this is quite paranoid, since all the known shells bail 227 # out after a failed `exec'. 228 $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 229 exit 255 230 fi 231 232 if test x$as_have_required = xno; then : 233 $as_echo "$0: This script requires a shell more modern than all" 234 $as_echo "$0: the shells that I found on your system." 235 if test x${ZSH_VERSION+set} = xset ; then 236 $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" 237 $as_echo "$0: be upgraded to zsh 4.3.4 or later." 238 else 239 $as_echo "$0: Please tell bug-autoconf (at] gnu.org about your system, 240 $0: including any error possibly output before this 241 $0: message. Then install a modern shell, or manually run 242 $0: the script under such a shell if you do have one." 243 fi 244 exit 1 245 fi 246 fi 247 fi 248 SHELL=${CONFIG_SHELL-/bin/sh} 249 export SHELL 250 # Unset more variables known to interfere with behavior of common tools. 251 CLICOLOR_FORCE= GREP_OPTIONS= 252 unset CLICOLOR_FORCE GREP_OPTIONS 253 254 ## --------------------- ## 255 ## M4sh Shell Functions. ## 256 ## --------------------- ## 257 # as_fn_unset VAR 258 # --------------- 259 # Portably unset VAR. 260 as_fn_unset () 261 { 262 { eval $1=; unset $1;} 263 } 264 as_unset=as_fn_unset 265 266 # as_fn_set_status STATUS 267 # ----------------------- 268 # Set $? to STATUS, without forking. 269 as_fn_set_status () 270 { 271 return $1 272 } # as_fn_set_status 273 274 # as_fn_exit STATUS 275 # ----------------- 276 # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. 277 as_fn_exit () 278 { 279 set +e 280 as_fn_set_status $1 281 exit $1 282 } # as_fn_exit 283 284 # as_fn_mkdir_p 285 # ------------- 286 # Create "$as_dir" as a directory, including parents if necessary. 287 as_fn_mkdir_p () 288 { 289 290 case $as_dir in #( 291 -*) as_dir=./$as_dir;; 292 esac 293 test -d "$as_dir" || eval $as_mkdir_p || { 294 as_dirs= 295 while :; do 296 case $as_dir in #( 297 *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( 298 *) as_qdir=$as_dir;; 299 esac 300 as_dirs="'$as_qdir' $as_dirs" 301 as_dir=`$as_dirname -- "$as_dir" || 302 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ 303 X"$as_dir" : 'X\(//\)[^/]' \| \ 304 X"$as_dir" : 'X\(//\)$' \| \ 305 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || 306 $as_echo X"$as_dir" | 307 sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ 308 s//\1/ 309 q 310 } 311 /^X\(\/\/\)[^/].*/{ 312 s//\1/ 313 q 314 } 315 /^X\(\/\/\)$/{ 316 s//\1/ 317 q 318 } 319 /^X\(\/\).*/{ 320 s//\1/ 321 q 322 } 323 s/.*/./; q'` 324 test -d "$as_dir" && break 325 done 326 test -z "$as_dirs" || eval "mkdir $as_dirs" 327 } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" 328 329 330 } # as_fn_mkdir_p 331 332 # as_fn_executable_p FILE 333 # ----------------------- 334 # Test if FILE is an executable regular file. 335 as_fn_executable_p () 336 { 337 test -f "$1" && test -x "$1" 338 } # as_fn_executable_p 339 # as_fn_append VAR VALUE 340 # ---------------------- 341 # Append the text in VALUE to the end of the definition contained in VAR. Take 342 # advantage of any shell optimizations that allow amortized linear growth over 343 # repeated appends, instead of the typical quadratic growth present in naive 344 # implementations. 345 if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : 346 eval 'as_fn_append () 347 { 348 eval $1+=\$2 349 }' 350 else 351 as_fn_append () 352 { 353 eval $1=\$$1\$2 354 } 355 fi # as_fn_append 356 357 # as_fn_arith ARG... 358 # ------------------ 359 # Perform arithmetic evaluation on the ARGs, and store the result in the 360 # global $as_val. Take advantage of shells that can avoid forks. The arguments 361 # must be portable across $(()) and expr. 362 if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : 363 eval 'as_fn_arith () 364 { 365 as_val=$(( $* )) 366 }' 367 else 368 as_fn_arith () 369 { 370 as_val=`expr "$@" || test $? -eq 1` 371 } 372 fi # as_fn_arith 373 374 375 # as_fn_error STATUS ERROR [LINENO LOG_FD] 376 # ---------------------------------------- 377 # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are 378 # provided, also output the error to LOG_FD, referencing LINENO. Then exit the 379 # script with STATUS, using 1 if that was 0. 380 as_fn_error () 381 { 382 as_status=$1; test $as_status -eq 0 && as_status=1 383 if test "$4"; then 384 as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack 385 $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 386 fi 387 $as_echo "$as_me: error: $2" >&2 388 as_fn_exit $as_status 389 } # as_fn_error 390 391 if expr a : '\(a\)' >/dev/null 2>&1 && 392 test "X`expr 00001 : '.*\(...\)'`" = X001; then 393 as_expr=expr 394 else 395 as_expr=false 396 fi 397 398 if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then 399 as_basename=basename 400 else 401 as_basename=false 402 fi 403 404 as_me=`$as_basename -- "$0" || 405 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ 406 X"$0" : 'X\(//\)$' \| \ 407 X"$0" : 'X\(/\)' \| . 2>/dev/null || 408 $as_echo X/"$0" | 409 sed '/^.*\/\([^/][^/]*\)\/*$/{ 410 s//\1/ 411 q 412 } 413 /^X\/\(\/\/\)$/{ 414 s//\1/ 415 q 416 } 417 /^X\/\(\/\).*/{ 418 s//\1/ 419 q 420 } 421 s/.*/./; q'` 422 423 if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then 424 as_dirname=dirname 425 else 426 as_dirname=false 427 fi 428 429 # Avoid depending upon Character Ranges. 430 as_cr_letters='abcdefghijklmnopqrstuvwxyz' 431 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' 432 as_cr_Letters=$as_cr_letters$as_cr_LETTERS 433 as_cr_digits='0123456789' 434 as_cr_alnum=$as_cr_Letters$as_cr_digits 435 436 437 as_lineno_1=$LINENO as_lineno_1a=$LINENO 438 as_lineno_2=$LINENO as_lineno_2a=$LINENO 439 eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && 440 test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { 441 # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) 442 sed -n ' 443 p 444 /[$]LINENO/= 445 ' <$as_myself | 446 sed ' 447 s/[$]LINENO.*/&-/ 448 t lineno 449 b 450 :lineno 451 N 452 :loop 453 s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ 454 t loop 455 s/-\n.*// 456 ' >$as_me.lineno && 457 chmod +x "$as_me.lineno" || 458 { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } 459 460 # If we had to re-execute with $CONFIG_SHELL, we're ensured to have 461 # already done that, so ensure we don't try to do so again and fall 462 # in an infinite loop. This has already happened in practice. 463 _as_can_reexec=no; export _as_can_reexec 464 # Don't try to exec as it changes $[0], causing all sort of problems 465 # (the dirname of $[0] is not the place where we might find the 466 # original and so on. Autoconf is especially sensitive to this). 467 . "./$as_me.lineno" 468 # Exit status is that of the last command. 469 exit 470 } 471 472 ECHO_C= ECHO_N= ECHO_T= 473 case `echo -n x` in #((((( 474 -n*) 475 case `echo 'xy\c'` in 476 *c*) ECHO_T=' ';; # ECHO_T is single tab character. 477 xy) ECHO_C='\c';; 478 *) echo `echo ksh88 bug on AIX 6.1` > /dev/null 479 ECHO_T=' ';; 480 esac;; 481 *) 482 ECHO_N='-n';; 483 esac 484 485 rm -f conf$$ conf$$.exe conf$$.file 486 if test -d conf$$.dir; then 487 rm -f conf$$.dir/conf$$.file 488 else 489 rm -f conf$$.dir 490 mkdir conf$$.dir 2>/dev/null 491 fi 492 if (echo >conf$$.file) 2>/dev/null; then 493 if ln -s conf$$.file conf$$ 2>/dev/null; then 494 as_ln_s='ln -s' 495 # ... but there are two gotchas: 496 # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. 497 # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. 498 # In both cases, we have to default to `cp -pR'. 499 ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || 500 as_ln_s='cp -pR' 501 elif ln conf$$.file conf$$ 2>/dev/null; then 502 as_ln_s=ln 503 else 504 as_ln_s='cp -pR' 505 fi 506 else 507 as_ln_s='cp -pR' 508 fi 509 rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file 510 rmdir conf$$.dir 2>/dev/null 511 512 if mkdir -p . 2>/dev/null; then 513 as_mkdir_p='mkdir -p "$as_dir"' 514 else 515 test -d ./-p && rmdir ./-p 516 as_mkdir_p=false 517 fi 518 519 as_test_x='test -x' 520 as_executable_p=as_fn_executable_p 521 522 # Sed expression to map a string onto a valid CPP name. 523 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" 524 525 # Sed expression to map a string onto a valid variable name. 526 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" 527 528 529 530 531 532 SHELL=${CONFIG_SHELL-/bin/sh} 533 534 # How were we run? 535 at_cli_args="$@" 536 537 538 # Not all shells have the 'times' builtin; the subshell is needed to make 539 # sure we discard the 'times: not found' message from the shell. 540 at_times_p=false 541 (times) >/dev/null 2>&1 && at_times_p=: 542 543 # CLI Arguments to pass to the debugging scripts. 544 at_debug_args= 545 # -e sets to true 546 at_errexit_p=false 547 # Shall we be verbose? ':' means no, empty means yes. 548 at_verbose=: 549 at_quiet= 550 # Running several jobs in parallel, 0 means as many as test groups. 551 at_jobs=1 552 at_traceon=: 553 at_trace_echo=: 554 at_check_filter_trace=: 555 556 # Shall we keep the debug scripts? Must be `:' when the suite is 557 # run by a debug script, so that the script doesn't remove itself. 558 at_debug_p=false 559 # Display help message? 560 at_help_p=false 561 # Display the version message? 562 at_version_p=false 563 # List test groups? 564 at_list_p=false 565 # --clean 566 at_clean=false 567 # Test groups to run 568 at_groups= 569 # Whether to rerun failed tests. 570 at_recheck= 571 # Whether a write failure occurred 572 at_write_fail=0 573 574 # The directory we run the suite in. Default to . if no -C option. 575 at_dir=`pwd` 576 # An absolute reference to this testsuite script. 577 case $as_myself in 578 [\\/]* | ?:[\\/]* ) at_myself=$as_myself ;; 579 * ) at_myself=$at_dir/$as_myself ;; 580 esac 581 # Whether -C is in effect. 582 at_change_dir=false 583 584 # Whether to enable colored test results. 585 at_color=auto 586 # List of the tested programs. 587 at_tested='bison' 588 # As many question marks as there are digits in the last test group number. 589 # Used to normalize the test group numbers so that `ls' lists them in 590 # numerical order. 591 at_format='???' 592 # Description of all the test groups. 593 at_help_all="1;input.at:27;Invalid inputs;; 594 2;input.at:57;Invalid inputs with {};; 595 3;input.at:84;Invalid \$n and @n;; 596 4;input.at:104;Type Clashes;; 597 5;input.at:285;Unused values;; 598 6;input.at:295;Unused values before symbol declarations;; 599 7;input.at:305;Default %printer and %destructor redeclared;; 600 8;input.at:365;Per-type %printer and %destructor redeclared;; 601 9;input.at:408;Unused values with default %destructor;; 602 10;input.at:450;Unused values with per-type %destructor;; 603 11;input.at:475;Incompatible Aliases;; 604 12;input.at:516;Torturing the Scanner;; 605 13;input.at:674;Typed symbol aliases;; 606 14;input.at:710;Require 1.0;; 607 15;input.at:711;Require 2.7;; 608 16;input.at:713;Require 100.0;; 609 17;input.at:720;String aliases for character tokens;; 610 18;input.at:741;Symbols;; 611 19;input.at:807;Numbered tokens;; 612 20;input.at:845;Unclosed constructs;; 613 21;input.at:909;%start after first rule;; 614 22;input.at:930;%prec takes a token;; 615 23;input.at:951;%prec's token must be defined;; 616 24;input.at:971;Reject unused %code qualifiers;; 617 25;input.at:1060;%define errors;; 618 26;input.at:1096;%define, --define, --force-define;; 619 27;input.at:1161;%define Boolean variables;; 620 28;input.at:1181;%define enum variables;; 621 29;input.at:1216;%define backward compatibility;; 622 30;input.at:1257;Unused %define api.pure;; 623 31;input.at:1290;C++ namespace reference errors;; 624 32;input.at:1346;Bad character literals;; 625 33;input.at:1399;Bad escapes in literals;; 626 34;input.at:1448;LAC: Errors for %define;; 627 35;input.at:1471;-Werror is not affected by -Wnone and -Wall;; 628 36;input.at:1505;%name-prefix and %define api.prefix are incompatible;; 629 37;input.at:1534;Stray \$ or @;; 630 38;input.at:1568;Code injection;; 631 39;named-refs.at:21;Tutorial calculator;; 632 40;named-refs.at:195;Undefined and ambiguous references;; 633 41;named-refs.at:271;Misleading references;; 634 42;named-refs.at:288;Many kinds of errors;; 635 43;named-refs.at:521;Missing identifiers in brackets;; 636 44;named-refs.at:535;Redundant words in brackets;; 637 45;named-refs.at:549;Comments in brackets;; 638 46;named-refs.at:563;Stray symbols in brackets;; 639 47;named-refs.at:580;Redundant words in LHS brackets;; 640 48;named-refs.at:595;Factored LHS;; 641 49;named-refs.at:606;Unresolved references;; 642 50;named-refs.at:671;\$ or @ followed by . or -;; 643 51;output.at:44;Output files: -dv ;; 644 52;output.at:50;Output files: -dv >&-;; 645 53;output.at:55;Output files: -dv -o foo.c ;; 646 54;output.at:57;Output files: -dv -o foo.tab.c ;; 647 55;output.at:59;Output files: -dv -y ;; 648 56;output.at:61;Output files: -dv -b bar ;; 649 57;output.at:63;Output files: -dv -g -o foo.c ;; 650 58;output.at:67;Output files: %defines %verbose ;; 651 59;output.at:69;Output files: %defines %verbose %yacc ;; 652 60;output.at:72;Output files: %defines %verbose %yacc ;; 653 61;output.at:76;Output files: %file-prefix \"bar\" %defines %verbose ;; 654 62;output.at:78;Output files: %output=\"bar.c\" %defines %verbose %yacc ;; 655 63;output.at:80;Output files: %file-prefix=\"baz\" %output \"bar.c\" %defines %verbose %yacc ;; 656 64;output.at:87;Output files: %defines %verbose ;; 657 65;output.at:90;Output files: %defines %verbose -o foo.c ;; 658 66;output.at:93;Output files: --defines=foo.hpp -o foo.c++ ;; 659 67;output.at:97;Output files: %defines \"foo.hpp\" -o foo.c++ ;; 660 68;output.at:101;Output files: -o foo.c++ --graph=foo.gph ;; 661 69;output.at:116;Output files: %skeleton \"lalr1.cc\" %defines %verbose ;; 662 70;output.at:119;Output files: %skeleton \"lalr1.cc\" %defines %verbose ;; 663 71;output.at:123;Output files: %skeleton \"lalr1.cc\" %defines %verbose -o subdir/foo.cc ;; 664 72;output.at:128;Output files: %skeleton \"lalr1.cc\" %defines %verbose %file-prefix \"output_dir/foo\" ;; 665 73;output.at:158;Conflicting output files: --graph=\"foo.tab.c\";; 666 74;output.at:163;Conflicting output files: %defines \"foo.output\" -v;; 667 75;output.at:168;Conflicting output files: %skeleton \"lalr1.cc\" %defines --graph=\"location.hh\";; 668 76;output.at:173;Conflicting output files: -o foo.y;; 669 77;output.at:219;Output file name: \`~!@#\$%^&*()-=_+{}[]|\\:;<>, .';c++; 670 78;output.at:226;Output file name: (;c++; 671 79;output.at:227;Output file name: );c++; 672 80;output.at:228;Output file name: #;c++; 673 81;output.at:229;Output file name: @@;c++; 674 82;output.at:230;Output file name: @{;c++; 675 83;output.at:231;Output file name: @};c++; 676 84;output.at:232;Output file name: [;c++; 677 85;output.at:233;Output file name: ];c++; 678 86;output.at:260;Graph with no conflicts;graph; 679 87;output.at:294;Graph with unsolved S/R;graph; 680 88;output.at:358;Graph with solved S/R;graph; 681 89;output.at:417;Graph with R/R;graph; 682 90;output.at:449;Graph with reductions with multiple LAT;graph; 683 91;output.at:508;Graph with a reduction rule both enabled and disabled;graph; 684 92;skeletons.at:24;Relative skeleton file names;; 685 93;skeletons.at:84;Installed skeleton file names;; 686 94;skeletons.at:146;%define Boolean variables: invalid skeleton defaults;; 687 95;skeletons.at:170;Complaining during macro argument expansion;; 688 96;skeletons.at:252;Fatal errors make M4 exit immediately;; 689 97;skeletons.at:306;Fatal errors but M4 continues producing output;; 690 98;sets.at:66;Nullable;; 691 99;sets.at:151;Broken Closure;; 692 100;sets.at:193;Firsts;; 693 101;sets.at:269;Accept;; 694 102;reduce.at:25;Useless Terminals;; 695 103;reduce.at:69;Useless Nonterminals;; 696 104;reduce.at:124;Useless Rules;report; 697 105;reduce.at:271;Reduced Automaton;report; 698 106;reduce.at:381;Underivable Rules;report; 699 107;reduce.at:423;Empty Language;; 700 108;reduce.at:474;no %define lr.type: Single State Split;; 701 109;reduce.at:474;%define lr.type lalr: Single State Split;; 702 110;reduce.at:474;%define lr.type ielr: Single State Split;; 703 111;reduce.at:474;%define lr.type canonical-lr: Single State Split;; 704 112;reduce.at:707;no %define lr.type: Lane Split;; 705 113;reduce.at:707;%define lr.type lalr: Lane Split;; 706 114;reduce.at:707;%define lr.type ielr: Lane Split;; 707 115;reduce.at:707;%define lr.type canonical-lr: Lane Split;; 708 116;reduce.at:951;no %define lr.type: Complex Lane Split;; 709 117;reduce.at:951;%define lr.type lalr: Complex Lane Split;; 710 118;reduce.at:951;%define lr.type ielr: Complex Lane Split;; 711 119;reduce.at:951;%define lr.type canonical-lr: Complex Lane Split;; 712 120;reduce.at:1220;no %define lr.type: Split During Added Lookahead Propagation;; 713 121;reduce.at:1220;%define lr.type lalr: Split During Added Lookahead Propagation;; 714 122;reduce.at:1220;%define lr.type ielr: Split During Added Lookahead Propagation;; 715 123;reduce.at:1220;%define lr.type canonical-lr: Split During Added Lookahead Propagation;; 716 124;reduce.at:1550;no %define lr.default-reductions;; 717 125;reduce.at:1550;%define lr.default-reductions most;; 718 126;reduce.at:1550;%define lr.default-reductions consistent;; 719 127;reduce.at:1550;%define lr.default-reductions accepting;; 720 128;synclines.at:150;Prologue syncline;; 721 129;synclines.at:168;%union syncline;; 722 130;synclines.at:189;Postprologue syncline;; 723 131;synclines.at:213;Action syncline;; 724 132;synclines.at:232;Epilogue syncline;; 725 133;synclines.at:249;%code top syncline;; 726 134;synclines.at:290;%no-lines;; 727 135;synclines.at:291;%no-lines;; 728 136;synclines.at:292;%no-lines;; 729 137;synclines.at:293;%no-lines;; 730 138;headers.at:57;Invalid CPP guards: --defines=input/input.h;; 731 139;headers.at:58;Invalid CPP guards: --defines=9foo.h;; 732 140;headers.at:59;Invalid CPP guards: %glr-parser --defines=input/input.h;; 733 141;headers.at:60;Invalid CPP guards: %glr-parser --defines=9foo.h;; 734 142;headers.at:69;export YYLTYPE;; 735 143;headers.at:125;Several parsers;c++; 736 144;actions.at:24;Mid-rule actions;; 737 145;actions.at:133;Initial location: yacc.c ;; 738 146;actions.at:134;Initial location: yacc.c %define api.pure full;; 739 147;actions.at:135;Initial location: yacc.c %define api.pure %parse-param { int x };; 740 148;actions.at:136;Initial location: yacc.c %define api.push-pull both;; 741 149;actions.at:137;Initial location: yacc.c %define api.push-pull both %define api.pure full;; 742 150;actions.at:138;Initial location: glr.c ;; 743 151;actions.at:139;Initial location: glr.c %define api.pure;; 744 152;actions.at:140;Initial location: lalr1.cc ;c++; 745 153;actions.at:141;Initial location: glr.cc ;c++; 746 154;actions.at:150;Initial location: yacc.c %define api.pure full;; 747 155;actions.at:161;Initial location: yacc.c %define api.pure full;; 748 156;actions.at:244;Location print: yacc.c ;; 749 157;actions.at:245;Location print: glr.c ;; 750 158;actions.at:257;Exotic Dollars;; 751 159;actions.at:751;Printers and Destructors;; 752 160;actions.at:752;Printers and Destructors with union;; 753 161;actions.at:754;Printers and Destructors: %defines %skeleton \"lalr1.cc\";c++; 754 162;actions.at:755;Printers and Destructors with union: %defines %skeleton \"lalr1.cc\";c++; 755 163;actions.at:757;Printers and Destructors: %glr-parser;; 756 164;actions.at:758;Printers and Destructors with union: %glr-parser;; 757 165;actions.at:769;Default tagless %printer and %destructor;; 758 166;actions.at:867;Default tagged and per-type %printer and %destructor;; 759 167;actions.at:991;Default %printer and %destructor for user-defined end token;; 760 168;actions.at:1098;Default %printer and %destructor are not for error or \$undefined;; 761 169;actions.at:1193;Default %printer and %destructor are not for \$accept;; 762 170;actions.at:1258;Default %printer and %destructor for mid-rule values;; 763 171;actions.at:1406;@\$ in %initial-action implies %locations;; 764 172;actions.at:1407;@\$ in %destructor implies %locations;; 765 173;actions.at:1408;@\$ in %printer implies %locations;; 766 174;actions.at:1529;Qualified \$\$ in actions: yacc.c;; 767 175;actions.at:1530;Qualified \$\$ in actions: glr.c;; 768 176;actions.at:1531;Qualified \$\$ in actions: lalr1.cc;c++; 769 177;actions.at:1532;Qualified \$\$ in actions: glr.cc;c++; 770 178;actions.at:1540;Fix user actions without a trailing semicolon;; 771 179;actions.at:1649;Destroying lookahead assigned by semantic action;; 772 180;actions.at:1708;YYBACKUP;; 773 181;conflicts.at:31;S/R in initial;; 774 182;conflicts.at:57;%nonassoc and eof;; 775 183;conflicts.at:155;%error-verbose and consistent errors;c++ java; 776 184;conflicts.at:456;LAC: %nonassoc requires splitting canonical LR states;; 777 185;conflicts.at:546;Unresolved SR Conflicts;report; 778 186;conflicts.at:653;Resolved SR Conflicts;report; 779 187;conflicts.at:775;Defaulted Conflicted Reduction;report; 780 188;conflicts.at:894;%expect not enough;; 781 189;conflicts.at:914;%expect right;; 782 190;conflicts.at:931;%expect too much;; 783 191;conflicts.at:951;%expect with reduce conflicts;; 784 192;conflicts.at:971;%prec with user string;; 785 193;conflicts.at:988;%no-default-prec without %prec;; 786 194;conflicts.at:1014;%no-default-prec with %prec;; 787 195;conflicts.at:1038;%default-prec;; 788 196;conflicts.at:1062;Unreachable States After Conflict Resolution;; 789 197;conflicts.at:1273;Solved conflicts report for multiple reductions in a state;; 790 198;conflicts.at:1353;%nonassoc error actions for multiple reductions in a state;; 791 199;conflicts.at:1422;-W versus %expect and %expect-rr;; 792 200;calc.at:597;Calculator ;; 793 201;calc.at:599;Calculator %defines;; 794 202;calc.at:600;Calculator %locations;; 795 203;calc.at:602;Calculator %name-prefix=\"calc\";; 796 204;calc.at:603;Calculator %verbose;; 797 205;calc.at:604;Calculator %yacc;; 798 206;calc.at:605;Calculator %error-verbose;; 799 207;calc.at:607;Calculator %define api.pure full %locations;; 800 208;calc.at:608;Calculator %define api.push-pull both %define api.pure full %locations;; 801 209;calc.at:609;Calculator %error-verbose %locations;; 802 210;calc.at:611;Calculator %error-verbose %locations %defines %name-prefix \"calc\" %verbose %yacc;; 803 211;calc.at:612;Calculator %error-verbose %locations %defines %define api.prefix \"calc\" %verbose %yacc;; 804 212;calc.at:614;Calculator %debug;; 805 213;calc.at:615;Calculator %error-verbose %debug %locations %defines %name-prefix \"calc\" %verbose %yacc;; 806 214;calc.at:616;Calculator %error-verbose %debug %locations %defines %define api.prefix \"calc\" %verbose %yacc;; 807 215;calc.at:618;Calculator %define api.pure full %verbose %debug %locations %defines %name-prefix \"calc\" %verbose %yacc;; 808 216;calc.at:619;Calculator %define api.push-pull both %define api.pure full %verbose %debug %locations %defines %define api.prefix \"calc\" %verbose %yacc;; 809 217;calc.at:621;Calculator %define api.pure %error-verbose %debug %locations %defines %define api.prefix \"calc\" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count};; 810 218;calc.at:638;Calculator %glr-parser ;; 811 219;calc.at:640;Calculator %glr-parser %defines;; 812 220;calc.at:641;Calculator %glr-parser %locations;; 813 221;calc.at:642;Calculator %glr-parser %name-prefix \"calc\";; 814 222;calc.at:643;Calculator %glr-parser %define api.prefix \"calc\";; 815 223;calc.at:644;Calculator %glr-parser %verbose;; 816 224;calc.at:645;Calculator %glr-parser %yacc;; 817 225;calc.at:646;Calculator %glr-parser %error-verbose;; 818 226;calc.at:648;Calculator %glr-parser %define api.pure %locations;; 819 227;calc.at:649;Calculator %glr-parser %error-verbose %locations;; 820 228;calc.at:651;Calculator %glr-parser %error-verbose %locations %defines %name-prefix \"calc\" %verbose %yacc;; 821 229;calc.at:653;Calculator %glr-parser %debug;; 822 230;calc.at:654;Calculator %glr-parser %error-verbose %debug %locations %defines %name-prefix \"calc\" %verbose %yacc;; 823 231;calc.at:655;Calculator %glr-parser %error-verbose %debug %locations %defines %define api.prefix \"calc\" %verbose %yacc;; 824 232;calc.at:657;Calculator %glr-parser %define api.pure %error-verbose %debug %locations %defines %name-prefix \"calc\" %verbose %yacc;; 825 233;calc.at:659;Calculator %glr-parser %define api.pure %error-verbose %debug %locations %defines %name-prefix \"calc\" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count};; 826 234;calc.at:660;Calculator %glr-parser %define api.pure %error-verbose %debug %locations %defines %define api.prefix \"calc\" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count};; 827 235;calc.at:670;Calculator %skeleton \"lalr1.cc\" %defines %locations;c++; 828 236;calc.at:679;Calculator %language \"C++\" %defines %locations ;c++; 829 237;calc.at:680;Calculator %language \"C++\" %defines %locations %define api.location.type Span;c++; 830 238;calc.at:681;Calculator %language \"C++\" %defines %locations %error-verbose %name-prefix \"calc\" %verbose %yacc;c++; 831 239;calc.at:682;Calculator %language \"C++\" %defines %locations %error-verbose %define api.prefix \"calc\" %verbose %yacc;c++; 832 240;calc.at:683;Calculator %language \"C++\" %defines %locations %error-verbose %debug %name-prefix \"calc\" %verbose %yacc;c++; 833 241;calc.at:685;Calculator %language \"C++\" %defines %locations %pure-parser %error-verbose %debug %define api.prefix \"calc\" %verbose %yacc;c++; 834 242;calc.at:687;Calculator %language \"C++\" %defines %locations %pure-parser %error-verbose %debug %name-prefix \"calc\" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count};c++; 835 243;calc.at:688;Calculator %language \"C++\" %defines %locations %pure-parser %error-verbose %debug %define api.prefix \"calc\" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count};c++; 836 244;calc.at:699;Calculator %skeleton \"glr.cc\" %defines %locations;c++; 837 245;calc.at:708;Calculator %language \"C++\" %glr-parser %defines %locations ;c++; 838 246;calc.at:709;Calculator %language \"C++\" %glr-parser %defines %locations %define api.location.type Span;c++; 839 247;calc.at:710;Calculator %language \"C++\" %glr-parser %defines %locations %error-verbose %name-prefix \"calc\" %verbose %yacc;c++; 840 248;calc.at:711;Calculator %language \"C++\" %glr-parser %defines %locations %error-verbose %define api.prefix \"calc\" %verbose %yacc;c++; 841 249;calc.at:713;Calculator %language \"C++\" %glr-parser %defines %locations %debug;c++; 842 250;calc.at:714;Calculator %language \"C++\" %glr-parser %defines %locations %error-verbose %debug %name-prefix \"calc\" %verbose %yacc;c++; 843 251;calc.at:716;Calculator %language \"C++\" %glr-parser %defines %locations %pure-parser %error-verbose %debug %name-prefix \"calc\" %verbose %yacc;c++; 844 252;calc.at:718;Calculator %language \"C++\" %glr-parser %defines %locations %pure-parser %error-verbose %debug %name-prefix \"calc\" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count};c++; 845 253;calc.at:719;Calculator %language \"C++\" %glr-parser %defines %locations %pure-parser %error-verbose %debug %define api.prefix \"calc\" %verbose %yacc %parse-param {semantic_value *result} %parse-param {int *count};c++; 846 254;torture.at:137;Big triangle;; 847 255;torture.at:227;Big horizontal;; 848 256;torture.at:364;Many lookahead tokens;; 849 257;torture.at:466;Exploding the Stack Size with Alloca;; 850 258;torture.at:512;Exploding the Stack Size with Malloc;; 851 259;existing.at:79;GNU AWK 3.1.0 Grammar: LALR(1);; 852 260;existing.at:79;GNU AWK 3.1.0 Grammar: IELR(1);; 853 261;existing.at:79;GNU AWK 3.1.0 Grammar: Canonical LR(1);; 854 262;existing.at:783;GNU Cim Grammar: LALR(1);; 855 263;existing.at:783;GNU Cim Grammar: IELR(1);; 856 264;existing.at:783;GNU Cim Grammar: Canonical LR(1);; 857 265;existing.at:1403;GNU pic (Groff 1.18.1) Grammar: LALR(1);; 858 266;existing.at:1403;GNU pic (Groff 1.18.1) Grammar: IELR(1);; 859 267;existing.at:1403;GNU pic (Groff 1.18.1) Grammar: Canonical LR(1);; 860 268;regression.at:25;Trivial grammars;; 861 269;regression.at:55;YYSTYPE typedef;; 862 270;regression.at:85;Early token definitions with --yacc;; 863 271;regression.at:125;Early token definitions without --yacc;; 864 272;regression.at:170;Braces parsing;; 865 273;regression.at:194;Duplicate string;; 866 274;regression.at:222;Rule Line Numbers;report; 867 275;regression.at:368;Mixing %token styles;; 868 276;regression.at:391;Invalid inputs;; 869 277;regression.at:418;Invalid inputs with {};; 870 278;regression.at:443;Token definitions;; 871 279;regression.at:511;Characters Escapes;; 872 280;regression.at:544;Web2c Report;report; 873 281;regression.at:721;Web2c Actions;report; 874 282;regression.at:936;Dancer ;; 875 283;regression.at:937;Dancer %glr-parser;; 876 284;regression.at:938;Dancer %skeleton \"lalr1.cc\";c++; 877 285;regression.at:1020;Expecting two tokens ;; 878 286;regression.at:1021;Expecting two tokens %glr-parser;; 879 287;regression.at:1022;Expecting two tokens %skeleton \"lalr1.cc\";c++; 880 288;regression.at:1030;Braced code in declaration in rules section;; 881 289;regression.at:1097;String alias declared after use;; 882 290;regression.at:1120;Extra lookahead sets in report;; 883 291;regression.at:1161;Token number in precedence declaration;; 884 292;regression.at:1219;parse-gram.y: LALR = IELR;; 885 293;regression.at:1240;%error-verbose and YYSTACK_USE_ALLOCA;; 886 294;regression.at:1319;%error-verbose overflow;; 887 295;regression.at:1429;LAC: Exploratory stack;; 888 296;regression.at:1523;LAC: Memory exhaustion;; 889 297;regression.at:1664;Lex and parse params: yacc.c;; 890 298;regression.at:1665;Lex and parse params: glr.c;; 891 299;regression.at:1666;Lex and parse params: lalr1.cc;c++; 892 300;regression.at:1667;Lex and parse params: glr.cc;c++; 893 301;c++.at:101;Doxygen Public Documentation;; 894 302;c++.at:102;Doxygen Private Documentation;; 895 303;c++.at:160;Relative namespace references;c++; 896 304;c++.at:166;Absolute namespace references;c++; 897 305;c++.at:175;Syntactically invalid namespace references;; 898 306;c++.at:190;Exception safety;c++; 899 307;java.at:360;Calculator ;java; 900 308;java.at:360;Calculator %error-verbose ;java; 901 309;java.at:360;Calculator %locations ;java; 902 310;java.at:360;Calculator %error-verbose %locations ;java; 903 311;java.at:369;Calculator %lex-param { InputStream is } ;java; 904 312;java.at:369;Calculator %error-verbose %lex-param { InputStream is } ;java; 905 313;java.at:369;Calculator %locations %lex-param { InputStream is } ;java; 906 314;java.at:369;Calculator %error-verbose %locations %lex-param { InputStream is } ;java; 907 315;java.at:455;Java parser class and package names;java; 908 316;java.at:476;Java parser class modifiers;java; 909 317;java.at:534;Java parser class extends and implements;java; 910 318;java.at:554;Java %parse-param and %lex-param;java; 911 319;java.at:628;Java throws specifications;java; 912 320;java.at:717;Java stype, position_class and location_class;java; 913 321;java.at:748;Java syntax error handling without error token;java; 914 322;cxx-type.at:394;GLR: Resolve ambiguity, impure, no locations;; 915 323;cxx-type.at:401;GLR: Resolve ambiguity, impure, locations;; 916 324;cxx-type.at:407;GLR: Resolve ambiguity, pure, no locations;; 917 325;cxx-type.at:414;GLR: Resolve ambiguity, pure, locations;; 918 326;cxx-type.at:421;GLR: Merge conflicting parses, impure, no locations;; 919 327;cxx-type.at:428;GLR: Merge conflicting parses, impure, locations;; 920 328;cxx-type.at:435;GLR: Merge conflicting parses, pure, no locations;; 921 329;cxx-type.at:441;GLR: Merge conflicting parses, pure, locations;; 922 330;cxx-type.at:448;GLR: Verbose messages, resolve ambiguity, impure, no locations;; 923 331;glr-regression.at:25;Badly Collapsed GLR States;; 924 332;glr-regression.at:112;Improper handling of embedded actions and dollar(-N) in GLR parsers;; 925 333;glr-regression.at:244;Improper merging of GLR delayed action sets;; 926 334;glr-regression.at:364;Duplicate representation of merged trees;; 927 335;glr-regression.at:455;User destructor for unresolved GLR semantic value;; 928 336;glr-regression.at:515;User destructor after an error during a split parse;; 929 337;glr-regression.at:569;Duplicated user destructor for lookahead;; 930 338;glr-regression.at:658;Incorrectly initialized location for empty right-hand side in GLR;; 931 339;glr-regression.at:752;No users destructors if stack 0 deleted;; 932 340;glr-regression.at:829;Corrupted semantic options if user action cuts parse;; 933 341;glr-regression.at:883;Undesirable destructors if user action cuts parse;; 934 342;glr-regression.at:941;Leaked semantic values if user action cuts parse;; 935 343;glr-regression.at:1064;Incorrect lookahead during deterministic GLR;; 936 344;glr-regression.at:1188;Incorrect lookahead during nondeterministic GLR;; 937 345;glr-regression.at:1405;Leaked semantic values when reporting ambiguity;; 938 346;glr-regression.at:1487;Leaked lookahead after nondeterministic parse syntax error;; 939 347;glr-regression.at:1547;Uninitialized location when reporting ambiguity;; 940 348;glr-regression.at:1625;Missed %merge type warnings when LHS type is declared later;; 941 349;glr-regression.at:1678;Ambiguity reports;; 942 350;push.at:24;Memory Leak for Early Deletion;; 943 351;push.at:83;Multiple impure instances;; 944 352;push.at:144;Unsupported Skeletons;; 945 " 946 # List of the all the test groups. 947 at_groups_all=`$as_echo "$at_help_all" | sed 's/;.*//'` 948 949 # at_fn_validate_ranges NAME... 950 # ----------------------------- 951 # Validate and normalize the test group number contained in each variable 952 # NAME. Leading zeroes are treated as decimal. 953 at_fn_validate_ranges () 954 { 955 for at_grp 956 do 957 eval at_value=\$$at_grp 958 if test $at_value -lt 1 || test $at_value -gt 352; then 959 $as_echo "invalid test group: $at_value" >&2 960 exit 1 961 fi 962 case $at_value in 963 0*) # We want to treat leading 0 as decimal, like expr and test, but 964 # AS_VAR_ARITH treats it as octal if it uses $(( )). 965 # With XSI shells, ${at_value#${at_value%%[1-9]*}} avoids the 966 # expr fork, but it is not worth the effort to determine if the 967 # shell supports XSI when the user can just avoid leading 0. 968 eval $at_grp='`expr $at_value + 0`' ;; 969 esac 970 done 971 } 972 973 ## 974 ## Set up package specific options. 975 ## 976 977 at_arg_compile_c_with_cxx=false 978 at_arg_given_compile_c_with_cxx=false 979 980 981 at_prev= 982 for at_option 983 do 984 # If the previous option needs an argument, assign it. 985 if test -n "$at_prev"; then 986 at_option=$at_prev=$at_option 987 at_prev= 988 fi 989 990 case $at_option in 991 *=?*) at_optarg=`expr "X$at_option" : '[^=]*=\(.*\)'` ;; 992 *) at_optarg= ;; 993 esac 994 995 # Accept the important Cygnus configure options, so we can diagnose typos. 996 997 case $at_option in 998 --help | -h ) 999 at_help_p=: 1000 ;; 1001 1002 --list | -l ) 1003 at_list_p=: 1004 ;; 1005 1006 --version | -V ) 1007 at_version_p=: 1008 ;; 1009 1010 --clean | -c ) 1011 at_clean=: 1012 ;; 1013 1014 --color ) 1015 at_color=always 1016 ;; 1017 --color=* ) 1018 case $at_optarg in 1019 no | never | none) at_color=never ;; 1020 auto | tty | if-tty) at_color=auto ;; 1021 always | yes | force) at_color=always ;; 1022 *) at_optname=`echo " $at_option" | sed 's/^ //; s/=.*//'` 1023 as_fn_error $? "unrecognized argument to $at_optname: $at_optarg" ;; 1024 esac 1025 ;; 1026 1027 --debug | -d ) 1028 at_debug_p=: 1029 ;; 1030 1031 --errexit | -e ) 1032 at_debug_p=: 1033 at_errexit_p=: 1034 ;; 1035 1036 --verbose | -v ) 1037 at_verbose=; at_quiet=: 1038 ;; 1039 1040 --trace | -x ) 1041 at_traceon='set -x' 1042 at_trace_echo=echo 1043 at_check_filter_trace=at_fn_filter_trace 1044 ;; 1045 1046 [0-9] | [0-9][0-9] | [0-9][0-9][0-9] | [0-9][0-9][0-9][0-9]) 1047 at_fn_validate_ranges at_option 1048 as_fn_append at_groups "$at_option$as_nl" 1049 ;; 1050 1051 # Ranges 1052 [0-9]- | [0-9][0-9]- | [0-9][0-9][0-9]- | [0-9][0-9][0-9][0-9]-) 1053 at_range_start=`echo $at_option |tr -d X-` 1054 at_fn_validate_ranges at_range_start 1055 at_range=`$as_echo "$at_groups_all" | \ 1056 sed -ne '/^'$at_range_start'$/,$p'` 1057 as_fn_append at_groups "$at_range$as_nl" 1058 ;; 1059 1060 -[0-9] | -[0-9][0-9] | -[0-9][0-9][0-9] | -[0-9][0-9][0-9][0-9]) 1061 at_range_end=`echo $at_option |tr -d X-` 1062 at_fn_validate_ranges at_range_end 1063 at_range=`$as_echo "$at_groups_all" | \ 1064 sed -ne '1,/^'$at_range_end'$/p'` 1065 as_fn_append at_groups "$at_range$as_nl" 1066 ;; 1067 1068 [0-9]-[0-9] | [0-9]-[0-9][0-9] | [0-9]-[0-9][0-9][0-9] | \ 1069 [0-9]-[0-9][0-9][0-9][0-9] | [0-9][0-9]-[0-9][0-9] | \ 1070 [0-9][0-9]-[0-9][0-9][0-9] | [0-9][0-9]-[0-9][0-9][0-9][0-9] | \ 1071 [0-9][0-9][0-9]-[0-9][0-9][0-9] | \ 1072 [0-9][0-9][0-9]-[0-9][0-9][0-9][0-9] | \ 1073 [0-9][0-9][0-9][0-9]-[0-9][0-9][0-9][0-9] ) 1074 at_range_start=`expr $at_option : '\(.*\)-'` 1075 at_range_end=`expr $at_option : '.*-\(.*\)'` 1076 if test $at_range_start -gt $at_range_end; then 1077 at_tmp=$at_range_end 1078 at_range_end=$at_range_start 1079 at_range_start=$at_tmp 1080 fi 1081 at_fn_validate_ranges at_range_start at_range_end 1082 at_range=`$as_echo "$at_groups_all" | \ 1083 sed -ne '/^'$at_range_start'$/,/^'$at_range_end'$/p'` 1084 as_fn_append at_groups "$at_range$as_nl" 1085 ;; 1086 1087 # Directory selection. 1088 --directory | -C ) 1089 at_prev=--directory 1090 ;; 1091 --directory=* ) 1092 at_change_dir=: 1093 at_dir=$at_optarg 1094 if test x- = "x$at_dir" ; then 1095 at_dir=./- 1096 fi 1097 ;; 1098 1099 # Parallel execution. 1100 --jobs | -j ) 1101 at_jobs=0 1102 ;; 1103 --jobs=* | -j[0-9]* ) 1104 if test -n "$at_optarg"; then 1105 at_jobs=$at_optarg 1106 else 1107 at_jobs=`expr X$at_option : 'X-j\(.*\)'` 1108 fi 1109 case $at_jobs in *[!0-9]*) 1110 at_optname=`echo " $at_option" | sed 's/^ //; s/[0-9=].*//'` 1111 as_fn_error $? "non-numeric argument to $at_optname: $at_jobs" ;; 1112 esac 1113 ;; 1114 1115 # Keywords. 1116 --keywords | -k ) 1117 at_prev=--keywords 1118 ;; 1119 --keywords=* ) 1120 at_groups_selected=$at_help_all 1121 at_save_IFS=$IFS 1122 IFS=, 1123 set X $at_optarg 1124 shift 1125 IFS=$at_save_IFS 1126 for at_keyword 1127 do 1128 at_invert= 1129 case $at_keyword in 1130 '!'*) 1131 at_invert="-v" 1132 at_keyword=`expr "X$at_keyword" : 'X!\(.*\)'` 1133 ;; 1134 esac 1135 # It is on purpose that we match the test group titles too. 1136 at_groups_selected=`$as_echo "$at_groups_selected" | 1137 grep -i $at_invert "^[1-9][^;]*;.*[; ]$at_keyword[ ;]"` 1138 done 1139 # Smash the keywords. 1140 at_groups_selected=`$as_echo "$at_groups_selected" | sed 's/;.*//'` 1141 as_fn_append at_groups "$at_groups_selected$as_nl" 1142 ;; 1143 --recheck) 1144 at_recheck=: 1145 ;; 1146 --compile-c-with-cxx ) 1147 at_optarg=: 1148 at_arg_compile_c_with_cxx=: 1149 at_arg_given_compile_c_with_cxx=: 1150 ;; 1151 --no-compile-c-with-cxx ) 1152 at_optarg=false 1153 at_arg_compile_c_with_cxx=false 1154 at_arg_given_compile_c_with_cxx=: 1155 ;; 1156 1157 1158 *=*) 1159 at_envvar=`expr "x$at_option" : 'x\([^=]*\)='` 1160 # Reject names that are not valid shell variable names. 1161 case $at_envvar in 1162 '' | [0-9]* | *[!_$as_cr_alnum]* ) 1163 as_fn_error $? "invalid variable name: \`$at_envvar'" ;; 1164 esac 1165 at_value=`$as_echo "$at_optarg" | sed "s/'/'\\\\\\\\''/g"` 1166 # Export now, but save eval for later and for debug scripts. 1167 export $at_envvar 1168 as_fn_append at_debug_args " $at_envvar='$at_value'" 1169 ;; 1170 1171 *) $as_echo "$as_me: invalid option: $at_option" >&2 1172 $as_echo "Try \`$0 --help' for more information." >&2 1173 exit 1 1174 ;; 1175 esac 1176 done 1177 1178 # Verify our last option didn't require an argument 1179 if test -n "$at_prev"; then : 1180 as_fn_error $? "\`$at_prev' requires an argument" 1181 fi 1182 1183 # The file containing the suite. 1184 at_suite_log=$at_dir/$as_me.log 1185 1186 # Selected test groups. 1187 if test -z "$at_groups$at_recheck"; then 1188 at_groups=$at_groups_all 1189 else 1190 if test -n "$at_recheck" && test -r "$at_suite_log"; then 1191 at_oldfails=`sed -n ' 1192 /^Failed tests:$/,/^Skipped tests:$/{ 1193 s/^[ ]*\([1-9][0-9]*\):.*/\1/p 1194 } 1195 /^Unexpected passes:$/,/^## Detailed failed tests/{ 1196 s/^[ ]*\([1-9][0-9]*\):.*/\1/p 1197 } 1198 /^## Detailed failed tests/q 1199 ' "$at_suite_log"` 1200 as_fn_append at_groups "$at_oldfails$as_nl" 1201 fi 1202 # Sort the tests, removing duplicates. 1203 at_groups=`$as_echo "$at_groups" | sort -nu | sed '/^$/d'` 1204 fi 1205 1206 if test x"$at_color" = xalways \ 1207 || { test x"$at_color" = xauto && test -t 1; }; then 1208 at_red=`printf '\033[0;31m'` 1209 at_grn=`printf '\033[0;32m'` 1210 at_lgn=`printf '\033[1;32m'` 1211 at_blu=`printf '\033[1;34m'` 1212 at_std=`printf '\033[m'` 1213 else 1214 at_red= at_grn= at_lgn= at_blu= at_std= 1215 fi 1216 1217 # Help message. 1218 if $at_help_p; then 1219 cat <<_ATEOF || at_write_fail=1 1220 Usage: $0 [OPTION]... [VARIABLE=VALUE]... [TESTS] 1221 1222 Run all the tests, or the selected TESTS, given by numeric ranges, and 1223 save a detailed log file. Upon failure, create debugging scripts. 1224 1225 Do not change environment variables directly. Instead, set them via 1226 command line arguments. Set \`AUTOTEST_PATH' to select the executables 1227 to exercise. Each relative directory is expanded as build and source 1228 directories relative to the top level of this distribution. 1229 E.g., from within the build directory /tmp/foo-1.0, invoking this: 1230 1231 $ $0 AUTOTEST_PATH=bin 1232 1233 is equivalent to the following, assuming the source directory is /src/foo-1.0: 1234 1235 PATH=/tmp/foo-1.0/bin:/src/foo-1.0/bin:\$PATH $0 1236 _ATEOF 1237 cat <<_ATEOF || at_write_fail=1 1238 1239 Operation modes: 1240 -h, --help print the help message, then exit 1241 -V, --version print version number, then exit 1242 -c, --clean remove all the files this test suite might create and exit 1243 -l, --list describes all the tests, or the selected TESTS 1244 _ATEOF 1245 cat <<_ATEOF || at_write_fail=1 1246 1247 Execution tuning: 1248 -C, --directory=DIR 1249 change to directory DIR before starting 1250 --color[=never|auto|always] 1251 disable colored test results, or enable even without terminal 1252 -j, --jobs[=N] 1253 Allow N jobs at once; infinite jobs with no arg (default 1) 1254 -k, --keywords=KEYWORDS 1255 select the tests matching all the comma-separated KEYWORDS 1256 multiple \`-k' accumulate; prefixed \`!' negates a KEYWORD 1257 --recheck select all tests that failed or passed unexpectedly last time 1258 -e, --errexit abort as soon as a test fails; implies --debug 1259 -v, --verbose force more detailed output 1260 default for debugging scripts 1261 -d, --debug inhibit clean up and top-level logging 1262 default for debugging scripts 1263 -x, --trace enable tests shell tracing 1264 _ATEOF 1265 cat <<_ATEOF || at_write_fail=1 1266 1267 Other options: 1268 _ATEOF 1269 1270 cat <<_ATEOF || at_write_fail=1 1271 compile C parsers with the C++ compiler 1272 _ATEOF 1273 cat <<_ATEOF || at_write_fail=1 1274 1275 Report bugs to <bug-bison@gnu.org>. 1276 General help using GNU software: <http://www.gnu.org/gethelp/>. 1277 _ATEOF 1278 exit $at_write_fail 1279 fi 1280 1281 # List of tests. 1282 if $at_list_p; then 1283 cat <<_ATEOF || at_write_fail=1 1284 GNU Bison 2.7 test suite test groups: 1285 1286 NUM: FILE-NAME:LINE TEST-GROUP-NAME 1287 KEYWORDS 1288 1289 _ATEOF 1290 # Pass an empty line as separator between selected groups and help. 1291 $as_echo "$at_groups$as_nl$as_nl$at_help_all" | 1292 awk 'NF == 1 && FS != ";" { 1293 selected[$ 1] = 1 1294 next 1295 } 1296 /^$/ { FS = ";" } 1297 NF > 0 { 1298 if (selected[$ 1]) { 1299 printf " %3d: %-18s %s\n", $ 1, $ 2, $ 3 1300 if ($ 4) { 1301 lmax = 79 1302 indent = " " 1303 line = indent 1304 len = length (line) 1305 n = split ($ 4, a, " ") 1306 for (i = 1; i <= n; i++) { 1307 l = length (a[i]) + 1 1308 if (i > 1 && len + l > lmax) { 1309 print line 1310 line = indent " " a[i] 1311 len = length (line) 1312 } else { 1313 line = line " " a[i] 1314 len += l 1315 } 1316 } 1317 if (n) 1318 print line 1319 } 1320 } 1321 }' || at_write_fail=1 1322 exit $at_write_fail 1323 fi 1324 if $at_version_p; then 1325 $as_echo "$as_me (GNU Bison 2.7)" && 1326 cat <<\_ATEOF || at_write_fail=1 1327 1328 Copyright (C) 2012 Free Software Foundation, Inc. 1329 This test suite is free software; the Free Software Foundation gives 1330 unlimited permission to copy, distribute and modify it. 1331 _ATEOF 1332 exit $at_write_fail 1333 fi 1334 1335 # Should we print banners? Yes if more than one test is run. 1336 case $at_groups in #( 1337 *$as_nl* ) 1338 at_print_banners=: ;; #( 1339 * ) at_print_banners=false ;; 1340 esac 1341 # Text for banner N, set to a single space once printed. 1342 # Banner 1. input.at:18 1343 # Category starts at test group 1. 1344 at_banner_text_1="Input Processing." 1345 # Banner 2. named-refs.at:19 1346 # Category starts at test group 39. 1347 at_banner_text_2="Named references tests." 1348 # Banner 3. output.at:18 1349 # Category starts at test group 51. 1350 at_banner_text_3="Output file names." 1351 # Banner 4. skeletons.at:18 1352 # Category starts at test group 92. 1353 at_banner_text_4="Skeleton Support." 1354 # Banner 5. sets.at:59 1355 # Category starts at test group 98. 1356 at_banner_text_5="Grammar Sets (Firsts etc.)." 1357 # Banner 6. reduce.at:18 1358 # Category starts at test group 102. 1359 at_banner_text_6="Grammar Reduction." 1360 # Banner 7. synclines.at:19 1361 # Category starts at test group 128. 1362 at_banner_text_7="User Actions." 1363 # Banner 8. headers.at:19 1364 # Category starts at test group 138. 1365 at_banner_text_8="Parser Headers." 1366 # Banner 9. actions.at:18 1367 # Category starts at test group 144. 1368 at_banner_text_9="User Actions." 1369 # Banner 10. conflicts.at:19 1370 # Category starts at test group 181. 1371 at_banner_text_10="Conflicts." 1372 # Banner 11. calc.at:588 1373 # Category starts at test group 200. 1374 at_banner_text_11="Simple LALR(1) Calculator." 1375 # Banner 12. calc.at:628 1376 # Category starts at test group 218. 1377 at_banner_text_12="Simple GLR Calculator." 1378 # Banner 13. calc.at:667 1379 # Category starts at test group 235. 1380 at_banner_text_13="Simple LALR(1) C++ Calculator." 1381 # Banner 14. calc.at:696 1382 # Category starts at test group 244. 1383 at_banner_text_14="Simple GLR C++ Calculator." 1384 # Banner 15. torture.at:19 1385 # Category starts at test group 254. 1386 at_banner_text_15="Torture Tests." 1387 # Banner 16. existing.at:19 1388 # Category starts at test group 259. 1389 at_banner_text_16="Existing Grammars." 1390 # Banner 17. regression.at:18 1391 # Category starts at test group 268. 1392 at_banner_text_17="Regression tests." 1393 # Banner 18. c++.at:19 1394 # Category starts at test group 301. 1395 at_banner_text_18="C++ Features." 1396 # Banner 19. java.at:18 1397 # Category starts at test group 307. 1398 at_banner_text_19="Java Calculator." 1399 # Banner 20. java.at:382 1400 # Category starts at test group 315. 1401 at_banner_text_20="Java Parameters." 1402 # Banner 21. cxx-type.at:18 1403 # Category starts at test group 322. 1404 at_banner_text_21="C++ Type Syntax (GLR)." 1405 # Banner 22. glr-regression.at:19 1406 # Category starts at test group 331. 1407 at_banner_text_22="GLR Regression Tests" 1408 # Banner 23. push.at:18 1409 # Category starts at test group 350. 1410 at_banner_text_23="Push Parsing Tests" 1411 1412 # Take any -C into account. 1413 if $at_change_dir ; then 1414 test x != "x$at_dir" && cd "$at_dir" \ 1415 || as_fn_error $? "unable to change directory" 1416 at_dir=`pwd` 1417 fi 1418 1419 # Load the config files for any default variable assignments. 1420 for at_file in atconfig atlocal 1421 do 1422 test -r $at_file || continue 1423 . ./$at_file || as_fn_error $? "invalid content: $at_file" 1424 done 1425 1426 # Autoconf <=2.59b set at_top_builddir instead of at_top_build_prefix: 1427 : "${at_top_build_prefix=$at_top_builddir}" 1428 1429 # Perform any assignments requested during argument parsing. 1430 eval "$at_debug_args" 1431 1432 # atconfig delivers names relative to the directory the test suite is 1433 # in, but the groups themselves are run in testsuite-dir/group-dir. 1434 if test -n "$at_top_srcdir"; then 1435 builddir=../.. 1436 for at_dir_var in srcdir top_srcdir top_build_prefix 1437 do 1438 eval at_val=\$at_$at_dir_var 1439 case $at_val in 1440 [\\/$]* | ?:[\\/]* ) at_prefix= ;; 1441 *) at_prefix=../../ ;; 1442 esac 1443 eval "$at_dir_var=\$at_prefix\$at_val" 1444 done 1445 fi 1446 1447 ## -------------------- ## 1448 ## Directory structure. ## 1449 ## -------------------- ## 1450 1451 # This is the set of directories and files used by this script 1452 # (non-literals are capitalized): 1453 # 1454 # TESTSUITE - the testsuite 1455 # TESTSUITE.log - summarizes the complete testsuite run 1456 # TESTSUITE.dir/ - created during a run, remains after -d or failed test 1457 # + at-groups/ - during a run: status of all groups in run 1458 # | + NNN/ - during a run: meta-data about test group NNN 1459 # | | + check-line - location (source file and line) of current AT_CHECK 1460 # | | + status - exit status of current AT_CHECK 1461 # | | + stdout - stdout of current AT_CHECK 1462 # | | + stder1 - stderr, including trace 1463 # | | + stderr - stderr, with trace filtered out 1464 # | | + test-source - portion of testsuite that defines group 1465 # | | + times - timestamps for computing duration 1466 # | | + pass - created if group passed 1467 # | | + xpass - created if group xpassed 1468 # | | + fail - created if group failed 1469 # | | + xfail - created if group xfailed 1470 # | | + skip - created if group skipped 1471 # + at-stop - during a run: end the run if this file exists 1472 # + at-source-lines - during a run: cache of TESTSUITE line numbers for extraction 1473 # + 0..NNN/ - created for each group NNN, remains after -d or failed test 1474 # | + TESTSUITE.log - summarizes the group results 1475 # | + ... - files created during the group 1476 1477 # The directory the whole suite works in. 1478 # Should be absolute to let the user `cd' at will. 1479 at_suite_dir=$at_dir/$as_me.dir 1480 # The file containing the suite ($at_dir might have changed since earlier). 1481 at_suite_log=$at_dir/$as_me.log 1482 # The directory containing helper files per test group. 1483 at_helper_dir=$at_suite_dir/at-groups 1484 # Stop file: if it exists, do not start new jobs. 1485 at_stop_file=$at_suite_dir/at-stop 1486 # The fifo used for the job dispatcher. 1487 at_job_fifo=$at_suite_dir/at-job-fifo 1488 1489 if $at_clean; then 1490 test -d "$at_suite_dir" && 1491 find "$at_suite_dir" -type d ! -perm -700 -exec chmod u+rwx \{\} \; 1492 rm -f -r "$at_suite_dir" "$at_suite_log" 1493 exit $? 1494 fi 1495 1496 # Don't take risks: use only absolute directories in PATH. 1497 # 1498 # For stand-alone test suites (ie. atconfig was not found), 1499 # AUTOTEST_PATH is relative to `.'. 1500 # 1501 # For embedded test suites, AUTOTEST_PATH is relative to the top level 1502 # of the package. Then expand it into build/src parts, since users 1503 # may create executables in both places. 1504 AUTOTEST_PATH=`$as_echo "$AUTOTEST_PATH" | sed "s|:|$PATH_SEPARATOR|g"` 1505 at_path= 1506 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR 1507 for as_dir in $AUTOTEST_PATH $PATH 1508 do 1509 IFS=$as_save_IFS 1510 test -z "$as_dir" && as_dir=. 1511 test -n "$at_path" && as_fn_append at_path $PATH_SEPARATOR 1512 case $as_dir in 1513 [\\/]* | ?:[\\/]* ) 1514 as_fn_append at_path "$as_dir" 1515 ;; 1516 * ) 1517 if test -z "$at_top_build_prefix"; then 1518 # Stand-alone test suite. 1519 as_fn_append at_path "$as_dir" 1520 else 1521 # Embedded test suite. 1522 as_fn_append at_path "$at_top_build_prefix$as_dir$PATH_SEPARATOR" 1523 as_fn_append at_path "$at_top_srcdir/$as_dir" 1524 fi 1525 ;; 1526 esac 1527 done 1528 IFS=$as_save_IFS 1529 1530 1531 # Now build and simplify PATH. 1532 # 1533 # There might be directories that don't exist, but don't redirect 1534 # builtins' (eg., cd) stderr directly: Ultrix's sh hates that. 1535 at_new_path= 1536 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR 1537 for as_dir in $at_path 1538 do 1539 IFS=$as_save_IFS 1540 test -z "$as_dir" && as_dir=. 1541 test -d "$as_dir" || continue 1542 case $as_dir in 1543 [\\/]* | ?:[\\/]* ) ;; 1544 * ) as_dir=`(cd "$as_dir" && pwd) 2>/dev/null` ;; 1545 esac 1546 case $PATH_SEPARATOR$at_new_path$PATH_SEPARATOR in 1547 *$PATH_SEPARATOR$as_dir$PATH_SEPARATOR*) ;; 1548 $PATH_SEPARATOR$PATH_SEPARATOR) at_new_path=$as_dir ;; 1549 *) as_fn_append at_new_path "$PATH_SEPARATOR$as_dir" ;; 1550 esac 1551 done 1552 IFS=$as_save_IFS 1553 1554 PATH=$at_new_path 1555 export PATH 1556 1557 # Setting up the FDs. 1558 1559 1560 1561 # 5 is the log file. Not to be overwritten if `-d'. 1562 if $at_debug_p; then 1563 at_suite_log=/dev/null 1564 else 1565 : >"$at_suite_log" 1566 fi 1567 exec 5>>"$at_suite_log" 1568 1569 # Banners and logs. 1570 $as_echo "## ------------------------- ## 1571 ## GNU Bison 2.7 test suite. ## 1572 ## ------------------------- ##" 1573 { 1574 $as_echo "## ------------------------- ## 1575 ## GNU Bison 2.7 test suite. ## 1576 ## ------------------------- ##" 1577 echo 1578 1579 $as_echo "$as_me: command line was:" 1580 $as_echo " \$ $0 $at_cli_args" 1581 echo 1582 1583 # If ChangeLog exists, list a few lines in case it might help determining 1584 # the exact version. 1585 if test -n "$at_top_srcdir" && test -f "$at_top_srcdir/ChangeLog"; then 1586 $as_echo "## ---------- ## 1587 ## ChangeLog. ## 1588 ## ---------- ##" 1589 echo 1590 sed 's/^/| /;10q' "$at_top_srcdir/ChangeLog" 1591 echo 1592 fi 1593 1594 { 1595 cat <<_ASUNAME 1596 ## --------- ## 1597 ## Platform. ## 1598 ## --------- ## 1599 1600 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` 1601 uname -m = `(uname -m) 2>/dev/null || echo unknown` 1602 uname -r = `(uname -r) 2>/dev/null || echo unknown` 1603 uname -s = `(uname -s) 2>/dev/null || echo unknown` 1604 uname -v = `(uname -v) 2>/dev/null || echo unknown` 1605 1606 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` 1607 /bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` 1608 1609 /bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` 1610 /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` 1611 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` 1612 /usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` 1613 /bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` 1614 /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` 1615 /bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` 1616 1617 _ASUNAME 1618 1619 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR 1620 for as_dir in $PATH 1621 do 1622 IFS=$as_save_IFS 1623 test -z "$as_dir" && as_dir=. 1624 $as_echo "PATH: $as_dir" 1625 done 1626 IFS=$as_save_IFS 1627 1628 } 1629 echo 1630 1631 # Contents of the config files. 1632 for at_file in atconfig atlocal 1633 do 1634 test -r $at_file || continue 1635 $as_echo "$as_me: $at_file:" 1636 sed 's/^/| /' $at_file 1637 echo 1638 done 1639 } >&5 1640 1641 at_save_special_files () 1642 { 1643 for at_save_file in stderr experr expout 1644 do 1645 test ! -f at-bison-check-$at_save_file.bak || 1646 as_fn_error 1 "fatal error: back-up on top of a back-up" 1647 test ! -f $at_save_file || mv $at_save_file at-bison-check-$at_save_file.bak 1648 done 1649 } 1650 1651 at_restore_special_files () 1652 { 1653 for at_save_file in stderr experr expout 1654 do 1655 test ! -f at-bison-check-$at_save_file.bak || 1656 mv at-bison-check-$at_save_file.bak $at_save_file 1657 done 1658 } 1659 1660 1661 ## ------------------------- ## 1662 ## Autotest shell functions. ## 1663 ## ------------------------- ## 1664 1665 # at_fn_banner NUMBER 1666 # ------------------- 1667 # Output banner NUMBER, provided the testsuite is running multiple groups and 1668 # this particular banner has not yet been printed. 1669 at_fn_banner () 1670 { 1671 $at_print_banners || return 0 1672 eval at_banner_text=\$at_banner_text_$1 1673 test "x$at_banner_text" = "x " && return 0 1674 eval "at_banner_text_$1=\" \"" 1675 if test -z "$at_banner_text"; then 1676 $at_first || echo 1677 else 1678 $as_echo "$as_nl$at_banner_text$as_nl" 1679 fi 1680 } # at_fn_banner 1681 1682 # at_fn_check_prepare_notrace REASON LINE 1683 # --------------------------------------- 1684 # Perform AT_CHECK preparations for the command at LINE for an untraceable 1685 # command; REASON is the reason for disabling tracing. 1686 at_fn_check_prepare_notrace () 1687 { 1688 $at_trace_echo "Not enabling shell tracing (command contains $1)" 1689 $as_echo "$2" >"$at_check_line_file" 1690 at_check_trace=: at_check_filter=: 1691 : >"$at_stdout"; : >"$at_stderr" 1692 } 1693 1694 # at_fn_check_prepare_trace LINE 1695 # ------------------------------ 1696 # Perform AT_CHECK preparations for the command at LINE for a traceable 1697 # command. 1698 at_fn_check_prepare_trace () 1699 { 1700 $as_echo "$1" >"$at_check_line_file" 1701 at_check_trace=$at_traceon at_check_filter=$at_check_filter_trace 1702 : >"$at_stdout"; : >"$at_stderr" 1703 } 1704 1705 # at_fn_check_prepare_dynamic COMMAND LINE 1706 # ---------------------------------------- 1707 # Decide if COMMAND at LINE is traceable at runtime, and call the appropriate 1708 # preparation function. 1709 at_fn_check_prepare_dynamic () 1710 { 1711 case $1 in 1712 *$as_nl*) 1713 at_fn_check_prepare_notrace 'an embedded newline' "$2" ;; 1714 *) 1715 at_fn_check_prepare_trace "$2" ;; 1716 esac 1717 } 1718 1719 # at_fn_filter_trace 1720 # ------------------ 1721 # Remove the lines in the file "$at_stderr" generated by "set -x" and print 1722 # them to stderr. 1723 at_fn_filter_trace () 1724 { 1725 mv "$at_stderr" "$at_stder1" 1726 grep '^ *+' "$at_stder1" >&2 1727 grep -v '^ *+' "$at_stder1" >"$at_stderr" 1728 } 1729 1730 # at_fn_log_failure FILE-LIST 1731 # --------------------------- 1732 # Copy the files in the list on stdout with a "> " prefix, and exit the shell 1733 # with a failure exit code. 1734 at_fn_log_failure () 1735 { 1736 for file 1737 do $as_echo "$file:"; sed 's/^/> /' "$file"; done 1738 echo 1 > "$at_status_file" 1739 exit 1 1740 } 1741 1742 # at_fn_check_skip EXIT-CODE LINE 1743 # ------------------------------- 1744 # Check whether EXIT-CODE is a special exit code (77 or 99), and if so exit 1745 # the test group subshell with that same exit code. Use LINE in any report 1746 # about test failure. 1747 at_fn_check_skip () 1748 { 1749 case $1 in 1750 99) echo 99 > "$at_status_file"; at_failed=: 1751 $as_echo "$2: hard failure"; exit 99;; 1752 77) echo 77 > "$at_status_file"; exit 77;; 1753 esac 1754 } 1755 1756 # at_fn_check_status EXPECTED EXIT-CODE LINE 1757 # ------------------------------------------ 1758 # Check whether EXIT-CODE is the EXPECTED exit code, and if so do nothing. 1759 # Otherwise, if it is 77 or 99, exit the test group subshell with that same 1760 # exit code; if it is anything else print an error message referring to LINE, 1761 # and fail the test. 1762 at_fn_check_status () 1763 { 1764 case $2 in 1765 $1 ) ;; 1766 77) echo 77 > "$at_status_file"; exit 77;; 1767 99) echo 99 > "$at_status_file"; at_failed=: 1768 $as_echo "$3: hard failure"; exit 99;; 1769 *) $as_echo "$3: exit code was $2, expected $1" 1770 at_failed=:;; 1771 esac 1772 } 1773 1774 # at_fn_diff_devnull FILE 1775 # ----------------------- 1776 # Emit a diff between /dev/null and FILE. Uses "test -s" to avoid useless diff 1777 # invocations. 1778 at_fn_diff_devnull () 1779 { 1780 test -s "$1" || return 0 1781 $at_diff "$at_devnull" "$1" 1782 } 1783 1784 # at_fn_test NUMBER 1785 # ----------------- 1786 # Parse out test NUMBER from the tail of this file. 1787 at_fn_test () 1788 { 1789 eval at_sed=\$at_sed$1 1790 sed "$at_sed" "$at_myself" > "$at_test_source" 1791 } 1792 1793 # at_fn_create_debugging_script 1794 # ----------------------------- 1795 # Create the debugging script $at_group_dir/run which will reproduce the 1796 # current test group. 1797 at_fn_create_debugging_script () 1798 { 1799 { 1800 echo "#! /bin/sh" && 1801 echo 'test "${ZSH_VERSION+set}" = set && alias -g '\''${1+"$@"}'\''='\''"$@"'\''' && 1802 $as_echo "cd '$at_dir'" && 1803 $as_echo "exec \${CONFIG_SHELL-$SHELL} \"$at_myself\" -v -d $at_debug_args $at_group \${1+\"\$@\"}" && 1804 echo 'exit 1' 1805 } >"$at_group_dir/run" && 1806 chmod +x "$at_group_dir/run" 1807 } 1808 1809 ## -------------------------------- ## 1810 ## End of autotest shell functions. ## 1811 ## -------------------------------- ## 1812 { 1813 $as_echo "## ---------------- ## 1814 ## Tested programs. ## 1815 ## ---------------- ##" 1816 echo 1817 } >&5 1818 1819 # Report what programs are being tested. 1820 for at_program in : $at_tested 1821 do 1822 test "$at_program" = : && continue 1823 case $at_program in 1824 [\\/]* | ?:[\\/]* ) $at_program_=$at_program ;; 1825 * ) 1826 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR 1827 for as_dir in $PATH 1828 do 1829 IFS=$as_save_IFS 1830 test -z "$as_dir" && as_dir=. 1831 test -f "$as_dir/$at_program" && break 1832 done 1833 IFS=$as_save_IFS 1834 1835 at_program_=$as_dir/$at_program ;; 1836 esac 1837 if test -f "$at_program_"; then 1838 { 1839 $as_echo "$at_srcdir/local.at:913: $at_program_ --version" 1840 "$at_program_" --version </dev/null 1841 echo 1842 } >&5 2>&1 1843 else 1844 as_fn_error $? "cannot find $at_program" "$LINENO" 5 1845 fi 1846 done 1847 1848 { 1849 $as_echo "## ------------------ ## 1850 ## Running the tests. ## 1851 ## ------------------ ##" 1852 } >&5 1853 1854 at_start_date=`date` 1855 at_start_time=`date +%s 2>/dev/null` 1856 $as_echo "$as_me: starting at: $at_start_date" >&5 1857 1858 # Create the master directory if it doesn't already exist. 1859 as_dir="$at_suite_dir"; as_fn_mkdir_p || 1860 as_fn_error $? "cannot create \`$at_suite_dir'" "$LINENO" 5 1861 1862 # Can we diff with `/dev/null'? DU 5.0 refuses. 1863 if diff /dev/null /dev/null >/dev/null 2>&1; then 1864 at_devnull=/dev/null 1865 else 1866 at_devnull=$at_suite_dir/devnull 1867 >"$at_devnull" 1868 fi 1869 1870 # Use `diff -u' when possible. 1871 if at_diff=`diff -u "$at_devnull" "$at_devnull" 2>&1` && test -z "$at_diff" 1872 then 1873 at_diff='diff -u' 1874 else 1875 at_diff=diff 1876 fi 1877 1878 # Get the last needed group. 1879 for at_group in : $at_groups; do :; done 1880 1881 # Extract the start and end lines of each test group at the tail 1882 # of this file 1883 awk ' 1884 BEGIN { FS="" } 1885 /^#AT_START_/ { 1886 start = NR 1887 } 1888 /^#AT_STOP_/ { 1889 test = substr ($ 0, 10) 1890 print "at_sed" test "=\"1," start "d;" (NR-1) "q\"" 1891 if (test == "'"$at_group"'") exit 1892 }' "$at_myself" > "$at_suite_dir/at-source-lines" && 1893 . "$at_suite_dir/at-source-lines" || 1894 as_fn_error $? "cannot create test line number cache" "$LINENO" 5 1895 rm -f "$at_suite_dir/at-source-lines" 1896 1897 # Set number of jobs for `-j'; avoid more jobs than test groups. 1898 set X $at_groups; shift; at_max_jobs=$# 1899 if test $at_max_jobs -eq 0; then 1900 at_jobs=1 1901 fi 1902 if test $at_jobs -ne 1 && 1903 { test $at_jobs -eq 0 || test $at_jobs -gt $at_max_jobs; }; then 1904 at_jobs=$at_max_jobs 1905 fi 1906 1907 # If parallel mode, don't output banners, don't split summary lines. 1908 if test $at_jobs -ne 1; then 1909 at_print_banners=false 1910 at_quiet=: 1911 fi 1912 1913 # Set up helper dirs. 1914 rm -rf "$at_helper_dir" && 1915 mkdir "$at_helper_dir" && 1916 cd "$at_helper_dir" && 1917 { test -z "$at_groups" || mkdir $at_groups; } || 1918 as_fn_error $? "testsuite directory setup failed" "$LINENO" 5 1919 1920 # Functions for running a test group. We leave the actual 1921 # test group execution outside of a shell function in order 1922 # to avoid hitting zsh 4.x exit status bugs. 1923 1924 # at_fn_group_prepare 1925 # ------------------- 1926 # Prepare for running a test group. 1927 at_fn_group_prepare () 1928 { 1929 # The directory for additional per-group helper files. 1930 at_job_dir=$at_helper_dir/$at_group 1931 # The file containing the location of the last AT_CHECK. 1932 at_check_line_file=$at_job_dir/check-line 1933 # The file containing the exit status of the last command. 1934 at_status_file=$at_job_dir/status 1935 # The files containing the output of the tested commands. 1936 at_stdout=$at_job_dir/stdout 1937 at_stder1=$at_job_dir/stder1 1938 at_stderr=$at_job_dir/stderr 1939 # The file containing the code for a test group. 1940 at_test_source=$at_job_dir/test-source 1941 # The file containing dates. 1942 at_times_file=$at_job_dir/times 1943 1944 # Be sure to come back to the top test directory. 1945 cd "$at_suite_dir" 1946 1947 # Clearly separate the test groups when verbose. 1948 $at_first || $at_verbose echo 1949 1950 at_group_normalized=$at_group 1951 1952 eval 'while :; do 1953 case $at_group_normalized in #( 1954 '"$at_format"'*) break;; 1955 esac 1956 at_group_normalized=0$at_group_normalized 1957 done' 1958 1959 1960 # Create a fresh directory for the next test group, and enter. 1961 # If one already exists, the user may have invoked ./run from 1962 # within that directory; we remove the contents, but not the 1963 # directory itself, so that we aren't pulling the rug out from 1964 # under the shell's notion of the current directory. 1965 at_group_dir=$at_suite_dir/$at_group_normalized 1966 at_group_log=$at_group_dir/$as_me.log 1967 if test -d "$at_group_dir"; then 1968 find "$at_group_dir" -type d ! -perm -700 -exec chmod u+rwx {} \; 1969 rm -fr "$at_group_dir"/* "$at_group_dir"/.[!.] "$at_group_dir"/.??* 1970 fi || 1971 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: test directory for $at_group_normalized could not be cleaned" >&5 1972 $as_echo "$as_me: WARNING: test directory for $at_group_normalized could not be cleaned" >&2;} 1973 # Be tolerant if the above `rm' was not able to remove the directory. 1974 as_dir="$at_group_dir"; as_fn_mkdir_p 1975 1976 echo 0 > "$at_status_file" 1977 1978 # In verbose mode, append to the log file *and* show on 1979 # the standard output; in quiet mode only write to the log. 1980 if test -z "$at_verbose"; then 1981 at_tee_pipe='tee -a "$at_group_log"' 1982 else 1983 at_tee_pipe='cat >> "$at_group_log"' 1984 fi 1985 } 1986 1987 # at_fn_group_banner ORDINAL LINE DESC PAD [BANNER] 1988 # ------------------------------------------------- 1989 # Declare the test group ORDINAL, located at LINE with group description DESC, 1990 # and residing under BANNER. Use PAD to align the status column. 1991 at_fn_group_banner () 1992 { 1993 at_setup_line="$2" 1994 test -n "$5" && at_fn_banner $5 1995 at_desc="$3" 1996 case $1 in 1997 [0-9]) at_desc_line=" $1: ";; 1998 [0-9][0-9]) at_desc_line=" $1: " ;; 1999 *) at_desc_line="$1: " ;; 2000 esac 2001 as_fn_append at_desc_line "$3$4" 2002 $at_quiet $as_echo_n "$at_desc_line" 2003 echo "# -*- compilation -*-" >> "$at_group_log" 2004 } 2005 2006 # at_fn_group_postprocess 2007 # ----------------------- 2008 # Perform cleanup after running a test group. 2009 at_fn_group_postprocess () 2010 { 2011 # Be sure to come back to the suite directory, in particular 2012 # since below we might `rm' the group directory we are in currently. 2013 cd "$at_suite_dir" 2014 2015 if test ! -f "$at_check_line_file"; then 2016 sed "s/^ */$as_me: WARNING: /" <<_ATEOF 2017 A failure happened in a test group before any test could be 2018 run. This means that test suite is improperly designed. Please 2019 report this failure to <bug-bison@gnu.org>. 2020 _ATEOF 2021 $as_echo "$at_setup_line" >"$at_check_line_file" 2022 at_status=99 2023 fi 2024 $at_verbose $as_echo_n "$at_group. $at_setup_line: " 2025 $as_echo_n "$at_group. $at_setup_line: " >> "$at_group_log" 2026 case $at_xfail:$at_status in 2027 yes:0) 2028 at_msg="UNEXPECTED PASS" 2029 at_res=xpass 2030 at_errexit=$at_errexit_p 2031 at_color=$at_red 2032 ;; 2033 no:0) 2034 at_msg="ok" 2035 at_res=pass 2036 at_errexit=false 2037 at_color=$at_grn 2038 ;; 2039 *:77) 2040 at_msg='skipped ('`cat "$at_check_line_file"`')' 2041 at_res=skip 2042 at_errexit=false 2043 at_color=$at_blu 2044 ;; 2045 no:* | *:99) 2046 at_msg='FAILED ('`cat "$at_check_line_file"`')' 2047 at_res=fail 2048 at_errexit=$at_errexit_p 2049 at_color=$at_red 2050 ;; 2051 yes:*) 2052 at_msg='expected failure ('`cat "$at_check_line_file"`')' 2053 at_res=xfail 2054 at_errexit=false 2055 at_color=$at_lgn 2056 ;; 2057 esac 2058 echo "$at_res" > "$at_job_dir/$at_res" 2059 # In parallel mode, output the summary line only afterwards. 2060 if test $at_jobs -ne 1 && test -n "$at_verbose"; then 2061 $as_echo "$at_desc_line $at_color$at_msg$at_std" 2062 else 2063 # Make sure there is a separator even with long titles. 2064 $as_echo " $at_color$at_msg$at_std" 2065 fi 2066 at_log_msg="$at_group. $at_desc ($at_setup_line): $at_msg" 2067 case $at_status in 2068 0|77) 2069 # $at_times_file is only available if the group succeeded. 2070 # We're not including the group log, so the success message 2071 # is written in the global log separately. But we also 2072 # write to the group log in case they're using -d. 2073 if test -f "$at_times_file"; then 2074 at_log_msg="$at_log_msg ("`sed 1d "$at_times_file"`')' 2075 rm -f "$at_times_file" 2076 fi 2077 $as_echo "$at_log_msg" >> "$at_group_log" 2078 $as_echo "$at_log_msg" >&5 2079 2080 # Cleanup the group directory, unless the user wants the files 2081 # or the success was unexpected. 2082 if $at_debug_p || test $at_res = xpass; then 2083 at_fn_create_debugging_script 2084 if test $at_res = xpass && $at_errexit; then 2085 echo stop > "$at_stop_file" 2086 fi 2087 else 2088 if test -d "$at_group_dir"; then 2089 find "$at_group_dir" -type d ! -perm -700 -exec chmod u+rwx \{\} \; 2090 rm -fr "$at_group_dir" 2091 fi 2092 rm -f "$at_test_source" 2093 fi 2094 ;; 2095 *) 2096 # Upon failure, include the log into the testsuite's global 2097 # log. The failure message is written in the group log. It 2098 # is later included in the global log. 2099 $as_echo "$at_log_msg" >> "$at_group_log" 2100 2101 # Upon failure, keep the group directory for autopsy, and create 2102 # the debugging script. With -e, do not start any further tests. 2103 at_fn_create_debugging_script 2104 if $at_errexit; then 2105 echo stop > "$at_stop_file" 2106 fi 2107 ;; 2108 esac 2109 } 2110 2111 2112 ## ------------ ## 2113 ## Driver loop. ## 2114 ## ------------ ## 2115 2116 2117 if (set -m && set +m && set +b) >/dev/null 2>&1; then 2118 set +b 2119 at_job_control_on='set -m' at_job_control_off='set +m' at_job_group=- 2120 else 2121 at_job_control_on=: at_job_control_off=: at_job_group= 2122 fi 2123 2124 for at_signal in 1 2 15; do 2125 trap 'set +x; set +e 2126 $at_job_control_off 2127 at_signal='"$at_signal"' 2128 echo stop > "$at_stop_file" 2129 trap "" $at_signal 2130 at_pgids= 2131 for at_pgid in `jobs -p 2>/dev/null`; do 2132 at_pgids="$at_pgids $at_job_group$at_pgid" 2133 done 2134 test -z "$at_pgids" || kill -$at_signal $at_pgids 2>/dev/null 2135 wait 2136 if test "$at_jobs" -eq 1 || test -z "$at_verbose"; then 2137 echo >&2 2138 fi 2139 at_signame=`kill -l $at_signal 2>&1 || echo $at_signal` 2140 set x $at_signame 2141 test 0 -gt 2 && at_signame=$at_signal 2142 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: caught signal $at_signame, bailing out" >&5 2143 $as_echo "$as_me: WARNING: caught signal $at_signame, bailing out" >&2;} 2144 as_fn_arith 128 + $at_signal && exit_status=$as_val 2145 as_fn_exit $exit_status' $at_signal 2146 done 2147 2148 rm -f "$at_stop_file" 2149 at_first=: 2150 2151 if test $at_jobs -ne 1 && 2152 rm -f "$at_job_fifo" && 2153 test -n "$at_job_group" && 2154 ( mkfifo "$at_job_fifo" && trap 'exit 1' PIPE STOP TSTP ) 2>/dev/null 2155 then 2156 # FIFO job dispatcher. 2157 2158 trap 'at_pids= 2159 for at_pid in `jobs -p`; do 2160 at_pids="$at_pids $at_job_group$at_pid" 2161 done 2162 if test -n "$at_pids"; then 2163 at_sig=TSTP 2164 test "${TMOUT+set}" = set && at_sig=STOP 2165 kill -$at_sig $at_pids 2>/dev/null 2166 fi 2167 kill -STOP $$ 2168 test -z "$at_pids" || kill -CONT $at_pids 2>/dev/null' TSTP 2169 2170 echo 2171 # Turn jobs into a list of numbers, starting from 1. 2172 at_joblist=`$as_echo "$at_groups" | sed -n 1,${at_jobs}p` 2173 2174 set X $at_joblist 2175 shift 2176 for at_group in $at_groups; do 2177 $at_job_control_on 2>/dev/null 2178 ( 2179 # Start one test group. 2180 $at_job_control_off 2181 if $at_first; then 2182 exec 7>"$at_job_fifo" 2183 else 2184 exec 6<&- 2185 fi 2186 trap 'set +x; set +e 2187 trap "" PIPE 2188 echo stop > "$at_stop_file" 2189 echo >&7 2190 as_fn_exit 141' PIPE 2191 at_fn_group_prepare 2192 if cd "$at_group_dir" && 2193 at_fn_test $at_group && 2194 . "$at_test_source" 2195 then :; else 2196 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unable to parse test group: $at_group" >&5 2197 $as_echo "$as_me: WARNING: unable to parse test group: $at_group" >&2;} 2198 at_failed=: 2199 fi 2200 at_fn_group_postprocess 2201 echo >&7 2202 ) & 2203 $at_job_control_off 2204 if $at_first; then 2205 at_first=false 2206 exec 6<"$at_job_fifo" 7>"$at_job_fifo" 2207 fi 2208 shift # Consume one token. 2209 if test $# -gt 0; then :; else 2210 read at_token <&6 || break 2211 set x $* 2212 fi 2213 test -f "$at_stop_file" && break 2214 done 2215 exec 7>&- 2216 # Read back the remaining ($at_jobs - 1) tokens. 2217 set X $at_joblist 2218 shift 2219 if test $# -gt 0; then 2220 shift 2221 for at_job 2222 do 2223 read at_token 2224 done <&6 2225 fi 2226 exec 6<&- 2227 wait 2228 else 2229 # Run serially, avoid forks and other potential surprises. 2230 for at_group in $at_groups; do 2231 at_fn_group_prepare 2232 if cd "$at_group_dir" && 2233 at_fn_test $at_group && 2234 . "$at_test_source"; then :; else 2235 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unable to parse test group: $at_group" >&5 2236 $as_echo "$as_me: WARNING: unable to parse test group: $at_group" >&2;} 2237 at_failed=: 2238 fi 2239 at_fn_group_postprocess 2240 test -f "$at_stop_file" && break 2241 at_first=false 2242 done 2243 fi 2244 2245 # Wrap up the test suite with summary statistics. 2246 cd "$at_helper_dir" 2247 2248 # Use ?..???? when the list must remain sorted, the faster * otherwise. 2249 at_pass_list=`for f in */pass; do echo $f; done | sed '/\*/d; s,/pass,,'` 2250 at_skip_list=`for f in */skip; do echo $f; done | sed '/\*/d; s,/skip,,'` 2251 at_xfail_list=`for f in */xfail; do echo $f; done | sed '/\*/d; s,/xfail,,'` 2252 at_xpass_list=`for f in ?/xpass ??/xpass ???/xpass ????/xpass; do 2253 echo $f; done | sed '/?/d; s,/xpass,,'` 2254 at_fail_list=`for f in ?/fail ??/fail ???/fail ????/fail; do 2255 echo $f; done | sed '/?/d; s,/fail,,'` 2256 2257 set X $at_pass_list $at_xpass_list $at_xfail_list $at_fail_list $at_skip_list 2258 shift; at_group_count=$# 2259 set X $at_xpass_list; shift; at_xpass_count=$#; at_xpass_list=$* 2260 set X $at_xfail_list; shift; at_xfail_count=$# 2261 set X $at_fail_list; shift; at_fail_count=$#; at_fail_list=$* 2262 set X $at_skip_list; shift; at_skip_count=$# 2263 2264 as_fn_arith $at_group_count - $at_skip_count && at_run_count=$as_val 2265 as_fn_arith $at_xpass_count + $at_fail_count && at_unexpected_count=$as_val 2266 as_fn_arith $at_xfail_count + $at_fail_count && at_total_fail_count=$as_val 2267 2268 # Back to the top directory. 2269 cd "$at_dir" 2270 rm -rf "$at_helper_dir" 2271 2272 # Compute the duration of the suite. 2273 at_stop_date=`date` 2274 at_stop_time=`date +%s 2>/dev/null` 2275 $as_echo "$as_me: ending at: $at_stop_date" >&5 2276 case $at_start_time,$at_stop_time in 2277 [0-9]*,[0-9]*) 2278 as_fn_arith $at_stop_time - $at_start_time && at_duration_s=$as_val 2279 as_fn_arith $at_duration_s / 60 && at_duration_m=$as_val 2280 as_fn_arith $at_duration_m / 60 && at_duration_h=$as_val 2281 as_fn_arith $at_duration_s % 60 && at_duration_s=$as_val 2282 as_fn_arith $at_duration_m % 60 && at_duration_m=$as_val 2283 at_duration="${at_duration_h}h ${at_duration_m}m ${at_duration_s}s" 2284 $as_echo "$as_me: test suite duration: $at_duration" >&5 2285 ;; 2286 esac 2287 2288 echo 2289 $as_echo "## ------------- ## 2290 ## Test results. ## 2291 ## ------------- ##" 2292 echo 2293 { 2294 echo 2295 $as_echo "## ------------- ## 2296 ## Test results. ## 2297 ## ------------- ##" 2298 echo 2299 } >&5 2300 2301 if test $at_run_count = 1; then 2302 at_result="1 test" 2303 at_were=was 2304 else 2305 at_result="$at_run_count tests" 2306 at_were=were 2307 fi 2308 if $at_errexit_p && test $at_unexpected_count != 0; then 2309 if test $at_xpass_count = 1; then 2310 at_result="$at_result $at_were run, one passed" 2311 else 2312 at_result="$at_result $at_were run, one failed" 2313 fi 2314 at_result="$at_result unexpectedly and inhibited subsequent tests." 2315 at_color=$at_red 2316 else 2317 # Don't you just love exponential explosion of the number of cases? 2318 at_color=$at_red 2319 case $at_xpass_count:$at_fail_count:$at_xfail_count in 2320 # So far, so good. 2321 0:0:0) at_result="$at_result $at_were successful." at_color=$at_grn ;; 2322 0:0:*) at_result="$at_result behaved as expected." at_color=$at_lgn ;; 2323 2324 # Some unexpected failures 2325 0:*:0) at_result="$at_result $at_were run, 2326 $at_fail_count failed unexpectedly." ;; 2327 2328 # Some failures, both expected and unexpected 2329 0:*:1) at_result="$at_result $at_were run, 2330 $at_total_fail_count failed ($at_xfail_count expected failure)." ;; 2331 0:*:*) at_result="$at_result $at_were run, 2332 $at_total_fail_count failed ($at_xfail_count expected failures)." ;; 2333 2334 # No unexpected failures, but some xpasses 2335 *:0:*) at_result="$at_result $at_were run, 2336 $at_xpass_count passed unexpectedly." ;; 2337 2338 # No expected failures, but failures and xpasses 2339 *:1:0) at_result="$at_result $at_were run, 2340 $at_unexpected_count did not behave as expected ($at_fail_count unexpected failure)." ;; 2341 *:*:0) at_result="$at_result $at_were run, 2342 $at_unexpected_count did not behave as expected ($at_fail_count unexpected failures)." ;; 2343 2344 # All of them. 2345 *:*:1) at_result="$at_result $at_were run, 2346 $at_xpass_count passed unexpectedly, 2347 $at_total_fail_count failed ($at_xfail_count expected failure)." ;; 2348 *:*:*) at_result="$at_result $at_were run, 2349 $at_xpass_count passed unexpectedly, 2350 $at_total_fail_count failed ($at_xfail_count expected failures)." ;; 2351 esac 2352 2353 if test $at_skip_count = 0 && test $at_run_count -gt 1; then 2354 at_result="All $at_result" 2355 fi 2356 fi 2357 2358 # Now put skips in the mix. 2359 case $at_skip_count in 2360 0) ;; 2361 1) at_result="$at_result 2362 1 test was skipped." ;; 2363 *) at_result="$at_result 2364 $at_skip_count tests were skipped." ;; 2365 esac 2366 2367 if test $at_unexpected_count = 0; then 2368 echo "$at_color$at_result$at_std" 2369 echo "$at_result" >&5 2370 else 2371 echo "${at_color}ERROR: $at_result$at_std" >&2 2372 echo "ERROR: $at_result" >&5 2373 { 2374 echo 2375 $as_echo "## ------------------------ ## 2376 ## Summary of the failures. ## 2377 ## ------------------------ ##" 2378 2379 # Summary of failed and skipped tests. 2380 if test $at_fail_count != 0; then 2381 echo "Failed tests:" 2382 $SHELL "$at_myself" $at_fail_list --list 2383 echo 2384 fi 2385 if test $at_skip_count != 0; then 2386 echo "Skipped tests:" 2387 $SHELL "$at_myself" $at_skip_list --list 2388 echo 2389 fi 2390 if test $at_xpass_count != 0; then 2391 echo "Unexpected passes:" 2392 $SHELL "$at_myself" $at_xpass_list --list 2393 echo 2394 fi 2395 if test $at_fail_count != 0; then 2396 $as_echo "## ---------------------- ## 2397 ## Detailed failed tests. ## 2398 ## ---------------------- ##" 2399 echo 2400 for at_group in $at_fail_list 2401 do 2402 at_group_normalized=$at_group 2403 2404 eval 'while :; do 2405 case $at_group_normalized in #( 2406 '"$at_format"'*) break;; 2407 esac 2408 at_group_normalized=0$at_group_normalized 2409 done' 2410 2411 cat "$at_suite_dir/$at_group_normalized/$as_me.log" 2412 echo 2413 done 2414 echo 2415 fi 2416 if test -n "$at_top_srcdir"; then 2417 sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX 2418 ## ${at_top_build_prefix}config.log ## 2419 _ASBOX 2420 sed 's/^/| /' ${at_top_build_prefix}config.log 2421 echo 2422 fi 2423 } >&5 2424 2425 sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX 2426 ## $as_me.log was created. ## 2427 _ASBOX 2428 2429 echo 2430 if $at_debug_p; then 2431 at_msg='per-test log files' 2432 else 2433 at_msg="\`${at_testdir+${at_testdir}/}$as_me.log'" 2434 fi 2435 $as_echo "Please send $at_msg and all information you think might help: 2436 2437 To: <bug-bison (at] gnu.org> 2438 Subject: [GNU Bison 2.7] $as_me: $at_fail_list${at_fail_list:+ failed${at_xpass_list:+, }}$at_xpass_list${at_xpass_list:+ passed unexpectedly} 2439 2440 You may investigate any problem if you feel able to do so, in which 2441 case the test suite provides a good starting point. Its output may 2442 be found below \`${at_testdir+${at_testdir}/}$as_me.dir'. 2443 " 2444 exit 1 2445 fi 2446 2447 exit 0 2448 2449 ## ------------- ## 2450 ## Actual tests. ## 2451 ## ------------- ## 2452 #AT_START_1 2453 at_fn_group_banner 1 'input.at:27' \ 2454 "Invalid inputs" " " 1 2455 at_xfail=no 2456 ( 2457 $as_echo "1. $at_setup_line: testing $at_desc ..." 2458 $at_traceon 2459 2460 2461 cat >input.y <<'_ATEOF' 2462 \000\001\002\377? 2463 %% 2464 ? 2465 default: 'a' } 2466 %& 2467 %a-does-not-exist 2468 %- 2469 %{ 2470 _ATEOF 2471 2472 { set +x 2473 $as_echo "$at_srcdir/input.at:39: \$PERL -pi -e 's/\\\\(\\d{3})/chr(oct(\$1))/ge' input.y || exit 77" 2474 at_fn_check_prepare_dynamic "$PERL -pi -e 's/\\\\(\\d{3})/chr(oct($1))/ge' input.y || exit 77" "input.at:39" 2475 ( $at_check_trace; $PERL -pi -e 's/\\(\d{3})/chr(oct($1))/ge' input.y || exit 77 2476 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2477 at_status=$? at_failed=false 2478 $at_check_filter 2479 at_fn_diff_devnull "$at_stderr" || at_failed=: 2480 at_fn_diff_devnull "$at_stdout" || at_failed=: 2481 at_fn_check_status 0 $at_status "$at_srcdir/input.at:39" 2482 $at_failed && at_fn_log_failure 2483 $at_traceon; } 2484 2485 2486 2487 { set +x 2488 $as_echo "$at_srcdir/input.at:41: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 2489 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:41" 2490 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 2491 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2492 at_status=$? at_failed=false 2493 $at_check_filter 2494 echo >>"$at_stderr"; $as_echo "input.y:1.1-2: error: invalid characters: '\\0\\001\\002\\377?' 2495 input.y:3.1: error: invalid character: '?' 2496 input.y:4.14: error: invalid character: '}' 2497 input.y:5.1: error: invalid character: '%' 2498 input.y:5.2: error: invalid character: '&' 2499 input.y:6.1-17: error: invalid directive: '%a-does-not-exist' 2500 input.y:7.1: error: invalid character: '%' 2501 input.y:7.2: error: invalid character: '-' 2502 input.y:8.1-9.0: error: missing '%}' at end of file 2503 input.y:8.1-9.0: error: syntax error, unexpected %{...%} 2504 " | \ 2505 $at_diff - "$at_stderr" || at_failed=: 2506 at_fn_diff_devnull "$at_stdout" || at_failed=: 2507 at_fn_check_status 1 $at_status "$at_srcdir/input.at:41" 2508 $at_failed && at_fn_log_failure 2509 $at_traceon; } 2510 2511 2512 2513 set +x 2514 $at_times_p && times >"$at_times_file" 2515 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 2516 read at_status <"$at_status_file" 2517 #AT_STOP_1 2518 #AT_START_2 2519 at_fn_group_banner 2 'input.at:57' \ 2520 "Invalid inputs with {}" " " 1 2521 at_xfail=no 2522 ( 2523 $as_echo "2. $at_setup_line: testing $at_desc ..." 2524 $at_traceon 2525 2526 2527 # We used to SEGV here. See 2528 # http://lists.gnu.org/archive/html/bug-bison/2005-07/msg00053.html 2529 2530 cat >input.y <<'_ATEOF' 2531 2532 %destructor 2533 %initial-action 2534 %lex-param 2535 %parse-param 2536 %printer 2537 %union 2538 _ATEOF 2539 2540 2541 2542 { set +x 2543 $as_echo "$at_srcdir/input.at:72: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 2544 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:72" 2545 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 2546 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2547 at_status=$? at_failed=false 2548 $at_check_filter 2549 echo >>"$at_stderr"; $as_echo "input.y:3.1-15: error: syntax error, unexpected %initial-action, expecting {...} 2550 " | \ 2551 $at_diff - "$at_stderr" || at_failed=: 2552 at_fn_diff_devnull "$at_stdout" || at_failed=: 2553 at_fn_check_status 1 $at_status "$at_srcdir/input.at:72" 2554 $at_failed && at_fn_log_failure 2555 $at_traceon; } 2556 2557 2558 2559 set +x 2560 $at_times_p && times >"$at_times_file" 2561 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 2562 read at_status <"$at_status_file" 2563 #AT_STOP_2 2564 #AT_START_3 2565 at_fn_group_banner 3 'input.at:84' \ 2566 "Invalid \$n and @n" " " 1 2567 at_xfail=no 2568 ( 2569 $as_echo "3. $at_setup_line: testing $at_desc ..." 2570 $at_traceon 2571 2572 2573 cat >input.y <<'_ATEOF' 2574 %% 2575 exp: { $$ = $1 ; }; 2576 exp: { @$ = @1 ; }; 2577 _ATEOF 2578 2579 2580 2581 { set +x 2582 $as_echo "$at_srcdir/input.at:92: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 2583 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:92" 2584 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 2585 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2586 at_status=$? at_failed=false 2587 $at_check_filter 2588 echo >>"$at_stderr"; $as_echo "input.y:2.13-14: error: integer out of range: '\$1' 2589 input.y:3.13-14: error: integer out of range: '@1' 2590 " | \ 2591 $at_diff - "$at_stderr" || at_failed=: 2592 at_fn_diff_devnull "$at_stdout" || at_failed=: 2593 at_fn_check_status 1 $at_status "$at_srcdir/input.at:92" 2594 $at_failed && at_fn_log_failure 2595 $at_traceon; } 2596 2597 2598 2599 set +x 2600 $at_times_p && times >"$at_times_file" 2601 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 2602 read at_status <"$at_status_file" 2603 #AT_STOP_3 2604 #AT_START_4 2605 at_fn_group_banner 4 'input.at:104' \ 2606 "Type Clashes" " " 1 2607 at_xfail=no 2608 ( 2609 $as_echo "4. $at_setup_line: testing $at_desc ..." 2610 $at_traceon 2611 2612 2613 cat >input.y <<'_ATEOF' 2614 %union { int bar; } 2615 %token foo 2616 %type <bar> exp 2617 %% 2618 exp: foo { $$; } foo { $2; } foo 2619 | foo 2620 | /* Empty. */ 2621 ; 2622 _ATEOF 2623 2624 2625 2626 { set +x 2627 $as_echo "$at_srcdir/input.at:117: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 2628 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:117" 2629 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 2630 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2631 at_status=$? at_failed=false 2632 $at_check_filter 2633 echo >>"$at_stderr"; $as_echo "input.y:5.12-13: error: \$\$ for the midrule at \$2 of 'exp' has no declared type 2634 input.y:5.24-25: error: \$2 of 'exp' has no declared type 2635 input.y:5.6-32: warning: type clash on default action: <bar> != <> 2636 input.y:6.6-8: warning: type clash on default action: <bar> != <> 2637 input.y:7.5: warning: empty rule for typed nonterminal, and no action 2638 " | \ 2639 $at_diff - "$at_stderr" || at_failed=: 2640 at_fn_diff_devnull "$at_stdout" || at_failed=: 2641 at_fn_check_status 1 $at_status "$at_srcdir/input.at:117" 2642 $at_failed && at_fn_log_failure 2643 $at_traceon; } 2644 2645 2646 2647 set +x 2648 $at_times_p && times >"$at_times_file" 2649 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 2650 read at_status <"$at_status_file" 2651 #AT_STOP_4 2652 #AT_START_5 2653 at_fn_group_banner 5 'input.at:285' \ 2654 "Unused values" " " 1 2655 at_xfail=no 2656 ( 2657 $as_echo "5. $at_setup_line: testing $at_desc ..." 2658 $at_traceon 2659 2660 cat >input.y <<'_ATEOF' 2661 %token <integer> INT; 2662 %type <integer> a b c d e f g h i j k l; 2663 %destructor { destroy ($$); } INT a b c d e f g h i j k l; 2664 %% 2665 start: 2666 'a' a { $2; } | 'b' b { $2; } | 'c' c { $2; } | 'd' d { $2; } 2667 | 'e' e { $2; } | 'f' f { $2; } | 'g' g { $2; } | 'h' h { $2; } 2668 | 'i' i { $2; } | 'j' j { $2; } | 'k' k { $2; } | 'l' l { $2; } 2669 ; 2670 2671 a: INT | INT { } INT { } INT { }; 2672 b: INT | /* empty */; 2673 c: INT | INT { $1; } INT { $<integer>2; } INT { $<integer>4; }; 2674 d: INT | INT { } INT { $1; } INT { $<integer>2; }; 2675 e: INT | INT { } INT { } INT { $1; }; 2676 f: INT | INT { } INT { } INT { $$ = $1 + $3 + $5; }; 2677 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 2678 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 2679 i: INT | INT INT { } { $$ = $1 + $2; }; 2680 j: INT | INT INT { $<integer>$ = 1; } { $$ = $1 + $2; }; 2681 k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { }; 2682 l: INT | INT { $<integer>$ = $<integer>1; } INT { $<integer>$ = $<integer>2 + $<integer>3; } INT { $<integer>$ = $<integer>4 + $<integer>5; }; 2683 _ATEOF 2684 2685 2686 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 2687 at_save_special_files 2688 mkdir xml-tests 2689 # Don't combine these Bison invocations since we want to be sure that 2690 # --report=all isn't required to get the full XML file. 2691 { set +x 2692 $as_echo "$at_srcdir/input.at:286: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 2693 --graph=xml-tests/test.dot -fcaret input.y" 2694 at_fn_check_prepare_notrace 'an embedded newline' "input.at:286" 2695 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 2696 --graph=xml-tests/test.dot -fcaret input.y 2697 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2698 at_status=$? at_failed=false 2699 $at_check_filter 2700 echo stderr:; cat "$at_stderr" 2701 echo stdout:; cat "$at_stdout" 2702 at_fn_check_status 0 $at_status "$at_srcdir/input.at:286" 2703 $at_failed && at_fn_log_failure 2704 $at_traceon; } 2705 2706 { set +x 2707 $as_echo "$at_srcdir/input.at:286: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -fcaret input.y" 2708 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -fcaret input.y" "input.at:286" 2709 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -fcaret input.y 2710 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2711 at_status=$? at_failed=false 2712 $at_check_filter 2713 echo stderr:; cat "$at_stderr" 2714 echo stdout:; cat "$at_stdout" 2715 at_fn_check_status 0 $at_status "$at_srcdir/input.at:286" 2716 $at_failed && at_fn_log_failure 2717 $at_traceon; } 2718 2719 cp xml-tests/test.output expout 2720 { set +x 2721 $as_echo "$at_srcdir/input.at:286: \$XSLTPROC \\ 2722 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 2723 xml-tests/test.xml" 2724 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:286" 2725 ( $at_check_trace; $XSLTPROC \ 2726 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 2727 xml-tests/test.xml 2728 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2729 at_status=$? at_failed=false 2730 $at_check_filter 2731 at_fn_diff_devnull "$at_stderr" || at_failed=: 2732 $at_diff expout "$at_stdout" || at_failed=: 2733 at_fn_check_status 0 $at_status "$at_srcdir/input.at:286" 2734 $at_failed && at_fn_log_failure 2735 $at_traceon; } 2736 2737 sort xml-tests/test.dot > expout 2738 { set +x 2739 $as_echo "$at_srcdir/input.at:286: \$XSLTPROC \\ 2740 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 2741 xml-tests/test.xml | sort" 2742 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:286" 2743 ( $at_check_trace; $XSLTPROC \ 2744 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 2745 xml-tests/test.xml | sort 2746 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2747 at_status=$? at_failed=false 2748 $at_check_filter 2749 at_fn_diff_devnull "$at_stderr" || at_failed=: 2750 $at_diff expout "$at_stdout" || at_failed=: 2751 at_fn_check_status 0 $at_status "$at_srcdir/input.at:286" 2752 $at_failed && at_fn_log_failure 2753 $at_traceon; } 2754 2755 rm -rf xml-tests expout 2756 at_restore_special_files 2757 fi 2758 { set +x 2759 $as_echo "$at_srcdir/input.at:286: bison -fcaret input.y" 2760 at_fn_check_prepare_trace "input.at:286" 2761 ( $at_check_trace; bison -fcaret input.y 2762 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2763 at_status=$? at_failed=false 2764 $at_check_filter 2765 echo >>"$at_stderr"; $as_echo "input.y:11.10-32: warning: unset value: \$\$ 2766 a: INT | INT { } INT { } INT { }; 2767 ^^^^^^^^^^^^^^^^^^^^^^^ 2768 input.y:11.10-12: warning: unused value: \$1 2769 a: INT | INT { } INT { } INT { }; 2770 ^^^ 2771 input.y:11.18-20: warning: unused value: \$3 2772 a: INT | INT { } INT { } INT { }; 2773 ^^^ 2774 input.y:11.26-28: warning: unused value: \$5 2775 a: INT | INT { } INT { } INT { }; 2776 ^^^ 2777 input.y:12.9: warning: empty rule for typed nonterminal, and no action 2778 b: INT | /* empty */; 2779 ^ 2780 input.y:13.10-62: warning: unset value: \$\$ 2781 c: INT | INT { \$1; } INT { \$<integer>2; } INT { \$<integer>4; }; 2782 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 2783 input.y:13.22-24: warning: unused value: \$3 2784 c: INT | INT { \$1; } INT { \$<integer>2; } INT { \$<integer>4; }; 2785 ^^^ 2786 input.y:13.43-45: warning: unused value: \$5 2787 c: INT | INT { \$1; } INT { \$<integer>2; } INT { \$<integer>4; }; 2788 ^^^ 2789 input.y:14.10-49: warning: unset value: \$\$ 2790 d: INT | INT { } INT { \$1; } INT { \$<integer>2; }; 2791 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 2792 input.y:14.18-20: warning: unused value: \$3 2793 d: INT | INT { } INT { \$1; } INT { \$<integer>2; }; 2794 ^^^ 2795 input.y:14.30-32: warning: unused value: \$5 2796 d: INT | INT { } INT { \$1; } INT { \$<integer>2; }; 2797 ^^^ 2798 input.y:15.10-37: warning: unset value: \$\$ 2799 e: INT | INT { } INT { } INT { \$1; }; 2800 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 2801 input.y:15.18-20: warning: unused value: \$3 2802 e: INT | INT { } INT { } INT { \$1; }; 2803 ^^^ 2804 input.y:15.27-29: warning: unused value: \$5 2805 e: INT | INT { } INT { } INT { \$1; }; 2806 ^^^ 2807 input.y:17.10-58: warning: unset value: \$\$ 2808 g: INT | INT { \$<integer>\$; } INT { \$<integer>\$; } INT { }; 2809 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 2810 input.y:17.10-12: warning: unused value: \$1 2811 g: INT | INT { \$<integer>\$; } INT { \$<integer>\$; } INT { }; 2812 ^^^ 2813 input.y:17.31-33: warning: unused value: \$3 2814 g: INT | INT { \$<integer>\$; } INT { \$<integer>\$; } INT { }; 2815 ^^^ 2816 input.y:17.52-54: warning: unused value: \$5 2817 g: INT | INT { \$<integer>\$; } INT { \$<integer>\$; } INT { }; 2818 ^^^ 2819 input.y:18.10-72: warning: unset value: \$\$ 2820 h: INT | INT { \$<integer>\$; } INT { \$<integer>\$ = \$<integer>2; } INT { }; 2821 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 2822 input.y:18.10-12: warning: unused value: \$1 2823 h: INT | INT { \$<integer>\$; } INT { \$<integer>\$ = \$<integer>2; } INT { }; 2824 ^^^ 2825 input.y:18.31-33: warning: unused value: \$3 2826 h: INT | INT { \$<integer>\$; } INT { \$<integer>\$ = \$<integer>2; } INT { }; 2827 ^^^ 2828 input.y:18.66-68: warning: unused value: \$5 2829 h: INT | INT { \$<integer>\$; } INT { \$<integer>\$ = \$<integer>2; } INT { }; 2830 ^^^ 2831 input.y:21.10-68: warning: unset value: \$\$ 2832 k: INT | INT INT { \$<integer>\$; } { \$<integer>\$ = \$<integer>3; } { }; 2833 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 2834 input.y:21.10-12: warning: unused value: \$1 2835 k: INT | INT INT { \$<integer>\$; } { \$<integer>\$ = \$<integer>3; } { }; 2836 ^^^ 2837 input.y:21.14-16: warning: unused value: \$2 2838 k: INT | INT INT { \$<integer>\$; } { \$<integer>\$ = \$<integer>3; } { }; 2839 ^^^ 2840 " | \ 2841 $at_diff - "$at_stderr" || at_failed=: 2842 at_fn_diff_devnull "$at_stdout" || at_failed=: 2843 at_fn_check_status 0 $at_status "$at_srcdir/input.at:286" 2844 $at_failed && at_fn_log_failure 2845 $at_traceon; } 2846 2847 # Defining POSIXLY_CORRECT causes bison to complain if options are 2848 # added after the grammar file name, so skip these checks in that 2849 # case. 2850 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 2851 at_save_special_files 2852 2853 # To avoid expanding it repeatedly, store specified stdout. 2854 : >expout 2855 2856 # Run with -Werror. 2857 { set +x 2858 $as_echo "$at_srcdir/input.at:286: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y -Werror" 2859 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y -Werror" "input.at:286" 2860 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -fcaret input.y -Werror 2861 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2862 at_status=$? at_failed=false 2863 $at_check_filter 2864 echo stderr:; tee stderr <"$at_stderr" 2865 $at_diff expout "$at_stdout" || at_failed=: 2866 at_fn_check_status 1 $at_status "$at_srcdir/input.at:286" 2867 $at_failed && at_fn_log_failure 2868 $at_traceon; } 2869 2870 2871 # Build expected stderr up to and including the "warnings being 2872 # treated as errors" message. 2873 cat >at-bison-check-warnings <<'_ATEOF' 2874 input.y:11.10-32: warning: unset value: $$ 2875 a: INT | INT { } INT { } INT { }; 2876 ^^^^^^^^^^^^^^^^^^^^^^^ 2877 input.y:11.10-12: warning: unused value: $1 2878 a: INT | INT { } INT { } INT { }; 2879 ^^^ 2880 input.y:11.18-20: warning: unused value: $3 2881 a: INT | INT { } INT { } INT { }; 2882 ^^^ 2883 input.y:11.26-28: warning: unused value: $5 2884 a: INT | INT { } INT { } INT { }; 2885 ^^^ 2886 input.y:12.9: warning: empty rule for typed nonterminal, and no action 2887 b: INT | /* empty */; 2888 ^ 2889 input.y:13.10-62: warning: unset value: $$ 2890 c: INT | INT { $1; } INT { $<integer>2; } INT { $<integer>4; }; 2891 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 2892 input.y:13.22-24: warning: unused value: $3 2893 c: INT | INT { $1; } INT { $<integer>2; } INT { $<integer>4; }; 2894 ^^^ 2895 input.y:13.43-45: warning: unused value: $5 2896 c: INT | INT { $1; } INT { $<integer>2; } INT { $<integer>4; }; 2897 ^^^ 2898 input.y:14.10-49: warning: unset value: $$ 2899 d: INT | INT { } INT { $1; } INT { $<integer>2; }; 2900 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 2901 input.y:14.18-20: warning: unused value: $3 2902 d: INT | INT { } INT { $1; } INT { $<integer>2; }; 2903 ^^^ 2904 input.y:14.30-32: warning: unused value: $5 2905 d: INT | INT { } INT { $1; } INT { $<integer>2; }; 2906 ^^^ 2907 input.y:15.10-37: warning: unset value: $$ 2908 e: INT | INT { } INT { } INT { $1; }; 2909 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 2910 input.y:15.18-20: warning: unused value: $3 2911 e: INT | INT { } INT { } INT { $1; }; 2912 ^^^ 2913 input.y:15.27-29: warning: unused value: $5 2914 e: INT | INT { } INT { } INT { $1; }; 2915 ^^^ 2916 input.y:17.10-58: warning: unset value: $$ 2917 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 2918 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 2919 input.y:17.10-12: warning: unused value: $1 2920 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 2921 ^^^ 2922 input.y:17.31-33: warning: unused value: $3 2923 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 2924 ^^^ 2925 input.y:17.52-54: warning: unused value: $5 2926 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 2927 ^^^ 2928 input.y:18.10-72: warning: unset value: $$ 2929 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 2930 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 2931 input.y:18.10-12: warning: unused value: $1 2932 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 2933 ^^^ 2934 input.y:18.31-33: warning: unused value: $3 2935 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 2936 ^^^ 2937 input.y:18.66-68: warning: unused value: $5 2938 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 2939 ^^^ 2940 input.y:21.10-68: warning: unset value: $$ 2941 k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { }; 2942 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 2943 input.y:21.10-12: warning: unused value: $1 2944 k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { }; 2945 ^^^ 2946 input.y:21.14-16: warning: unused value: $2 2947 k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { }; 2948 ^^^ 2949 _ATEOF 2950 2951 at_bison_check_first=`sed -n \ 2952 '/: warning: /{=;q;}' at-bison-check-warnings` 2953 : ${at_bison_check_first:=1} 2954 at_bison_check_first_tmp=`sed -n \ 2955 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 2956 : ${at_bison_check_first_tmp:=1} 2957 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 2958 at_bison_check_first=$at_bison_check_first_tmp 2959 fi 2960 if test $at_bison_check_first -gt 1; then 2961 sed -n "1,`expr $at_bison_check_first - 1`"p \ 2962 at-bison-check-warnings > experr 2963 fi 2964 echo 'bison: warnings being treated as errors' >> experr 2965 2966 # Finish building expected stderr and check. Unlike warnings, 2967 # complaints cause bison to exit early. Thus, with -Werror, bison 2968 # does not necessarily report all warnings that it does without 2969 # -Werror, but it at least reports one. 2970 at_bison_check_last=`sed -n '$=' stderr` 2971 : ${at_bison_check_last:=1} 2972 at_bison_check_last=`expr $at_bison_check_last - 1` 2973 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 2974 at-bison-check-warnings >> experr 2975 { set +x 2976 $as_echo "$at_srcdir/input.at:286: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 2977 stderr 1>&2" 2978 at_fn_check_prepare_notrace 'an embedded newline' "input.at:286" 2979 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 2980 stderr 1>&2 2981 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2982 at_status=$? at_failed=false 2983 $at_check_filter 2984 $at_diff experr "$at_stderr" || at_failed=: 2985 at_fn_diff_devnull "$at_stdout" || at_failed=: 2986 at_fn_check_status 0 $at_status "$at_srcdir/input.at:286" 2987 $at_failed && at_fn_log_failure 2988 $at_traceon; } 2989 2990 2991 # Now check --warnings=error. 2992 cp stderr experr 2993 { set +x 2994 $as_echo "$at_srcdir/input.at:286: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y --warnings=error" 2995 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y --warnings=error" "input.at:286" 2996 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -fcaret input.y --warnings=error 2997 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 2998 at_status=$? at_failed=false 2999 $at_check_filter 3000 $at_diff experr "$at_stderr" || at_failed=: 3001 $at_diff expout "$at_stdout" || at_failed=: 3002 at_fn_check_status 1 $at_status "$at_srcdir/input.at:286" 3003 $at_failed && at_fn_log_failure 3004 $at_traceon; } 3005 3006 3007 # Now check -Wnone and --warnings=none by making sure that 3008 # -Werror doesn't change the exit status when -Wnone or 3009 # --warnings=none is specified. 3010 { set +x 3011 $as_echo "$at_srcdir/input.at:286: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y -Wnone -Werror" 3012 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y -Wnone -Werror" "input.at:286" 3013 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -fcaret input.y -Wnone -Werror 3014 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3015 at_status=$? at_failed=false 3016 $at_check_filter 3017 at_fn_diff_devnull "$at_stderr" || at_failed=: 3018 $at_diff expout "$at_stdout" || at_failed=: 3019 at_fn_check_status 0 $at_status "$at_srcdir/input.at:286" 3020 $at_failed && at_fn_log_failure 3021 $at_traceon; } 3022 3023 { set +x 3024 $as_echo "$at_srcdir/input.at:286: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y --warnings=none -Werror" 3025 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y --warnings=none -Werror" "input.at:286" 3026 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -fcaret input.y --warnings=none -Werror 3027 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3028 at_status=$? at_failed=false 3029 $at_check_filter 3030 at_fn_diff_devnull "$at_stderr" || at_failed=: 3031 $at_diff expout "$at_stdout" || at_failed=: 3032 at_fn_check_status 0 $at_status "$at_srcdir/input.at:286" 3033 $at_failed && at_fn_log_failure 3034 $at_traceon; } 3035 3036 3037 at_restore_special_files 3038 fi 3039 3040 cat >input.y <<'_ATEOF' 3041 %token <integer> INT; 3042 %type <integer> a b c d e f g h i j k l; 3043 %destructor { destroy ($$); } INT a b c d e f g h i j k l; 3044 %% 3045 start: 3046 'a' a { $2; } | 'b' b { $2; } | 'c' c { $2; } | 'd' d { $2; } 3047 | 'e' e { $2; } | 'f' f { $2; } | 'g' g { $2; } | 'h' h { $2; } 3048 | 'i' i { $2; } | 'j' j { $2; } | 'k' k { $2; } | 'l' l { $2; } 3049 ; 3050 3051 a: INT | INT { } INT { } INT { }; 3052 b: INT | /* empty */; 3053 c: INT | INT { $1; } INT { $<integer>2; } INT { $<integer>4; }; 3054 d: INT | INT { } INT { $1; } INT { $<integer>2; }; 3055 e: INT | INT { } INT { } INT { $1; }; 3056 f: INT | INT { } INT { } INT { $$ = $1 + $3 + $5; }; 3057 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 3058 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 3059 i: INT | INT INT { } { $$ = $1 + $2; }; 3060 j: INT | INT INT { $<integer>$ = 1; } { $$ = $1 + $2; }; 3061 k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { }; 3062 l: INT | INT { $<integer>$ = $<integer>1; } INT { $<integer>$ = $<integer>2 + $<integer>3; } INT { $<integer>$ = $<integer>4 + $<integer>5; }; 3063 _ATEOF 3064 3065 3066 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 3067 at_save_special_files 3068 mkdir xml-tests 3069 # Don't combine these Bison invocations since we want to be sure that 3070 # --report=all isn't required to get the full XML file. 3071 { set +x 3072 $as_echo "$at_srcdir/input.at:287: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 3073 --graph=xml-tests/test.dot --warnings=midrule-values -fcaret input.y" 3074 at_fn_check_prepare_notrace 'an embedded newline' "input.at:287" 3075 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 3076 --graph=xml-tests/test.dot --warnings=midrule-values -fcaret input.y 3077 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3078 at_status=$? at_failed=false 3079 $at_check_filter 3080 echo stderr:; cat "$at_stderr" 3081 echo stdout:; cat "$at_stdout" 3082 at_fn_check_status 0 $at_status "$at_srcdir/input.at:287" 3083 $at_failed && at_fn_log_failure 3084 $at_traceon; } 3085 3086 { set +x 3087 $as_echo "$at_srcdir/input.at:287: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --warnings=midrule-values -fcaret input.y" 3088 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --warnings=midrule-values -fcaret input.y" "input.at:287" 3089 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --warnings=midrule-values -fcaret input.y 3090 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3091 at_status=$? at_failed=false 3092 $at_check_filter 3093 echo stderr:; cat "$at_stderr" 3094 echo stdout:; cat "$at_stdout" 3095 at_fn_check_status 0 $at_status "$at_srcdir/input.at:287" 3096 $at_failed && at_fn_log_failure 3097 $at_traceon; } 3098 3099 cp xml-tests/test.output expout 3100 { set +x 3101 $as_echo "$at_srcdir/input.at:287: \$XSLTPROC \\ 3102 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 3103 xml-tests/test.xml" 3104 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:287" 3105 ( $at_check_trace; $XSLTPROC \ 3106 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 3107 xml-tests/test.xml 3108 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3109 at_status=$? at_failed=false 3110 $at_check_filter 3111 at_fn_diff_devnull "$at_stderr" || at_failed=: 3112 $at_diff expout "$at_stdout" || at_failed=: 3113 at_fn_check_status 0 $at_status "$at_srcdir/input.at:287" 3114 $at_failed && at_fn_log_failure 3115 $at_traceon; } 3116 3117 sort xml-tests/test.dot > expout 3118 { set +x 3119 $as_echo "$at_srcdir/input.at:287: \$XSLTPROC \\ 3120 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 3121 xml-tests/test.xml | sort" 3122 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:287" 3123 ( $at_check_trace; $XSLTPROC \ 3124 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 3125 xml-tests/test.xml | sort 3126 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3127 at_status=$? at_failed=false 3128 $at_check_filter 3129 at_fn_diff_devnull "$at_stderr" || at_failed=: 3130 $at_diff expout "$at_stdout" || at_failed=: 3131 at_fn_check_status 0 $at_status "$at_srcdir/input.at:287" 3132 $at_failed && at_fn_log_failure 3133 $at_traceon; } 3134 3135 rm -rf xml-tests expout 3136 at_restore_special_files 3137 fi 3138 { set +x 3139 $as_echo "$at_srcdir/input.at:287: bison --warnings=midrule-values -fcaret input.y" 3140 at_fn_check_prepare_trace "input.at:287" 3141 ( $at_check_trace; bison --warnings=midrule-values -fcaret input.y 3142 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3143 at_status=$? at_failed=false 3144 $at_check_filter 3145 echo >>"$at_stderr"; $as_echo "input.y:11.10-32: warning: unset value: \$\$ 3146 a: INT | INT { } INT { } INT { }; 3147 ^^^^^^^^^^^^^^^^^^^^^^^ 3148 input.y:11.10-12: warning: unused value: \$1 3149 a: INT | INT { } INT { } INT { }; 3150 ^^^ 3151 input.y:11.18-20: warning: unused value: \$3 3152 a: INT | INT { } INT { } INT { }; 3153 ^^^ 3154 input.y:11.26-28: warning: unused value: \$5 3155 a: INT | INT { } INT { } INT { }; 3156 ^^^ 3157 input.y:12.9: warning: empty rule for typed nonterminal, and no action 3158 b: INT | /* empty */; 3159 ^ 3160 input.y:13.14-20: warning: unset value: \$\$ 3161 c: INT | INT { \$1; } INT { \$<integer>2; } INT { \$<integer>4; }; 3162 ^^^^^^^ 3163 input.y:13.26-41: warning: unset value: \$\$ 3164 c: INT | INT { \$1; } INT { \$<integer>2; } INT { \$<integer>4; }; 3165 ^^^^^^^^^^^^^^^^ 3166 input.y:13.10-62: warning: unset value: \$\$ 3167 c: INT | INT { \$1; } INT { \$<integer>2; } INT { \$<integer>4; }; 3168 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3169 input.y:13.22-24: warning: unused value: \$3 3170 c: INT | INT { \$1; } INT { \$<integer>2; } INT { \$<integer>4; }; 3171 ^^^ 3172 input.y:13.43-45: warning: unused value: \$5 3173 c: INT | INT { \$1; } INT { \$<integer>2; } INT { \$<integer>4; }; 3174 ^^^ 3175 input.y:14.14-16: warning: unset value: \$\$ 3176 d: INT | INT { } INT { \$1; } INT { \$<integer>2; }; 3177 ^^^ 3178 input.y:14.10-49: warning: unset value: \$\$ 3179 d: INT | INT { } INT { \$1; } INT { \$<integer>2; }; 3180 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3181 input.y:14.18-20: warning: unused value: \$3 3182 d: INT | INT { } INT { \$1; } INT { \$<integer>2; }; 3183 ^^^ 3184 input.y:14.30-32: warning: unused value: \$5 3185 d: INT | INT { } INT { \$1; } INT { \$<integer>2; }; 3186 ^^^ 3187 input.y:15.10-37: warning: unset value: \$\$ 3188 e: INT | INT { } INT { } INT { \$1; }; 3189 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3190 input.y:15.18-20: warning: unused value: \$3 3191 e: INT | INT { } INT { } INT { \$1; }; 3192 ^^^ 3193 input.y:15.27-29: warning: unused value: \$5 3194 e: INT | INT { } INT { } INT { \$1; }; 3195 ^^^ 3196 input.y:17.10-58: warning: unset value: \$\$ 3197 g: INT | INT { \$<integer>\$; } INT { \$<integer>\$; } INT { }; 3198 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3199 input.y:17.10-12: warning: unused value: \$1 3200 g: INT | INT { \$<integer>\$; } INT { \$<integer>\$; } INT { }; 3201 ^^^ 3202 input.y:17.14-29: warning: unused value: \$2 3203 g: INT | INT { \$<integer>\$; } INT { \$<integer>\$; } INT { }; 3204 ^^^^^^^^^^^^^^^^ 3205 input.y:17.31-33: warning: unused value: \$3 3206 g: INT | INT { \$<integer>\$; } INT { \$<integer>\$; } INT { }; 3207 ^^^ 3208 input.y:17.35-50: warning: unused value: \$4 3209 g: INT | INT { \$<integer>\$; } INT { \$<integer>\$; } INT { }; 3210 ^^^^^^^^^^^^^^^^ 3211 input.y:17.52-54: warning: unused value: \$5 3212 g: INT | INT { \$<integer>\$; } INT { \$<integer>\$; } INT { }; 3213 ^^^ 3214 input.y:18.10-72: warning: unset value: \$\$ 3215 h: INT | INT { \$<integer>\$; } INT { \$<integer>\$ = \$<integer>2; } INT { }; 3216 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3217 input.y:18.10-12: warning: unused value: \$1 3218 h: INT | INT { \$<integer>\$; } INT { \$<integer>\$ = \$<integer>2; } INT { }; 3219 ^^^ 3220 input.y:18.31-33: warning: unused value: \$3 3221 h: INT | INT { \$<integer>\$; } INT { \$<integer>\$ = \$<integer>2; } INT { }; 3222 ^^^ 3223 input.y:18.35-64: warning: unused value: \$4 3224 h: INT | INT { \$<integer>\$; } INT { \$<integer>\$ = \$<integer>2; } INT { }; 3225 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3226 input.y:18.66-68: warning: unused value: \$5 3227 h: INT | INT { \$<integer>\$; } INT { \$<integer>\$ = \$<integer>2; } INT { }; 3228 ^^^ 3229 input.y:20.18-37: warning: unused value: \$3 3230 j: INT | INT INT { \$<integer>\$ = 1; } { \$\$ = \$1 + \$2; }; 3231 ^^^^^^^^^^^^^^^^^^^^ 3232 input.y:21.10-68: warning: unset value: \$\$ 3233 k: INT | INT INT { \$<integer>\$; } { \$<integer>\$ = \$<integer>3; } { }; 3234 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3235 input.y:21.10-12: warning: unused value: \$1 3236 k: INT | INT INT { \$<integer>\$; } { \$<integer>\$ = \$<integer>3; } { }; 3237 ^^^ 3238 input.y:21.14-16: warning: unused value: \$2 3239 k: INT | INT INT { \$<integer>\$; } { \$<integer>\$ = \$<integer>3; } { }; 3240 ^^^ 3241 input.y:21.35-64: warning: unused value: \$4 3242 k: INT | INT INT { \$<integer>\$; } { \$<integer>\$ = \$<integer>3; } { }; 3243 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3244 " | \ 3245 $at_diff - "$at_stderr" || at_failed=: 3246 at_fn_diff_devnull "$at_stdout" || at_failed=: 3247 at_fn_check_status 0 $at_status "$at_srcdir/input.at:287" 3248 $at_failed && at_fn_log_failure 3249 $at_traceon; } 3250 3251 # Defining POSIXLY_CORRECT causes bison to complain if options are 3252 # added after the grammar file name, so skip these checks in that 3253 # case. 3254 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 3255 at_save_special_files 3256 3257 # To avoid expanding it repeatedly, store specified stdout. 3258 : >expout 3259 3260 # Run with -Werror. 3261 { set +x 3262 $as_echo "$at_srcdir/input.at:287: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y -Werror" 3263 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y -Werror" "input.at:287" 3264 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y -Werror 3265 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3266 at_status=$? at_failed=false 3267 $at_check_filter 3268 echo stderr:; tee stderr <"$at_stderr" 3269 $at_diff expout "$at_stdout" || at_failed=: 3270 at_fn_check_status 1 $at_status "$at_srcdir/input.at:287" 3271 $at_failed && at_fn_log_failure 3272 $at_traceon; } 3273 3274 3275 # Build expected stderr up to and including the "warnings being 3276 # treated as errors" message. 3277 cat >at-bison-check-warnings <<'_ATEOF' 3278 input.y:11.10-32: warning: unset value: $$ 3279 a: INT | INT { } INT { } INT { }; 3280 ^^^^^^^^^^^^^^^^^^^^^^^ 3281 input.y:11.10-12: warning: unused value: $1 3282 a: INT | INT { } INT { } INT { }; 3283 ^^^ 3284 input.y:11.18-20: warning: unused value: $3 3285 a: INT | INT { } INT { } INT { }; 3286 ^^^ 3287 input.y:11.26-28: warning: unused value: $5 3288 a: INT | INT { } INT { } INT { }; 3289 ^^^ 3290 input.y:12.9: warning: empty rule for typed nonterminal, and no action 3291 b: INT | /* empty */; 3292 ^ 3293 input.y:13.14-20: warning: unset value: $$ 3294 c: INT | INT { $1; } INT { $<integer>2; } INT { $<integer>4; }; 3295 ^^^^^^^ 3296 input.y:13.26-41: warning: unset value: $$ 3297 c: INT | INT { $1; } INT { $<integer>2; } INT { $<integer>4; }; 3298 ^^^^^^^^^^^^^^^^ 3299 input.y:13.10-62: warning: unset value: $$ 3300 c: INT | INT { $1; } INT { $<integer>2; } INT { $<integer>4; }; 3301 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3302 input.y:13.22-24: warning: unused value: $3 3303 c: INT | INT { $1; } INT { $<integer>2; } INT { $<integer>4; }; 3304 ^^^ 3305 input.y:13.43-45: warning: unused value: $5 3306 c: INT | INT { $1; } INT { $<integer>2; } INT { $<integer>4; }; 3307 ^^^ 3308 input.y:14.14-16: warning: unset value: $$ 3309 d: INT | INT { } INT { $1; } INT { $<integer>2; }; 3310 ^^^ 3311 input.y:14.10-49: warning: unset value: $$ 3312 d: INT | INT { } INT { $1; } INT { $<integer>2; }; 3313 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3314 input.y:14.18-20: warning: unused value: $3 3315 d: INT | INT { } INT { $1; } INT { $<integer>2; }; 3316 ^^^ 3317 input.y:14.30-32: warning: unused value: $5 3318 d: INT | INT { } INT { $1; } INT { $<integer>2; }; 3319 ^^^ 3320 input.y:15.10-37: warning: unset value: $$ 3321 e: INT | INT { } INT { } INT { $1; }; 3322 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3323 input.y:15.18-20: warning: unused value: $3 3324 e: INT | INT { } INT { } INT { $1; }; 3325 ^^^ 3326 input.y:15.27-29: warning: unused value: $5 3327 e: INT | INT { } INT { } INT { $1; }; 3328 ^^^ 3329 input.y:17.10-58: warning: unset value: $$ 3330 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 3331 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3332 input.y:17.10-12: warning: unused value: $1 3333 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 3334 ^^^ 3335 input.y:17.14-29: warning: unused value: $2 3336 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 3337 ^^^^^^^^^^^^^^^^ 3338 input.y:17.31-33: warning: unused value: $3 3339 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 3340 ^^^ 3341 input.y:17.35-50: warning: unused value: $4 3342 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 3343 ^^^^^^^^^^^^^^^^ 3344 input.y:17.52-54: warning: unused value: $5 3345 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 3346 ^^^ 3347 input.y:18.10-72: warning: unset value: $$ 3348 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 3349 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3350 input.y:18.10-12: warning: unused value: $1 3351 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 3352 ^^^ 3353 input.y:18.31-33: warning: unused value: $3 3354 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 3355 ^^^ 3356 input.y:18.35-64: warning: unused value: $4 3357 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 3358 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3359 input.y:18.66-68: warning: unused value: $5 3360 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 3361 ^^^ 3362 input.y:20.18-37: warning: unused value: $3 3363 j: INT | INT INT { $<integer>$ = 1; } { $$ = $1 + $2; }; 3364 ^^^^^^^^^^^^^^^^^^^^ 3365 input.y:21.10-68: warning: unset value: $$ 3366 k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { }; 3367 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3368 input.y:21.10-12: warning: unused value: $1 3369 k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { }; 3370 ^^^ 3371 input.y:21.14-16: warning: unused value: $2 3372 k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { }; 3373 ^^^ 3374 input.y:21.35-64: warning: unused value: $4 3375 k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { }; 3376 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3377 _ATEOF 3378 3379 at_bison_check_first=`sed -n \ 3380 '/: warning: /{=;q;}' at-bison-check-warnings` 3381 : ${at_bison_check_first:=1} 3382 at_bison_check_first_tmp=`sed -n \ 3383 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 3384 : ${at_bison_check_first_tmp:=1} 3385 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 3386 at_bison_check_first=$at_bison_check_first_tmp 3387 fi 3388 if test $at_bison_check_first -gt 1; then 3389 sed -n "1,`expr $at_bison_check_first - 1`"p \ 3390 at-bison-check-warnings > experr 3391 fi 3392 echo 'bison: warnings being treated as errors' >> experr 3393 3394 # Finish building expected stderr and check. Unlike warnings, 3395 # complaints cause bison to exit early. Thus, with -Werror, bison 3396 # does not necessarily report all warnings that it does without 3397 # -Werror, but it at least reports one. 3398 at_bison_check_last=`sed -n '$=' stderr` 3399 : ${at_bison_check_last:=1} 3400 at_bison_check_last=`expr $at_bison_check_last - 1` 3401 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 3402 at-bison-check-warnings >> experr 3403 { set +x 3404 $as_echo "$at_srcdir/input.at:287: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 3405 stderr 1>&2" 3406 at_fn_check_prepare_notrace 'an embedded newline' "input.at:287" 3407 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 3408 stderr 1>&2 3409 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3410 at_status=$? at_failed=false 3411 $at_check_filter 3412 $at_diff experr "$at_stderr" || at_failed=: 3413 at_fn_diff_devnull "$at_stdout" || at_failed=: 3414 at_fn_check_status 0 $at_status "$at_srcdir/input.at:287" 3415 $at_failed && at_fn_log_failure 3416 $at_traceon; } 3417 3418 3419 # Now check --warnings=error. 3420 cp stderr experr 3421 { set +x 3422 $as_echo "$at_srcdir/input.at:287: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y --warnings=error" 3423 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y --warnings=error" "input.at:287" 3424 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y --warnings=error 3425 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3426 at_status=$? at_failed=false 3427 $at_check_filter 3428 $at_diff experr "$at_stderr" || at_failed=: 3429 $at_diff expout "$at_stdout" || at_failed=: 3430 at_fn_check_status 1 $at_status "$at_srcdir/input.at:287" 3431 $at_failed && at_fn_log_failure 3432 $at_traceon; } 3433 3434 3435 # Now check -Wnone and --warnings=none by making sure that 3436 # -Werror doesn't change the exit status when -Wnone or 3437 # --warnings=none is specified. 3438 { set +x 3439 $as_echo "$at_srcdir/input.at:287: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y -Wnone -Werror" 3440 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y -Wnone -Werror" "input.at:287" 3441 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y -Wnone -Werror 3442 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3443 at_status=$? at_failed=false 3444 $at_check_filter 3445 at_fn_diff_devnull "$at_stderr" || at_failed=: 3446 $at_diff expout "$at_stdout" || at_failed=: 3447 at_fn_check_status 0 $at_status "$at_srcdir/input.at:287" 3448 $at_failed && at_fn_log_failure 3449 $at_traceon; } 3450 3451 { set +x 3452 $as_echo "$at_srcdir/input.at:287: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y --warnings=none -Werror" 3453 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y --warnings=none -Werror" "input.at:287" 3454 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y --warnings=none -Werror 3455 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3456 at_status=$? at_failed=false 3457 $at_check_filter 3458 at_fn_diff_devnull "$at_stderr" || at_failed=: 3459 $at_diff expout "$at_stdout" || at_failed=: 3460 at_fn_check_status 0 $at_status "$at_srcdir/input.at:287" 3461 $at_failed && at_fn_log_failure 3462 $at_traceon; } 3463 3464 3465 at_restore_special_files 3466 fi 3467 3468 set +x 3469 $at_times_p && times >"$at_times_file" 3470 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 3471 read at_status <"$at_status_file" 3472 #AT_STOP_5 3473 #AT_START_6 3474 at_fn_group_banner 6 'input.at:295' \ 3475 "Unused values before symbol declarations" " " 1 3476 at_xfail=no 3477 ( 3478 $as_echo "6. $at_setup_line: testing $at_desc ..." 3479 $at_traceon 3480 3481 cat >input.y <<'_ATEOF' 3482 3483 3484 3485 %% 3486 start: 3487 'a' a { $2; } | 'b' b { $2; } | 'c' c { $2; } | 'd' d { $2; } 3488 | 'e' e { $2; } | 'f' f { $2; } | 'g' g { $2; } | 'h' h { $2; } 3489 | 'i' i { $2; } | 'j' j { $2; } | 'k' k { $2; } | 'l' l { $2; } 3490 ; 3491 3492 a: INT | INT { } INT { } INT { }; 3493 b: INT | /* empty */; 3494 c: INT | INT { $1; } INT { $<integer>2; } INT { $<integer>4; }; 3495 d: INT | INT { } INT { $1; } INT { $<integer>2; }; 3496 e: INT | INT { } INT { } INT { $1; }; 3497 f: INT | INT { } INT { } INT { $$ = $1 + $3 + $5; }; 3498 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 3499 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 3500 i: INT | INT INT { } { $$ = $1 + $2; }; 3501 j: INT | INT INT { $<integer>$ = 1; } { $$ = $1 + $2; }; 3502 k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { }; 3503 l: INT | INT { $<integer>$ = $<integer>1; } INT { $<integer>$ = $<integer>2 + $<integer>3; } INT { $<integer>$ = $<integer>4 + $<integer>5; }; 3504 %token <integer> INT; 3505 %type <integer> a b c d e f g h i j k l; 3506 %destructor { destroy ($$); } INT a b c d e f g h i j k l; 3507 _ATEOF 3508 3509 3510 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 3511 at_save_special_files 3512 mkdir xml-tests 3513 # Don't combine these Bison invocations since we want to be sure that 3514 # --report=all isn't required to get the full XML file. 3515 { set +x 3516 $as_echo "$at_srcdir/input.at:296: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 3517 --graph=xml-tests/test.dot -fcaret input.y" 3518 at_fn_check_prepare_notrace 'an embedded newline' "input.at:296" 3519 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 3520 --graph=xml-tests/test.dot -fcaret input.y 3521 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3522 at_status=$? at_failed=false 3523 $at_check_filter 3524 echo stderr:; cat "$at_stderr" 3525 echo stdout:; cat "$at_stdout" 3526 at_fn_check_status 0 $at_status "$at_srcdir/input.at:296" 3527 $at_failed && at_fn_log_failure 3528 $at_traceon; } 3529 3530 { set +x 3531 $as_echo "$at_srcdir/input.at:296: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -fcaret input.y" 3532 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -fcaret input.y" "input.at:296" 3533 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -fcaret input.y 3534 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3535 at_status=$? at_failed=false 3536 $at_check_filter 3537 echo stderr:; cat "$at_stderr" 3538 echo stdout:; cat "$at_stdout" 3539 at_fn_check_status 0 $at_status "$at_srcdir/input.at:296" 3540 $at_failed && at_fn_log_failure 3541 $at_traceon; } 3542 3543 cp xml-tests/test.output expout 3544 { set +x 3545 $as_echo "$at_srcdir/input.at:296: \$XSLTPROC \\ 3546 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 3547 xml-tests/test.xml" 3548 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:296" 3549 ( $at_check_trace; $XSLTPROC \ 3550 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 3551 xml-tests/test.xml 3552 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3553 at_status=$? at_failed=false 3554 $at_check_filter 3555 at_fn_diff_devnull "$at_stderr" || at_failed=: 3556 $at_diff expout "$at_stdout" || at_failed=: 3557 at_fn_check_status 0 $at_status "$at_srcdir/input.at:296" 3558 $at_failed && at_fn_log_failure 3559 $at_traceon; } 3560 3561 sort xml-tests/test.dot > expout 3562 { set +x 3563 $as_echo "$at_srcdir/input.at:296: \$XSLTPROC \\ 3564 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 3565 xml-tests/test.xml | sort" 3566 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:296" 3567 ( $at_check_trace; $XSLTPROC \ 3568 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 3569 xml-tests/test.xml | sort 3570 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3571 at_status=$? at_failed=false 3572 $at_check_filter 3573 at_fn_diff_devnull "$at_stderr" || at_failed=: 3574 $at_diff expout "$at_stdout" || at_failed=: 3575 at_fn_check_status 0 $at_status "$at_srcdir/input.at:296" 3576 $at_failed && at_fn_log_failure 3577 $at_traceon; } 3578 3579 rm -rf xml-tests expout 3580 at_restore_special_files 3581 fi 3582 { set +x 3583 $as_echo "$at_srcdir/input.at:296: bison -fcaret input.y" 3584 at_fn_check_prepare_trace "input.at:296" 3585 ( $at_check_trace; bison -fcaret input.y 3586 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3587 at_status=$? at_failed=false 3588 $at_check_filter 3589 echo >>"$at_stderr"; $as_echo "input.y:11.10-32: warning: unset value: \$\$ 3590 a: INT | INT { } INT { } INT { }; 3591 ^^^^^^^^^^^^^^^^^^^^^^^ 3592 input.y:11.10-12: warning: unused value: \$1 3593 a: INT | INT { } INT { } INT { }; 3594 ^^^ 3595 input.y:11.18-20: warning: unused value: \$3 3596 a: INT | INT { } INT { } INT { }; 3597 ^^^ 3598 input.y:11.26-28: warning: unused value: \$5 3599 a: INT | INT { } INT { } INT { }; 3600 ^^^ 3601 input.y:12.9: warning: empty rule for typed nonterminal, and no action 3602 b: INT | /* empty */; 3603 ^ 3604 input.y:13.10-62: warning: unset value: \$\$ 3605 c: INT | INT { \$1; } INT { \$<integer>2; } INT { \$<integer>4; }; 3606 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3607 input.y:13.22-24: warning: unused value: \$3 3608 c: INT | INT { \$1; } INT { \$<integer>2; } INT { \$<integer>4; }; 3609 ^^^ 3610 input.y:13.43-45: warning: unused value: \$5 3611 c: INT | INT { \$1; } INT { \$<integer>2; } INT { \$<integer>4; }; 3612 ^^^ 3613 input.y:14.10-49: warning: unset value: \$\$ 3614 d: INT | INT { } INT { \$1; } INT { \$<integer>2; }; 3615 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3616 input.y:14.18-20: warning: unused value: \$3 3617 d: INT | INT { } INT { \$1; } INT { \$<integer>2; }; 3618 ^^^ 3619 input.y:14.30-32: warning: unused value: \$5 3620 d: INT | INT { } INT { \$1; } INT { \$<integer>2; }; 3621 ^^^ 3622 input.y:15.10-37: warning: unset value: \$\$ 3623 e: INT | INT { } INT { } INT { \$1; }; 3624 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3625 input.y:15.18-20: warning: unused value: \$3 3626 e: INT | INT { } INT { } INT { \$1; }; 3627 ^^^ 3628 input.y:15.27-29: warning: unused value: \$5 3629 e: INT | INT { } INT { } INT { \$1; }; 3630 ^^^ 3631 input.y:17.10-58: warning: unset value: \$\$ 3632 g: INT | INT { \$<integer>\$; } INT { \$<integer>\$; } INT { }; 3633 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3634 input.y:17.10-12: warning: unused value: \$1 3635 g: INT | INT { \$<integer>\$; } INT { \$<integer>\$; } INT { }; 3636 ^^^ 3637 input.y:17.31-33: warning: unused value: \$3 3638 g: INT | INT { \$<integer>\$; } INT { \$<integer>\$; } INT { }; 3639 ^^^ 3640 input.y:17.52-54: warning: unused value: \$5 3641 g: INT | INT { \$<integer>\$; } INT { \$<integer>\$; } INT { }; 3642 ^^^ 3643 input.y:18.10-72: warning: unset value: \$\$ 3644 h: INT | INT { \$<integer>\$; } INT { \$<integer>\$ = \$<integer>2; } INT { }; 3645 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3646 input.y:18.10-12: warning: unused value: \$1 3647 h: INT | INT { \$<integer>\$; } INT { \$<integer>\$ = \$<integer>2; } INT { }; 3648 ^^^ 3649 input.y:18.31-33: warning: unused value: \$3 3650 h: INT | INT { \$<integer>\$; } INT { \$<integer>\$ = \$<integer>2; } INT { }; 3651 ^^^ 3652 input.y:18.66-68: warning: unused value: \$5 3653 h: INT | INT { \$<integer>\$; } INT { \$<integer>\$ = \$<integer>2; } INT { }; 3654 ^^^ 3655 input.y:21.10-68: warning: unset value: \$\$ 3656 k: INT | INT INT { \$<integer>\$; } { \$<integer>\$ = \$<integer>3; } { }; 3657 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3658 input.y:21.10-12: warning: unused value: \$1 3659 k: INT | INT INT { \$<integer>\$; } { \$<integer>\$ = \$<integer>3; } { }; 3660 ^^^ 3661 input.y:21.14-16: warning: unused value: \$2 3662 k: INT | INT INT { \$<integer>\$; } { \$<integer>\$ = \$<integer>3; } { }; 3663 ^^^ 3664 " | \ 3665 $at_diff - "$at_stderr" || at_failed=: 3666 at_fn_diff_devnull "$at_stdout" || at_failed=: 3667 at_fn_check_status 0 $at_status "$at_srcdir/input.at:296" 3668 $at_failed && at_fn_log_failure 3669 $at_traceon; } 3670 3671 # Defining POSIXLY_CORRECT causes bison to complain if options are 3672 # added after the grammar file name, so skip these checks in that 3673 # case. 3674 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 3675 at_save_special_files 3676 3677 # To avoid expanding it repeatedly, store specified stdout. 3678 : >expout 3679 3680 # Run with -Werror. 3681 { set +x 3682 $as_echo "$at_srcdir/input.at:296: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y -Werror" 3683 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y -Werror" "input.at:296" 3684 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -fcaret input.y -Werror 3685 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3686 at_status=$? at_failed=false 3687 $at_check_filter 3688 echo stderr:; tee stderr <"$at_stderr" 3689 $at_diff expout "$at_stdout" || at_failed=: 3690 at_fn_check_status 1 $at_status "$at_srcdir/input.at:296" 3691 $at_failed && at_fn_log_failure 3692 $at_traceon; } 3693 3694 3695 # Build expected stderr up to and including the "warnings being 3696 # treated as errors" message. 3697 cat >at-bison-check-warnings <<'_ATEOF' 3698 input.y:11.10-32: warning: unset value: $$ 3699 a: INT | INT { } INT { } INT { }; 3700 ^^^^^^^^^^^^^^^^^^^^^^^ 3701 input.y:11.10-12: warning: unused value: $1 3702 a: INT | INT { } INT { } INT { }; 3703 ^^^ 3704 input.y:11.18-20: warning: unused value: $3 3705 a: INT | INT { } INT { } INT { }; 3706 ^^^ 3707 input.y:11.26-28: warning: unused value: $5 3708 a: INT | INT { } INT { } INT { }; 3709 ^^^ 3710 input.y:12.9: warning: empty rule for typed nonterminal, and no action 3711 b: INT | /* empty */; 3712 ^ 3713 input.y:13.10-62: warning: unset value: $$ 3714 c: INT | INT { $1; } INT { $<integer>2; } INT { $<integer>4; }; 3715 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3716 input.y:13.22-24: warning: unused value: $3 3717 c: INT | INT { $1; } INT { $<integer>2; } INT { $<integer>4; }; 3718 ^^^ 3719 input.y:13.43-45: warning: unused value: $5 3720 c: INT | INT { $1; } INT { $<integer>2; } INT { $<integer>4; }; 3721 ^^^ 3722 input.y:14.10-49: warning: unset value: $$ 3723 d: INT | INT { } INT { $1; } INT { $<integer>2; }; 3724 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3725 input.y:14.18-20: warning: unused value: $3 3726 d: INT | INT { } INT { $1; } INT { $<integer>2; }; 3727 ^^^ 3728 input.y:14.30-32: warning: unused value: $5 3729 d: INT | INT { } INT { $1; } INT { $<integer>2; }; 3730 ^^^ 3731 input.y:15.10-37: warning: unset value: $$ 3732 e: INT | INT { } INT { } INT { $1; }; 3733 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3734 input.y:15.18-20: warning: unused value: $3 3735 e: INT | INT { } INT { } INT { $1; }; 3736 ^^^ 3737 input.y:15.27-29: warning: unused value: $5 3738 e: INT | INT { } INT { } INT { $1; }; 3739 ^^^ 3740 input.y:17.10-58: warning: unset value: $$ 3741 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 3742 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3743 input.y:17.10-12: warning: unused value: $1 3744 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 3745 ^^^ 3746 input.y:17.31-33: warning: unused value: $3 3747 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 3748 ^^^ 3749 input.y:17.52-54: warning: unused value: $5 3750 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 3751 ^^^ 3752 input.y:18.10-72: warning: unset value: $$ 3753 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 3754 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3755 input.y:18.10-12: warning: unused value: $1 3756 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 3757 ^^^ 3758 input.y:18.31-33: warning: unused value: $3 3759 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 3760 ^^^ 3761 input.y:18.66-68: warning: unused value: $5 3762 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 3763 ^^^ 3764 input.y:21.10-68: warning: unset value: $$ 3765 k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { }; 3766 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3767 input.y:21.10-12: warning: unused value: $1 3768 k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { }; 3769 ^^^ 3770 input.y:21.14-16: warning: unused value: $2 3771 k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { }; 3772 ^^^ 3773 _ATEOF 3774 3775 at_bison_check_first=`sed -n \ 3776 '/: warning: /{=;q;}' at-bison-check-warnings` 3777 : ${at_bison_check_first:=1} 3778 at_bison_check_first_tmp=`sed -n \ 3779 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 3780 : ${at_bison_check_first_tmp:=1} 3781 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 3782 at_bison_check_first=$at_bison_check_first_tmp 3783 fi 3784 if test $at_bison_check_first -gt 1; then 3785 sed -n "1,`expr $at_bison_check_first - 1`"p \ 3786 at-bison-check-warnings > experr 3787 fi 3788 echo 'bison: warnings being treated as errors' >> experr 3789 3790 # Finish building expected stderr and check. Unlike warnings, 3791 # complaints cause bison to exit early. Thus, with -Werror, bison 3792 # does not necessarily report all warnings that it does without 3793 # -Werror, but it at least reports one. 3794 at_bison_check_last=`sed -n '$=' stderr` 3795 : ${at_bison_check_last:=1} 3796 at_bison_check_last=`expr $at_bison_check_last - 1` 3797 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 3798 at-bison-check-warnings >> experr 3799 { set +x 3800 $as_echo "$at_srcdir/input.at:296: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 3801 stderr 1>&2" 3802 at_fn_check_prepare_notrace 'an embedded newline' "input.at:296" 3803 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 3804 stderr 1>&2 3805 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3806 at_status=$? at_failed=false 3807 $at_check_filter 3808 $at_diff experr "$at_stderr" || at_failed=: 3809 at_fn_diff_devnull "$at_stdout" || at_failed=: 3810 at_fn_check_status 0 $at_status "$at_srcdir/input.at:296" 3811 $at_failed && at_fn_log_failure 3812 $at_traceon; } 3813 3814 3815 # Now check --warnings=error. 3816 cp stderr experr 3817 { set +x 3818 $as_echo "$at_srcdir/input.at:296: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y --warnings=error" 3819 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y --warnings=error" "input.at:296" 3820 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -fcaret input.y --warnings=error 3821 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3822 at_status=$? at_failed=false 3823 $at_check_filter 3824 $at_diff experr "$at_stderr" || at_failed=: 3825 $at_diff expout "$at_stdout" || at_failed=: 3826 at_fn_check_status 1 $at_status "$at_srcdir/input.at:296" 3827 $at_failed && at_fn_log_failure 3828 $at_traceon; } 3829 3830 3831 # Now check -Wnone and --warnings=none by making sure that 3832 # -Werror doesn't change the exit status when -Wnone or 3833 # --warnings=none is specified. 3834 { set +x 3835 $as_echo "$at_srcdir/input.at:296: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y -Wnone -Werror" 3836 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y -Wnone -Werror" "input.at:296" 3837 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -fcaret input.y -Wnone -Werror 3838 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3839 at_status=$? at_failed=false 3840 $at_check_filter 3841 at_fn_diff_devnull "$at_stderr" || at_failed=: 3842 $at_diff expout "$at_stdout" || at_failed=: 3843 at_fn_check_status 0 $at_status "$at_srcdir/input.at:296" 3844 $at_failed && at_fn_log_failure 3845 $at_traceon; } 3846 3847 { set +x 3848 $as_echo "$at_srcdir/input.at:296: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y --warnings=none -Werror" 3849 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y --warnings=none -Werror" "input.at:296" 3850 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -fcaret input.y --warnings=none -Werror 3851 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3852 at_status=$? at_failed=false 3853 $at_check_filter 3854 at_fn_diff_devnull "$at_stderr" || at_failed=: 3855 $at_diff expout "$at_stdout" || at_failed=: 3856 at_fn_check_status 0 $at_status "$at_srcdir/input.at:296" 3857 $at_failed && at_fn_log_failure 3858 $at_traceon; } 3859 3860 3861 at_restore_special_files 3862 fi 3863 3864 cat >input.y <<'_ATEOF' 3865 3866 3867 3868 %% 3869 start: 3870 'a' a { $2; } | 'b' b { $2; } | 'c' c { $2; } | 'd' d { $2; } 3871 | 'e' e { $2; } | 'f' f { $2; } | 'g' g { $2; } | 'h' h { $2; } 3872 | 'i' i { $2; } | 'j' j { $2; } | 'k' k { $2; } | 'l' l { $2; } 3873 ; 3874 3875 a: INT | INT { } INT { } INT { }; 3876 b: INT | /* empty */; 3877 c: INT | INT { $1; } INT { $<integer>2; } INT { $<integer>4; }; 3878 d: INT | INT { } INT { $1; } INT { $<integer>2; }; 3879 e: INT | INT { } INT { } INT { $1; }; 3880 f: INT | INT { } INT { } INT { $$ = $1 + $3 + $5; }; 3881 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 3882 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 3883 i: INT | INT INT { } { $$ = $1 + $2; }; 3884 j: INT | INT INT { $<integer>$ = 1; } { $$ = $1 + $2; }; 3885 k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { }; 3886 l: INT | INT { $<integer>$ = $<integer>1; } INT { $<integer>$ = $<integer>2 + $<integer>3; } INT { $<integer>$ = $<integer>4 + $<integer>5; }; 3887 %token <integer> INT; 3888 %type <integer> a b c d e f g h i j k l; 3889 %destructor { destroy ($$); } INT a b c d e f g h i j k l; 3890 _ATEOF 3891 3892 3893 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 3894 at_save_special_files 3895 mkdir xml-tests 3896 # Don't combine these Bison invocations since we want to be sure that 3897 # --report=all isn't required to get the full XML file. 3898 { set +x 3899 $as_echo "$at_srcdir/input.at:297: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 3900 --graph=xml-tests/test.dot --warnings=midrule-values -fcaret input.y" 3901 at_fn_check_prepare_notrace 'an embedded newline' "input.at:297" 3902 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 3903 --graph=xml-tests/test.dot --warnings=midrule-values -fcaret input.y 3904 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3905 at_status=$? at_failed=false 3906 $at_check_filter 3907 echo stderr:; cat "$at_stderr" 3908 echo stdout:; cat "$at_stdout" 3909 at_fn_check_status 0 $at_status "$at_srcdir/input.at:297" 3910 $at_failed && at_fn_log_failure 3911 $at_traceon; } 3912 3913 { set +x 3914 $as_echo "$at_srcdir/input.at:297: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --warnings=midrule-values -fcaret input.y" 3915 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --warnings=midrule-values -fcaret input.y" "input.at:297" 3916 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --warnings=midrule-values -fcaret input.y 3917 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3918 at_status=$? at_failed=false 3919 $at_check_filter 3920 echo stderr:; cat "$at_stderr" 3921 echo stdout:; cat "$at_stdout" 3922 at_fn_check_status 0 $at_status "$at_srcdir/input.at:297" 3923 $at_failed && at_fn_log_failure 3924 $at_traceon; } 3925 3926 cp xml-tests/test.output expout 3927 { set +x 3928 $as_echo "$at_srcdir/input.at:297: \$XSLTPROC \\ 3929 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 3930 xml-tests/test.xml" 3931 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:297" 3932 ( $at_check_trace; $XSLTPROC \ 3933 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 3934 xml-tests/test.xml 3935 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3936 at_status=$? at_failed=false 3937 $at_check_filter 3938 at_fn_diff_devnull "$at_stderr" || at_failed=: 3939 $at_diff expout "$at_stdout" || at_failed=: 3940 at_fn_check_status 0 $at_status "$at_srcdir/input.at:297" 3941 $at_failed && at_fn_log_failure 3942 $at_traceon; } 3943 3944 sort xml-tests/test.dot > expout 3945 { set +x 3946 $as_echo "$at_srcdir/input.at:297: \$XSLTPROC \\ 3947 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 3948 xml-tests/test.xml | sort" 3949 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:297" 3950 ( $at_check_trace; $XSLTPROC \ 3951 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 3952 xml-tests/test.xml | sort 3953 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3954 at_status=$? at_failed=false 3955 $at_check_filter 3956 at_fn_diff_devnull "$at_stderr" || at_failed=: 3957 $at_diff expout "$at_stdout" || at_failed=: 3958 at_fn_check_status 0 $at_status "$at_srcdir/input.at:297" 3959 $at_failed && at_fn_log_failure 3960 $at_traceon; } 3961 3962 rm -rf xml-tests expout 3963 at_restore_special_files 3964 fi 3965 { set +x 3966 $as_echo "$at_srcdir/input.at:297: bison --warnings=midrule-values -fcaret input.y" 3967 at_fn_check_prepare_trace "input.at:297" 3968 ( $at_check_trace; bison --warnings=midrule-values -fcaret input.y 3969 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 3970 at_status=$? at_failed=false 3971 $at_check_filter 3972 echo >>"$at_stderr"; $as_echo "input.y:11.10-32: warning: unset value: \$\$ 3973 a: INT | INT { } INT { } INT { }; 3974 ^^^^^^^^^^^^^^^^^^^^^^^ 3975 input.y:11.10-12: warning: unused value: \$1 3976 a: INT | INT { } INT { } INT { }; 3977 ^^^ 3978 input.y:11.18-20: warning: unused value: \$3 3979 a: INT | INT { } INT { } INT { }; 3980 ^^^ 3981 input.y:11.26-28: warning: unused value: \$5 3982 a: INT | INT { } INT { } INT { }; 3983 ^^^ 3984 input.y:12.9: warning: empty rule for typed nonterminal, and no action 3985 b: INT | /* empty */; 3986 ^ 3987 input.y:13.14-20: warning: unset value: \$\$ 3988 c: INT | INT { \$1; } INT { \$<integer>2; } INT { \$<integer>4; }; 3989 ^^^^^^^ 3990 input.y:13.26-41: warning: unset value: \$\$ 3991 c: INT | INT { \$1; } INT { \$<integer>2; } INT { \$<integer>4; }; 3992 ^^^^^^^^^^^^^^^^ 3993 input.y:13.10-62: warning: unset value: \$\$ 3994 c: INT | INT { \$1; } INT { \$<integer>2; } INT { \$<integer>4; }; 3995 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 3996 input.y:13.22-24: warning: unused value: \$3 3997 c: INT | INT { \$1; } INT { \$<integer>2; } INT { \$<integer>4; }; 3998 ^^^ 3999 input.y:13.43-45: warning: unused value: \$5 4000 c: INT | INT { \$1; } INT { \$<integer>2; } INT { \$<integer>4; }; 4001 ^^^ 4002 input.y:14.14-16: warning: unset value: \$\$ 4003 d: INT | INT { } INT { \$1; } INT { \$<integer>2; }; 4004 ^^^ 4005 input.y:14.10-49: warning: unset value: \$\$ 4006 d: INT | INT { } INT { \$1; } INT { \$<integer>2; }; 4007 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 4008 input.y:14.18-20: warning: unused value: \$3 4009 d: INT | INT { } INT { \$1; } INT { \$<integer>2; }; 4010 ^^^ 4011 input.y:14.30-32: warning: unused value: \$5 4012 d: INT | INT { } INT { \$1; } INT { \$<integer>2; }; 4013 ^^^ 4014 input.y:15.10-37: warning: unset value: \$\$ 4015 e: INT | INT { } INT { } INT { \$1; }; 4016 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 4017 input.y:15.18-20: warning: unused value: \$3 4018 e: INT | INT { } INT { } INT { \$1; }; 4019 ^^^ 4020 input.y:15.27-29: warning: unused value: \$5 4021 e: INT | INT { } INT { } INT { \$1; }; 4022 ^^^ 4023 input.y:17.10-58: warning: unset value: \$\$ 4024 g: INT | INT { \$<integer>\$; } INT { \$<integer>\$; } INT { }; 4025 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 4026 input.y:17.10-12: warning: unused value: \$1 4027 g: INT | INT { \$<integer>\$; } INT { \$<integer>\$; } INT { }; 4028 ^^^ 4029 input.y:17.14-29: warning: unused value: \$2 4030 g: INT | INT { \$<integer>\$; } INT { \$<integer>\$; } INT { }; 4031 ^^^^^^^^^^^^^^^^ 4032 input.y:17.31-33: warning: unused value: \$3 4033 g: INT | INT { \$<integer>\$; } INT { \$<integer>\$; } INT { }; 4034 ^^^ 4035 input.y:17.35-50: warning: unused value: \$4 4036 g: INT | INT { \$<integer>\$; } INT { \$<integer>\$; } INT { }; 4037 ^^^^^^^^^^^^^^^^ 4038 input.y:17.52-54: warning: unused value: \$5 4039 g: INT | INT { \$<integer>\$; } INT { \$<integer>\$; } INT { }; 4040 ^^^ 4041 input.y:18.10-72: warning: unset value: \$\$ 4042 h: INT | INT { \$<integer>\$; } INT { \$<integer>\$ = \$<integer>2; } INT { }; 4043 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 4044 input.y:18.10-12: warning: unused value: \$1 4045 h: INT | INT { \$<integer>\$; } INT { \$<integer>\$ = \$<integer>2; } INT { }; 4046 ^^^ 4047 input.y:18.31-33: warning: unused value: \$3 4048 h: INT | INT { \$<integer>\$; } INT { \$<integer>\$ = \$<integer>2; } INT { }; 4049 ^^^ 4050 input.y:18.35-64: warning: unused value: \$4 4051 h: INT | INT { \$<integer>\$; } INT { \$<integer>\$ = \$<integer>2; } INT { }; 4052 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 4053 input.y:18.66-68: warning: unused value: \$5 4054 h: INT | INT { \$<integer>\$; } INT { \$<integer>\$ = \$<integer>2; } INT { }; 4055 ^^^ 4056 input.y:20.18-37: warning: unused value: \$3 4057 j: INT | INT INT { \$<integer>\$ = 1; } { \$\$ = \$1 + \$2; }; 4058 ^^^^^^^^^^^^^^^^^^^^ 4059 input.y:21.10-68: warning: unset value: \$\$ 4060 k: INT | INT INT { \$<integer>\$; } { \$<integer>\$ = \$<integer>3; } { }; 4061 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 4062 input.y:21.10-12: warning: unused value: \$1 4063 k: INT | INT INT { \$<integer>\$; } { \$<integer>\$ = \$<integer>3; } { }; 4064 ^^^ 4065 input.y:21.14-16: warning: unused value: \$2 4066 k: INT | INT INT { \$<integer>\$; } { \$<integer>\$ = \$<integer>3; } { }; 4067 ^^^ 4068 input.y:21.35-64: warning: unused value: \$4 4069 k: INT | INT INT { \$<integer>\$; } { \$<integer>\$ = \$<integer>3; } { }; 4070 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 4071 " | \ 4072 $at_diff - "$at_stderr" || at_failed=: 4073 at_fn_diff_devnull "$at_stdout" || at_failed=: 4074 at_fn_check_status 0 $at_status "$at_srcdir/input.at:297" 4075 $at_failed && at_fn_log_failure 4076 $at_traceon; } 4077 4078 # Defining POSIXLY_CORRECT causes bison to complain if options are 4079 # added after the grammar file name, so skip these checks in that 4080 # case. 4081 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 4082 at_save_special_files 4083 4084 # To avoid expanding it repeatedly, store specified stdout. 4085 : >expout 4086 4087 # Run with -Werror. 4088 { set +x 4089 $as_echo "$at_srcdir/input.at:297: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y -Werror" 4090 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y -Werror" "input.at:297" 4091 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y -Werror 4092 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4093 at_status=$? at_failed=false 4094 $at_check_filter 4095 echo stderr:; tee stderr <"$at_stderr" 4096 $at_diff expout "$at_stdout" || at_failed=: 4097 at_fn_check_status 1 $at_status "$at_srcdir/input.at:297" 4098 $at_failed && at_fn_log_failure 4099 $at_traceon; } 4100 4101 4102 # Build expected stderr up to and including the "warnings being 4103 # treated as errors" message. 4104 cat >at-bison-check-warnings <<'_ATEOF' 4105 input.y:11.10-32: warning: unset value: $$ 4106 a: INT | INT { } INT { } INT { }; 4107 ^^^^^^^^^^^^^^^^^^^^^^^ 4108 input.y:11.10-12: warning: unused value: $1 4109 a: INT | INT { } INT { } INT { }; 4110 ^^^ 4111 input.y:11.18-20: warning: unused value: $3 4112 a: INT | INT { } INT { } INT { }; 4113 ^^^ 4114 input.y:11.26-28: warning: unused value: $5 4115 a: INT | INT { } INT { } INT { }; 4116 ^^^ 4117 input.y:12.9: warning: empty rule for typed nonterminal, and no action 4118 b: INT | /* empty */; 4119 ^ 4120 input.y:13.14-20: warning: unset value: $$ 4121 c: INT | INT { $1; } INT { $<integer>2; } INT { $<integer>4; }; 4122 ^^^^^^^ 4123 input.y:13.26-41: warning: unset value: $$ 4124 c: INT | INT { $1; } INT { $<integer>2; } INT { $<integer>4; }; 4125 ^^^^^^^^^^^^^^^^ 4126 input.y:13.10-62: warning: unset value: $$ 4127 c: INT | INT { $1; } INT { $<integer>2; } INT { $<integer>4; }; 4128 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 4129 input.y:13.22-24: warning: unused value: $3 4130 c: INT | INT { $1; } INT { $<integer>2; } INT { $<integer>4; }; 4131 ^^^ 4132 input.y:13.43-45: warning: unused value: $5 4133 c: INT | INT { $1; } INT { $<integer>2; } INT { $<integer>4; }; 4134 ^^^ 4135 input.y:14.14-16: warning: unset value: $$ 4136 d: INT | INT { } INT { $1; } INT { $<integer>2; }; 4137 ^^^ 4138 input.y:14.10-49: warning: unset value: $$ 4139 d: INT | INT { } INT { $1; } INT { $<integer>2; }; 4140 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 4141 input.y:14.18-20: warning: unused value: $3 4142 d: INT | INT { } INT { $1; } INT { $<integer>2; }; 4143 ^^^ 4144 input.y:14.30-32: warning: unused value: $5 4145 d: INT | INT { } INT { $1; } INT { $<integer>2; }; 4146 ^^^ 4147 input.y:15.10-37: warning: unset value: $$ 4148 e: INT | INT { } INT { } INT { $1; }; 4149 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 4150 input.y:15.18-20: warning: unused value: $3 4151 e: INT | INT { } INT { } INT { $1; }; 4152 ^^^ 4153 input.y:15.27-29: warning: unused value: $5 4154 e: INT | INT { } INT { } INT { $1; }; 4155 ^^^ 4156 input.y:17.10-58: warning: unset value: $$ 4157 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 4158 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 4159 input.y:17.10-12: warning: unused value: $1 4160 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 4161 ^^^ 4162 input.y:17.14-29: warning: unused value: $2 4163 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 4164 ^^^^^^^^^^^^^^^^ 4165 input.y:17.31-33: warning: unused value: $3 4166 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 4167 ^^^ 4168 input.y:17.35-50: warning: unused value: $4 4169 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 4170 ^^^^^^^^^^^^^^^^ 4171 input.y:17.52-54: warning: unused value: $5 4172 g: INT | INT { $<integer>$; } INT { $<integer>$; } INT { }; 4173 ^^^ 4174 input.y:18.10-72: warning: unset value: $$ 4175 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 4176 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 4177 input.y:18.10-12: warning: unused value: $1 4178 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 4179 ^^^ 4180 input.y:18.31-33: warning: unused value: $3 4181 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 4182 ^^^ 4183 input.y:18.35-64: warning: unused value: $4 4184 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 4185 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 4186 input.y:18.66-68: warning: unused value: $5 4187 h: INT | INT { $<integer>$; } INT { $<integer>$ = $<integer>2; } INT { }; 4188 ^^^ 4189 input.y:20.18-37: warning: unused value: $3 4190 j: INT | INT INT { $<integer>$ = 1; } { $$ = $1 + $2; }; 4191 ^^^^^^^^^^^^^^^^^^^^ 4192 input.y:21.10-68: warning: unset value: $$ 4193 k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { }; 4194 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 4195 input.y:21.10-12: warning: unused value: $1 4196 k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { }; 4197 ^^^ 4198 input.y:21.14-16: warning: unused value: $2 4199 k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { }; 4200 ^^^ 4201 input.y:21.35-64: warning: unused value: $4 4202 k: INT | INT INT { $<integer>$; } { $<integer>$ = $<integer>3; } { }; 4203 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 4204 _ATEOF 4205 4206 at_bison_check_first=`sed -n \ 4207 '/: warning: /{=;q;}' at-bison-check-warnings` 4208 : ${at_bison_check_first:=1} 4209 at_bison_check_first_tmp=`sed -n \ 4210 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 4211 : ${at_bison_check_first_tmp:=1} 4212 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 4213 at_bison_check_first=$at_bison_check_first_tmp 4214 fi 4215 if test $at_bison_check_first -gt 1; then 4216 sed -n "1,`expr $at_bison_check_first - 1`"p \ 4217 at-bison-check-warnings > experr 4218 fi 4219 echo 'bison: warnings being treated as errors' >> experr 4220 4221 # Finish building expected stderr and check. Unlike warnings, 4222 # complaints cause bison to exit early. Thus, with -Werror, bison 4223 # does not necessarily report all warnings that it does without 4224 # -Werror, but it at least reports one. 4225 at_bison_check_last=`sed -n '$=' stderr` 4226 : ${at_bison_check_last:=1} 4227 at_bison_check_last=`expr $at_bison_check_last - 1` 4228 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 4229 at-bison-check-warnings >> experr 4230 { set +x 4231 $as_echo "$at_srcdir/input.at:297: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 4232 stderr 1>&2" 4233 at_fn_check_prepare_notrace 'an embedded newline' "input.at:297" 4234 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 4235 stderr 1>&2 4236 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4237 at_status=$? at_failed=false 4238 $at_check_filter 4239 $at_diff experr "$at_stderr" || at_failed=: 4240 at_fn_diff_devnull "$at_stdout" || at_failed=: 4241 at_fn_check_status 0 $at_status "$at_srcdir/input.at:297" 4242 $at_failed && at_fn_log_failure 4243 $at_traceon; } 4244 4245 4246 # Now check --warnings=error. 4247 cp stderr experr 4248 { set +x 4249 $as_echo "$at_srcdir/input.at:297: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y --warnings=error" 4250 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y --warnings=error" "input.at:297" 4251 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y --warnings=error 4252 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4253 at_status=$? at_failed=false 4254 $at_check_filter 4255 $at_diff experr "$at_stderr" || at_failed=: 4256 $at_diff expout "$at_stdout" || at_failed=: 4257 at_fn_check_status 1 $at_status "$at_srcdir/input.at:297" 4258 $at_failed && at_fn_log_failure 4259 $at_traceon; } 4260 4261 4262 # Now check -Wnone and --warnings=none by making sure that 4263 # -Werror doesn't change the exit status when -Wnone or 4264 # --warnings=none is specified. 4265 { set +x 4266 $as_echo "$at_srcdir/input.at:297: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y -Wnone -Werror" 4267 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y -Wnone -Werror" "input.at:297" 4268 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y -Wnone -Werror 4269 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4270 at_status=$? at_failed=false 4271 $at_check_filter 4272 at_fn_diff_devnull "$at_stderr" || at_failed=: 4273 $at_diff expout "$at_stdout" || at_failed=: 4274 at_fn_check_status 0 $at_status "$at_srcdir/input.at:297" 4275 $at_failed && at_fn_log_failure 4276 $at_traceon; } 4277 4278 { set +x 4279 $as_echo "$at_srcdir/input.at:297: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y --warnings=none -Werror" 4280 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y --warnings=none -Werror" "input.at:297" 4281 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --warnings=midrule-values -fcaret input.y --warnings=none -Werror 4282 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4283 at_status=$? at_failed=false 4284 $at_check_filter 4285 at_fn_diff_devnull "$at_stderr" || at_failed=: 4286 $at_diff expout "$at_stdout" || at_failed=: 4287 at_fn_check_status 0 $at_status "$at_srcdir/input.at:297" 4288 $at_failed && at_fn_log_failure 4289 $at_traceon; } 4290 4291 4292 at_restore_special_files 4293 fi 4294 4295 set +x 4296 $at_times_p && times >"$at_times_file" 4297 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 4298 read at_status <"$at_status_file" 4299 #AT_STOP_6 4300 #AT_START_7 4301 at_fn_group_banner 7 'input.at:305' \ 4302 "Default %printer and %destructor redeclared" " " 1 4303 at_xfail=no 4304 ( 4305 $as_echo "7. $at_setup_line: testing $at_desc ..." 4306 $at_traceon 4307 4308 4309 cat >input.y <<'_ATEOF' 4310 %destructor { destroy ($$); } <*> <*> 4311 %printer { print ($$); } <*> <*> 4312 4313 %destructor { destroy ($$); } <*> 4314 %printer { print ($$); } <*> 4315 4316 %destructor { destroy ($$); } <> <> 4317 %printer { print ($$); } <> <> 4318 4319 %destructor { destroy ($$); } <> 4320 %printer { print ($$); } <> 4321 4322 %% 4323 4324 start: ; 4325 4326 %destructor { destroy ($$); } <*>; 4327 %printer { print ($$); } <*>; 4328 4329 %destructor { destroy ($$); } <>; 4330 %printer { print ($$); } <>; 4331 _ATEOF 4332 4333 4334 4335 { set +x 4336 $as_echo "$at_srcdir/input.at:331: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 4337 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:331" 4338 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 4339 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4340 at_status=$? at_failed=false 4341 $at_check_filter 4342 echo >>"$at_stderr"; $as_echo "input.y:1.13-29: error: redeclaration for default tagged %destructor 4343 input.y:1.13-29: previous declaration 4344 input.y:2.10-24: error: redeclaration for default tagged %printer 4345 input.y:2.10-24: previous declaration 4346 input.y:4.13-29: error: redeclaration for default tagged %destructor 4347 input.y:1.13-29: previous declaration 4348 input.y:5.10-24: error: redeclaration for default tagged %printer 4349 input.y:2.10-24: previous declaration 4350 input.y:7.13-29: error: redeclaration for default tagless %destructor 4351 input.y:7.13-29: previous declaration 4352 input.y:8.10-24: error: redeclaration for default tagless %printer 4353 input.y:8.10-24: previous declaration 4354 input.y:10.13-29: error: redeclaration for default tagless %destructor 4355 input.y:7.13-29: previous declaration 4356 input.y:11.10-24: error: redeclaration for default tagless %printer 4357 input.y:8.10-24: previous declaration 4358 input.y:17.13-29: error: redeclaration for default tagged %destructor 4359 input.y:4.13-29: previous declaration 4360 input.y:18.10-24: error: redeclaration for default tagged %printer 4361 input.y:5.10-24: previous declaration 4362 input.y:20.13-29: error: redeclaration for default tagless %destructor 4363 input.y:10.13-29: previous declaration 4364 input.y:21.10-24: error: redeclaration for default tagless %printer 4365 input.y:11.10-24: previous declaration 4366 " | \ 4367 $at_diff - "$at_stderr" || at_failed=: 4368 at_fn_diff_devnull "$at_stdout" || at_failed=: 4369 at_fn_check_status 1 $at_status "$at_srcdir/input.at:331" 4370 $at_failed && at_fn_log_failure 4371 $at_traceon; } 4372 4373 4374 4375 set +x 4376 $at_times_p && times >"$at_times_file" 4377 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 4378 read at_status <"$at_status_file" 4379 #AT_STOP_7 4380 #AT_START_8 4381 at_fn_group_banner 8 'input.at:365' \ 4382 "Per-type %printer and %destructor redeclared" " " 1 4383 at_xfail=no 4384 ( 4385 $as_echo "8. $at_setup_line: testing $at_desc ..." 4386 $at_traceon 4387 4388 4389 cat >input.y <<'_ATEOF' 4390 %destructor { destroy ($$); } <field1> <field2> 4391 %printer { print ($$); } <field1> <field2> 4392 4393 %destructor { destroy ($$); } <field1> <field1> 4394 %printer { print ($$); } <field2> <field2> 4395 4396 %% 4397 4398 start: ; 4399 4400 %destructor { destroy ($$); } <field2> <field1>; 4401 %printer { print ($$); } <field2> <field1>; 4402 _ATEOF 4403 4404 4405 4406 { set +x 4407 $as_echo "$at_srcdir/input.at:382: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 4408 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:382" 4409 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 4410 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4411 at_status=$? at_failed=false 4412 $at_check_filter 4413 echo >>"$at_stderr"; $as_echo "input.y:4.13-29: error: %destructor redeclaration for <field1> 4414 input.y:1.13-29: previous declaration 4415 input.y:4.13-29: error: %destructor redeclaration for <field1> 4416 input.y:4.13-29: previous declaration 4417 input.y:5.10-24: error: %printer redeclaration for <field2> 4418 input.y:2.10-24: previous declaration 4419 input.y:5.10-24: error: %printer redeclaration for <field2> 4420 input.y:5.10-24: previous declaration 4421 input.y:11.13-29: error: %destructor redeclaration for <field1> 4422 input.y:4.13-29: previous declaration 4423 input.y:11.13-29: error: %destructor redeclaration for <field2> 4424 input.y:1.13-29: previous declaration 4425 input.y:12.10-24: error: %printer redeclaration for <field1> 4426 input.y:2.10-24: previous declaration 4427 input.y:12.10-24: error: %printer redeclaration for <field2> 4428 input.y:5.10-24: previous declaration 4429 " | \ 4430 $at_diff - "$at_stderr" || at_failed=: 4431 at_fn_diff_devnull "$at_stdout" || at_failed=: 4432 at_fn_check_status 1 $at_status "$at_srcdir/input.at:382" 4433 $at_failed && at_fn_log_failure 4434 $at_traceon; } 4435 4436 4437 4438 set +x 4439 $at_times_p && times >"$at_times_file" 4440 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 4441 read at_status <"$at_status_file" 4442 #AT_STOP_8 4443 #AT_START_9 4444 at_fn_group_banner 9 'input.at:408' \ 4445 "Unused values with default %destructor" " " 1 4446 at_xfail=no 4447 ( 4448 $as_echo "9. $at_setup_line: testing $at_desc ..." 4449 $at_traceon 4450 4451 4452 cat >input.y <<'_ATEOF' 4453 %destructor { destroy ($$); } <> 4454 %type <tag> tagged 4455 4456 %% 4457 4458 start: end end tagged tagged { $<tag>1; $3; } ; 4459 end: { } ; 4460 tagged: { } ; 4461 _ATEOF 4462 4463 4464 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 4465 at_save_special_files 4466 mkdir xml-tests 4467 # Don't combine these Bison invocations since we want to be sure that 4468 # --report=all isn't required to get the full XML file. 4469 { set +x 4470 $as_echo "$at_srcdir/input.at:421: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 4471 --graph=xml-tests/test.dot input.y" 4472 at_fn_check_prepare_notrace 'an embedded newline' "input.at:421" 4473 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 4474 --graph=xml-tests/test.dot input.y 4475 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4476 at_status=$? at_failed=false 4477 $at_check_filter 4478 echo stderr:; cat "$at_stderr" 4479 echo stdout:; cat "$at_stdout" 4480 at_fn_check_status 0 $at_status "$at_srcdir/input.at:421" 4481 $at_failed && at_fn_log_failure 4482 $at_traceon; } 4483 4484 { set +x 4485 $as_echo "$at_srcdir/input.at:421: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y" 4486 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y" "input.at:421" 4487 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y 4488 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4489 at_status=$? at_failed=false 4490 $at_check_filter 4491 echo stderr:; cat "$at_stderr" 4492 echo stdout:; cat "$at_stdout" 4493 at_fn_check_status 0 $at_status "$at_srcdir/input.at:421" 4494 $at_failed && at_fn_log_failure 4495 $at_traceon; } 4496 4497 cp xml-tests/test.output expout 4498 { set +x 4499 $as_echo "$at_srcdir/input.at:421: \$XSLTPROC \\ 4500 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 4501 xml-tests/test.xml" 4502 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:421" 4503 ( $at_check_trace; $XSLTPROC \ 4504 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 4505 xml-tests/test.xml 4506 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4507 at_status=$? at_failed=false 4508 $at_check_filter 4509 at_fn_diff_devnull "$at_stderr" || at_failed=: 4510 $at_diff expout "$at_stdout" || at_failed=: 4511 at_fn_check_status 0 $at_status "$at_srcdir/input.at:421" 4512 $at_failed && at_fn_log_failure 4513 $at_traceon; } 4514 4515 sort xml-tests/test.dot > expout 4516 { set +x 4517 $as_echo "$at_srcdir/input.at:421: \$XSLTPROC \\ 4518 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 4519 xml-tests/test.xml | sort" 4520 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:421" 4521 ( $at_check_trace; $XSLTPROC \ 4522 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 4523 xml-tests/test.xml | sort 4524 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4525 at_status=$? at_failed=false 4526 $at_check_filter 4527 at_fn_diff_devnull "$at_stderr" || at_failed=: 4528 $at_diff expout "$at_stdout" || at_failed=: 4529 at_fn_check_status 0 $at_status "$at_srcdir/input.at:421" 4530 $at_failed && at_fn_log_failure 4531 $at_traceon; } 4532 4533 rm -rf xml-tests expout 4534 at_restore_special_files 4535 fi 4536 { set +x 4537 $as_echo "$at_srcdir/input.at:421: bison input.y" 4538 at_fn_check_prepare_trace "input.at:421" 4539 ( $at_check_trace; bison input.y 4540 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4541 at_status=$? at_failed=false 4542 $at_check_filter 4543 echo >>"$at_stderr"; $as_echo "input.y:6.8-45: warning: unset value: \$\$ 4544 input.y:6.12-14: warning: unused value: \$2 4545 input.y:7.6-8: warning: unset value: \$\$ 4546 " | \ 4547 $at_diff - "$at_stderr" || at_failed=: 4548 at_fn_diff_devnull "$at_stdout" || at_failed=: 4549 at_fn_check_status 0 $at_status "$at_srcdir/input.at:421" 4550 $at_failed && at_fn_log_failure 4551 $at_traceon; } 4552 4553 # Defining POSIXLY_CORRECT causes bison to complain if options are 4554 # added after the grammar file name, so skip these checks in that 4555 # case. 4556 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 4557 at_save_special_files 4558 4559 # To avoid expanding it repeatedly, store specified stdout. 4560 : >expout 4561 4562 # Run with -Werror. 4563 { set +x 4564 $as_echo "$at_srcdir/input.at:421: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Werror" 4565 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Werror" "input.at:421" 4566 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y -Werror 4567 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4568 at_status=$? at_failed=false 4569 $at_check_filter 4570 echo stderr:; tee stderr <"$at_stderr" 4571 $at_diff expout "$at_stdout" || at_failed=: 4572 at_fn_check_status 1 $at_status "$at_srcdir/input.at:421" 4573 $at_failed && at_fn_log_failure 4574 $at_traceon; } 4575 4576 4577 # Build expected stderr up to and including the "warnings being 4578 # treated as errors" message. 4579 cat >at-bison-check-warnings <<'_ATEOF' 4580 input.y:6.8-45: warning: unset value: $$ 4581 input.y:6.12-14: warning: unused value: $2 4582 input.y:7.6-8: warning: unset value: $$ 4583 _ATEOF 4584 4585 at_bison_check_first=`sed -n \ 4586 '/: warning: /{=;q;}' at-bison-check-warnings` 4587 : ${at_bison_check_first:=1} 4588 at_bison_check_first_tmp=`sed -n \ 4589 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 4590 : ${at_bison_check_first_tmp:=1} 4591 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 4592 at_bison_check_first=$at_bison_check_first_tmp 4593 fi 4594 if test $at_bison_check_first -gt 1; then 4595 sed -n "1,`expr $at_bison_check_first - 1`"p \ 4596 at-bison-check-warnings > experr 4597 fi 4598 echo 'bison: warnings being treated as errors' >> experr 4599 4600 # Finish building expected stderr and check. Unlike warnings, 4601 # complaints cause bison to exit early. Thus, with -Werror, bison 4602 # does not necessarily report all warnings that it does without 4603 # -Werror, but it at least reports one. 4604 at_bison_check_last=`sed -n '$=' stderr` 4605 : ${at_bison_check_last:=1} 4606 at_bison_check_last=`expr $at_bison_check_last - 1` 4607 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 4608 at-bison-check-warnings >> experr 4609 { set +x 4610 $as_echo "$at_srcdir/input.at:421: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 4611 stderr 1>&2" 4612 at_fn_check_prepare_notrace 'an embedded newline' "input.at:421" 4613 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 4614 stderr 1>&2 4615 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4616 at_status=$? at_failed=false 4617 $at_check_filter 4618 $at_diff experr "$at_stderr" || at_failed=: 4619 at_fn_diff_devnull "$at_stdout" || at_failed=: 4620 at_fn_check_status 0 $at_status "$at_srcdir/input.at:421" 4621 $at_failed && at_fn_log_failure 4622 $at_traceon; } 4623 4624 4625 # Now check --warnings=error. 4626 cp stderr experr 4627 { set +x 4628 $as_echo "$at_srcdir/input.at:421: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=error" 4629 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=error" "input.at:421" 4630 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y --warnings=error 4631 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4632 at_status=$? at_failed=false 4633 $at_check_filter 4634 $at_diff experr "$at_stderr" || at_failed=: 4635 $at_diff expout "$at_stdout" || at_failed=: 4636 at_fn_check_status 1 $at_status "$at_srcdir/input.at:421" 4637 $at_failed && at_fn_log_failure 4638 $at_traceon; } 4639 4640 4641 # Now check -Wnone and --warnings=none by making sure that 4642 # -Werror doesn't change the exit status when -Wnone or 4643 # --warnings=none is specified. 4644 { set +x 4645 $as_echo "$at_srcdir/input.at:421: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Wnone -Werror" 4646 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Wnone -Werror" "input.at:421" 4647 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y -Wnone -Werror 4648 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4649 at_status=$? at_failed=false 4650 $at_check_filter 4651 at_fn_diff_devnull "$at_stderr" || at_failed=: 4652 $at_diff expout "$at_stdout" || at_failed=: 4653 at_fn_check_status 0 $at_status "$at_srcdir/input.at:421" 4654 $at_failed && at_fn_log_failure 4655 $at_traceon; } 4656 4657 { set +x 4658 $as_echo "$at_srcdir/input.at:421: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror" 4659 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror" "input.at:421" 4660 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror 4661 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4662 at_status=$? at_failed=false 4663 $at_check_filter 4664 at_fn_diff_devnull "$at_stderr" || at_failed=: 4665 $at_diff expout "$at_stdout" || at_failed=: 4666 at_fn_check_status 0 $at_status "$at_srcdir/input.at:421" 4667 $at_failed && at_fn_log_failure 4668 $at_traceon; } 4669 4670 4671 at_restore_special_files 4672 fi 4673 4674 cat >input.y <<'_ATEOF' 4675 %destructor { destroy ($$); } <*> 4676 %type <tag> tagged 4677 4678 %% 4679 4680 start: end end tagged tagged { $<tag>1; $3; } ; 4681 end: { } ; 4682 tagged: { } ; 4683 _ATEOF 4684 4685 4686 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 4687 at_save_special_files 4688 mkdir xml-tests 4689 # Don't combine these Bison invocations since we want to be sure that 4690 # --report=all isn't required to get the full XML file. 4691 { set +x 4692 $as_echo "$at_srcdir/input.at:438: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 4693 --graph=xml-tests/test.dot input.y" 4694 at_fn_check_prepare_notrace 'an embedded newline' "input.at:438" 4695 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 4696 --graph=xml-tests/test.dot input.y 4697 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4698 at_status=$? at_failed=false 4699 $at_check_filter 4700 echo stderr:; cat "$at_stderr" 4701 echo stdout:; cat "$at_stdout" 4702 at_fn_check_status 0 $at_status "$at_srcdir/input.at:438" 4703 $at_failed && at_fn_log_failure 4704 $at_traceon; } 4705 4706 { set +x 4707 $as_echo "$at_srcdir/input.at:438: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y" 4708 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y" "input.at:438" 4709 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y 4710 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4711 at_status=$? at_failed=false 4712 $at_check_filter 4713 echo stderr:; cat "$at_stderr" 4714 echo stdout:; cat "$at_stdout" 4715 at_fn_check_status 0 $at_status "$at_srcdir/input.at:438" 4716 $at_failed && at_fn_log_failure 4717 $at_traceon; } 4718 4719 cp xml-tests/test.output expout 4720 { set +x 4721 $as_echo "$at_srcdir/input.at:438: \$XSLTPROC \\ 4722 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 4723 xml-tests/test.xml" 4724 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:438" 4725 ( $at_check_trace; $XSLTPROC \ 4726 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 4727 xml-tests/test.xml 4728 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4729 at_status=$? at_failed=false 4730 $at_check_filter 4731 at_fn_diff_devnull "$at_stderr" || at_failed=: 4732 $at_diff expout "$at_stdout" || at_failed=: 4733 at_fn_check_status 0 $at_status "$at_srcdir/input.at:438" 4734 $at_failed && at_fn_log_failure 4735 $at_traceon; } 4736 4737 sort xml-tests/test.dot > expout 4738 { set +x 4739 $as_echo "$at_srcdir/input.at:438: \$XSLTPROC \\ 4740 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 4741 xml-tests/test.xml | sort" 4742 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:438" 4743 ( $at_check_trace; $XSLTPROC \ 4744 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 4745 xml-tests/test.xml | sort 4746 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4747 at_status=$? at_failed=false 4748 $at_check_filter 4749 at_fn_diff_devnull "$at_stderr" || at_failed=: 4750 $at_diff expout "$at_stdout" || at_failed=: 4751 at_fn_check_status 0 $at_status "$at_srcdir/input.at:438" 4752 $at_failed && at_fn_log_failure 4753 $at_traceon; } 4754 4755 rm -rf xml-tests expout 4756 at_restore_special_files 4757 fi 4758 { set +x 4759 $as_echo "$at_srcdir/input.at:438: bison input.y" 4760 at_fn_check_prepare_trace "input.at:438" 4761 ( $at_check_trace; bison input.y 4762 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4763 at_status=$? at_failed=false 4764 $at_check_filter 4765 echo >>"$at_stderr"; $as_echo "input.y:6.23-28: warning: unused value: \$4 4766 input.y:8.9-11: warning: unset value: \$\$ 4767 " | \ 4768 $at_diff - "$at_stderr" || at_failed=: 4769 at_fn_diff_devnull "$at_stdout" || at_failed=: 4770 at_fn_check_status 0 $at_status "$at_srcdir/input.at:438" 4771 $at_failed && at_fn_log_failure 4772 $at_traceon; } 4773 4774 # Defining POSIXLY_CORRECT causes bison to complain if options are 4775 # added after the grammar file name, so skip these checks in that 4776 # case. 4777 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 4778 at_save_special_files 4779 4780 # To avoid expanding it repeatedly, store specified stdout. 4781 : >expout 4782 4783 # Run with -Werror. 4784 { set +x 4785 $as_echo "$at_srcdir/input.at:438: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Werror" 4786 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Werror" "input.at:438" 4787 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y -Werror 4788 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4789 at_status=$? at_failed=false 4790 $at_check_filter 4791 echo stderr:; tee stderr <"$at_stderr" 4792 $at_diff expout "$at_stdout" || at_failed=: 4793 at_fn_check_status 1 $at_status "$at_srcdir/input.at:438" 4794 $at_failed && at_fn_log_failure 4795 $at_traceon; } 4796 4797 4798 # Build expected stderr up to and including the "warnings being 4799 # treated as errors" message. 4800 cat >at-bison-check-warnings <<'_ATEOF' 4801 input.y:6.23-28: warning: unused value: $4 4802 input.y:8.9-11: warning: unset value: $$ 4803 _ATEOF 4804 4805 at_bison_check_first=`sed -n \ 4806 '/: warning: /{=;q;}' at-bison-check-warnings` 4807 : ${at_bison_check_first:=1} 4808 at_bison_check_first_tmp=`sed -n \ 4809 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 4810 : ${at_bison_check_first_tmp:=1} 4811 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 4812 at_bison_check_first=$at_bison_check_first_tmp 4813 fi 4814 if test $at_bison_check_first -gt 1; then 4815 sed -n "1,`expr $at_bison_check_first - 1`"p \ 4816 at-bison-check-warnings > experr 4817 fi 4818 echo 'bison: warnings being treated as errors' >> experr 4819 4820 # Finish building expected stderr and check. Unlike warnings, 4821 # complaints cause bison to exit early. Thus, with -Werror, bison 4822 # does not necessarily report all warnings that it does without 4823 # -Werror, but it at least reports one. 4824 at_bison_check_last=`sed -n '$=' stderr` 4825 : ${at_bison_check_last:=1} 4826 at_bison_check_last=`expr $at_bison_check_last - 1` 4827 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 4828 at-bison-check-warnings >> experr 4829 { set +x 4830 $as_echo "$at_srcdir/input.at:438: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 4831 stderr 1>&2" 4832 at_fn_check_prepare_notrace 'an embedded newline' "input.at:438" 4833 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 4834 stderr 1>&2 4835 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4836 at_status=$? at_failed=false 4837 $at_check_filter 4838 $at_diff experr "$at_stderr" || at_failed=: 4839 at_fn_diff_devnull "$at_stdout" || at_failed=: 4840 at_fn_check_status 0 $at_status "$at_srcdir/input.at:438" 4841 $at_failed && at_fn_log_failure 4842 $at_traceon; } 4843 4844 4845 # Now check --warnings=error. 4846 cp stderr experr 4847 { set +x 4848 $as_echo "$at_srcdir/input.at:438: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=error" 4849 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=error" "input.at:438" 4850 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y --warnings=error 4851 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4852 at_status=$? at_failed=false 4853 $at_check_filter 4854 $at_diff experr "$at_stderr" || at_failed=: 4855 $at_diff expout "$at_stdout" || at_failed=: 4856 at_fn_check_status 1 $at_status "$at_srcdir/input.at:438" 4857 $at_failed && at_fn_log_failure 4858 $at_traceon; } 4859 4860 4861 # Now check -Wnone and --warnings=none by making sure that 4862 # -Werror doesn't change the exit status when -Wnone or 4863 # --warnings=none is specified. 4864 { set +x 4865 $as_echo "$at_srcdir/input.at:438: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Wnone -Werror" 4866 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Wnone -Werror" "input.at:438" 4867 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y -Wnone -Werror 4868 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4869 at_status=$? at_failed=false 4870 $at_check_filter 4871 at_fn_diff_devnull "$at_stderr" || at_failed=: 4872 $at_diff expout "$at_stdout" || at_failed=: 4873 at_fn_check_status 0 $at_status "$at_srcdir/input.at:438" 4874 $at_failed && at_fn_log_failure 4875 $at_traceon; } 4876 4877 { set +x 4878 $as_echo "$at_srcdir/input.at:438: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror" 4879 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror" "input.at:438" 4880 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror 4881 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4882 at_status=$? at_failed=false 4883 $at_check_filter 4884 at_fn_diff_devnull "$at_stderr" || at_failed=: 4885 $at_diff expout "$at_stdout" || at_failed=: 4886 at_fn_check_status 0 $at_status "$at_srcdir/input.at:438" 4887 $at_failed && at_fn_log_failure 4888 $at_traceon; } 4889 4890 4891 at_restore_special_files 4892 fi 4893 4894 set +x 4895 $at_times_p && times >"$at_times_file" 4896 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 4897 read at_status <"$at_status_file" 4898 #AT_STOP_9 4899 #AT_START_10 4900 at_fn_group_banner 10 'input.at:450' \ 4901 "Unused values with per-type %destructor" " " 1 4902 at_xfail=no 4903 ( 4904 $as_echo "10. $at_setup_line: testing $at_desc ..." 4905 $at_traceon 4906 4907 4908 cat >input.y <<'_ATEOF' 4909 %destructor { destroy ($$); } <field1> 4910 %type <field1> start end 4911 4912 %% 4913 4914 start: end end { $1; } ; 4915 end: { } ; 4916 _ATEOF 4917 4918 4919 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 4920 at_save_special_files 4921 mkdir xml-tests 4922 # Don't combine these Bison invocations since we want to be sure that 4923 # --report=all isn't required to get the full XML file. 4924 { set +x 4925 $as_echo "$at_srcdir/input.at:462: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 4926 --graph=xml-tests/test.dot input.y" 4927 at_fn_check_prepare_notrace 'an embedded newline' "input.at:462" 4928 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 4929 --graph=xml-tests/test.dot input.y 4930 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4931 at_status=$? at_failed=false 4932 $at_check_filter 4933 echo stderr:; cat "$at_stderr" 4934 echo stdout:; cat "$at_stdout" 4935 at_fn_check_status 0 $at_status "$at_srcdir/input.at:462" 4936 $at_failed && at_fn_log_failure 4937 $at_traceon; } 4938 4939 { set +x 4940 $as_echo "$at_srcdir/input.at:462: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y" 4941 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y" "input.at:462" 4942 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y 4943 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4944 at_status=$? at_failed=false 4945 $at_check_filter 4946 echo stderr:; cat "$at_stderr" 4947 echo stdout:; cat "$at_stdout" 4948 at_fn_check_status 0 $at_status "$at_srcdir/input.at:462" 4949 $at_failed && at_fn_log_failure 4950 $at_traceon; } 4951 4952 cp xml-tests/test.output expout 4953 { set +x 4954 $as_echo "$at_srcdir/input.at:462: \$XSLTPROC \\ 4955 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 4956 xml-tests/test.xml" 4957 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:462" 4958 ( $at_check_trace; $XSLTPROC \ 4959 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 4960 xml-tests/test.xml 4961 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4962 at_status=$? at_failed=false 4963 $at_check_filter 4964 at_fn_diff_devnull "$at_stderr" || at_failed=: 4965 $at_diff expout "$at_stdout" || at_failed=: 4966 at_fn_check_status 0 $at_status "$at_srcdir/input.at:462" 4967 $at_failed && at_fn_log_failure 4968 $at_traceon; } 4969 4970 sort xml-tests/test.dot > expout 4971 { set +x 4972 $as_echo "$at_srcdir/input.at:462: \$XSLTPROC \\ 4973 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 4974 xml-tests/test.xml | sort" 4975 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:462" 4976 ( $at_check_trace; $XSLTPROC \ 4977 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 4978 xml-tests/test.xml | sort 4979 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4980 at_status=$? at_failed=false 4981 $at_check_filter 4982 at_fn_diff_devnull "$at_stderr" || at_failed=: 4983 $at_diff expout "$at_stdout" || at_failed=: 4984 at_fn_check_status 0 $at_status "$at_srcdir/input.at:462" 4985 $at_failed && at_fn_log_failure 4986 $at_traceon; } 4987 4988 rm -rf xml-tests expout 4989 at_restore_special_files 4990 fi 4991 { set +x 4992 $as_echo "$at_srcdir/input.at:462: bison input.y" 4993 at_fn_check_prepare_trace "input.at:462" 4994 ( $at_check_trace; bison input.y 4995 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 4996 at_status=$? at_failed=false 4997 $at_check_filter 4998 echo >>"$at_stderr"; $as_echo "input.y:6.8-22: warning: unset value: \$\$ 4999 input.y:6.12-14: warning: unused value: \$2 5000 input.y:7.6-8: warning: unset value: \$\$ 5001 " | \ 5002 $at_diff - "$at_stderr" || at_failed=: 5003 at_fn_diff_devnull "$at_stdout" || at_failed=: 5004 at_fn_check_status 0 $at_status "$at_srcdir/input.at:462" 5005 $at_failed && at_fn_log_failure 5006 $at_traceon; } 5007 5008 # Defining POSIXLY_CORRECT causes bison to complain if options are 5009 # added after the grammar file name, so skip these checks in that 5010 # case. 5011 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 5012 at_save_special_files 5013 5014 # To avoid expanding it repeatedly, store specified stdout. 5015 : >expout 5016 5017 # Run with -Werror. 5018 { set +x 5019 $as_echo "$at_srcdir/input.at:462: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Werror" 5020 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Werror" "input.at:462" 5021 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y -Werror 5022 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5023 at_status=$? at_failed=false 5024 $at_check_filter 5025 echo stderr:; tee stderr <"$at_stderr" 5026 $at_diff expout "$at_stdout" || at_failed=: 5027 at_fn_check_status 1 $at_status "$at_srcdir/input.at:462" 5028 $at_failed && at_fn_log_failure 5029 $at_traceon; } 5030 5031 5032 # Build expected stderr up to and including the "warnings being 5033 # treated as errors" message. 5034 cat >at-bison-check-warnings <<'_ATEOF' 5035 input.y:6.8-22: warning: unset value: $$ 5036 input.y:6.12-14: warning: unused value: $2 5037 input.y:7.6-8: warning: unset value: $$ 5038 _ATEOF 5039 5040 at_bison_check_first=`sed -n \ 5041 '/: warning: /{=;q;}' at-bison-check-warnings` 5042 : ${at_bison_check_first:=1} 5043 at_bison_check_first_tmp=`sed -n \ 5044 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 5045 : ${at_bison_check_first_tmp:=1} 5046 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 5047 at_bison_check_first=$at_bison_check_first_tmp 5048 fi 5049 if test $at_bison_check_first -gt 1; then 5050 sed -n "1,`expr $at_bison_check_first - 1`"p \ 5051 at-bison-check-warnings > experr 5052 fi 5053 echo 'bison: warnings being treated as errors' >> experr 5054 5055 # Finish building expected stderr and check. Unlike warnings, 5056 # complaints cause bison to exit early. Thus, with -Werror, bison 5057 # does not necessarily report all warnings that it does without 5058 # -Werror, but it at least reports one. 5059 at_bison_check_last=`sed -n '$=' stderr` 5060 : ${at_bison_check_last:=1} 5061 at_bison_check_last=`expr $at_bison_check_last - 1` 5062 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 5063 at-bison-check-warnings >> experr 5064 { set +x 5065 $as_echo "$at_srcdir/input.at:462: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 5066 stderr 1>&2" 5067 at_fn_check_prepare_notrace 'an embedded newline' "input.at:462" 5068 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 5069 stderr 1>&2 5070 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5071 at_status=$? at_failed=false 5072 $at_check_filter 5073 $at_diff experr "$at_stderr" || at_failed=: 5074 at_fn_diff_devnull "$at_stdout" || at_failed=: 5075 at_fn_check_status 0 $at_status "$at_srcdir/input.at:462" 5076 $at_failed && at_fn_log_failure 5077 $at_traceon; } 5078 5079 5080 # Now check --warnings=error. 5081 cp stderr experr 5082 { set +x 5083 $as_echo "$at_srcdir/input.at:462: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=error" 5084 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=error" "input.at:462" 5085 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y --warnings=error 5086 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5087 at_status=$? at_failed=false 5088 $at_check_filter 5089 $at_diff experr "$at_stderr" || at_failed=: 5090 $at_diff expout "$at_stdout" || at_failed=: 5091 at_fn_check_status 1 $at_status "$at_srcdir/input.at:462" 5092 $at_failed && at_fn_log_failure 5093 $at_traceon; } 5094 5095 5096 # Now check -Wnone and --warnings=none by making sure that 5097 # -Werror doesn't change the exit status when -Wnone or 5098 # --warnings=none is specified. 5099 { set +x 5100 $as_echo "$at_srcdir/input.at:462: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Wnone -Werror" 5101 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Wnone -Werror" "input.at:462" 5102 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y -Wnone -Werror 5103 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5104 at_status=$? at_failed=false 5105 $at_check_filter 5106 at_fn_diff_devnull "$at_stderr" || at_failed=: 5107 $at_diff expout "$at_stdout" || at_failed=: 5108 at_fn_check_status 0 $at_status "$at_srcdir/input.at:462" 5109 $at_failed && at_fn_log_failure 5110 $at_traceon; } 5111 5112 { set +x 5113 $as_echo "$at_srcdir/input.at:462: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror" 5114 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror" "input.at:462" 5115 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror 5116 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5117 at_status=$? at_failed=false 5118 $at_check_filter 5119 at_fn_diff_devnull "$at_stderr" || at_failed=: 5120 $at_diff expout "$at_stdout" || at_failed=: 5121 at_fn_check_status 0 $at_status "$at_srcdir/input.at:462" 5122 $at_failed && at_fn_log_failure 5123 $at_traceon; } 5124 5125 5126 at_restore_special_files 5127 fi 5128 5129 set +x 5130 $at_times_p && times >"$at_times_file" 5131 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 5132 read at_status <"$at_status_file" 5133 #AT_STOP_10 5134 #AT_START_11 5135 at_fn_group_banner 11 'input.at:475' \ 5136 "Incompatible Aliases" " " 1 5137 at_xfail=no 5138 ( 5139 $as_echo "11. $at_setup_line: testing $at_desc ..." 5140 $at_traceon 5141 5142 5143 cat >input.y <<'_ATEOF' 5144 %token foo "foo" 5145 5146 %type <bar> foo 5147 %printer {bar} foo 5148 %destructor {bar} foo 5149 %left foo 5150 5151 %type <baz> "foo" 5152 %printer {baz} "foo" 5153 %destructor {baz} "foo" 5154 %left "foo" 5155 5156 %% 5157 exp: foo; 5158 _ATEOF 5159 5160 5161 5162 { set +x 5163 $as_echo "$at_srcdir/input.at:494: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 5164 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:494" 5165 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 5166 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5167 at_status=$? at_failed=false 5168 $at_check_filter 5169 echo >>"$at_stderr"; $as_echo "input.y:8.7-11: error: %type redeclaration for foo 5170 input.y:3.7-11: previous declaration 5171 input.y:10.13-17: error: %destructor redeclaration for foo 5172 input.y:5.13-17: previous declaration 5173 input.y:9.10-14: error: %printer redeclaration for foo 5174 input.y:4.10-14: previous declaration 5175 input.y:11.1-5: error: %left redeclaration for foo 5176 input.y:6.1-5: previous declaration 5177 " | \ 5178 $at_diff - "$at_stderr" || at_failed=: 5179 at_fn_diff_devnull "$at_stdout" || at_failed=: 5180 at_fn_check_status 1 $at_status "$at_srcdir/input.at:494" 5181 $at_failed && at_fn_log_failure 5182 $at_traceon; } 5183 5184 5185 5186 set +x 5187 $at_times_p && times >"$at_times_file" 5188 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 5189 read at_status <"$at_status_file" 5190 #AT_STOP_11 5191 #AT_START_12 5192 at_fn_group_banner 12 'input.at:516' \ 5193 "Torturing the Scanner" " " 1 5194 at_xfail=no 5195 ( 5196 $as_echo "12. $at_setup_line: testing $at_desc ..." 5197 $at_traceon 5198 5199 5200 5201 : >input.y 5202 5203 { set +x 5204 $as_echo "$at_srcdir/input.at:520: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 5205 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:520" 5206 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 5207 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5208 at_status=$? at_failed=false 5209 $at_check_filter 5210 echo >>"$at_stderr"; $as_echo "input.y:1.1: error: syntax error, unexpected end of file 5211 " | \ 5212 $at_diff - "$at_stderr" || at_failed=: 5213 at_fn_diff_devnull "$at_stdout" || at_failed=: 5214 at_fn_check_status 1 $at_status "$at_srcdir/input.at:520" 5215 $at_failed && at_fn_log_failure 5216 $at_traceon; } 5217 5218 5219 5220 5221 cat >input.y <<'_ATEOF' 5222 {} 5223 _ATEOF 5224 5225 5226 { set +x 5227 $as_echo "$at_srcdir/input.at:528: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 5228 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:528" 5229 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 5230 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5231 at_status=$? at_failed=false 5232 $at_check_filter 5233 echo >>"$at_stderr"; $as_echo "input.y:1.1-2: error: syntax error, unexpected {...} 5234 " | \ 5235 $at_diff - "$at_stderr" || at_failed=: 5236 at_fn_diff_devnull "$at_stdout" || at_failed=: 5237 at_fn_check_status 1 $at_status "$at_srcdir/input.at:528" 5238 $at_failed && at_fn_log_failure 5239 $at_traceon; } 5240 5241 5242 5243 5244 cat >input.y <<'_ATEOF' 5245 %code top { 5246 #include <config.h> 5247 /* We don't need perfect functions for these tests. */ 5248 #undef malloc 5249 #undef memcmp 5250 #undef realloc 5251 } 5252 5253 %{ 5254 /* This is seen in GCC: a %{ and %} in middle of a comment. */ 5255 const char *foo = "So %{ and %} can be here too."; 5256 5257 #if 0 5258 /* These examples test Bison while not stressing C compilers too much. 5259 Many C compilers mishandle backslash-newlines, so this part of the 5260 test is inside "#if 0". The comment and string are written so that 5261 the "#endif" will be seen regardless of the C compiler bugs that we 5262 know about, namely: 5263 5264 HP C (as of late 2002) mishandles *\[newline]\[newline]/ within a 5265 comment. 5266 5267 The Apple Darwin compiler (as of late 2002) mishandles 5268 \\[newline]' within a character constant. 5269 5270 */ 5271 5272 /\ 5273 * A comment with backslash-newlines in it. %} *\ 5274 \ 5275 / 5276 /* { Close the above comment, if the C compiler mishandled it. */ 5277 5278 char str[] = "\\ 5279 " A string with backslash-newlines in it %{ %} \\ 5280 \ 5281 ""; 5282 5283 char apostrophe = '\''; 5284 #endif 5285 5286 #include <stdio.h> 5287 #include <stdlib.h> 5288 #include <assert.h> 5289 %} 5290 /* %{ and %} can be here too. */ 5291 5292 %{ 5293 /* Exercise pre-prologue dependency to %union. */ 5294 typedef int value; 5295 %} 5296 5297 /* Exercise M4 quoting: ']]', 0. */ 5298 5299 /* Also exercise %union. */ 5300 %union 5301 { 5302 value ival; /* A comment to exercise an old bug. */ 5303 }; 5304 5305 5306 /* Exercise post-prologue dependency to %union. */ 5307 %{ 5308 static YYSTYPE value_as_yystype (value val); 5309 5310 /* Exercise quotes in declarations. */ 5311 char quote[] = "]],"; 5312 %} 5313 5314 %{ 5315 static void yyerror ( const char *msg); 5316 static int yylex (void); 5317 %} 5318 5319 %type <ival> '[' 5320 5321 /* Exercise quotes in strings. */ 5322 %token FAKE "fake [] \a\b\f\n\r\t\v\"\'\?\\\u005B\U0000005c ??!??'??(??)??-??/??<??=??> \x1\1" 5323 5324 %% 5325 /* Exercise M4 quoting: ']]', [, 1. */ 5326 exp: '[' '\1' two '$' '@' '{' oline output.or.oline.opt 5327 { 5328 /* Exercise quotes in braces. */ 5329 char tmp[] = "[%c],\n"; 5330 printf (tmp, $1); 5331 } 5332 ; 5333 5334 two: '\x000000000000000000000000000000000000000000000000000000000000000000002'; 5335 oline: '@' 'o' 'l' 'i' 'n' 'e' '@' '_' '_' 'o' 'l' 'i' 'n' 'e' '_' '_'; 5336 output.or.oline.opt: ;|oline;;|output;;; 5337 output: '#' 'o' 'u' 't' 'p' 'u' 't' ' '; 5338 %% 5339 /* Exercise M4 quoting: ']]', [, 2. */ 5340 5341 static YYSTYPE 5342 value_as_yystype (value val) 5343 { 5344 YYSTYPE res; 5345 res.ival = val; 5346 return res; 5347 } 5348 #include <stdio.h> 5349 /* A C error reporting function. */ 5350 static 5351 void yyerror ( const char *msg) 5352 { 5353 fprintf (stderr, "%s\n", msg); 5354 } 5355 static int 5356 yylex (void) 5357 { 5358 static char const input[] = "[\1\2$@{@oline@__oline__\ 5359 #output "; /* " 5360 */ 5361 static size_t toknum; 5362 assert (toknum < sizeof input); 5363 yylval = value_as_yystype (input[toknum]); 5364 return input[toknum++]; 5365 } 5366 _ATEOF 5367 5368 5369 5370 # Pacify Emacs' font-lock-mode: " 5371 5372 cat >main.c <<'_ATEOF' 5373 typedef int value; 5374 #include "input.h" 5375 5376 int yyparse (void); 5377 5378 int 5379 main (void) 5380 { 5381 return yyparse (); 5382 } 5383 _ATEOF 5384 5385 5386 5387 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 5388 at_save_special_files 5389 mkdir xml-tests 5390 # Don't combine these Bison invocations since we want to be sure that 5391 # --report=all isn't required to get the full XML file. 5392 { set +x 5393 $as_echo "$at_srcdir/input.at:659: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 5394 --graph=xml-tests/test.dot -d -v -o input.c input.y" 5395 at_fn_check_prepare_notrace 'an embedded newline' "input.at:659" 5396 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 5397 --graph=xml-tests/test.dot -d -v -o input.c input.y 5398 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5399 at_status=$? at_failed=false 5400 $at_check_filter 5401 echo stderr:; cat "$at_stderr" 5402 echo stdout:; cat "$at_stdout" 5403 at_fn_check_status 0 $at_status "$at_srcdir/input.at:659" 5404 $at_failed && at_fn_log_failure 5405 $at_traceon; } 5406 5407 { set +x 5408 $as_echo "$at_srcdir/input.at:659: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d -v -o input.c input.y" 5409 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d -v -o input.c input.y" "input.at:659" 5410 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d -v -o input.c input.y 5411 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5412 at_status=$? at_failed=false 5413 $at_check_filter 5414 echo stderr:; cat "$at_stderr" 5415 echo stdout:; cat "$at_stdout" 5416 at_fn_check_status 0 $at_status "$at_srcdir/input.at:659" 5417 $at_failed && at_fn_log_failure 5418 $at_traceon; } 5419 5420 cp xml-tests/test.output expout 5421 { set +x 5422 $as_echo "$at_srcdir/input.at:659: \$XSLTPROC \\ 5423 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 5424 xml-tests/test.xml" 5425 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:659" 5426 ( $at_check_trace; $XSLTPROC \ 5427 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 5428 xml-tests/test.xml 5429 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5430 at_status=$? at_failed=false 5431 $at_check_filter 5432 at_fn_diff_devnull "$at_stderr" || at_failed=: 5433 $at_diff expout "$at_stdout" || at_failed=: 5434 at_fn_check_status 0 $at_status "$at_srcdir/input.at:659" 5435 $at_failed && at_fn_log_failure 5436 $at_traceon; } 5437 5438 sort xml-tests/test.dot > expout 5439 { set +x 5440 $as_echo "$at_srcdir/input.at:659: \$XSLTPROC \\ 5441 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 5442 xml-tests/test.xml | sort" 5443 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:659" 5444 ( $at_check_trace; $XSLTPROC \ 5445 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 5446 xml-tests/test.xml | sort 5447 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5448 at_status=$? at_failed=false 5449 $at_check_filter 5450 at_fn_diff_devnull "$at_stderr" || at_failed=: 5451 $at_diff expout "$at_stdout" || at_failed=: 5452 at_fn_check_status 0 $at_status "$at_srcdir/input.at:659" 5453 $at_failed && at_fn_log_failure 5454 $at_traceon; } 5455 5456 rm -rf xml-tests expout 5457 at_restore_special_files 5458 fi 5459 { set +x 5460 $as_echo "$at_srcdir/input.at:659: bison -d -v -o input.c input.y" 5461 at_fn_check_prepare_trace "input.at:659" 5462 ( $at_check_trace; bison -d -v -o input.c input.y 5463 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5464 at_status=$? at_failed=false 5465 $at_check_filter 5466 at_fn_diff_devnull "$at_stderr" || at_failed=: 5467 at_fn_diff_devnull "$at_stdout" || at_failed=: 5468 at_fn_check_status 0 $at_status "$at_srcdir/input.at:659" 5469 $at_failed && at_fn_log_failure 5470 $at_traceon; } 5471 5472 5473 { set +x 5474 $as_echo "$at_srcdir/input.at:660: \$BISON_C_WORKS" 5475 at_fn_check_prepare_dynamic "$BISON_C_WORKS" "input.at:660" 5476 ( $at_check_trace; $BISON_C_WORKS 5477 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5478 at_status=$? at_failed=false 5479 $at_check_filter 5480 echo stderr:; cat "$at_stderr" 5481 echo stdout:; cat "$at_stdout" 5482 at_fn_check_status 0 $at_status "$at_srcdir/input.at:660" 5483 $at_failed && at_fn_log_failure 5484 $at_traceon; } 5485 5486 { set +x 5487 $as_echo "$at_srcdir/input.at:660: \$CC \$CFLAGS \$CPPFLAGS -c -o input.o input.c " 5488 at_fn_check_prepare_dynamic "$CC $CFLAGS $CPPFLAGS -c -o input.o input.c " "input.at:660" 5489 ( $at_check_trace; $CC $CFLAGS $CPPFLAGS -c -o input.o input.c 5490 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5491 at_status=$? at_failed=false 5492 $at_check_filter 5493 echo stderr:; cat "$at_stderr" 5494 echo stdout:; cat "$at_stdout" 5495 at_fn_check_status 0 $at_status "$at_srcdir/input.at:660" 5496 $at_failed && at_fn_log_failure 5497 $at_traceon; } 5498 5499 { set +x 5500 $as_echo "$at_srcdir/input.at:661: \$BISON_C_WORKS" 5501 at_fn_check_prepare_dynamic "$BISON_C_WORKS" "input.at:661" 5502 ( $at_check_trace; $BISON_C_WORKS 5503 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5504 at_status=$? at_failed=false 5505 $at_check_filter 5506 echo stderr:; cat "$at_stderr" 5507 echo stdout:; cat "$at_stdout" 5508 at_fn_check_status 0 $at_status "$at_srcdir/input.at:661" 5509 $at_failed && at_fn_log_failure 5510 $at_traceon; } 5511 5512 { set +x 5513 $as_echo "$at_srcdir/input.at:661: \$CC \$CFLAGS \$CPPFLAGS -c -o main.o main.c " 5514 at_fn_check_prepare_dynamic "$CC $CFLAGS $CPPFLAGS -c -o main.o main.c " "input.at:661" 5515 ( $at_check_trace; $CC $CFLAGS $CPPFLAGS -c -o main.o main.c 5516 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5517 at_status=$? at_failed=false 5518 $at_check_filter 5519 echo stderr:; cat "$at_stderr" 5520 echo stdout:; cat "$at_stdout" 5521 at_fn_check_status 0 $at_status "$at_srcdir/input.at:661" 5522 $at_failed && at_fn_log_failure 5523 $at_traceon; } 5524 5525 { set +x 5526 $as_echo "$at_srcdir/input.at:662: \$BISON_C_WORKS" 5527 at_fn_check_prepare_dynamic "$BISON_C_WORKS" "input.at:662" 5528 ( $at_check_trace; $BISON_C_WORKS 5529 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5530 at_status=$? at_failed=false 5531 $at_check_filter 5532 echo stderr:; cat "$at_stderr" 5533 echo stdout:; cat "$at_stdout" 5534 at_fn_check_status 0 $at_status "$at_srcdir/input.at:662" 5535 $at_failed && at_fn_log_failure 5536 $at_traceon; } 5537 5538 { set +x 5539 $as_echo "$at_srcdir/input.at:662: \$CC \$CFLAGS \$CPPFLAGS \$LDFLAGS -o input input.o main.o \$LIBS" 5540 at_fn_check_prepare_dynamic "$CC $CFLAGS $CPPFLAGS $LDFLAGS -o input input.o main.o $LIBS" "input.at:662" 5541 ( $at_check_trace; $CC $CFLAGS $CPPFLAGS $LDFLAGS -o input input.o main.o $LIBS 5542 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5543 at_status=$? at_failed=false 5544 $at_check_filter 5545 echo stderr:; cat "$at_stderr" 5546 echo stdout:; cat "$at_stdout" 5547 at_fn_check_status 0 $at_status "$at_srcdir/input.at:662" 5548 $at_failed && at_fn_log_failure 5549 $at_traceon; } 5550 5551 { set +x 5552 $as_echo "$at_srcdir/input.at:663: \$PREPARSER ./input" 5553 at_fn_check_prepare_dynamic " $PREPARSER ./input" "input.at:663" 5554 ( $at_check_trace; $PREPARSER ./input 5555 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5556 at_status=$? at_failed=false 5557 $at_check_filter 5558 echo stderr:; tee stderr <"$at_stderr" 5559 echo >>"$at_stdout"; $as_echo "[[], 5560 " | \ 5561 $at_diff - "$at_stdout" || at_failed=: 5562 at_fn_check_status 0 $at_status "$at_srcdir/input.at:663" 5563 $at_failed && at_fn_log_failure 5564 $at_traceon; } 5565 5566 { set +x 5567 $as_echo "$at_srcdir/input.at:663: sed >&2 -e '/^profiling:.*:Merge mismatch for summaries/d' stderr" 5568 at_fn_check_prepare_trace "input.at:663" 5569 ( $at_check_trace; sed >&2 -e '/^profiling:.*:Merge mismatch for summaries/d' stderr 5570 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5571 at_status=$? at_failed=false 5572 $at_check_filter 5573 at_fn_diff_devnull "$at_stderr" || at_failed=: 5574 at_fn_diff_devnull "$at_stdout" || at_failed=: 5575 at_fn_check_status 0 $at_status "$at_srcdir/input.at:663" 5576 $at_failed && at_fn_log_failure 5577 $at_traceon; } 5578 5579 5580 5581 set +x 5582 $at_times_p && times >"$at_times_file" 5583 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 5584 read at_status <"$at_status_file" 5585 #AT_STOP_12 5586 #AT_START_13 5587 at_fn_group_banner 13 'input.at:674' \ 5588 "Typed symbol aliases" " " 1 5589 at_xfail=no 5590 ( 5591 $as_echo "13. $at_setup_line: testing $at_desc ..." 5592 $at_traceon 5593 5594 5595 # Bison 2.0 broke typed symbol aliases - ensure they work. 5596 5597 cat >input.y <<'_ATEOF' 5598 %code top { 5599 #include <config.h> 5600 /* We don't need perfect functions for these tests. */ 5601 #undef malloc 5602 #undef memcmp 5603 #undef realloc 5604 } 5605 5606 %union 5607 { 5608 int val; 5609 }; 5610 %token <val> MY_TOKEN "MY TOKEN" 5611 %type <val> exp 5612 %% 5613 exp: "MY TOKEN"; 5614 %% 5615 _ATEOF 5616 5617 5618 5619 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 5620 at_save_special_files 5621 mkdir xml-tests 5622 # Don't combine these Bison invocations since we want to be sure that 5623 # --report=all isn't required to get the full XML file. 5624 { set +x 5625 $as_echo "$at_srcdir/input.at:690: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 5626 --graph=xml-tests/test.dot -o input.c input.y" 5627 at_fn_check_prepare_notrace 'an embedded newline' "input.at:690" 5628 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 5629 --graph=xml-tests/test.dot -o input.c input.y 5630 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5631 at_status=$? at_failed=false 5632 $at_check_filter 5633 echo stderr:; cat "$at_stderr" 5634 echo stdout:; cat "$at_stdout" 5635 at_fn_check_status 0 $at_status "$at_srcdir/input.at:690" 5636 $at_failed && at_fn_log_failure 5637 $at_traceon; } 5638 5639 { set +x 5640 $as_echo "$at_srcdir/input.at:690: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o input.c input.y" 5641 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o input.c input.y" "input.at:690" 5642 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o input.c input.y 5643 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5644 at_status=$? at_failed=false 5645 $at_check_filter 5646 echo stderr:; cat "$at_stderr" 5647 echo stdout:; cat "$at_stdout" 5648 at_fn_check_status 0 $at_status "$at_srcdir/input.at:690" 5649 $at_failed && at_fn_log_failure 5650 $at_traceon; } 5651 5652 cp xml-tests/test.output expout 5653 { set +x 5654 $as_echo "$at_srcdir/input.at:690: \$XSLTPROC \\ 5655 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 5656 xml-tests/test.xml" 5657 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:690" 5658 ( $at_check_trace; $XSLTPROC \ 5659 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 5660 xml-tests/test.xml 5661 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5662 at_status=$? at_failed=false 5663 $at_check_filter 5664 at_fn_diff_devnull "$at_stderr" || at_failed=: 5665 $at_diff expout "$at_stdout" || at_failed=: 5666 at_fn_check_status 0 $at_status "$at_srcdir/input.at:690" 5667 $at_failed && at_fn_log_failure 5668 $at_traceon; } 5669 5670 sort xml-tests/test.dot > expout 5671 { set +x 5672 $as_echo "$at_srcdir/input.at:690: \$XSLTPROC \\ 5673 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 5674 xml-tests/test.xml | sort" 5675 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:690" 5676 ( $at_check_trace; $XSLTPROC \ 5677 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 5678 xml-tests/test.xml | sort 5679 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5680 at_status=$? at_failed=false 5681 $at_check_filter 5682 at_fn_diff_devnull "$at_stderr" || at_failed=: 5683 $at_diff expout "$at_stdout" || at_failed=: 5684 at_fn_check_status 0 $at_status "$at_srcdir/input.at:690" 5685 $at_failed && at_fn_log_failure 5686 $at_traceon; } 5687 5688 rm -rf xml-tests expout 5689 at_restore_special_files 5690 fi 5691 { set +x 5692 $as_echo "$at_srcdir/input.at:690: bison -o input.c input.y" 5693 at_fn_check_prepare_trace "input.at:690" 5694 ( $at_check_trace; bison -o input.c input.y 5695 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5696 at_status=$? at_failed=false 5697 $at_check_filter 5698 at_fn_diff_devnull "$at_stderr" || at_failed=: 5699 at_fn_diff_devnull "$at_stdout" || at_failed=: 5700 at_fn_check_status 0 $at_status "$at_srcdir/input.at:690" 5701 $at_failed && at_fn_log_failure 5702 $at_traceon; } 5703 5704 5705 5706 set +x 5707 $at_times_p && times >"$at_times_file" 5708 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 5709 read at_status <"$at_status_file" 5710 #AT_STOP_13 5711 #AT_START_14 5712 at_fn_group_banner 14 'input.at:710' \ 5713 "Require 1.0" " " 1 5714 at_xfail=no 5715 ( 5716 $as_echo "14. $at_setup_line: testing $at_desc ..." 5717 $at_traceon 5718 5719 cat >input.y <<'_ATEOF' 5720 %code top { 5721 #include <config.h> 5722 /* We don't need perfect functions for these tests. */ 5723 #undef malloc 5724 #undef memcmp 5725 #undef realloc 5726 } 5727 5728 %require "1.0"; 5729 %% 5730 empty_file:; 5731 _ATEOF 5732 5733 5734 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 5735 at_save_special_files 5736 mkdir xml-tests 5737 # Don't combine these Bison invocations since we want to be sure that 5738 # --report=all isn't required to get the full XML file. 5739 { set +x 5740 $as_echo "$at_srcdir/input.at:710: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 5741 --graph=xml-tests/test.dot -o input.c input.y" 5742 at_fn_check_prepare_notrace 'an embedded newline' "input.at:710" 5743 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 5744 --graph=xml-tests/test.dot -o input.c input.y 5745 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5746 at_status=$? at_failed=false 5747 $at_check_filter 5748 echo stderr:; cat "$at_stderr" 5749 echo stdout:; cat "$at_stdout" 5750 at_fn_check_status 0 $at_status "$at_srcdir/input.at:710" 5751 $at_failed && at_fn_log_failure 5752 $at_traceon; } 5753 5754 { set +x 5755 $as_echo "$at_srcdir/input.at:710: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o input.c input.y" 5756 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o input.c input.y" "input.at:710" 5757 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o input.c input.y 5758 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5759 at_status=$? at_failed=false 5760 $at_check_filter 5761 echo stderr:; cat "$at_stderr" 5762 echo stdout:; cat "$at_stdout" 5763 at_fn_check_status 0 $at_status "$at_srcdir/input.at:710" 5764 $at_failed && at_fn_log_failure 5765 $at_traceon; } 5766 5767 cp xml-tests/test.output expout 5768 { set +x 5769 $as_echo "$at_srcdir/input.at:710: \$XSLTPROC \\ 5770 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 5771 xml-tests/test.xml" 5772 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:710" 5773 ( $at_check_trace; $XSLTPROC \ 5774 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 5775 xml-tests/test.xml 5776 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5777 at_status=$? at_failed=false 5778 $at_check_filter 5779 at_fn_diff_devnull "$at_stderr" || at_failed=: 5780 $at_diff expout "$at_stdout" || at_failed=: 5781 at_fn_check_status 0 $at_status "$at_srcdir/input.at:710" 5782 $at_failed && at_fn_log_failure 5783 $at_traceon; } 5784 5785 sort xml-tests/test.dot > expout 5786 { set +x 5787 $as_echo "$at_srcdir/input.at:710: \$XSLTPROC \\ 5788 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 5789 xml-tests/test.xml | sort" 5790 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:710" 5791 ( $at_check_trace; $XSLTPROC \ 5792 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 5793 xml-tests/test.xml | sort 5794 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5795 at_status=$? at_failed=false 5796 $at_check_filter 5797 at_fn_diff_devnull "$at_stderr" || at_failed=: 5798 $at_diff expout "$at_stdout" || at_failed=: 5799 at_fn_check_status 0 $at_status "$at_srcdir/input.at:710" 5800 $at_failed && at_fn_log_failure 5801 $at_traceon; } 5802 5803 rm -rf xml-tests expout 5804 at_restore_special_files 5805 fi 5806 { set +x 5807 $as_echo "$at_srcdir/input.at:710: bison -o input.c input.y" 5808 at_fn_check_prepare_trace "input.at:710" 5809 ( $at_check_trace; bison -o input.c input.y 5810 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5811 at_status=$? at_failed=false 5812 $at_check_filter 5813 echo stderr:; cat "$at_stderr" 5814 at_fn_diff_devnull "$at_stdout" || at_failed=: 5815 at_fn_check_status 0 $at_status "$at_srcdir/input.at:710" 5816 $at_failed && at_fn_log_failure 5817 $at_traceon; } 5818 5819 5820 set +x 5821 $at_times_p && times >"$at_times_file" 5822 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 5823 read at_status <"$at_status_file" 5824 #AT_STOP_14 5825 #AT_START_15 5826 at_fn_group_banner 15 'input.at:711' \ 5827 "Require 2.7" " " 1 5828 at_xfail=no 5829 ( 5830 $as_echo "15. $at_setup_line: testing $at_desc ..." 5831 $at_traceon 5832 5833 cat >input.y <<'_ATEOF' 5834 %code top { 5835 #include <config.h> 5836 /* We don't need perfect functions for these tests. */ 5837 #undef malloc 5838 #undef memcmp 5839 #undef realloc 5840 } 5841 5842 %require "2.7"; 5843 %% 5844 empty_file:; 5845 _ATEOF 5846 5847 5848 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 5849 at_save_special_files 5850 mkdir xml-tests 5851 # Don't combine these Bison invocations since we want to be sure that 5852 # --report=all isn't required to get the full XML file. 5853 { set +x 5854 $as_echo "$at_srcdir/input.at:711: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 5855 --graph=xml-tests/test.dot -o input.c input.y" 5856 at_fn_check_prepare_notrace 'an embedded newline' "input.at:711" 5857 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 5858 --graph=xml-tests/test.dot -o input.c input.y 5859 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5860 at_status=$? at_failed=false 5861 $at_check_filter 5862 echo stderr:; cat "$at_stderr" 5863 echo stdout:; cat "$at_stdout" 5864 at_fn_check_status 0 $at_status "$at_srcdir/input.at:711" 5865 $at_failed && at_fn_log_failure 5866 $at_traceon; } 5867 5868 { set +x 5869 $as_echo "$at_srcdir/input.at:711: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o input.c input.y" 5870 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o input.c input.y" "input.at:711" 5871 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o input.c input.y 5872 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5873 at_status=$? at_failed=false 5874 $at_check_filter 5875 echo stderr:; cat "$at_stderr" 5876 echo stdout:; cat "$at_stdout" 5877 at_fn_check_status 0 $at_status "$at_srcdir/input.at:711" 5878 $at_failed && at_fn_log_failure 5879 $at_traceon; } 5880 5881 cp xml-tests/test.output expout 5882 { set +x 5883 $as_echo "$at_srcdir/input.at:711: \$XSLTPROC \\ 5884 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 5885 xml-tests/test.xml" 5886 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:711" 5887 ( $at_check_trace; $XSLTPROC \ 5888 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 5889 xml-tests/test.xml 5890 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5891 at_status=$? at_failed=false 5892 $at_check_filter 5893 at_fn_diff_devnull "$at_stderr" || at_failed=: 5894 $at_diff expout "$at_stdout" || at_failed=: 5895 at_fn_check_status 0 $at_status "$at_srcdir/input.at:711" 5896 $at_failed && at_fn_log_failure 5897 $at_traceon; } 5898 5899 sort xml-tests/test.dot > expout 5900 { set +x 5901 $as_echo "$at_srcdir/input.at:711: \$XSLTPROC \\ 5902 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 5903 xml-tests/test.xml | sort" 5904 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:711" 5905 ( $at_check_trace; $XSLTPROC \ 5906 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 5907 xml-tests/test.xml | sort 5908 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5909 at_status=$? at_failed=false 5910 $at_check_filter 5911 at_fn_diff_devnull "$at_stderr" || at_failed=: 5912 $at_diff expout "$at_stdout" || at_failed=: 5913 at_fn_check_status 0 $at_status "$at_srcdir/input.at:711" 5914 $at_failed && at_fn_log_failure 5915 $at_traceon; } 5916 5917 rm -rf xml-tests expout 5918 at_restore_special_files 5919 fi 5920 { set +x 5921 $as_echo "$at_srcdir/input.at:711: bison -o input.c input.y" 5922 at_fn_check_prepare_trace "input.at:711" 5923 ( $at_check_trace; bison -o input.c input.y 5924 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5925 at_status=$? at_failed=false 5926 $at_check_filter 5927 echo stderr:; cat "$at_stderr" 5928 at_fn_diff_devnull "$at_stdout" || at_failed=: 5929 at_fn_check_status 0 $at_status "$at_srcdir/input.at:711" 5930 $at_failed && at_fn_log_failure 5931 $at_traceon; } 5932 5933 5934 set +x 5935 $at_times_p && times >"$at_times_file" 5936 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 5937 read at_status <"$at_status_file" 5938 #AT_STOP_15 5939 #AT_START_16 5940 at_fn_group_banner 16 'input.at:713' \ 5941 "Require 100.0" " " 1 5942 at_xfail=no 5943 ( 5944 $as_echo "16. $at_setup_line: testing $at_desc ..." 5945 $at_traceon 5946 5947 cat >input.y <<'_ATEOF' 5948 %code top { 5949 #include <config.h> 5950 /* We don't need perfect functions for these tests. */ 5951 #undef malloc 5952 #undef memcmp 5953 #undef realloc 5954 } 5955 5956 %require "100.0"; 5957 %% 5958 empty_file:; 5959 _ATEOF 5960 5961 5962 5963 { set +x 5964 $as_echo "$at_srcdir/input.at:713: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o input.c input.y" 5965 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o input.c input.y" "input.at:713" 5966 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -o input.c input.y 5967 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 5968 at_status=$? at_failed=false 5969 $at_check_filter 5970 echo stderr:; cat "$at_stderr" 5971 at_fn_diff_devnull "$at_stdout" || at_failed=: 5972 at_fn_check_status 63 $at_status "$at_srcdir/input.at:713" 5973 $at_failed && at_fn_log_failure 5974 $at_traceon; } 5975 5976 5977 set +x 5978 $at_times_p && times >"$at_times_file" 5979 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 5980 read at_status <"$at_status_file" 5981 #AT_STOP_16 5982 #AT_START_17 5983 at_fn_group_banner 17 'input.at:720' \ 5984 "String aliases for character tokens" " " 1 5985 at_xfail=no 5986 ( 5987 $as_echo "17. $at_setup_line: testing $at_desc ..." 5988 $at_traceon 5989 5990 5991 # Bison once thought a character token and its alias were different symbols 5992 # with the same user token number. 5993 5994 cat >input.y <<'_ATEOF' 5995 %code top { 5996 #include <config.h> 5997 /* We don't need perfect functions for these tests. */ 5998 #undef malloc 5999 #undef memcmp 6000 #undef realloc 6001 } 6002 6003 %token 'a' "a" 6004 %% 6005 start: 'a'; 6006 %% 6007 _ATEOF 6008 6009 6010 6011 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 6012 at_save_special_files 6013 mkdir xml-tests 6014 # Don't combine these Bison invocations since we want to be sure that 6015 # --report=all isn't required to get the full XML file. 6016 { set +x 6017 $as_echo "$at_srcdir/input.at:732: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 6018 --graph=xml-tests/test.dot -o input.c input.y" 6019 at_fn_check_prepare_notrace 'an embedded newline' "input.at:732" 6020 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 6021 --graph=xml-tests/test.dot -o input.c input.y 6022 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6023 at_status=$? at_failed=false 6024 $at_check_filter 6025 echo stderr:; cat "$at_stderr" 6026 echo stdout:; cat "$at_stdout" 6027 at_fn_check_status 0 $at_status "$at_srcdir/input.at:732" 6028 $at_failed && at_fn_log_failure 6029 $at_traceon; } 6030 6031 { set +x 6032 $as_echo "$at_srcdir/input.at:732: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o input.c input.y" 6033 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o input.c input.y" "input.at:732" 6034 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o input.c input.y 6035 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6036 at_status=$? at_failed=false 6037 $at_check_filter 6038 echo stderr:; cat "$at_stderr" 6039 echo stdout:; cat "$at_stdout" 6040 at_fn_check_status 0 $at_status "$at_srcdir/input.at:732" 6041 $at_failed && at_fn_log_failure 6042 $at_traceon; } 6043 6044 cp xml-tests/test.output expout 6045 { set +x 6046 $as_echo "$at_srcdir/input.at:732: \$XSLTPROC \\ 6047 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 6048 xml-tests/test.xml" 6049 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:732" 6050 ( $at_check_trace; $XSLTPROC \ 6051 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 6052 xml-tests/test.xml 6053 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6054 at_status=$? at_failed=false 6055 $at_check_filter 6056 at_fn_diff_devnull "$at_stderr" || at_failed=: 6057 $at_diff expout "$at_stdout" || at_failed=: 6058 at_fn_check_status 0 $at_status "$at_srcdir/input.at:732" 6059 $at_failed && at_fn_log_failure 6060 $at_traceon; } 6061 6062 sort xml-tests/test.dot > expout 6063 { set +x 6064 $as_echo "$at_srcdir/input.at:732: \$XSLTPROC \\ 6065 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 6066 xml-tests/test.xml | sort" 6067 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:732" 6068 ( $at_check_trace; $XSLTPROC \ 6069 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 6070 xml-tests/test.xml | sort 6071 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6072 at_status=$? at_failed=false 6073 $at_check_filter 6074 at_fn_diff_devnull "$at_stderr" || at_failed=: 6075 $at_diff expout "$at_stdout" || at_failed=: 6076 at_fn_check_status 0 $at_status "$at_srcdir/input.at:732" 6077 $at_failed && at_fn_log_failure 6078 $at_traceon; } 6079 6080 rm -rf xml-tests expout 6081 at_restore_special_files 6082 fi 6083 { set +x 6084 $as_echo "$at_srcdir/input.at:732: bison -o input.c input.y" 6085 at_fn_check_prepare_trace "input.at:732" 6086 ( $at_check_trace; bison -o input.c input.y 6087 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6088 at_status=$? at_failed=false 6089 $at_check_filter 6090 at_fn_diff_devnull "$at_stderr" || at_failed=: 6091 at_fn_diff_devnull "$at_stdout" || at_failed=: 6092 at_fn_check_status 0 $at_status "$at_srcdir/input.at:732" 6093 $at_failed && at_fn_log_failure 6094 $at_traceon; } 6095 6096 6097 6098 set +x 6099 $at_times_p && times >"$at_times_file" 6100 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 6101 read at_status <"$at_status_file" 6102 #AT_STOP_17 6103 #AT_START_18 6104 at_fn_group_banner 18 'input.at:741' \ 6105 "Symbols" " " 1 6106 at_xfail=no 6107 ( 6108 $as_echo "18. $at_setup_line: testing $at_desc ..." 6109 $at_traceon 6110 6111 6112 6113 cat >input.y <<'_ATEOF' 6114 %code top { 6115 #include <config.h> 6116 /* We don't need perfect functions for these tests. */ 6117 #undef malloc 6118 #undef memcmp 6119 #undef realloc 6120 } 6121 6122 %token WITH-DASH 6123 %token WITHOUT_DASH "WITHOUT-DASH" 6124 %token WITH.PERIOD 6125 %token WITHOUT_PERIOD "WITHOUT.PERIOD" 6126 %code { 6127 static void yyerror ( const char *msg); 6128 static int yylex (void); 6129 } 6130 %% 6131 start: with-dash without_dash with.period without_period; 6132 with-dash: WITH-DASH; 6133 without_dash: "WITHOUT-DASH"; 6134 with.period: WITH.PERIOD; 6135 without_period: "WITHOUT.PERIOD"; 6136 %% 6137 #include <stdio.h> 6138 /* A C error reporting function. */ 6139 static 6140 void yyerror ( const char *msg) 6141 { 6142 fprintf (stderr, "%s\n", msg); 6143 } 6144 #include <assert.h> 6145 static 6146 int yylex (void) 6147 { 6148 static char const input[] = ""; 6149 static size_t toknum = 0; 6150 int res; 6151 ; 6152 assert (toknum < sizeof input / sizeof input[0]); 6153 res = input[toknum++]; 6154 ; 6155 return res; 6156 } 6157 _ATEOF 6158 6159 6160 6161 6162 # POSIX Yacc accept periods, but not dashes. 6163 6164 { set +x 6165 $as_echo "$at_srcdir/input.at:766: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --yacc input.y" 6166 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --yacc input.y" "input.at:766" 6167 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --yacc input.y 6168 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6169 at_status=$? at_failed=false 6170 $at_check_filter 6171 echo >>"$at_stderr"; $as_echo "input.y:9.8-16: POSIX Yacc forbids dashes in symbol names: WITH-DASH 6172 input.y:18.8-16: POSIX Yacc forbids dashes in symbol names: with-dash 6173 " | \ 6174 $at_diff - "$at_stderr" || at_failed=: 6175 at_fn_diff_devnull "$at_stdout" || at_failed=: 6176 at_fn_check_status 1 $at_status "$at_srcdir/input.at:766" 6177 $at_failed && at_fn_log_failure 6178 $at_traceon; } 6179 6180 6181 6182 # So warn about them. 6183 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 6184 at_save_special_files 6185 mkdir xml-tests 6186 # Don't combine these Bison invocations since we want to be sure that 6187 # --report=all isn't required to get the full XML file. 6188 { set +x 6189 $as_echo "$at_srcdir/input.at:772: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 6190 --graph=xml-tests/test.dot -Wyacc input.y" 6191 at_fn_check_prepare_notrace 'an embedded newline' "input.at:772" 6192 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 6193 --graph=xml-tests/test.dot -Wyacc input.y 6194 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6195 at_status=$? at_failed=false 6196 $at_check_filter 6197 echo stderr:; cat "$at_stderr" 6198 echo stdout:; cat "$at_stdout" 6199 at_fn_check_status 0 $at_status "$at_srcdir/input.at:772" 6200 $at_failed && at_fn_log_failure 6201 $at_traceon; } 6202 6203 { set +x 6204 $as_echo "$at_srcdir/input.at:772: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -Wyacc input.y" 6205 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -Wyacc input.y" "input.at:772" 6206 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -Wyacc input.y 6207 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6208 at_status=$? at_failed=false 6209 $at_check_filter 6210 echo stderr:; cat "$at_stderr" 6211 echo stdout:; cat "$at_stdout" 6212 at_fn_check_status 0 $at_status "$at_srcdir/input.at:772" 6213 $at_failed && at_fn_log_failure 6214 $at_traceon; } 6215 6216 cp xml-tests/test.output expout 6217 { set +x 6218 $as_echo "$at_srcdir/input.at:772: \$XSLTPROC \\ 6219 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 6220 xml-tests/test.xml" 6221 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:772" 6222 ( $at_check_trace; $XSLTPROC \ 6223 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 6224 xml-tests/test.xml 6225 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6226 at_status=$? at_failed=false 6227 $at_check_filter 6228 at_fn_diff_devnull "$at_stderr" || at_failed=: 6229 $at_diff expout "$at_stdout" || at_failed=: 6230 at_fn_check_status 0 $at_status "$at_srcdir/input.at:772" 6231 $at_failed && at_fn_log_failure 6232 $at_traceon; } 6233 6234 sort xml-tests/test.dot > expout 6235 { set +x 6236 $as_echo "$at_srcdir/input.at:772: \$XSLTPROC \\ 6237 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 6238 xml-tests/test.xml | sort" 6239 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:772" 6240 ( $at_check_trace; $XSLTPROC \ 6241 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 6242 xml-tests/test.xml | sort 6243 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6244 at_status=$? at_failed=false 6245 $at_check_filter 6246 at_fn_diff_devnull "$at_stderr" || at_failed=: 6247 $at_diff expout "$at_stdout" || at_failed=: 6248 at_fn_check_status 0 $at_status "$at_srcdir/input.at:772" 6249 $at_failed && at_fn_log_failure 6250 $at_traceon; } 6251 6252 rm -rf xml-tests expout 6253 at_restore_special_files 6254 fi 6255 { set +x 6256 $as_echo "$at_srcdir/input.at:772: bison -Wyacc input.y" 6257 at_fn_check_prepare_trace "input.at:772" 6258 ( $at_check_trace; bison -Wyacc input.y 6259 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6260 at_status=$? at_failed=false 6261 $at_check_filter 6262 echo >>"$at_stderr"; $as_echo "input.y:9.8-16: warning: POSIX Yacc forbids dashes in symbol names: WITH-DASH 6263 input.y:18.8-16: warning: POSIX Yacc forbids dashes in symbol names: with-dash 6264 " | \ 6265 $at_diff - "$at_stderr" || at_failed=: 6266 at_fn_diff_devnull "$at_stdout" || at_failed=: 6267 at_fn_check_status 0 $at_status "$at_srcdir/input.at:772" 6268 $at_failed && at_fn_log_failure 6269 $at_traceon; } 6270 6271 # Defining POSIXLY_CORRECT causes bison to complain if options are 6272 # added after the grammar file name, so skip these checks in that 6273 # case. 6274 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 6275 at_save_special_files 6276 6277 # To avoid expanding it repeatedly, store specified stdout. 6278 : >expout 6279 6280 # Run with -Werror. 6281 { set +x 6282 $as_echo "$at_srcdir/input.at:772: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wyacc input.y -Werror" 6283 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wyacc input.y -Werror" "input.at:772" 6284 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -Wyacc input.y -Werror 6285 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6286 at_status=$? at_failed=false 6287 $at_check_filter 6288 echo stderr:; tee stderr <"$at_stderr" 6289 $at_diff expout "$at_stdout" || at_failed=: 6290 at_fn_check_status 1 $at_status "$at_srcdir/input.at:772" 6291 $at_failed && at_fn_log_failure 6292 $at_traceon; } 6293 6294 6295 # Build expected stderr up to and including the "warnings being 6296 # treated as errors" message. 6297 cat >at-bison-check-warnings <<'_ATEOF' 6298 input.y:9.8-16: warning: POSIX Yacc forbids dashes in symbol names: WITH-DASH 6299 input.y:18.8-16: warning: POSIX Yacc forbids dashes in symbol names: with-dash 6300 _ATEOF 6301 6302 at_bison_check_first=`sed -n \ 6303 '/: warning: /{=;q;}' at-bison-check-warnings` 6304 : ${at_bison_check_first:=1} 6305 at_bison_check_first_tmp=`sed -n \ 6306 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 6307 : ${at_bison_check_first_tmp:=1} 6308 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 6309 at_bison_check_first=$at_bison_check_first_tmp 6310 fi 6311 if test $at_bison_check_first -gt 1; then 6312 sed -n "1,`expr $at_bison_check_first - 1`"p \ 6313 at-bison-check-warnings > experr 6314 fi 6315 echo 'bison: warnings being treated as errors' >> experr 6316 6317 # Finish building expected stderr and check. Unlike warnings, 6318 # complaints cause bison to exit early. Thus, with -Werror, bison 6319 # does not necessarily report all warnings that it does without 6320 # -Werror, but it at least reports one. 6321 at_bison_check_last=`sed -n '$=' stderr` 6322 : ${at_bison_check_last:=1} 6323 at_bison_check_last=`expr $at_bison_check_last - 1` 6324 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 6325 at-bison-check-warnings >> experr 6326 { set +x 6327 $as_echo "$at_srcdir/input.at:772: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 6328 stderr 1>&2" 6329 at_fn_check_prepare_notrace 'an embedded newline' "input.at:772" 6330 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 6331 stderr 1>&2 6332 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6333 at_status=$? at_failed=false 6334 $at_check_filter 6335 $at_diff experr "$at_stderr" || at_failed=: 6336 at_fn_diff_devnull "$at_stdout" || at_failed=: 6337 at_fn_check_status 0 $at_status "$at_srcdir/input.at:772" 6338 $at_failed && at_fn_log_failure 6339 $at_traceon; } 6340 6341 6342 # Now check --warnings=error. 6343 cp stderr experr 6344 { set +x 6345 $as_echo "$at_srcdir/input.at:772: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wyacc input.y --warnings=error" 6346 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wyacc input.y --warnings=error" "input.at:772" 6347 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -Wyacc input.y --warnings=error 6348 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6349 at_status=$? at_failed=false 6350 $at_check_filter 6351 $at_diff experr "$at_stderr" || at_failed=: 6352 $at_diff expout "$at_stdout" || at_failed=: 6353 at_fn_check_status 1 $at_status "$at_srcdir/input.at:772" 6354 $at_failed && at_fn_log_failure 6355 $at_traceon; } 6356 6357 6358 # Now check -Wnone and --warnings=none by making sure that 6359 # -Werror doesn't change the exit status when -Wnone or 6360 # --warnings=none is specified. 6361 { set +x 6362 $as_echo "$at_srcdir/input.at:772: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wyacc input.y -Wnone -Werror" 6363 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wyacc input.y -Wnone -Werror" "input.at:772" 6364 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -Wyacc input.y -Wnone -Werror 6365 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6366 at_status=$? at_failed=false 6367 $at_check_filter 6368 at_fn_diff_devnull "$at_stderr" || at_failed=: 6369 $at_diff expout "$at_stdout" || at_failed=: 6370 at_fn_check_status 0 $at_status "$at_srcdir/input.at:772" 6371 $at_failed && at_fn_log_failure 6372 $at_traceon; } 6373 6374 { set +x 6375 $as_echo "$at_srcdir/input.at:772: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wyacc input.y --warnings=none -Werror" 6376 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wyacc input.y --warnings=none -Werror" "input.at:772" 6377 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -Wyacc input.y --warnings=none -Werror 6378 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6379 at_status=$? at_failed=false 6380 $at_check_filter 6381 at_fn_diff_devnull "$at_stderr" || at_failed=: 6382 $at_diff expout "$at_stdout" || at_failed=: 6383 at_fn_check_status 0 $at_status "$at_srcdir/input.at:772" 6384 $at_failed && at_fn_log_failure 6385 $at_traceon; } 6386 6387 6388 at_restore_special_files 6389 fi 6390 6391 # Dashes are fine for GNU Bison. 6392 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 6393 at_save_special_files 6394 mkdir xml-tests 6395 # Don't combine these Bison invocations since we want to be sure that 6396 # --report=all isn't required to get the full XML file. 6397 { set +x 6398 $as_echo "$at_srcdir/input.at:778: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 6399 --graph=xml-tests/test.dot -o input.c input.y" 6400 at_fn_check_prepare_notrace 'an embedded newline' "input.at:778" 6401 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 6402 --graph=xml-tests/test.dot -o input.c input.y 6403 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6404 at_status=$? at_failed=false 6405 $at_check_filter 6406 echo stderr:; cat "$at_stderr" 6407 echo stdout:; cat "$at_stdout" 6408 at_fn_check_status 0 $at_status "$at_srcdir/input.at:778" 6409 $at_failed && at_fn_log_failure 6410 $at_traceon; } 6411 6412 { set +x 6413 $as_echo "$at_srcdir/input.at:778: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o input.c input.y" 6414 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o input.c input.y" "input.at:778" 6415 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o input.c input.y 6416 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6417 at_status=$? at_failed=false 6418 $at_check_filter 6419 echo stderr:; cat "$at_stderr" 6420 echo stdout:; cat "$at_stdout" 6421 at_fn_check_status 0 $at_status "$at_srcdir/input.at:778" 6422 $at_failed && at_fn_log_failure 6423 $at_traceon; } 6424 6425 cp xml-tests/test.output expout 6426 { set +x 6427 $as_echo "$at_srcdir/input.at:778: \$XSLTPROC \\ 6428 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 6429 xml-tests/test.xml" 6430 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:778" 6431 ( $at_check_trace; $XSLTPROC \ 6432 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 6433 xml-tests/test.xml 6434 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6435 at_status=$? at_failed=false 6436 $at_check_filter 6437 at_fn_diff_devnull "$at_stderr" || at_failed=: 6438 $at_diff expout "$at_stdout" || at_failed=: 6439 at_fn_check_status 0 $at_status "$at_srcdir/input.at:778" 6440 $at_failed && at_fn_log_failure 6441 $at_traceon; } 6442 6443 sort xml-tests/test.dot > expout 6444 { set +x 6445 $as_echo "$at_srcdir/input.at:778: \$XSLTPROC \\ 6446 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 6447 xml-tests/test.xml | sort" 6448 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:778" 6449 ( $at_check_trace; $XSLTPROC \ 6450 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 6451 xml-tests/test.xml | sort 6452 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6453 at_status=$? at_failed=false 6454 $at_check_filter 6455 at_fn_diff_devnull "$at_stderr" || at_failed=: 6456 $at_diff expout "$at_stdout" || at_failed=: 6457 at_fn_check_status 0 $at_status "$at_srcdir/input.at:778" 6458 $at_failed && at_fn_log_failure 6459 $at_traceon; } 6460 6461 rm -rf xml-tests expout 6462 at_restore_special_files 6463 fi 6464 { set +x 6465 $as_echo "$at_srcdir/input.at:778: bison -o input.c input.y" 6466 at_fn_check_prepare_trace "input.at:778" 6467 ( $at_check_trace; bison -o input.c input.y 6468 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6469 at_status=$? at_failed=false 6470 $at_check_filter 6471 at_fn_diff_devnull "$at_stderr" || at_failed=: 6472 at_fn_diff_devnull "$at_stdout" || at_failed=: 6473 at_fn_check_status 0 $at_status "$at_srcdir/input.at:778" 6474 $at_failed && at_fn_log_failure 6475 $at_traceon; } 6476 6477 6478 6479 # Make sure we don't export silly token identifiers with periods or dashes. 6480 { set +x 6481 $as_echo "$at_srcdir/input.at:781: \$BISON_C_WORKS" 6482 at_fn_check_prepare_dynamic "$BISON_C_WORKS" "input.at:781" 6483 ( $at_check_trace; $BISON_C_WORKS 6484 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6485 at_status=$? at_failed=false 6486 $at_check_filter 6487 echo stderr:; cat "$at_stderr" 6488 echo stdout:; cat "$at_stdout" 6489 at_fn_check_status 0 $at_status "$at_srcdir/input.at:781" 6490 $at_failed && at_fn_log_failure 6491 $at_traceon; } 6492 6493 { set +x 6494 $as_echo "$at_srcdir/input.at:781: \$CC \$CFLAGS \$CPPFLAGS -c -o input.o input.c " 6495 at_fn_check_prepare_dynamic "$CC $CFLAGS $CPPFLAGS -c -o input.o input.c " "input.at:781" 6496 ( $at_check_trace; $CC $CFLAGS $CPPFLAGS -c -o input.o input.c 6497 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6498 at_status=$? at_failed=false 6499 $at_check_filter 6500 echo stderr:; cat "$at_stderr" 6501 echo stdout:; cat "$at_stdout" 6502 at_fn_check_status 0 $at_status "$at_srcdir/input.at:781" 6503 $at_failed && at_fn_log_failure 6504 $at_traceon; } 6505 6506 6507 6508 # Periods are genuine letters, they can start identifiers. 6509 # Digits and dashes cannot. 6510 cat >input.y <<'_ATEOF' 6511 %code top { 6512 #include <config.h> 6513 /* We don't need perfect functions for these tests. */ 6514 #undef malloc 6515 #undef memcmp 6516 #undef realloc 6517 } 6518 6519 %token .GOOD 6520 -GOOD 6521 1NV4L1D 6522 -123 6523 %% 6524 start: .GOOD GOOD 6525 _ATEOF 6526 6527 6528 6529 { set +x 6530 $as_echo "$at_srcdir/input.at:794: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o input.c input.y" 6531 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o input.c input.y" "input.at:794" 6532 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -o input.c input.y 6533 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6534 at_status=$? at_failed=false 6535 $at_check_filter 6536 echo >>"$at_stderr"; $as_echo "input.y:10.10: error: invalid character: '-' 6537 input.y:11.10-16: error: invalid identifier: '1NV4L1D' 6538 input.y:12.10: error: invalid character: '-' 6539 " | \ 6540 $at_diff - "$at_stderr" || at_failed=: 6541 at_fn_diff_devnull "$at_stdout" || at_failed=: 6542 at_fn_check_status 1 $at_status "$at_srcdir/input.at:794" 6543 $at_failed && at_fn_log_failure 6544 $at_traceon; } 6545 6546 6547 6548 set +x 6549 $at_times_p && times >"$at_times_file" 6550 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 6551 read at_status <"$at_status_file" 6552 #AT_STOP_18 6553 #AT_START_19 6554 at_fn_group_banner 19 'input.at:807' \ 6555 "Numbered tokens" " " 1 6556 at_xfail=no 6557 ( 6558 $as_echo "19. $at_setup_line: testing $at_desc ..." 6559 $at_traceon 6560 6561 6562 cat >redecl.y <<'_ATEOF' 6563 %code top { 6564 #include <config.h> 6565 /* We don't need perfect functions for these tests. */ 6566 #undef malloc 6567 #undef memcmp 6568 #undef realloc 6569 } 6570 6571 %token DECIMAL_1 11259375 6572 HEXADECIMAL_1 0xabcdef 6573 HEXADECIMAL_2 0xFEDCBA 6574 DECIMAL_2 16702650 6575 %% 6576 start: DECIMAL_1 HEXADECIMAL_2; 6577 _ATEOF 6578 6579 6580 6581 6582 { set +x 6583 $as_echo "$at_srcdir/input.at:818: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison redecl.y" 6584 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison redecl.y" "input.at:818" 6585 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison redecl.y 6586 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6587 at_status=$? at_failed=false 6588 $at_check_filter 6589 echo >>"$at_stderr"; $as_echo "redecl.y:10.10-22: error: user token number 11259375 redeclaration for HEXADECIMAL_1 6590 redecl.y:9.8-16: previous declaration for DECIMAL_1 6591 redecl.y:12.10-18: error: user token number 16702650 redeclaration for DECIMAL_2 6592 redecl.y:11.10-22: previous declaration for HEXADECIMAL_2 6593 " | \ 6594 $at_diff - "$at_stderr" || at_failed=: 6595 at_fn_diff_devnull "$at_stdout" || at_failed=: 6596 at_fn_check_status 1 $at_status "$at_srcdir/input.at:818" 6597 $at_failed && at_fn_log_failure 6598 $at_traceon; } 6599 6600 6601 6602 cat >too-large.y <<'_ATEOF' 6603 %code top { 6604 #include <config.h> 6605 /* We don't need perfect functions for these tests. */ 6606 #undef malloc 6607 #undef memcmp 6608 #undef realloc 6609 } 6610 6611 %token TOO_LARGE_DEC 999999999999999999999 6612 TOO_LARGE_HEX 0xFFFFFFFFFFFFFFFFFFF 6613 %% 6614 start: TOO_LARGE_DEC TOO_LARGE_HEX 6615 %% 6616 _ATEOF 6617 6618 6619 6620 6621 { set +x 6622 $as_echo "$at_srcdir/input.at:833: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison too-large.y" 6623 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison too-large.y" "input.at:833" 6624 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison too-large.y 6625 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6626 at_status=$? at_failed=false 6627 $at_check_filter 6628 echo >>"$at_stderr"; $as_echo "too-large.y:9.22-42: error: integer out of range: '999999999999999999999' 6629 too-large.y:10.24-44: error: integer out of range: '0xFFFFFFFFFFFFFFFFFFF' 6630 " | \ 6631 $at_diff - "$at_stderr" || at_failed=: 6632 at_fn_diff_devnull "$at_stdout" || at_failed=: 6633 at_fn_check_status 1 $at_status "$at_srcdir/input.at:833" 6634 $at_failed && at_fn_log_failure 6635 $at_traceon; } 6636 6637 6638 6639 set +x 6640 $at_times_p && times >"$at_times_file" 6641 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 6642 read at_status <"$at_status_file" 6643 #AT_STOP_19 6644 #AT_START_20 6645 at_fn_group_banner 20 'input.at:845' \ 6646 "Unclosed constructs" " " 1 6647 at_xfail=no 6648 ( 6649 $as_echo "20. $at_setup_line: testing $at_desc ..." 6650 $at_traceon 6651 6652 6653 # Bison's scan-gram.l once forgot to STRING_FINISH some unclosed constructs, so 6654 # they were prepended to whatever it STRING_GROW'ed next. It also threw them 6655 # away rather than returning them to the parser. The effect was confusing 6656 # subsequent error messages. 6657 6658 cat >input.y <<'_ATEOF' 6659 %token A "a 6660 %token B "b" 6661 %token AB "ab" // Used to complain that "ab" was already used. 6662 %token C '1 6663 %token TWO "2" 6664 %token TICK_TWELVE "'12" // Used to complain that "'12" was already used. 6665 6666 %% 6667 6668 start: ; 6669 6670 // Used to report a syntax error because it didn't see any kind of symbol 6671 // identifier. 6672 %type <f> 'a 6673 ; 6674 %type <f> "a 6675 ; 6676 // Used to report a syntax error because it didn't see braced code. 6677 %destructor { free ($$) 6678 _ATEOF 6679 6680 6681 6682 { set +x 6683 $as_echo "$at_srcdir/input.at:874: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o input.c input.y" 6684 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o input.c input.y" "input.at:874" 6685 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -o input.c input.y 6686 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6687 at_status=$? at_failed=false 6688 $at_check_filter 6689 echo >>"$at_stderr"; $as_echo "input.y:1.10-2.0: error: missing '\"' at end of line 6690 input.y:4.10-5.0: error: missing \"'\" at end of line 6691 input.y:14.11-15.0: error: missing \"'\" at end of line 6692 input.y:16.11-17.0: error: missing '\"' at end of line 6693 input.y:19.13-20.0: error: missing '}' at end of file 6694 input.y:20.1: error: syntax error, unexpected end of file 6695 " | \ 6696 $at_diff - "$at_stderr" || at_failed=: 6697 at_fn_diff_devnull "$at_stdout" || at_failed=: 6698 at_fn_check_status 1 $at_status "$at_srcdir/input.at:874" 6699 $at_failed && at_fn_log_failure 6700 $at_traceon; } 6701 6702 6703 6704 6705 { set +x 6706 $as_echo "$at_srcdir/input.at:883: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret -o input.c input.y" 6707 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret -o input.c input.y" "input.at:883" 6708 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -fcaret -o input.c input.y 6709 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6710 at_status=$? at_failed=false 6711 $at_check_filter 6712 echo >>"$at_stderr"; $as_echo "input.y:1.10-2.0: error: missing '\"' at end of line 6713 %token A \"a 6714 ^^ 6715 input.y:4.10-5.0: error: missing \"'\" at end of line 6716 %token C '1 6717 ^^ 6718 input.y:14.11-15.0: error: missing \"'\" at end of line 6719 %type <f> 'a 6720 ^^ 6721 input.y:16.11-17.0: error: missing '\"' at end of line 6722 %type <f> \"a 6723 ^^ 6724 input.y:19.13-20.0: error: missing '}' at end of file 6725 %destructor { free (\$\$) 6726 ^^^^^^^^^^^ 6727 input.y:20.1: error: syntax error, unexpected end of file 6728 " | \ 6729 $at_diff - "$at_stderr" || at_failed=: 6730 at_fn_diff_devnull "$at_stdout" || at_failed=: 6731 at_fn_check_status 1 $at_status "$at_srcdir/input.at:883" 6732 $at_failed && at_fn_log_failure 6733 $at_traceon; } 6734 6735 6736 6737 set +x 6738 $at_times_p && times >"$at_times_file" 6739 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 6740 read at_status <"$at_status_file" 6741 #AT_STOP_20 6742 #AT_START_21 6743 at_fn_group_banner 21 'input.at:909' \ 6744 "%start after first rule" " " 1 6745 at_xfail=no 6746 ( 6747 $as_echo "21. $at_setup_line: testing $at_desc ..." 6748 $at_traceon 6749 6750 6751 # Bison once complained that a %start after the first rule was a redeclaration 6752 # of the start symbol. 6753 6754 cat >input.y <<'_ATEOF' 6755 %% 6756 false_start: ; 6757 start: false_start ; 6758 %start start; 6759 _ATEOF 6760 6761 6762 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 6763 at_save_special_files 6764 mkdir xml-tests 6765 # Don't combine these Bison invocations since we want to be sure that 6766 # --report=all isn't required to get the full XML file. 6767 { set +x 6768 $as_echo "$at_srcdir/input.at:921: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 6769 --graph=xml-tests/test.dot -o input.c input.y" 6770 at_fn_check_prepare_notrace 'an embedded newline' "input.at:921" 6771 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 6772 --graph=xml-tests/test.dot -o input.c input.y 6773 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6774 at_status=$? at_failed=false 6775 $at_check_filter 6776 echo stderr:; cat "$at_stderr" 6777 echo stdout:; cat "$at_stdout" 6778 at_fn_check_status 0 $at_status "$at_srcdir/input.at:921" 6779 $at_failed && at_fn_log_failure 6780 $at_traceon; } 6781 6782 { set +x 6783 $as_echo "$at_srcdir/input.at:921: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o input.c input.y" 6784 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o input.c input.y" "input.at:921" 6785 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o input.c input.y 6786 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6787 at_status=$? at_failed=false 6788 $at_check_filter 6789 echo stderr:; cat "$at_stderr" 6790 echo stdout:; cat "$at_stdout" 6791 at_fn_check_status 0 $at_status "$at_srcdir/input.at:921" 6792 $at_failed && at_fn_log_failure 6793 $at_traceon; } 6794 6795 cp xml-tests/test.output expout 6796 { set +x 6797 $as_echo "$at_srcdir/input.at:921: \$XSLTPROC \\ 6798 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 6799 xml-tests/test.xml" 6800 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:921" 6801 ( $at_check_trace; $XSLTPROC \ 6802 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 6803 xml-tests/test.xml 6804 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6805 at_status=$? at_failed=false 6806 $at_check_filter 6807 at_fn_diff_devnull "$at_stderr" || at_failed=: 6808 $at_diff expout "$at_stdout" || at_failed=: 6809 at_fn_check_status 0 $at_status "$at_srcdir/input.at:921" 6810 $at_failed && at_fn_log_failure 6811 $at_traceon; } 6812 6813 sort xml-tests/test.dot > expout 6814 { set +x 6815 $as_echo "$at_srcdir/input.at:921: \$XSLTPROC \\ 6816 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 6817 xml-tests/test.xml | sort" 6818 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:921" 6819 ( $at_check_trace; $XSLTPROC \ 6820 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 6821 xml-tests/test.xml | sort 6822 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6823 at_status=$? at_failed=false 6824 $at_check_filter 6825 at_fn_diff_devnull "$at_stderr" || at_failed=: 6826 $at_diff expout "$at_stdout" || at_failed=: 6827 at_fn_check_status 0 $at_status "$at_srcdir/input.at:921" 6828 $at_failed && at_fn_log_failure 6829 $at_traceon; } 6830 6831 rm -rf xml-tests expout 6832 at_restore_special_files 6833 fi 6834 { set +x 6835 $as_echo "$at_srcdir/input.at:921: bison -o input.c input.y" 6836 at_fn_check_prepare_trace "input.at:921" 6837 ( $at_check_trace; bison -o input.c input.y 6838 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6839 at_status=$? at_failed=false 6840 $at_check_filter 6841 at_fn_diff_devnull "$at_stderr" || at_failed=: 6842 at_fn_diff_devnull "$at_stdout" || at_failed=: 6843 at_fn_check_status 0 $at_status "$at_srcdir/input.at:921" 6844 $at_failed && at_fn_log_failure 6845 $at_traceon; } 6846 6847 6848 6849 set +x 6850 $at_times_p && times >"$at_times_file" 6851 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 6852 read at_status <"$at_status_file" 6853 #AT_STOP_21 6854 #AT_START_22 6855 at_fn_group_banner 22 'input.at:930' \ 6856 "%prec takes a token" " " 1 6857 at_xfail=no 6858 ( 6859 $as_echo "22. $at_setup_line: testing $at_desc ..." 6860 $at_traceon 6861 6862 6863 # Bison once allowed %prec sym where sym was a nonterminal. 6864 6865 cat >input.y <<'_ATEOF' 6866 %% 6867 start: PREC %prec PREC ; 6868 PREC: ; 6869 _ATEOF 6870 6871 6872 6873 { set +x 6874 $as_echo "$at_srcdir/input.at:940: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 6875 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:940" 6876 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 6877 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6878 at_status=$? at_failed=false 6879 $at_check_filter 6880 echo >>"$at_stderr"; $as_echo "input.y:3.1-4: error: rule given for PREC, which is a token 6881 " | \ 6882 $at_diff - "$at_stderr" || at_failed=: 6883 at_fn_diff_devnull "$at_stdout" || at_failed=: 6884 at_fn_check_status 1 $at_status "$at_srcdir/input.at:940" 6885 $at_failed && at_fn_log_failure 6886 $at_traceon; } 6887 6888 6889 6890 set +x 6891 $at_times_p && times >"$at_times_file" 6892 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 6893 read at_status <"$at_status_file" 6894 #AT_STOP_22 6895 #AT_START_23 6896 at_fn_group_banner 23 'input.at:951' \ 6897 "%prec's token must be defined" " " 1 6898 at_xfail=no 6899 ( 6900 $as_echo "23. $at_setup_line: testing $at_desc ..." 6901 $at_traceon 6902 6903 6904 # According to POSIX, a %prec token must be defined separately. 6905 6906 cat >input.y <<'_ATEOF' 6907 %% 6908 start: %prec PREC ; 6909 _ATEOF 6910 6911 6912 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 6913 at_save_special_files 6914 mkdir xml-tests 6915 # Don't combine these Bison invocations since we want to be sure that 6916 # --report=all isn't required to get the full XML file. 6917 { set +x 6918 $as_echo "$at_srcdir/input.at:960: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 6919 --graph=xml-tests/test.dot input.y" 6920 at_fn_check_prepare_notrace 'an embedded newline' "input.at:960" 6921 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 6922 --graph=xml-tests/test.dot input.y 6923 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6924 at_status=$? at_failed=false 6925 $at_check_filter 6926 echo stderr:; cat "$at_stderr" 6927 echo stdout:; cat "$at_stdout" 6928 at_fn_check_status 0 $at_status "$at_srcdir/input.at:960" 6929 $at_failed && at_fn_log_failure 6930 $at_traceon; } 6931 6932 { set +x 6933 $as_echo "$at_srcdir/input.at:960: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y" 6934 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y" "input.at:960" 6935 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y 6936 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6937 at_status=$? at_failed=false 6938 $at_check_filter 6939 echo stderr:; cat "$at_stderr" 6940 echo stdout:; cat "$at_stdout" 6941 at_fn_check_status 0 $at_status "$at_srcdir/input.at:960" 6942 $at_failed && at_fn_log_failure 6943 $at_traceon; } 6944 6945 cp xml-tests/test.output expout 6946 { set +x 6947 $as_echo "$at_srcdir/input.at:960: \$XSLTPROC \\ 6948 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 6949 xml-tests/test.xml" 6950 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:960" 6951 ( $at_check_trace; $XSLTPROC \ 6952 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 6953 xml-tests/test.xml 6954 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6955 at_status=$? at_failed=false 6956 $at_check_filter 6957 at_fn_diff_devnull "$at_stderr" || at_failed=: 6958 $at_diff expout "$at_stdout" || at_failed=: 6959 at_fn_check_status 0 $at_status "$at_srcdir/input.at:960" 6960 $at_failed && at_fn_log_failure 6961 $at_traceon; } 6962 6963 sort xml-tests/test.dot > expout 6964 { set +x 6965 $as_echo "$at_srcdir/input.at:960: \$XSLTPROC \\ 6966 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 6967 xml-tests/test.xml | sort" 6968 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:960" 6969 ( $at_check_trace; $XSLTPROC \ 6970 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 6971 xml-tests/test.xml | sort 6972 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6973 at_status=$? at_failed=false 6974 $at_check_filter 6975 at_fn_diff_devnull "$at_stderr" || at_failed=: 6976 $at_diff expout "$at_stdout" || at_failed=: 6977 at_fn_check_status 0 $at_status "$at_srcdir/input.at:960" 6978 $at_failed && at_fn_log_failure 6979 $at_traceon; } 6980 6981 rm -rf xml-tests expout 6982 at_restore_special_files 6983 fi 6984 { set +x 6985 $as_echo "$at_srcdir/input.at:960: bison input.y" 6986 at_fn_check_prepare_trace "input.at:960" 6987 ( $at_check_trace; bison input.y 6988 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 6989 at_status=$? at_failed=false 6990 $at_check_filter 6991 echo >>"$at_stderr"; $as_echo "input.y:2.8-17: warning: token for %prec is not defined: PREC 6992 " | \ 6993 $at_diff - "$at_stderr" || at_failed=: 6994 at_fn_diff_devnull "$at_stdout" || at_failed=: 6995 at_fn_check_status 0 $at_status "$at_srcdir/input.at:960" 6996 $at_failed && at_fn_log_failure 6997 $at_traceon; } 6998 6999 # Defining POSIXLY_CORRECT causes bison to complain if options are 7000 # added after the grammar file name, so skip these checks in that 7001 # case. 7002 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 7003 at_save_special_files 7004 7005 # To avoid expanding it repeatedly, store specified stdout. 7006 : >expout 7007 7008 # Run with -Werror. 7009 { set +x 7010 $as_echo "$at_srcdir/input.at:960: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Werror" 7011 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Werror" "input.at:960" 7012 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y -Werror 7013 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7014 at_status=$? at_failed=false 7015 $at_check_filter 7016 echo stderr:; tee stderr <"$at_stderr" 7017 $at_diff expout "$at_stdout" || at_failed=: 7018 at_fn_check_status 1 $at_status "$at_srcdir/input.at:960" 7019 $at_failed && at_fn_log_failure 7020 $at_traceon; } 7021 7022 7023 # Build expected stderr up to and including the "warnings being 7024 # treated as errors" message. 7025 cat >at-bison-check-warnings <<'_ATEOF' 7026 input.y:2.8-17: warning: token for %prec is not defined: PREC 7027 _ATEOF 7028 7029 at_bison_check_first=`sed -n \ 7030 '/: warning: /{=;q;}' at-bison-check-warnings` 7031 : ${at_bison_check_first:=1} 7032 at_bison_check_first_tmp=`sed -n \ 7033 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 7034 : ${at_bison_check_first_tmp:=1} 7035 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 7036 at_bison_check_first=$at_bison_check_first_tmp 7037 fi 7038 if test $at_bison_check_first -gt 1; then 7039 sed -n "1,`expr $at_bison_check_first - 1`"p \ 7040 at-bison-check-warnings > experr 7041 fi 7042 echo 'bison: warnings being treated as errors' >> experr 7043 7044 # Finish building expected stderr and check. Unlike warnings, 7045 # complaints cause bison to exit early. Thus, with -Werror, bison 7046 # does not necessarily report all warnings that it does without 7047 # -Werror, but it at least reports one. 7048 at_bison_check_last=`sed -n '$=' stderr` 7049 : ${at_bison_check_last:=1} 7050 at_bison_check_last=`expr $at_bison_check_last - 1` 7051 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 7052 at-bison-check-warnings >> experr 7053 { set +x 7054 $as_echo "$at_srcdir/input.at:960: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 7055 stderr 1>&2" 7056 at_fn_check_prepare_notrace 'an embedded newline' "input.at:960" 7057 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 7058 stderr 1>&2 7059 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7060 at_status=$? at_failed=false 7061 $at_check_filter 7062 $at_diff experr "$at_stderr" || at_failed=: 7063 at_fn_diff_devnull "$at_stdout" || at_failed=: 7064 at_fn_check_status 0 $at_status "$at_srcdir/input.at:960" 7065 $at_failed && at_fn_log_failure 7066 $at_traceon; } 7067 7068 7069 # Now check --warnings=error. 7070 cp stderr experr 7071 { set +x 7072 $as_echo "$at_srcdir/input.at:960: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=error" 7073 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=error" "input.at:960" 7074 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y --warnings=error 7075 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7076 at_status=$? at_failed=false 7077 $at_check_filter 7078 $at_diff experr "$at_stderr" || at_failed=: 7079 $at_diff expout "$at_stdout" || at_failed=: 7080 at_fn_check_status 1 $at_status "$at_srcdir/input.at:960" 7081 $at_failed && at_fn_log_failure 7082 $at_traceon; } 7083 7084 7085 # Now check -Wnone and --warnings=none by making sure that 7086 # -Werror doesn't change the exit status when -Wnone or 7087 # --warnings=none is specified. 7088 { set +x 7089 $as_echo "$at_srcdir/input.at:960: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Wnone -Werror" 7090 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Wnone -Werror" "input.at:960" 7091 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y -Wnone -Werror 7092 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7093 at_status=$? at_failed=false 7094 $at_check_filter 7095 at_fn_diff_devnull "$at_stderr" || at_failed=: 7096 $at_diff expout "$at_stdout" || at_failed=: 7097 at_fn_check_status 0 $at_status "$at_srcdir/input.at:960" 7098 $at_failed && at_fn_log_failure 7099 $at_traceon; } 7100 7101 { set +x 7102 $as_echo "$at_srcdir/input.at:960: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror" 7103 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror" "input.at:960" 7104 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror 7105 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7106 at_status=$? at_failed=false 7107 $at_check_filter 7108 at_fn_diff_devnull "$at_stderr" || at_failed=: 7109 $at_diff expout "$at_stdout" || at_failed=: 7110 at_fn_check_status 0 $at_status "$at_srcdir/input.at:960" 7111 $at_failed && at_fn_log_failure 7112 $at_traceon; } 7113 7114 7115 at_restore_special_files 7116 fi 7117 7118 set +x 7119 $at_times_p && times >"$at_times_file" 7120 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 7121 read at_status <"$at_status_file" 7122 #AT_STOP_23 7123 #AT_START_24 7124 at_fn_group_banner 24 'input.at:971' \ 7125 "Reject unused %code qualifiers" " " 1 7126 at_xfail=no 7127 ( 7128 $as_echo "24. $at_setup_line: testing $at_desc ..." 7129 $at_traceon 7130 7131 7132 cat >input-c.y <<'_ATEOF' 7133 %code q {} 7134 %code bad {} 7135 %code bad {} 7136 %code format {} 7137 %% 7138 start: ; 7139 _ATEOF 7140 7141 7142 { set +x 7143 $as_echo "$at_srcdir/input.at:981: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input-c.y" 7144 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input-c.y" "input.at:981" 7145 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input-c.y 7146 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7147 at_status=$? at_failed=false 7148 $at_check_filter 7149 echo >>"$at_stderr"; $as_echo "input-c.y:1.7: error: %code qualifier 'q' is not used 7150 input-c.y:2.7-9: error: %code qualifier 'bad' is not used 7151 input-c.y:3.7-9: error: %code qualifier 'bad' is not used 7152 input-c.y:4.7-12: error: %code qualifier 'format' is not used 7153 " | \ 7154 $at_diff - "$at_stderr" || at_failed=: 7155 at_fn_diff_devnull "$at_stdout" || at_failed=: 7156 at_fn_check_status 1 $at_status "$at_srcdir/input.at:981" 7157 $at_failed && at_fn_log_failure 7158 $at_traceon; } 7159 7160 7161 7162 cat >input-c-glr.y <<'_ATEOF' 7163 %code q {} 7164 %code bad {} 7165 %code bad {} 7166 %% 7167 start: ; 7168 _ATEOF 7169 7170 7171 { set +x 7172 $as_echo "$at_srcdir/input.at:995: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input-c-glr.y" 7173 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input-c-glr.y" "input.at:995" 7174 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input-c-glr.y 7175 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7176 at_status=$? at_failed=false 7177 $at_check_filter 7178 echo >>"$at_stderr"; $as_echo "input-c-glr.y:1.7: error: %code qualifier 'q' is not used 7179 input-c-glr.y:2.7-9: error: %code qualifier 'bad' is not used 7180 input-c-glr.y:3.8-10: error: %code qualifier 'bad' is not used 7181 " | \ 7182 $at_diff - "$at_stderr" || at_failed=: 7183 at_fn_diff_devnull "$at_stdout" || at_failed=: 7184 at_fn_check_status 1 $at_status "$at_srcdir/input.at:995" 7185 $at_failed && at_fn_log_failure 7186 $at_traceon; } 7187 7188 7189 7190 cat >input-c++.y <<'_ATEOF' 7191 %code q {} 7192 %code bad {} 7193 %code q {} 7194 %% 7195 start: ; 7196 _ATEOF 7197 7198 7199 { set +x 7200 $as_echo "$at_srcdir/input.at:1008: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input-c++.y" 7201 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input-c++.y" "input.at:1008" 7202 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input-c++.y 7203 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7204 at_status=$? at_failed=false 7205 $at_check_filter 7206 echo >>"$at_stderr"; $as_echo "input-c++.y:1.7: error: %code qualifier 'q' is not used 7207 input-c++.y:2.7-9: error: %code qualifier 'bad' is not used 7208 input-c++.y:3.8: error: %code qualifier 'q' is not used 7209 " | \ 7210 $at_diff - "$at_stderr" || at_failed=: 7211 at_fn_diff_devnull "$at_stdout" || at_failed=: 7212 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1008" 7213 $at_failed && at_fn_log_failure 7214 $at_traceon; } 7215 7216 7217 7218 cat >input-c++-glr.y <<'_ATEOF' 7219 %code bad {} 7220 %code q {} 7221 %code q {} 7222 %% 7223 start: ; 7224 _ATEOF 7225 7226 7227 { set +x 7228 $as_echo "$at_srcdir/input.at:1021: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input-c++-glr.y" 7229 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input-c++-glr.y" "input.at:1021" 7230 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input-c++-glr.y 7231 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7232 at_status=$? at_failed=false 7233 $at_check_filter 7234 echo >>"$at_stderr"; $as_echo "input-c++-glr.y:1.7-9: error: %code qualifier 'bad' is not used 7235 input-c++-glr.y:2.7: error: %code qualifier 'q' is not used 7236 input-c++-glr.y:3.7: error: %code qualifier 'q' is not used 7237 " | \ 7238 $at_diff - "$at_stderr" || at_failed=: 7239 at_fn_diff_devnull "$at_stdout" || at_failed=: 7240 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1021" 7241 $at_failed && at_fn_log_failure 7242 $at_traceon; } 7243 7244 7245 7246 cat >special-char-@@.y <<'_ATEOF' 7247 %code bad {} 7248 %code q {} 7249 %code q {} 7250 %% 7251 start: ; 7252 _ATEOF 7253 7254 7255 { set +x 7256 $as_echo "$at_srcdir/input.at:1034: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison special-char-@@.y" 7257 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison special-char-@@.y" "input.at:1034" 7258 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison special-char-@@.y 7259 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7260 at_status=$? at_failed=false 7261 $at_check_filter 7262 echo >>"$at_stderr"; $as_echo "special-char-@@.y:1.7-9: error: %code qualifier 'bad' is not used 7263 special-char-@@.y:2.7: error: %code qualifier 'q' is not used 7264 special-char-@@.y:3.7: error: %code qualifier 'q' is not used 7265 " | \ 7266 $at_diff - "$at_stderr" || at_failed=: 7267 at_fn_diff_devnull "$at_stdout" || at_failed=: 7268 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1034" 7269 $at_failed && at_fn_log_failure 7270 $at_traceon; } 7271 7272 7273 7274 cat >special-char-].y <<'_ATEOF' 7275 %code bad {} 7276 %code q {} 7277 %code q {} 7278 %% 7279 start: ; 7280 _ATEOF 7281 7282 7283 { set +x 7284 $as_echo "$at_srcdir/input.at:1047: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison special-char-].y" 7285 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison special-char-].y" "input.at:1047" 7286 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison special-char-].y 7287 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7288 at_status=$? at_failed=false 7289 $at_check_filter 7290 echo >>"$at_stderr"; $as_echo "special-char-].y:1.7-9: error: %code qualifier 'bad' is not used 7291 special-char-].y:2.7: error: %code qualifier 'q' is not used 7292 special-char-].y:3.7: error: %code qualifier 'q' is not used 7293 " | \ 7294 $at_diff - "$at_stderr" || at_failed=: 7295 at_fn_diff_devnull "$at_stdout" || at_failed=: 7296 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1047" 7297 $at_failed && at_fn_log_failure 7298 $at_traceon; } 7299 7300 7301 7302 set +x 7303 $at_times_p && times >"$at_times_file" 7304 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 7305 read at_status <"$at_status_file" 7306 #AT_STOP_24 7307 #AT_START_25 7308 at_fn_group_banner 25 'input.at:1060' \ 7309 "%define errors" " " 1 7310 at_xfail=no 7311 ( 7312 $as_echo "25. $at_setup_line: testing $at_desc ..." 7313 $at_traceon 7314 7315 7316 cat >input-redefined.y <<'_ATEOF' 7317 %define var "value1" 7318 %define var "value1" 7319 %define var "value2" 7320 %define special1 "]" 7321 %define special2 "[" 7322 %% 7323 start: ; 7324 _ATEOF 7325 7326 7327 7328 { set +x 7329 $as_echo "$at_srcdir/input.at:1072: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input-redefined.y" 7330 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input-redefined.y" "input.at:1072" 7331 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input-redefined.y 7332 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7333 at_status=$? at_failed=false 7334 $at_check_filter 7335 echo >>"$at_stderr"; $as_echo "input-redefined.y:2.9-11: error: %define variable 'var' redefined 7336 input-redefined.y:1.9-11: previous definition 7337 input-redefined.y:3.10-12: error: %define variable 'var' redefined 7338 input-redefined.y:2.9-11: previous definition 7339 " | \ 7340 $at_diff - "$at_stderr" || at_failed=: 7341 at_fn_diff_devnull "$at_stdout" || at_failed=: 7342 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1072" 7343 $at_failed && at_fn_log_failure 7344 $at_traceon; } 7345 7346 7347 7348 cat >input-unused.y <<'_ATEOF' 7349 %define var "value" 7350 %% 7351 start: ; 7352 _ATEOF 7353 7354 7355 7356 { set +x 7357 $as_echo "$at_srcdir/input.at:1085: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input-unused.y" 7358 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input-unused.y" "input.at:1085" 7359 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input-unused.y 7360 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7361 at_status=$? at_failed=false 7362 $at_check_filter 7363 echo >>"$at_stderr"; $as_echo "input-unused.y:1.9-11: error: %define variable 'var' is not used 7364 " | \ 7365 $at_diff - "$at_stderr" || at_failed=: 7366 at_fn_diff_devnull "$at_stdout" || at_failed=: 7367 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1085" 7368 $at_failed && at_fn_log_failure 7369 $at_traceon; } 7370 7371 7372 7373 set +x 7374 $at_times_p && times >"$at_times_file" 7375 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 7376 read at_status <"$at_status_file" 7377 #AT_STOP_25 7378 #AT_START_26 7379 at_fn_group_banner 26 'input.at:1096' \ 7380 "%define, --define, --force-define" " " 1 7381 at_xfail=no 7382 ( 7383 $as_echo "26. $at_setup_line: testing $at_desc ..." 7384 $at_traceon 7385 7386 7387 cat >skel.c <<'_ATEOF' 7388 m4_divert_push(0)@ 7389 @output(b4_parser_file_name@)@ 7390 [var-dd: ]b4_percent_define_get([[var-dd]])[ 7391 var-ff: ]b4_percent_define_get([[var-ff]])[ 7392 var-dfg: ]b4_percent_define_get([[var-dfg]])[ 7393 var-fd: ]b4_percent_define_get([[var-fd]]) 7394 m4_divert_pop(0) 7395 _ATEOF 7396 7397 cat >input.y <<'_ATEOF' 7398 %define var-dfg "gram" 7399 %% 7400 start: ; 7401 _ATEOF 7402 7403 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 7404 at_save_special_files 7405 mkdir xml-tests 7406 # Don't combine these Bison invocations since we want to be sure that 7407 # --report=all isn't required to get the full XML file. 7408 { set +x 7409 $as_echo "$at_srcdir/input.at:1112: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 7410 --graph=xml-tests/test.dot -Dvar-dd=cmd-d1 -Dvar-dd=cmd-d2 \\ 7411 -Fvar-ff=cmd-f1 -Fvar-ff=cmd-f2 \\ 7412 -Dvar-dfg=cmd-d -Fvar-dfg=cmd-f \\ 7413 -Fvar-fd=cmd-f -Dvar-fd=cmd-d \\ 7414 --skeleton ./skel.c input.y" 7415 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1112" 7416 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 7417 --graph=xml-tests/test.dot -Dvar-dd=cmd-d1 -Dvar-dd=cmd-d2 \ 7418 -Fvar-ff=cmd-f1 -Fvar-ff=cmd-f2 \ 7419 -Dvar-dfg=cmd-d -Fvar-dfg=cmd-f \ 7420 -Fvar-fd=cmd-f -Dvar-fd=cmd-d \ 7421 --skeleton ./skel.c input.y 7422 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7423 at_status=$? at_failed=false 7424 $at_check_filter 7425 echo stderr:; cat "$at_stderr" 7426 echo stdout:; cat "$at_stdout" 7427 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1112" 7428 $at_failed && at_fn_log_failure 7429 $at_traceon; } 7430 7431 { set +x 7432 $as_echo "$at_srcdir/input.at:1112: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -Dvar-dd=cmd-d1 -Dvar-dd=cmd-d2 \\ 7433 -Fvar-ff=cmd-f1 -Fvar-ff=cmd-f2 \\ 7434 -Dvar-dfg=cmd-d -Fvar-dfg=cmd-f \\ 7435 -Fvar-fd=cmd-f -Dvar-fd=cmd-d \\ 7436 --skeleton ./skel.c input.y" 7437 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1112" 7438 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -Dvar-dd=cmd-d1 -Dvar-dd=cmd-d2 \ 7439 -Fvar-ff=cmd-f1 -Fvar-ff=cmd-f2 \ 7440 -Dvar-dfg=cmd-d -Fvar-dfg=cmd-f \ 7441 -Fvar-fd=cmd-f -Dvar-fd=cmd-d \ 7442 --skeleton ./skel.c input.y 7443 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7444 at_status=$? at_failed=false 7445 $at_check_filter 7446 echo stderr:; cat "$at_stderr" 7447 echo stdout:; cat "$at_stdout" 7448 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1112" 7449 $at_failed && at_fn_log_failure 7450 $at_traceon; } 7451 7452 cp xml-tests/test.output expout 7453 { set +x 7454 $as_echo "$at_srcdir/input.at:1112: \$XSLTPROC \\ 7455 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 7456 xml-tests/test.xml" 7457 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1112" 7458 ( $at_check_trace; $XSLTPROC \ 7459 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 7460 xml-tests/test.xml 7461 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7462 at_status=$? at_failed=false 7463 $at_check_filter 7464 at_fn_diff_devnull "$at_stderr" || at_failed=: 7465 $at_diff expout "$at_stdout" || at_failed=: 7466 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1112" 7467 $at_failed && at_fn_log_failure 7468 $at_traceon; } 7469 7470 sort xml-tests/test.dot > expout 7471 { set +x 7472 $as_echo "$at_srcdir/input.at:1112: \$XSLTPROC \\ 7473 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 7474 xml-tests/test.xml | sort" 7475 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1112" 7476 ( $at_check_trace; $XSLTPROC \ 7477 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 7478 xml-tests/test.xml | sort 7479 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7480 at_status=$? at_failed=false 7481 $at_check_filter 7482 at_fn_diff_devnull "$at_stderr" || at_failed=: 7483 $at_diff expout "$at_stdout" || at_failed=: 7484 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1112" 7485 $at_failed && at_fn_log_failure 7486 $at_traceon; } 7487 7488 rm -rf xml-tests expout 7489 at_restore_special_files 7490 fi 7491 { set +x 7492 $as_echo "$at_srcdir/input.at:1112: bison -Dvar-dd=cmd-d1 -Dvar-dd=cmd-d2 \\ 7493 -Fvar-ff=cmd-f1 -Fvar-ff=cmd-f2 \\ 7494 -Dvar-dfg=cmd-d -Fvar-dfg=cmd-f \\ 7495 -Fvar-fd=cmd-f -Dvar-fd=cmd-d \\ 7496 --skeleton ./skel.c input.y" 7497 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1112" 7498 ( $at_check_trace; bison -Dvar-dd=cmd-d1 -Dvar-dd=cmd-d2 \ 7499 -Fvar-ff=cmd-f1 -Fvar-ff=cmd-f2 \ 7500 -Dvar-dfg=cmd-d -Fvar-dfg=cmd-f \ 7501 -Fvar-fd=cmd-f -Dvar-fd=cmd-d \ 7502 --skeleton ./skel.c input.y 7503 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7504 at_status=$? at_failed=false 7505 $at_check_filter 7506 at_fn_diff_devnull "$at_stderr" || at_failed=: 7507 at_fn_diff_devnull "$at_stdout" || at_failed=: 7508 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1112" 7509 $at_failed && at_fn_log_failure 7510 $at_traceon; } 7511 7512 7513 { set +x 7514 $as_echo "$at_srcdir/input.at:1117: cat input.tab.c" 7515 at_fn_check_prepare_trace "input.at:1117" 7516 ( $at_check_trace; cat input.tab.c 7517 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7518 at_status=$? at_failed=false 7519 $at_check_filter 7520 at_fn_diff_devnull "$at_stderr" || at_failed=: 7521 echo >>"$at_stdout"; $as_echo "var-dd: cmd-d2 7522 var-ff: cmd-f2 7523 var-dfg: cmd-f 7524 var-fd: cmd-d 7525 " | \ 7526 $at_diff - "$at_stdout" || at_failed=: 7527 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1117" 7528 $at_failed && at_fn_log_failure 7529 $at_traceon; } 7530 7531 7532 cat >input-dg.y <<'_ATEOF' 7533 %define var "gram" 7534 %% 7535 start: ; 7536 _ATEOF 7537 7538 7539 { set +x 7540 $as_echo "$at_srcdir/input.at:1129: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Dvar=cmd-d input-dg.y" 7541 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Dvar=cmd-d input-dg.y" "input.at:1129" 7542 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -Dvar=cmd-d input-dg.y 7543 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7544 at_status=$? at_failed=false 7545 $at_check_filter 7546 echo >>"$at_stderr"; $as_echo "input-dg.y:1.9-11: error: %define variable 'var' redefined 7547 <command line>:1: previous definition 7548 " | \ 7549 $at_diff - "$at_stderr" || at_failed=: 7550 at_fn_diff_devnull "$at_stdout" || at_failed=: 7551 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1129" 7552 $at_failed && at_fn_log_failure 7553 $at_traceon; } 7554 7555 7556 7557 cat >input-dg.y <<'_ATEOF' 7558 %define var "gram" 7559 %% 7560 start: ; 7561 _ATEOF 7562 7563 7564 { set +x 7565 $as_echo "$at_srcdir/input.at:1139: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret -Dvar=cmd-d input-dg.y" 7566 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret -Dvar=cmd-d input-dg.y" "input.at:1139" 7567 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -fcaret -Dvar=cmd-d input-dg.y 7568 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7569 at_status=$? at_failed=false 7570 $at_check_filter 7571 echo >>"$at_stderr"; $as_echo "input-dg.y:1.9-11: error: %define variable 'var' redefined 7572 %define var \"gram\" 7573 ^^^ 7574 <command line>:2: previous definition 7575 " | \ 7576 $at_diff - "$at_stderr" || at_failed=: 7577 at_fn_diff_devnull "$at_stdout" || at_failed=: 7578 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1139" 7579 $at_failed && at_fn_log_failure 7580 $at_traceon; } 7581 7582 7583 7584 cat >input-unused.y <<'_ATEOF' 7585 %% 7586 start: ; 7587 _ATEOF 7588 7589 7590 { set +x 7591 $as_echo "$at_srcdir/input.at:1150: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Dunused-d -Funused-f input-unused.y" 7592 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Dunused-d -Funused-f input-unused.y" "input.at:1150" 7593 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -Dunused-d -Funused-f input-unused.y 7594 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7595 at_status=$? at_failed=false 7596 $at_check_filter 7597 echo >>"$at_stderr"; $as_echo "<command line>:1: error: %define variable 'unused-d' is not used 7598 <command line>:2: error: %define variable 'unused-f' is not used 7599 " | \ 7600 $at_diff - "$at_stderr" || at_failed=: 7601 at_fn_diff_devnull "$at_stdout" || at_failed=: 7602 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1150" 7603 $at_failed && at_fn_log_failure 7604 $at_traceon; } 7605 7606 7607 7608 set +x 7609 $at_times_p && times >"$at_times_file" 7610 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 7611 read at_status <"$at_status_file" 7612 #AT_STOP_26 7613 #AT_START_27 7614 at_fn_group_banner 27 'input.at:1161' \ 7615 "%define Boolean variables" " " 1 7616 at_xfail=no 7617 ( 7618 $as_echo "27. $at_setup_line: testing $at_desc ..." 7619 $at_traceon 7620 7621 7622 cat >Input.y <<'_ATEOF' 7623 %language "Java" 7624 %define public "maybe" 7625 %define parser_class_name "Input" 7626 %% 7627 start: ; 7628 _ATEOF 7629 7630 7631 7632 { set +x 7633 $as_echo "$at_srcdir/input.at:1171: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison Input.y" 7634 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison Input.y" "input.at:1171" 7635 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison Input.y 7636 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7637 at_status=$? at_failed=false 7638 $at_check_filter 7639 echo >>"$at_stderr"; $as_echo "Input.y:2.9-14: error: invalid value for %define Boolean variable 'public' 7640 " | \ 7641 $at_diff - "$at_stderr" || at_failed=: 7642 at_fn_diff_devnull "$at_stdout" || at_failed=: 7643 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1171" 7644 $at_failed && at_fn_log_failure 7645 $at_traceon; } 7646 7647 7648 7649 set +x 7650 $at_times_p && times >"$at_times_file" 7651 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 7652 read at_status <"$at_status_file" 7653 #AT_STOP_27 7654 #AT_START_28 7655 at_fn_group_banner 28 'input.at:1181' \ 7656 "%define enum variables" " " 1 7657 at_xfail=no 7658 ( 7659 $as_echo "28. $at_setup_line: testing $at_desc ..." 7660 $at_traceon 7661 7662 7663 # Front-end. 7664 cat >input.y <<'_ATEOF' 7665 %define lr.default-reductions bogus 7666 %% 7667 start: ; 7668 _ATEOF 7669 7670 7671 { set +x 7672 $as_echo "$at_srcdir/input.at:1189: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 7673 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1189" 7674 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 7675 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7676 at_status=$? at_failed=false 7677 $at_check_filter 7678 echo >>"$at_stderr"; $as_echo "input.y:1.9-29: error: invalid value for %define variable 'lr.default-reductions': 'bogus' 7679 input.y:1.9-29: accepted value: 'most' 7680 input.y:1.9-29: accepted value: 'consistent' 7681 input.y:1.9-29: accepted value: 'accepting' 7682 " | \ 7683 $at_diff - "$at_stderr" || at_failed=: 7684 at_fn_diff_devnull "$at_stdout" || at_failed=: 7685 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1189" 7686 $at_failed && at_fn_log_failure 7687 $at_traceon; } 7688 7689 7690 7691 # Back-end. 7692 # FIXME: these should be indented, but we shouldn't mess with the m4 yet 7693 cat >input.y <<'_ATEOF' 7694 %define api.push-pull neither 7695 %% 7696 start: ; 7697 _ATEOF 7698 7699 7700 { set +x 7701 $as_echo "$at_srcdir/input.at:1203: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 7702 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1203" 7703 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 7704 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7705 at_status=$? at_failed=false 7706 $at_check_filter 7707 echo >>"$at_stderr"; $as_echo "input.y:1.9-21: error: invalid value for %define variable 'api.push-pull': 'neither' 7708 input.y:1.9-21: error: accepted value: 'pull' 7709 input.y:1.9-21: error: accepted value: 'push' 7710 input.y:1.9-21: error: accepted value: 'both' 7711 " | \ 7712 $at_diff - "$at_stderr" || at_failed=: 7713 at_fn_diff_devnull "$at_stdout" || at_failed=: 7714 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1203" 7715 $at_failed && at_fn_log_failure 7716 $at_traceon; } 7717 7718 7719 7720 set +x 7721 $at_times_p && times >"$at_times_file" 7722 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 7723 read at_status <"$at_status_file" 7724 #AT_STOP_28 7725 #AT_START_29 7726 at_fn_group_banner 29 'input.at:1216' \ 7727 "%define backward compatibility" " " 1 7728 at_xfail=no 7729 ( 7730 $as_echo "29. $at_setup_line: testing $at_desc ..." 7731 $at_traceon 7732 7733 7734 # The error messages tell us whether underscores in these variables are 7735 # being converted to dashes. 7736 7737 cat >input.y <<'_ATEOF' 7738 %define api.push_pull "neither" 7739 %% 7740 start: ; 7741 _ATEOF 7742 7743 7744 { set +x 7745 $as_echo "$at_srcdir/input.at:1226: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 7746 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1226" 7747 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 7748 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7749 at_status=$? at_failed=false 7750 $at_check_filter 7751 echo >>"$at_stderr"; $as_echo "input.y:1.9-21: error: invalid value for %define variable 'api.push-pull': 'neither' 7752 input.y:1.9-21: error: accepted value: 'pull' 7753 input.y:1.9-21: error: accepted value: 'push' 7754 input.y:1.9-21: error: accepted value: 'both' 7755 " | \ 7756 $at_diff - "$at_stderr" || at_failed=: 7757 at_fn_diff_devnull "$at_stdout" || at_failed=: 7758 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1226" 7759 $at_failed && at_fn_log_failure 7760 $at_traceon; } 7761 7762 7763 7764 cat >input.y <<'_ATEOF' 7765 %define lr.keep_unreachable_states maybe 7766 %% 7767 start: ; 7768 _ATEOF 7769 7770 7771 { set +x 7772 $as_echo "$at_srcdir/input.at:1238: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 7773 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1238" 7774 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 7775 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7776 at_status=$? at_failed=false 7777 $at_check_filter 7778 echo >>"$at_stderr"; $as_echo "input.y:1.9-34: error: invalid value for %define Boolean variable 'lr.keep-unreachable-states' 7779 " | \ 7780 $at_diff - "$at_stderr" || at_failed=: 7781 at_fn_diff_devnull "$at_stdout" || at_failed=: 7782 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1238" 7783 $at_failed && at_fn_log_failure 7784 $at_traceon; } 7785 7786 7787 7788 cat >input.y <<'_ATEOF' 7789 %define foo_bar "baz" 7790 %% 7791 start: ; 7792 _ATEOF 7793 7794 7795 { set +x 7796 $as_echo "$at_srcdir/input.at:1247: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 7797 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1247" 7798 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 7799 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7800 at_status=$? at_failed=false 7801 $at_check_filter 7802 echo >>"$at_stderr"; $as_echo "input.y:1.9-15: error: %define variable 'foo_bar' is not used 7803 " | \ 7804 $at_diff - "$at_stderr" || at_failed=: 7805 at_fn_diff_devnull "$at_stdout" || at_failed=: 7806 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1247" 7807 $at_failed && at_fn_log_failure 7808 $at_traceon; } 7809 7810 7811 7812 set +x 7813 $at_times_p && times >"$at_times_file" 7814 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 7815 read at_status <"$at_status_file" 7816 #AT_STOP_29 7817 #AT_START_30 7818 at_fn_group_banner 30 'input.at:1257' \ 7819 "Unused %define api.pure" " " 1 7820 at_xfail=no 7821 ( 7822 $as_echo "30. $at_setup_line: testing $at_desc ..." 7823 $at_traceon 7824 7825 7826 # AT_CHECK_API_PURE(DECLS, VALUE) 7827 # ------------------------------- 7828 # Make sure Bison reports that `%define api.pure VALUE' is unused when DECLS 7829 # are specified. 7830 7831 7832 7833 cat >input.y <<'_ATEOF' 7834 %define api.pure 7835 %language "c++" %defines 7836 %% 7837 start: ; 7838 _ATEOF 7839 7840 7841 7842 { set +x 7843 $as_echo "$at_srcdir/input.at:1277: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 7844 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1277" 7845 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 7846 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7847 at_status=$? at_failed=false 7848 $at_check_filter 7849 echo >>"$at_stderr"; $as_echo "input.y:1.9-16: error: %define variable 'api.pure' is not used 7850 " | \ 7851 $at_diff - "$at_stderr" || at_failed=: 7852 at_fn_diff_devnull "$at_stdout" || at_failed=: 7853 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1277" 7854 $at_failed && at_fn_log_failure 7855 $at_traceon; } 7856 7857 7858 7859 7860 cat >input.y <<'_ATEOF' 7861 %define api.pure false 7862 %language "c++" %defines 7863 %% 7864 start: ; 7865 _ATEOF 7866 7867 7868 7869 { set +x 7870 $as_echo "$at_srcdir/input.at:1278: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 7871 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1278" 7872 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 7873 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7874 at_status=$? at_failed=false 7875 $at_check_filter 7876 echo >>"$at_stderr"; $as_echo "input.y:1.9-16: error: %define variable 'api.pure' is not used 7877 " | \ 7878 $at_diff - "$at_stderr" || at_failed=: 7879 at_fn_diff_devnull "$at_stdout" || at_failed=: 7880 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1278" 7881 $at_failed && at_fn_log_failure 7882 $at_traceon; } 7883 7884 7885 7886 7887 cat >input.y <<'_ATEOF' 7888 %define api.pure "" 7889 %language "c++" %defines %glr-parser 7890 %% 7891 start: ; 7892 _ATEOF 7893 7894 7895 7896 { set +x 7897 $as_echo "$at_srcdir/input.at:1279: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 7898 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1279" 7899 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 7900 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7901 at_status=$? at_failed=false 7902 $at_check_filter 7903 echo >>"$at_stderr"; $as_echo "input.y:1.9-16: error: %define variable 'api.pure' is not used 7904 " | \ 7905 $at_diff - "$at_stderr" || at_failed=: 7906 at_fn_diff_devnull "$at_stdout" || at_failed=: 7907 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1279" 7908 $at_failed && at_fn_log_failure 7909 $at_traceon; } 7910 7911 7912 7913 7914 cat >input.y <<'_ATEOF' 7915 %define api.pure false 7916 %language "c++" %defines %glr-parser 7917 %% 7918 start: ; 7919 _ATEOF 7920 7921 7922 7923 { set +x 7924 $as_echo "$at_srcdir/input.at:1280: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 7925 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1280" 7926 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 7927 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7928 at_status=$? at_failed=false 7929 $at_check_filter 7930 echo >>"$at_stderr"; $as_echo "input.y:1.9-16: error: %define variable 'api.pure' is not used 7931 " | \ 7932 $at_diff - "$at_stderr" || at_failed=: 7933 at_fn_diff_devnull "$at_stdout" || at_failed=: 7934 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1280" 7935 $at_failed && at_fn_log_failure 7936 $at_traceon; } 7937 7938 7939 7940 7941 cat >input.y <<'_ATEOF' 7942 %define api.pure true 7943 %language "java" 7944 %% 7945 start: ; 7946 _ATEOF 7947 7948 7949 7950 { set +x 7951 $as_echo "$at_srcdir/input.at:1281: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 7952 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1281" 7953 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 7954 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7955 at_status=$? at_failed=false 7956 $at_check_filter 7957 echo >>"$at_stderr"; $as_echo "input.y:1.9-16: error: %define variable 'api.pure' is not used 7958 " | \ 7959 $at_diff - "$at_stderr" || at_failed=: 7960 at_fn_diff_devnull "$at_stdout" || at_failed=: 7961 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1281" 7962 $at_failed && at_fn_log_failure 7963 $at_traceon; } 7964 7965 7966 7967 7968 cat >input.y <<'_ATEOF' 7969 %define api.pure false 7970 %language "java" 7971 %% 7972 start: ; 7973 _ATEOF 7974 7975 7976 7977 { set +x 7978 $as_echo "$at_srcdir/input.at:1282: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 7979 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1282" 7980 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 7981 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 7982 at_status=$? at_failed=false 7983 $at_check_filter 7984 echo >>"$at_stderr"; $as_echo "input.y:1.9-16: error: %define variable 'api.pure' is not used 7985 " | \ 7986 $at_diff - "$at_stderr" || at_failed=: 7987 at_fn_diff_devnull "$at_stdout" || at_failed=: 7988 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1282" 7989 $at_failed && at_fn_log_failure 7990 $at_traceon; } 7991 7992 7993 7994 7995 set +x 7996 $at_times_p && times >"$at_times_file" 7997 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 7998 read at_status <"$at_status_file" 7999 #AT_STOP_30 8000 #AT_START_31 8001 at_fn_group_banner 31 'input.at:1290' \ 8002 "C++ namespace reference errors" " " 1 8003 at_xfail=no 8004 ( 8005 $as_echo "31. $at_setup_line: testing $at_desc ..." 8006 $at_traceon 8007 8008 8009 # AT_CHECK_NAMESPACE_ERROR(NAMESPACE-DECL, ERROR, [ERROR], ...) 8010 # ------------------------------------------------------------- 8011 # Make sure Bison reports all ERROR's for %define namespace "NAMESPACE-DECL". 8012 8013 8014 8015 cat >input.y <<'_ATEOF' 8016 %language "C++" 8017 %defines 8018 %define namespace "" 8019 %% 8020 start: ; 8021 _ATEOF 8022 8023 8024 8025 { set +x 8026 $as_echo "$at_srcdir/input.at:1311: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 8027 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1311" 8028 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 8029 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8030 at_status=$? at_failed=false 8031 $at_check_filter 8032 echo >>"$at_stderr"; $as_echo "input.y:3.9-17: error: namespace reference is empty 8033 " | \ 8034 $at_diff - "$at_stderr" || at_failed=: 8035 at_fn_diff_devnull "$at_stdout" || at_failed=: 8036 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1311" 8037 $at_failed && at_fn_log_failure 8038 $at_traceon; } 8039 8040 8041 8042 8043 cat >input.y <<'_ATEOF' 8044 %language "C++" 8045 %defines 8046 %define namespace " " 8047 %% 8048 start: ; 8049 _ATEOF 8050 8051 8052 8053 { set +x 8054 $as_echo "$at_srcdir/input.at:1313: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 8055 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1313" 8056 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 8057 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8058 at_status=$? at_failed=false 8059 $at_check_filter 8060 echo >>"$at_stderr"; $as_echo "input.y:3.9-17: error: namespace reference is empty 8061 " | \ 8062 $at_diff - "$at_stderr" || at_failed=: 8063 at_fn_diff_devnull "$at_stdout" || at_failed=: 8064 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1313" 8065 $at_failed && at_fn_log_failure 8066 $at_traceon; } 8067 8068 8069 8070 8071 cat >input.y <<'_ATEOF' 8072 %language "C++" 8073 %defines 8074 %define namespace "foo::::bar" 8075 %% 8076 start: ; 8077 _ATEOF 8078 8079 8080 8081 { set +x 8082 $as_echo "$at_srcdir/input.at:1315: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 8083 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1315" 8084 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 8085 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8086 at_status=$? at_failed=false 8087 $at_check_filter 8088 echo >>"$at_stderr"; $as_echo "input.y:3.9-17: error: namespace reference has consecutive \"::\" 8089 " | \ 8090 $at_diff - "$at_stderr" || at_failed=: 8091 at_fn_diff_devnull "$at_stdout" || at_failed=: 8092 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1315" 8093 $at_failed && at_fn_log_failure 8094 $at_traceon; } 8095 8096 8097 8098 8099 cat >input.y <<'_ATEOF' 8100 %language "C++" 8101 %defines 8102 %define namespace "foo:: ::bar" 8103 %% 8104 start: ; 8105 _ATEOF 8106 8107 8108 8109 { set +x 8110 $as_echo "$at_srcdir/input.at:1317: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 8111 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1317" 8112 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 8113 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8114 at_status=$? at_failed=false 8115 $at_check_filter 8116 echo >>"$at_stderr"; $as_echo "input.y:3.9-17: error: namespace reference has consecutive \"::\" 8117 " | \ 8118 $at_diff - "$at_stderr" || at_failed=: 8119 at_fn_diff_devnull "$at_stdout" || at_failed=: 8120 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1317" 8121 $at_failed && at_fn_log_failure 8122 $at_traceon; } 8123 8124 8125 8126 8127 cat >input.y <<'_ATEOF' 8128 %language "C++" 8129 %defines 8130 %define namespace "::::bar" 8131 %% 8132 start: ; 8133 _ATEOF 8134 8135 8136 8137 { set +x 8138 $as_echo "$at_srcdir/input.at:1319: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 8139 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1319" 8140 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 8141 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8142 at_status=$? at_failed=false 8143 $at_check_filter 8144 echo >>"$at_stderr"; $as_echo "input.y:3.9-17: error: namespace reference has consecutive \"::\" 8145 " | \ 8146 $at_diff - "$at_stderr" || at_failed=: 8147 at_fn_diff_devnull "$at_stdout" || at_failed=: 8148 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1319" 8149 $at_failed && at_fn_log_failure 8150 $at_traceon; } 8151 8152 8153 8154 8155 cat >input.y <<'_ATEOF' 8156 %language "C++" 8157 %defines 8158 %define namespace ":: ::bar" 8159 %% 8160 start: ; 8161 _ATEOF 8162 8163 8164 8165 { set +x 8166 $as_echo "$at_srcdir/input.at:1321: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 8167 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1321" 8168 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 8169 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8170 at_status=$? at_failed=false 8171 $at_check_filter 8172 echo >>"$at_stderr"; $as_echo "input.y:3.9-17: error: namespace reference has consecutive \"::\" 8173 " | \ 8174 $at_diff - "$at_stderr" || at_failed=: 8175 at_fn_diff_devnull "$at_stdout" || at_failed=: 8176 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1321" 8177 $at_failed && at_fn_log_failure 8178 $at_traceon; } 8179 8180 8181 8182 8183 cat >input.y <<'_ATEOF' 8184 %language "C++" 8185 %defines 8186 %define namespace "foo::bar:: ::" 8187 %% 8188 start: ; 8189 _ATEOF 8190 8191 8192 8193 { set +x 8194 $as_echo "$at_srcdir/input.at:1323: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 8195 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1323" 8196 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 8197 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8198 at_status=$? at_failed=false 8199 $at_check_filter 8200 echo >>"$at_stderr"; $as_echo "input.y:3.9-17: error: namespace reference has consecutive \"::\" 8201 input.y:3.9-17: error: namespace reference has a trailing \"::\" 8202 " | \ 8203 $at_diff - "$at_stderr" || at_failed=: 8204 at_fn_diff_devnull "$at_stdout" || at_failed=: 8205 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1323" 8206 $at_failed && at_fn_log_failure 8207 $at_traceon; } 8208 8209 8210 8211 8212 cat >input.y <<'_ATEOF' 8213 %language "C++" 8214 %defines 8215 %define namespace "foo::bar::" 8216 %% 8217 start: ; 8218 _ATEOF 8219 8220 8221 8222 { set +x 8223 $as_echo "$at_srcdir/input.at:1326: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 8224 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1326" 8225 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 8226 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8227 at_status=$? at_failed=false 8228 $at_check_filter 8229 echo >>"$at_stderr"; $as_echo "input.y:3.9-17: error: namespace reference has a trailing \"::\" 8230 " | \ 8231 $at_diff - "$at_stderr" || at_failed=: 8232 at_fn_diff_devnull "$at_stdout" || at_failed=: 8233 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1326" 8234 $at_failed && at_fn_log_failure 8235 $at_traceon; } 8236 8237 8238 8239 8240 cat >input.y <<'_ATEOF' 8241 %language "C++" 8242 %defines 8243 %define namespace "foo::bar:: " 8244 %% 8245 start: ; 8246 _ATEOF 8247 8248 8249 8250 { set +x 8251 $as_echo "$at_srcdir/input.at:1328: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 8252 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1328" 8253 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 8254 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8255 at_status=$? at_failed=false 8256 $at_check_filter 8257 echo >>"$at_stderr"; $as_echo "input.y:3.9-17: error: namespace reference has a trailing \"::\" 8258 " | \ 8259 $at_diff - "$at_stderr" || at_failed=: 8260 at_fn_diff_devnull "$at_stdout" || at_failed=: 8261 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1328" 8262 $at_failed && at_fn_log_failure 8263 $at_traceon; } 8264 8265 8266 8267 8268 cat >input.y <<'_ATEOF' 8269 %language "C++" 8270 %defines 8271 %define namespace "::" 8272 %% 8273 start: ; 8274 _ATEOF 8275 8276 8277 8278 { set +x 8279 $as_echo "$at_srcdir/input.at:1330: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 8280 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1330" 8281 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 8282 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8283 at_status=$? at_failed=false 8284 $at_check_filter 8285 echo >>"$at_stderr"; $as_echo "input.y:3.9-17: error: namespace reference has a trailing \"::\" 8286 " | \ 8287 $at_diff - "$at_stderr" || at_failed=: 8288 at_fn_diff_devnull "$at_stdout" || at_failed=: 8289 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1330" 8290 $at_failed && at_fn_log_failure 8291 $at_traceon; } 8292 8293 8294 8295 8296 set +x 8297 $at_times_p && times >"$at_times_file" 8298 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 8299 read at_status <"$at_status_file" 8300 #AT_STOP_31 8301 #AT_START_32 8302 at_fn_group_banner 32 'input.at:1346' \ 8303 "Bad character literals" " " 1 8304 at_xfail=no 8305 ( 8306 $as_echo "32. $at_setup_line: testing $at_desc ..." 8307 $at_traceon 8308 8309 8310 cat >empty.y <<'_ATEOF' 8311 %% 8312 start: ''; 8313 start: ' 8314 _ATEOF 8315 8316 { set +x 8317 $as_echo "$at_srcdir/input.at:1353: \$PERL -e \"print 'start: \\'';\" >> empty.y || exit 77" 8318 at_fn_check_prepare_dynamic "$PERL -e \"print 'start: \\'';\" >> empty.y || exit 77" "input.at:1353" 8319 ( $at_check_trace; $PERL -e "print 'start: \'';" >> empty.y || exit 77 8320 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8321 at_status=$? at_failed=false 8322 $at_check_filter 8323 at_fn_diff_devnull "$at_stderr" || at_failed=: 8324 at_fn_diff_devnull "$at_stdout" || at_failed=: 8325 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1353" 8326 $at_failed && at_fn_log_failure 8327 $at_traceon; } 8328 8329 8330 8331 { set +x 8332 $as_echo "$at_srcdir/input.at:1355: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison empty.y" 8333 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison empty.y" "input.at:1355" 8334 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison empty.y 8335 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8336 at_status=$? at_failed=false 8337 $at_check_filter 8338 echo >>"$at_stderr"; $as_echo "empty.y:2.8-9: warning: empty character literal 8339 empty.y:3.8-4.0: warning: empty character literal 8340 empty.y:3.8-4.0: error: missing \"'\" at end of line 8341 empty.y:4.8: warning: empty character literal 8342 empty.y:4.8: error: missing \"'\" at end of file 8343 " | \ 8344 $at_diff - "$at_stderr" || at_failed=: 8345 at_fn_diff_devnull "$at_stdout" || at_failed=: 8346 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1355" 8347 $at_failed && at_fn_log_failure 8348 $at_traceon; } 8349 8350 8351 8352 cat >two.y <<'_ATEOF' 8353 %% 8354 start: 'ab'; 8355 start: 'ab 8356 _ATEOF 8357 8358 { set +x 8359 $as_echo "$at_srcdir/input.at:1368: \$PERL -e \"print 'start: \\'ab';\" >> two.y || exit 77" 8360 at_fn_check_prepare_dynamic "$PERL -e \"print 'start: \\'ab';\" >> two.y || exit 77" "input.at:1368" 8361 ( $at_check_trace; $PERL -e "print 'start: \'ab';" >> two.y || exit 77 8362 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8363 at_status=$? at_failed=false 8364 $at_check_filter 8365 at_fn_diff_devnull "$at_stderr" || at_failed=: 8366 at_fn_diff_devnull "$at_stdout" || at_failed=: 8367 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1368" 8368 $at_failed && at_fn_log_failure 8369 $at_traceon; } 8370 8371 8372 8373 { set +x 8374 $as_echo "$at_srcdir/input.at:1370: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison two.y" 8375 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison two.y" "input.at:1370" 8376 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison two.y 8377 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8378 at_status=$? at_failed=false 8379 $at_check_filter 8380 echo >>"$at_stderr"; $as_echo "two.y:2.8-11: warning: extra characters in character literal 8381 two.y:3.8-4.0: warning: extra characters in character literal 8382 two.y:3.8-4.0: error: missing \"'\" at end of line 8383 two.y:4.8-10: warning: extra characters in character literal 8384 two.y:4.8-10: error: missing \"'\" at end of file 8385 " | \ 8386 $at_diff - "$at_stderr" || at_failed=: 8387 at_fn_diff_devnull "$at_stdout" || at_failed=: 8388 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1370" 8389 $at_failed && at_fn_log_failure 8390 $at_traceon; } 8391 8392 8393 8394 cat >three.y <<'_ATEOF' 8395 %% 8396 start: 'abc'; 8397 start: 'abc 8398 _ATEOF 8399 8400 { set +x 8401 $as_echo "$at_srcdir/input.at:1383: \$PERL -e \"print 'start: \\'abc';\" >> three.y || exit 77" 8402 at_fn_check_prepare_dynamic "$PERL -e \"print 'start: \\'abc';\" >> three.y || exit 77" "input.at:1383" 8403 ( $at_check_trace; $PERL -e "print 'start: \'abc';" >> three.y || exit 77 8404 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8405 at_status=$? at_failed=false 8406 $at_check_filter 8407 at_fn_diff_devnull "$at_stderr" || at_failed=: 8408 at_fn_diff_devnull "$at_stdout" || at_failed=: 8409 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1383" 8410 $at_failed && at_fn_log_failure 8411 $at_traceon; } 8412 8413 8414 8415 { set +x 8416 $as_echo "$at_srcdir/input.at:1385: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison three.y" 8417 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison three.y" "input.at:1385" 8418 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison three.y 8419 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8420 at_status=$? at_failed=false 8421 $at_check_filter 8422 echo >>"$at_stderr"; $as_echo "three.y:2.8-12: warning: extra characters in character literal 8423 three.y:3.8-4.0: warning: extra characters in character literal 8424 three.y:3.8-4.0: error: missing \"'\" at end of line 8425 three.y:4.8-11: warning: extra characters in character literal 8426 three.y:4.8-11: error: missing \"'\" at end of file 8427 " | \ 8428 $at_diff - "$at_stderr" || at_failed=: 8429 at_fn_diff_devnull "$at_stdout" || at_failed=: 8430 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1385" 8431 $at_failed && at_fn_log_failure 8432 $at_traceon; } 8433 8434 8435 8436 set +x 8437 $at_times_p && times >"$at_times_file" 8438 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 8439 read at_status <"$at_status_file" 8440 #AT_STOP_32 8441 #AT_START_33 8442 at_fn_group_banner 33 'input.at:1399' \ 8443 "Bad escapes in literals" " " 1 8444 at_xfail=no 8445 ( 8446 $as_echo "33. $at_setup_line: testing $at_desc ..." 8447 $at_traceon 8448 8449 8450 cat >input.y <<'_ATEOF' 8451 %% 8452 start: '\777' '\0' '\xfff' '\x0' 8453 '\uffff' '\u0000' '\Uffffffff' '\U00000000' 8454 '\ ' '\A'; 8455 _ATEOF 8456 8457 8458 # It is not easy to create special characters, we cannot even trust tr. 8459 # Beside we cannot even expect "echo '\0'" to output two characters 8460 # (well three with \n): at least Bash 3.2 converts the two-character 8461 # sequence "\0" into a single NUL character. 8462 { set +x 8463 $as_echo "$at_srcdir/input.at:1412: \$PERL -e 'print \"start: \\\"\\\\\\t\\\\\\f\\\\\\0\\\\\\1\\\" ;\";' >> input.y \\ 8464 || exit 77" 8465 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1412" 8466 ( $at_check_trace; $PERL -e 'print "start: \"\\\t\\\f\\\0\\\1\" ;";' >> input.y \ 8467 || exit 77 8468 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8469 at_status=$? at_failed=false 8470 $at_check_filter 8471 at_fn_diff_devnull "$at_stderr" || at_failed=: 8472 at_fn_diff_devnull "$at_stdout" || at_failed=: 8473 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1412" 8474 $at_failed && at_fn_log_failure 8475 $at_traceon; } 8476 8477 8478 8479 { set +x 8480 $as_echo "$at_srcdir/input.at:1415: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 8481 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1415" 8482 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 8483 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8484 at_status=$? at_failed=false 8485 $at_check_filter 8486 echo >>"$at_stderr"; $as_echo "input.y:2.9-12: error: invalid number after \\-escape: 777 8487 input.y:2.8-13: warning: empty character literal 8488 input.y:2.16-17: error: invalid number after \\-escape: 0 8489 input.y:2.15-18: warning: empty character literal 8490 input.y:2.21-25: error: invalid number after \\-escape: xfff 8491 input.y:2.20-26: warning: empty character literal 8492 input.y:2.29-31: error: invalid number after \\-escape: x0 8493 input.y:2.28-32: warning: empty character literal 8494 input.y:3.9-14: error: invalid number after \\-escape: uffff 8495 input.y:3.8-15: warning: empty character literal 8496 input.y:3.18-23: error: invalid number after \\-escape: u0000 8497 input.y:3.17-24: warning: empty character literal 8498 input.y:3.27-36: error: invalid number after \\-escape: Uffffffff 8499 input.y:3.26-37: warning: empty character literal 8500 input.y:3.40-49: error: invalid number after \\-escape: U00000000 8501 input.y:3.39-50: warning: empty character literal 8502 input.y:4.9-10: error: invalid character after \\-escape: ' ' 8503 input.y:4.8-11: warning: empty character literal 8504 input.y:4.14-15: error: invalid character after \\-escape: A 8505 input.y:4.13-16: warning: empty character literal 8506 input.y:5.9-16: error: invalid character after \\-escape: \\t 8507 input.y:5.17: error: invalid character after \\-escape: \\f 8508 input.y:5.18: error: invalid character after \\-escape: \\0 8509 input.y:5.19: error: invalid character after \\-escape: \\001 8510 " | \ 8511 $at_diff - "$at_stderr" || at_failed=: 8512 at_fn_diff_devnull "$at_stdout" || at_failed=: 8513 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1415" 8514 $at_failed && at_fn_log_failure 8515 $at_traceon; } 8516 8517 8518 8519 set +x 8520 $at_times_p && times >"$at_times_file" 8521 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 8522 read at_status <"$at_status_file" 8523 #AT_STOP_33 8524 #AT_START_34 8525 at_fn_group_banner 34 'input.at:1448' \ 8526 "LAC: Errors for %define" " " 1 8527 at_xfail=no 8528 ( 8529 $as_echo "34. $at_setup_line: testing $at_desc ..." 8530 $at_traceon 8531 8532 8533 cat >input.y <<'_ATEOF' 8534 %% 8535 start: ; 8536 _ATEOF 8537 8538 8539 # parse.lac.* options are useless if LAC isn't actually activated. 8540 8541 { set +x 8542 $as_echo "$at_srcdir/input.at:1456: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Dparse.lac.es-capacity-initial=1 input.y" 8543 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Dparse.lac.es-capacity-initial=1 input.y" "input.at:1456" 8544 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -Dparse.lac.es-capacity-initial=1 input.y 8545 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8546 at_status=$? at_failed=false 8547 $at_check_filter 8548 echo >>"$at_stderr"; $as_echo "<command line>:1: error: %define variable 'parse.lac.es-capacity-initial' is not used 8549 " | \ 8550 $at_diff - "$at_stderr" || at_failed=: 8551 at_fn_diff_devnull "$at_stdout" || at_failed=: 8552 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1456" 8553 $at_failed && at_fn_log_failure 8554 $at_traceon; } 8555 8556 8557 8558 { set +x 8559 $as_echo "$at_srcdir/input.at:1460: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Dparse.lac.memory-trace=full input.y" 8560 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Dparse.lac.memory-trace=full input.y" "input.at:1460" 8561 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -Dparse.lac.memory-trace=full input.y 8562 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8563 at_status=$? at_failed=false 8564 $at_check_filter 8565 echo >>"$at_stderr"; $as_echo "<command line>:1: error: %define variable 'parse.lac.memory-trace' is not used 8566 " | \ 8567 $at_diff - "$at_stderr" || at_failed=: 8568 at_fn_diff_devnull "$at_stdout" || at_failed=: 8569 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1460" 8570 $at_failed && at_fn_log_failure 8571 $at_traceon; } 8572 8573 8574 8575 set +x 8576 $at_times_p && times >"$at_times_file" 8577 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 8578 read at_status <"$at_status_file" 8579 #AT_STOP_34 8580 #AT_START_35 8581 at_fn_group_banner 35 'input.at:1471' \ 8582 "-Werror is not affected by -Wnone and -Wall" " " 1 8583 at_xfail=no 8584 ( 8585 $as_echo "35. $at_setup_line: testing $at_desc ..." 8586 $at_traceon 8587 8588 8589 cat >input.y <<'_ATEOF' 8590 %% 8591 foo-bar: ; 8592 _ATEOF 8593 8594 8595 # -Werror is not enabled by -Wall or equivalent. 8596 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 8597 at_save_special_files 8598 mkdir xml-tests 8599 # Don't combine these Bison invocations since we want to be sure that 8600 # --report=all isn't required to get the full XML file. 8601 { set +x 8602 $as_echo "$at_srcdir/input.at:1479: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 8603 --graph=xml-tests/test.dot -Wall input.y" 8604 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1479" 8605 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 8606 --graph=xml-tests/test.dot -Wall input.y 8607 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8608 at_status=$? at_failed=false 8609 $at_check_filter 8610 echo stderr:; cat "$at_stderr" 8611 echo stdout:; cat "$at_stdout" 8612 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1479" 8613 $at_failed && at_fn_log_failure 8614 $at_traceon; } 8615 8616 { set +x 8617 $as_echo "$at_srcdir/input.at:1479: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -Wall input.y" 8618 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -Wall input.y" "input.at:1479" 8619 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -Wall input.y 8620 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8621 at_status=$? at_failed=false 8622 $at_check_filter 8623 echo stderr:; cat "$at_stderr" 8624 echo stdout:; cat "$at_stdout" 8625 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1479" 8626 $at_failed && at_fn_log_failure 8627 $at_traceon; } 8628 8629 cp xml-tests/test.output expout 8630 { set +x 8631 $as_echo "$at_srcdir/input.at:1479: \$XSLTPROC \\ 8632 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 8633 xml-tests/test.xml" 8634 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1479" 8635 ( $at_check_trace; $XSLTPROC \ 8636 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 8637 xml-tests/test.xml 8638 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8639 at_status=$? at_failed=false 8640 $at_check_filter 8641 at_fn_diff_devnull "$at_stderr" || at_failed=: 8642 $at_diff expout "$at_stdout" || at_failed=: 8643 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1479" 8644 $at_failed && at_fn_log_failure 8645 $at_traceon; } 8646 8647 sort xml-tests/test.dot > expout 8648 { set +x 8649 $as_echo "$at_srcdir/input.at:1479: \$XSLTPROC \\ 8650 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 8651 xml-tests/test.xml | sort" 8652 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1479" 8653 ( $at_check_trace; $XSLTPROC \ 8654 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 8655 xml-tests/test.xml | sort 8656 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8657 at_status=$? at_failed=false 8658 $at_check_filter 8659 at_fn_diff_devnull "$at_stderr" || at_failed=: 8660 $at_diff expout "$at_stdout" || at_failed=: 8661 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1479" 8662 $at_failed && at_fn_log_failure 8663 $at_traceon; } 8664 8665 rm -rf xml-tests expout 8666 at_restore_special_files 8667 fi 8668 { set +x 8669 $as_echo "$at_srcdir/input.at:1479: bison -Wall input.y" 8670 at_fn_check_prepare_trace "input.at:1479" 8671 ( $at_check_trace; bison -Wall input.y 8672 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8673 at_status=$? at_failed=false 8674 $at_check_filter 8675 echo >>"$at_stderr"; $as_echo "input.y:2.1-7: warning: POSIX Yacc forbids dashes in symbol names: foo-bar 8676 " | \ 8677 $at_diff - "$at_stderr" || at_failed=: 8678 at_fn_diff_devnull "$at_stdout" || at_failed=: 8679 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1479" 8680 $at_failed && at_fn_log_failure 8681 $at_traceon; } 8682 8683 # Defining POSIXLY_CORRECT causes bison to complain if options are 8684 # added after the grammar file name, so skip these checks in that 8685 # case. 8686 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 8687 at_save_special_files 8688 8689 # To avoid expanding it repeatedly, store specified stdout. 8690 : >expout 8691 8692 # Run with -Werror. 8693 { set +x 8694 $as_echo "$at_srcdir/input.at:1479: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wall input.y -Werror" 8695 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wall input.y -Werror" "input.at:1479" 8696 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -Wall input.y -Werror 8697 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8698 at_status=$? at_failed=false 8699 $at_check_filter 8700 echo stderr:; tee stderr <"$at_stderr" 8701 $at_diff expout "$at_stdout" || at_failed=: 8702 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1479" 8703 $at_failed && at_fn_log_failure 8704 $at_traceon; } 8705 8706 8707 # Build expected stderr up to and including the "warnings being 8708 # treated as errors" message. 8709 cat >at-bison-check-warnings <<'_ATEOF' 8710 input.y:2.1-7: warning: POSIX Yacc forbids dashes in symbol names: foo-bar 8711 _ATEOF 8712 8713 at_bison_check_first=`sed -n \ 8714 '/: warning: /{=;q;}' at-bison-check-warnings` 8715 : ${at_bison_check_first:=1} 8716 at_bison_check_first_tmp=`sed -n \ 8717 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 8718 : ${at_bison_check_first_tmp:=1} 8719 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 8720 at_bison_check_first=$at_bison_check_first_tmp 8721 fi 8722 if test $at_bison_check_first -gt 1; then 8723 sed -n "1,`expr $at_bison_check_first - 1`"p \ 8724 at-bison-check-warnings > experr 8725 fi 8726 echo 'bison: warnings being treated as errors' >> experr 8727 8728 # Finish building expected stderr and check. Unlike warnings, 8729 # complaints cause bison to exit early. Thus, with -Werror, bison 8730 # does not necessarily report all warnings that it does without 8731 # -Werror, but it at least reports one. 8732 at_bison_check_last=`sed -n '$=' stderr` 8733 : ${at_bison_check_last:=1} 8734 at_bison_check_last=`expr $at_bison_check_last - 1` 8735 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 8736 at-bison-check-warnings >> experr 8737 { set +x 8738 $as_echo "$at_srcdir/input.at:1479: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 8739 stderr 1>&2" 8740 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1479" 8741 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 8742 stderr 1>&2 8743 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8744 at_status=$? at_failed=false 8745 $at_check_filter 8746 $at_diff experr "$at_stderr" || at_failed=: 8747 at_fn_diff_devnull "$at_stdout" || at_failed=: 8748 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1479" 8749 $at_failed && at_fn_log_failure 8750 $at_traceon; } 8751 8752 8753 # Now check --warnings=error. 8754 cp stderr experr 8755 { set +x 8756 $as_echo "$at_srcdir/input.at:1479: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wall input.y --warnings=error" 8757 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wall input.y --warnings=error" "input.at:1479" 8758 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -Wall input.y --warnings=error 8759 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8760 at_status=$? at_failed=false 8761 $at_check_filter 8762 $at_diff experr "$at_stderr" || at_failed=: 8763 $at_diff expout "$at_stdout" || at_failed=: 8764 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1479" 8765 $at_failed && at_fn_log_failure 8766 $at_traceon; } 8767 8768 8769 # Now check -Wnone and --warnings=none by making sure that 8770 # -Werror doesn't change the exit status when -Wnone or 8771 # --warnings=none is specified. 8772 { set +x 8773 $as_echo "$at_srcdir/input.at:1479: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wall input.y -Wnone -Werror" 8774 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wall input.y -Wnone -Werror" "input.at:1479" 8775 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -Wall input.y -Wnone -Werror 8776 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8777 at_status=$? at_failed=false 8778 $at_check_filter 8779 at_fn_diff_devnull "$at_stderr" || at_failed=: 8780 $at_diff expout "$at_stdout" || at_failed=: 8781 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1479" 8782 $at_failed && at_fn_log_failure 8783 $at_traceon; } 8784 8785 { set +x 8786 $as_echo "$at_srcdir/input.at:1479: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wall input.y --warnings=none -Werror" 8787 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wall input.y --warnings=none -Werror" "input.at:1479" 8788 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -Wall input.y --warnings=none -Werror 8789 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8790 at_status=$? at_failed=false 8791 $at_check_filter 8792 at_fn_diff_devnull "$at_stderr" || at_failed=: 8793 $at_diff expout "$at_stdout" || at_failed=: 8794 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1479" 8795 $at_failed && at_fn_log_failure 8796 $at_traceon; } 8797 8798 8799 at_restore_special_files 8800 fi 8801 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 8802 at_save_special_files 8803 mkdir xml-tests 8804 # Don't combine these Bison invocations since we want to be sure that 8805 # --report=all isn't required to get the full XML file. 8806 { set +x 8807 $as_echo "$at_srcdir/input.at:1482: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 8808 --graph=xml-tests/test.dot -W input.y" 8809 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1482" 8810 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 8811 --graph=xml-tests/test.dot -W input.y 8812 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8813 at_status=$? at_failed=false 8814 $at_check_filter 8815 echo stderr:; cat "$at_stderr" 8816 echo stdout:; cat "$at_stdout" 8817 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1482" 8818 $at_failed && at_fn_log_failure 8819 $at_traceon; } 8820 8821 { set +x 8822 $as_echo "$at_srcdir/input.at:1482: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -W input.y" 8823 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -W input.y" "input.at:1482" 8824 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -W input.y 8825 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8826 at_status=$? at_failed=false 8827 $at_check_filter 8828 echo stderr:; cat "$at_stderr" 8829 echo stdout:; cat "$at_stdout" 8830 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1482" 8831 $at_failed && at_fn_log_failure 8832 $at_traceon; } 8833 8834 cp xml-tests/test.output expout 8835 { set +x 8836 $as_echo "$at_srcdir/input.at:1482: \$XSLTPROC \\ 8837 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 8838 xml-tests/test.xml" 8839 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1482" 8840 ( $at_check_trace; $XSLTPROC \ 8841 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 8842 xml-tests/test.xml 8843 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8844 at_status=$? at_failed=false 8845 $at_check_filter 8846 at_fn_diff_devnull "$at_stderr" || at_failed=: 8847 $at_diff expout "$at_stdout" || at_failed=: 8848 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1482" 8849 $at_failed && at_fn_log_failure 8850 $at_traceon; } 8851 8852 sort xml-tests/test.dot > expout 8853 { set +x 8854 $as_echo "$at_srcdir/input.at:1482: \$XSLTPROC \\ 8855 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 8856 xml-tests/test.xml | sort" 8857 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1482" 8858 ( $at_check_trace; $XSLTPROC \ 8859 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 8860 xml-tests/test.xml | sort 8861 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8862 at_status=$? at_failed=false 8863 $at_check_filter 8864 at_fn_diff_devnull "$at_stderr" || at_failed=: 8865 $at_diff expout "$at_stdout" || at_failed=: 8866 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1482" 8867 $at_failed && at_fn_log_failure 8868 $at_traceon; } 8869 8870 rm -rf xml-tests expout 8871 at_restore_special_files 8872 fi 8873 { set +x 8874 $as_echo "$at_srcdir/input.at:1482: bison -W input.y" 8875 at_fn_check_prepare_trace "input.at:1482" 8876 ( $at_check_trace; bison -W input.y 8877 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8878 at_status=$? at_failed=false 8879 $at_check_filter 8880 echo >>"$at_stderr"; $as_echo "input.y:2.1-7: warning: POSIX Yacc forbids dashes in symbol names: foo-bar 8881 " | \ 8882 $at_diff - "$at_stderr" || at_failed=: 8883 at_fn_diff_devnull "$at_stdout" || at_failed=: 8884 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1482" 8885 $at_failed && at_fn_log_failure 8886 $at_traceon; } 8887 8888 # Defining POSIXLY_CORRECT causes bison to complain if options are 8889 # added after the grammar file name, so skip these checks in that 8890 # case. 8891 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 8892 at_save_special_files 8893 8894 # To avoid expanding it repeatedly, store specified stdout. 8895 : >expout 8896 8897 # Run with -Werror. 8898 { set +x 8899 $as_echo "$at_srcdir/input.at:1482: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -W input.y -Werror" 8900 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -W input.y -Werror" "input.at:1482" 8901 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -W input.y -Werror 8902 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8903 at_status=$? at_failed=false 8904 $at_check_filter 8905 echo stderr:; tee stderr <"$at_stderr" 8906 $at_diff expout "$at_stdout" || at_failed=: 8907 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1482" 8908 $at_failed && at_fn_log_failure 8909 $at_traceon; } 8910 8911 8912 # Build expected stderr up to and including the "warnings being 8913 # treated as errors" message. 8914 cat >at-bison-check-warnings <<'_ATEOF' 8915 input.y:2.1-7: warning: POSIX Yacc forbids dashes in symbol names: foo-bar 8916 _ATEOF 8917 8918 at_bison_check_first=`sed -n \ 8919 '/: warning: /{=;q;}' at-bison-check-warnings` 8920 : ${at_bison_check_first:=1} 8921 at_bison_check_first_tmp=`sed -n \ 8922 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 8923 : ${at_bison_check_first_tmp:=1} 8924 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 8925 at_bison_check_first=$at_bison_check_first_tmp 8926 fi 8927 if test $at_bison_check_first -gt 1; then 8928 sed -n "1,`expr $at_bison_check_first - 1`"p \ 8929 at-bison-check-warnings > experr 8930 fi 8931 echo 'bison: warnings being treated as errors' >> experr 8932 8933 # Finish building expected stderr and check. Unlike warnings, 8934 # complaints cause bison to exit early. Thus, with -Werror, bison 8935 # does not necessarily report all warnings that it does without 8936 # -Werror, but it at least reports one. 8937 at_bison_check_last=`sed -n '$=' stderr` 8938 : ${at_bison_check_last:=1} 8939 at_bison_check_last=`expr $at_bison_check_last - 1` 8940 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 8941 at-bison-check-warnings >> experr 8942 { set +x 8943 $as_echo "$at_srcdir/input.at:1482: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 8944 stderr 1>&2" 8945 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1482" 8946 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 8947 stderr 1>&2 8948 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8949 at_status=$? at_failed=false 8950 $at_check_filter 8951 $at_diff experr "$at_stderr" || at_failed=: 8952 at_fn_diff_devnull "$at_stdout" || at_failed=: 8953 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1482" 8954 $at_failed && at_fn_log_failure 8955 $at_traceon; } 8956 8957 8958 # Now check --warnings=error. 8959 cp stderr experr 8960 { set +x 8961 $as_echo "$at_srcdir/input.at:1482: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -W input.y --warnings=error" 8962 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -W input.y --warnings=error" "input.at:1482" 8963 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -W input.y --warnings=error 8964 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8965 at_status=$? at_failed=false 8966 $at_check_filter 8967 $at_diff experr "$at_stderr" || at_failed=: 8968 $at_diff expout "$at_stdout" || at_failed=: 8969 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1482" 8970 $at_failed && at_fn_log_failure 8971 $at_traceon; } 8972 8973 8974 # Now check -Wnone and --warnings=none by making sure that 8975 # -Werror doesn't change the exit status when -Wnone or 8976 # --warnings=none is specified. 8977 { set +x 8978 $as_echo "$at_srcdir/input.at:1482: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -W input.y -Wnone -Werror" 8979 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -W input.y -Wnone -Werror" "input.at:1482" 8980 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -W input.y -Wnone -Werror 8981 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8982 at_status=$? at_failed=false 8983 $at_check_filter 8984 at_fn_diff_devnull "$at_stderr" || at_failed=: 8985 $at_diff expout "$at_stdout" || at_failed=: 8986 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1482" 8987 $at_failed && at_fn_log_failure 8988 $at_traceon; } 8989 8990 { set +x 8991 $as_echo "$at_srcdir/input.at:1482: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -W input.y --warnings=none -Werror" 8992 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -W input.y --warnings=none -Werror" "input.at:1482" 8993 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -W input.y --warnings=none -Werror 8994 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 8995 at_status=$? at_failed=false 8996 $at_check_filter 8997 at_fn_diff_devnull "$at_stderr" || at_failed=: 8998 $at_diff expout "$at_stdout" || at_failed=: 8999 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1482" 9000 $at_failed && at_fn_log_failure 9001 $at_traceon; } 9002 9003 9004 at_restore_special_files 9005 fi 9006 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 9007 at_save_special_files 9008 mkdir xml-tests 9009 # Don't combine these Bison invocations since we want to be sure that 9010 # --report=all isn't required to get the full XML file. 9011 { set +x 9012 $as_echo "$at_srcdir/input.at:1485: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 9013 --graph=xml-tests/test.dot -Wno-none input.y" 9014 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1485" 9015 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 9016 --graph=xml-tests/test.dot -Wno-none input.y 9017 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9018 at_status=$? at_failed=false 9019 $at_check_filter 9020 echo stderr:; cat "$at_stderr" 9021 echo stdout:; cat "$at_stdout" 9022 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1485" 9023 $at_failed && at_fn_log_failure 9024 $at_traceon; } 9025 9026 { set +x 9027 $as_echo "$at_srcdir/input.at:1485: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -Wno-none input.y" 9028 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -Wno-none input.y" "input.at:1485" 9029 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -Wno-none input.y 9030 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9031 at_status=$? at_failed=false 9032 $at_check_filter 9033 echo stderr:; cat "$at_stderr" 9034 echo stdout:; cat "$at_stdout" 9035 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1485" 9036 $at_failed && at_fn_log_failure 9037 $at_traceon; } 9038 9039 cp xml-tests/test.output expout 9040 { set +x 9041 $as_echo "$at_srcdir/input.at:1485: \$XSLTPROC \\ 9042 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 9043 xml-tests/test.xml" 9044 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1485" 9045 ( $at_check_trace; $XSLTPROC \ 9046 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 9047 xml-tests/test.xml 9048 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9049 at_status=$? at_failed=false 9050 $at_check_filter 9051 at_fn_diff_devnull "$at_stderr" || at_failed=: 9052 $at_diff expout "$at_stdout" || at_failed=: 9053 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1485" 9054 $at_failed && at_fn_log_failure 9055 $at_traceon; } 9056 9057 sort xml-tests/test.dot > expout 9058 { set +x 9059 $as_echo "$at_srcdir/input.at:1485: \$XSLTPROC \\ 9060 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 9061 xml-tests/test.xml | sort" 9062 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1485" 9063 ( $at_check_trace; $XSLTPROC \ 9064 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 9065 xml-tests/test.xml | sort 9066 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9067 at_status=$? at_failed=false 9068 $at_check_filter 9069 at_fn_diff_devnull "$at_stderr" || at_failed=: 9070 $at_diff expout "$at_stdout" || at_failed=: 9071 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1485" 9072 $at_failed && at_fn_log_failure 9073 $at_traceon; } 9074 9075 rm -rf xml-tests expout 9076 at_restore_special_files 9077 fi 9078 { set +x 9079 $as_echo "$at_srcdir/input.at:1485: bison -Wno-none input.y" 9080 at_fn_check_prepare_trace "input.at:1485" 9081 ( $at_check_trace; bison -Wno-none input.y 9082 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9083 at_status=$? at_failed=false 9084 $at_check_filter 9085 echo >>"$at_stderr"; $as_echo "input.y:2.1-7: warning: POSIX Yacc forbids dashes in symbol names: foo-bar 9086 " | \ 9087 $at_diff - "$at_stderr" || at_failed=: 9088 at_fn_diff_devnull "$at_stdout" || at_failed=: 9089 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1485" 9090 $at_failed && at_fn_log_failure 9091 $at_traceon; } 9092 9093 # Defining POSIXLY_CORRECT causes bison to complain if options are 9094 # added after the grammar file name, so skip these checks in that 9095 # case. 9096 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 9097 at_save_special_files 9098 9099 # To avoid expanding it repeatedly, store specified stdout. 9100 : >expout 9101 9102 # Run with -Werror. 9103 { set +x 9104 $as_echo "$at_srcdir/input.at:1485: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wno-none input.y -Werror" 9105 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wno-none input.y -Werror" "input.at:1485" 9106 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -Wno-none input.y -Werror 9107 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9108 at_status=$? at_failed=false 9109 $at_check_filter 9110 echo stderr:; tee stderr <"$at_stderr" 9111 $at_diff expout "$at_stdout" || at_failed=: 9112 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1485" 9113 $at_failed && at_fn_log_failure 9114 $at_traceon; } 9115 9116 9117 # Build expected stderr up to and including the "warnings being 9118 # treated as errors" message. 9119 cat >at-bison-check-warnings <<'_ATEOF' 9120 input.y:2.1-7: warning: POSIX Yacc forbids dashes in symbol names: foo-bar 9121 _ATEOF 9122 9123 at_bison_check_first=`sed -n \ 9124 '/: warning: /{=;q;}' at-bison-check-warnings` 9125 : ${at_bison_check_first:=1} 9126 at_bison_check_first_tmp=`sed -n \ 9127 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 9128 : ${at_bison_check_first_tmp:=1} 9129 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 9130 at_bison_check_first=$at_bison_check_first_tmp 9131 fi 9132 if test $at_bison_check_first -gt 1; then 9133 sed -n "1,`expr $at_bison_check_first - 1`"p \ 9134 at-bison-check-warnings > experr 9135 fi 9136 echo 'bison: warnings being treated as errors' >> experr 9137 9138 # Finish building expected stderr and check. Unlike warnings, 9139 # complaints cause bison to exit early. Thus, with -Werror, bison 9140 # does not necessarily report all warnings that it does without 9141 # -Werror, but it at least reports one. 9142 at_bison_check_last=`sed -n '$=' stderr` 9143 : ${at_bison_check_last:=1} 9144 at_bison_check_last=`expr $at_bison_check_last - 1` 9145 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 9146 at-bison-check-warnings >> experr 9147 { set +x 9148 $as_echo "$at_srcdir/input.at:1485: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 9149 stderr 1>&2" 9150 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1485" 9151 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 9152 stderr 1>&2 9153 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9154 at_status=$? at_failed=false 9155 $at_check_filter 9156 $at_diff experr "$at_stderr" || at_failed=: 9157 at_fn_diff_devnull "$at_stdout" || at_failed=: 9158 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1485" 9159 $at_failed && at_fn_log_failure 9160 $at_traceon; } 9161 9162 9163 # Now check --warnings=error. 9164 cp stderr experr 9165 { set +x 9166 $as_echo "$at_srcdir/input.at:1485: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wno-none input.y --warnings=error" 9167 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wno-none input.y --warnings=error" "input.at:1485" 9168 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -Wno-none input.y --warnings=error 9169 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9170 at_status=$? at_failed=false 9171 $at_check_filter 9172 $at_diff experr "$at_stderr" || at_failed=: 9173 $at_diff expout "$at_stdout" || at_failed=: 9174 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1485" 9175 $at_failed && at_fn_log_failure 9176 $at_traceon; } 9177 9178 9179 # Now check -Wnone and --warnings=none by making sure that 9180 # -Werror doesn't change the exit status when -Wnone or 9181 # --warnings=none is specified. 9182 { set +x 9183 $as_echo "$at_srcdir/input.at:1485: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wno-none input.y -Wnone -Werror" 9184 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wno-none input.y -Wnone -Werror" "input.at:1485" 9185 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -Wno-none input.y -Wnone -Werror 9186 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9187 at_status=$? at_failed=false 9188 $at_check_filter 9189 at_fn_diff_devnull "$at_stderr" || at_failed=: 9190 $at_diff expout "$at_stdout" || at_failed=: 9191 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1485" 9192 $at_failed && at_fn_log_failure 9193 $at_traceon; } 9194 9195 { set +x 9196 $as_echo "$at_srcdir/input.at:1485: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wno-none input.y --warnings=none -Werror" 9197 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Wno-none input.y --warnings=none -Werror" "input.at:1485" 9198 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -Wno-none input.y --warnings=none -Werror 9199 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9200 at_status=$? at_failed=false 9201 $at_check_filter 9202 at_fn_diff_devnull "$at_stderr" || at_failed=: 9203 $at_diff expout "$at_stdout" || at_failed=: 9204 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1485" 9205 $at_failed && at_fn_log_failure 9206 $at_traceon; } 9207 9208 9209 at_restore_special_files 9210 fi 9211 9212 # -Werror is not disabled by -Wnone or equivalent. 9213 9214 { set +x 9215 $as_echo "$at_srcdir/input.at:1490: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Werror,none,yacc input.y" 9216 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Werror,none,yacc input.y" "input.at:1490" 9217 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -Werror,none,yacc input.y 9218 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9219 at_status=$? at_failed=false 9220 $at_check_filter 9221 echo stderr:; tee stderr <"$at_stderr" 9222 at_fn_diff_devnull "$at_stdout" || at_failed=: 9223 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1490" 9224 $at_failed && at_fn_log_failure 9225 $at_traceon; } 9226 9227 9228 { set +x 9229 $as_echo "$at_srcdir/input.at:1491: sed 's/^.*bison:/bison:/' stderr" 9230 at_fn_check_prepare_trace "input.at:1491" 9231 ( $at_check_trace; sed 's/^.*bison:/bison:/' stderr 9232 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9233 at_status=$? at_failed=false 9234 $at_check_filter 9235 at_fn_diff_devnull "$at_stderr" || at_failed=: 9236 echo >>"$at_stdout"; $as_echo "bison: warnings being treated as errors 9237 input.y:2.1-7: warning: POSIX Yacc forbids dashes in symbol names: foo-bar 9238 " | \ 9239 $at_diff - "$at_stdout" || at_failed=: 9240 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1491" 9241 $at_failed && at_fn_log_failure 9242 $at_traceon; } 9243 9244 mv stderr experr 9245 9246 { set +x 9247 $as_echo "$at_srcdir/input.at:1496: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Werror,no-all,yacc input.y" 9248 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Werror,no-all,yacc input.y" "input.at:1496" 9249 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -Werror,no-all,yacc input.y 9250 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9251 at_status=$? at_failed=false 9252 $at_check_filter 9253 $at_diff experr "$at_stderr" || at_failed=: 9254 at_fn_diff_devnull "$at_stdout" || at_failed=: 9255 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1496" 9256 $at_failed && at_fn_log_failure 9257 $at_traceon; } 9258 9259 9260 9261 set +x 9262 $at_times_p && times >"$at_times_file" 9263 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 9264 read at_status <"$at_status_file" 9265 #AT_STOP_35 9266 #AT_START_36 9267 at_fn_group_banner 36 'input.at:1505' \ 9268 "%name-prefix and %define api.prefix are incompatible" "" 1 9269 at_xfail=no 9270 ( 9271 $as_echo "36. $at_setup_line: testing $at_desc ..." 9272 $at_traceon 9273 9274 9275 # AT_TEST(DIRECTIVES, OPTIONS, ERROR-LOCATION) 9276 # -------------------------------------------- 9277 9278 9279 cat >input.y <<'_ATEOF' 9280 %define api.prefix foo %name-prefix "bar" 9281 %% 9282 exp:; 9283 _ATEOF 9284 9285 9286 { set +x 9287 $as_echo "$at_srcdir/input.at:1520: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 9288 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "input.at:1520" 9289 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 9290 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9291 at_status=$? at_failed=false 9292 $at_check_filter 9293 echo >>"$at_stderr"; $as_echo "input.y:1.9-18: error: '%name-prefix' and '%define api.prefix' cannot be used together 9294 " | \ 9295 $at_diff - "$at_stderr" || at_failed=: 9296 at_fn_diff_devnull "$at_stdout" || at_failed=: 9297 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1520" 9298 $at_failed && at_fn_log_failure 9299 $at_traceon; } 9300 9301 9302 9303 cat >input.y <<'_ATEOF' 9304 9305 %% 9306 exp:; 9307 _ATEOF 9308 9309 9310 { set +x 9311 $as_echo "$at_srcdir/input.at:1521: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Dapi.prefix=foo -p bar input.y" 9312 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Dapi.prefix=foo -p bar input.y" "input.at:1521" 9313 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -Dapi.prefix=foo -p bar input.y 9314 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9315 at_status=$? at_failed=false 9316 $at_check_filter 9317 echo >>"$at_stderr"; $as_echo "<command line>:1: error: '%name-prefix' and '%define api.prefix' cannot be used together 9318 " | \ 9319 $at_diff - "$at_stderr" || at_failed=: 9320 at_fn_diff_devnull "$at_stdout" || at_failed=: 9321 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1521" 9322 $at_failed && at_fn_log_failure 9323 $at_traceon; } 9324 9325 9326 9327 cat >input.y <<'_ATEOF' 9328 %name-prefix "bar" 9329 %% 9330 exp:; 9331 _ATEOF 9332 9333 9334 { set +x 9335 $as_echo "$at_srcdir/input.at:1522: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Dapi.prefix=foo input.y" 9336 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -Dapi.prefix=foo input.y" "input.at:1522" 9337 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -Dapi.prefix=foo input.y 9338 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9339 at_status=$? at_failed=false 9340 $at_check_filter 9341 echo >>"$at_stderr"; $as_echo "<command line>:1: error: '%name-prefix' and '%define api.prefix' cannot be used together 9342 " | \ 9343 $at_diff - "$at_stderr" || at_failed=: 9344 at_fn_diff_devnull "$at_stdout" || at_failed=: 9345 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1522" 9346 $at_failed && at_fn_log_failure 9347 $at_traceon; } 9348 9349 9350 9351 cat >input.y <<'_ATEOF' 9352 %define api.prefix foo 9353 %% 9354 exp:; 9355 _ATEOF 9356 9357 9358 { set +x 9359 $as_echo "$at_srcdir/input.at:1523: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -p bar input.y" 9360 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -p bar input.y" "input.at:1523" 9361 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -p bar input.y 9362 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9363 at_status=$? at_failed=false 9364 $at_check_filter 9365 echo >>"$at_stderr"; $as_echo "input.y:1.9-18: error: '%name-prefix' and '%define api.prefix' cannot be used together 9366 " | \ 9367 $at_diff - "$at_stderr" || at_failed=: 9368 at_fn_diff_devnull "$at_stdout" || at_failed=: 9369 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1523" 9370 $at_failed && at_fn_log_failure 9371 $at_traceon; } 9372 9373 9374 9375 9376 9377 9378 set +x 9379 $at_times_p && times >"$at_times_file" 9380 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 9381 read at_status <"$at_status_file" 9382 #AT_STOP_36 9383 #AT_START_37 9384 at_fn_group_banner 37 'input.at:1534' \ 9385 "Stray \$ or @" " " 1 9386 at_xfail=no 9387 ( 9388 $as_echo "37. $at_setup_line: testing $at_desc ..." 9389 $at_traceon 9390 9391 9392 # Give %printer and %destructor "<*> exp TOK" instead of "<*>" to 9393 # check that the warnings are reported once, not three times. 9394 9395 cat >input.y <<'_ATEOF' 9396 %code top { 9397 #include <config.h> 9398 /* We don't need perfect functions for these tests. */ 9399 #undef malloc 9400 #undef memcmp 9401 #undef realloc 9402 } 9403 9404 %token TOK 9405 %destructor { $%; @%; } <*> exp TOK; 9406 %initial-action { $%; @%; }; 9407 %printer { $%; @%; } <*> exp TOK; 9408 %% 9409 exp: TOK { $%; @%; $$ = $1; }; 9410 _ATEOF 9411 9412 9413 9414 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 9415 at_save_special_files 9416 mkdir xml-tests 9417 # Don't combine these Bison invocations since we want to be sure that 9418 # --report=all isn't required to get the full XML file. 9419 { set +x 9420 $as_echo "$at_srcdir/input.at:1548: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 9421 --graph=xml-tests/test.dot input.y" 9422 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1548" 9423 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 9424 --graph=xml-tests/test.dot input.y 9425 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9426 at_status=$? at_failed=false 9427 $at_check_filter 9428 echo stderr:; cat "$at_stderr" 9429 echo stdout:; cat "$at_stdout" 9430 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1548" 9431 $at_failed && at_fn_log_failure 9432 $at_traceon; } 9433 9434 { set +x 9435 $as_echo "$at_srcdir/input.at:1548: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y" 9436 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y" "input.at:1548" 9437 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y 9438 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9439 at_status=$? at_failed=false 9440 $at_check_filter 9441 echo stderr:; cat "$at_stderr" 9442 echo stdout:; cat "$at_stdout" 9443 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1548" 9444 $at_failed && at_fn_log_failure 9445 $at_traceon; } 9446 9447 cp xml-tests/test.output expout 9448 { set +x 9449 $as_echo "$at_srcdir/input.at:1548: \$XSLTPROC \\ 9450 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 9451 xml-tests/test.xml" 9452 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1548" 9453 ( $at_check_trace; $XSLTPROC \ 9454 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 9455 xml-tests/test.xml 9456 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9457 at_status=$? at_failed=false 9458 $at_check_filter 9459 at_fn_diff_devnull "$at_stderr" || at_failed=: 9460 $at_diff expout "$at_stdout" || at_failed=: 9461 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1548" 9462 $at_failed && at_fn_log_failure 9463 $at_traceon; } 9464 9465 sort xml-tests/test.dot > expout 9466 { set +x 9467 $as_echo "$at_srcdir/input.at:1548: \$XSLTPROC \\ 9468 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 9469 xml-tests/test.xml | sort" 9470 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1548" 9471 ( $at_check_trace; $XSLTPROC \ 9472 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 9473 xml-tests/test.xml | sort 9474 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9475 at_status=$? at_failed=false 9476 $at_check_filter 9477 at_fn_diff_devnull "$at_stderr" || at_failed=: 9478 $at_diff expout "$at_stdout" || at_failed=: 9479 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1548" 9480 $at_failed && at_fn_log_failure 9481 $at_traceon; } 9482 9483 rm -rf xml-tests expout 9484 at_restore_special_files 9485 fi 9486 { set +x 9487 $as_echo "$at_srcdir/input.at:1548: bison input.y" 9488 at_fn_check_prepare_trace "input.at:1548" 9489 ( $at_check_trace; bison input.y 9490 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9491 at_status=$? at_failed=false 9492 $at_check_filter 9493 echo >>"$at_stderr"; $as_echo "input.y:10.19: warning: stray '\$' 9494 input.y:10.23: warning: stray '@' 9495 input.y:11.19: warning: stray '\$' 9496 input.y:11.23: warning: stray '@' 9497 input.y:12.19: warning: stray '\$' 9498 input.y:12.23: warning: stray '@' 9499 input.y:14.19: warning: stray '\$' 9500 input.y:14.23: warning: stray '@' 9501 " | \ 9502 $at_diff - "$at_stderr" || at_failed=: 9503 at_fn_diff_devnull "$at_stdout" || at_failed=: 9504 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1548" 9505 $at_failed && at_fn_log_failure 9506 $at_traceon; } 9507 9508 # Defining POSIXLY_CORRECT causes bison to complain if options are 9509 # added after the grammar file name, so skip these checks in that 9510 # case. 9511 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 9512 at_save_special_files 9513 9514 # To avoid expanding it repeatedly, store specified stdout. 9515 : >expout 9516 9517 # Run with -Werror. 9518 { set +x 9519 $as_echo "$at_srcdir/input.at:1548: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Werror" 9520 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Werror" "input.at:1548" 9521 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y -Werror 9522 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9523 at_status=$? at_failed=false 9524 $at_check_filter 9525 echo stderr:; tee stderr <"$at_stderr" 9526 $at_diff expout "$at_stdout" || at_failed=: 9527 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1548" 9528 $at_failed && at_fn_log_failure 9529 $at_traceon; } 9530 9531 9532 # Build expected stderr up to and including the "warnings being 9533 # treated as errors" message. 9534 cat >at-bison-check-warnings <<'_ATEOF' 9535 input.y:10.19: warning: stray '$' 9536 input.y:10.23: warning: stray '@' 9537 input.y:11.19: warning: stray '$' 9538 input.y:11.23: warning: stray '@' 9539 input.y:12.19: warning: stray '$' 9540 input.y:12.23: warning: stray '@' 9541 input.y:14.19: warning: stray '$' 9542 input.y:14.23: warning: stray '@' 9543 _ATEOF 9544 9545 at_bison_check_first=`sed -n \ 9546 '/: warning: /{=;q;}' at-bison-check-warnings` 9547 : ${at_bison_check_first:=1} 9548 at_bison_check_first_tmp=`sed -n \ 9549 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 9550 : ${at_bison_check_first_tmp:=1} 9551 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 9552 at_bison_check_first=$at_bison_check_first_tmp 9553 fi 9554 if test $at_bison_check_first -gt 1; then 9555 sed -n "1,`expr $at_bison_check_first - 1`"p \ 9556 at-bison-check-warnings > experr 9557 fi 9558 echo 'bison: warnings being treated as errors' >> experr 9559 9560 # Finish building expected stderr and check. Unlike warnings, 9561 # complaints cause bison to exit early. Thus, with -Werror, bison 9562 # does not necessarily report all warnings that it does without 9563 # -Werror, but it at least reports one. 9564 at_bison_check_last=`sed -n '$=' stderr` 9565 : ${at_bison_check_last:=1} 9566 at_bison_check_last=`expr $at_bison_check_last - 1` 9567 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 9568 at-bison-check-warnings >> experr 9569 { set +x 9570 $as_echo "$at_srcdir/input.at:1548: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 9571 stderr 1>&2" 9572 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1548" 9573 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 9574 stderr 1>&2 9575 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9576 at_status=$? at_failed=false 9577 $at_check_filter 9578 $at_diff experr "$at_stderr" || at_failed=: 9579 at_fn_diff_devnull "$at_stdout" || at_failed=: 9580 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1548" 9581 $at_failed && at_fn_log_failure 9582 $at_traceon; } 9583 9584 9585 # Now check --warnings=error. 9586 cp stderr experr 9587 { set +x 9588 $as_echo "$at_srcdir/input.at:1548: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=error" 9589 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=error" "input.at:1548" 9590 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y --warnings=error 9591 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9592 at_status=$? at_failed=false 9593 $at_check_filter 9594 $at_diff experr "$at_stderr" || at_failed=: 9595 $at_diff expout "$at_stdout" || at_failed=: 9596 at_fn_check_status 1 $at_status "$at_srcdir/input.at:1548" 9597 $at_failed && at_fn_log_failure 9598 $at_traceon; } 9599 9600 9601 # Now check -Wnone and --warnings=none by making sure that 9602 # -Werror doesn't change the exit status when -Wnone or 9603 # --warnings=none is specified. 9604 { set +x 9605 $as_echo "$at_srcdir/input.at:1548: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Wnone -Werror" 9606 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Wnone -Werror" "input.at:1548" 9607 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y -Wnone -Werror 9608 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9609 at_status=$? at_failed=false 9610 $at_check_filter 9611 at_fn_diff_devnull "$at_stderr" || at_failed=: 9612 $at_diff expout "$at_stdout" || at_failed=: 9613 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1548" 9614 $at_failed && at_fn_log_failure 9615 $at_traceon; } 9616 9617 { set +x 9618 $as_echo "$at_srcdir/input.at:1548: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror" 9619 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror" "input.at:1548" 9620 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror 9621 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9622 at_status=$? at_failed=false 9623 $at_check_filter 9624 at_fn_diff_devnull "$at_stderr" || at_failed=: 9625 $at_diff expout "$at_stdout" || at_failed=: 9626 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1548" 9627 $at_failed && at_fn_log_failure 9628 $at_traceon; } 9629 9630 9631 at_restore_special_files 9632 fi 9633 9634 set +x 9635 $at_times_p && times >"$at_times_file" 9636 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 9637 read at_status <"$at_status_file" 9638 #AT_STOP_37 9639 #AT_START_38 9640 at_fn_group_banner 38 'input.at:1568' \ 9641 "Code injection" " " 1 9642 at_xfail=no 9643 ( 9644 $as_echo "38. $at_setup_line: testing $at_desc ..." 9645 $at_traceon 9646 9647 9648 9649 9650 # AT_TEST([MACRO]) 9651 # ---------------- 9652 # Try to have MACRO be run by bison. 9653 9654 9655 cat >input.y <<'_ATEOF' 9656 %type <m4_errprintn(DEAD %type)> exp 9657 %token <m4_errprintn(DEAD %token)> a 9658 %initial-action 9659 { 9660 $$; 9661 $<m4_errprintn(DEAD %initial-action)>$ 9662 }; 9663 %printer 9664 { 9665 $$ 9666 $<m4_errprintn(DEAD %printer)>$ 9667 } <> <*>; 9668 %lex-param 9669 { 9670 m4_errprintn(DEAD %lex-param) 9671 }; 9672 %parse-param 9673 { 9674 m4_errprintn(DEAD %parse-param) 9675 }; 9676 %% 9677 exp: 9678 a a[last] 9679 { 9680 $$; 9681 $1; 9682 $<m4_errprintn(DEAD action 1)>$ 9683 $<m4_errprintn(DEAD action 2)>1 9684 $<m4_errprintn(DEAD action 3)>last 9685 $<m4_errprintn(DEAD action 4)>0 9686 ; 9687 }; 9688 _ATEOF 9689 9690 9691 # FIXME: Provide a means to iterate over all the skeletons. 9692 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 9693 at_save_special_files 9694 mkdir xml-tests 9695 # Don't combine these Bison invocations since we want to be sure that 9696 # --report=all isn't required to get the full XML file. 9697 { set +x 9698 $as_echo "$at_srcdir/input.at:1619: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 9699 --graph=xml-tests/test.dot -d input.y" 9700 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1619" 9701 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 9702 --graph=xml-tests/test.dot -d input.y 9703 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9704 at_status=$? at_failed=false 9705 $at_check_filter 9706 echo stderr:; cat "$at_stderr" 9707 echo stdout:; cat "$at_stdout" 9708 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 9709 $at_failed && at_fn_log_failure 9710 $at_traceon; } 9711 9712 { set +x 9713 $as_echo "$at_srcdir/input.at:1619: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d input.y" 9714 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d input.y" "input.at:1619" 9715 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d input.y 9716 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9717 at_status=$? at_failed=false 9718 $at_check_filter 9719 echo stderr:; cat "$at_stderr" 9720 echo stdout:; cat "$at_stdout" 9721 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 9722 $at_failed && at_fn_log_failure 9723 $at_traceon; } 9724 9725 cp xml-tests/test.output expout 9726 { set +x 9727 $as_echo "$at_srcdir/input.at:1619: \$XSLTPROC \\ 9728 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 9729 xml-tests/test.xml" 9730 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1619" 9731 ( $at_check_trace; $XSLTPROC \ 9732 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 9733 xml-tests/test.xml 9734 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9735 at_status=$? at_failed=false 9736 $at_check_filter 9737 at_fn_diff_devnull "$at_stderr" || at_failed=: 9738 $at_diff expout "$at_stdout" || at_failed=: 9739 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 9740 $at_failed && at_fn_log_failure 9741 $at_traceon; } 9742 9743 sort xml-tests/test.dot > expout 9744 { set +x 9745 $as_echo "$at_srcdir/input.at:1619: \$XSLTPROC \\ 9746 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 9747 xml-tests/test.xml | sort" 9748 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1619" 9749 ( $at_check_trace; $XSLTPROC \ 9750 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 9751 xml-tests/test.xml | sort 9752 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9753 at_status=$? at_failed=false 9754 $at_check_filter 9755 at_fn_diff_devnull "$at_stderr" || at_failed=: 9756 $at_diff expout "$at_stdout" || at_failed=: 9757 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 9758 $at_failed && at_fn_log_failure 9759 $at_traceon; } 9760 9761 rm -rf xml-tests expout 9762 at_restore_special_files 9763 fi 9764 { set +x 9765 $as_echo "$at_srcdir/input.at:1619: bison -d input.y" 9766 at_fn_check_prepare_trace "input.at:1619" 9767 ( $at_check_trace; bison -d input.y 9768 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9769 at_status=$? at_failed=false 9770 $at_check_filter 9771 at_fn_diff_devnull "$at_stderr" || at_failed=: 9772 at_fn_diff_devnull "$at_stdout" || at_failed=: 9773 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 9774 $at_failed && at_fn_log_failure 9775 $at_traceon; } 9776 9777 9778 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 9779 at_save_special_files 9780 mkdir xml-tests 9781 # Don't combine these Bison invocations since we want to be sure that 9782 # --report=all isn't required to get the full XML file. 9783 { set +x 9784 $as_echo "$at_srcdir/input.at:1619: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 9785 --graph=xml-tests/test.dot -d -S glr.c input.y" 9786 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1619" 9787 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 9788 --graph=xml-tests/test.dot -d -S glr.c input.y 9789 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9790 at_status=$? at_failed=false 9791 $at_check_filter 9792 echo stderr:; cat "$at_stderr" 9793 echo stdout:; cat "$at_stdout" 9794 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 9795 $at_failed && at_fn_log_failure 9796 $at_traceon; } 9797 9798 { set +x 9799 $as_echo "$at_srcdir/input.at:1619: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d -S glr.c input.y" 9800 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d -S glr.c input.y" "input.at:1619" 9801 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d -S glr.c input.y 9802 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9803 at_status=$? at_failed=false 9804 $at_check_filter 9805 echo stderr:; cat "$at_stderr" 9806 echo stdout:; cat "$at_stdout" 9807 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 9808 $at_failed && at_fn_log_failure 9809 $at_traceon; } 9810 9811 cp xml-tests/test.output expout 9812 { set +x 9813 $as_echo "$at_srcdir/input.at:1619: \$XSLTPROC \\ 9814 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 9815 xml-tests/test.xml" 9816 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1619" 9817 ( $at_check_trace; $XSLTPROC \ 9818 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 9819 xml-tests/test.xml 9820 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9821 at_status=$? at_failed=false 9822 $at_check_filter 9823 at_fn_diff_devnull "$at_stderr" || at_failed=: 9824 $at_diff expout "$at_stdout" || at_failed=: 9825 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 9826 $at_failed && at_fn_log_failure 9827 $at_traceon; } 9828 9829 sort xml-tests/test.dot > expout 9830 { set +x 9831 $as_echo "$at_srcdir/input.at:1619: \$XSLTPROC \\ 9832 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 9833 xml-tests/test.xml | sort" 9834 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1619" 9835 ( $at_check_trace; $XSLTPROC \ 9836 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 9837 xml-tests/test.xml | sort 9838 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9839 at_status=$? at_failed=false 9840 $at_check_filter 9841 at_fn_diff_devnull "$at_stderr" || at_failed=: 9842 $at_diff expout "$at_stdout" || at_failed=: 9843 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 9844 $at_failed && at_fn_log_failure 9845 $at_traceon; } 9846 9847 rm -rf xml-tests expout 9848 at_restore_special_files 9849 fi 9850 { set +x 9851 $as_echo "$at_srcdir/input.at:1619: bison -d -S glr.c input.y" 9852 at_fn_check_prepare_trace "input.at:1619" 9853 ( $at_check_trace; bison -d -S glr.c input.y 9854 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9855 at_status=$? at_failed=false 9856 $at_check_filter 9857 at_fn_diff_devnull "$at_stderr" || at_failed=: 9858 at_fn_diff_devnull "$at_stdout" || at_failed=: 9859 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 9860 $at_failed && at_fn_log_failure 9861 $at_traceon; } 9862 9863 9864 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 9865 at_save_special_files 9866 mkdir xml-tests 9867 # Don't combine these Bison invocations since we want to be sure that 9868 # --report=all isn't required to get the full XML file. 9869 { set +x 9870 $as_echo "$at_srcdir/input.at:1619: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 9871 --graph=xml-tests/test.dot -d -S lalr1.cc input.y" 9872 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1619" 9873 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 9874 --graph=xml-tests/test.dot -d -S lalr1.cc input.y 9875 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9876 at_status=$? at_failed=false 9877 $at_check_filter 9878 echo stderr:; cat "$at_stderr" 9879 echo stdout:; cat "$at_stdout" 9880 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 9881 $at_failed && at_fn_log_failure 9882 $at_traceon; } 9883 9884 { set +x 9885 $as_echo "$at_srcdir/input.at:1619: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d -S lalr1.cc input.y" 9886 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d -S lalr1.cc input.y" "input.at:1619" 9887 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d -S lalr1.cc input.y 9888 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9889 at_status=$? at_failed=false 9890 $at_check_filter 9891 echo stderr:; cat "$at_stderr" 9892 echo stdout:; cat "$at_stdout" 9893 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 9894 $at_failed && at_fn_log_failure 9895 $at_traceon; } 9896 9897 cp xml-tests/test.output expout 9898 { set +x 9899 $as_echo "$at_srcdir/input.at:1619: \$XSLTPROC \\ 9900 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 9901 xml-tests/test.xml" 9902 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1619" 9903 ( $at_check_trace; $XSLTPROC \ 9904 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 9905 xml-tests/test.xml 9906 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9907 at_status=$? at_failed=false 9908 $at_check_filter 9909 at_fn_diff_devnull "$at_stderr" || at_failed=: 9910 $at_diff expout "$at_stdout" || at_failed=: 9911 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 9912 $at_failed && at_fn_log_failure 9913 $at_traceon; } 9914 9915 sort xml-tests/test.dot > expout 9916 { set +x 9917 $as_echo "$at_srcdir/input.at:1619: \$XSLTPROC \\ 9918 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 9919 xml-tests/test.xml | sort" 9920 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1619" 9921 ( $at_check_trace; $XSLTPROC \ 9922 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 9923 xml-tests/test.xml | sort 9924 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9925 at_status=$? at_failed=false 9926 $at_check_filter 9927 at_fn_diff_devnull "$at_stderr" || at_failed=: 9928 $at_diff expout "$at_stdout" || at_failed=: 9929 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 9930 $at_failed && at_fn_log_failure 9931 $at_traceon; } 9932 9933 rm -rf xml-tests expout 9934 at_restore_special_files 9935 fi 9936 { set +x 9937 $as_echo "$at_srcdir/input.at:1619: bison -d -S lalr1.cc input.y" 9938 at_fn_check_prepare_trace "input.at:1619" 9939 ( $at_check_trace; bison -d -S lalr1.cc input.y 9940 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9941 at_status=$? at_failed=false 9942 $at_check_filter 9943 at_fn_diff_devnull "$at_stderr" || at_failed=: 9944 at_fn_diff_devnull "$at_stdout" || at_failed=: 9945 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 9946 $at_failed && at_fn_log_failure 9947 $at_traceon; } 9948 9949 9950 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 9951 at_save_special_files 9952 mkdir xml-tests 9953 # Don't combine these Bison invocations since we want to be sure that 9954 # --report=all isn't required to get the full XML file. 9955 { set +x 9956 $as_echo "$at_srcdir/input.at:1619: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 9957 --graph=xml-tests/test.dot -d -S glr.cc input.y" 9958 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1619" 9959 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 9960 --graph=xml-tests/test.dot -d -S glr.cc input.y 9961 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9962 at_status=$? at_failed=false 9963 $at_check_filter 9964 echo stderr:; cat "$at_stderr" 9965 echo stdout:; cat "$at_stdout" 9966 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 9967 $at_failed && at_fn_log_failure 9968 $at_traceon; } 9969 9970 { set +x 9971 $as_echo "$at_srcdir/input.at:1619: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d -S glr.cc input.y" 9972 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d -S glr.cc input.y" "input.at:1619" 9973 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d -S glr.cc input.y 9974 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9975 at_status=$? at_failed=false 9976 $at_check_filter 9977 echo stderr:; cat "$at_stderr" 9978 echo stdout:; cat "$at_stdout" 9979 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 9980 $at_failed && at_fn_log_failure 9981 $at_traceon; } 9982 9983 cp xml-tests/test.output expout 9984 { set +x 9985 $as_echo "$at_srcdir/input.at:1619: \$XSLTPROC \\ 9986 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 9987 xml-tests/test.xml" 9988 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1619" 9989 ( $at_check_trace; $XSLTPROC \ 9990 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 9991 xml-tests/test.xml 9992 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 9993 at_status=$? at_failed=false 9994 $at_check_filter 9995 at_fn_diff_devnull "$at_stderr" || at_failed=: 9996 $at_diff expout "$at_stdout" || at_failed=: 9997 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 9998 $at_failed && at_fn_log_failure 9999 $at_traceon; } 10000 10001 sort xml-tests/test.dot > expout 10002 { set +x 10003 $as_echo "$at_srcdir/input.at:1619: \$XSLTPROC \\ 10004 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 10005 xml-tests/test.xml | sort" 10006 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1619" 10007 ( $at_check_trace; $XSLTPROC \ 10008 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 10009 xml-tests/test.xml | sort 10010 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10011 at_status=$? at_failed=false 10012 $at_check_filter 10013 at_fn_diff_devnull "$at_stderr" || at_failed=: 10014 $at_diff expout "$at_stdout" || at_failed=: 10015 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 10016 $at_failed && at_fn_log_failure 10017 $at_traceon; } 10018 10019 rm -rf xml-tests expout 10020 at_restore_special_files 10021 fi 10022 { set +x 10023 $as_echo "$at_srcdir/input.at:1619: bison -d -S glr.cc input.y" 10024 at_fn_check_prepare_trace "input.at:1619" 10025 ( $at_check_trace; bison -d -S glr.cc input.y 10026 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10027 at_status=$? at_failed=false 10028 $at_check_filter 10029 at_fn_diff_devnull "$at_stderr" || at_failed=: 10030 at_fn_diff_devnull "$at_stdout" || at_failed=: 10031 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 10032 $at_failed && at_fn_log_failure 10033 $at_traceon; } 10034 10035 10036 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 10037 at_save_special_files 10038 mkdir xml-tests 10039 # Don't combine these Bison invocations since we want to be sure that 10040 # --report=all isn't required to get the full XML file. 10041 { set +x 10042 $as_echo "$at_srcdir/input.at:1619: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 10043 --graph=xml-tests/test.dot -S lalr1.java input.y" 10044 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1619" 10045 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 10046 --graph=xml-tests/test.dot -S lalr1.java input.y 10047 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10048 at_status=$? at_failed=false 10049 $at_check_filter 10050 echo stderr:; cat "$at_stderr" 10051 echo stdout:; cat "$at_stdout" 10052 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 10053 $at_failed && at_fn_log_failure 10054 $at_traceon; } 10055 10056 { set +x 10057 $as_echo "$at_srcdir/input.at:1619: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -S lalr1.java input.y" 10058 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -S lalr1.java input.y" "input.at:1619" 10059 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -S lalr1.java input.y 10060 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10061 at_status=$? at_failed=false 10062 $at_check_filter 10063 echo stderr:; cat "$at_stderr" 10064 echo stdout:; cat "$at_stdout" 10065 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 10066 $at_failed && at_fn_log_failure 10067 $at_traceon; } 10068 10069 cp xml-tests/test.output expout 10070 { set +x 10071 $as_echo "$at_srcdir/input.at:1619: \$XSLTPROC \\ 10072 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 10073 xml-tests/test.xml" 10074 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1619" 10075 ( $at_check_trace; $XSLTPROC \ 10076 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 10077 xml-tests/test.xml 10078 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10079 at_status=$? at_failed=false 10080 $at_check_filter 10081 at_fn_diff_devnull "$at_stderr" || at_failed=: 10082 $at_diff expout "$at_stdout" || at_failed=: 10083 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 10084 $at_failed && at_fn_log_failure 10085 $at_traceon; } 10086 10087 sort xml-tests/test.dot > expout 10088 { set +x 10089 $as_echo "$at_srcdir/input.at:1619: \$XSLTPROC \\ 10090 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 10091 xml-tests/test.xml | sort" 10092 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1619" 10093 ( $at_check_trace; $XSLTPROC \ 10094 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 10095 xml-tests/test.xml | sort 10096 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10097 at_status=$? at_failed=false 10098 $at_check_filter 10099 at_fn_diff_devnull "$at_stderr" || at_failed=: 10100 $at_diff expout "$at_stdout" || at_failed=: 10101 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 10102 $at_failed && at_fn_log_failure 10103 $at_traceon; } 10104 10105 rm -rf xml-tests expout 10106 at_restore_special_files 10107 fi 10108 { set +x 10109 $as_echo "$at_srcdir/input.at:1619: bison -S lalr1.java input.y" 10110 at_fn_check_prepare_trace "input.at:1619" 10111 ( $at_check_trace; bison -S lalr1.java input.y 10112 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10113 at_status=$? at_failed=false 10114 $at_check_filter 10115 at_fn_diff_devnull "$at_stderr" || at_failed=: 10116 at_fn_diff_devnull "$at_stdout" || at_failed=: 10117 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1619" 10118 $at_failed && at_fn_log_failure 10119 $at_traceon; } 10120 10121 10122 10123 cat >input.y <<'_ATEOF' 10124 %type <]m4_errprintn(DEAD %type)> exp 10125 %token <]m4_errprintn(DEAD %token)> a 10126 %initial-action 10127 { 10128 $$; 10129 $<]m4_errprintn(DEAD %initial-action)>$ 10130 }; 10131 %printer 10132 { 10133 $$ 10134 $<]m4_errprintn(DEAD %printer)>$ 10135 } <> <*>; 10136 %lex-param 10137 { 10138 ]m4_errprintn(DEAD %lex-param) 10139 }; 10140 %parse-param 10141 { 10142 ]m4_errprintn(DEAD %parse-param) 10143 }; 10144 %% 10145 exp: 10146 a a[last] 10147 { 10148 $$; 10149 $1; 10150 $<]m4_errprintn(DEAD action 1)>$ 10151 $<]m4_errprintn(DEAD action 2)>1 10152 $<]m4_errprintn(DEAD action 3)>last 10153 $<]m4_errprintn(DEAD action 4)>0 10154 ; 10155 }; 10156 _ATEOF 10157 10158 10159 # FIXME: Provide a means to iterate over all the skeletons. 10160 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 10161 at_save_special_files 10162 mkdir xml-tests 10163 # Don't combine these Bison invocations since we want to be sure that 10164 # --report=all isn't required to get the full XML file. 10165 { set +x 10166 $as_echo "$at_srcdir/input.at:1620: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 10167 --graph=xml-tests/test.dot -d input.y" 10168 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1620" 10169 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 10170 --graph=xml-tests/test.dot -d input.y 10171 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10172 at_status=$? at_failed=false 10173 $at_check_filter 10174 echo stderr:; cat "$at_stderr" 10175 echo stdout:; cat "$at_stdout" 10176 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10177 $at_failed && at_fn_log_failure 10178 $at_traceon; } 10179 10180 { set +x 10181 $as_echo "$at_srcdir/input.at:1620: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d input.y" 10182 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d input.y" "input.at:1620" 10183 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d input.y 10184 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10185 at_status=$? at_failed=false 10186 $at_check_filter 10187 echo stderr:; cat "$at_stderr" 10188 echo stdout:; cat "$at_stdout" 10189 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10190 $at_failed && at_fn_log_failure 10191 $at_traceon; } 10192 10193 cp xml-tests/test.output expout 10194 { set +x 10195 $as_echo "$at_srcdir/input.at:1620: \$XSLTPROC \\ 10196 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 10197 xml-tests/test.xml" 10198 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1620" 10199 ( $at_check_trace; $XSLTPROC \ 10200 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 10201 xml-tests/test.xml 10202 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10203 at_status=$? at_failed=false 10204 $at_check_filter 10205 at_fn_diff_devnull "$at_stderr" || at_failed=: 10206 $at_diff expout "$at_stdout" || at_failed=: 10207 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10208 $at_failed && at_fn_log_failure 10209 $at_traceon; } 10210 10211 sort xml-tests/test.dot > expout 10212 { set +x 10213 $as_echo "$at_srcdir/input.at:1620: \$XSLTPROC \\ 10214 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 10215 xml-tests/test.xml | sort" 10216 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1620" 10217 ( $at_check_trace; $XSLTPROC \ 10218 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 10219 xml-tests/test.xml | sort 10220 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10221 at_status=$? at_failed=false 10222 $at_check_filter 10223 at_fn_diff_devnull "$at_stderr" || at_failed=: 10224 $at_diff expout "$at_stdout" || at_failed=: 10225 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10226 $at_failed && at_fn_log_failure 10227 $at_traceon; } 10228 10229 rm -rf xml-tests expout 10230 at_restore_special_files 10231 fi 10232 { set +x 10233 $as_echo "$at_srcdir/input.at:1620: bison -d input.y" 10234 at_fn_check_prepare_trace "input.at:1620" 10235 ( $at_check_trace; bison -d input.y 10236 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10237 at_status=$? at_failed=false 10238 $at_check_filter 10239 at_fn_diff_devnull "$at_stderr" || at_failed=: 10240 at_fn_diff_devnull "$at_stdout" || at_failed=: 10241 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10242 $at_failed && at_fn_log_failure 10243 $at_traceon; } 10244 10245 10246 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 10247 at_save_special_files 10248 mkdir xml-tests 10249 # Don't combine these Bison invocations since we want to be sure that 10250 # --report=all isn't required to get the full XML file. 10251 { set +x 10252 $as_echo "$at_srcdir/input.at:1620: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 10253 --graph=xml-tests/test.dot -d -S glr.c input.y" 10254 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1620" 10255 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 10256 --graph=xml-tests/test.dot -d -S glr.c input.y 10257 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10258 at_status=$? at_failed=false 10259 $at_check_filter 10260 echo stderr:; cat "$at_stderr" 10261 echo stdout:; cat "$at_stdout" 10262 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10263 $at_failed && at_fn_log_failure 10264 $at_traceon; } 10265 10266 { set +x 10267 $as_echo "$at_srcdir/input.at:1620: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d -S glr.c input.y" 10268 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d -S glr.c input.y" "input.at:1620" 10269 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d -S glr.c input.y 10270 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10271 at_status=$? at_failed=false 10272 $at_check_filter 10273 echo stderr:; cat "$at_stderr" 10274 echo stdout:; cat "$at_stdout" 10275 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10276 $at_failed && at_fn_log_failure 10277 $at_traceon; } 10278 10279 cp xml-tests/test.output expout 10280 { set +x 10281 $as_echo "$at_srcdir/input.at:1620: \$XSLTPROC \\ 10282 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 10283 xml-tests/test.xml" 10284 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1620" 10285 ( $at_check_trace; $XSLTPROC \ 10286 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 10287 xml-tests/test.xml 10288 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10289 at_status=$? at_failed=false 10290 $at_check_filter 10291 at_fn_diff_devnull "$at_stderr" || at_failed=: 10292 $at_diff expout "$at_stdout" || at_failed=: 10293 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10294 $at_failed && at_fn_log_failure 10295 $at_traceon; } 10296 10297 sort xml-tests/test.dot > expout 10298 { set +x 10299 $as_echo "$at_srcdir/input.at:1620: \$XSLTPROC \\ 10300 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 10301 xml-tests/test.xml | sort" 10302 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1620" 10303 ( $at_check_trace; $XSLTPROC \ 10304 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 10305 xml-tests/test.xml | sort 10306 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10307 at_status=$? at_failed=false 10308 $at_check_filter 10309 at_fn_diff_devnull "$at_stderr" || at_failed=: 10310 $at_diff expout "$at_stdout" || at_failed=: 10311 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10312 $at_failed && at_fn_log_failure 10313 $at_traceon; } 10314 10315 rm -rf xml-tests expout 10316 at_restore_special_files 10317 fi 10318 { set +x 10319 $as_echo "$at_srcdir/input.at:1620: bison -d -S glr.c input.y" 10320 at_fn_check_prepare_trace "input.at:1620" 10321 ( $at_check_trace; bison -d -S glr.c input.y 10322 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10323 at_status=$? at_failed=false 10324 $at_check_filter 10325 at_fn_diff_devnull "$at_stderr" || at_failed=: 10326 at_fn_diff_devnull "$at_stdout" || at_failed=: 10327 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10328 $at_failed && at_fn_log_failure 10329 $at_traceon; } 10330 10331 10332 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 10333 at_save_special_files 10334 mkdir xml-tests 10335 # Don't combine these Bison invocations since we want to be sure that 10336 # --report=all isn't required to get the full XML file. 10337 { set +x 10338 $as_echo "$at_srcdir/input.at:1620: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 10339 --graph=xml-tests/test.dot -d -S lalr1.cc input.y" 10340 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1620" 10341 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 10342 --graph=xml-tests/test.dot -d -S lalr1.cc input.y 10343 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10344 at_status=$? at_failed=false 10345 $at_check_filter 10346 echo stderr:; cat "$at_stderr" 10347 echo stdout:; cat "$at_stdout" 10348 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10349 $at_failed && at_fn_log_failure 10350 $at_traceon; } 10351 10352 { set +x 10353 $as_echo "$at_srcdir/input.at:1620: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d -S lalr1.cc input.y" 10354 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d -S lalr1.cc input.y" "input.at:1620" 10355 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d -S lalr1.cc input.y 10356 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10357 at_status=$? at_failed=false 10358 $at_check_filter 10359 echo stderr:; cat "$at_stderr" 10360 echo stdout:; cat "$at_stdout" 10361 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10362 $at_failed && at_fn_log_failure 10363 $at_traceon; } 10364 10365 cp xml-tests/test.output expout 10366 { set +x 10367 $as_echo "$at_srcdir/input.at:1620: \$XSLTPROC \\ 10368 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 10369 xml-tests/test.xml" 10370 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1620" 10371 ( $at_check_trace; $XSLTPROC \ 10372 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 10373 xml-tests/test.xml 10374 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10375 at_status=$? at_failed=false 10376 $at_check_filter 10377 at_fn_diff_devnull "$at_stderr" || at_failed=: 10378 $at_diff expout "$at_stdout" || at_failed=: 10379 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10380 $at_failed && at_fn_log_failure 10381 $at_traceon; } 10382 10383 sort xml-tests/test.dot > expout 10384 { set +x 10385 $as_echo "$at_srcdir/input.at:1620: \$XSLTPROC \\ 10386 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 10387 xml-tests/test.xml | sort" 10388 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1620" 10389 ( $at_check_trace; $XSLTPROC \ 10390 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 10391 xml-tests/test.xml | sort 10392 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10393 at_status=$? at_failed=false 10394 $at_check_filter 10395 at_fn_diff_devnull "$at_stderr" || at_failed=: 10396 $at_diff expout "$at_stdout" || at_failed=: 10397 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10398 $at_failed && at_fn_log_failure 10399 $at_traceon; } 10400 10401 rm -rf xml-tests expout 10402 at_restore_special_files 10403 fi 10404 { set +x 10405 $as_echo "$at_srcdir/input.at:1620: bison -d -S lalr1.cc input.y" 10406 at_fn_check_prepare_trace "input.at:1620" 10407 ( $at_check_trace; bison -d -S lalr1.cc input.y 10408 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10409 at_status=$? at_failed=false 10410 $at_check_filter 10411 at_fn_diff_devnull "$at_stderr" || at_failed=: 10412 at_fn_diff_devnull "$at_stdout" || at_failed=: 10413 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10414 $at_failed && at_fn_log_failure 10415 $at_traceon; } 10416 10417 10418 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 10419 at_save_special_files 10420 mkdir xml-tests 10421 # Don't combine these Bison invocations since we want to be sure that 10422 # --report=all isn't required to get the full XML file. 10423 { set +x 10424 $as_echo "$at_srcdir/input.at:1620: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 10425 --graph=xml-tests/test.dot -d -S glr.cc input.y" 10426 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1620" 10427 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 10428 --graph=xml-tests/test.dot -d -S glr.cc input.y 10429 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10430 at_status=$? at_failed=false 10431 $at_check_filter 10432 echo stderr:; cat "$at_stderr" 10433 echo stdout:; cat "$at_stdout" 10434 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10435 $at_failed && at_fn_log_failure 10436 $at_traceon; } 10437 10438 { set +x 10439 $as_echo "$at_srcdir/input.at:1620: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d -S glr.cc input.y" 10440 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d -S glr.cc input.y" "input.at:1620" 10441 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -d -S glr.cc input.y 10442 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10443 at_status=$? at_failed=false 10444 $at_check_filter 10445 echo stderr:; cat "$at_stderr" 10446 echo stdout:; cat "$at_stdout" 10447 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10448 $at_failed && at_fn_log_failure 10449 $at_traceon; } 10450 10451 cp xml-tests/test.output expout 10452 { set +x 10453 $as_echo "$at_srcdir/input.at:1620: \$XSLTPROC \\ 10454 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 10455 xml-tests/test.xml" 10456 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1620" 10457 ( $at_check_trace; $XSLTPROC \ 10458 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 10459 xml-tests/test.xml 10460 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10461 at_status=$? at_failed=false 10462 $at_check_filter 10463 at_fn_diff_devnull "$at_stderr" || at_failed=: 10464 $at_diff expout "$at_stdout" || at_failed=: 10465 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10466 $at_failed && at_fn_log_failure 10467 $at_traceon; } 10468 10469 sort xml-tests/test.dot > expout 10470 { set +x 10471 $as_echo "$at_srcdir/input.at:1620: \$XSLTPROC \\ 10472 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 10473 xml-tests/test.xml | sort" 10474 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1620" 10475 ( $at_check_trace; $XSLTPROC \ 10476 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 10477 xml-tests/test.xml | sort 10478 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10479 at_status=$? at_failed=false 10480 $at_check_filter 10481 at_fn_diff_devnull "$at_stderr" || at_failed=: 10482 $at_diff expout "$at_stdout" || at_failed=: 10483 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10484 $at_failed && at_fn_log_failure 10485 $at_traceon; } 10486 10487 rm -rf xml-tests expout 10488 at_restore_special_files 10489 fi 10490 { set +x 10491 $as_echo "$at_srcdir/input.at:1620: bison -d -S glr.cc input.y" 10492 at_fn_check_prepare_trace "input.at:1620" 10493 ( $at_check_trace; bison -d -S glr.cc input.y 10494 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10495 at_status=$? at_failed=false 10496 $at_check_filter 10497 at_fn_diff_devnull "$at_stderr" || at_failed=: 10498 at_fn_diff_devnull "$at_stdout" || at_failed=: 10499 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10500 $at_failed && at_fn_log_failure 10501 $at_traceon; } 10502 10503 10504 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 10505 at_save_special_files 10506 mkdir xml-tests 10507 # Don't combine these Bison invocations since we want to be sure that 10508 # --report=all isn't required to get the full XML file. 10509 { set +x 10510 $as_echo "$at_srcdir/input.at:1620: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 10511 --graph=xml-tests/test.dot -S lalr1.java input.y" 10512 at_fn_check_prepare_notrace 'an embedded newline' "input.at:1620" 10513 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 10514 --graph=xml-tests/test.dot -S lalr1.java input.y 10515 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10516 at_status=$? at_failed=false 10517 $at_check_filter 10518 echo stderr:; cat "$at_stderr" 10519 echo stdout:; cat "$at_stdout" 10520 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10521 $at_failed && at_fn_log_failure 10522 $at_traceon; } 10523 10524 { set +x 10525 $as_echo "$at_srcdir/input.at:1620: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -S lalr1.java input.y" 10526 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -S lalr1.java input.y" "input.at:1620" 10527 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -S lalr1.java input.y 10528 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10529 at_status=$? at_failed=false 10530 $at_check_filter 10531 echo stderr:; cat "$at_stderr" 10532 echo stdout:; cat "$at_stdout" 10533 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10534 $at_failed && at_fn_log_failure 10535 $at_traceon; } 10536 10537 cp xml-tests/test.output expout 10538 { set +x 10539 $as_echo "$at_srcdir/input.at:1620: \$XSLTPROC \\ 10540 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 10541 xml-tests/test.xml" 10542 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1620" 10543 ( $at_check_trace; $XSLTPROC \ 10544 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 10545 xml-tests/test.xml 10546 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10547 at_status=$? at_failed=false 10548 $at_check_filter 10549 at_fn_diff_devnull "$at_stderr" || at_failed=: 10550 $at_diff expout "$at_stdout" || at_failed=: 10551 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10552 $at_failed && at_fn_log_failure 10553 $at_traceon; } 10554 10555 sort xml-tests/test.dot > expout 10556 { set +x 10557 $as_echo "$at_srcdir/input.at:1620: \$XSLTPROC \\ 10558 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 10559 xml-tests/test.xml | sort" 10560 at_fn_check_prepare_notrace 'a `...` command substitution' "input.at:1620" 10561 ( $at_check_trace; $XSLTPROC \ 10562 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 10563 xml-tests/test.xml | sort 10564 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10565 at_status=$? at_failed=false 10566 $at_check_filter 10567 at_fn_diff_devnull "$at_stderr" || at_failed=: 10568 $at_diff expout "$at_stdout" || at_failed=: 10569 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10570 $at_failed && at_fn_log_failure 10571 $at_traceon; } 10572 10573 rm -rf xml-tests expout 10574 at_restore_special_files 10575 fi 10576 { set +x 10577 $as_echo "$at_srcdir/input.at:1620: bison -S lalr1.java input.y" 10578 at_fn_check_prepare_trace "input.at:1620" 10579 ( $at_check_trace; bison -S lalr1.java input.y 10580 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10581 at_status=$? at_failed=false 10582 $at_check_filter 10583 at_fn_diff_devnull "$at_stderr" || at_failed=: 10584 at_fn_diff_devnull "$at_stdout" || at_failed=: 10585 at_fn_check_status 0 $at_status "$at_srcdir/input.at:1620" 10586 $at_failed && at_fn_log_failure 10587 $at_traceon; } 10588 10589 10590 10591 10592 10593 10594 set +x 10595 $at_times_p && times >"$at_times_file" 10596 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 10597 read at_status <"$at_status_file" 10598 #AT_STOP_38 10599 #AT_START_39 10600 at_fn_group_banner 39 'named-refs.at:21' \ 10601 "Tutorial calculator" " " 2 10602 at_xfail=no 10603 ( 10604 $as_echo "39. $at_setup_line: testing $at_desc ..." 10605 $at_traceon 10606 10607 10608 cat >test.y <<'_ATEOF' 10609 %code top { 10610 #include <config.h> 10611 /* We don't need perfect functions for these tests. */ 10612 #undef malloc 10613 #undef memcmp 10614 #undef realloc 10615 } 10616 10617 10618 %{ 10619 #include <assert.h> 10620 #include <stdio.h> 10621 #include <stdlib.h> 10622 #include <string.h> 10623 #include <ctype.h> 10624 typedef int semantic_value; 10625 FILE *input; 10626 static semantic_value global_result = 0; 10627 static int global_count = 0; 10628 static int power (int base, int exponent); 10629 static void yyerror ( const char *msg); 10630 static int yylex (void); 10631 %} 10632 10633 %union 10634 { 10635 semantic_value ival; 10636 }; 10637 10638 %token CALC_EOF 0 "end of input" 10639 %token <ival> NUM "number" 10640 %type <ival> exp 10641 10642 %nonassoc '=' /* comparison */ 10643 %left '-' '+' 10644 %left '*' '/' 10645 %left NEG /* negation--unary minus */ 10646 %right '^' /* exponentiation */ 10647 10648 %% 10649 input: 10650 line 10651 | input line {} 10652 ; 10653 10654 line: 10655 '\n' 10656 | exp '\n' {} 10657 ; 10658 10659 exp: 10660 NUM { $$ = $NUM; } 10661 | exp[l] '=' exp[r] 10662 { 10663 if ($l != $r) 10664 fprintf (stderr, "calc: error: %d != %d\n", $l, $r); 10665 $$ = $l; 10666 } 10667 | exp[x] '+' { $<ival>$ = $x; } [l] exp[r] { $$ = $<ival>l + $r; } 10668 | exp[l] '-' exp[r] { $$ = $l - $r; } 10669 | exp[l] '*' exp[r] { $$ = $l * $r; } 10670 | exp[l] '/' exp[r] { $$ = $l / $r; } 10671 | '-' exp %prec NEG { $$ = -$2; } 10672 | exp[l] '^' exp[r] { $$ = power ($l, $r); } 10673 | '(' exp[e] ')' { $$ = $e; } 10674 | '(' error ')' { $$ = 1111; yyerrok; } 10675 | '!' { $$ = 0; YYERROR; } 10676 | '-' error { $$ = 0; YYERROR; } 10677 ; 10678 %% 10679 #include <stdio.h> 10680 /* A C error reporting function. */ 10681 static 10682 void yyerror ( const char *msg) 10683 { 10684 fprintf (stderr, "%s\n", msg); 10685 } 10686 static int get_char (void) 10687 { 10688 int res = getc (input); 10689 return res; 10690 } 10691 10692 static void unget_char (int c) 10693 { 10694 ungetc (c, input); 10695 } 10696 10697 static int read_signed_integer (void) 10698 { 10699 int c = get_char (); 10700 int sign = 1; 10701 int n = 0; 10702 if (c == '-') 10703 { 10704 c = get_char (); 10705 sign = -1; 10706 } 10707 while (isdigit (c)) 10708 { 10709 n = 10 * n + (c - '0'); 10710 c = get_char (); 10711 } 10712 unget_char ( c); 10713 return sign * n; 10714 } 10715 10716 static int 10717 yylex (void) 10718 { 10719 int c; 10720 /* Skip white space. */ 10721 while ((c = get_char ()) == ' ' || c == '\t') {} 10722 10723 /* process numbers */ 10724 if (c == '.' || isdigit (c)) 10725 { 10726 unget_char ( c); 10727 (yylval).ival = read_signed_integer (); 10728 return NUM; 10729 } 10730 10731 /* Return end-of-file. */ 10732 if (c == EOF) 10733 return CALC_EOF; 10734 10735 /* Return single chars. */ 10736 return c; 10737 } 10738 10739 static int power (int base, int exponent) 10740 { 10741 int res = 1; 10742 assert (0 <= exponent); 10743 for (/* Niente */; exponent; --exponent) 10744 res *= base; 10745 return res; 10746 } 10747 10748 int main (int argc, const char **argv) 10749 { 10750 semantic_value result = 0; 10751 int count = 0; 10752 int status; 10753 if (argc == 2) 10754 input = fopen (argv[1], "r"); 10755 else 10756 input = stdin; 10757 if (!input) 10758 { 10759 perror (argv[1]); 10760 return 3; 10761 } 10762 status = yyparse (); 10763 fclose (input); 10764 assert (global_result == result); 10765 assert (global_count == count); 10766 return status; 10767 } 10768 _ATEOF 10769 10770 10771 10772 cat >input.txt <<'_ATEOF' 10773 10774 1 + 2 * 3 = 7 10775 1 + 2 * -3 = -5 10776 -1^2 = -1 10777 (-1)^2 = 1 10778 ---1 = -1 10779 1 - 2 - 3 = -4 10780 1 - (2 - 3) = 2 10781 2^2^3 = 256 10782 (2^2)^3 = 64 10783 _ATEOF 10784 10785 10786 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 10787 at_save_special_files 10788 mkdir xml-tests 10789 # Don't combine these Bison invocations since we want to be sure that 10790 # --report=all isn't required to get the full XML file. 10791 { set +x 10792 $as_echo "$at_srcdir/named-refs.at:184: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 10793 --graph=xml-tests/test.dot -o test.c test.y" 10794 at_fn_check_prepare_notrace 'an embedded newline' "named-refs.at:184" 10795 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 10796 --graph=xml-tests/test.dot -o test.c test.y 10797 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10798 at_status=$? at_failed=false 10799 $at_check_filter 10800 echo stderr:; cat "$at_stderr" 10801 echo stdout:; cat "$at_stdout" 10802 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:184" 10803 $at_failed && at_fn_log_failure 10804 $at_traceon; } 10805 10806 { set +x 10807 $as_echo "$at_srcdir/named-refs.at:184: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o test.c test.y" 10808 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o test.c test.y" "named-refs.at:184" 10809 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o test.c test.y 10810 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10811 at_status=$? at_failed=false 10812 $at_check_filter 10813 echo stderr:; cat "$at_stderr" 10814 echo stdout:; cat "$at_stdout" 10815 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:184" 10816 $at_failed && at_fn_log_failure 10817 $at_traceon; } 10818 10819 cp xml-tests/test.output expout 10820 { set +x 10821 $as_echo "$at_srcdir/named-refs.at:184: \$XSLTPROC \\ 10822 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 10823 xml-tests/test.xml" 10824 at_fn_check_prepare_notrace 'a `...` command substitution' "named-refs.at:184" 10825 ( $at_check_trace; $XSLTPROC \ 10826 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 10827 xml-tests/test.xml 10828 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10829 at_status=$? at_failed=false 10830 $at_check_filter 10831 at_fn_diff_devnull "$at_stderr" || at_failed=: 10832 $at_diff expout "$at_stdout" || at_failed=: 10833 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:184" 10834 $at_failed && at_fn_log_failure 10835 $at_traceon; } 10836 10837 sort xml-tests/test.dot > expout 10838 { set +x 10839 $as_echo "$at_srcdir/named-refs.at:184: \$XSLTPROC \\ 10840 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 10841 xml-tests/test.xml | sort" 10842 at_fn_check_prepare_notrace 'a `...` command substitution' "named-refs.at:184" 10843 ( $at_check_trace; $XSLTPROC \ 10844 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 10845 xml-tests/test.xml | sort 10846 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10847 at_status=$? at_failed=false 10848 $at_check_filter 10849 at_fn_diff_devnull "$at_stderr" || at_failed=: 10850 $at_diff expout "$at_stdout" || at_failed=: 10851 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:184" 10852 $at_failed && at_fn_log_failure 10853 $at_traceon; } 10854 10855 rm -rf xml-tests expout 10856 at_restore_special_files 10857 fi 10858 { set +x 10859 $as_echo "$at_srcdir/named-refs.at:184: bison -o test.c test.y" 10860 at_fn_check_prepare_trace "named-refs.at:184" 10861 ( $at_check_trace; bison -o test.c test.y 10862 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10863 at_status=$? at_failed=false 10864 $at_check_filter 10865 at_fn_diff_devnull "$at_stderr" || at_failed=: 10866 at_fn_diff_devnull "$at_stdout" || at_failed=: 10867 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:184" 10868 $at_failed && at_fn_log_failure 10869 $at_traceon; } 10870 10871 10872 { set +x 10873 $as_echo "$at_srcdir/named-refs.at:185: \$BISON_C_WORKS" 10874 at_fn_check_prepare_dynamic "$BISON_C_WORKS" "named-refs.at:185" 10875 ( $at_check_trace; $BISON_C_WORKS 10876 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10877 at_status=$? at_failed=false 10878 $at_check_filter 10879 echo stderr:; cat "$at_stderr" 10880 echo stdout:; cat "$at_stdout" 10881 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:185" 10882 $at_failed && at_fn_log_failure 10883 $at_traceon; } 10884 10885 { set +x 10886 $as_echo "$at_srcdir/named-refs.at:185: \$CC \$CFLAGS \$CPPFLAGS \$LDFLAGS -o test test.c \$LIBS" 10887 at_fn_check_prepare_dynamic "$CC $CFLAGS $CPPFLAGS $LDFLAGS -o test test.c $LIBS" "named-refs.at:185" 10888 ( $at_check_trace; $CC $CFLAGS $CPPFLAGS $LDFLAGS -o test test.c $LIBS 10889 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10890 at_status=$? at_failed=false 10891 $at_check_filter 10892 echo stderr:; cat "$at_stderr" 10893 echo stdout:; cat "$at_stdout" 10894 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:185" 10895 $at_failed && at_fn_log_failure 10896 $at_traceon; } 10897 10898 { set +x 10899 $as_echo "$at_srcdir/named-refs.at:186: \$PREPARSER ./test input.txt" 10900 at_fn_check_prepare_dynamic " $PREPARSER ./test input.txt" "named-refs.at:186" 10901 ( $at_check_trace; $PREPARSER ./test input.txt 10902 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10903 at_status=$? at_failed=false 10904 $at_check_filter 10905 echo stderr:; tee stderr <"$at_stderr" 10906 at_fn_diff_devnull "$at_stdout" || at_failed=: 10907 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:186" 10908 $at_failed && at_fn_log_failure 10909 $at_traceon; } 10910 10911 { set +x 10912 $as_echo "$at_srcdir/named-refs.at:186: sed >&2 -e '/^profiling:.*:Merge mismatch for summaries/d' stderr" 10913 at_fn_check_prepare_trace "named-refs.at:186" 10914 ( $at_check_trace; sed >&2 -e '/^profiling:.*:Merge mismatch for summaries/d' stderr 10915 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 10916 at_status=$? at_failed=false 10917 $at_check_filter 10918 echo stderr:; tee stderr <"$at_stderr" 10919 at_fn_diff_devnull "$at_stdout" || at_failed=: 10920 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:186" 10921 $at_failed && at_fn_log_failure 10922 $at_traceon; } 10923 10924 10925 10926 set +x 10927 $at_times_p && times >"$at_times_file" 10928 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 10929 read at_status <"$at_status_file" 10930 #AT_STOP_39 10931 #AT_START_40 10932 at_fn_group_banner 40 'named-refs.at:195' \ 10933 "Undefined and ambiguous references" " " 2 10934 at_xfail=no 10935 ( 10936 $as_echo "40. $at_setup_line: testing $at_desc ..." 10937 $at_traceon 10938 10939 10940 cat >test.y <<'_ATEOF' 10941 %code top { 10942 #include <config.h> 10943 /* We don't need perfect functions for these tests. */ 10944 #undef malloc 10945 #undef memcmp 10946 #undef realloc 10947 } 10948 10949 10950 %{ 10951 static int power (int base, int exponent); 10952 static void yyerror ( const char *msg); 10953 static int yylex (void); 10954 %} 10955 10956 %union 10957 { 10958 int ival; 10959 }; 10960 10961 %token CALC_EOF 0 "end of input" 10962 %token <ival> NUM "number" 10963 %type <ival> exp 10964 10965 %nonassoc '=' /* comparison */ 10966 %left '-' '+' 10967 %left '*' '/' 10968 %left NEG /* negation--unary minus */ 10969 %right '^' /* exponentiation */ 10970 10971 %% 10972 input: 10973 line 10974 | input line {} 10975 ; 10976 10977 line: 10978 '\n' 10979 | exp '\n' {} 10980 ; 10981 10982 exp: 10983 NUM { $$ = $NUM; } 10984 | exp[l] '=' exp[r] 10985 { 10986 if ($l != $r) 10987 fprintf (stderr, "calc: error: %d != %d\n", $l, $r); 10988 $$ = $l; 10989 } 10990 | exp[x] '+' { $<ival>$ = $x; } [l] exp[r] { $$ = $<ival>lo9 + $r; } 10991 | exp[x] '-' { $<ival>$ = $x; } [l] exp[r] { $$ = $<ival>exp - $r; } 10992 | exp[x] '*' { $<ival>$ = $x; } [l] exp[r] { $$ = $l * $r; } 10993 | exp[l] '/' exp[r] { $$ = $l / $r; } 10994 | '-' exp %prec NEG { $$ = -$2; } 10995 | exp[l] '^' exp[r] { $$ = power ($l, $r12); } 10996 | '(' exp ')' { $$ = $expo; } 10997 | '(' error ')' { $$ = 1111; yyerrok; } 10998 | '!' { $$ = 0; YYERROR; } 10999 | '-' error { $$ = 0; YYERROR; } 11000 ; 11001 %% 11002 _ATEOF 11003 11004 11005 11006 11007 { set +x 11008 $as_echo "$at_srcdir/named-refs.at:253: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y" 11009 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y" "named-refs.at:253" 11010 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -o test.c test.y 11011 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11012 at_status=$? at_failed=false 11013 $at_check_filter 11014 echo >>"$at_stderr"; $as_echo "test.y:50.51-60: error: invalid reference: '\$<ival>lo9' 11015 test.y:50.3-68: symbol not found in production: lo9 11016 test.y:51.51-60: warning: misleading reference: '\$<ival>exp' 11017 test.y:42.1-3: refers to: \$exp at \$\$ 11018 test.y:51.7: possibly meant: \$x, hiding \$exp at \$1 11019 test.y:51.41: possibly meant: \$r, hiding \$exp at \$4 11020 test.y:52.51-52: error: \$l of 'exp' has no declared type 11021 test.y:55.40-43: error: invalid reference: '\$r12' 11022 test.y:55.3-47: symbol not found in production: r12 11023 test.y:56.29-33: error: invalid reference: '\$expo' 11024 test.y:56.3-46: symbol not found in production: expo 11025 " | \ 11026 $at_diff - "$at_stderr" || at_failed=: 11027 at_fn_diff_devnull "$at_stdout" || at_failed=: 11028 at_fn_check_status 1 $at_status "$at_srcdir/named-refs.at:253" 11029 $at_failed && at_fn_log_failure 11030 $at_traceon; } 11031 11032 11033 11034 set +x 11035 $at_times_p && times >"$at_times_file" 11036 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 11037 read at_status <"$at_status_file" 11038 #AT_STOP_40 11039 #AT_START_41 11040 at_fn_group_banner 41 'named-refs.at:271' \ 11041 "Misleading references" " " 2 11042 at_xfail=no 11043 ( 11044 $as_echo "41. $at_setup_line: testing $at_desc ..." 11045 $at_traceon 11046 11047 cat >test.y <<'_ATEOF' 11048 %code top { 11049 #include <config.h> 11050 /* We don't need perfect functions for these tests. */ 11051 #undef malloc 11052 #undef memcmp 11053 #undef realloc 11054 } 11055 11056 11057 %% 11058 start: foo foo.bar { $foo.bar; } 11059 foo: '1' 11060 foo.bar: '2' 11061 _ATEOF 11062 11063 11064 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 11065 at_save_special_files 11066 mkdir xml-tests 11067 # Don't combine these Bison invocations since we want to be sure that 11068 # --report=all isn't required to get the full XML file. 11069 { set +x 11070 $as_echo "$at_srcdir/named-refs.at:279: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 11071 --graph=xml-tests/test.dot -o test.c test.y" 11072 at_fn_check_prepare_notrace 'an embedded newline' "named-refs.at:279" 11073 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 11074 --graph=xml-tests/test.dot -o test.c test.y 11075 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11076 at_status=$? at_failed=false 11077 $at_check_filter 11078 echo stderr:; cat "$at_stderr" 11079 echo stdout:; cat "$at_stdout" 11080 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:279" 11081 $at_failed && at_fn_log_failure 11082 $at_traceon; } 11083 11084 { set +x 11085 $as_echo "$at_srcdir/named-refs.at:279: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o test.c test.y" 11086 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o test.c test.y" "named-refs.at:279" 11087 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o test.c test.y 11088 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11089 at_status=$? at_failed=false 11090 $at_check_filter 11091 echo stderr:; cat "$at_stderr" 11092 echo stdout:; cat "$at_stdout" 11093 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:279" 11094 $at_failed && at_fn_log_failure 11095 $at_traceon; } 11096 11097 cp xml-tests/test.output expout 11098 { set +x 11099 $as_echo "$at_srcdir/named-refs.at:279: \$XSLTPROC \\ 11100 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 11101 xml-tests/test.xml" 11102 at_fn_check_prepare_notrace 'a `...` command substitution' "named-refs.at:279" 11103 ( $at_check_trace; $XSLTPROC \ 11104 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 11105 xml-tests/test.xml 11106 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11107 at_status=$? at_failed=false 11108 $at_check_filter 11109 at_fn_diff_devnull "$at_stderr" || at_failed=: 11110 $at_diff expout "$at_stdout" || at_failed=: 11111 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:279" 11112 $at_failed && at_fn_log_failure 11113 $at_traceon; } 11114 11115 sort xml-tests/test.dot > expout 11116 { set +x 11117 $as_echo "$at_srcdir/named-refs.at:279: \$XSLTPROC \\ 11118 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 11119 xml-tests/test.xml | sort" 11120 at_fn_check_prepare_notrace 'a `...` command substitution' "named-refs.at:279" 11121 ( $at_check_trace; $XSLTPROC \ 11122 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 11123 xml-tests/test.xml | sort 11124 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11125 at_status=$? at_failed=false 11126 $at_check_filter 11127 at_fn_diff_devnull "$at_stderr" || at_failed=: 11128 $at_diff expout "$at_stdout" || at_failed=: 11129 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:279" 11130 $at_failed && at_fn_log_failure 11131 $at_traceon; } 11132 11133 rm -rf xml-tests expout 11134 at_restore_special_files 11135 fi 11136 { set +x 11137 $as_echo "$at_srcdir/named-refs.at:279: bison -o test.c test.y" 11138 at_fn_check_prepare_trace "named-refs.at:279" 11139 ( $at_check_trace; bison -o test.c test.y 11140 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11141 at_status=$? at_failed=false 11142 $at_check_filter 11143 echo >>"$at_stderr"; $as_echo "test.y:11.22-29: warning: misleading reference: '\$foo.bar' 11144 test.y:11.8-10: refers to: \$foo at \$1 11145 test.y:11.12-18: possibly meant: \$[foo.bar] at \$2 11146 " | \ 11147 $at_diff - "$at_stderr" || at_failed=: 11148 at_fn_diff_devnull "$at_stdout" || at_failed=: 11149 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:279" 11150 $at_failed && at_fn_log_failure 11151 $at_traceon; } 11152 11153 # Defining POSIXLY_CORRECT causes bison to complain if options are 11154 # added after the grammar file name, so skip these checks in that 11155 # case. 11156 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 11157 at_save_special_files 11158 11159 # To avoid expanding it repeatedly, store specified stdout. 11160 : >expout 11161 11162 # Run with -Werror. 11163 { set +x 11164 $as_echo "$at_srcdir/named-refs.at:279: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y -Werror" 11165 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y -Werror" "named-refs.at:279" 11166 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -o test.c test.y -Werror 11167 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11168 at_status=$? at_failed=false 11169 $at_check_filter 11170 echo stderr:; tee stderr <"$at_stderr" 11171 $at_diff expout "$at_stdout" || at_failed=: 11172 at_fn_check_status 1 $at_status "$at_srcdir/named-refs.at:279" 11173 $at_failed && at_fn_log_failure 11174 $at_traceon; } 11175 11176 11177 # Build expected stderr up to and including the "warnings being 11178 # treated as errors" message. 11179 cat >at-bison-check-warnings <<'_ATEOF' 11180 test.y:11.22-29: warning: misleading reference: '$foo.bar' 11181 test.y:11.8-10: refers to: $foo at $1 11182 test.y:11.12-18: possibly meant: $[foo.bar] at $2 11183 _ATEOF 11184 11185 at_bison_check_first=`sed -n \ 11186 '/: warning: /{=;q;}' at-bison-check-warnings` 11187 : ${at_bison_check_first:=1} 11188 at_bison_check_first_tmp=`sed -n \ 11189 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 11190 : ${at_bison_check_first_tmp:=1} 11191 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 11192 at_bison_check_first=$at_bison_check_first_tmp 11193 fi 11194 if test $at_bison_check_first -gt 1; then 11195 sed -n "1,`expr $at_bison_check_first - 1`"p \ 11196 at-bison-check-warnings > experr 11197 fi 11198 echo 'bison: warnings being treated as errors' >> experr 11199 11200 # Finish building expected stderr and check. Unlike warnings, 11201 # complaints cause bison to exit early. Thus, with -Werror, bison 11202 # does not necessarily report all warnings that it does without 11203 # -Werror, but it at least reports one. 11204 at_bison_check_last=`sed -n '$=' stderr` 11205 : ${at_bison_check_last:=1} 11206 at_bison_check_last=`expr $at_bison_check_last - 1` 11207 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 11208 at-bison-check-warnings >> experr 11209 { set +x 11210 $as_echo "$at_srcdir/named-refs.at:279: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 11211 stderr 1>&2" 11212 at_fn_check_prepare_notrace 'an embedded newline' "named-refs.at:279" 11213 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 11214 stderr 1>&2 11215 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11216 at_status=$? at_failed=false 11217 $at_check_filter 11218 $at_diff experr "$at_stderr" || at_failed=: 11219 at_fn_diff_devnull "$at_stdout" || at_failed=: 11220 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:279" 11221 $at_failed && at_fn_log_failure 11222 $at_traceon; } 11223 11224 11225 # Now check --warnings=error. 11226 cp stderr experr 11227 { set +x 11228 $as_echo "$at_srcdir/named-refs.at:279: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y --warnings=error" 11229 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y --warnings=error" "named-refs.at:279" 11230 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -o test.c test.y --warnings=error 11231 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11232 at_status=$? at_failed=false 11233 $at_check_filter 11234 $at_diff experr "$at_stderr" || at_failed=: 11235 $at_diff expout "$at_stdout" || at_failed=: 11236 at_fn_check_status 1 $at_status "$at_srcdir/named-refs.at:279" 11237 $at_failed && at_fn_log_failure 11238 $at_traceon; } 11239 11240 11241 # Now check -Wnone and --warnings=none by making sure that 11242 # -Werror doesn't change the exit status when -Wnone or 11243 # --warnings=none is specified. 11244 { set +x 11245 $as_echo "$at_srcdir/named-refs.at:279: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y -Wnone -Werror" 11246 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y -Wnone -Werror" "named-refs.at:279" 11247 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -o test.c test.y -Wnone -Werror 11248 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11249 at_status=$? at_failed=false 11250 $at_check_filter 11251 at_fn_diff_devnull "$at_stderr" || at_failed=: 11252 $at_diff expout "$at_stdout" || at_failed=: 11253 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:279" 11254 $at_failed && at_fn_log_failure 11255 $at_traceon; } 11256 11257 { set +x 11258 $as_echo "$at_srcdir/named-refs.at:279: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y --warnings=none -Werror" 11259 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y --warnings=none -Werror" "named-refs.at:279" 11260 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -o test.c test.y --warnings=none -Werror 11261 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11262 at_status=$? at_failed=false 11263 $at_check_filter 11264 at_fn_diff_devnull "$at_stderr" || at_failed=: 11265 $at_diff expout "$at_stdout" || at_failed=: 11266 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:279" 11267 $at_failed && at_fn_log_failure 11268 $at_traceon; } 11269 11270 11271 at_restore_special_files 11272 fi 11273 set +x 11274 $at_times_p && times >"$at_times_file" 11275 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 11276 read at_status <"$at_status_file" 11277 #AT_STOP_41 11278 #AT_START_42 11279 at_fn_group_banner 42 'named-refs.at:288' \ 11280 "Many kinds of errors" " " 2 11281 at_xfail=no 11282 ( 11283 $as_echo "42. $at_setup_line: testing $at_desc ..." 11284 $at_traceon 11285 11286 cat >test.y <<'_ATEOF' 11287 %code top { 11288 #include <config.h> 11289 /* We don't need perfect functions for these tests. */ 11290 #undef malloc 11291 #undef memcmp 11292 #undef realloc 11293 } 11294 11295 11296 %token IDENT 11297 %token NUMBER 11298 %token ASSIGNOP 11299 %token IF 11300 %token IF1 11301 %token THEN 11302 %token ELSE 11303 %token FI 11304 %token WHILE 11305 %token DO 11306 %token OD 11307 %start program 11308 %% 11309 if_stmt1: IF expr[cond] THEN stmt[then] ELSE stmt.list[else] FI 11310 { $if_stmt1 = new IfStmt($cond1, $then.f1, $else); }; 11311 if_stmt2: IF expr[cond] THEN stmt[then] FI 11312 { $if_stmt2 = new IfStmt($cond, $stmt.field, 0); }; 11313 if_stmt3: IF expr[cond] THEN stmt.list FI 11314 { $if_stmt3 = new IfStmt($cond, $stmt.list, 0); }; 11315 if_stmt4: IF expr[cond] THEN stmt[xyz] ELSE stmt[xyz] FI 11316 { $if_stmt4 = new IfStmt($cond, $xyz, $cond); }; 11317 if_stmt5: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI 11318 { $if_stmt5 = new IfStmt($cond, $stmt.list, $else); }; 11319 if_stmt6: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI 11320 { $if_stmt6 = new IfStmt($cond, $stmt.list.field, $else); }; 11321 if_stmt7: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI 11322 { $if_stmt7 = new IfStmt($cond, $[stmt.list].field, $else); }; 11323 if_stmt8: IF expr[cond] THEN stmt.list[then.1] ELSE stmt.list[else] FI 11324 { $if_stmt8 = new IfStmt($cond, $then.1, $else); }; 11325 if_stmt9: IF expr[cond] THEN stmt.list[then.1] ELSE stmt.list[else] FI 11326 { $if_stmt9 = new IfStmt($cond, $then.1.field, $else); }; 11327 if_stmt10: IF expr[cond] THEN stmt[stmt.x] FI 11328 { $if_stmt10 = new IfStmt($cond, $stmt.x, 0); }; 11329 if-stmt-a: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI 11330 { $if-stmt-a = new IfStmt($cond, $then, $else); }; 11331 if-stmt-b: IF expr[cond] THEN if-stmt-a[then-a] ELSE stmt.list[else] FI 11332 { $[if-stmt-b] = new IfStmt($cond, $then-a.f, $else); }; 11333 program: stmt.list; 11334 stmt.list: stmt ';' stmt.list { $3->insert($stmt); $$ = $3; } 11335 | stmt ';' { SL = new StmtList(); SL->insert($1); $$ = SL; } 11336 ; 11337 stmt: assign_stmt { $$ = $1; } 11338 | if_stmt { $$ = $1; } 11339 | if_stmt1 { $$ = $1; } 11340 | while_stmt { $$ = $1; } 11341 ; 11342 assign_stmt: IDENT ASSIGNOP expr 11343 { $$ = new AssignStmt(string($1),$3); }; 11344 if_stmt: IF expr[cond] THEN stmt.list FI 11345 { $if_stmt = new IfStmt($cond, $[stmt.list], 0); }; 11346 while_stmt[res]: WHILE expr DO stmt.list OD 11347 { $res = new WhileStmt($[expr], $[stmt.list]); }; 11348 expr: expr '+' term { $$ = new Plus($1,$3); } 11349 | expr '-' term { $$ = new Minus($1,$3); } 11350 | term { $$ = $1; } 11351 ; 11352 term: term '*' factor { $$ = new Times($1,$3); } 11353 | factor { $$ = $1; } 11354 ; 11355 factor: '(' expr ')' { $$ = $2; } 11356 | NUMBER { $$ = new Number($1); } 11357 | IDENT { $$ = new Ident(string($1)); } 11358 ; 11359 _ATEOF 11360 11361 11362 11363 { set +x 11364 $as_echo "$at_srcdir/named-refs.at:355: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y" 11365 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y" "named-refs.at:355" 11366 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -o test.c test.y 11367 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11368 at_status=$? at_failed=false 11369 $at_check_filter 11370 echo >>"$at_stderr"; $as_echo "test.y:24.36-41: error: invalid reference: '\$cond1' 11371 test.y:23.11-24.62: symbol not found in production: cond1 11372 test.y:26.43-53: error: invalid reference: '\$stmt.field' 11373 test.y:25.11-26.60: symbol not found in production: stmt 11374 test.y:25.35-38: possibly meant: \$then.field, hiding \$stmt.field at \$4 11375 test.y:28.43-52: error: invalid reference: '\$stmt.list' 11376 test.y:27.11-28.59: symbol not found in production: stmt 11377 test.y:27.30-38: possibly meant: \$[stmt.list] at \$4 11378 test.y:30.43-46: error: ambiguous reference: '\$xyz' 11379 test.y:29.35-37: refers to: \$xyz at \$4 11380 test.y:29.50-52: refers to: \$xyz at \$6 11381 test.y:32.43-52: error: invalid reference: '\$stmt.list' 11382 test.y:31.11-32.63: symbol not found in production: stmt 11383 test.y:31.40-43: possibly meant: \$then, hiding \$[stmt.list] at \$4 11384 test.y:31.61-64: possibly meant: \$else, hiding \$[stmt.list] at \$6 11385 test.y:34.43-58: error: invalid reference: '\$stmt.list.field' 11386 test.y:33.11-34.69: symbol not found in production: stmt 11387 test.y:33.40-43: possibly meant: \$then.field, hiding \$[stmt.list].field at \$4 11388 test.y:33.61-64: possibly meant: \$else.field, hiding \$[stmt.list].field at \$6 11389 test.y:36.43-54: error: invalid reference: '\$[stmt.list]' 11390 test.y:35.11-36.71: symbol not found in production: stmt.list 11391 test.y:35.40-43: possibly meant: \$then, hiding \$[stmt.list] at \$4 11392 test.y:35.61-64: possibly meant: \$else, hiding \$[stmt.list] at \$6 11393 test.y:38.43-49: error: invalid reference: '\$then.1' 11394 test.y:37.11-38.60: symbol not found in production: then 11395 test.y:37.40-45: possibly meant: \$[then.1] at \$4 11396 test.y:40.43-55: error: invalid reference: '\$then.1.field' 11397 test.y:39.11-40.66: symbol not found in production: then 11398 test.y:39.40-45: possibly meant: \$[then.1].field at \$4 11399 test.y:42.44-50: error: invalid reference: '\$stmt.x' 11400 test.y:41.12-42.57: symbol not found in production: stmt 11401 test.y:41.36-41: possibly meant: \$[stmt.x].x, hiding \$stmt.x at \$4 11402 test.y:41.36-41: possibly meant: \$[stmt.x] at \$4 11403 test.y:44.13-22: error: invalid reference: '\$if-stmt-a' 11404 test.y:43.12-44.59: symbol not found in production: if 11405 test.y:43.1-9: possibly meant: \$[if-stmt-a] at \$\$ 11406 test.y:46.46-54: error: invalid reference: '\$then-a.f' 11407 test.y:45.12-46.65: symbol not found in production: then 11408 test.y:45.41-46: possibly meant: \$[then-a].f at \$4 11409 " | \ 11410 $at_diff - "$at_stderr" || at_failed=: 11411 at_fn_diff_devnull "$at_stdout" || at_failed=: 11412 at_fn_check_status 1 $at_status "$at_srcdir/named-refs.at:355" 11413 $at_failed && at_fn_log_failure 11414 $at_traceon; } 11415 11416 11417 11418 11419 { set +x 11420 $as_echo "$at_srcdir/named-refs.at:397: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret -o test.c test.y" 11421 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret -o test.c test.y" "named-refs.at:397" 11422 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -fcaret -o test.c test.y 11423 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11424 at_status=$? at_failed=false 11425 $at_check_filter 11426 echo >>"$at_stderr"; $as_echo "test.y:24.36-41: error: invalid reference: '\$cond1' 11427 { \$if_stmt1 = new IfStmt(\$cond1, \$then.f1, \$else); }; 11428 ^^^^^^ 11429 test.y:23.11-24.62: symbol not found in production: cond1 11430 if_stmt1: IF expr[cond] THEN stmt[then] ELSE stmt.list[else] FI 11431 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 11432 test.y:26.43-53: error: invalid reference: '\$stmt.field' 11433 { \$if_stmt2 = new IfStmt(\$cond, \$stmt.field, 0); }; 11434 ^^^^^^^^^^^ 11435 test.y:25.11-26.60: symbol not found in production: stmt 11436 if_stmt2: IF expr[cond] THEN stmt[then] FI 11437 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 11438 test.y:25.35-38: possibly meant: \$then.field, hiding \$stmt.field at \$4 11439 if_stmt2: IF expr[cond] THEN stmt[then] FI 11440 ^^^^ 11441 test.y:28.43-52: error: invalid reference: '\$stmt.list' 11442 { \$if_stmt3 = new IfStmt(\$cond, \$stmt.list, 0); }; 11443 ^^^^^^^^^^ 11444 test.y:27.11-28.59: symbol not found in production: stmt 11445 if_stmt3: IF expr[cond] THEN stmt.list FI 11446 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 11447 test.y:27.30-38: possibly meant: \$[stmt.list] at \$4 11448 if_stmt3: IF expr[cond] THEN stmt.list FI 11449 ^^^^^^^^^ 11450 test.y:30.43-46: error: ambiguous reference: '\$xyz' 11451 { \$if_stmt4 = new IfStmt(\$cond, \$xyz, \$cond); }; 11452 ^^^^ 11453 test.y:29.35-37: refers to: \$xyz at \$4 11454 if_stmt4: IF expr[cond] THEN stmt[xyz] ELSE stmt[xyz] FI 11455 ^^^ 11456 test.y:29.50-52: refers to: \$xyz at \$6 11457 if_stmt4: IF expr[cond] THEN stmt[xyz] ELSE stmt[xyz] FI 11458 ^^^ 11459 test.y:32.43-52: error: invalid reference: '\$stmt.list' 11460 { \$if_stmt5 = new IfStmt(\$cond, \$stmt.list, \$else); }; 11461 ^^^^^^^^^^ 11462 test.y:31.11-32.63: symbol not found in production: stmt 11463 if_stmt5: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI 11464 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 11465 test.y:31.40-43: possibly meant: \$then, hiding \$[stmt.list] at \$4 11466 if_stmt5: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI 11467 ^^^^ 11468 test.y:31.61-64: possibly meant: \$else, hiding \$[stmt.list] at \$6 11469 if_stmt5: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI 11470 ^^^^ 11471 test.y:34.43-58: error: invalid reference: '\$stmt.list.field' 11472 { \$if_stmt6 = new IfStmt(\$cond, \$stmt.list.field, \$else); }; 11473 ^^^^^^^^^^^^^^^^ 11474 test.y:33.11-34.69: symbol not found in production: stmt 11475 if_stmt6: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI 11476 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 11477 test.y:33.40-43: possibly meant: \$then.field, hiding \$[stmt.list].field at \$4 11478 if_stmt6: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI 11479 ^^^^ 11480 test.y:33.61-64: possibly meant: \$else.field, hiding \$[stmt.list].field at \$6 11481 if_stmt6: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI 11482 ^^^^ 11483 test.y:36.43-54: error: invalid reference: '\$[stmt.list]' 11484 { \$if_stmt7 = new IfStmt(\$cond, \$[stmt.list].field, \$else); }; 11485 ^^^^^^^^^^^^ 11486 test.y:35.11-36.71: symbol not found in production: stmt.list 11487 if_stmt7: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI 11488 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 11489 test.y:35.40-43: possibly meant: \$then, hiding \$[stmt.list] at \$4 11490 if_stmt7: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI 11491 ^^^^ 11492 test.y:35.61-64: possibly meant: \$else, hiding \$[stmt.list] at \$6 11493 if_stmt7: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI 11494 ^^^^ 11495 test.y:38.43-49: error: invalid reference: '\$then.1' 11496 { \$if_stmt8 = new IfStmt(\$cond, \$then.1, \$else); }; 11497 ^^^^^^^ 11498 test.y:37.11-38.60: symbol not found in production: then 11499 if_stmt8: IF expr[cond] THEN stmt.list[then.1] ELSE stmt.list[else] FI 11500 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 11501 test.y:37.40-45: possibly meant: \$[then.1] at \$4 11502 if_stmt8: IF expr[cond] THEN stmt.list[then.1] ELSE stmt.list[else] FI 11503 ^^^^^^ 11504 test.y:40.43-55: error: invalid reference: '\$then.1.field' 11505 { \$if_stmt9 = new IfStmt(\$cond, \$then.1.field, \$else); }; 11506 ^^^^^^^^^^^^^ 11507 test.y:39.11-40.66: symbol not found in production: then 11508 if_stmt9: IF expr[cond] THEN stmt.list[then.1] ELSE stmt.list[else] FI 11509 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 11510 test.y:39.40-45: possibly meant: \$[then.1].field at \$4 11511 if_stmt9: IF expr[cond] THEN stmt.list[then.1] ELSE stmt.list[else] FI 11512 ^^^^^^ 11513 test.y:42.44-50: error: invalid reference: '\$stmt.x' 11514 { \$if_stmt10 = new IfStmt(\$cond, \$stmt.x, 0); }; 11515 ^^^^^^^ 11516 test.y:41.12-42.57: symbol not found in production: stmt 11517 if_stmt10: IF expr[cond] THEN stmt[stmt.x] FI 11518 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 11519 test.y:41.36-41: possibly meant: \$[stmt.x].x, hiding \$stmt.x at \$4 11520 if_stmt10: IF expr[cond] THEN stmt[stmt.x] FI 11521 ^^^^^^ 11522 test.y:41.36-41: possibly meant: \$[stmt.x] at \$4 11523 if_stmt10: IF expr[cond] THEN stmt[stmt.x] FI 11524 ^^^^^^ 11525 test.y:44.13-22: error: invalid reference: '\$if-stmt-a' 11526 { \$if-stmt-a = new IfStmt(\$cond, \$then, \$else); }; 11527 ^^^^^^^^^^ 11528 test.y:43.12-44.59: symbol not found in production: if 11529 if-stmt-a: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI 11530 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 11531 test.y:43.1-9: possibly meant: \$[if-stmt-a] at \$\$ 11532 if-stmt-a: IF expr[cond] THEN stmt.list[then] ELSE stmt.list[else] FI 11533 ^^^^^^^^^ 11534 test.y:46.46-54: error: invalid reference: '\$then-a.f' 11535 { \$[if-stmt-b] = new IfStmt(\$cond, \$then-a.f, \$else); }; 11536 ^^^^^^^^^ 11537 test.y:45.12-46.65: symbol not found in production: then 11538 if-stmt-b: IF expr[cond] THEN if-stmt-a[then-a] ELSE stmt.list[else] FI 11539 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 11540 test.y:45.41-46: possibly meant: \$[then-a].f at \$4 11541 if-stmt-b: IF expr[cond] THEN if-stmt-a[then-a] ELSE stmt.list[else] FI 11542 ^^^^^^ 11543 " | \ 11544 $at_diff - "$at_stderr" || at_failed=: 11545 at_fn_diff_devnull "$at_stdout" || at_failed=: 11546 at_fn_check_status 1 $at_status "$at_srcdir/named-refs.at:397" 11547 $at_failed && at_fn_log_failure 11548 $at_traceon; } 11549 11550 11551 11552 set +x 11553 $at_times_p && times >"$at_times_file" 11554 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 11555 read at_status <"$at_status_file" 11556 #AT_STOP_42 11557 #AT_START_43 11558 at_fn_group_banner 43 'named-refs.at:521' \ 11559 "Missing identifiers in brackets" " " 2 11560 at_xfail=no 11561 ( 11562 $as_echo "43. $at_setup_line: testing $at_desc ..." 11563 $at_traceon 11564 11565 cat >test.y <<'_ATEOF' 11566 %code top { 11567 #include <config.h> 11568 /* We don't need perfect functions for these tests. */ 11569 #undef malloc 11570 #undef memcmp 11571 #undef realloc 11572 } 11573 11574 11575 %% 11576 start: foo[] bar 11577 { s = $foo; } 11578 _ATEOF 11579 11580 11581 11582 { set +x 11583 $as_echo "$at_srcdir/named-refs.at:528: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y" 11584 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y" "named-refs.at:528" 11585 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -o test.c test.y 11586 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11587 at_status=$? at_failed=false 11588 $at_check_filter 11589 echo >>"$at_stderr"; $as_echo "test.y:11.12: error: an identifier expected 11590 " | \ 11591 $at_diff - "$at_stderr" || at_failed=: 11592 at_fn_diff_devnull "$at_stdout" || at_failed=: 11593 at_fn_check_status 1 $at_status "$at_srcdir/named-refs.at:528" 11594 $at_failed && at_fn_log_failure 11595 $at_traceon; } 11596 11597 11598 set +x 11599 $at_times_p && times >"$at_times_file" 11600 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 11601 read at_status <"$at_status_file" 11602 #AT_STOP_43 11603 #AT_START_44 11604 at_fn_group_banner 44 'named-refs.at:535' \ 11605 "Redundant words in brackets" " " 2 11606 at_xfail=no 11607 ( 11608 $as_echo "44. $at_setup_line: testing $at_desc ..." 11609 $at_traceon 11610 11611 cat >test.y <<'_ATEOF' 11612 %code top { 11613 #include <config.h> 11614 /* We don't need perfect functions for these tests. */ 11615 #undef malloc 11616 #undef memcmp 11617 #undef realloc 11618 } 11619 11620 11621 %% 11622 start: foo[ a d ] bar 11623 { s = $foo; } 11624 _ATEOF 11625 11626 11627 11628 { set +x 11629 $as_echo "$at_srcdir/named-refs.at:542: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y" 11630 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y" "named-refs.at:542" 11631 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -o test.c test.y 11632 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11633 at_status=$? at_failed=false 11634 $at_check_filter 11635 echo >>"$at_stderr"; $as_echo "test.y:11.15: error: unexpected identifier in bracketed name: 'd' 11636 " | \ 11637 $at_diff - "$at_stderr" || at_failed=: 11638 at_fn_diff_devnull "$at_stdout" || at_failed=: 11639 at_fn_check_status 1 $at_status "$at_srcdir/named-refs.at:542" 11640 $at_failed && at_fn_log_failure 11641 $at_traceon; } 11642 11643 11644 set +x 11645 $at_times_p && times >"$at_times_file" 11646 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 11647 read at_status <"$at_status_file" 11648 #AT_STOP_44 11649 #AT_START_45 11650 at_fn_group_banner 45 'named-refs.at:549' \ 11651 "Comments in brackets" " " 2 11652 at_xfail=no 11653 ( 11654 $as_echo "45. $at_setup_line: testing $at_desc ..." 11655 $at_traceon 11656 11657 cat >test.y <<'_ATEOF' 11658 %code top { 11659 #include <config.h> 11660 /* We don't need perfect functions for these tests. */ 11661 #undef malloc 11662 #undef memcmp 11663 #undef realloc 11664 } 11665 11666 11667 %% 11668 start: foo[/* comment */] bar 11669 { s = $foo; } 11670 _ATEOF 11671 11672 11673 11674 { set +x 11675 $as_echo "$at_srcdir/named-refs.at:556: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y" 11676 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y" "named-refs.at:556" 11677 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -o test.c test.y 11678 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11679 at_status=$? at_failed=false 11680 $at_check_filter 11681 echo >>"$at_stderr"; $as_echo "test.y:11.25: error: an identifier expected 11682 " | \ 11683 $at_diff - "$at_stderr" || at_failed=: 11684 at_fn_diff_devnull "$at_stdout" || at_failed=: 11685 at_fn_check_status 1 $at_status "$at_srcdir/named-refs.at:556" 11686 $at_failed && at_fn_log_failure 11687 $at_traceon; } 11688 11689 11690 set +x 11691 $at_times_p && times >"$at_times_file" 11692 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 11693 read at_status <"$at_status_file" 11694 #AT_STOP_45 11695 #AT_START_46 11696 at_fn_group_banner 46 'named-refs.at:563' \ 11697 "Stray symbols in brackets" " " 2 11698 at_xfail=no 11699 ( 11700 $as_echo "46. $at_setup_line: testing $at_desc ..." 11701 $at_traceon 11702 11703 cat >test.y <<'_ATEOF' 11704 %code top { 11705 #include <config.h> 11706 /* We don't need perfect functions for these tests. */ 11707 #undef malloc 11708 #undef memcmp 11709 #undef realloc 11710 } 11711 11712 11713 %% 11714 start: foo[ % /* aaa */ *&-.+\000\001\002\377 ] bar 11715 { s = $foo; } 11716 _ATEOF 11717 11718 11719 { set +x 11720 $as_echo "$at_srcdir/named-refs.at:570: \$PERL -pi -e 's/\\\\(\\d{3})/chr(oct(\$1))/ge' test.y || exit 77" 11721 at_fn_check_prepare_dynamic "$PERL -pi -e 's/\\\\(\\d{3})/chr(oct($1))/ge' test.y || exit 77" "named-refs.at:570" 11722 ( $at_check_trace; $PERL -pi -e 's/\\(\d{3})/chr(oct($1))/ge' test.y || exit 77 11723 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11724 at_status=$? at_failed=false 11725 $at_check_filter 11726 at_fn_diff_devnull "$at_stderr" || at_failed=: 11727 at_fn_diff_devnull "$at_stdout" || at_failed=: 11728 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:570" 11729 $at_failed && at_fn_log_failure 11730 $at_traceon; } 11731 11732 11733 { set +x 11734 $as_echo "$at_srcdir/named-refs.at:571: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y" 11735 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y" "named-refs.at:571" 11736 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -o test.c test.y 11737 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11738 at_status=$? at_failed=false 11739 $at_check_filter 11740 echo >>"$at_stderr"; $as_echo "test.y:11.13: error: invalid character in bracketed name: '%' 11741 test.y:11.25-27: error: invalid characters in bracketed name: '*&-' 11742 test.y:11.29-30: error: invalid characters in bracketed name: '+\\0\\001\\002\\377' 11743 " | \ 11744 $at_diff - "$at_stderr" || at_failed=: 11745 at_fn_diff_devnull "$at_stdout" || at_failed=: 11746 at_fn_check_status 1 $at_status "$at_srcdir/named-refs.at:571" 11747 $at_failed && at_fn_log_failure 11748 $at_traceon; } 11749 11750 11751 set +x 11752 $at_times_p && times >"$at_times_file" 11753 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 11754 read at_status <"$at_status_file" 11755 #AT_STOP_46 11756 #AT_START_47 11757 at_fn_group_banner 47 'named-refs.at:580' \ 11758 "Redundant words in LHS brackets" " " 2 11759 at_xfail=no 11760 ( 11761 $as_echo "47. $at_setup_line: testing $at_desc ..." 11762 $at_traceon 11763 11764 cat >test.y <<'_ATEOF' 11765 %code top { 11766 #include <config.h> 11767 /* We don't need perfect functions for these tests. */ 11768 #undef malloc 11769 #undef memcmp 11770 #undef realloc 11771 } 11772 11773 11774 %% 11775 start[a s]: foo; 11776 _ATEOF 11777 11778 11779 11780 { set +x 11781 $as_echo "$at_srcdir/named-refs.at:586: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y" 11782 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y" "named-refs.at:586" 11783 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -o test.c test.y 11784 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11785 at_status=$? at_failed=false 11786 $at_check_filter 11787 echo >>"$at_stderr"; $as_echo "test.y:11.9: error: unexpected identifier in bracketed name: 's' 11788 " | \ 11789 $at_diff - "$at_stderr" || at_failed=: 11790 at_fn_diff_devnull "$at_stdout" || at_failed=: 11791 at_fn_check_status 1 $at_status "$at_srcdir/named-refs.at:586" 11792 $at_failed && at_fn_log_failure 11793 $at_traceon; } 11794 11795 11796 set +x 11797 $at_times_p && times >"$at_times_file" 11798 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 11799 read at_status <"$at_status_file" 11800 #AT_STOP_47 11801 #AT_START_48 11802 at_fn_group_banner 48 'named-refs.at:595' \ 11803 "Factored LHS" " " 2 11804 at_xfail=no 11805 ( 11806 $as_echo "48. $at_setup_line: testing $at_desc ..." 11807 $at_traceon 11808 11809 cat >test.y <<'_ATEOF' 11810 %code top { 11811 #include <config.h> 11812 /* We don't need perfect functions for these tests. */ 11813 #undef malloc 11814 #undef memcmp 11815 #undef realloc 11816 } 11817 11818 11819 %% 11820 start[a]: "foo" | "bar"; 11821 _ATEOF 11822 11823 11824 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 11825 at_save_special_files 11826 mkdir xml-tests 11827 # Don't combine these Bison invocations since we want to be sure that 11828 # --report=all isn't required to get the full XML file. 11829 { set +x 11830 $as_echo "$at_srcdir/named-refs.at:601: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 11831 --graph=xml-tests/test.dot -o test.c test.y" 11832 at_fn_check_prepare_notrace 'an embedded newline' "named-refs.at:601" 11833 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 11834 --graph=xml-tests/test.dot -o test.c test.y 11835 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11836 at_status=$? at_failed=false 11837 $at_check_filter 11838 echo stderr:; cat "$at_stderr" 11839 echo stdout:; cat "$at_stdout" 11840 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:601" 11841 $at_failed && at_fn_log_failure 11842 $at_traceon; } 11843 11844 { set +x 11845 $as_echo "$at_srcdir/named-refs.at:601: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o test.c test.y" 11846 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o test.c test.y" "named-refs.at:601" 11847 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o test.c test.y 11848 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11849 at_status=$? at_failed=false 11850 $at_check_filter 11851 echo stderr:; cat "$at_stderr" 11852 echo stdout:; cat "$at_stdout" 11853 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:601" 11854 $at_failed && at_fn_log_failure 11855 $at_traceon; } 11856 11857 cp xml-tests/test.output expout 11858 { set +x 11859 $as_echo "$at_srcdir/named-refs.at:601: \$XSLTPROC \\ 11860 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 11861 xml-tests/test.xml" 11862 at_fn_check_prepare_notrace 'a `...` command substitution' "named-refs.at:601" 11863 ( $at_check_trace; $XSLTPROC \ 11864 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 11865 xml-tests/test.xml 11866 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11867 at_status=$? at_failed=false 11868 $at_check_filter 11869 at_fn_diff_devnull "$at_stderr" || at_failed=: 11870 $at_diff expout "$at_stdout" || at_failed=: 11871 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:601" 11872 $at_failed && at_fn_log_failure 11873 $at_traceon; } 11874 11875 sort xml-tests/test.dot > expout 11876 { set +x 11877 $as_echo "$at_srcdir/named-refs.at:601: \$XSLTPROC \\ 11878 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 11879 xml-tests/test.xml | sort" 11880 at_fn_check_prepare_notrace 'a `...` command substitution' "named-refs.at:601" 11881 ( $at_check_trace; $XSLTPROC \ 11882 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 11883 xml-tests/test.xml | sort 11884 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11885 at_status=$? at_failed=false 11886 $at_check_filter 11887 at_fn_diff_devnull "$at_stderr" || at_failed=: 11888 $at_diff expout "$at_stdout" || at_failed=: 11889 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:601" 11890 $at_failed && at_fn_log_failure 11891 $at_traceon; } 11892 11893 rm -rf xml-tests expout 11894 at_restore_special_files 11895 fi 11896 { set +x 11897 $as_echo "$at_srcdir/named-refs.at:601: bison -o test.c test.y" 11898 at_fn_check_prepare_trace "named-refs.at:601" 11899 ( $at_check_trace; bison -o test.c test.y 11900 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11901 at_status=$? at_failed=false 11902 $at_check_filter 11903 at_fn_diff_devnull "$at_stderr" || at_failed=: 11904 at_fn_diff_devnull "$at_stdout" || at_failed=: 11905 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:601" 11906 $at_failed && at_fn_log_failure 11907 $at_traceon; } 11908 11909 11910 set +x 11911 $at_times_p && times >"$at_times_file" 11912 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 11913 read at_status <"$at_status_file" 11914 #AT_STOP_48 11915 #AT_START_49 11916 at_fn_group_banner 49 'named-refs.at:606' \ 11917 "Unresolved references" " " 2 11918 at_xfail=no 11919 ( 11920 $as_echo "49. $at_setup_line: testing $at_desc ..." 11921 $at_traceon 11922 11923 cat >test.y <<'_ATEOF' 11924 %code top { 11925 #include <config.h> 11926 /* We don't need perfect functions for these tests. */ 11927 #undef malloc 11928 #undef memcmp 11929 #undef realloc 11930 } 11931 11932 11933 %% 11934 stat: 11935 sym_a sym_b { func($sym.field); } 11936 | sym_a sym_b { func($<aa>sym.field); } 11937 | sym_a sym_b { func($[sym.field]); } 11938 | sym_a sym_b { func($<aa>[sym.field]); } 11939 | sym_a sym_b { func($sym); } 11940 | sym_a sym_b { func($<aa>sym); } 11941 | sym_a sym_b { func($[sym]); } sym_a sym_b { func($<aa>[sym]); } 11942 ; 11943 11944 stat1: 11945 sym_a sym_b { func($sym-field); } 11946 | sym_a sym_b { func($<aa>sym-field); } 11947 | sym_a sym_b { func($[sym-field]); } 11948 | sym_a sym_b { func($<aa>[sym-field]); } 11949 | sym_a sym_b { func($sym); } 11950 | sym_a sym_b { func($<aa>sym); } 11951 | sym_a sym_b { func($[sym]); } sym_a sym_b { func($<aa>[sym]); } 11952 ; 11953 11954 sym_a: 'a'; 11955 sym_b: 'b'; 11956 _ATEOF 11957 11958 11959 11960 { set +x 11961 $as_echo "$at_srcdir/named-refs.at:633: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y" 11962 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o test.c test.y" "named-refs.at:633" 11963 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -o test.c test.y 11964 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 11965 at_status=$? at_failed=false 11966 $at_check_filter 11967 echo >>"$at_stderr"; $as_echo "test.y:12.22-31: error: invalid reference: '\$sym.field' 11968 test.y:12.3-35: symbol not found in production: sym 11969 test.y:13.22-35: error: invalid reference: '\$<aa>sym.field' 11970 test.y:13.3-39: symbol not found in production: sym 11971 test.y:14.22-33: error: invalid reference: '\$[sym.field]' 11972 test.y:14.3-37: symbol not found in production: sym.field 11973 test.y:15.22-37: error: invalid reference: '\$<aa>[sym.field]' 11974 test.y:15.3-41: symbol not found in production: sym.field 11975 test.y:16.22-25: error: invalid reference: '\$sym' 11976 test.y:16.3-29: symbol not found in production: sym 11977 test.y:17.22-29: error: invalid reference: '\$<aa>sym' 11978 test.y:17.3-33: symbol not found in production: sym 11979 test.y:18.22-27: error: invalid reference: '\$[sym]' 11980 test.y:18.3-65: symbol not found in production before \$3: sym 11981 test.y:18.52-61: error: invalid reference: '\$<aa>[sym]' 11982 test.y:18.3-65: symbol not found in production: sym 11983 test.y:22.22-31: error: invalid reference: '\$sym-field' 11984 test.y:22.3-35: symbol not found in production: sym 11985 test.y:23.22-35: error: invalid reference: '\$<aa>sym-field' 11986 test.y:23.3-39: symbol not found in production: sym 11987 test.y:24.22-33: error: invalid reference: '\$[sym-field]' 11988 test.y:24.3-37: symbol not found in production: sym-field 11989 test.y:25.22-37: error: invalid reference: '\$<aa>[sym-field]' 11990 test.y:25.3-41: symbol not found in production: sym-field 11991 test.y:26.22-25: error: invalid reference: '\$sym' 11992 test.y:26.3-29: symbol not found in production: sym 11993 test.y:27.22-29: error: invalid reference: '\$<aa>sym' 11994 test.y:27.3-33: symbol not found in production: sym 11995 test.y:28.22-27: error: invalid reference: '\$[sym]' 11996 test.y:28.3-65: symbol not found in production before \$3: sym 11997 test.y:28.52-61: error: invalid reference: '\$<aa>[sym]' 11998 test.y:28.3-65: symbol not found in production: sym 11999 " | \ 12000 $at_diff - "$at_stderr" || at_failed=: 12001 at_fn_diff_devnull "$at_stdout" || at_failed=: 12002 at_fn_check_status 1 $at_status "$at_srcdir/named-refs.at:633" 12003 $at_failed && at_fn_log_failure 12004 $at_traceon; } 12005 12006 12007 set +x 12008 $at_times_p && times >"$at_times_file" 12009 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 12010 read at_status <"$at_status_file" 12011 #AT_STOP_49 12012 #AT_START_50 12013 at_fn_group_banner 50 'named-refs.at:671' \ 12014 "\$ or @ followed by . or -" " " 2 12015 at_xfail=no 12016 ( 12017 $as_echo "50. $at_setup_line: testing $at_desc ..." 12018 $at_traceon 12019 12020 cat >test.y <<'_ATEOF' 12021 12022 %% 12023 start: 12024 .field { $.field; } 12025 | 'a' { @.field; } 12026 ; 12027 .field: ; 12028 _ATEOF 12029 12030 12031 { set +x 12032 $as_echo "$at_srcdir/named-refs.at:681: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison test.y" 12033 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison test.y" "named-refs.at:681" 12034 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison test.y 12035 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12036 at_status=$? at_failed=false 12037 $at_check_filter 12038 echo >>"$at_stderr"; $as_echo "test.y:4.12-18: error: invalid reference: '\$.field' 12039 test.y:4.13: syntax error after '\$', expecting integer, letter, '_', '[', or '\$' 12040 test.y:4.3-8: possibly meant: \$[.field] at \$1 12041 test.y:5.12-18: error: invalid reference: '@.field' 12042 test.y:5.13: syntax error after '@', expecting integer, letter, '_', '[', or '\$' 12043 " | \ 12044 $at_diff - "$at_stderr" || at_failed=: 12045 at_fn_diff_devnull "$at_stdout" || at_failed=: 12046 at_fn_check_status 1 $at_status "$at_srcdir/named-refs.at:681" 12047 $at_failed && at_fn_log_failure 12048 $at_traceon; } 12049 12050 12051 cat >test.y <<'_ATEOF' 12052 12053 %% 12054 start: 12055 'a' { $-field; } 12056 | 'b' { @-field; } 12057 ; 12058 _ATEOF 12059 12060 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 12061 at_save_special_files 12062 mkdir xml-tests 12063 # Don't combine these Bison invocations since we want to be sure that 12064 # --report=all isn't required to get the full XML file. 12065 { set +x 12066 $as_echo "$at_srcdir/named-refs.at:696: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 12067 --graph=xml-tests/test.dot test.y" 12068 at_fn_check_prepare_notrace 'an embedded newline' "named-refs.at:696" 12069 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 12070 --graph=xml-tests/test.dot test.y 12071 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12072 at_status=$? at_failed=false 12073 $at_check_filter 12074 echo stderr:; cat "$at_stderr" 12075 echo stdout:; cat "$at_stdout" 12076 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:696" 12077 $at_failed && at_fn_log_failure 12078 $at_traceon; } 12079 12080 { set +x 12081 $as_echo "$at_srcdir/named-refs.at:696: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml test.y" 12082 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml test.y" "named-refs.at:696" 12083 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml test.y 12084 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12085 at_status=$? at_failed=false 12086 $at_check_filter 12087 echo stderr:; cat "$at_stderr" 12088 echo stdout:; cat "$at_stdout" 12089 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:696" 12090 $at_failed && at_fn_log_failure 12091 $at_traceon; } 12092 12093 cp xml-tests/test.output expout 12094 { set +x 12095 $as_echo "$at_srcdir/named-refs.at:696: \$XSLTPROC \\ 12096 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 12097 xml-tests/test.xml" 12098 at_fn_check_prepare_notrace 'a `...` command substitution' "named-refs.at:696" 12099 ( $at_check_trace; $XSLTPROC \ 12100 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 12101 xml-tests/test.xml 12102 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12103 at_status=$? at_failed=false 12104 $at_check_filter 12105 at_fn_diff_devnull "$at_stderr" || at_failed=: 12106 $at_diff expout "$at_stdout" || at_failed=: 12107 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:696" 12108 $at_failed && at_fn_log_failure 12109 $at_traceon; } 12110 12111 sort xml-tests/test.dot > expout 12112 { set +x 12113 $as_echo "$at_srcdir/named-refs.at:696: \$XSLTPROC \\ 12114 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 12115 xml-tests/test.xml | sort" 12116 at_fn_check_prepare_notrace 'a `...` command substitution' "named-refs.at:696" 12117 ( $at_check_trace; $XSLTPROC \ 12118 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 12119 xml-tests/test.xml | sort 12120 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12121 at_status=$? at_failed=false 12122 $at_check_filter 12123 at_fn_diff_devnull "$at_stderr" || at_failed=: 12124 $at_diff expout "$at_stdout" || at_failed=: 12125 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:696" 12126 $at_failed && at_fn_log_failure 12127 $at_traceon; } 12128 12129 rm -rf xml-tests expout 12130 at_restore_special_files 12131 fi 12132 { set +x 12133 $as_echo "$at_srcdir/named-refs.at:696: bison test.y" 12134 at_fn_check_prepare_trace "named-refs.at:696" 12135 ( $at_check_trace; bison test.y 12136 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12137 at_status=$? at_failed=false 12138 $at_check_filter 12139 echo >>"$at_stderr"; $as_echo "test.y:4.9: warning: stray '\$' 12140 test.y:5.9: warning: stray '@' 12141 " | \ 12142 $at_diff - "$at_stderr" || at_failed=: 12143 at_fn_diff_devnull "$at_stdout" || at_failed=: 12144 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:696" 12145 $at_failed && at_fn_log_failure 12146 $at_traceon; } 12147 12148 # Defining POSIXLY_CORRECT causes bison to complain if options are 12149 # added after the grammar file name, so skip these checks in that 12150 # case. 12151 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 12152 at_save_special_files 12153 12154 # To avoid expanding it repeatedly, store specified stdout. 12155 : >expout 12156 12157 # Run with -Werror. 12158 { set +x 12159 $as_echo "$at_srcdir/named-refs.at:696: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison test.y -Werror" 12160 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison test.y -Werror" "named-refs.at:696" 12161 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison test.y -Werror 12162 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12163 at_status=$? at_failed=false 12164 $at_check_filter 12165 echo stderr:; tee stderr <"$at_stderr" 12166 $at_diff expout "$at_stdout" || at_failed=: 12167 at_fn_check_status 1 $at_status "$at_srcdir/named-refs.at:696" 12168 $at_failed && at_fn_log_failure 12169 $at_traceon; } 12170 12171 12172 # Build expected stderr up to and including the "warnings being 12173 # treated as errors" message. 12174 cat >at-bison-check-warnings <<'_ATEOF' 12175 test.y:4.9: warning: stray '$' 12176 test.y:5.9: warning: stray '@' 12177 _ATEOF 12178 12179 at_bison_check_first=`sed -n \ 12180 '/: warning: /{=;q;}' at-bison-check-warnings` 12181 : ${at_bison_check_first:=1} 12182 at_bison_check_first_tmp=`sed -n \ 12183 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 12184 : ${at_bison_check_first_tmp:=1} 12185 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 12186 at_bison_check_first=$at_bison_check_first_tmp 12187 fi 12188 if test $at_bison_check_first -gt 1; then 12189 sed -n "1,`expr $at_bison_check_first - 1`"p \ 12190 at-bison-check-warnings > experr 12191 fi 12192 echo 'bison: warnings being treated as errors' >> experr 12193 12194 # Finish building expected stderr and check. Unlike warnings, 12195 # complaints cause bison to exit early. Thus, with -Werror, bison 12196 # does not necessarily report all warnings that it does without 12197 # -Werror, but it at least reports one. 12198 at_bison_check_last=`sed -n '$=' stderr` 12199 : ${at_bison_check_last:=1} 12200 at_bison_check_last=`expr $at_bison_check_last - 1` 12201 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 12202 at-bison-check-warnings >> experr 12203 { set +x 12204 $as_echo "$at_srcdir/named-refs.at:696: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 12205 stderr 1>&2" 12206 at_fn_check_prepare_notrace 'an embedded newline' "named-refs.at:696" 12207 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 12208 stderr 1>&2 12209 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12210 at_status=$? at_failed=false 12211 $at_check_filter 12212 $at_diff experr "$at_stderr" || at_failed=: 12213 at_fn_diff_devnull "$at_stdout" || at_failed=: 12214 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:696" 12215 $at_failed && at_fn_log_failure 12216 $at_traceon; } 12217 12218 12219 # Now check --warnings=error. 12220 cp stderr experr 12221 { set +x 12222 $as_echo "$at_srcdir/named-refs.at:696: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison test.y --warnings=error" 12223 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison test.y --warnings=error" "named-refs.at:696" 12224 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison test.y --warnings=error 12225 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12226 at_status=$? at_failed=false 12227 $at_check_filter 12228 $at_diff experr "$at_stderr" || at_failed=: 12229 $at_diff expout "$at_stdout" || at_failed=: 12230 at_fn_check_status 1 $at_status "$at_srcdir/named-refs.at:696" 12231 $at_failed && at_fn_log_failure 12232 $at_traceon; } 12233 12234 12235 # Now check -Wnone and --warnings=none by making sure that 12236 # -Werror doesn't change the exit status when -Wnone or 12237 # --warnings=none is specified. 12238 { set +x 12239 $as_echo "$at_srcdir/named-refs.at:696: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison test.y -Wnone -Werror" 12240 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison test.y -Wnone -Werror" "named-refs.at:696" 12241 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison test.y -Wnone -Werror 12242 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12243 at_status=$? at_failed=false 12244 $at_check_filter 12245 at_fn_diff_devnull "$at_stderr" || at_failed=: 12246 $at_diff expout "$at_stdout" || at_failed=: 12247 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:696" 12248 $at_failed && at_fn_log_failure 12249 $at_traceon; } 12250 12251 { set +x 12252 $as_echo "$at_srcdir/named-refs.at:696: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison test.y --warnings=none -Werror" 12253 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison test.y --warnings=none -Werror" "named-refs.at:696" 12254 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison test.y --warnings=none -Werror 12255 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12256 at_status=$? at_failed=false 12257 $at_check_filter 12258 at_fn_diff_devnull "$at_stderr" || at_failed=: 12259 $at_diff expout "$at_stdout" || at_failed=: 12260 at_fn_check_status 0 $at_status "$at_srcdir/named-refs.at:696" 12261 $at_failed && at_fn_log_failure 12262 $at_traceon; } 12263 12264 12265 at_restore_special_files 12266 fi 12267 set +x 12268 $at_times_p && times >"$at_times_file" 12269 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 12270 read at_status <"$at_status_file" 12271 #AT_STOP_50 12272 #AT_START_51 12273 at_fn_group_banner 51 'output.at:44' \ 12274 "Output files: -dv " " " 3 12275 at_xfail=no 12276 ( 12277 $as_echo "51. $at_setup_line: testing $at_desc ..." 12278 $at_traceon 12279 12280 12281 for file in foo.y foo.output foo.tab.c foo.tab.h; do 12282 case "$file" in 12283 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 12284 esac 12285 done 12286 cat >foo.y <<'_ATEOF' 12287 12288 %% 12289 foo: {}; 12290 _ATEOF 12291 12292 12293 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 12294 at_save_special_files 12295 mkdir xml-tests 12296 # Don't combine these Bison invocations since we want to be sure that 12297 # --report=all isn't required to get the full XML file. 12298 { set +x 12299 $as_echo "$at_srcdir/output.at:44: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 12300 --graph=xml-tests/test.dot -dv foo.y " 12301 at_fn_check_prepare_notrace 'an embedded newline' "output.at:44" 12302 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 12303 --graph=xml-tests/test.dot -dv foo.y 12304 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12305 at_status=$? at_failed=false 12306 $at_check_filter 12307 echo stderr:; cat "$at_stderr" 12308 echo stdout:; cat "$at_stdout" 12309 at_fn_check_status 0 $at_status "$at_srcdir/output.at:44" 12310 $at_failed && at_fn_log_failure 12311 $at_traceon; } 12312 12313 { set +x 12314 $as_echo "$at_srcdir/output.at:44: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -dv foo.y " 12315 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -dv foo.y " "output.at:44" 12316 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -dv foo.y 12317 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12318 at_status=$? at_failed=false 12319 $at_check_filter 12320 echo stderr:; cat "$at_stderr" 12321 echo stdout:; cat "$at_stdout" 12322 at_fn_check_status 0 $at_status "$at_srcdir/output.at:44" 12323 $at_failed && at_fn_log_failure 12324 $at_traceon; } 12325 12326 cp xml-tests/test.output expout 12327 { set +x 12328 $as_echo "$at_srcdir/output.at:44: \$XSLTPROC \\ 12329 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 12330 xml-tests/test.xml" 12331 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:44" 12332 ( $at_check_trace; $XSLTPROC \ 12333 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 12334 xml-tests/test.xml 12335 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12336 at_status=$? at_failed=false 12337 $at_check_filter 12338 at_fn_diff_devnull "$at_stderr" || at_failed=: 12339 $at_diff expout "$at_stdout" || at_failed=: 12340 at_fn_check_status 0 $at_status "$at_srcdir/output.at:44" 12341 $at_failed && at_fn_log_failure 12342 $at_traceon; } 12343 12344 sort xml-tests/test.dot > expout 12345 { set +x 12346 $as_echo "$at_srcdir/output.at:44: \$XSLTPROC \\ 12347 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 12348 xml-tests/test.xml | sort" 12349 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:44" 12350 ( $at_check_trace; $XSLTPROC \ 12351 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 12352 xml-tests/test.xml | sort 12353 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12354 at_status=$? at_failed=false 12355 $at_check_filter 12356 at_fn_diff_devnull "$at_stderr" || at_failed=: 12357 $at_diff expout "$at_stdout" || at_failed=: 12358 at_fn_check_status 0 $at_status "$at_srcdir/output.at:44" 12359 $at_failed && at_fn_log_failure 12360 $at_traceon; } 12361 12362 rm -rf xml-tests expout 12363 at_restore_special_files 12364 fi 12365 { set +x 12366 $as_echo "$at_srcdir/output.at:44: bison -dv foo.y " 12367 at_fn_check_prepare_trace "output.at:44" 12368 ( $at_check_trace; bison -dv foo.y 12369 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12370 at_status=$? at_failed=false 12371 $at_check_filter 12372 at_fn_diff_devnull "$at_stderr" || at_failed=: 12373 at_fn_diff_devnull "$at_stdout" || at_failed=: 12374 at_fn_check_status 0 $at_status "$at_srcdir/output.at:44" 12375 $at_failed && at_fn_log_failure 12376 $at_traceon; } 12377 12378 12379 { set +x 12380 $as_echo "$at_srcdir/output.at:44: ls foo.output foo.tab.c foo.tab.h" 12381 at_fn_check_prepare_trace "output.at:44" 12382 ( $at_check_trace; ls foo.output foo.tab.c foo.tab.h 12383 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12384 at_status=$? at_failed=false 12385 $at_check_filter 12386 at_fn_diff_devnull "$at_stderr" || at_failed=: 12387 echo stdout:; cat "$at_stdout" 12388 at_fn_check_status 0 $at_status "$at_srcdir/output.at:44" 12389 $at_failed && at_fn_log_failure 12390 $at_traceon; } 12391 12392 12393 set +x 12394 $at_times_p && times >"$at_times_file" 12395 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 12396 read at_status <"$at_status_file" 12397 #AT_STOP_51 12398 #AT_START_52 12399 at_fn_group_banner 52 'output.at:50' \ 12400 "Output files: -dv >&-" " " 3 12401 at_xfail=no 12402 ( 12403 $as_echo "52. $at_setup_line: testing $at_desc ..." 12404 $at_traceon 12405 12406 { set +x 12407 $as_echo "$at_srcdir/output.at:50: case \"\$PREBISON\" in *valgrind*) exit 77;; esac" 12408 at_fn_check_prepare_dynamic "case \"$PREBISON\" in *valgrind*) exit 77;; esac" "output.at:50" 12409 ( $at_check_trace; case "$PREBISON" in *valgrind*) exit 77;; esac 12410 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12411 at_status=$? at_failed=false 12412 $at_check_filter 12413 at_fn_diff_devnull "$at_stderr" || at_failed=: 12414 at_fn_diff_devnull "$at_stdout" || at_failed=: 12415 at_fn_check_status 0 $at_status "$at_srcdir/output.at:50" 12416 $at_failed && at_fn_log_failure 12417 $at_traceon; } 12418 12419 for file in foo.y foo.output foo.tab.c foo.tab.h; do 12420 case "$file" in 12421 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 12422 esac 12423 done 12424 cat >foo.y <<'_ATEOF' 12425 12426 %% 12427 foo: {}; 12428 _ATEOF 12429 12430 12431 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 12432 at_save_special_files 12433 mkdir xml-tests 12434 # Don't combine these Bison invocations since we want to be sure that 12435 # --report=all isn't required to get the full XML file. 12436 { set +x 12437 $as_echo "$at_srcdir/output.at:50: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 12438 --graph=xml-tests/test.dot -dv foo.y >&-" 12439 at_fn_check_prepare_notrace 'an embedded newline' "output.at:50" 12440 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 12441 --graph=xml-tests/test.dot -dv foo.y >&- 12442 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12443 at_status=$? at_failed=false 12444 $at_check_filter 12445 echo stderr:; cat "$at_stderr" 12446 echo stdout:; cat "$at_stdout" 12447 at_fn_check_status 0 $at_status "$at_srcdir/output.at:50" 12448 $at_failed && at_fn_log_failure 12449 $at_traceon; } 12450 12451 { set +x 12452 $as_echo "$at_srcdir/output.at:50: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -dv foo.y >&-" 12453 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -dv foo.y >&-" "output.at:50" 12454 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -dv foo.y >&- 12455 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12456 at_status=$? at_failed=false 12457 $at_check_filter 12458 echo stderr:; cat "$at_stderr" 12459 echo stdout:; cat "$at_stdout" 12460 at_fn_check_status 0 $at_status "$at_srcdir/output.at:50" 12461 $at_failed && at_fn_log_failure 12462 $at_traceon; } 12463 12464 cp xml-tests/test.output expout 12465 { set +x 12466 $as_echo "$at_srcdir/output.at:50: \$XSLTPROC \\ 12467 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 12468 xml-tests/test.xml" 12469 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:50" 12470 ( $at_check_trace; $XSLTPROC \ 12471 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 12472 xml-tests/test.xml 12473 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12474 at_status=$? at_failed=false 12475 $at_check_filter 12476 at_fn_diff_devnull "$at_stderr" || at_failed=: 12477 $at_diff expout "$at_stdout" || at_failed=: 12478 at_fn_check_status 0 $at_status "$at_srcdir/output.at:50" 12479 $at_failed && at_fn_log_failure 12480 $at_traceon; } 12481 12482 sort xml-tests/test.dot > expout 12483 { set +x 12484 $as_echo "$at_srcdir/output.at:50: \$XSLTPROC \\ 12485 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 12486 xml-tests/test.xml | sort" 12487 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:50" 12488 ( $at_check_trace; $XSLTPROC \ 12489 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 12490 xml-tests/test.xml | sort 12491 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12492 at_status=$? at_failed=false 12493 $at_check_filter 12494 at_fn_diff_devnull "$at_stderr" || at_failed=: 12495 $at_diff expout "$at_stdout" || at_failed=: 12496 at_fn_check_status 0 $at_status "$at_srcdir/output.at:50" 12497 $at_failed && at_fn_log_failure 12498 $at_traceon; } 12499 12500 rm -rf xml-tests expout 12501 at_restore_special_files 12502 fi 12503 { set +x 12504 $as_echo "$at_srcdir/output.at:50: bison -dv foo.y >&-" 12505 at_fn_check_prepare_trace "output.at:50" 12506 ( $at_check_trace; bison -dv foo.y >&- 12507 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12508 at_status=$? at_failed=false 12509 $at_check_filter 12510 at_fn_diff_devnull "$at_stderr" || at_failed=: 12511 at_fn_diff_devnull "$at_stdout" || at_failed=: 12512 at_fn_check_status 0 $at_status "$at_srcdir/output.at:50" 12513 $at_failed && at_fn_log_failure 12514 $at_traceon; } 12515 12516 12517 { set +x 12518 $as_echo "$at_srcdir/output.at:50: ls foo.output foo.tab.c foo.tab.h" 12519 at_fn_check_prepare_trace "output.at:50" 12520 ( $at_check_trace; ls foo.output foo.tab.c foo.tab.h 12521 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12522 at_status=$? at_failed=false 12523 $at_check_filter 12524 at_fn_diff_devnull "$at_stderr" || at_failed=: 12525 echo stdout:; cat "$at_stdout" 12526 at_fn_check_status 0 $at_status "$at_srcdir/output.at:50" 12527 $at_failed && at_fn_log_failure 12528 $at_traceon; } 12529 12530 12531 set +x 12532 $at_times_p && times >"$at_times_file" 12533 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 12534 read at_status <"$at_status_file" 12535 #AT_STOP_52 12536 #AT_START_53 12537 at_fn_group_banner 53 'output.at:55' \ 12538 "Output files: -dv -o foo.c " " " 3 12539 at_xfail=no 12540 ( 12541 $as_echo "53. $at_setup_line: testing $at_desc ..." 12542 $at_traceon 12543 12544 12545 for file in foo.y foo.c foo.h foo.output; do 12546 case "$file" in 12547 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 12548 esac 12549 done 12550 cat >foo.y <<'_ATEOF' 12551 12552 %% 12553 foo: {}; 12554 _ATEOF 12555 12556 12557 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 12558 at_save_special_files 12559 mkdir xml-tests 12560 # Don't combine these Bison invocations since we want to be sure that 12561 # --report=all isn't required to get the full XML file. 12562 { set +x 12563 $as_echo "$at_srcdir/output.at:55: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 12564 --graph=xml-tests/test.dot -dv -o foo.c foo.y " 12565 at_fn_check_prepare_notrace 'an embedded newline' "output.at:55" 12566 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 12567 --graph=xml-tests/test.dot -dv -o foo.c foo.y 12568 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12569 at_status=$? at_failed=false 12570 $at_check_filter 12571 echo stderr:; cat "$at_stderr" 12572 echo stdout:; cat "$at_stdout" 12573 at_fn_check_status 0 $at_status "$at_srcdir/output.at:55" 12574 $at_failed && at_fn_log_failure 12575 $at_traceon; } 12576 12577 { set +x 12578 $as_echo "$at_srcdir/output.at:55: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -dv -o foo.c foo.y " 12579 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -dv -o foo.c foo.y " "output.at:55" 12580 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -dv -o foo.c foo.y 12581 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12582 at_status=$? at_failed=false 12583 $at_check_filter 12584 echo stderr:; cat "$at_stderr" 12585 echo stdout:; cat "$at_stdout" 12586 at_fn_check_status 0 $at_status "$at_srcdir/output.at:55" 12587 $at_failed && at_fn_log_failure 12588 $at_traceon; } 12589 12590 cp xml-tests/test.output expout 12591 { set +x 12592 $as_echo "$at_srcdir/output.at:55: \$XSLTPROC \\ 12593 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 12594 xml-tests/test.xml" 12595 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:55" 12596 ( $at_check_trace; $XSLTPROC \ 12597 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 12598 xml-tests/test.xml 12599 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12600 at_status=$? at_failed=false 12601 $at_check_filter 12602 at_fn_diff_devnull "$at_stderr" || at_failed=: 12603 $at_diff expout "$at_stdout" || at_failed=: 12604 at_fn_check_status 0 $at_status "$at_srcdir/output.at:55" 12605 $at_failed && at_fn_log_failure 12606 $at_traceon; } 12607 12608 sort xml-tests/test.dot > expout 12609 { set +x 12610 $as_echo "$at_srcdir/output.at:55: \$XSLTPROC \\ 12611 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 12612 xml-tests/test.xml | sort" 12613 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:55" 12614 ( $at_check_trace; $XSLTPROC \ 12615 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 12616 xml-tests/test.xml | sort 12617 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12618 at_status=$? at_failed=false 12619 $at_check_filter 12620 at_fn_diff_devnull "$at_stderr" || at_failed=: 12621 $at_diff expout "$at_stdout" || at_failed=: 12622 at_fn_check_status 0 $at_status "$at_srcdir/output.at:55" 12623 $at_failed && at_fn_log_failure 12624 $at_traceon; } 12625 12626 rm -rf xml-tests expout 12627 at_restore_special_files 12628 fi 12629 { set +x 12630 $as_echo "$at_srcdir/output.at:55: bison -dv -o foo.c foo.y " 12631 at_fn_check_prepare_trace "output.at:55" 12632 ( $at_check_trace; bison -dv -o foo.c foo.y 12633 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12634 at_status=$? at_failed=false 12635 $at_check_filter 12636 at_fn_diff_devnull "$at_stderr" || at_failed=: 12637 at_fn_diff_devnull "$at_stdout" || at_failed=: 12638 at_fn_check_status 0 $at_status "$at_srcdir/output.at:55" 12639 $at_failed && at_fn_log_failure 12640 $at_traceon; } 12641 12642 12643 { set +x 12644 $as_echo "$at_srcdir/output.at:55: ls foo.c foo.h foo.output" 12645 at_fn_check_prepare_trace "output.at:55" 12646 ( $at_check_trace; ls foo.c foo.h foo.output 12647 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12648 at_status=$? at_failed=false 12649 $at_check_filter 12650 at_fn_diff_devnull "$at_stderr" || at_failed=: 12651 echo stdout:; cat "$at_stdout" 12652 at_fn_check_status 0 $at_status "$at_srcdir/output.at:55" 12653 $at_failed && at_fn_log_failure 12654 $at_traceon; } 12655 12656 12657 set +x 12658 $at_times_p && times >"$at_times_file" 12659 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 12660 read at_status <"$at_status_file" 12661 #AT_STOP_53 12662 #AT_START_54 12663 at_fn_group_banner 54 'output.at:57' \ 12664 "Output files: -dv -o foo.tab.c " " " 3 12665 at_xfail=no 12666 ( 12667 $as_echo "54. $at_setup_line: testing $at_desc ..." 12668 $at_traceon 12669 12670 12671 for file in foo.y foo.output foo.tab.c foo.tab.h; do 12672 case "$file" in 12673 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 12674 esac 12675 done 12676 cat >foo.y <<'_ATEOF' 12677 12678 %% 12679 foo: {}; 12680 _ATEOF 12681 12682 12683 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 12684 at_save_special_files 12685 mkdir xml-tests 12686 # Don't combine these Bison invocations since we want to be sure that 12687 # --report=all isn't required to get the full XML file. 12688 { set +x 12689 $as_echo "$at_srcdir/output.at:57: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 12690 --graph=xml-tests/test.dot -dv -o foo.tab.c foo.y " 12691 at_fn_check_prepare_notrace 'an embedded newline' "output.at:57" 12692 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 12693 --graph=xml-tests/test.dot -dv -o foo.tab.c foo.y 12694 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12695 at_status=$? at_failed=false 12696 $at_check_filter 12697 echo stderr:; cat "$at_stderr" 12698 echo stdout:; cat "$at_stdout" 12699 at_fn_check_status 0 $at_status "$at_srcdir/output.at:57" 12700 $at_failed && at_fn_log_failure 12701 $at_traceon; } 12702 12703 { set +x 12704 $as_echo "$at_srcdir/output.at:57: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -dv -o foo.tab.c foo.y " 12705 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -dv -o foo.tab.c foo.y " "output.at:57" 12706 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -dv -o foo.tab.c foo.y 12707 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12708 at_status=$? at_failed=false 12709 $at_check_filter 12710 echo stderr:; cat "$at_stderr" 12711 echo stdout:; cat "$at_stdout" 12712 at_fn_check_status 0 $at_status "$at_srcdir/output.at:57" 12713 $at_failed && at_fn_log_failure 12714 $at_traceon; } 12715 12716 cp xml-tests/test.output expout 12717 { set +x 12718 $as_echo "$at_srcdir/output.at:57: \$XSLTPROC \\ 12719 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 12720 xml-tests/test.xml" 12721 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:57" 12722 ( $at_check_trace; $XSLTPROC \ 12723 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 12724 xml-tests/test.xml 12725 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12726 at_status=$? at_failed=false 12727 $at_check_filter 12728 at_fn_diff_devnull "$at_stderr" || at_failed=: 12729 $at_diff expout "$at_stdout" || at_failed=: 12730 at_fn_check_status 0 $at_status "$at_srcdir/output.at:57" 12731 $at_failed && at_fn_log_failure 12732 $at_traceon; } 12733 12734 sort xml-tests/test.dot > expout 12735 { set +x 12736 $as_echo "$at_srcdir/output.at:57: \$XSLTPROC \\ 12737 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 12738 xml-tests/test.xml | sort" 12739 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:57" 12740 ( $at_check_trace; $XSLTPROC \ 12741 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 12742 xml-tests/test.xml | sort 12743 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12744 at_status=$? at_failed=false 12745 $at_check_filter 12746 at_fn_diff_devnull "$at_stderr" || at_failed=: 12747 $at_diff expout "$at_stdout" || at_failed=: 12748 at_fn_check_status 0 $at_status "$at_srcdir/output.at:57" 12749 $at_failed && at_fn_log_failure 12750 $at_traceon; } 12751 12752 rm -rf xml-tests expout 12753 at_restore_special_files 12754 fi 12755 { set +x 12756 $as_echo "$at_srcdir/output.at:57: bison -dv -o foo.tab.c foo.y " 12757 at_fn_check_prepare_trace "output.at:57" 12758 ( $at_check_trace; bison -dv -o foo.tab.c foo.y 12759 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12760 at_status=$? at_failed=false 12761 $at_check_filter 12762 at_fn_diff_devnull "$at_stderr" || at_failed=: 12763 at_fn_diff_devnull "$at_stdout" || at_failed=: 12764 at_fn_check_status 0 $at_status "$at_srcdir/output.at:57" 12765 $at_failed && at_fn_log_failure 12766 $at_traceon; } 12767 12768 12769 { set +x 12770 $as_echo "$at_srcdir/output.at:57: ls foo.output foo.tab.c foo.tab.h" 12771 at_fn_check_prepare_trace "output.at:57" 12772 ( $at_check_trace; ls foo.output foo.tab.c foo.tab.h 12773 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12774 at_status=$? at_failed=false 12775 $at_check_filter 12776 at_fn_diff_devnull "$at_stderr" || at_failed=: 12777 echo stdout:; cat "$at_stdout" 12778 at_fn_check_status 0 $at_status "$at_srcdir/output.at:57" 12779 $at_failed && at_fn_log_failure 12780 $at_traceon; } 12781 12782 12783 set +x 12784 $at_times_p && times >"$at_times_file" 12785 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 12786 read at_status <"$at_status_file" 12787 #AT_STOP_54 12788 #AT_START_55 12789 at_fn_group_banner 55 'output.at:59' \ 12790 "Output files: -dv -y " " " 3 12791 at_xfail=no 12792 ( 12793 $as_echo "55. $at_setup_line: testing $at_desc ..." 12794 $at_traceon 12795 12796 12797 for file in foo.y y.output y.tab.c y.tab.h; do 12798 case "$file" in 12799 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 12800 esac 12801 done 12802 cat >foo.y <<'_ATEOF' 12803 12804 %% 12805 foo: {}; 12806 _ATEOF 12807 12808 12809 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 12810 at_save_special_files 12811 mkdir xml-tests 12812 # Don't combine these Bison invocations since we want to be sure that 12813 # --report=all isn't required to get the full XML file. 12814 { set +x 12815 $as_echo "$at_srcdir/output.at:59: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 12816 --graph=xml-tests/test.dot -dv -y foo.y " 12817 at_fn_check_prepare_notrace 'an embedded newline' "output.at:59" 12818 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 12819 --graph=xml-tests/test.dot -dv -y foo.y 12820 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12821 at_status=$? at_failed=false 12822 $at_check_filter 12823 echo stderr:; cat "$at_stderr" 12824 echo stdout:; cat "$at_stdout" 12825 at_fn_check_status 0 $at_status "$at_srcdir/output.at:59" 12826 $at_failed && at_fn_log_failure 12827 $at_traceon; } 12828 12829 { set +x 12830 $as_echo "$at_srcdir/output.at:59: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -dv -y foo.y " 12831 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -dv -y foo.y " "output.at:59" 12832 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -dv -y foo.y 12833 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12834 at_status=$? at_failed=false 12835 $at_check_filter 12836 echo stderr:; cat "$at_stderr" 12837 echo stdout:; cat "$at_stdout" 12838 at_fn_check_status 0 $at_status "$at_srcdir/output.at:59" 12839 $at_failed && at_fn_log_failure 12840 $at_traceon; } 12841 12842 cp xml-tests/test.output expout 12843 { set +x 12844 $as_echo "$at_srcdir/output.at:59: \$XSLTPROC \\ 12845 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 12846 xml-tests/test.xml" 12847 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:59" 12848 ( $at_check_trace; $XSLTPROC \ 12849 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 12850 xml-tests/test.xml 12851 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12852 at_status=$? at_failed=false 12853 $at_check_filter 12854 at_fn_diff_devnull "$at_stderr" || at_failed=: 12855 $at_diff expout "$at_stdout" || at_failed=: 12856 at_fn_check_status 0 $at_status "$at_srcdir/output.at:59" 12857 $at_failed && at_fn_log_failure 12858 $at_traceon; } 12859 12860 sort xml-tests/test.dot > expout 12861 { set +x 12862 $as_echo "$at_srcdir/output.at:59: \$XSLTPROC \\ 12863 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 12864 xml-tests/test.xml | sort" 12865 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:59" 12866 ( $at_check_trace; $XSLTPROC \ 12867 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 12868 xml-tests/test.xml | sort 12869 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12870 at_status=$? at_failed=false 12871 $at_check_filter 12872 at_fn_diff_devnull "$at_stderr" || at_failed=: 12873 $at_diff expout "$at_stdout" || at_failed=: 12874 at_fn_check_status 0 $at_status "$at_srcdir/output.at:59" 12875 $at_failed && at_fn_log_failure 12876 $at_traceon; } 12877 12878 rm -rf xml-tests expout 12879 at_restore_special_files 12880 fi 12881 { set +x 12882 $as_echo "$at_srcdir/output.at:59: bison -dv -y foo.y " 12883 at_fn_check_prepare_trace "output.at:59" 12884 ( $at_check_trace; bison -dv -y foo.y 12885 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12886 at_status=$? at_failed=false 12887 $at_check_filter 12888 at_fn_diff_devnull "$at_stderr" || at_failed=: 12889 at_fn_diff_devnull "$at_stdout" || at_failed=: 12890 at_fn_check_status 0 $at_status "$at_srcdir/output.at:59" 12891 $at_failed && at_fn_log_failure 12892 $at_traceon; } 12893 12894 12895 { set +x 12896 $as_echo "$at_srcdir/output.at:59: ls y.output y.tab.c y.tab.h" 12897 at_fn_check_prepare_trace "output.at:59" 12898 ( $at_check_trace; ls y.output y.tab.c y.tab.h 12899 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12900 at_status=$? at_failed=false 12901 $at_check_filter 12902 at_fn_diff_devnull "$at_stderr" || at_failed=: 12903 echo stdout:; cat "$at_stdout" 12904 at_fn_check_status 0 $at_status "$at_srcdir/output.at:59" 12905 $at_failed && at_fn_log_failure 12906 $at_traceon; } 12907 12908 12909 set +x 12910 $at_times_p && times >"$at_times_file" 12911 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 12912 read at_status <"$at_status_file" 12913 #AT_STOP_55 12914 #AT_START_56 12915 at_fn_group_banner 56 'output.at:61' \ 12916 "Output files: -dv -b bar " " " 3 12917 at_xfail=no 12918 ( 12919 $as_echo "56. $at_setup_line: testing $at_desc ..." 12920 $at_traceon 12921 12922 12923 for file in foo.y bar.output bar.tab.c bar.tab.h; do 12924 case "$file" in 12925 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 12926 esac 12927 done 12928 cat >foo.y <<'_ATEOF' 12929 12930 %% 12931 foo: {}; 12932 _ATEOF 12933 12934 12935 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 12936 at_save_special_files 12937 mkdir xml-tests 12938 # Don't combine these Bison invocations since we want to be sure that 12939 # --report=all isn't required to get the full XML file. 12940 { set +x 12941 $as_echo "$at_srcdir/output.at:61: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 12942 --graph=xml-tests/test.dot -dv -b bar foo.y " 12943 at_fn_check_prepare_notrace 'an embedded newline' "output.at:61" 12944 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 12945 --graph=xml-tests/test.dot -dv -b bar foo.y 12946 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12947 at_status=$? at_failed=false 12948 $at_check_filter 12949 echo stderr:; cat "$at_stderr" 12950 echo stdout:; cat "$at_stdout" 12951 at_fn_check_status 0 $at_status "$at_srcdir/output.at:61" 12952 $at_failed && at_fn_log_failure 12953 $at_traceon; } 12954 12955 { set +x 12956 $as_echo "$at_srcdir/output.at:61: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -dv -b bar foo.y " 12957 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -dv -b bar foo.y " "output.at:61" 12958 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -dv -b bar foo.y 12959 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12960 at_status=$? at_failed=false 12961 $at_check_filter 12962 echo stderr:; cat "$at_stderr" 12963 echo stdout:; cat "$at_stdout" 12964 at_fn_check_status 0 $at_status "$at_srcdir/output.at:61" 12965 $at_failed && at_fn_log_failure 12966 $at_traceon; } 12967 12968 cp xml-tests/test.output expout 12969 { set +x 12970 $as_echo "$at_srcdir/output.at:61: \$XSLTPROC \\ 12971 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 12972 xml-tests/test.xml" 12973 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:61" 12974 ( $at_check_trace; $XSLTPROC \ 12975 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 12976 xml-tests/test.xml 12977 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12978 at_status=$? at_failed=false 12979 $at_check_filter 12980 at_fn_diff_devnull "$at_stderr" || at_failed=: 12981 $at_diff expout "$at_stdout" || at_failed=: 12982 at_fn_check_status 0 $at_status "$at_srcdir/output.at:61" 12983 $at_failed && at_fn_log_failure 12984 $at_traceon; } 12985 12986 sort xml-tests/test.dot > expout 12987 { set +x 12988 $as_echo "$at_srcdir/output.at:61: \$XSLTPROC \\ 12989 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 12990 xml-tests/test.xml | sort" 12991 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:61" 12992 ( $at_check_trace; $XSLTPROC \ 12993 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 12994 xml-tests/test.xml | sort 12995 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 12996 at_status=$? at_failed=false 12997 $at_check_filter 12998 at_fn_diff_devnull "$at_stderr" || at_failed=: 12999 $at_diff expout "$at_stdout" || at_failed=: 13000 at_fn_check_status 0 $at_status "$at_srcdir/output.at:61" 13001 $at_failed && at_fn_log_failure 13002 $at_traceon; } 13003 13004 rm -rf xml-tests expout 13005 at_restore_special_files 13006 fi 13007 { set +x 13008 $as_echo "$at_srcdir/output.at:61: bison -dv -b bar foo.y " 13009 at_fn_check_prepare_trace "output.at:61" 13010 ( $at_check_trace; bison -dv -b bar foo.y 13011 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13012 at_status=$? at_failed=false 13013 $at_check_filter 13014 at_fn_diff_devnull "$at_stderr" || at_failed=: 13015 at_fn_diff_devnull "$at_stdout" || at_failed=: 13016 at_fn_check_status 0 $at_status "$at_srcdir/output.at:61" 13017 $at_failed && at_fn_log_failure 13018 $at_traceon; } 13019 13020 13021 { set +x 13022 $as_echo "$at_srcdir/output.at:61: ls bar.output bar.tab.c bar.tab.h" 13023 at_fn_check_prepare_trace "output.at:61" 13024 ( $at_check_trace; ls bar.output bar.tab.c bar.tab.h 13025 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13026 at_status=$? at_failed=false 13027 $at_check_filter 13028 at_fn_diff_devnull "$at_stderr" || at_failed=: 13029 echo stdout:; cat "$at_stdout" 13030 at_fn_check_status 0 $at_status "$at_srcdir/output.at:61" 13031 $at_failed && at_fn_log_failure 13032 $at_traceon; } 13033 13034 13035 set +x 13036 $at_times_p && times >"$at_times_file" 13037 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 13038 read at_status <"$at_status_file" 13039 #AT_STOP_56 13040 #AT_START_57 13041 at_fn_group_banner 57 'output.at:63' \ 13042 "Output files: -dv -g -o foo.c " " " 3 13043 at_xfail=no 13044 ( 13045 $as_echo "57. $at_setup_line: testing $at_desc ..." 13046 $at_traceon 13047 13048 13049 for file in foo.y foo.c foo.dot foo.h foo.output; do 13050 case "$file" in 13051 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 13052 esac 13053 done 13054 cat >foo.y <<'_ATEOF' 13055 13056 %% 13057 foo: {}; 13058 _ATEOF 13059 13060 13061 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 13062 at_save_special_files 13063 mkdir xml-tests 13064 # Don't combine these Bison invocations since we want to be sure that 13065 # --report=all isn't required to get the full XML file. 13066 { set +x 13067 $as_echo "$at_srcdir/output.at:63: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 13068 --graph=xml-tests/test.dot -dv -g -o foo.c foo.y " 13069 at_fn_check_prepare_notrace 'an embedded newline' "output.at:63" 13070 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 13071 --graph=xml-tests/test.dot -dv -g -o foo.c foo.y 13072 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13073 at_status=$? at_failed=false 13074 $at_check_filter 13075 echo stderr:; cat "$at_stderr" 13076 echo stdout:; cat "$at_stdout" 13077 at_fn_check_status 0 $at_status "$at_srcdir/output.at:63" 13078 $at_failed && at_fn_log_failure 13079 $at_traceon; } 13080 13081 { set +x 13082 $as_echo "$at_srcdir/output.at:63: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -dv -g -o foo.c foo.y " 13083 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -dv -g -o foo.c foo.y " "output.at:63" 13084 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -dv -g -o foo.c foo.y 13085 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13086 at_status=$? at_failed=false 13087 $at_check_filter 13088 echo stderr:; cat "$at_stderr" 13089 echo stdout:; cat "$at_stdout" 13090 at_fn_check_status 0 $at_status "$at_srcdir/output.at:63" 13091 $at_failed && at_fn_log_failure 13092 $at_traceon; } 13093 13094 cp xml-tests/test.output expout 13095 { set +x 13096 $as_echo "$at_srcdir/output.at:63: \$XSLTPROC \\ 13097 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 13098 xml-tests/test.xml" 13099 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:63" 13100 ( $at_check_trace; $XSLTPROC \ 13101 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 13102 xml-tests/test.xml 13103 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13104 at_status=$? at_failed=false 13105 $at_check_filter 13106 at_fn_diff_devnull "$at_stderr" || at_failed=: 13107 $at_diff expout "$at_stdout" || at_failed=: 13108 at_fn_check_status 0 $at_status "$at_srcdir/output.at:63" 13109 $at_failed && at_fn_log_failure 13110 $at_traceon; } 13111 13112 sort xml-tests/test.dot > expout 13113 { set +x 13114 $as_echo "$at_srcdir/output.at:63: \$XSLTPROC \\ 13115 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 13116 xml-tests/test.xml | sort" 13117 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:63" 13118 ( $at_check_trace; $XSLTPROC \ 13119 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 13120 xml-tests/test.xml | sort 13121 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13122 at_status=$? at_failed=false 13123 $at_check_filter 13124 at_fn_diff_devnull "$at_stderr" || at_failed=: 13125 $at_diff expout "$at_stdout" || at_failed=: 13126 at_fn_check_status 0 $at_status "$at_srcdir/output.at:63" 13127 $at_failed && at_fn_log_failure 13128 $at_traceon; } 13129 13130 rm -rf xml-tests expout 13131 at_restore_special_files 13132 fi 13133 { set +x 13134 $as_echo "$at_srcdir/output.at:63: bison -dv -g -o foo.c foo.y " 13135 at_fn_check_prepare_trace "output.at:63" 13136 ( $at_check_trace; bison -dv -g -o foo.c foo.y 13137 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13138 at_status=$? at_failed=false 13139 $at_check_filter 13140 at_fn_diff_devnull "$at_stderr" || at_failed=: 13141 at_fn_diff_devnull "$at_stdout" || at_failed=: 13142 at_fn_check_status 0 $at_status "$at_srcdir/output.at:63" 13143 $at_failed && at_fn_log_failure 13144 $at_traceon; } 13145 13146 13147 { set +x 13148 $as_echo "$at_srcdir/output.at:63: ls foo.c foo.dot foo.h foo.output" 13149 at_fn_check_prepare_trace "output.at:63" 13150 ( $at_check_trace; ls foo.c foo.dot foo.h foo.output 13151 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13152 at_status=$? at_failed=false 13153 $at_check_filter 13154 at_fn_diff_devnull "$at_stderr" || at_failed=: 13155 echo stdout:; cat "$at_stdout" 13156 at_fn_check_status 0 $at_status "$at_srcdir/output.at:63" 13157 $at_failed && at_fn_log_failure 13158 $at_traceon; } 13159 13160 13161 set +x 13162 $at_times_p && times >"$at_times_file" 13163 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 13164 read at_status <"$at_status_file" 13165 #AT_STOP_57 13166 #AT_START_58 13167 at_fn_group_banner 58 'output.at:67' \ 13168 "Output files: %defines %verbose " " " 3 13169 at_xfail=no 13170 ( 13171 $as_echo "58. $at_setup_line: testing $at_desc ..." 13172 $at_traceon 13173 13174 13175 for file in foo.y foo.output foo.tab.c foo.tab.h; do 13176 case "$file" in 13177 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 13178 esac 13179 done 13180 cat >foo.y <<'_ATEOF' 13181 %defines %verbose 13182 %% 13183 foo: {}; 13184 _ATEOF 13185 13186 13187 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 13188 at_save_special_files 13189 mkdir xml-tests 13190 # Don't combine these Bison invocations since we want to be sure that 13191 # --report=all isn't required to get the full XML file. 13192 { set +x 13193 $as_echo "$at_srcdir/output.at:67: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 13194 --graph=xml-tests/test.dot foo.y " 13195 at_fn_check_prepare_notrace 'an embedded newline' "output.at:67" 13196 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 13197 --graph=xml-tests/test.dot foo.y 13198 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13199 at_status=$? at_failed=false 13200 $at_check_filter 13201 echo stderr:; cat "$at_stderr" 13202 echo stdout:; cat "$at_stdout" 13203 at_fn_check_status 0 $at_status "$at_srcdir/output.at:67" 13204 $at_failed && at_fn_log_failure 13205 $at_traceon; } 13206 13207 { set +x 13208 $as_echo "$at_srcdir/output.at:67: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.y " 13209 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.y " "output.at:67" 13210 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.y 13211 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13212 at_status=$? at_failed=false 13213 $at_check_filter 13214 echo stderr:; cat "$at_stderr" 13215 echo stdout:; cat "$at_stdout" 13216 at_fn_check_status 0 $at_status "$at_srcdir/output.at:67" 13217 $at_failed && at_fn_log_failure 13218 $at_traceon; } 13219 13220 cp xml-tests/test.output expout 13221 { set +x 13222 $as_echo "$at_srcdir/output.at:67: \$XSLTPROC \\ 13223 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 13224 xml-tests/test.xml" 13225 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:67" 13226 ( $at_check_trace; $XSLTPROC \ 13227 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 13228 xml-tests/test.xml 13229 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13230 at_status=$? at_failed=false 13231 $at_check_filter 13232 at_fn_diff_devnull "$at_stderr" || at_failed=: 13233 $at_diff expout "$at_stdout" || at_failed=: 13234 at_fn_check_status 0 $at_status "$at_srcdir/output.at:67" 13235 $at_failed && at_fn_log_failure 13236 $at_traceon; } 13237 13238 sort xml-tests/test.dot > expout 13239 { set +x 13240 $as_echo "$at_srcdir/output.at:67: \$XSLTPROC \\ 13241 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 13242 xml-tests/test.xml | sort" 13243 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:67" 13244 ( $at_check_trace; $XSLTPROC \ 13245 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 13246 xml-tests/test.xml | sort 13247 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13248 at_status=$? at_failed=false 13249 $at_check_filter 13250 at_fn_diff_devnull "$at_stderr" || at_failed=: 13251 $at_diff expout "$at_stdout" || at_failed=: 13252 at_fn_check_status 0 $at_status "$at_srcdir/output.at:67" 13253 $at_failed && at_fn_log_failure 13254 $at_traceon; } 13255 13256 rm -rf xml-tests expout 13257 at_restore_special_files 13258 fi 13259 { set +x 13260 $as_echo "$at_srcdir/output.at:67: bison foo.y " 13261 at_fn_check_prepare_trace "output.at:67" 13262 ( $at_check_trace; bison foo.y 13263 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13264 at_status=$? at_failed=false 13265 $at_check_filter 13266 at_fn_diff_devnull "$at_stderr" || at_failed=: 13267 at_fn_diff_devnull "$at_stdout" || at_failed=: 13268 at_fn_check_status 0 $at_status "$at_srcdir/output.at:67" 13269 $at_failed && at_fn_log_failure 13270 $at_traceon; } 13271 13272 13273 { set +x 13274 $as_echo "$at_srcdir/output.at:67: ls foo.output foo.tab.c foo.tab.h" 13275 at_fn_check_prepare_trace "output.at:67" 13276 ( $at_check_trace; ls foo.output foo.tab.c foo.tab.h 13277 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13278 at_status=$? at_failed=false 13279 $at_check_filter 13280 at_fn_diff_devnull "$at_stderr" || at_failed=: 13281 echo stdout:; cat "$at_stdout" 13282 at_fn_check_status 0 $at_status "$at_srcdir/output.at:67" 13283 $at_failed && at_fn_log_failure 13284 $at_traceon; } 13285 13286 13287 set +x 13288 $at_times_p && times >"$at_times_file" 13289 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 13290 read at_status <"$at_status_file" 13291 #AT_STOP_58 13292 #AT_START_59 13293 at_fn_group_banner 59 'output.at:69' \ 13294 "Output files: %defines %verbose %yacc " " " 3 13295 at_xfail=no 13296 ( 13297 $as_echo "59. $at_setup_line: testing $at_desc ..." 13298 $at_traceon 13299 13300 13301 for file in foo.y y.output y.tab.c y.tab.h; do 13302 case "$file" in 13303 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 13304 esac 13305 done 13306 cat >foo.y <<'_ATEOF' 13307 %defines %verbose %yacc 13308 %% 13309 foo: {}; 13310 _ATEOF 13311 13312 13313 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 13314 at_save_special_files 13315 mkdir xml-tests 13316 # Don't combine these Bison invocations since we want to be sure that 13317 # --report=all isn't required to get the full XML file. 13318 { set +x 13319 $as_echo "$at_srcdir/output.at:69: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 13320 --graph=xml-tests/test.dot foo.y " 13321 at_fn_check_prepare_notrace 'an embedded newline' "output.at:69" 13322 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 13323 --graph=xml-tests/test.dot foo.y 13324 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13325 at_status=$? at_failed=false 13326 $at_check_filter 13327 echo stderr:; cat "$at_stderr" 13328 echo stdout:; cat "$at_stdout" 13329 at_fn_check_status 0 $at_status "$at_srcdir/output.at:69" 13330 $at_failed && at_fn_log_failure 13331 $at_traceon; } 13332 13333 { set +x 13334 $as_echo "$at_srcdir/output.at:69: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.y " 13335 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.y " "output.at:69" 13336 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.y 13337 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13338 at_status=$? at_failed=false 13339 $at_check_filter 13340 echo stderr:; cat "$at_stderr" 13341 echo stdout:; cat "$at_stdout" 13342 at_fn_check_status 0 $at_status "$at_srcdir/output.at:69" 13343 $at_failed && at_fn_log_failure 13344 $at_traceon; } 13345 13346 cp xml-tests/test.output expout 13347 { set +x 13348 $as_echo "$at_srcdir/output.at:69: \$XSLTPROC \\ 13349 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 13350 xml-tests/test.xml" 13351 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:69" 13352 ( $at_check_trace; $XSLTPROC \ 13353 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 13354 xml-tests/test.xml 13355 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13356 at_status=$? at_failed=false 13357 $at_check_filter 13358 at_fn_diff_devnull "$at_stderr" || at_failed=: 13359 $at_diff expout "$at_stdout" || at_failed=: 13360 at_fn_check_status 0 $at_status "$at_srcdir/output.at:69" 13361 $at_failed && at_fn_log_failure 13362 $at_traceon; } 13363 13364 sort xml-tests/test.dot > expout 13365 { set +x 13366 $as_echo "$at_srcdir/output.at:69: \$XSLTPROC \\ 13367 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 13368 xml-tests/test.xml | sort" 13369 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:69" 13370 ( $at_check_trace; $XSLTPROC \ 13371 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 13372 xml-tests/test.xml | sort 13373 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13374 at_status=$? at_failed=false 13375 $at_check_filter 13376 at_fn_diff_devnull "$at_stderr" || at_failed=: 13377 $at_diff expout "$at_stdout" || at_failed=: 13378 at_fn_check_status 0 $at_status "$at_srcdir/output.at:69" 13379 $at_failed && at_fn_log_failure 13380 $at_traceon; } 13381 13382 rm -rf xml-tests expout 13383 at_restore_special_files 13384 fi 13385 { set +x 13386 $as_echo "$at_srcdir/output.at:69: bison foo.y " 13387 at_fn_check_prepare_trace "output.at:69" 13388 ( $at_check_trace; bison foo.y 13389 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13390 at_status=$? at_failed=false 13391 $at_check_filter 13392 at_fn_diff_devnull "$at_stderr" || at_failed=: 13393 at_fn_diff_devnull "$at_stdout" || at_failed=: 13394 at_fn_check_status 0 $at_status "$at_srcdir/output.at:69" 13395 $at_failed && at_fn_log_failure 13396 $at_traceon; } 13397 13398 13399 { set +x 13400 $as_echo "$at_srcdir/output.at:69: ls y.output y.tab.c y.tab.h" 13401 at_fn_check_prepare_trace "output.at:69" 13402 ( $at_check_trace; ls y.output y.tab.c y.tab.h 13403 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13404 at_status=$? at_failed=false 13405 $at_check_filter 13406 at_fn_diff_devnull "$at_stderr" || at_failed=: 13407 echo stdout:; cat "$at_stdout" 13408 at_fn_check_status 0 $at_status "$at_srcdir/output.at:69" 13409 $at_failed && at_fn_log_failure 13410 $at_traceon; } 13411 13412 13413 set +x 13414 $at_times_p && times >"$at_times_file" 13415 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 13416 read at_status <"$at_status_file" 13417 #AT_STOP_59 13418 #AT_START_60 13419 at_fn_group_banner 60 'output.at:72' \ 13420 "Output files: %defines %verbose %yacc " " " 3 13421 at_xfail=no 13422 ( 13423 $as_echo "60. $at_setup_line: testing $at_desc ..." 13424 $at_traceon 13425 13426 13427 for file in foo.yy y.output y.tab.c y.tab.h; do 13428 case "$file" in 13429 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 13430 esac 13431 done 13432 cat >foo.yy <<'_ATEOF' 13433 %defines %verbose %yacc 13434 %% 13435 foo: {}; 13436 _ATEOF 13437 13438 13439 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 13440 at_save_special_files 13441 mkdir xml-tests 13442 # Don't combine these Bison invocations since we want to be sure that 13443 # --report=all isn't required to get the full XML file. 13444 { set +x 13445 $as_echo "$at_srcdir/output.at:72: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 13446 --graph=xml-tests/test.dot foo.yy " 13447 at_fn_check_prepare_notrace 'an embedded newline' "output.at:72" 13448 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 13449 --graph=xml-tests/test.dot foo.yy 13450 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13451 at_status=$? at_failed=false 13452 $at_check_filter 13453 echo stderr:; cat "$at_stderr" 13454 echo stdout:; cat "$at_stdout" 13455 at_fn_check_status 0 $at_status "$at_srcdir/output.at:72" 13456 $at_failed && at_fn_log_failure 13457 $at_traceon; } 13458 13459 { set +x 13460 $as_echo "$at_srcdir/output.at:72: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.yy " 13461 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.yy " "output.at:72" 13462 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.yy 13463 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13464 at_status=$? at_failed=false 13465 $at_check_filter 13466 echo stderr:; cat "$at_stderr" 13467 echo stdout:; cat "$at_stdout" 13468 at_fn_check_status 0 $at_status "$at_srcdir/output.at:72" 13469 $at_failed && at_fn_log_failure 13470 $at_traceon; } 13471 13472 cp xml-tests/test.output expout 13473 { set +x 13474 $as_echo "$at_srcdir/output.at:72: \$XSLTPROC \\ 13475 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 13476 xml-tests/test.xml" 13477 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:72" 13478 ( $at_check_trace; $XSLTPROC \ 13479 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 13480 xml-tests/test.xml 13481 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13482 at_status=$? at_failed=false 13483 $at_check_filter 13484 at_fn_diff_devnull "$at_stderr" || at_failed=: 13485 $at_diff expout "$at_stdout" || at_failed=: 13486 at_fn_check_status 0 $at_status "$at_srcdir/output.at:72" 13487 $at_failed && at_fn_log_failure 13488 $at_traceon; } 13489 13490 sort xml-tests/test.dot > expout 13491 { set +x 13492 $as_echo "$at_srcdir/output.at:72: \$XSLTPROC \\ 13493 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 13494 xml-tests/test.xml | sort" 13495 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:72" 13496 ( $at_check_trace; $XSLTPROC \ 13497 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 13498 xml-tests/test.xml | sort 13499 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13500 at_status=$? at_failed=false 13501 $at_check_filter 13502 at_fn_diff_devnull "$at_stderr" || at_failed=: 13503 $at_diff expout "$at_stdout" || at_failed=: 13504 at_fn_check_status 0 $at_status "$at_srcdir/output.at:72" 13505 $at_failed && at_fn_log_failure 13506 $at_traceon; } 13507 13508 rm -rf xml-tests expout 13509 at_restore_special_files 13510 fi 13511 { set +x 13512 $as_echo "$at_srcdir/output.at:72: bison foo.yy " 13513 at_fn_check_prepare_trace "output.at:72" 13514 ( $at_check_trace; bison foo.yy 13515 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13516 at_status=$? at_failed=false 13517 $at_check_filter 13518 at_fn_diff_devnull "$at_stderr" || at_failed=: 13519 at_fn_diff_devnull "$at_stdout" || at_failed=: 13520 at_fn_check_status 0 $at_status "$at_srcdir/output.at:72" 13521 $at_failed && at_fn_log_failure 13522 $at_traceon; } 13523 13524 13525 { set +x 13526 $as_echo "$at_srcdir/output.at:72: ls y.output y.tab.c y.tab.h" 13527 at_fn_check_prepare_trace "output.at:72" 13528 ( $at_check_trace; ls y.output y.tab.c y.tab.h 13529 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13530 at_status=$? at_failed=false 13531 $at_check_filter 13532 at_fn_diff_devnull "$at_stderr" || at_failed=: 13533 echo stdout:; cat "$at_stdout" 13534 at_fn_check_status 0 $at_status "$at_srcdir/output.at:72" 13535 $at_failed && at_fn_log_failure 13536 $at_traceon; } 13537 13538 13539 set +x 13540 $at_times_p && times >"$at_times_file" 13541 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 13542 read at_status <"$at_status_file" 13543 #AT_STOP_60 13544 #AT_START_61 13545 at_fn_group_banner 61 'output.at:76' \ 13546 "Output files: %file-prefix \"bar\" %defines %verbose " "" 3 13547 at_xfail=no 13548 ( 13549 $as_echo "61. $at_setup_line: testing $at_desc ..." 13550 $at_traceon 13551 13552 13553 for file in foo.y bar.output bar.tab.c bar.tab.h; do 13554 case "$file" in 13555 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 13556 esac 13557 done 13558 cat >foo.y <<'_ATEOF' 13559 %file-prefix "bar" %defines %verbose 13560 %% 13561 foo: {}; 13562 _ATEOF 13563 13564 13565 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 13566 at_save_special_files 13567 mkdir xml-tests 13568 # Don't combine these Bison invocations since we want to be sure that 13569 # --report=all isn't required to get the full XML file. 13570 { set +x 13571 $as_echo "$at_srcdir/output.at:76: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 13572 --graph=xml-tests/test.dot foo.y " 13573 at_fn_check_prepare_notrace 'an embedded newline' "output.at:76" 13574 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 13575 --graph=xml-tests/test.dot foo.y 13576 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13577 at_status=$? at_failed=false 13578 $at_check_filter 13579 echo stderr:; cat "$at_stderr" 13580 echo stdout:; cat "$at_stdout" 13581 at_fn_check_status 0 $at_status "$at_srcdir/output.at:76" 13582 $at_failed && at_fn_log_failure 13583 $at_traceon; } 13584 13585 { set +x 13586 $as_echo "$at_srcdir/output.at:76: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.y " 13587 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.y " "output.at:76" 13588 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.y 13589 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13590 at_status=$? at_failed=false 13591 $at_check_filter 13592 echo stderr:; cat "$at_stderr" 13593 echo stdout:; cat "$at_stdout" 13594 at_fn_check_status 0 $at_status "$at_srcdir/output.at:76" 13595 $at_failed && at_fn_log_failure 13596 $at_traceon; } 13597 13598 cp xml-tests/test.output expout 13599 { set +x 13600 $as_echo "$at_srcdir/output.at:76: \$XSLTPROC \\ 13601 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 13602 xml-tests/test.xml" 13603 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:76" 13604 ( $at_check_trace; $XSLTPROC \ 13605 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 13606 xml-tests/test.xml 13607 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13608 at_status=$? at_failed=false 13609 $at_check_filter 13610 at_fn_diff_devnull "$at_stderr" || at_failed=: 13611 $at_diff expout "$at_stdout" || at_failed=: 13612 at_fn_check_status 0 $at_status "$at_srcdir/output.at:76" 13613 $at_failed && at_fn_log_failure 13614 $at_traceon; } 13615 13616 sort xml-tests/test.dot > expout 13617 { set +x 13618 $as_echo "$at_srcdir/output.at:76: \$XSLTPROC \\ 13619 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 13620 xml-tests/test.xml | sort" 13621 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:76" 13622 ( $at_check_trace; $XSLTPROC \ 13623 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 13624 xml-tests/test.xml | sort 13625 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13626 at_status=$? at_failed=false 13627 $at_check_filter 13628 at_fn_diff_devnull "$at_stderr" || at_failed=: 13629 $at_diff expout "$at_stdout" || at_failed=: 13630 at_fn_check_status 0 $at_status "$at_srcdir/output.at:76" 13631 $at_failed && at_fn_log_failure 13632 $at_traceon; } 13633 13634 rm -rf xml-tests expout 13635 at_restore_special_files 13636 fi 13637 { set +x 13638 $as_echo "$at_srcdir/output.at:76: bison foo.y " 13639 at_fn_check_prepare_trace "output.at:76" 13640 ( $at_check_trace; bison foo.y 13641 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13642 at_status=$? at_failed=false 13643 $at_check_filter 13644 at_fn_diff_devnull "$at_stderr" || at_failed=: 13645 at_fn_diff_devnull "$at_stdout" || at_failed=: 13646 at_fn_check_status 0 $at_status "$at_srcdir/output.at:76" 13647 $at_failed && at_fn_log_failure 13648 $at_traceon; } 13649 13650 13651 { set +x 13652 $as_echo "$at_srcdir/output.at:76: ls bar.output bar.tab.c bar.tab.h" 13653 at_fn_check_prepare_trace "output.at:76" 13654 ( $at_check_trace; ls bar.output bar.tab.c bar.tab.h 13655 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13656 at_status=$? at_failed=false 13657 $at_check_filter 13658 at_fn_diff_devnull "$at_stderr" || at_failed=: 13659 echo stdout:; cat "$at_stdout" 13660 at_fn_check_status 0 $at_status "$at_srcdir/output.at:76" 13661 $at_failed && at_fn_log_failure 13662 $at_traceon; } 13663 13664 13665 set +x 13666 $at_times_p && times >"$at_times_file" 13667 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 13668 read at_status <"$at_status_file" 13669 #AT_STOP_61 13670 #AT_START_62 13671 at_fn_group_banner 62 'output.at:78' \ 13672 "Output files: %output=\"bar.c\" %defines %verbose %yacc " "" 3 13673 at_xfail=no 13674 ( 13675 $as_echo "62. $at_setup_line: testing $at_desc ..." 13676 $at_traceon 13677 13678 13679 for file in foo.y bar.output bar.c bar.h; do 13680 case "$file" in 13681 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 13682 esac 13683 done 13684 cat >foo.y <<'_ATEOF' 13685 %output="bar.c" %defines %verbose %yacc 13686 %% 13687 foo: {}; 13688 _ATEOF 13689 13690 13691 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 13692 at_save_special_files 13693 mkdir xml-tests 13694 # Don't combine these Bison invocations since we want to be sure that 13695 # --report=all isn't required to get the full XML file. 13696 { set +x 13697 $as_echo "$at_srcdir/output.at:78: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 13698 --graph=xml-tests/test.dot foo.y " 13699 at_fn_check_prepare_notrace 'an embedded newline' "output.at:78" 13700 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 13701 --graph=xml-tests/test.dot foo.y 13702 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13703 at_status=$? at_failed=false 13704 $at_check_filter 13705 echo stderr:; cat "$at_stderr" 13706 echo stdout:; cat "$at_stdout" 13707 at_fn_check_status 0 $at_status "$at_srcdir/output.at:78" 13708 $at_failed && at_fn_log_failure 13709 $at_traceon; } 13710 13711 { set +x 13712 $as_echo "$at_srcdir/output.at:78: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.y " 13713 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.y " "output.at:78" 13714 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.y 13715 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13716 at_status=$? at_failed=false 13717 $at_check_filter 13718 echo stderr:; cat "$at_stderr" 13719 echo stdout:; cat "$at_stdout" 13720 at_fn_check_status 0 $at_status "$at_srcdir/output.at:78" 13721 $at_failed && at_fn_log_failure 13722 $at_traceon; } 13723 13724 cp xml-tests/test.output expout 13725 { set +x 13726 $as_echo "$at_srcdir/output.at:78: \$XSLTPROC \\ 13727 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 13728 xml-tests/test.xml" 13729 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:78" 13730 ( $at_check_trace; $XSLTPROC \ 13731 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 13732 xml-tests/test.xml 13733 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13734 at_status=$? at_failed=false 13735 $at_check_filter 13736 at_fn_diff_devnull "$at_stderr" || at_failed=: 13737 $at_diff expout "$at_stdout" || at_failed=: 13738 at_fn_check_status 0 $at_status "$at_srcdir/output.at:78" 13739 $at_failed && at_fn_log_failure 13740 $at_traceon; } 13741 13742 sort xml-tests/test.dot > expout 13743 { set +x 13744 $as_echo "$at_srcdir/output.at:78: \$XSLTPROC \\ 13745 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 13746 xml-tests/test.xml | sort" 13747 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:78" 13748 ( $at_check_trace; $XSLTPROC \ 13749 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 13750 xml-tests/test.xml | sort 13751 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13752 at_status=$? at_failed=false 13753 $at_check_filter 13754 at_fn_diff_devnull "$at_stderr" || at_failed=: 13755 $at_diff expout "$at_stdout" || at_failed=: 13756 at_fn_check_status 0 $at_status "$at_srcdir/output.at:78" 13757 $at_failed && at_fn_log_failure 13758 $at_traceon; } 13759 13760 rm -rf xml-tests expout 13761 at_restore_special_files 13762 fi 13763 { set +x 13764 $as_echo "$at_srcdir/output.at:78: bison foo.y " 13765 at_fn_check_prepare_trace "output.at:78" 13766 ( $at_check_trace; bison foo.y 13767 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13768 at_status=$? at_failed=false 13769 $at_check_filter 13770 at_fn_diff_devnull "$at_stderr" || at_failed=: 13771 at_fn_diff_devnull "$at_stdout" || at_failed=: 13772 at_fn_check_status 0 $at_status "$at_srcdir/output.at:78" 13773 $at_failed && at_fn_log_failure 13774 $at_traceon; } 13775 13776 13777 { set +x 13778 $as_echo "$at_srcdir/output.at:78: ls bar.output bar.c bar.h" 13779 at_fn_check_prepare_trace "output.at:78" 13780 ( $at_check_trace; ls bar.output bar.c bar.h 13781 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13782 at_status=$? at_failed=false 13783 $at_check_filter 13784 at_fn_diff_devnull "$at_stderr" || at_failed=: 13785 echo stdout:; cat "$at_stdout" 13786 at_fn_check_status 0 $at_status "$at_srcdir/output.at:78" 13787 $at_failed && at_fn_log_failure 13788 $at_traceon; } 13789 13790 13791 set +x 13792 $at_times_p && times >"$at_times_file" 13793 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 13794 read at_status <"$at_status_file" 13795 #AT_STOP_62 13796 #AT_START_63 13797 at_fn_group_banner 63 'output.at:80' \ 13798 "Output files: %file-prefix=\"baz\" %output \"bar.c\" %defines %verbose %yacc " "" 3 13799 at_xfail=no 13800 ( 13801 $as_echo "63. $at_setup_line: testing $at_desc ..." 13802 $at_traceon 13803 13804 13805 for file in foo.y bar.output bar.c bar.h; do 13806 case "$file" in 13807 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 13808 esac 13809 done 13810 cat >foo.y <<'_ATEOF' 13811 %file-prefix="baz" %output "bar.c" %defines %verbose %yacc 13812 %% 13813 foo: {}; 13814 _ATEOF 13815 13816 13817 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 13818 at_save_special_files 13819 mkdir xml-tests 13820 # Don't combine these Bison invocations since we want to be sure that 13821 # --report=all isn't required to get the full XML file. 13822 { set +x 13823 $as_echo "$at_srcdir/output.at:80: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 13824 --graph=xml-tests/test.dot foo.y " 13825 at_fn_check_prepare_notrace 'an embedded newline' "output.at:80" 13826 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 13827 --graph=xml-tests/test.dot foo.y 13828 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13829 at_status=$? at_failed=false 13830 $at_check_filter 13831 echo stderr:; cat "$at_stderr" 13832 echo stdout:; cat "$at_stdout" 13833 at_fn_check_status 0 $at_status "$at_srcdir/output.at:80" 13834 $at_failed && at_fn_log_failure 13835 $at_traceon; } 13836 13837 { set +x 13838 $as_echo "$at_srcdir/output.at:80: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.y " 13839 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.y " "output.at:80" 13840 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.y 13841 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13842 at_status=$? at_failed=false 13843 $at_check_filter 13844 echo stderr:; cat "$at_stderr" 13845 echo stdout:; cat "$at_stdout" 13846 at_fn_check_status 0 $at_status "$at_srcdir/output.at:80" 13847 $at_failed && at_fn_log_failure 13848 $at_traceon; } 13849 13850 cp xml-tests/test.output expout 13851 { set +x 13852 $as_echo "$at_srcdir/output.at:80: \$XSLTPROC \\ 13853 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 13854 xml-tests/test.xml" 13855 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:80" 13856 ( $at_check_trace; $XSLTPROC \ 13857 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 13858 xml-tests/test.xml 13859 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13860 at_status=$? at_failed=false 13861 $at_check_filter 13862 at_fn_diff_devnull "$at_stderr" || at_failed=: 13863 $at_diff expout "$at_stdout" || at_failed=: 13864 at_fn_check_status 0 $at_status "$at_srcdir/output.at:80" 13865 $at_failed && at_fn_log_failure 13866 $at_traceon; } 13867 13868 sort xml-tests/test.dot > expout 13869 { set +x 13870 $as_echo "$at_srcdir/output.at:80: \$XSLTPROC \\ 13871 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 13872 xml-tests/test.xml | sort" 13873 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:80" 13874 ( $at_check_trace; $XSLTPROC \ 13875 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 13876 xml-tests/test.xml | sort 13877 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13878 at_status=$? at_failed=false 13879 $at_check_filter 13880 at_fn_diff_devnull "$at_stderr" || at_failed=: 13881 $at_diff expout "$at_stdout" || at_failed=: 13882 at_fn_check_status 0 $at_status "$at_srcdir/output.at:80" 13883 $at_failed && at_fn_log_failure 13884 $at_traceon; } 13885 13886 rm -rf xml-tests expout 13887 at_restore_special_files 13888 fi 13889 { set +x 13890 $as_echo "$at_srcdir/output.at:80: bison foo.y " 13891 at_fn_check_prepare_trace "output.at:80" 13892 ( $at_check_trace; bison foo.y 13893 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13894 at_status=$? at_failed=false 13895 $at_check_filter 13896 at_fn_diff_devnull "$at_stderr" || at_failed=: 13897 at_fn_diff_devnull "$at_stdout" || at_failed=: 13898 at_fn_check_status 0 $at_status "$at_srcdir/output.at:80" 13899 $at_failed && at_fn_log_failure 13900 $at_traceon; } 13901 13902 13903 { set +x 13904 $as_echo "$at_srcdir/output.at:80: ls bar.output bar.c bar.h" 13905 at_fn_check_prepare_trace "output.at:80" 13906 ( $at_check_trace; ls bar.output bar.c bar.h 13907 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13908 at_status=$? at_failed=false 13909 $at_check_filter 13910 at_fn_diff_devnull "$at_stderr" || at_failed=: 13911 echo stdout:; cat "$at_stdout" 13912 at_fn_check_status 0 $at_status "$at_srcdir/output.at:80" 13913 $at_failed && at_fn_log_failure 13914 $at_traceon; } 13915 13916 13917 set +x 13918 $at_times_p && times >"$at_times_file" 13919 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 13920 read at_status <"$at_status_file" 13921 #AT_STOP_63 13922 #AT_START_64 13923 at_fn_group_banner 64 'output.at:87' \ 13924 "Output files: %defines %verbose " " " 3 13925 at_xfail=no 13926 ( 13927 $as_echo "64. $at_setup_line: testing $at_desc ..." 13928 $at_traceon 13929 13930 13931 for file in foo.yy foo.output foo.tab.cc foo.tab.hh; do 13932 case "$file" in 13933 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 13934 esac 13935 done 13936 cat >foo.yy <<'_ATEOF' 13937 %defines %verbose 13938 %% 13939 foo: {}; 13940 _ATEOF 13941 13942 13943 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 13944 at_save_special_files 13945 mkdir xml-tests 13946 # Don't combine these Bison invocations since we want to be sure that 13947 # --report=all isn't required to get the full XML file. 13948 { set +x 13949 $as_echo "$at_srcdir/output.at:87: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 13950 --graph=xml-tests/test.dot foo.yy " 13951 at_fn_check_prepare_notrace 'an embedded newline' "output.at:87" 13952 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 13953 --graph=xml-tests/test.dot foo.yy 13954 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13955 at_status=$? at_failed=false 13956 $at_check_filter 13957 echo stderr:; cat "$at_stderr" 13958 echo stdout:; cat "$at_stdout" 13959 at_fn_check_status 0 $at_status "$at_srcdir/output.at:87" 13960 $at_failed && at_fn_log_failure 13961 $at_traceon; } 13962 13963 { set +x 13964 $as_echo "$at_srcdir/output.at:87: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.yy " 13965 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.yy " "output.at:87" 13966 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.yy 13967 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13968 at_status=$? at_failed=false 13969 $at_check_filter 13970 echo stderr:; cat "$at_stderr" 13971 echo stdout:; cat "$at_stdout" 13972 at_fn_check_status 0 $at_status "$at_srcdir/output.at:87" 13973 $at_failed && at_fn_log_failure 13974 $at_traceon; } 13975 13976 cp xml-tests/test.output expout 13977 { set +x 13978 $as_echo "$at_srcdir/output.at:87: \$XSLTPROC \\ 13979 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 13980 xml-tests/test.xml" 13981 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:87" 13982 ( $at_check_trace; $XSLTPROC \ 13983 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 13984 xml-tests/test.xml 13985 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 13986 at_status=$? at_failed=false 13987 $at_check_filter 13988 at_fn_diff_devnull "$at_stderr" || at_failed=: 13989 $at_diff expout "$at_stdout" || at_failed=: 13990 at_fn_check_status 0 $at_status "$at_srcdir/output.at:87" 13991 $at_failed && at_fn_log_failure 13992 $at_traceon; } 13993 13994 sort xml-tests/test.dot > expout 13995 { set +x 13996 $as_echo "$at_srcdir/output.at:87: \$XSLTPROC \\ 13997 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 13998 xml-tests/test.xml | sort" 13999 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:87" 14000 ( $at_check_trace; $XSLTPROC \ 14001 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 14002 xml-tests/test.xml | sort 14003 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14004 at_status=$? at_failed=false 14005 $at_check_filter 14006 at_fn_diff_devnull "$at_stderr" || at_failed=: 14007 $at_diff expout "$at_stdout" || at_failed=: 14008 at_fn_check_status 0 $at_status "$at_srcdir/output.at:87" 14009 $at_failed && at_fn_log_failure 14010 $at_traceon; } 14011 14012 rm -rf xml-tests expout 14013 at_restore_special_files 14014 fi 14015 { set +x 14016 $as_echo "$at_srcdir/output.at:87: bison foo.yy " 14017 at_fn_check_prepare_trace "output.at:87" 14018 ( $at_check_trace; bison foo.yy 14019 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14020 at_status=$? at_failed=false 14021 $at_check_filter 14022 at_fn_diff_devnull "$at_stderr" || at_failed=: 14023 at_fn_diff_devnull "$at_stdout" || at_failed=: 14024 at_fn_check_status 0 $at_status "$at_srcdir/output.at:87" 14025 $at_failed && at_fn_log_failure 14026 $at_traceon; } 14027 14028 14029 { set +x 14030 $as_echo "$at_srcdir/output.at:87: ls foo.output foo.tab.cc foo.tab.hh" 14031 at_fn_check_prepare_trace "output.at:87" 14032 ( $at_check_trace; ls foo.output foo.tab.cc foo.tab.hh 14033 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14034 at_status=$? at_failed=false 14035 $at_check_filter 14036 at_fn_diff_devnull "$at_stderr" || at_failed=: 14037 echo stdout:; cat "$at_stdout" 14038 at_fn_check_status 0 $at_status "$at_srcdir/output.at:87" 14039 $at_failed && at_fn_log_failure 14040 $at_traceon; } 14041 14042 14043 set +x 14044 $at_times_p && times >"$at_times_file" 14045 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 14046 read at_status <"$at_status_file" 14047 #AT_STOP_64 14048 #AT_START_65 14049 at_fn_group_banner 65 'output.at:90' \ 14050 "Output files: %defines %verbose -o foo.c " " " 3 14051 at_xfail=no 14052 ( 14053 $as_echo "65. $at_setup_line: testing $at_desc ..." 14054 $at_traceon 14055 14056 14057 for file in foo.yy foo.c foo.h foo.output; do 14058 case "$file" in 14059 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 14060 esac 14061 done 14062 cat >foo.yy <<'_ATEOF' 14063 %defines %verbose 14064 %% 14065 foo: {}; 14066 _ATEOF 14067 14068 14069 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 14070 at_save_special_files 14071 mkdir xml-tests 14072 # Don't combine these Bison invocations since we want to be sure that 14073 # --report=all isn't required to get the full XML file. 14074 { set +x 14075 $as_echo "$at_srcdir/output.at:90: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 14076 --graph=xml-tests/test.dot -o foo.c foo.yy " 14077 at_fn_check_prepare_notrace 'an embedded newline' "output.at:90" 14078 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 14079 --graph=xml-tests/test.dot -o foo.c foo.yy 14080 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14081 at_status=$? at_failed=false 14082 $at_check_filter 14083 echo stderr:; cat "$at_stderr" 14084 echo stdout:; cat "$at_stdout" 14085 at_fn_check_status 0 $at_status "$at_srcdir/output.at:90" 14086 $at_failed && at_fn_log_failure 14087 $at_traceon; } 14088 14089 { set +x 14090 $as_echo "$at_srcdir/output.at:90: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o foo.c foo.yy " 14091 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o foo.c foo.yy " "output.at:90" 14092 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o foo.c foo.yy 14093 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14094 at_status=$? at_failed=false 14095 $at_check_filter 14096 echo stderr:; cat "$at_stderr" 14097 echo stdout:; cat "$at_stdout" 14098 at_fn_check_status 0 $at_status "$at_srcdir/output.at:90" 14099 $at_failed && at_fn_log_failure 14100 $at_traceon; } 14101 14102 cp xml-tests/test.output expout 14103 { set +x 14104 $as_echo "$at_srcdir/output.at:90: \$XSLTPROC \\ 14105 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 14106 xml-tests/test.xml" 14107 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:90" 14108 ( $at_check_trace; $XSLTPROC \ 14109 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 14110 xml-tests/test.xml 14111 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14112 at_status=$? at_failed=false 14113 $at_check_filter 14114 at_fn_diff_devnull "$at_stderr" || at_failed=: 14115 $at_diff expout "$at_stdout" || at_failed=: 14116 at_fn_check_status 0 $at_status "$at_srcdir/output.at:90" 14117 $at_failed && at_fn_log_failure 14118 $at_traceon; } 14119 14120 sort xml-tests/test.dot > expout 14121 { set +x 14122 $as_echo "$at_srcdir/output.at:90: \$XSLTPROC \\ 14123 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 14124 xml-tests/test.xml | sort" 14125 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:90" 14126 ( $at_check_trace; $XSLTPROC \ 14127 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 14128 xml-tests/test.xml | sort 14129 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14130 at_status=$? at_failed=false 14131 $at_check_filter 14132 at_fn_diff_devnull "$at_stderr" || at_failed=: 14133 $at_diff expout "$at_stdout" || at_failed=: 14134 at_fn_check_status 0 $at_status "$at_srcdir/output.at:90" 14135 $at_failed && at_fn_log_failure 14136 $at_traceon; } 14137 14138 rm -rf xml-tests expout 14139 at_restore_special_files 14140 fi 14141 { set +x 14142 $as_echo "$at_srcdir/output.at:90: bison -o foo.c foo.yy " 14143 at_fn_check_prepare_trace "output.at:90" 14144 ( $at_check_trace; bison -o foo.c foo.yy 14145 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14146 at_status=$? at_failed=false 14147 $at_check_filter 14148 at_fn_diff_devnull "$at_stderr" || at_failed=: 14149 at_fn_diff_devnull "$at_stdout" || at_failed=: 14150 at_fn_check_status 0 $at_status "$at_srcdir/output.at:90" 14151 $at_failed && at_fn_log_failure 14152 $at_traceon; } 14153 14154 14155 { set +x 14156 $as_echo "$at_srcdir/output.at:90: ls foo.c foo.h foo.output" 14157 at_fn_check_prepare_trace "output.at:90" 14158 ( $at_check_trace; ls foo.c foo.h foo.output 14159 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14160 at_status=$? at_failed=false 14161 $at_check_filter 14162 at_fn_diff_devnull "$at_stderr" || at_failed=: 14163 echo stdout:; cat "$at_stdout" 14164 at_fn_check_status 0 $at_status "$at_srcdir/output.at:90" 14165 $at_failed && at_fn_log_failure 14166 $at_traceon; } 14167 14168 14169 set +x 14170 $at_times_p && times >"$at_times_file" 14171 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 14172 read at_status <"$at_status_file" 14173 #AT_STOP_65 14174 #AT_START_66 14175 at_fn_group_banner 66 'output.at:93' \ 14176 "Output files: --defines=foo.hpp -o foo.c++ " " " 3 14177 at_xfail=no 14178 ( 14179 $as_echo "66. $at_setup_line: testing $at_desc ..." 14180 $at_traceon 14181 14182 14183 for file in foo.yy foo.c++ foo.hpp; do 14184 case "$file" in 14185 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 14186 esac 14187 done 14188 cat >foo.yy <<'_ATEOF' 14189 14190 %% 14191 foo: {}; 14192 _ATEOF 14193 14194 14195 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 14196 at_save_special_files 14197 mkdir xml-tests 14198 # Don't combine these Bison invocations since we want to be sure that 14199 # --report=all isn't required to get the full XML file. 14200 { set +x 14201 $as_echo "$at_srcdir/output.at:93: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 14202 --graph=xml-tests/test.dot --defines=foo.hpp -o foo.c++ foo.yy " 14203 at_fn_check_prepare_notrace 'an embedded newline' "output.at:93" 14204 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 14205 --graph=xml-tests/test.dot --defines=foo.hpp -o foo.c++ foo.yy 14206 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14207 at_status=$? at_failed=false 14208 $at_check_filter 14209 echo stderr:; cat "$at_stderr" 14210 echo stdout:; cat "$at_stdout" 14211 at_fn_check_status 0 $at_status "$at_srcdir/output.at:93" 14212 $at_failed && at_fn_log_failure 14213 $at_traceon; } 14214 14215 { set +x 14216 $as_echo "$at_srcdir/output.at:93: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --defines=foo.hpp -o foo.c++ foo.yy " 14217 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --defines=foo.hpp -o foo.c++ foo.yy " "output.at:93" 14218 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --defines=foo.hpp -o foo.c++ foo.yy 14219 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14220 at_status=$? at_failed=false 14221 $at_check_filter 14222 echo stderr:; cat "$at_stderr" 14223 echo stdout:; cat "$at_stdout" 14224 at_fn_check_status 0 $at_status "$at_srcdir/output.at:93" 14225 $at_failed && at_fn_log_failure 14226 $at_traceon; } 14227 14228 cp xml-tests/test.output expout 14229 { set +x 14230 $as_echo "$at_srcdir/output.at:93: \$XSLTPROC \\ 14231 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 14232 xml-tests/test.xml" 14233 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:93" 14234 ( $at_check_trace; $XSLTPROC \ 14235 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 14236 xml-tests/test.xml 14237 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14238 at_status=$? at_failed=false 14239 $at_check_filter 14240 at_fn_diff_devnull "$at_stderr" || at_failed=: 14241 $at_diff expout "$at_stdout" || at_failed=: 14242 at_fn_check_status 0 $at_status "$at_srcdir/output.at:93" 14243 $at_failed && at_fn_log_failure 14244 $at_traceon; } 14245 14246 sort xml-tests/test.dot > expout 14247 { set +x 14248 $as_echo "$at_srcdir/output.at:93: \$XSLTPROC \\ 14249 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 14250 xml-tests/test.xml | sort" 14251 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:93" 14252 ( $at_check_trace; $XSLTPROC \ 14253 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 14254 xml-tests/test.xml | sort 14255 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14256 at_status=$? at_failed=false 14257 $at_check_filter 14258 at_fn_diff_devnull "$at_stderr" || at_failed=: 14259 $at_diff expout "$at_stdout" || at_failed=: 14260 at_fn_check_status 0 $at_status "$at_srcdir/output.at:93" 14261 $at_failed && at_fn_log_failure 14262 $at_traceon; } 14263 14264 rm -rf xml-tests expout 14265 at_restore_special_files 14266 fi 14267 { set +x 14268 $as_echo "$at_srcdir/output.at:93: bison --defines=foo.hpp -o foo.c++ foo.yy " 14269 at_fn_check_prepare_trace "output.at:93" 14270 ( $at_check_trace; bison --defines=foo.hpp -o foo.c++ foo.yy 14271 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14272 at_status=$? at_failed=false 14273 $at_check_filter 14274 at_fn_diff_devnull "$at_stderr" || at_failed=: 14275 at_fn_diff_devnull "$at_stdout" || at_failed=: 14276 at_fn_check_status 0 $at_status "$at_srcdir/output.at:93" 14277 $at_failed && at_fn_log_failure 14278 $at_traceon; } 14279 14280 14281 { set +x 14282 $as_echo "$at_srcdir/output.at:93: ls foo.c++ foo.hpp" 14283 at_fn_check_prepare_trace "output.at:93" 14284 ( $at_check_trace; ls foo.c++ foo.hpp 14285 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14286 at_status=$? at_failed=false 14287 $at_check_filter 14288 at_fn_diff_devnull "$at_stderr" || at_failed=: 14289 echo stdout:; cat "$at_stdout" 14290 at_fn_check_status 0 $at_status "$at_srcdir/output.at:93" 14291 $at_failed && at_fn_log_failure 14292 $at_traceon; } 14293 14294 14295 set +x 14296 $at_times_p && times >"$at_times_file" 14297 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 14298 read at_status <"$at_status_file" 14299 #AT_STOP_66 14300 #AT_START_67 14301 at_fn_group_banner 67 'output.at:97' \ 14302 "Output files: %defines \"foo.hpp\" -o foo.c++ " " " 3 14303 at_xfail=no 14304 ( 14305 $as_echo "67. $at_setup_line: testing $at_desc ..." 14306 $at_traceon 14307 14308 14309 for file in foo.yy foo.c++ foo.hpp; do 14310 case "$file" in 14311 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 14312 esac 14313 done 14314 cat >foo.yy <<'_ATEOF' 14315 %defines "foo.hpp" 14316 %% 14317 foo: {}; 14318 _ATEOF 14319 14320 14321 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 14322 at_save_special_files 14323 mkdir xml-tests 14324 # Don't combine these Bison invocations since we want to be sure that 14325 # --report=all isn't required to get the full XML file. 14326 { set +x 14327 $as_echo "$at_srcdir/output.at:97: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 14328 --graph=xml-tests/test.dot -o foo.c++ foo.yy " 14329 at_fn_check_prepare_notrace 'an embedded newline' "output.at:97" 14330 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 14331 --graph=xml-tests/test.dot -o foo.c++ foo.yy 14332 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14333 at_status=$? at_failed=false 14334 $at_check_filter 14335 echo stderr:; cat "$at_stderr" 14336 echo stdout:; cat "$at_stdout" 14337 at_fn_check_status 0 $at_status "$at_srcdir/output.at:97" 14338 $at_failed && at_fn_log_failure 14339 $at_traceon; } 14340 14341 { set +x 14342 $as_echo "$at_srcdir/output.at:97: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o foo.c++ foo.yy " 14343 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o foo.c++ foo.yy " "output.at:97" 14344 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o foo.c++ foo.yy 14345 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14346 at_status=$? at_failed=false 14347 $at_check_filter 14348 echo stderr:; cat "$at_stderr" 14349 echo stdout:; cat "$at_stdout" 14350 at_fn_check_status 0 $at_status "$at_srcdir/output.at:97" 14351 $at_failed && at_fn_log_failure 14352 $at_traceon; } 14353 14354 cp xml-tests/test.output expout 14355 { set +x 14356 $as_echo "$at_srcdir/output.at:97: \$XSLTPROC \\ 14357 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 14358 xml-tests/test.xml" 14359 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:97" 14360 ( $at_check_trace; $XSLTPROC \ 14361 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 14362 xml-tests/test.xml 14363 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14364 at_status=$? at_failed=false 14365 $at_check_filter 14366 at_fn_diff_devnull "$at_stderr" || at_failed=: 14367 $at_diff expout "$at_stdout" || at_failed=: 14368 at_fn_check_status 0 $at_status "$at_srcdir/output.at:97" 14369 $at_failed && at_fn_log_failure 14370 $at_traceon; } 14371 14372 sort xml-tests/test.dot > expout 14373 { set +x 14374 $as_echo "$at_srcdir/output.at:97: \$XSLTPROC \\ 14375 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 14376 xml-tests/test.xml | sort" 14377 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:97" 14378 ( $at_check_trace; $XSLTPROC \ 14379 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 14380 xml-tests/test.xml | sort 14381 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14382 at_status=$? at_failed=false 14383 $at_check_filter 14384 at_fn_diff_devnull "$at_stderr" || at_failed=: 14385 $at_diff expout "$at_stdout" || at_failed=: 14386 at_fn_check_status 0 $at_status "$at_srcdir/output.at:97" 14387 $at_failed && at_fn_log_failure 14388 $at_traceon; } 14389 14390 rm -rf xml-tests expout 14391 at_restore_special_files 14392 fi 14393 { set +x 14394 $as_echo "$at_srcdir/output.at:97: bison -o foo.c++ foo.yy " 14395 at_fn_check_prepare_trace "output.at:97" 14396 ( $at_check_trace; bison -o foo.c++ foo.yy 14397 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14398 at_status=$? at_failed=false 14399 $at_check_filter 14400 at_fn_diff_devnull "$at_stderr" || at_failed=: 14401 at_fn_diff_devnull "$at_stdout" || at_failed=: 14402 at_fn_check_status 0 $at_status "$at_srcdir/output.at:97" 14403 $at_failed && at_fn_log_failure 14404 $at_traceon; } 14405 14406 14407 { set +x 14408 $as_echo "$at_srcdir/output.at:97: ls foo.c++ foo.hpp" 14409 at_fn_check_prepare_trace "output.at:97" 14410 ( $at_check_trace; ls foo.c++ foo.hpp 14411 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14412 at_status=$? at_failed=false 14413 $at_check_filter 14414 at_fn_diff_devnull "$at_stderr" || at_failed=: 14415 echo stdout:; cat "$at_stdout" 14416 at_fn_check_status 0 $at_status "$at_srcdir/output.at:97" 14417 $at_failed && at_fn_log_failure 14418 $at_traceon; } 14419 14420 14421 set +x 14422 $at_times_p && times >"$at_times_file" 14423 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 14424 read at_status <"$at_status_file" 14425 #AT_STOP_67 14426 #AT_START_68 14427 at_fn_group_banner 68 'output.at:101' \ 14428 "Output files: -o foo.c++ --graph=foo.gph " " " 3 14429 at_xfail=no 14430 ( 14431 $as_echo "68. $at_setup_line: testing $at_desc ..." 14432 $at_traceon 14433 14434 14435 for file in foo.yy foo.c++ foo.gph; do 14436 case "$file" in 14437 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 14438 esac 14439 done 14440 cat >foo.yy <<'_ATEOF' 14441 14442 %% 14443 foo: {}; 14444 _ATEOF 14445 14446 14447 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 14448 at_save_special_files 14449 mkdir xml-tests 14450 # Don't combine these Bison invocations since we want to be sure that 14451 # --report=all isn't required to get the full XML file. 14452 { set +x 14453 $as_echo "$at_srcdir/output.at:101: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 14454 --graph=xml-tests/test.dot -o foo.c++ foo.yy " 14455 at_fn_check_prepare_notrace 'an embedded newline' "output.at:101" 14456 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 14457 --graph=xml-tests/test.dot -o foo.c++ foo.yy 14458 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14459 at_status=$? at_failed=false 14460 $at_check_filter 14461 echo stderr:; cat "$at_stderr" 14462 echo stdout:; cat "$at_stdout" 14463 at_fn_check_status 0 $at_status "$at_srcdir/output.at:101" 14464 $at_failed && at_fn_log_failure 14465 $at_traceon; } 14466 14467 { set +x 14468 $as_echo "$at_srcdir/output.at:101: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o foo.c++ foo.yy " 14469 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o foo.c++ foo.yy " "output.at:101" 14470 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o foo.c++ foo.yy 14471 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14472 at_status=$? at_failed=false 14473 $at_check_filter 14474 echo stderr:; cat "$at_stderr" 14475 echo stdout:; cat "$at_stdout" 14476 at_fn_check_status 0 $at_status "$at_srcdir/output.at:101" 14477 $at_failed && at_fn_log_failure 14478 $at_traceon; } 14479 14480 cp xml-tests/test.output expout 14481 { set +x 14482 $as_echo "$at_srcdir/output.at:101: \$XSLTPROC \\ 14483 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 14484 xml-tests/test.xml" 14485 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:101" 14486 ( $at_check_trace; $XSLTPROC \ 14487 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 14488 xml-tests/test.xml 14489 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14490 at_status=$? at_failed=false 14491 $at_check_filter 14492 at_fn_diff_devnull "$at_stderr" || at_failed=: 14493 $at_diff expout "$at_stdout" || at_failed=: 14494 at_fn_check_status 0 $at_status "$at_srcdir/output.at:101" 14495 $at_failed && at_fn_log_failure 14496 $at_traceon; } 14497 14498 sort xml-tests/test.dot > expout 14499 { set +x 14500 $as_echo "$at_srcdir/output.at:101: \$XSLTPROC \\ 14501 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 14502 xml-tests/test.xml | sort" 14503 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:101" 14504 ( $at_check_trace; $XSLTPROC \ 14505 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 14506 xml-tests/test.xml | sort 14507 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14508 at_status=$? at_failed=false 14509 $at_check_filter 14510 at_fn_diff_devnull "$at_stderr" || at_failed=: 14511 $at_diff expout "$at_stdout" || at_failed=: 14512 at_fn_check_status 0 $at_status "$at_srcdir/output.at:101" 14513 $at_failed && at_fn_log_failure 14514 $at_traceon; } 14515 14516 rm -rf xml-tests expout 14517 at_restore_special_files 14518 fi 14519 { set +x 14520 $as_echo "$at_srcdir/output.at:101: bison -o foo.c++ --graph=foo.gph foo.yy " 14521 at_fn_check_prepare_trace "output.at:101" 14522 ( $at_check_trace; bison -o foo.c++ --graph=foo.gph foo.yy 14523 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14524 at_status=$? at_failed=false 14525 $at_check_filter 14526 at_fn_diff_devnull "$at_stderr" || at_failed=: 14527 at_fn_diff_devnull "$at_stdout" || at_failed=: 14528 at_fn_check_status 0 $at_status "$at_srcdir/output.at:101" 14529 $at_failed && at_fn_log_failure 14530 $at_traceon; } 14531 14532 14533 { set +x 14534 $as_echo "$at_srcdir/output.at:101: ls foo.c++ foo.gph" 14535 at_fn_check_prepare_trace "output.at:101" 14536 ( $at_check_trace; ls foo.c++ foo.gph 14537 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14538 at_status=$? at_failed=false 14539 $at_check_filter 14540 at_fn_diff_devnull "$at_stderr" || at_failed=: 14541 echo stdout:; cat "$at_stdout" 14542 at_fn_check_status 0 $at_status "$at_srcdir/output.at:101" 14543 $at_failed && at_fn_log_failure 14544 $at_traceon; } 14545 14546 14547 set +x 14548 $at_times_p && times >"$at_times_file" 14549 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 14550 read at_status <"$at_status_file" 14551 #AT_STOP_68 14552 #AT_START_69 14553 at_fn_group_banner 69 'output.at:116' \ 14554 "Output files: %skeleton \"lalr1.cc\" %defines %verbose " "" 3 14555 at_xfail=no 14556 ( 14557 $as_echo "69. $at_setup_line: testing $at_desc ..." 14558 $at_traceon 14559 14560 14561 for file in foo.yy foo.tab.cc foo.tab.hh foo.output location.hh stack.hh position.hh; do 14562 case "$file" in 14563 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 14564 esac 14565 done 14566 cat >foo.yy <<'_ATEOF' 14567 %skeleton "lalr1.cc" %defines %verbose 14568 %% 14569 foo: {}; 14570 _ATEOF 14571 14572 14573 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 14574 at_save_special_files 14575 mkdir xml-tests 14576 # Don't combine these Bison invocations since we want to be sure that 14577 # --report=all isn't required to get the full XML file. 14578 { set +x 14579 $as_echo "$at_srcdir/output.at:116: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 14580 --graph=xml-tests/test.dot foo.yy " 14581 at_fn_check_prepare_notrace 'an embedded newline' "output.at:116" 14582 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 14583 --graph=xml-tests/test.dot foo.yy 14584 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14585 at_status=$? at_failed=false 14586 $at_check_filter 14587 echo stderr:; cat "$at_stderr" 14588 echo stdout:; cat "$at_stdout" 14589 at_fn_check_status 0 $at_status "$at_srcdir/output.at:116" 14590 $at_failed && at_fn_log_failure 14591 $at_traceon; } 14592 14593 { set +x 14594 $as_echo "$at_srcdir/output.at:116: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.yy " 14595 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.yy " "output.at:116" 14596 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml foo.yy 14597 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14598 at_status=$? at_failed=false 14599 $at_check_filter 14600 echo stderr:; cat "$at_stderr" 14601 echo stdout:; cat "$at_stdout" 14602 at_fn_check_status 0 $at_status "$at_srcdir/output.at:116" 14603 $at_failed && at_fn_log_failure 14604 $at_traceon; } 14605 14606 cp xml-tests/test.output expout 14607 { set +x 14608 $as_echo "$at_srcdir/output.at:116: \$XSLTPROC \\ 14609 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 14610 xml-tests/test.xml" 14611 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:116" 14612 ( $at_check_trace; $XSLTPROC \ 14613 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 14614 xml-tests/test.xml 14615 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14616 at_status=$? at_failed=false 14617 $at_check_filter 14618 at_fn_diff_devnull "$at_stderr" || at_failed=: 14619 $at_diff expout "$at_stdout" || at_failed=: 14620 at_fn_check_status 0 $at_status "$at_srcdir/output.at:116" 14621 $at_failed && at_fn_log_failure 14622 $at_traceon; } 14623 14624 sort xml-tests/test.dot > expout 14625 { set +x 14626 $as_echo "$at_srcdir/output.at:116: \$XSLTPROC \\ 14627 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 14628 xml-tests/test.xml | sort" 14629 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:116" 14630 ( $at_check_trace; $XSLTPROC \ 14631 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 14632 xml-tests/test.xml | sort 14633 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14634 at_status=$? at_failed=false 14635 $at_check_filter 14636 at_fn_diff_devnull "$at_stderr" || at_failed=: 14637 $at_diff expout "$at_stdout" || at_failed=: 14638 at_fn_check_status 0 $at_status "$at_srcdir/output.at:116" 14639 $at_failed && at_fn_log_failure 14640 $at_traceon; } 14641 14642 rm -rf xml-tests expout 14643 at_restore_special_files 14644 fi 14645 { set +x 14646 $as_echo "$at_srcdir/output.at:116: bison foo.yy " 14647 at_fn_check_prepare_trace "output.at:116" 14648 ( $at_check_trace; bison foo.yy 14649 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14650 at_status=$? at_failed=false 14651 $at_check_filter 14652 at_fn_diff_devnull "$at_stderr" || at_failed=: 14653 at_fn_diff_devnull "$at_stdout" || at_failed=: 14654 at_fn_check_status 0 $at_status "$at_srcdir/output.at:116" 14655 $at_failed && at_fn_log_failure 14656 $at_traceon; } 14657 14658 14659 { set +x 14660 $as_echo "$at_srcdir/output.at:116: ls foo.tab.cc foo.tab.hh foo.output location.hh stack.hh position.hh" 14661 at_fn_check_prepare_trace "output.at:116" 14662 ( $at_check_trace; ls foo.tab.cc foo.tab.hh foo.output location.hh stack.hh position.hh 14663 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14664 at_status=$? at_failed=false 14665 $at_check_filter 14666 at_fn_diff_devnull "$at_stderr" || at_failed=: 14667 echo stdout:; cat "$at_stdout" 14668 at_fn_check_status 0 $at_status "$at_srcdir/output.at:116" 14669 $at_failed && at_fn_log_failure 14670 $at_traceon; } 14671 14672 14673 set +x 14674 $at_times_p && times >"$at_times_file" 14675 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 14676 read at_status <"$at_status_file" 14677 #AT_STOP_69 14678 #AT_START_70 14679 at_fn_group_banner 70 'output.at:119' \ 14680 "Output files: %skeleton \"lalr1.cc\" %defines %verbose " "" 3 14681 at_xfail=no 14682 ( 14683 $as_echo "70. $at_setup_line: testing $at_desc ..." 14684 $at_traceon 14685 14686 14687 for file in subdir/foo.yy foo.tab.cc foo.tab.hh foo.output location.hh stack.hh position.hh; do 14688 case "$file" in 14689 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 14690 esac 14691 done 14692 cat >subdir/foo.yy <<'_ATEOF' 14693 %skeleton "lalr1.cc" %defines %verbose 14694 %% 14695 foo: {}; 14696 _ATEOF 14697 14698 14699 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 14700 at_save_special_files 14701 mkdir xml-tests 14702 # Don't combine these Bison invocations since we want to be sure that 14703 # --report=all isn't required to get the full XML file. 14704 { set +x 14705 $as_echo "$at_srcdir/output.at:119: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 14706 --graph=xml-tests/test.dot subdir/foo.yy " 14707 at_fn_check_prepare_notrace 'an embedded newline' "output.at:119" 14708 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 14709 --graph=xml-tests/test.dot subdir/foo.yy 14710 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14711 at_status=$? at_failed=false 14712 $at_check_filter 14713 echo stderr:; cat "$at_stderr" 14714 echo stdout:; cat "$at_stdout" 14715 at_fn_check_status 0 $at_status "$at_srcdir/output.at:119" 14716 $at_failed && at_fn_log_failure 14717 $at_traceon; } 14718 14719 { set +x 14720 $as_echo "$at_srcdir/output.at:119: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml subdir/foo.yy " 14721 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml subdir/foo.yy " "output.at:119" 14722 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml subdir/foo.yy 14723 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14724 at_status=$? at_failed=false 14725 $at_check_filter 14726 echo stderr:; cat "$at_stderr" 14727 echo stdout:; cat "$at_stdout" 14728 at_fn_check_status 0 $at_status "$at_srcdir/output.at:119" 14729 $at_failed && at_fn_log_failure 14730 $at_traceon; } 14731 14732 cp xml-tests/test.output expout 14733 { set +x 14734 $as_echo "$at_srcdir/output.at:119: \$XSLTPROC \\ 14735 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 14736 xml-tests/test.xml" 14737 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:119" 14738 ( $at_check_trace; $XSLTPROC \ 14739 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 14740 xml-tests/test.xml 14741 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14742 at_status=$? at_failed=false 14743 $at_check_filter 14744 at_fn_diff_devnull "$at_stderr" || at_failed=: 14745 $at_diff expout "$at_stdout" || at_failed=: 14746 at_fn_check_status 0 $at_status "$at_srcdir/output.at:119" 14747 $at_failed && at_fn_log_failure 14748 $at_traceon; } 14749 14750 sort xml-tests/test.dot > expout 14751 { set +x 14752 $as_echo "$at_srcdir/output.at:119: \$XSLTPROC \\ 14753 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 14754 xml-tests/test.xml | sort" 14755 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:119" 14756 ( $at_check_trace; $XSLTPROC \ 14757 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 14758 xml-tests/test.xml | sort 14759 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14760 at_status=$? at_failed=false 14761 $at_check_filter 14762 at_fn_diff_devnull "$at_stderr" || at_failed=: 14763 $at_diff expout "$at_stdout" || at_failed=: 14764 at_fn_check_status 0 $at_status "$at_srcdir/output.at:119" 14765 $at_failed && at_fn_log_failure 14766 $at_traceon; } 14767 14768 rm -rf xml-tests expout 14769 at_restore_special_files 14770 fi 14771 { set +x 14772 $as_echo "$at_srcdir/output.at:119: bison subdir/foo.yy " 14773 at_fn_check_prepare_trace "output.at:119" 14774 ( $at_check_trace; bison subdir/foo.yy 14775 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14776 at_status=$? at_failed=false 14777 $at_check_filter 14778 at_fn_diff_devnull "$at_stderr" || at_failed=: 14779 at_fn_diff_devnull "$at_stdout" || at_failed=: 14780 at_fn_check_status 0 $at_status "$at_srcdir/output.at:119" 14781 $at_failed && at_fn_log_failure 14782 $at_traceon; } 14783 14784 14785 { set +x 14786 $as_echo "$at_srcdir/output.at:119: ls foo.tab.cc foo.tab.hh foo.output location.hh stack.hh position.hh" 14787 at_fn_check_prepare_trace "output.at:119" 14788 ( $at_check_trace; ls foo.tab.cc foo.tab.hh foo.output location.hh stack.hh position.hh 14789 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14790 at_status=$? at_failed=false 14791 $at_check_filter 14792 at_fn_diff_devnull "$at_stderr" || at_failed=: 14793 echo stdout:; cat "$at_stdout" 14794 at_fn_check_status 0 $at_status "$at_srcdir/output.at:119" 14795 $at_failed && at_fn_log_failure 14796 $at_traceon; } 14797 14798 # Also make sure that the includes do not refer to the subdirectory. 14799 { set +x 14800 $as_echo "$at_srcdir/output.at:119: grep 'include .subdir/' foo.tab.cc" 14801 at_fn_check_prepare_trace "output.at:119" 14802 ( $at_check_trace; grep 'include .subdir/' foo.tab.cc 14803 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14804 at_status=$? at_failed=false 14805 $at_check_filter 14806 at_fn_diff_devnull "$at_stderr" || at_failed=: 14807 at_fn_diff_devnull "$at_stdout" || at_failed=: 14808 at_fn_check_status 1 $at_status "$at_srcdir/output.at:119" 14809 $at_failed && at_fn_log_failure 14810 $at_traceon; } 14811 14812 { set +x 14813 $as_echo "$at_srcdir/output.at:119: grep 'include .subdir/' foo.tab.hh" 14814 at_fn_check_prepare_trace "output.at:119" 14815 ( $at_check_trace; grep 'include .subdir/' foo.tab.hh 14816 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14817 at_status=$? at_failed=false 14818 $at_check_filter 14819 at_fn_diff_devnull "$at_stderr" || at_failed=: 14820 at_fn_diff_devnull "$at_stdout" || at_failed=: 14821 at_fn_check_status 1 $at_status "$at_srcdir/output.at:119" 14822 $at_failed && at_fn_log_failure 14823 $at_traceon; } 14824 14825 14826 set +x 14827 $at_times_p && times >"$at_times_file" 14828 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 14829 read at_status <"$at_status_file" 14830 #AT_STOP_70 14831 #AT_START_71 14832 at_fn_group_banner 71 'output.at:123' \ 14833 "Output files: %skeleton \"lalr1.cc\" %defines %verbose -o subdir/foo.cc " "" 3 14834 at_xfail=no 14835 ( 14836 $as_echo "71. $at_setup_line: testing $at_desc ..." 14837 $at_traceon 14838 14839 14840 for file in subdir/foo.yy subdir/foo.cc subdir/foo.hh subdir/foo.output subdir/location.hh subdir/stack.hh subdir/position.hh; do 14841 case "$file" in 14842 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 14843 esac 14844 done 14845 cat >subdir/foo.yy <<'_ATEOF' 14846 %skeleton "lalr1.cc" %defines %verbose 14847 %% 14848 foo: {}; 14849 _ATEOF 14850 14851 14852 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 14853 at_save_special_files 14854 mkdir xml-tests 14855 # Don't combine these Bison invocations since we want to be sure that 14856 # --report=all isn't required to get the full XML file. 14857 { set +x 14858 $as_echo "$at_srcdir/output.at:123: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 14859 --graph=xml-tests/test.dot -o subdir/foo.cc subdir/foo.yy " 14860 at_fn_check_prepare_notrace 'an embedded newline' "output.at:123" 14861 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 14862 --graph=xml-tests/test.dot -o subdir/foo.cc subdir/foo.yy 14863 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14864 at_status=$? at_failed=false 14865 $at_check_filter 14866 echo stderr:; cat "$at_stderr" 14867 echo stdout:; cat "$at_stdout" 14868 at_fn_check_status 0 $at_status "$at_srcdir/output.at:123" 14869 $at_failed && at_fn_log_failure 14870 $at_traceon; } 14871 14872 { set +x 14873 $as_echo "$at_srcdir/output.at:123: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o subdir/foo.cc subdir/foo.yy " 14874 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o subdir/foo.cc subdir/foo.yy " "output.at:123" 14875 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o subdir/foo.cc subdir/foo.yy 14876 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14877 at_status=$? at_failed=false 14878 $at_check_filter 14879 echo stderr:; cat "$at_stderr" 14880 echo stdout:; cat "$at_stdout" 14881 at_fn_check_status 0 $at_status "$at_srcdir/output.at:123" 14882 $at_failed && at_fn_log_failure 14883 $at_traceon; } 14884 14885 cp xml-tests/test.output expout 14886 { set +x 14887 $as_echo "$at_srcdir/output.at:123: \$XSLTPROC \\ 14888 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 14889 xml-tests/test.xml" 14890 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:123" 14891 ( $at_check_trace; $XSLTPROC \ 14892 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 14893 xml-tests/test.xml 14894 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14895 at_status=$? at_failed=false 14896 $at_check_filter 14897 at_fn_diff_devnull "$at_stderr" || at_failed=: 14898 $at_diff expout "$at_stdout" || at_failed=: 14899 at_fn_check_status 0 $at_status "$at_srcdir/output.at:123" 14900 $at_failed && at_fn_log_failure 14901 $at_traceon; } 14902 14903 sort xml-tests/test.dot > expout 14904 { set +x 14905 $as_echo "$at_srcdir/output.at:123: \$XSLTPROC \\ 14906 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 14907 xml-tests/test.xml | sort" 14908 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:123" 14909 ( $at_check_trace; $XSLTPROC \ 14910 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 14911 xml-tests/test.xml | sort 14912 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14913 at_status=$? at_failed=false 14914 $at_check_filter 14915 at_fn_diff_devnull "$at_stderr" || at_failed=: 14916 $at_diff expout "$at_stdout" || at_failed=: 14917 at_fn_check_status 0 $at_status "$at_srcdir/output.at:123" 14918 $at_failed && at_fn_log_failure 14919 $at_traceon; } 14920 14921 rm -rf xml-tests expout 14922 at_restore_special_files 14923 fi 14924 { set +x 14925 $as_echo "$at_srcdir/output.at:123: bison -o subdir/foo.cc subdir/foo.yy " 14926 at_fn_check_prepare_trace "output.at:123" 14927 ( $at_check_trace; bison -o subdir/foo.cc subdir/foo.yy 14928 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14929 at_status=$? at_failed=false 14930 $at_check_filter 14931 at_fn_diff_devnull "$at_stderr" || at_failed=: 14932 at_fn_diff_devnull "$at_stdout" || at_failed=: 14933 at_fn_check_status 0 $at_status "$at_srcdir/output.at:123" 14934 $at_failed && at_fn_log_failure 14935 $at_traceon; } 14936 14937 14938 { set +x 14939 $as_echo "$at_srcdir/output.at:123: ls subdir/foo.cc subdir/foo.hh subdir/foo.output subdir/location.hh subdir/stack.hh subdir/position.hh" 14940 at_fn_check_prepare_trace "output.at:123" 14941 ( $at_check_trace; ls subdir/foo.cc subdir/foo.hh subdir/foo.output subdir/location.hh subdir/stack.hh subdir/position.hh 14942 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14943 at_status=$? at_failed=false 14944 $at_check_filter 14945 at_fn_diff_devnull "$at_stderr" || at_failed=: 14946 echo stdout:; cat "$at_stdout" 14947 at_fn_check_status 0 $at_status "$at_srcdir/output.at:123" 14948 $at_failed && at_fn_log_failure 14949 $at_traceon; } 14950 14951 # Also make sure that the includes do not refer to the subdirectory. 14952 { set +x 14953 $as_echo "$at_srcdir/output.at:123: grep 'include .subdir/' subdir/foo.cc" 14954 at_fn_check_prepare_trace "output.at:123" 14955 ( $at_check_trace; grep 'include .subdir/' subdir/foo.cc 14956 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14957 at_status=$? at_failed=false 14958 $at_check_filter 14959 at_fn_diff_devnull "$at_stderr" || at_failed=: 14960 at_fn_diff_devnull "$at_stdout" || at_failed=: 14961 at_fn_check_status 1 $at_status "$at_srcdir/output.at:123" 14962 $at_failed && at_fn_log_failure 14963 $at_traceon; } 14964 14965 { set +x 14966 $as_echo "$at_srcdir/output.at:123: grep 'include .subdir/' subdir/foo.hh" 14967 at_fn_check_prepare_trace "output.at:123" 14968 ( $at_check_trace; grep 'include .subdir/' subdir/foo.hh 14969 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 14970 at_status=$? at_failed=false 14971 $at_check_filter 14972 at_fn_diff_devnull "$at_stderr" || at_failed=: 14973 at_fn_diff_devnull "$at_stdout" || at_failed=: 14974 at_fn_check_status 1 $at_status "$at_srcdir/output.at:123" 14975 $at_failed && at_fn_log_failure 14976 $at_traceon; } 14977 14978 14979 set +x 14980 $at_times_p && times >"$at_times_file" 14981 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 14982 read at_status <"$at_status_file" 14983 #AT_STOP_71 14984 #AT_START_72 14985 at_fn_group_banner 72 'output.at:128' \ 14986 "Output files: %skeleton \"lalr1.cc\" %defines %verbose %file-prefix \"output_dir/foo\" " "" 3 14987 at_xfail=no 14988 ( 14989 $as_echo "72. $at_setup_line: testing $at_desc ..." 14990 $at_traceon 14991 14992 14993 for file in gram_dir/foo.yy output_dir/foo.tab.cc output_dir/foo.tab.hh output_dir/foo.output output_dir/location.hh output_dir/stack.hh output_dir/position.hh; do 14994 case "$file" in 14995 */*) mkdir -p `echo "$file" | sed 's,/.*,,'`;; 14996 esac 14997 done 14998 cat >gram_dir/foo.yy <<'_ATEOF' 14999 %skeleton "lalr1.cc" %defines %verbose %file-prefix "output_dir/foo" 15000 %% 15001 foo: {}; 15002 _ATEOF 15003 15004 15005 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 15006 at_save_special_files 15007 mkdir xml-tests 15008 # Don't combine these Bison invocations since we want to be sure that 15009 # --report=all isn't required to get the full XML file. 15010 { set +x 15011 $as_echo "$at_srcdir/output.at:128: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 15012 --graph=xml-tests/test.dot gram_dir/foo.yy " 15013 at_fn_check_prepare_notrace 'an embedded newline' "output.at:128" 15014 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 15015 --graph=xml-tests/test.dot gram_dir/foo.yy 15016 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15017 at_status=$? at_failed=false 15018 $at_check_filter 15019 echo stderr:; cat "$at_stderr" 15020 echo stdout:; cat "$at_stdout" 15021 at_fn_check_status 0 $at_status "$at_srcdir/output.at:128" 15022 $at_failed && at_fn_log_failure 15023 $at_traceon; } 15024 15025 { set +x 15026 $as_echo "$at_srcdir/output.at:128: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml gram_dir/foo.yy " 15027 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml gram_dir/foo.yy " "output.at:128" 15028 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml gram_dir/foo.yy 15029 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15030 at_status=$? at_failed=false 15031 $at_check_filter 15032 echo stderr:; cat "$at_stderr" 15033 echo stdout:; cat "$at_stdout" 15034 at_fn_check_status 0 $at_status "$at_srcdir/output.at:128" 15035 $at_failed && at_fn_log_failure 15036 $at_traceon; } 15037 15038 cp xml-tests/test.output expout 15039 { set +x 15040 $as_echo "$at_srcdir/output.at:128: \$XSLTPROC \\ 15041 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 15042 xml-tests/test.xml" 15043 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:128" 15044 ( $at_check_trace; $XSLTPROC \ 15045 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 15046 xml-tests/test.xml 15047 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15048 at_status=$? at_failed=false 15049 $at_check_filter 15050 at_fn_diff_devnull "$at_stderr" || at_failed=: 15051 $at_diff expout "$at_stdout" || at_failed=: 15052 at_fn_check_status 0 $at_status "$at_srcdir/output.at:128" 15053 $at_failed && at_fn_log_failure 15054 $at_traceon; } 15055 15056 sort xml-tests/test.dot > expout 15057 { set +x 15058 $as_echo "$at_srcdir/output.at:128: \$XSLTPROC \\ 15059 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 15060 xml-tests/test.xml | sort" 15061 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:128" 15062 ( $at_check_trace; $XSLTPROC \ 15063 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 15064 xml-tests/test.xml | sort 15065 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15066 at_status=$? at_failed=false 15067 $at_check_filter 15068 at_fn_diff_devnull "$at_stderr" || at_failed=: 15069 $at_diff expout "$at_stdout" || at_failed=: 15070 at_fn_check_status 0 $at_status "$at_srcdir/output.at:128" 15071 $at_failed && at_fn_log_failure 15072 $at_traceon; } 15073 15074 rm -rf xml-tests expout 15075 at_restore_special_files 15076 fi 15077 { set +x 15078 $as_echo "$at_srcdir/output.at:128: bison gram_dir/foo.yy " 15079 at_fn_check_prepare_trace "output.at:128" 15080 ( $at_check_trace; bison gram_dir/foo.yy 15081 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15082 at_status=$? at_failed=false 15083 $at_check_filter 15084 at_fn_diff_devnull "$at_stderr" || at_failed=: 15085 at_fn_diff_devnull "$at_stdout" || at_failed=: 15086 at_fn_check_status 0 $at_status "$at_srcdir/output.at:128" 15087 $at_failed && at_fn_log_failure 15088 $at_traceon; } 15089 15090 15091 { set +x 15092 $as_echo "$at_srcdir/output.at:128: ls output_dir/foo.tab.cc output_dir/foo.tab.hh output_dir/foo.output output_dir/location.hh output_dir/stack.hh output_dir/position.hh" 15093 at_fn_check_prepare_trace "output.at:128" 15094 ( $at_check_trace; ls output_dir/foo.tab.cc output_dir/foo.tab.hh output_dir/foo.output output_dir/location.hh output_dir/stack.hh output_dir/position.hh 15095 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15096 at_status=$? at_failed=false 15097 $at_check_filter 15098 at_fn_diff_devnull "$at_stderr" || at_failed=: 15099 echo stdout:; cat "$at_stdout" 15100 at_fn_check_status 0 $at_status "$at_srcdir/output.at:128" 15101 $at_failed && at_fn_log_failure 15102 $at_traceon; } 15103 15104 15105 set +x 15106 $at_times_p && times >"$at_times_file" 15107 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 15108 read at_status <"$at_status_file" 15109 #AT_STOP_72 15110 #AT_START_73 15111 at_fn_group_banner 73 'output.at:158' \ 15112 "Conflicting output files: --graph=\"foo.tab.c\"" " " 3 15113 at_xfail=no 15114 ( 15115 $as_echo "73. $at_setup_line: testing $at_desc ..." 15116 $at_traceon 15117 15118 case "foo.y" in 15119 */*) mkdir `echo "foo.y" | sed 's,/.*,,'`;; 15120 esac 15121 cat >foo.y <<'_ATEOF' 15122 15123 %% 15124 foo: {}; 15125 _ATEOF 15126 15127 15128 cp foo.y expout 15129 # Because an output file name conflict is still a warning, Bison exits 15130 # with status 0, so AT_BISON_CHECK does not realize that there may be no 15131 # output file against which to check the XML. AT_BISON_CHECK_NO_XML 15132 # avoids that problem. 15133 { set +x 15134 $as_echo "$at_srcdir/output.at:158: bison --graph=\"foo.tab.c\" foo.y" 15135 at_fn_check_prepare_trace "output.at:158" 15136 ( $at_check_trace; bison --graph="foo.tab.c" foo.y 15137 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15138 at_status=$? at_failed=false 15139 $at_check_filter 15140 echo >>"$at_stderr"; $as_echo "foo.y: warning: conflicting outputs to file 'foo.tab.c' 15141 " | \ 15142 $at_diff - "$at_stderr" || at_failed=: 15143 at_fn_diff_devnull "$at_stdout" || at_failed=: 15144 at_fn_check_status 0 $at_status "$at_srcdir/output.at:158" 15145 $at_failed && at_fn_log_failure 15146 $at_traceon; } 15147 15148 # Defining POSIXLY_CORRECT causes bison to complain if options are 15149 # added after the grammar file name, so skip these checks in that 15150 # case. 15151 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 15152 at_save_special_files 15153 15154 # To avoid expanding it repeatedly, store specified stdout. 15155 : >expout 15156 15157 # Run with -Werror. 15158 { set +x 15159 $as_echo "$at_srcdir/output.at:158: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --graph=\"foo.tab.c\" foo.y -Werror" 15160 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --graph=\"foo.tab.c\" foo.y -Werror" "output.at:158" 15161 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --graph="foo.tab.c" foo.y -Werror 15162 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15163 at_status=$? at_failed=false 15164 $at_check_filter 15165 echo stderr:; tee stderr <"$at_stderr" 15166 $at_diff expout "$at_stdout" || at_failed=: 15167 at_fn_check_status 1 $at_status "$at_srcdir/output.at:158" 15168 $at_failed && at_fn_log_failure 15169 $at_traceon; } 15170 15171 15172 # Build expected stderr up to and including the "warnings being 15173 # treated as errors" message. 15174 cat >at-bison-check-warnings <<'_ATEOF' 15175 foo.y: warning: conflicting outputs to file 'foo.tab.c' 15176 _ATEOF 15177 15178 at_bison_check_first=`sed -n \ 15179 '/: warning: /{=;q;}' at-bison-check-warnings` 15180 : ${at_bison_check_first:=1} 15181 at_bison_check_first_tmp=`sed -n \ 15182 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 15183 : ${at_bison_check_first_tmp:=1} 15184 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 15185 at_bison_check_first=$at_bison_check_first_tmp 15186 fi 15187 if test $at_bison_check_first -gt 1; then 15188 sed -n "1,`expr $at_bison_check_first - 1`"p \ 15189 at-bison-check-warnings > experr 15190 fi 15191 echo 'bison: warnings being treated as errors' >> experr 15192 15193 # Finish building expected stderr and check. Unlike warnings, 15194 # complaints cause bison to exit early. Thus, with -Werror, bison 15195 # does not necessarily report all warnings that it does without 15196 # -Werror, but it at least reports one. 15197 at_bison_check_last=`sed -n '$=' stderr` 15198 : ${at_bison_check_last:=1} 15199 at_bison_check_last=`expr $at_bison_check_last - 1` 15200 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 15201 at-bison-check-warnings >> experr 15202 { set +x 15203 $as_echo "$at_srcdir/output.at:158: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 15204 stderr 1>&2" 15205 at_fn_check_prepare_notrace 'an embedded newline' "output.at:158" 15206 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 15207 stderr 1>&2 15208 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15209 at_status=$? at_failed=false 15210 $at_check_filter 15211 $at_diff experr "$at_stderr" || at_failed=: 15212 at_fn_diff_devnull "$at_stdout" || at_failed=: 15213 at_fn_check_status 0 $at_status "$at_srcdir/output.at:158" 15214 $at_failed && at_fn_log_failure 15215 $at_traceon; } 15216 15217 15218 # Now check --warnings=error. 15219 cp stderr experr 15220 { set +x 15221 $as_echo "$at_srcdir/output.at:158: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --graph=\"foo.tab.c\" foo.y --warnings=error" 15222 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --graph=\"foo.tab.c\" foo.y --warnings=error" "output.at:158" 15223 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --graph="foo.tab.c" foo.y --warnings=error 15224 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15225 at_status=$? at_failed=false 15226 $at_check_filter 15227 $at_diff experr "$at_stderr" || at_failed=: 15228 $at_diff expout "$at_stdout" || at_failed=: 15229 at_fn_check_status 1 $at_status "$at_srcdir/output.at:158" 15230 $at_failed && at_fn_log_failure 15231 $at_traceon; } 15232 15233 15234 # Now check -Wnone and --warnings=none by making sure that 15235 # -Werror doesn't change the exit status when -Wnone or 15236 # --warnings=none is specified. 15237 { set +x 15238 $as_echo "$at_srcdir/output.at:158: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --graph=\"foo.tab.c\" foo.y -Wnone -Werror" 15239 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --graph=\"foo.tab.c\" foo.y -Wnone -Werror" "output.at:158" 15240 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --graph="foo.tab.c" foo.y -Wnone -Werror 15241 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15242 at_status=$? at_failed=false 15243 $at_check_filter 15244 at_fn_diff_devnull "$at_stderr" || at_failed=: 15245 $at_diff expout "$at_stdout" || at_failed=: 15246 at_fn_check_status 0 $at_status "$at_srcdir/output.at:158" 15247 $at_failed && at_fn_log_failure 15248 $at_traceon; } 15249 15250 { set +x 15251 $as_echo "$at_srcdir/output.at:158: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --graph=\"foo.tab.c\" foo.y --warnings=none -Werror" 15252 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --graph=\"foo.tab.c\" foo.y --warnings=none -Werror" "output.at:158" 15253 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --graph="foo.tab.c" foo.y --warnings=none -Werror 15254 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15255 at_status=$? at_failed=false 15256 $at_check_filter 15257 at_fn_diff_devnull "$at_stderr" || at_failed=: 15258 $at_diff expout "$at_stdout" || at_failed=: 15259 at_fn_check_status 0 $at_status "$at_srcdir/output.at:158" 15260 $at_failed && at_fn_log_failure 15261 $at_traceon; } 15262 15263 15264 at_restore_special_files 15265 fi 15266 { set +x 15267 $as_echo "$at_srcdir/output.at:158: cat foo.y" 15268 at_fn_check_prepare_trace "output.at:158" 15269 ( $at_check_trace; cat foo.y 15270 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15271 at_status=$? at_failed=false 15272 $at_check_filter 15273 at_fn_diff_devnull "$at_stderr" || at_failed=: 15274 $at_diff expout "$at_stdout" || at_failed=: 15275 at_fn_check_status 0 $at_status "$at_srcdir/output.at:158" 15276 $at_failed && at_fn_log_failure 15277 $at_traceon; } 15278 15279 set +x 15280 $at_times_p && times >"$at_times_file" 15281 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 15282 read at_status <"$at_status_file" 15283 #AT_STOP_73 15284 #AT_START_74 15285 at_fn_group_banner 74 'output.at:163' \ 15286 "Conflicting output files: %defines \"foo.output\" -v" "" 3 15287 at_xfail=no 15288 ( 15289 $as_echo "74. $at_setup_line: testing $at_desc ..." 15290 $at_traceon 15291 15292 case "foo.y" in 15293 */*) mkdir `echo "foo.y" | sed 's,/.*,,'`;; 15294 esac 15295 cat >foo.y <<'_ATEOF' 15296 %defines "foo.output" 15297 %% 15298 foo: {}; 15299 _ATEOF 15300 15301 15302 cp foo.y expout 15303 # Because an output file name conflict is still a warning, Bison exits 15304 # with status 0, so AT_BISON_CHECK does not realize that there may be no 15305 # output file against which to check the XML. AT_BISON_CHECK_NO_XML 15306 # avoids that problem. 15307 { set +x 15308 $as_echo "$at_srcdir/output.at:163: bison -v foo.y" 15309 at_fn_check_prepare_trace "output.at:163" 15310 ( $at_check_trace; bison -v foo.y 15311 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15312 at_status=$? at_failed=false 15313 $at_check_filter 15314 echo >>"$at_stderr"; $as_echo "foo.y: warning: conflicting outputs to file 'foo.output' 15315 " | \ 15316 $at_diff - "$at_stderr" || at_failed=: 15317 at_fn_diff_devnull "$at_stdout" || at_failed=: 15318 at_fn_check_status 0 $at_status "$at_srcdir/output.at:163" 15319 $at_failed && at_fn_log_failure 15320 $at_traceon; } 15321 15322 # Defining POSIXLY_CORRECT causes bison to complain if options are 15323 # added after the grammar file name, so skip these checks in that 15324 # case. 15325 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 15326 at_save_special_files 15327 15328 # To avoid expanding it repeatedly, store specified stdout. 15329 : >expout 15330 15331 # Run with -Werror. 15332 { set +x 15333 $as_echo "$at_srcdir/output.at:163: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -v foo.y -Werror" 15334 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -v foo.y -Werror" "output.at:163" 15335 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -v foo.y -Werror 15336 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15337 at_status=$? at_failed=false 15338 $at_check_filter 15339 echo stderr:; tee stderr <"$at_stderr" 15340 $at_diff expout "$at_stdout" || at_failed=: 15341 at_fn_check_status 1 $at_status "$at_srcdir/output.at:163" 15342 $at_failed && at_fn_log_failure 15343 $at_traceon; } 15344 15345 15346 # Build expected stderr up to and including the "warnings being 15347 # treated as errors" message. 15348 cat >at-bison-check-warnings <<'_ATEOF' 15349 foo.y: warning: conflicting outputs to file 'foo.output' 15350 _ATEOF 15351 15352 at_bison_check_first=`sed -n \ 15353 '/: warning: /{=;q;}' at-bison-check-warnings` 15354 : ${at_bison_check_first:=1} 15355 at_bison_check_first_tmp=`sed -n \ 15356 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 15357 : ${at_bison_check_first_tmp:=1} 15358 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 15359 at_bison_check_first=$at_bison_check_first_tmp 15360 fi 15361 if test $at_bison_check_first -gt 1; then 15362 sed -n "1,`expr $at_bison_check_first - 1`"p \ 15363 at-bison-check-warnings > experr 15364 fi 15365 echo 'bison: warnings being treated as errors' >> experr 15366 15367 # Finish building expected stderr and check. Unlike warnings, 15368 # complaints cause bison to exit early. Thus, with -Werror, bison 15369 # does not necessarily report all warnings that it does without 15370 # -Werror, but it at least reports one. 15371 at_bison_check_last=`sed -n '$=' stderr` 15372 : ${at_bison_check_last:=1} 15373 at_bison_check_last=`expr $at_bison_check_last - 1` 15374 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 15375 at-bison-check-warnings >> experr 15376 { set +x 15377 $as_echo "$at_srcdir/output.at:163: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 15378 stderr 1>&2" 15379 at_fn_check_prepare_notrace 'an embedded newline' "output.at:163" 15380 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 15381 stderr 1>&2 15382 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15383 at_status=$? at_failed=false 15384 $at_check_filter 15385 $at_diff experr "$at_stderr" || at_failed=: 15386 at_fn_diff_devnull "$at_stdout" || at_failed=: 15387 at_fn_check_status 0 $at_status "$at_srcdir/output.at:163" 15388 $at_failed && at_fn_log_failure 15389 $at_traceon; } 15390 15391 15392 # Now check --warnings=error. 15393 cp stderr experr 15394 { set +x 15395 $as_echo "$at_srcdir/output.at:163: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -v foo.y --warnings=error" 15396 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -v foo.y --warnings=error" "output.at:163" 15397 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -v foo.y --warnings=error 15398 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15399 at_status=$? at_failed=false 15400 $at_check_filter 15401 $at_diff experr "$at_stderr" || at_failed=: 15402 $at_diff expout "$at_stdout" || at_failed=: 15403 at_fn_check_status 1 $at_status "$at_srcdir/output.at:163" 15404 $at_failed && at_fn_log_failure 15405 $at_traceon; } 15406 15407 15408 # Now check -Wnone and --warnings=none by making sure that 15409 # -Werror doesn't change the exit status when -Wnone or 15410 # --warnings=none is specified. 15411 { set +x 15412 $as_echo "$at_srcdir/output.at:163: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -v foo.y -Wnone -Werror" 15413 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -v foo.y -Wnone -Werror" "output.at:163" 15414 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -v foo.y -Wnone -Werror 15415 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15416 at_status=$? at_failed=false 15417 $at_check_filter 15418 at_fn_diff_devnull "$at_stderr" || at_failed=: 15419 $at_diff expout "$at_stdout" || at_failed=: 15420 at_fn_check_status 0 $at_status "$at_srcdir/output.at:163" 15421 $at_failed && at_fn_log_failure 15422 $at_traceon; } 15423 15424 { set +x 15425 $as_echo "$at_srcdir/output.at:163: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -v foo.y --warnings=none -Werror" 15426 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -v foo.y --warnings=none -Werror" "output.at:163" 15427 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -v foo.y --warnings=none -Werror 15428 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15429 at_status=$? at_failed=false 15430 $at_check_filter 15431 at_fn_diff_devnull "$at_stderr" || at_failed=: 15432 $at_diff expout "$at_stdout" || at_failed=: 15433 at_fn_check_status 0 $at_status "$at_srcdir/output.at:163" 15434 $at_failed && at_fn_log_failure 15435 $at_traceon; } 15436 15437 15438 at_restore_special_files 15439 fi 15440 { set +x 15441 $as_echo "$at_srcdir/output.at:163: cat foo.y" 15442 at_fn_check_prepare_trace "output.at:163" 15443 ( $at_check_trace; cat foo.y 15444 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15445 at_status=$? at_failed=false 15446 $at_check_filter 15447 at_fn_diff_devnull "$at_stderr" || at_failed=: 15448 $at_diff expout "$at_stdout" || at_failed=: 15449 at_fn_check_status 0 $at_status "$at_srcdir/output.at:163" 15450 $at_failed && at_fn_log_failure 15451 $at_traceon; } 15452 15453 set +x 15454 $at_times_p && times >"$at_times_file" 15455 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 15456 read at_status <"$at_status_file" 15457 #AT_STOP_74 15458 #AT_START_75 15459 at_fn_group_banner 75 'output.at:168' \ 15460 "Conflicting output files: %skeleton \"lalr1.cc\" %defines --graph=\"location.hh\"" "" 3 15461 at_xfail=no 15462 ( 15463 $as_echo "75. $at_setup_line: testing $at_desc ..." 15464 $at_traceon 15465 15466 case "foo.y" in 15467 */*) mkdir `echo "foo.y" | sed 's,/.*,,'`;; 15468 esac 15469 cat >foo.y <<'_ATEOF' 15470 %skeleton "lalr1.cc" %defines 15471 %% 15472 foo: {}; 15473 _ATEOF 15474 15475 15476 cp foo.y expout 15477 # Because an output file name conflict is still a warning, Bison exits 15478 # with status 0, so AT_BISON_CHECK does not realize that there may be no 15479 # output file against which to check the XML. AT_BISON_CHECK_NO_XML 15480 # avoids that problem. 15481 { set +x 15482 $as_echo "$at_srcdir/output.at:168: bison --graph=\"location.hh\" foo.y" 15483 at_fn_check_prepare_trace "output.at:168" 15484 ( $at_check_trace; bison --graph="location.hh" foo.y 15485 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15486 at_status=$? at_failed=false 15487 $at_check_filter 15488 echo >>"$at_stderr"; $as_echo "foo.y: warning: conflicting outputs to file 'location.hh' 15489 " | \ 15490 $at_diff - "$at_stderr" || at_failed=: 15491 at_fn_diff_devnull "$at_stdout" || at_failed=: 15492 at_fn_check_status 0 $at_status "$at_srcdir/output.at:168" 15493 $at_failed && at_fn_log_failure 15494 $at_traceon; } 15495 15496 # Defining POSIXLY_CORRECT causes bison to complain if options are 15497 # added after the grammar file name, so skip these checks in that 15498 # case. 15499 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 15500 at_save_special_files 15501 15502 # To avoid expanding it repeatedly, store specified stdout. 15503 : >expout 15504 15505 # Run with -Werror. 15506 { set +x 15507 $as_echo "$at_srcdir/output.at:168: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --graph=\"location.hh\" foo.y -Werror" 15508 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --graph=\"location.hh\" foo.y -Werror" "output.at:168" 15509 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --graph="location.hh" foo.y -Werror 15510 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15511 at_status=$? at_failed=false 15512 $at_check_filter 15513 echo stderr:; tee stderr <"$at_stderr" 15514 $at_diff expout "$at_stdout" || at_failed=: 15515 at_fn_check_status 1 $at_status "$at_srcdir/output.at:168" 15516 $at_failed && at_fn_log_failure 15517 $at_traceon; } 15518 15519 15520 # Build expected stderr up to and including the "warnings being 15521 # treated as errors" message. 15522 cat >at-bison-check-warnings <<'_ATEOF' 15523 foo.y: warning: conflicting outputs to file 'location.hh' 15524 _ATEOF 15525 15526 at_bison_check_first=`sed -n \ 15527 '/: warning: /{=;q;}' at-bison-check-warnings` 15528 : ${at_bison_check_first:=1} 15529 at_bison_check_first_tmp=`sed -n \ 15530 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 15531 : ${at_bison_check_first_tmp:=1} 15532 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 15533 at_bison_check_first=$at_bison_check_first_tmp 15534 fi 15535 if test $at_bison_check_first -gt 1; then 15536 sed -n "1,`expr $at_bison_check_first - 1`"p \ 15537 at-bison-check-warnings > experr 15538 fi 15539 echo 'bison: warnings being treated as errors' >> experr 15540 15541 # Finish building expected stderr and check. Unlike warnings, 15542 # complaints cause bison to exit early. Thus, with -Werror, bison 15543 # does not necessarily report all warnings that it does without 15544 # -Werror, but it at least reports one. 15545 at_bison_check_last=`sed -n '$=' stderr` 15546 : ${at_bison_check_last:=1} 15547 at_bison_check_last=`expr $at_bison_check_last - 1` 15548 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 15549 at-bison-check-warnings >> experr 15550 { set +x 15551 $as_echo "$at_srcdir/output.at:168: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 15552 stderr 1>&2" 15553 at_fn_check_prepare_notrace 'an embedded newline' "output.at:168" 15554 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 15555 stderr 1>&2 15556 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15557 at_status=$? at_failed=false 15558 $at_check_filter 15559 $at_diff experr "$at_stderr" || at_failed=: 15560 at_fn_diff_devnull "$at_stdout" || at_failed=: 15561 at_fn_check_status 0 $at_status "$at_srcdir/output.at:168" 15562 $at_failed && at_fn_log_failure 15563 $at_traceon; } 15564 15565 15566 # Now check --warnings=error. 15567 cp stderr experr 15568 { set +x 15569 $as_echo "$at_srcdir/output.at:168: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --graph=\"location.hh\" foo.y --warnings=error" 15570 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --graph=\"location.hh\" foo.y --warnings=error" "output.at:168" 15571 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --graph="location.hh" foo.y --warnings=error 15572 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15573 at_status=$? at_failed=false 15574 $at_check_filter 15575 $at_diff experr "$at_stderr" || at_failed=: 15576 $at_diff expout "$at_stdout" || at_failed=: 15577 at_fn_check_status 1 $at_status "$at_srcdir/output.at:168" 15578 $at_failed && at_fn_log_failure 15579 $at_traceon; } 15580 15581 15582 # Now check -Wnone and --warnings=none by making sure that 15583 # -Werror doesn't change the exit status when -Wnone or 15584 # --warnings=none is specified. 15585 { set +x 15586 $as_echo "$at_srcdir/output.at:168: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --graph=\"location.hh\" foo.y -Wnone -Werror" 15587 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --graph=\"location.hh\" foo.y -Wnone -Werror" "output.at:168" 15588 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --graph="location.hh" foo.y -Wnone -Werror 15589 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15590 at_status=$? at_failed=false 15591 $at_check_filter 15592 at_fn_diff_devnull "$at_stderr" || at_failed=: 15593 $at_diff expout "$at_stdout" || at_failed=: 15594 at_fn_check_status 0 $at_status "$at_srcdir/output.at:168" 15595 $at_failed && at_fn_log_failure 15596 $at_traceon; } 15597 15598 { set +x 15599 $as_echo "$at_srcdir/output.at:168: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --graph=\"location.hh\" foo.y --warnings=none -Werror" 15600 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --graph=\"location.hh\" foo.y --warnings=none -Werror" "output.at:168" 15601 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --graph="location.hh" foo.y --warnings=none -Werror 15602 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15603 at_status=$? at_failed=false 15604 $at_check_filter 15605 at_fn_diff_devnull "$at_stderr" || at_failed=: 15606 $at_diff expout "$at_stdout" || at_failed=: 15607 at_fn_check_status 0 $at_status "$at_srcdir/output.at:168" 15608 $at_failed && at_fn_log_failure 15609 $at_traceon; } 15610 15611 15612 at_restore_special_files 15613 fi 15614 { set +x 15615 $as_echo "$at_srcdir/output.at:168: cat foo.y" 15616 at_fn_check_prepare_trace "output.at:168" 15617 ( $at_check_trace; cat foo.y 15618 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15619 at_status=$? at_failed=false 15620 $at_check_filter 15621 at_fn_diff_devnull "$at_stderr" || at_failed=: 15622 $at_diff expout "$at_stdout" || at_failed=: 15623 at_fn_check_status 0 $at_status "$at_srcdir/output.at:168" 15624 $at_failed && at_fn_log_failure 15625 $at_traceon; } 15626 15627 set +x 15628 $at_times_p && times >"$at_times_file" 15629 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 15630 read at_status <"$at_status_file" 15631 #AT_STOP_75 15632 #AT_START_76 15633 at_fn_group_banner 76 'output.at:173' \ 15634 "Conflicting output files: -o foo.y" " " 3 15635 at_xfail=no 15636 ( 15637 $as_echo "76. $at_setup_line: testing $at_desc ..." 15638 $at_traceon 15639 15640 case "foo.y" in 15641 */*) mkdir `echo "foo.y" | sed 's,/.*,,'`;; 15642 esac 15643 cat >foo.y <<'_ATEOF' 15644 15645 %% 15646 foo: {}; 15647 _ATEOF 15648 15649 15650 cp foo.y expout 15651 # Because an output file name conflict is still a warning, Bison exits 15652 # with status 0, so AT_BISON_CHECK does not realize that there may be no 15653 # output file against which to check the XML. AT_BISON_CHECK_NO_XML 15654 # avoids that problem. 15655 { set +x 15656 $as_echo "$at_srcdir/output.at:173: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o foo.y foo.y" 15657 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -o foo.y foo.y" "output.at:173" 15658 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -o foo.y foo.y 15659 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15660 at_status=$? at_failed=false 15661 $at_check_filter 15662 echo >>"$at_stderr"; $as_echo "foo.y: error: refusing to overwrite the input file 'foo.y' 15663 " | \ 15664 $at_diff - "$at_stderr" || at_failed=: 15665 at_fn_diff_devnull "$at_stdout" || at_failed=: 15666 at_fn_check_status 1 $at_status "$at_srcdir/output.at:173" 15667 $at_failed && at_fn_log_failure 15668 $at_traceon; } 15669 15670 15671 { set +x 15672 $as_echo "$at_srcdir/output.at:173: cat foo.y" 15673 at_fn_check_prepare_trace "output.at:173" 15674 ( $at_check_trace; cat foo.y 15675 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15676 at_status=$? at_failed=false 15677 $at_check_filter 15678 at_fn_diff_devnull "$at_stderr" || at_failed=: 15679 $at_diff expout "$at_stdout" || at_failed=: 15680 at_fn_check_status 0 $at_status "$at_srcdir/output.at:173" 15681 $at_failed && at_fn_log_failure 15682 $at_traceon; } 15683 15684 set +x 15685 $at_times_p && times >"$at_times_file" 15686 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 15687 read at_status <"$at_status_file" 15688 #AT_STOP_76 15689 #AT_START_77 15690 at_fn_group_banner 77 'output.at:219' \ 15691 "Output file name: \`~!@#\$%^&*()-=_+{}[]|\\:;<>, .'" "" 3 15692 at_xfail=no 15693 ( 15694 $as_echo "77. $at_setup_line: testing $at_desc ..." 15695 $at_traceon 15696 15697 15698 15699 # Skip if platform doesn't support file name. For example, Cygwin 15700 # doesn't support file names containing ":" or "\". 15701 { set +x 15702 $as_echo "$at_srcdir/output.at:219: touch \"\\\`~!@#\\\$%^&*()-=_+{}[]|\\\\:;<>, .'.tmp\" || exit 77" 15703 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:219" 15704 ( $at_check_trace; touch "\`~!@#\$%^&*()-=_+{}[]|\\:;<>, .'.tmp" || exit 77 15705 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15706 at_status=$? at_failed=false 15707 $at_check_filter 15708 at_fn_diff_devnull "$at_stderr" || at_failed=: 15709 at_fn_diff_devnull "$at_stdout" || at_failed=: 15710 at_fn_check_status 0 $at_status "$at_srcdir/output.at:219" 15711 $at_failed && at_fn_log_failure 15712 $at_traceon; } 15713 15714 15715 cat >glr.y <<'_ATEOF' 15716 %code top { 15717 #include <config.h> 15718 /* We don't need perfect functions for these tests. */ 15719 #undef malloc 15720 #undef memcmp 15721 #undef realloc 15722 } 15723 15724 %glr-parser 15725 %code { 15726 void yyerror ( const char *msg); 15727 int yylex (void); 15728 } 15729 %% 15730 start: {}; 15731 _ATEOF 15732 15733 15734 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 15735 at_save_special_files 15736 mkdir xml-tests 15737 # Don't combine these Bison invocations since we want to be sure that 15738 # --report=all isn't required to get the full XML file. 15739 { set +x 15740 $as_echo "$at_srcdir/output.at:219: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 15741 --graph=xml-tests/test.dot -o \"\\\`~!@#\\\$%^&*()-=_+{}[]|\\\\:;<>, .'.c\" --defines=\"\\\`~!@#\\\$%^&*()-=_+{}[]|\\\\:;<>, .'.h\" glr.y" 15742 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:219" 15743 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 15744 --graph=xml-tests/test.dot -o "\`~!@#\$%^&*()-=_+{}[]|\\:;<>, .'.c" --defines="\`~!@#\$%^&*()-=_+{}[]|\\:;<>, .'.h" glr.y 15745 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15746 at_status=$? at_failed=false 15747 $at_check_filter 15748 echo stderr:; cat "$at_stderr" 15749 echo stdout:; cat "$at_stdout" 15750 at_fn_check_status 0 $at_status "$at_srcdir/output.at:219" 15751 $at_failed && at_fn_log_failure 15752 $at_traceon; } 15753 15754 { set +x 15755 $as_echo "$at_srcdir/output.at:219: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o \"\\\`~!@#\\\$%^&*()-=_+{}[]|\\\\:;<>, .'.c\" --defines=\"\\\`~!@#\\\$%^&*()-=_+{}[]|\\\\:;<>, .'.h\" glr.y" 15756 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:219" 15757 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o "\`~!@#\$%^&*()-=_+{}[]|\\:;<>, .'.c" --defines="\`~!@#\$%^&*()-=_+{}[]|\\:;<>, .'.h" glr.y 15758 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15759 at_status=$? at_failed=false 15760 $at_check_filter 15761 echo stderr:; cat "$at_stderr" 15762 echo stdout:; cat "$at_stdout" 15763 at_fn_check_status 0 $at_status "$at_srcdir/output.at:219" 15764 $at_failed && at_fn_log_failure 15765 $at_traceon; } 15766 15767 cp xml-tests/test.output expout 15768 { set +x 15769 $as_echo "$at_srcdir/output.at:219: \$XSLTPROC \\ 15770 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 15771 xml-tests/test.xml" 15772 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:219" 15773 ( $at_check_trace; $XSLTPROC \ 15774 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 15775 xml-tests/test.xml 15776 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15777 at_status=$? at_failed=false 15778 $at_check_filter 15779 at_fn_diff_devnull "$at_stderr" || at_failed=: 15780 $at_diff expout "$at_stdout" || at_failed=: 15781 at_fn_check_status 0 $at_status "$at_srcdir/output.at:219" 15782 $at_failed && at_fn_log_failure 15783 $at_traceon; } 15784 15785 sort xml-tests/test.dot > expout 15786 { set +x 15787 $as_echo "$at_srcdir/output.at:219: \$XSLTPROC \\ 15788 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 15789 xml-tests/test.xml | sort" 15790 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:219" 15791 ( $at_check_trace; $XSLTPROC \ 15792 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 15793 xml-tests/test.xml | sort 15794 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15795 at_status=$? at_failed=false 15796 $at_check_filter 15797 at_fn_diff_devnull "$at_stderr" || at_failed=: 15798 $at_diff expout "$at_stdout" || at_failed=: 15799 at_fn_check_status 0 $at_status "$at_srcdir/output.at:219" 15800 $at_failed && at_fn_log_failure 15801 $at_traceon; } 15802 15803 rm -rf xml-tests expout 15804 at_restore_special_files 15805 fi 15806 { set +x 15807 $as_echo "$at_srcdir/output.at:219: bison -o \"\\\`~!@#\\\$%^&*()-=_+{}[]|\\\\:;<>, .'.c\" --defines=\"\\\`~!@#\\\$%^&*()-=_+{}[]|\\\\:;<>, .'.h\" glr.y" 15808 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:219" 15809 ( $at_check_trace; bison -o "\`~!@#\$%^&*()-=_+{}[]|\\:;<>, .'.c" --defines="\`~!@#\$%^&*()-=_+{}[]|\\:;<>, .'.h" glr.y 15810 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15811 at_status=$? at_failed=false 15812 $at_check_filter 15813 at_fn_diff_devnull "$at_stderr" || at_failed=: 15814 at_fn_diff_devnull "$at_stdout" || at_failed=: 15815 at_fn_check_status 0 $at_status "$at_srcdir/output.at:219" 15816 $at_failed && at_fn_log_failure 15817 $at_traceon; } 15818 15819 15820 { set +x 15821 $as_echo "$at_srcdir/output.at:219: ls \"\\\`~!@#\\\$%^&*()-=_+{}[]|\\\\:;<>, .'.c\" \"\\\`~!@#\\\$%^&*()-=_+{}[]|\\\\:;<>, .'.h\"" 15822 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:219" 15823 ( $at_check_trace; ls "\`~!@#\$%^&*()-=_+{}[]|\\:;<>, .'.c" "\`~!@#\$%^&*()-=_+{}[]|\\:;<>, .'.h" 15824 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15825 at_status=$? at_failed=false 15826 $at_check_filter 15827 at_fn_diff_devnull "$at_stderr" || at_failed=: 15828 echo stdout:; cat "$at_stdout" 15829 at_fn_check_status 0 $at_status "$at_srcdir/output.at:219" 15830 $at_failed && at_fn_log_failure 15831 $at_traceon; } 15832 15833 { set +x 15834 $as_echo "$at_srcdir/output.at:219: \$BISON_C_WORKS" 15835 at_fn_check_prepare_dynamic "$BISON_C_WORKS" "output.at:219" 15836 ( $at_check_trace; $BISON_C_WORKS 15837 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15838 at_status=$? at_failed=false 15839 $at_check_filter 15840 echo stderr:; cat "$at_stderr" 15841 echo stdout:; cat "$at_stdout" 15842 at_fn_check_status 0 $at_status "$at_srcdir/output.at:219" 15843 $at_failed && at_fn_log_failure 15844 $at_traceon; } 15845 15846 { set +x 15847 $as_echo "$at_srcdir/output.at:219: \$CC \$CFLAGS \$CPPFLAGS -c -o glr.o -c \"\\\`~!@#\\\$%^&*()-=_+{}[]|\\\\:;<>, .'.c\" " 15848 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:219" 15849 ( $at_check_trace; $CC $CFLAGS $CPPFLAGS -c -o glr.o -c "\`~!@#\$%^&*()-=_+{}[]|\\:;<>, .'.c" 15850 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15851 at_status=$? at_failed=false 15852 $at_check_filter 15853 echo stderr:; cat "$at_stderr" 15854 echo stdout:; cat "$at_stdout" 15855 at_fn_check_status 0 $at_status "$at_srcdir/output.at:219" 15856 $at_failed && at_fn_log_failure 15857 $at_traceon; } 15858 15859 15860 15861 cat >cxx.y <<'_ATEOF' 15862 %code top { 15863 #include <config.h> 15864 /* We don't need perfect functions for these tests. */ 15865 #undef malloc 15866 #undef memcmp 15867 #undef realloc 15868 } 15869 15870 %skeleton "lalr1.cc" 15871 %code { int yylex (yy::parser::semantic_type*); } 15872 %% 15873 start: {}; 15874 _ATEOF 15875 15876 15877 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 15878 at_save_special_files 15879 mkdir xml-tests 15880 # Don't combine these Bison invocations since we want to be sure that 15881 # --report=all isn't required to get the full XML file. 15882 { set +x 15883 $as_echo "$at_srcdir/output.at:219: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 15884 --graph=xml-tests/test.dot -o \"\\\`~!@#\\\$%^&*()-=_+{}[]|\\\\:;<>, .'.c\" --defines=\"\\\`~!@#\\\$%^&*()-=_+{}[]|\\\\:;<>, .'.h\" cxx.y" 15885 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:219" 15886 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 15887 --graph=xml-tests/test.dot -o "\`~!@#\$%^&*()-=_+{}[]|\\:;<>, .'.c" --defines="\`~!@#\$%^&*()-=_+{}[]|\\:;<>, .'.h" cxx.y 15888 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15889 at_status=$? at_failed=false 15890 $at_check_filter 15891 echo stderr:; cat "$at_stderr" 15892 echo stdout:; cat "$at_stdout" 15893 at_fn_check_status 0 $at_status "$at_srcdir/output.at:219" 15894 $at_failed && at_fn_log_failure 15895 $at_traceon; } 15896 15897 { set +x 15898 $as_echo "$at_srcdir/output.at:219: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o \"\\\`~!@#\\\$%^&*()-=_+{}[]|\\\\:;<>, .'.c\" --defines=\"\\\`~!@#\\\$%^&*()-=_+{}[]|\\\\:;<>, .'.h\" cxx.y" 15899 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:219" 15900 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o "\`~!@#\$%^&*()-=_+{}[]|\\:;<>, .'.c" --defines="\`~!@#\$%^&*()-=_+{}[]|\\:;<>, .'.h" cxx.y 15901 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15902 at_status=$? at_failed=false 15903 $at_check_filter 15904 echo stderr:; cat "$at_stderr" 15905 echo stdout:; cat "$at_stdout" 15906 at_fn_check_status 0 $at_status "$at_srcdir/output.at:219" 15907 $at_failed && at_fn_log_failure 15908 $at_traceon; } 15909 15910 cp xml-tests/test.output expout 15911 { set +x 15912 $as_echo "$at_srcdir/output.at:219: \$XSLTPROC \\ 15913 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 15914 xml-tests/test.xml" 15915 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:219" 15916 ( $at_check_trace; $XSLTPROC \ 15917 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 15918 xml-tests/test.xml 15919 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15920 at_status=$? at_failed=false 15921 $at_check_filter 15922 at_fn_diff_devnull "$at_stderr" || at_failed=: 15923 $at_diff expout "$at_stdout" || at_failed=: 15924 at_fn_check_status 0 $at_status "$at_srcdir/output.at:219" 15925 $at_failed && at_fn_log_failure 15926 $at_traceon; } 15927 15928 sort xml-tests/test.dot > expout 15929 { set +x 15930 $as_echo "$at_srcdir/output.at:219: \$XSLTPROC \\ 15931 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 15932 xml-tests/test.xml | sort" 15933 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:219" 15934 ( $at_check_trace; $XSLTPROC \ 15935 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 15936 xml-tests/test.xml | sort 15937 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15938 at_status=$? at_failed=false 15939 $at_check_filter 15940 at_fn_diff_devnull "$at_stderr" || at_failed=: 15941 $at_diff expout "$at_stdout" || at_failed=: 15942 at_fn_check_status 0 $at_status "$at_srcdir/output.at:219" 15943 $at_failed && at_fn_log_failure 15944 $at_traceon; } 15945 15946 rm -rf xml-tests expout 15947 at_restore_special_files 15948 fi 15949 { set +x 15950 $as_echo "$at_srcdir/output.at:219: bison -o \"\\\`~!@#\\\$%^&*()-=_+{}[]|\\\\:;<>, .'.c\" --defines=\"\\\`~!@#\\\$%^&*()-=_+{}[]|\\\\:;<>, .'.h\" cxx.y" 15951 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:219" 15952 ( $at_check_trace; bison -o "\`~!@#\$%^&*()-=_+{}[]|\\:;<>, .'.c" --defines="\`~!@#\$%^&*()-=_+{}[]|\\:;<>, .'.h" cxx.y 15953 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15954 at_status=$? at_failed=false 15955 $at_check_filter 15956 at_fn_diff_devnull "$at_stderr" || at_failed=: 15957 at_fn_diff_devnull "$at_stdout" || at_failed=: 15958 at_fn_check_status 0 $at_status "$at_srcdir/output.at:219" 15959 $at_failed && at_fn_log_failure 15960 $at_traceon; } 15961 15962 15963 { set +x 15964 $as_echo "$at_srcdir/output.at:219: ls \"\\\`~!@#\\\$%^&*()-=_+{}[]|\\\\:;<>, .'.c\" \"\\\`~!@#\\\$%^&*()-=_+{}[]|\\\\:;<>, .'.h\"" 15965 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:219" 15966 ( $at_check_trace; ls "\`~!@#\$%^&*()-=_+{}[]|\\:;<>, .'.c" "\`~!@#\$%^&*()-=_+{}[]|\\:;<>, .'.h" 15967 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15968 at_status=$? at_failed=false 15969 $at_check_filter 15970 at_fn_diff_devnull "$at_stderr" || at_failed=: 15971 echo stdout:; cat "$at_stdout" 15972 at_fn_check_status 0 $at_status "$at_srcdir/output.at:219" 15973 $at_failed && at_fn_log_failure 15974 $at_traceon; } 15975 15976 15977 { set +x 15978 $as_echo "$at_srcdir/output.at:219: \$BISON_CXX_WORKS" 15979 at_fn_check_prepare_dynamic "$BISON_CXX_WORKS" "output.at:219" 15980 ( $at_check_trace; $BISON_CXX_WORKS 15981 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15982 at_status=$? at_failed=false 15983 $at_check_filter 15984 echo stderr:; cat "$at_stderr" 15985 echo stdout:; cat "$at_stdout" 15986 at_fn_check_status 0 $at_status "$at_srcdir/output.at:219" 15987 $at_failed && at_fn_log_failure 15988 $at_traceon; } 15989 15990 { set +x 15991 $as_echo "$at_srcdir/output.at:219: \$CXX \$CXXFLAGS \$CPPFLAGS -c -o cxx.o -c \"\\\`~!@#\\\$%^&*()-=_+{}[]|\\\\:;<>, .'.c\" " 15992 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:219" 15993 ( $at_check_trace; $CXX $CXXFLAGS $CPPFLAGS -c -o cxx.o -c "\`~!@#\$%^&*()-=_+{}[]|\\:;<>, .'.c" 15994 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 15995 at_status=$? at_failed=false 15996 $at_check_filter 15997 echo stderr:; cat "$at_stderr" 15998 echo stdout:; cat "$at_stdout" 15999 at_fn_check_status 0 $at_status "$at_srcdir/output.at:219" 16000 $at_failed && at_fn_log_failure 16001 $at_traceon; } 16002 16003 16004 16005 16006 set +x 16007 $at_times_p && times >"$at_times_file" 16008 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 16009 read at_status <"$at_status_file" 16010 #AT_STOP_77 16011 #AT_START_78 16012 at_fn_group_banner 78 'output.at:226' \ 16013 "Output file name: (" " " 3 16014 at_xfail=no 16015 ( 16016 $as_echo "78. $at_setup_line: testing $at_desc ..." 16017 $at_traceon 16018 16019 16020 16021 # Skip if platform doesn't support file name. For example, Cygwin 16022 # doesn't support file names containing ":" or "\". 16023 { set +x 16024 $as_echo "$at_srcdir/output.at:226: touch \"(.tmp\" || exit 77" 16025 at_fn_check_prepare_trace "output.at:226" 16026 ( $at_check_trace; touch "(.tmp" || exit 77 16027 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16028 at_status=$? at_failed=false 16029 $at_check_filter 16030 at_fn_diff_devnull "$at_stderr" || at_failed=: 16031 at_fn_diff_devnull "$at_stdout" || at_failed=: 16032 at_fn_check_status 0 $at_status "$at_srcdir/output.at:226" 16033 $at_failed && at_fn_log_failure 16034 $at_traceon; } 16035 16036 16037 cat >glr.y <<'_ATEOF' 16038 %code top { 16039 #include <config.h> 16040 /* We don't need perfect functions for these tests. */ 16041 #undef malloc 16042 #undef memcmp 16043 #undef realloc 16044 } 16045 16046 %glr-parser 16047 %code { 16048 void yyerror ( const char *msg); 16049 int yylex (void); 16050 } 16051 %% 16052 start: {}; 16053 _ATEOF 16054 16055 16056 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 16057 at_save_special_files 16058 mkdir xml-tests 16059 # Don't combine these Bison invocations since we want to be sure that 16060 # --report=all isn't required to get the full XML file. 16061 { set +x 16062 $as_echo "$at_srcdir/output.at:226: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 16063 --graph=xml-tests/test.dot -o \"(.c\" --defines=\"(.h\" glr.y" 16064 at_fn_check_prepare_notrace 'an embedded newline' "output.at:226" 16065 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 16066 --graph=xml-tests/test.dot -o "(.c" --defines="(.h" glr.y 16067 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16068 at_status=$? at_failed=false 16069 $at_check_filter 16070 echo stderr:; cat "$at_stderr" 16071 echo stdout:; cat "$at_stdout" 16072 at_fn_check_status 0 $at_status "$at_srcdir/output.at:226" 16073 $at_failed && at_fn_log_failure 16074 $at_traceon; } 16075 16076 { set +x 16077 $as_echo "$at_srcdir/output.at:226: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o \"(.c\" --defines=\"(.h\" glr.y" 16078 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o \"(.c\" --defines=\"(.h\" glr.y" "output.at:226" 16079 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o "(.c" --defines="(.h" glr.y 16080 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16081 at_status=$? at_failed=false 16082 $at_check_filter 16083 echo stderr:; cat "$at_stderr" 16084 echo stdout:; cat "$at_stdout" 16085 at_fn_check_status 0 $at_status "$at_srcdir/output.at:226" 16086 $at_failed && at_fn_log_failure 16087 $at_traceon; } 16088 16089 cp xml-tests/test.output expout 16090 { set +x 16091 $as_echo "$at_srcdir/output.at:226: \$XSLTPROC \\ 16092 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 16093 xml-tests/test.xml" 16094 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:226" 16095 ( $at_check_trace; $XSLTPROC \ 16096 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 16097 xml-tests/test.xml 16098 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16099 at_status=$? at_failed=false 16100 $at_check_filter 16101 at_fn_diff_devnull "$at_stderr" || at_failed=: 16102 $at_diff expout "$at_stdout" || at_failed=: 16103 at_fn_check_status 0 $at_status "$at_srcdir/output.at:226" 16104 $at_failed && at_fn_log_failure 16105 $at_traceon; } 16106 16107 sort xml-tests/test.dot > expout 16108 { set +x 16109 $as_echo "$at_srcdir/output.at:226: \$XSLTPROC \\ 16110 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 16111 xml-tests/test.xml | sort" 16112 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:226" 16113 ( $at_check_trace; $XSLTPROC \ 16114 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 16115 xml-tests/test.xml | sort 16116 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16117 at_status=$? at_failed=false 16118 $at_check_filter 16119 at_fn_diff_devnull "$at_stderr" || at_failed=: 16120 $at_diff expout "$at_stdout" || at_failed=: 16121 at_fn_check_status 0 $at_status "$at_srcdir/output.at:226" 16122 $at_failed && at_fn_log_failure 16123 $at_traceon; } 16124 16125 rm -rf xml-tests expout 16126 at_restore_special_files 16127 fi 16128 { set +x 16129 $as_echo "$at_srcdir/output.at:226: bison -o \"(.c\" --defines=\"(.h\" glr.y" 16130 at_fn_check_prepare_trace "output.at:226" 16131 ( $at_check_trace; bison -o "(.c" --defines="(.h" glr.y 16132 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16133 at_status=$? at_failed=false 16134 $at_check_filter 16135 at_fn_diff_devnull "$at_stderr" || at_failed=: 16136 at_fn_diff_devnull "$at_stdout" || at_failed=: 16137 at_fn_check_status 0 $at_status "$at_srcdir/output.at:226" 16138 $at_failed && at_fn_log_failure 16139 $at_traceon; } 16140 16141 16142 { set +x 16143 $as_echo "$at_srcdir/output.at:226: ls \"(.c\" \"(.h\"" 16144 at_fn_check_prepare_trace "output.at:226" 16145 ( $at_check_trace; ls "(.c" "(.h" 16146 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16147 at_status=$? at_failed=false 16148 $at_check_filter 16149 at_fn_diff_devnull "$at_stderr" || at_failed=: 16150 echo stdout:; cat "$at_stdout" 16151 at_fn_check_status 0 $at_status "$at_srcdir/output.at:226" 16152 $at_failed && at_fn_log_failure 16153 $at_traceon; } 16154 16155 { set +x 16156 $as_echo "$at_srcdir/output.at:226: \$BISON_C_WORKS" 16157 at_fn_check_prepare_dynamic "$BISON_C_WORKS" "output.at:226" 16158 ( $at_check_trace; $BISON_C_WORKS 16159 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16160 at_status=$? at_failed=false 16161 $at_check_filter 16162 echo stderr:; cat "$at_stderr" 16163 echo stdout:; cat "$at_stdout" 16164 at_fn_check_status 0 $at_status "$at_srcdir/output.at:226" 16165 $at_failed && at_fn_log_failure 16166 $at_traceon; } 16167 16168 { set +x 16169 $as_echo "$at_srcdir/output.at:226: \$CC \$CFLAGS \$CPPFLAGS -c -o glr.o -c \"(.c\" " 16170 at_fn_check_prepare_dynamic "$CC $CFLAGS $CPPFLAGS -c -o glr.o -c \"(.c\" " "output.at:226" 16171 ( $at_check_trace; $CC $CFLAGS $CPPFLAGS -c -o glr.o -c "(.c" 16172 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16173 at_status=$? at_failed=false 16174 $at_check_filter 16175 echo stderr:; cat "$at_stderr" 16176 echo stdout:; cat "$at_stdout" 16177 at_fn_check_status 0 $at_status "$at_srcdir/output.at:226" 16178 $at_failed && at_fn_log_failure 16179 $at_traceon; } 16180 16181 16182 16183 cat >cxx.y <<'_ATEOF' 16184 %code top { 16185 #include <config.h> 16186 /* We don't need perfect functions for these tests. */ 16187 #undef malloc 16188 #undef memcmp 16189 #undef realloc 16190 } 16191 16192 %skeleton "lalr1.cc" 16193 %code { int yylex (yy::parser::semantic_type*); } 16194 %% 16195 start: {}; 16196 _ATEOF 16197 16198 16199 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 16200 at_save_special_files 16201 mkdir xml-tests 16202 # Don't combine these Bison invocations since we want to be sure that 16203 # --report=all isn't required to get the full XML file. 16204 { set +x 16205 $as_echo "$at_srcdir/output.at:226: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 16206 --graph=xml-tests/test.dot -o \"(.c\" --defines=\"(.h\" cxx.y" 16207 at_fn_check_prepare_notrace 'an embedded newline' "output.at:226" 16208 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 16209 --graph=xml-tests/test.dot -o "(.c" --defines="(.h" cxx.y 16210 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16211 at_status=$? at_failed=false 16212 $at_check_filter 16213 echo stderr:; cat "$at_stderr" 16214 echo stdout:; cat "$at_stdout" 16215 at_fn_check_status 0 $at_status "$at_srcdir/output.at:226" 16216 $at_failed && at_fn_log_failure 16217 $at_traceon; } 16218 16219 { set +x 16220 $as_echo "$at_srcdir/output.at:226: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o \"(.c\" --defines=\"(.h\" cxx.y" 16221 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o \"(.c\" --defines=\"(.h\" cxx.y" "output.at:226" 16222 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o "(.c" --defines="(.h" cxx.y 16223 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16224 at_status=$? at_failed=false 16225 $at_check_filter 16226 echo stderr:; cat "$at_stderr" 16227 echo stdout:; cat "$at_stdout" 16228 at_fn_check_status 0 $at_status "$at_srcdir/output.at:226" 16229 $at_failed && at_fn_log_failure 16230 $at_traceon; } 16231 16232 cp xml-tests/test.output expout 16233 { set +x 16234 $as_echo "$at_srcdir/output.at:226: \$XSLTPROC \\ 16235 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 16236 xml-tests/test.xml" 16237 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:226" 16238 ( $at_check_trace; $XSLTPROC \ 16239 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 16240 xml-tests/test.xml 16241 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16242 at_status=$? at_failed=false 16243 $at_check_filter 16244 at_fn_diff_devnull "$at_stderr" || at_failed=: 16245 $at_diff expout "$at_stdout" || at_failed=: 16246 at_fn_check_status 0 $at_status "$at_srcdir/output.at:226" 16247 $at_failed && at_fn_log_failure 16248 $at_traceon; } 16249 16250 sort xml-tests/test.dot > expout 16251 { set +x 16252 $as_echo "$at_srcdir/output.at:226: \$XSLTPROC \\ 16253 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 16254 xml-tests/test.xml | sort" 16255 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:226" 16256 ( $at_check_trace; $XSLTPROC \ 16257 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 16258 xml-tests/test.xml | sort 16259 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16260 at_status=$? at_failed=false 16261 $at_check_filter 16262 at_fn_diff_devnull "$at_stderr" || at_failed=: 16263 $at_diff expout "$at_stdout" || at_failed=: 16264 at_fn_check_status 0 $at_status "$at_srcdir/output.at:226" 16265 $at_failed && at_fn_log_failure 16266 $at_traceon; } 16267 16268 rm -rf xml-tests expout 16269 at_restore_special_files 16270 fi 16271 { set +x 16272 $as_echo "$at_srcdir/output.at:226: bison -o \"(.c\" --defines=\"(.h\" cxx.y" 16273 at_fn_check_prepare_trace "output.at:226" 16274 ( $at_check_trace; bison -o "(.c" --defines="(.h" cxx.y 16275 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16276 at_status=$? at_failed=false 16277 $at_check_filter 16278 at_fn_diff_devnull "$at_stderr" || at_failed=: 16279 at_fn_diff_devnull "$at_stdout" || at_failed=: 16280 at_fn_check_status 0 $at_status "$at_srcdir/output.at:226" 16281 $at_failed && at_fn_log_failure 16282 $at_traceon; } 16283 16284 16285 { set +x 16286 $as_echo "$at_srcdir/output.at:226: ls \"(.c\" \"(.h\"" 16287 at_fn_check_prepare_trace "output.at:226" 16288 ( $at_check_trace; ls "(.c" "(.h" 16289 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16290 at_status=$? at_failed=false 16291 $at_check_filter 16292 at_fn_diff_devnull "$at_stderr" || at_failed=: 16293 echo stdout:; cat "$at_stdout" 16294 at_fn_check_status 0 $at_status "$at_srcdir/output.at:226" 16295 $at_failed && at_fn_log_failure 16296 $at_traceon; } 16297 16298 16299 { set +x 16300 $as_echo "$at_srcdir/output.at:226: \$BISON_CXX_WORKS" 16301 at_fn_check_prepare_dynamic "$BISON_CXX_WORKS" "output.at:226" 16302 ( $at_check_trace; $BISON_CXX_WORKS 16303 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16304 at_status=$? at_failed=false 16305 $at_check_filter 16306 echo stderr:; cat "$at_stderr" 16307 echo stdout:; cat "$at_stdout" 16308 at_fn_check_status 0 $at_status "$at_srcdir/output.at:226" 16309 $at_failed && at_fn_log_failure 16310 $at_traceon; } 16311 16312 { set +x 16313 $as_echo "$at_srcdir/output.at:226: \$CXX \$CXXFLAGS \$CPPFLAGS -c -o cxx.o -c \"(.c\" " 16314 at_fn_check_prepare_dynamic "$CXX $CXXFLAGS $CPPFLAGS -c -o cxx.o -c \"(.c\" " "output.at:226" 16315 ( $at_check_trace; $CXX $CXXFLAGS $CPPFLAGS -c -o cxx.o -c "(.c" 16316 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16317 at_status=$? at_failed=false 16318 $at_check_filter 16319 echo stderr:; cat "$at_stderr" 16320 echo stdout:; cat "$at_stdout" 16321 at_fn_check_status 0 $at_status "$at_srcdir/output.at:226" 16322 $at_failed && at_fn_log_failure 16323 $at_traceon; } 16324 16325 16326 16327 16328 set +x 16329 $at_times_p && times >"$at_times_file" 16330 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 16331 read at_status <"$at_status_file" 16332 #AT_STOP_78 16333 #AT_START_79 16334 at_fn_group_banner 79 'output.at:227' \ 16335 "Output file name: )" " " 3 16336 at_xfail=no 16337 ( 16338 $as_echo "79. $at_setup_line: testing $at_desc ..." 16339 $at_traceon 16340 16341 16342 16343 # Skip if platform doesn't support file name. For example, Cygwin 16344 # doesn't support file names containing ":" or "\". 16345 { set +x 16346 $as_echo "$at_srcdir/output.at:227: touch \").tmp\" || exit 77" 16347 at_fn_check_prepare_trace "output.at:227" 16348 ( $at_check_trace; touch ").tmp" || exit 77 16349 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16350 at_status=$? at_failed=false 16351 $at_check_filter 16352 at_fn_diff_devnull "$at_stderr" || at_failed=: 16353 at_fn_diff_devnull "$at_stdout" || at_failed=: 16354 at_fn_check_status 0 $at_status "$at_srcdir/output.at:227" 16355 $at_failed && at_fn_log_failure 16356 $at_traceon; } 16357 16358 16359 cat >glr.y <<'_ATEOF' 16360 %code top { 16361 #include <config.h> 16362 /* We don't need perfect functions for these tests. */ 16363 #undef malloc 16364 #undef memcmp 16365 #undef realloc 16366 } 16367 16368 %glr-parser 16369 %code { 16370 void yyerror ( const char *msg); 16371 int yylex (void); 16372 } 16373 %% 16374 start: {}; 16375 _ATEOF 16376 16377 16378 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 16379 at_save_special_files 16380 mkdir xml-tests 16381 # Don't combine these Bison invocations since we want to be sure that 16382 # --report=all isn't required to get the full XML file. 16383 { set +x 16384 $as_echo "$at_srcdir/output.at:227: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 16385 --graph=xml-tests/test.dot -o \").c\" --defines=\").h\" glr.y" 16386 at_fn_check_prepare_notrace 'an embedded newline' "output.at:227" 16387 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \ 16388 --graph=xml-tests/test.dot -o ").c" --defines=").h" glr.y 16389 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16390 at_status=$? at_failed=false 16391 $at_check_filter 16392 echo stderr:; cat "$at_stderr" 16393 echo stdout:; cat "$at_stdout" 16394 at_fn_check_status 0 $at_status "$at_srcdir/output.at:227" 16395 $at_failed && at_fn_log_failure 16396 $at_traceon; } 16397 16398 { set +x 16399 $as_echo "$at_srcdir/output.at:227: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o \").c\" --defines=\").h\" glr.y" 16400 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o \").c\" --defines=\").h\" glr.y" "output.at:227" 16401 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o ").c" --defines=").h" glr.y 16402 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16403 at_status=$? at_failed=false 16404 $at_check_filter 16405 echo stderr:; cat "$at_stderr" 16406 echo stdout:; cat "$at_stdout" 16407 at_fn_check_status 0 $at_status "$at_srcdir/output.at:227" 16408 $at_failed && at_fn_log_failure 16409 $at_traceon; } 16410 16411 cp xml-tests/test.output expout 16412 { set +x 16413 $as_echo "$at_srcdir/output.at:227: \$XSLTPROC \\ 16414 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 16415 xml-tests/test.xml" 16416 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:227" 16417 ( $at_check_trace; $XSLTPROC \ 16418 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 16419 xml-tests/test.xml 16420 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16421 at_status=$? at_failed=false 16422 $at_check_filter 16423 at_fn_diff_devnull "$at_stderr" || at_failed=: 16424 $at_diff expout "$at_stdout" || at_failed=: 16425 at_fn_check_status 0 $at_status "$at_srcdir/outpu