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/output.at:227" 16426 $at_failed && at_fn_log_failure 16427 $at_traceon; } 16428 16429 sort xml-tests/test.dot > expout 16430 { set +x 16431 $as_echo "$at_srcdir/output.at:227: \$XSLTPROC \\ 16432 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 16433 xml-tests/test.xml | sort" 16434 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:227" 16435 ( $at_check_trace; $XSLTPROC \ 16436 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 16437 xml-tests/test.xml | sort 16438 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16439 at_status=$? at_failed=false 16440 $at_check_filter 16441 at_fn_diff_devnull "$at_stderr" || at_failed=: 16442 $at_diff expout "$at_stdout" || at_failed=: 16443 at_fn_check_status 0 $at_status "$at_srcdir/output.at:227" 16444 $at_failed && at_fn_log_failure 16445 $at_traceon; } 16446 16447 rm -rf xml-tests expout 16448 at_restore_special_files 16449 fi 16450 { set +x 16451 $as_echo "$at_srcdir/output.at:227: bison -o \").c\" --defines=\").h\" glr.y" 16452 at_fn_check_prepare_trace "output.at:227" 16453 ( $at_check_trace; bison -o ").c" --defines=").h" glr.y 16454 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16455 at_status=$? at_failed=false 16456 $at_check_filter 16457 at_fn_diff_devnull "$at_stderr" || at_failed=: 16458 at_fn_diff_devnull "$at_stdout" || at_failed=: 16459 at_fn_check_status 0 $at_status "$at_srcdir/output.at:227" 16460 $at_failed && at_fn_log_failure 16461 $at_traceon; } 16462 16463 16464 { set +x 16465 $as_echo "$at_srcdir/output.at:227: ls \").c\" \").h\"" 16466 at_fn_check_prepare_trace "output.at:227" 16467 ( $at_check_trace; ls ").c" ").h" 16468 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16469 at_status=$? at_failed=false 16470 $at_check_filter 16471 at_fn_diff_devnull "$at_stderr" || at_failed=: 16472 echo stdout:; cat "$at_stdout" 16473 at_fn_check_status 0 $at_status "$at_srcdir/output.at:227" 16474 $at_failed && at_fn_log_failure 16475 $at_traceon; } 16476 16477 { set +x 16478 $as_echo "$at_srcdir/output.at:227: \$BISON_C_WORKS" 16479 at_fn_check_prepare_dynamic "$BISON_C_WORKS" "output.at:227" 16480 ( $at_check_trace; $BISON_C_WORKS 16481 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16482 at_status=$? at_failed=false 16483 $at_check_filter 16484 echo stderr:; cat "$at_stderr" 16485 echo stdout:; cat "$at_stdout" 16486 at_fn_check_status 0 $at_status "$at_srcdir/output.at:227" 16487 $at_failed && at_fn_log_failure 16488 $at_traceon; } 16489 16490 { set +x 16491 $as_echo "$at_srcdir/output.at:227: \$CC \$CFLAGS \$CPPFLAGS -c -o glr.o -c \").c\" " 16492 at_fn_check_prepare_dynamic "$CC $CFLAGS $CPPFLAGS -c -o glr.o -c \").c\" " "output.at:227" 16493 ( $at_check_trace; $CC $CFLAGS $CPPFLAGS -c -o glr.o -c ").c" 16494 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16495 at_status=$? at_failed=false 16496 $at_check_filter 16497 echo stderr:; cat "$at_stderr" 16498 echo stdout:; cat "$at_stdout" 16499 at_fn_check_status 0 $at_status "$at_srcdir/output.at:227" 16500 $at_failed && at_fn_log_failure 16501 $at_traceon; } 16502 16503 16504 16505 cat >cxx.y <<'_ATEOF' 16506 %code top { 16507 #include <config.h> 16508 /* We don't need perfect functions for these tests. */ 16509 #undef malloc 16510 #undef memcmp 16511 #undef realloc 16512 } 16513 16514 %skeleton "lalr1.cc" 16515 %code { int yylex (yy::parser::semantic_type*); } 16516 %% 16517 start: {}; 16518 _ATEOF 16519 16520 16521 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 16522 at_save_special_files 16523 mkdir xml-tests 16524 # Don't combine these Bison invocations since we want to be sure that 16525 # --report=all isn't required to get the full XML file. 16526 { set +x 16527 $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 \\ 16528 --graph=xml-tests/test.dot -o \").c\" --defines=\").h\" cxx.y" 16529 at_fn_check_prepare_notrace 'an embedded newline' "output.at:227" 16530 ( $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 \ 16531 --graph=xml-tests/test.dot -o ").c" --defines=").h" cxx.y 16532 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16533 at_status=$? at_failed=false 16534 $at_check_filter 16535 echo stderr:; cat "$at_stderr" 16536 echo stdout:; cat "$at_stdout" 16537 at_fn_check_status 0 $at_status "$at_srcdir/output.at:227" 16538 $at_failed && at_fn_log_failure 16539 $at_traceon; } 16540 16541 { set +x 16542 $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\" cxx.y" 16543 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:227" 16544 ( $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 16545 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16546 at_status=$? at_failed=false 16547 $at_check_filter 16548 echo stderr:; cat "$at_stderr" 16549 echo stdout:; cat "$at_stdout" 16550 at_fn_check_status 0 $at_status "$at_srcdir/output.at:227" 16551 $at_failed && at_fn_log_failure 16552 $at_traceon; } 16553 16554 cp xml-tests/test.output expout 16555 { set +x 16556 $as_echo "$at_srcdir/output.at:227: \$XSLTPROC \\ 16557 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 16558 xml-tests/test.xml" 16559 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:227" 16560 ( $at_check_trace; $XSLTPROC \ 16561 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 16562 xml-tests/test.xml 16563 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16564 at_status=$? at_failed=false 16565 $at_check_filter 16566 at_fn_diff_devnull "$at_stderr" || at_failed=: 16567 $at_diff expout "$at_stdout" || at_failed=: 16568 at_fn_check_status 0 $at_status "$at_srcdir/output.at:227" 16569 $at_failed && at_fn_log_failure 16570 $at_traceon; } 16571 16572 sort xml-tests/test.dot > expout 16573 { set +x 16574 $as_echo "$at_srcdir/output.at:227: \$XSLTPROC \\ 16575 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 16576 xml-tests/test.xml | sort" 16577 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:227" 16578 ( $at_check_trace; $XSLTPROC \ 16579 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 16580 xml-tests/test.xml | sort 16581 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16582 at_status=$? at_failed=false 16583 $at_check_filter 16584 at_fn_diff_devnull "$at_stderr" || at_failed=: 16585 $at_diff expout "$at_stdout" || at_failed=: 16586 at_fn_check_status 0 $at_status "$at_srcdir/output.at:227" 16587 $at_failed && at_fn_log_failure 16588 $at_traceon; } 16589 16590 rm -rf xml-tests expout 16591 at_restore_special_files 16592 fi 16593 { set +x 16594 $as_echo "$at_srcdir/output.at:227: bison -o \").c\" --defines=\").h\" cxx.y" 16595 at_fn_check_prepare_trace "output.at:227" 16596 ( $at_check_trace; bison -o ").c" --defines=").h" cxx.y 16597 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16598 at_status=$? at_failed=false 16599 $at_check_filter 16600 at_fn_diff_devnull "$at_stderr" || at_failed=: 16601 at_fn_diff_devnull "$at_stdout" || at_failed=: 16602 at_fn_check_status 0 $at_status "$at_srcdir/output.at:227" 16603 $at_failed && at_fn_log_failure 16604 $at_traceon; } 16605 16606 16607 { set +x 16608 $as_echo "$at_srcdir/output.at:227: ls \").c\" \").h\"" 16609 at_fn_check_prepare_trace "output.at:227" 16610 ( $at_check_trace; ls ").c" ").h" 16611 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16612 at_status=$? at_failed=false 16613 $at_check_filter 16614 at_fn_diff_devnull "$at_stderr" || at_failed=: 16615 echo stdout:; cat "$at_stdout" 16616 at_fn_check_status 0 $at_status "$at_srcdir/output.at:227" 16617 $at_failed && at_fn_log_failure 16618 $at_traceon; } 16619 16620 16621 { set +x 16622 $as_echo "$at_srcdir/output.at:227: \$BISON_CXX_WORKS" 16623 at_fn_check_prepare_dynamic "$BISON_CXX_WORKS" "output.at:227" 16624 ( $at_check_trace; $BISON_CXX_WORKS 16625 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16626 at_status=$? at_failed=false 16627 $at_check_filter 16628 echo stderr:; cat "$at_stderr" 16629 echo stdout:; cat "$at_stdout" 16630 at_fn_check_status 0 $at_status "$at_srcdir/output.at:227" 16631 $at_failed && at_fn_log_failure 16632 $at_traceon; } 16633 16634 { set +x 16635 $as_echo "$at_srcdir/output.at:227: \$CXX \$CXXFLAGS \$CPPFLAGS -c -o cxx.o -c \").c\" " 16636 at_fn_check_prepare_dynamic "$CXX $CXXFLAGS $CPPFLAGS -c -o cxx.o -c \").c\" " "output.at:227" 16637 ( $at_check_trace; $CXX $CXXFLAGS $CPPFLAGS -c -o cxx.o -c ").c" 16638 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16639 at_status=$? at_failed=false 16640 $at_check_filter 16641 echo stderr:; cat "$at_stderr" 16642 echo stdout:; cat "$at_stdout" 16643 at_fn_check_status 0 $at_status "$at_srcdir/output.at:227" 16644 $at_failed && at_fn_log_failure 16645 $at_traceon; } 16646 16647 16648 16649 16650 set +x 16651 $at_times_p && times >"$at_times_file" 16652 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 16653 read at_status <"$at_status_file" 16654 #AT_STOP_79 16655 #AT_START_80 16656 at_fn_group_banner 80 'output.at:228' \ 16657 "Output file name: #" " " 3 16658 at_xfail=no 16659 ( 16660 $as_echo "80. $at_setup_line: testing $at_desc ..." 16661 $at_traceon 16662 16663 16664 16665 # Skip if platform doesn't support file name. For example, Cygwin 16666 # doesn't support file names containing ":" or "\". 16667 { set +x 16668 $as_echo "$at_srcdir/output.at:228: touch \"#.tmp\" || exit 77" 16669 at_fn_check_prepare_trace "output.at:228" 16670 ( $at_check_trace; touch "#.tmp" || exit 77 16671 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16672 at_status=$? at_failed=false 16673 $at_check_filter 16674 at_fn_diff_devnull "$at_stderr" || at_failed=: 16675 at_fn_diff_devnull "$at_stdout" || at_failed=: 16676 at_fn_check_status 0 $at_status "$at_srcdir/output.at:228" 16677 $at_failed && at_fn_log_failure 16678 $at_traceon; } 16679 16680 16681 cat >glr.y <<'_ATEOF' 16682 %code top { 16683 #include <config.h> 16684 /* We don't need perfect functions for these tests. */ 16685 #undef malloc 16686 #undef memcmp 16687 #undef realloc 16688 } 16689 16690 %glr-parser 16691 %code { 16692 void yyerror ( const char *msg); 16693 int yylex (void); 16694 } 16695 %% 16696 start: {}; 16697 _ATEOF 16698 16699 16700 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 16701 at_save_special_files 16702 mkdir xml-tests 16703 # Don't combine these Bison invocations since we want to be sure that 16704 # --report=all isn't required to get the full XML file. 16705 { set +x 16706 $as_echo "$at_srcdir/output.at:228: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 16707 --graph=xml-tests/test.dot -o \"#.c\" --defines=\"#.h\" glr.y" 16708 at_fn_check_prepare_notrace 'an embedded newline' "output.at:228" 16709 ( $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 \ 16710 --graph=xml-tests/test.dot -o "#.c" --defines="#.h" glr.y 16711 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16712 at_status=$? at_failed=false 16713 $at_check_filter 16714 echo stderr:; cat "$at_stderr" 16715 echo stdout:; cat "$at_stdout" 16716 at_fn_check_status 0 $at_status "$at_srcdir/output.at:228" 16717 $at_failed && at_fn_log_failure 16718 $at_traceon; } 16719 16720 { set +x 16721 $as_echo "$at_srcdir/output.at:228: 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" 16722 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:228" 16723 ( $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 16724 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16725 at_status=$? at_failed=false 16726 $at_check_filter 16727 echo stderr:; cat "$at_stderr" 16728 echo stdout:; cat "$at_stdout" 16729 at_fn_check_status 0 $at_status "$at_srcdir/output.at:228" 16730 $at_failed && at_fn_log_failure 16731 $at_traceon; } 16732 16733 cp xml-tests/test.output expout 16734 { set +x 16735 $as_echo "$at_srcdir/output.at:228: \$XSLTPROC \\ 16736 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 16737 xml-tests/test.xml" 16738 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:228" 16739 ( $at_check_trace; $XSLTPROC \ 16740 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 16741 xml-tests/test.xml 16742 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16743 at_status=$? at_failed=false 16744 $at_check_filter 16745 at_fn_diff_devnull "$at_stderr" || at_failed=: 16746 $at_diff expout "$at_stdout" || at_failed=: 16747 at_fn_check_status 0 $at_status "$at_srcdir/output.at:228" 16748 $at_failed && at_fn_log_failure 16749 $at_traceon; } 16750 16751 sort xml-tests/test.dot > expout 16752 { set +x 16753 $as_echo "$at_srcdir/output.at:228: \$XSLTPROC \\ 16754 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 16755 xml-tests/test.xml | sort" 16756 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:228" 16757 ( $at_check_trace; $XSLTPROC \ 16758 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 16759 xml-tests/test.xml | sort 16760 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16761 at_status=$? at_failed=false 16762 $at_check_filter 16763 at_fn_diff_devnull "$at_stderr" || at_failed=: 16764 $at_diff expout "$at_stdout" || at_failed=: 16765 at_fn_check_status 0 $at_status "$at_srcdir/output.at:228" 16766 $at_failed && at_fn_log_failure 16767 $at_traceon; } 16768 16769 rm -rf xml-tests expout 16770 at_restore_special_files 16771 fi 16772 { set +x 16773 $as_echo "$at_srcdir/output.at:228: bison -o \"#.c\" --defines=\"#.h\" glr.y" 16774 at_fn_check_prepare_trace "output.at:228" 16775 ( $at_check_trace; bison -o "#.c" --defines="#.h" glr.y 16776 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16777 at_status=$? at_failed=false 16778 $at_check_filter 16779 at_fn_diff_devnull "$at_stderr" || at_failed=: 16780 at_fn_diff_devnull "$at_stdout" || at_failed=: 16781 at_fn_check_status 0 $at_status "$at_srcdir/output.at:228" 16782 $at_failed && at_fn_log_failure 16783 $at_traceon; } 16784 16785 16786 { set +x 16787 $as_echo "$at_srcdir/output.at:228: ls \"#.c\" \"#.h\"" 16788 at_fn_check_prepare_trace "output.at:228" 16789 ( $at_check_trace; ls "#.c" "#.h" 16790 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16791 at_status=$? at_failed=false 16792 $at_check_filter 16793 at_fn_diff_devnull "$at_stderr" || at_failed=: 16794 echo stdout:; cat "$at_stdout" 16795 at_fn_check_status 0 $at_status "$at_srcdir/output.at:228" 16796 $at_failed && at_fn_log_failure 16797 $at_traceon; } 16798 16799 { set +x 16800 $as_echo "$at_srcdir/output.at:228: \$BISON_C_WORKS" 16801 at_fn_check_prepare_dynamic "$BISON_C_WORKS" "output.at:228" 16802 ( $at_check_trace; $BISON_C_WORKS 16803 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16804 at_status=$? at_failed=false 16805 $at_check_filter 16806 echo stderr:; cat "$at_stderr" 16807 echo stdout:; cat "$at_stdout" 16808 at_fn_check_status 0 $at_status "$at_srcdir/output.at:228" 16809 $at_failed && at_fn_log_failure 16810 $at_traceon; } 16811 16812 { set +x 16813 $as_echo "$at_srcdir/output.at:228: \$CC \$CFLAGS \$CPPFLAGS -c -o glr.o -c \"#.c\" " 16814 at_fn_check_prepare_dynamic "$CC $CFLAGS $CPPFLAGS -c -o glr.o -c \"#.c\" " "output.at:228" 16815 ( $at_check_trace; $CC $CFLAGS $CPPFLAGS -c -o glr.o -c "#.c" 16816 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16817 at_status=$? at_failed=false 16818 $at_check_filter 16819 echo stderr:; cat "$at_stderr" 16820 echo stdout:; cat "$at_stdout" 16821 at_fn_check_status 0 $at_status "$at_srcdir/output.at:228" 16822 $at_failed && at_fn_log_failure 16823 $at_traceon; } 16824 16825 16826 16827 cat >cxx.y <<'_ATEOF' 16828 %code top { 16829 #include <config.h> 16830 /* We don't need perfect functions for these tests. */ 16831 #undef malloc 16832 #undef memcmp 16833 #undef realloc 16834 } 16835 16836 %skeleton "lalr1.cc" 16837 %code { int yylex (yy::parser::semantic_type*); } 16838 %% 16839 start: {}; 16840 _ATEOF 16841 16842 16843 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 16844 at_save_special_files 16845 mkdir xml-tests 16846 # Don't combine these Bison invocations since we want to be sure that 16847 # --report=all isn't required to get the full XML file. 16848 { set +x 16849 $as_echo "$at_srcdir/output.at:228: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 16850 --graph=xml-tests/test.dot -o \"#.c\" --defines=\"#.h\" cxx.y" 16851 at_fn_check_prepare_notrace 'an embedded newline' "output.at:228" 16852 ( $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 \ 16853 --graph=xml-tests/test.dot -o "#.c" --defines="#.h" cxx.y 16854 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16855 at_status=$? at_failed=false 16856 $at_check_filter 16857 echo stderr:; cat "$at_stderr" 16858 echo stdout:; cat "$at_stdout" 16859 at_fn_check_status 0 $at_status "$at_srcdir/output.at:228" 16860 $at_failed && at_fn_log_failure 16861 $at_traceon; } 16862 16863 { set +x 16864 $as_echo "$at_srcdir/output.at:228: 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" 16865 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:228" 16866 ( $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 16867 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16868 at_status=$? at_failed=false 16869 $at_check_filter 16870 echo stderr:; cat "$at_stderr" 16871 echo stdout:; cat "$at_stdout" 16872 at_fn_check_status 0 $at_status "$at_srcdir/output.at:228" 16873 $at_failed && at_fn_log_failure 16874 $at_traceon; } 16875 16876 cp xml-tests/test.output expout 16877 { set +x 16878 $as_echo "$at_srcdir/output.at:228: \$XSLTPROC \\ 16879 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 16880 xml-tests/test.xml" 16881 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:228" 16882 ( $at_check_trace; $XSLTPROC \ 16883 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 16884 xml-tests/test.xml 16885 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16886 at_status=$? at_failed=false 16887 $at_check_filter 16888 at_fn_diff_devnull "$at_stderr" || at_failed=: 16889 $at_diff expout "$at_stdout" || at_failed=: 16890 at_fn_check_status 0 $at_status "$at_srcdir/output.at:228" 16891 $at_failed && at_fn_log_failure 16892 $at_traceon; } 16893 16894 sort xml-tests/test.dot > expout 16895 { set +x 16896 $as_echo "$at_srcdir/output.at:228: \$XSLTPROC \\ 16897 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 16898 xml-tests/test.xml | sort" 16899 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:228" 16900 ( $at_check_trace; $XSLTPROC \ 16901 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 16902 xml-tests/test.xml | sort 16903 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16904 at_status=$? at_failed=false 16905 $at_check_filter 16906 at_fn_diff_devnull "$at_stderr" || at_failed=: 16907 $at_diff expout "$at_stdout" || at_failed=: 16908 at_fn_check_status 0 $at_status "$at_srcdir/output.at:228" 16909 $at_failed && at_fn_log_failure 16910 $at_traceon; } 16911 16912 rm -rf xml-tests expout 16913 at_restore_special_files 16914 fi 16915 { set +x 16916 $as_echo "$at_srcdir/output.at:228: bison -o \"#.c\" --defines=\"#.h\" cxx.y" 16917 at_fn_check_prepare_trace "output.at:228" 16918 ( $at_check_trace; bison -o "#.c" --defines="#.h" cxx.y 16919 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16920 at_status=$? at_failed=false 16921 $at_check_filter 16922 at_fn_diff_devnull "$at_stderr" || at_failed=: 16923 at_fn_diff_devnull "$at_stdout" || at_failed=: 16924 at_fn_check_status 0 $at_status "$at_srcdir/output.at:228" 16925 $at_failed && at_fn_log_failure 16926 $at_traceon; } 16927 16928 16929 { set +x 16930 $as_echo "$at_srcdir/output.at:228: ls \"#.c\" \"#.h\"" 16931 at_fn_check_prepare_trace "output.at:228" 16932 ( $at_check_trace; ls "#.c" "#.h" 16933 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16934 at_status=$? at_failed=false 16935 $at_check_filter 16936 at_fn_diff_devnull "$at_stderr" || at_failed=: 16937 echo stdout:; cat "$at_stdout" 16938 at_fn_check_status 0 $at_status "$at_srcdir/output.at:228" 16939 $at_failed && at_fn_log_failure 16940 $at_traceon; } 16941 16942 16943 { set +x 16944 $as_echo "$at_srcdir/output.at:228: \$BISON_CXX_WORKS" 16945 at_fn_check_prepare_dynamic "$BISON_CXX_WORKS" "output.at:228" 16946 ( $at_check_trace; $BISON_CXX_WORKS 16947 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16948 at_status=$? at_failed=false 16949 $at_check_filter 16950 echo stderr:; cat "$at_stderr" 16951 echo stdout:; cat "$at_stdout" 16952 at_fn_check_status 0 $at_status "$at_srcdir/output.at:228" 16953 $at_failed && at_fn_log_failure 16954 $at_traceon; } 16955 16956 { set +x 16957 $as_echo "$at_srcdir/output.at:228: \$CXX \$CXXFLAGS \$CPPFLAGS -c -o cxx.o -c \"#.c\" " 16958 at_fn_check_prepare_dynamic "$CXX $CXXFLAGS $CPPFLAGS -c -o cxx.o -c \"#.c\" " "output.at:228" 16959 ( $at_check_trace; $CXX $CXXFLAGS $CPPFLAGS -c -o cxx.o -c "#.c" 16960 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16961 at_status=$? at_failed=false 16962 $at_check_filter 16963 echo stderr:; cat "$at_stderr" 16964 echo stdout:; cat "$at_stdout" 16965 at_fn_check_status 0 $at_status "$at_srcdir/output.at:228" 16966 $at_failed && at_fn_log_failure 16967 $at_traceon; } 16968 16969 16970 16971 16972 set +x 16973 $at_times_p && times >"$at_times_file" 16974 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 16975 read at_status <"$at_status_file" 16976 #AT_STOP_80 16977 #AT_START_81 16978 at_fn_group_banner 81 'output.at:229' \ 16979 "Output file name: @@" " " 3 16980 at_xfail=no 16981 ( 16982 $as_echo "81. $at_setup_line: testing $at_desc ..." 16983 $at_traceon 16984 16985 16986 16987 # Skip if platform doesn't support file name. For example, Cygwin 16988 # doesn't support file names containing ":" or "\". 16989 { set +x 16990 $as_echo "$at_srcdir/output.at:229: touch \"@@.tmp\" || exit 77" 16991 at_fn_check_prepare_trace "output.at:229" 16992 ( $at_check_trace; touch "@@.tmp" || exit 77 16993 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 16994 at_status=$? at_failed=false 16995 $at_check_filter 16996 at_fn_diff_devnull "$at_stderr" || at_failed=: 16997 at_fn_diff_devnull "$at_stdout" || at_failed=: 16998 at_fn_check_status 0 $at_status "$at_srcdir/output.at:229" 16999 $at_failed && at_fn_log_failure 17000 $at_traceon; } 17001 17002 17003 cat >glr.y <<'_ATEOF' 17004 %code top { 17005 #include <config.h> 17006 /* We don't need perfect functions for these tests. */ 17007 #undef malloc 17008 #undef memcmp 17009 #undef realloc 17010 } 17011 17012 %glr-parser 17013 %code { 17014 void yyerror ( const char *msg); 17015 int yylex (void); 17016 } 17017 %% 17018 start: {}; 17019 _ATEOF 17020 17021 17022 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 17023 at_save_special_files 17024 mkdir xml-tests 17025 # Don't combine these Bison invocations since we want to be sure that 17026 # --report=all isn't required to get the full XML file. 17027 { set +x 17028 $as_echo "$at_srcdir/output.at:229: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 17029 --graph=xml-tests/test.dot -o \"@@.c\" --defines=\"@@.h\" glr.y" 17030 at_fn_check_prepare_notrace 'an embedded newline' "output.at:229" 17031 ( $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 \ 17032 --graph=xml-tests/test.dot -o "@@.c" --defines="@@.h" glr.y 17033 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17034 at_status=$? at_failed=false 17035 $at_check_filter 17036 echo stderr:; cat "$at_stderr" 17037 echo stdout:; cat "$at_stdout" 17038 at_fn_check_status 0 $at_status "$at_srcdir/output.at:229" 17039 $at_failed && at_fn_log_failure 17040 $at_traceon; } 17041 17042 { set +x 17043 $as_echo "$at_srcdir/output.at:229: 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" 17044 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:229" 17045 ( $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 17046 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17047 at_status=$? at_failed=false 17048 $at_check_filter 17049 echo stderr:; cat "$at_stderr" 17050 echo stdout:; cat "$at_stdout" 17051 at_fn_check_status 0 $at_status "$at_srcdir/output.at:229" 17052 $at_failed && at_fn_log_failure 17053 $at_traceon; } 17054 17055 cp xml-tests/test.output expout 17056 { set +x 17057 $as_echo "$at_srcdir/output.at:229: \$XSLTPROC \\ 17058 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 17059 xml-tests/test.xml" 17060 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:229" 17061 ( $at_check_trace; $XSLTPROC \ 17062 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 17063 xml-tests/test.xml 17064 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17065 at_status=$? at_failed=false 17066 $at_check_filter 17067 at_fn_diff_devnull "$at_stderr" || at_failed=: 17068 $at_diff expout "$at_stdout" || at_failed=: 17069 at_fn_check_status 0 $at_status "$at_srcdir/output.at:229" 17070 $at_failed && at_fn_log_failure 17071 $at_traceon; } 17072 17073 sort xml-tests/test.dot > expout 17074 { set +x 17075 $as_echo "$at_srcdir/output.at:229: \$XSLTPROC \\ 17076 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 17077 xml-tests/test.xml | sort" 17078 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:229" 17079 ( $at_check_trace; $XSLTPROC \ 17080 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 17081 xml-tests/test.xml | sort 17082 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17083 at_status=$? at_failed=false 17084 $at_check_filter 17085 at_fn_diff_devnull "$at_stderr" || at_failed=: 17086 $at_diff expout "$at_stdout" || at_failed=: 17087 at_fn_check_status 0 $at_status "$at_srcdir/output.at:229" 17088 $at_failed && at_fn_log_failure 17089 $at_traceon; } 17090 17091 rm -rf xml-tests expout 17092 at_restore_special_files 17093 fi 17094 { set +x 17095 $as_echo "$at_srcdir/output.at:229: bison -o \"@@.c\" --defines=\"@@.h\" glr.y" 17096 at_fn_check_prepare_trace "output.at:229" 17097 ( $at_check_trace; bison -o "@@.c" --defines="@@.h" glr.y 17098 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17099 at_status=$? at_failed=false 17100 $at_check_filter 17101 at_fn_diff_devnull "$at_stderr" || at_failed=: 17102 at_fn_diff_devnull "$at_stdout" || at_failed=: 17103 at_fn_check_status 0 $at_status "$at_srcdir/output.at:229" 17104 $at_failed && at_fn_log_failure 17105 $at_traceon; } 17106 17107 17108 { set +x 17109 $as_echo "$at_srcdir/output.at:229: ls \"@@.c\" \"@@.h\"" 17110 at_fn_check_prepare_trace "output.at:229" 17111 ( $at_check_trace; ls "@@.c" "@@.h" 17112 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17113 at_status=$? at_failed=false 17114 $at_check_filter 17115 at_fn_diff_devnull "$at_stderr" || at_failed=: 17116 echo stdout:; cat "$at_stdout" 17117 at_fn_check_status 0 $at_status "$at_srcdir/output.at:229" 17118 $at_failed && at_fn_log_failure 17119 $at_traceon; } 17120 17121 { set +x 17122 $as_echo "$at_srcdir/output.at:229: \$BISON_C_WORKS" 17123 at_fn_check_prepare_dynamic "$BISON_C_WORKS" "output.at:229" 17124 ( $at_check_trace; $BISON_C_WORKS 17125 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17126 at_status=$? at_failed=false 17127 $at_check_filter 17128 echo stderr:; cat "$at_stderr" 17129 echo stdout:; cat "$at_stdout" 17130 at_fn_check_status 0 $at_status "$at_srcdir/output.at:229" 17131 $at_failed && at_fn_log_failure 17132 $at_traceon; } 17133 17134 { set +x 17135 $as_echo "$at_srcdir/output.at:229: \$CC \$CFLAGS \$CPPFLAGS -c -o glr.o -c \"@@.c\" " 17136 at_fn_check_prepare_dynamic "$CC $CFLAGS $CPPFLAGS -c -o glr.o -c \"@@.c\" " "output.at:229" 17137 ( $at_check_trace; $CC $CFLAGS $CPPFLAGS -c -o glr.o -c "@@.c" 17138 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17139 at_status=$? at_failed=false 17140 $at_check_filter 17141 echo stderr:; cat "$at_stderr" 17142 echo stdout:; cat "$at_stdout" 17143 at_fn_check_status 0 $at_status "$at_srcdir/output.at:229" 17144 $at_failed && at_fn_log_failure 17145 $at_traceon; } 17146 17147 17148 17149 cat >cxx.y <<'_ATEOF' 17150 %code top { 17151 #include <config.h> 17152 /* We don't need perfect functions for these tests. */ 17153 #undef malloc 17154 #undef memcmp 17155 #undef realloc 17156 } 17157 17158 %skeleton "lalr1.cc" 17159 %code { int yylex (yy::parser::semantic_type*); } 17160 %% 17161 start: {}; 17162 _ATEOF 17163 17164 17165 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 17166 at_save_special_files 17167 mkdir xml-tests 17168 # Don't combine these Bison invocations since we want to be sure that 17169 # --report=all isn't required to get the full XML file. 17170 { set +x 17171 $as_echo "$at_srcdir/output.at:229: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 17172 --graph=xml-tests/test.dot -o \"@@.c\" --defines=\"@@.h\" cxx.y" 17173 at_fn_check_prepare_notrace 'an embedded newline' "output.at:229" 17174 ( $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 \ 17175 --graph=xml-tests/test.dot -o "@@.c" --defines="@@.h" cxx.y 17176 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17177 at_status=$? at_failed=false 17178 $at_check_filter 17179 echo stderr:; cat "$at_stderr" 17180 echo stdout:; cat "$at_stdout" 17181 at_fn_check_status 0 $at_status "$at_srcdir/output.at:229" 17182 $at_failed && at_fn_log_failure 17183 $at_traceon; } 17184 17185 { set +x 17186 $as_echo "$at_srcdir/output.at:229: 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" 17187 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:229" 17188 ( $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 17189 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17190 at_status=$? at_failed=false 17191 $at_check_filter 17192 echo stderr:; cat "$at_stderr" 17193 echo stdout:; cat "$at_stdout" 17194 at_fn_check_status 0 $at_status "$at_srcdir/output.at:229" 17195 $at_failed && at_fn_log_failure 17196 $at_traceon; } 17197 17198 cp xml-tests/test.output expout 17199 { set +x 17200 $as_echo "$at_srcdir/output.at:229: \$XSLTPROC \\ 17201 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 17202 xml-tests/test.xml" 17203 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:229" 17204 ( $at_check_trace; $XSLTPROC \ 17205 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 17206 xml-tests/test.xml 17207 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17208 at_status=$? at_failed=false 17209 $at_check_filter 17210 at_fn_diff_devnull "$at_stderr" || at_failed=: 17211 $at_diff expout "$at_stdout" || at_failed=: 17212 at_fn_check_status 0 $at_status "$at_srcdir/output.at:229" 17213 $at_failed && at_fn_log_failure 17214 $at_traceon; } 17215 17216 sort xml-tests/test.dot > expout 17217 { set +x 17218 $as_echo "$at_srcdir/output.at:229: \$XSLTPROC \\ 17219 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 17220 xml-tests/test.xml | sort" 17221 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:229" 17222 ( $at_check_trace; $XSLTPROC \ 17223 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 17224 xml-tests/test.xml | sort 17225 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17226 at_status=$? at_failed=false 17227 $at_check_filter 17228 at_fn_diff_devnull "$at_stderr" || at_failed=: 17229 $at_diff expout "$at_stdout" || at_failed=: 17230 at_fn_check_status 0 $at_status "$at_srcdir/output.at:229" 17231 $at_failed && at_fn_log_failure 17232 $at_traceon; } 17233 17234 rm -rf xml-tests expout 17235 at_restore_special_files 17236 fi 17237 { set +x 17238 $as_echo "$at_srcdir/output.at:229: bison -o \"@@.c\" --defines=\"@@.h\" cxx.y" 17239 at_fn_check_prepare_trace "output.at:229" 17240 ( $at_check_trace; bison -o "@@.c" --defines="@@.h" cxx.y 17241 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17242 at_status=$? at_failed=false 17243 $at_check_filter 17244 at_fn_diff_devnull "$at_stderr" || at_failed=: 17245 at_fn_diff_devnull "$at_stdout" || at_failed=: 17246 at_fn_check_status 0 $at_status "$at_srcdir/output.at:229" 17247 $at_failed && at_fn_log_failure 17248 $at_traceon; } 17249 17250 17251 { set +x 17252 $as_echo "$at_srcdir/output.at:229: ls \"@@.c\" \"@@.h\"" 17253 at_fn_check_prepare_trace "output.at:229" 17254 ( $at_check_trace; ls "@@.c" "@@.h" 17255 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17256 at_status=$? at_failed=false 17257 $at_check_filter 17258 at_fn_diff_devnull "$at_stderr" || at_failed=: 17259 echo stdout:; cat "$at_stdout" 17260 at_fn_check_status 0 $at_status "$at_srcdir/output.at:229" 17261 $at_failed && at_fn_log_failure 17262 $at_traceon; } 17263 17264 17265 { set +x 17266 $as_echo "$at_srcdir/output.at:229: \$BISON_CXX_WORKS" 17267 at_fn_check_prepare_dynamic "$BISON_CXX_WORKS" "output.at:229" 17268 ( $at_check_trace; $BISON_CXX_WORKS 17269 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17270 at_status=$? at_failed=false 17271 $at_check_filter 17272 echo stderr:; cat "$at_stderr" 17273 echo stdout:; cat "$at_stdout" 17274 at_fn_check_status 0 $at_status "$at_srcdir/output.at:229" 17275 $at_failed && at_fn_log_failure 17276 $at_traceon; } 17277 17278 { set +x 17279 $as_echo "$at_srcdir/output.at:229: \$CXX \$CXXFLAGS \$CPPFLAGS -c -o cxx.o -c \"@@.c\" " 17280 at_fn_check_prepare_dynamic "$CXX $CXXFLAGS $CPPFLAGS -c -o cxx.o -c \"@@.c\" " "output.at:229" 17281 ( $at_check_trace; $CXX $CXXFLAGS $CPPFLAGS -c -o cxx.o -c "@@.c" 17282 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17283 at_status=$? at_failed=false 17284 $at_check_filter 17285 echo stderr:; cat "$at_stderr" 17286 echo stdout:; cat "$at_stdout" 17287 at_fn_check_status 0 $at_status "$at_srcdir/output.at:229" 17288 $at_failed && at_fn_log_failure 17289 $at_traceon; } 17290 17291 17292 17293 17294 set +x 17295 $at_times_p && times >"$at_times_file" 17296 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 17297 read at_status <"$at_status_file" 17298 #AT_STOP_81 17299 #AT_START_82 17300 at_fn_group_banner 82 'output.at:230' \ 17301 "Output file name: @{" " " 3 17302 at_xfail=no 17303 ( 17304 $as_echo "82. $at_setup_line: testing $at_desc ..." 17305 $at_traceon 17306 17307 17308 17309 # Skip if platform doesn't support file name. For example, Cygwin 17310 # doesn't support file names containing ":" or "\". 17311 { set +x 17312 $as_echo "$at_srcdir/output.at:230: touch \"@{.tmp\" || exit 77" 17313 at_fn_check_prepare_trace "output.at:230" 17314 ( $at_check_trace; touch "@{.tmp" || exit 77 17315 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17316 at_status=$? at_failed=false 17317 $at_check_filter 17318 at_fn_diff_devnull "$at_stderr" || at_failed=: 17319 at_fn_diff_devnull "$at_stdout" || at_failed=: 17320 at_fn_check_status 0 $at_status "$at_srcdir/output.at:230" 17321 $at_failed && at_fn_log_failure 17322 $at_traceon; } 17323 17324 17325 cat >glr.y <<'_ATEOF' 17326 %code top { 17327 #include <config.h> 17328 /* We don't need perfect functions for these tests. */ 17329 #undef malloc 17330 #undef memcmp 17331 #undef realloc 17332 } 17333 17334 %glr-parser 17335 %code { 17336 void yyerror ( const char *msg); 17337 int yylex (void); 17338 } 17339 %% 17340 start: {}; 17341 _ATEOF 17342 17343 17344 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 17345 at_save_special_files 17346 mkdir xml-tests 17347 # Don't combine these Bison invocations since we want to be sure that 17348 # --report=all isn't required to get the full XML file. 17349 { set +x 17350 $as_echo "$at_srcdir/output.at:230: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 17351 --graph=xml-tests/test.dot -o \"@{.c\" --defines=\"@{.h\" glr.y" 17352 at_fn_check_prepare_notrace 'an embedded newline' "output.at:230" 17353 ( $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 \ 17354 --graph=xml-tests/test.dot -o "@{.c" --defines="@{.h" glr.y 17355 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17356 at_status=$? at_failed=false 17357 $at_check_filter 17358 echo stderr:; cat "$at_stderr" 17359 echo stdout:; cat "$at_stdout" 17360 at_fn_check_status 0 $at_status "$at_srcdir/output.at:230" 17361 $at_failed && at_fn_log_failure 17362 $at_traceon; } 17363 17364 { set +x 17365 $as_echo "$at_srcdir/output.at:230: 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" 17366 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:230" 17367 ( $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 17368 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17369 at_status=$? at_failed=false 17370 $at_check_filter 17371 echo stderr:; cat "$at_stderr" 17372 echo stdout:; cat "$at_stdout" 17373 at_fn_check_status 0 $at_status "$at_srcdir/output.at:230" 17374 $at_failed && at_fn_log_failure 17375 $at_traceon; } 17376 17377 cp xml-tests/test.output expout 17378 { set +x 17379 $as_echo "$at_srcdir/output.at:230: \$XSLTPROC \\ 17380 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 17381 xml-tests/test.xml" 17382 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:230" 17383 ( $at_check_trace; $XSLTPROC \ 17384 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 17385 xml-tests/test.xml 17386 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17387 at_status=$? at_failed=false 17388 $at_check_filter 17389 at_fn_diff_devnull "$at_stderr" || at_failed=: 17390 $at_diff expout "$at_stdout" || at_failed=: 17391 at_fn_check_status 0 $at_status "$at_srcdir/output.at:230" 17392 $at_failed && at_fn_log_failure 17393 $at_traceon; } 17394 17395 sort xml-tests/test.dot > expout 17396 { set +x 17397 $as_echo "$at_srcdir/output.at:230: \$XSLTPROC \\ 17398 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 17399 xml-tests/test.xml | sort" 17400 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:230" 17401 ( $at_check_trace; $XSLTPROC \ 17402 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 17403 xml-tests/test.xml | sort 17404 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17405 at_status=$? at_failed=false 17406 $at_check_filter 17407 at_fn_diff_devnull "$at_stderr" || at_failed=: 17408 $at_diff expout "$at_stdout" || at_failed=: 17409 at_fn_check_status 0 $at_status "$at_srcdir/output.at:230" 17410 $at_failed && at_fn_log_failure 17411 $at_traceon; } 17412 17413 rm -rf xml-tests expout 17414 at_restore_special_files 17415 fi 17416 { set +x 17417 $as_echo "$at_srcdir/output.at:230: bison -o \"@{.c\" --defines=\"@{.h\" glr.y" 17418 at_fn_check_prepare_trace "output.at:230" 17419 ( $at_check_trace; bison -o "@{.c" --defines="@{.h" glr.y 17420 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17421 at_status=$? at_failed=false 17422 $at_check_filter 17423 at_fn_diff_devnull "$at_stderr" || at_failed=: 17424 at_fn_diff_devnull "$at_stdout" || at_failed=: 17425 at_fn_check_status 0 $at_status "$at_srcdir/output.at:230" 17426 $at_failed && at_fn_log_failure 17427 $at_traceon; } 17428 17429 17430 { set +x 17431 $as_echo "$at_srcdir/output.at:230: ls \"@{.c\" \"@{.h\"" 17432 at_fn_check_prepare_trace "output.at:230" 17433 ( $at_check_trace; ls "@{.c" "@{.h" 17434 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17435 at_status=$? at_failed=false 17436 $at_check_filter 17437 at_fn_diff_devnull "$at_stderr" || at_failed=: 17438 echo stdout:; cat "$at_stdout" 17439 at_fn_check_status 0 $at_status "$at_srcdir/output.at:230" 17440 $at_failed && at_fn_log_failure 17441 $at_traceon; } 17442 17443 { set +x 17444 $as_echo "$at_srcdir/output.at:230: \$BISON_C_WORKS" 17445 at_fn_check_prepare_dynamic "$BISON_C_WORKS" "output.at:230" 17446 ( $at_check_trace; $BISON_C_WORKS 17447 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17448 at_status=$? at_failed=false 17449 $at_check_filter 17450 echo stderr:; cat "$at_stderr" 17451 echo stdout:; cat "$at_stdout" 17452 at_fn_check_status 0 $at_status "$at_srcdir/output.at:230" 17453 $at_failed && at_fn_log_failure 17454 $at_traceon; } 17455 17456 { set +x 17457 $as_echo "$at_srcdir/output.at:230: \$CC \$CFLAGS \$CPPFLAGS -c -o glr.o -c \"@{.c\" " 17458 at_fn_check_prepare_dynamic "$CC $CFLAGS $CPPFLAGS -c -o glr.o -c \"@{.c\" " "output.at:230" 17459 ( $at_check_trace; $CC $CFLAGS $CPPFLAGS -c -o glr.o -c "@{.c" 17460 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17461 at_status=$? at_failed=false 17462 $at_check_filter 17463 echo stderr:; cat "$at_stderr" 17464 echo stdout:; cat "$at_stdout" 17465 at_fn_check_status 0 $at_status "$at_srcdir/output.at:230" 17466 $at_failed && at_fn_log_failure 17467 $at_traceon; } 17468 17469 17470 17471 cat >cxx.y <<'_ATEOF' 17472 %code top { 17473 #include <config.h> 17474 /* We don't need perfect functions for these tests. */ 17475 #undef malloc 17476 #undef memcmp 17477 #undef realloc 17478 } 17479 17480 %skeleton "lalr1.cc" 17481 %code { int yylex (yy::parser::semantic_type*); } 17482 %% 17483 start: {}; 17484 _ATEOF 17485 17486 17487 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 17488 at_save_special_files 17489 mkdir xml-tests 17490 # Don't combine these Bison invocations since we want to be sure that 17491 # --report=all isn't required to get the full XML file. 17492 { set +x 17493 $as_echo "$at_srcdir/output.at:230: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 17494 --graph=xml-tests/test.dot -o \"@{.c\" --defines=\"@{.h\" cxx.y" 17495 at_fn_check_prepare_notrace 'an embedded newline' "output.at:230" 17496 ( $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 \ 17497 --graph=xml-tests/test.dot -o "@{.c" --defines="@{.h" cxx.y 17498 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17499 at_status=$? at_failed=false 17500 $at_check_filter 17501 echo stderr:; cat "$at_stderr" 17502 echo stdout:; cat "$at_stdout" 17503 at_fn_check_status 0 $at_status "$at_srcdir/output.at:230" 17504 $at_failed && at_fn_log_failure 17505 $at_traceon; } 17506 17507 { set +x 17508 $as_echo "$at_srcdir/output.at:230: 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" 17509 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:230" 17510 ( $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 17511 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17512 at_status=$? at_failed=false 17513 $at_check_filter 17514 echo stderr:; cat "$at_stderr" 17515 echo stdout:; cat "$at_stdout" 17516 at_fn_check_status 0 $at_status "$at_srcdir/output.at:230" 17517 $at_failed && at_fn_log_failure 17518 $at_traceon; } 17519 17520 cp xml-tests/test.output expout 17521 { set +x 17522 $as_echo "$at_srcdir/output.at:230: \$XSLTPROC \\ 17523 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 17524 xml-tests/test.xml" 17525 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:230" 17526 ( $at_check_trace; $XSLTPROC \ 17527 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 17528 xml-tests/test.xml 17529 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17530 at_status=$? at_failed=false 17531 $at_check_filter 17532 at_fn_diff_devnull "$at_stderr" || at_failed=: 17533 $at_diff expout "$at_stdout" || at_failed=: 17534 at_fn_check_status 0 $at_status "$at_srcdir/output.at:230" 17535 $at_failed && at_fn_log_failure 17536 $at_traceon; } 17537 17538 sort xml-tests/test.dot > expout 17539 { set +x 17540 $as_echo "$at_srcdir/output.at:230: \$XSLTPROC \\ 17541 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 17542 xml-tests/test.xml | sort" 17543 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:230" 17544 ( $at_check_trace; $XSLTPROC \ 17545 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 17546 xml-tests/test.xml | sort 17547 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17548 at_status=$? at_failed=false 17549 $at_check_filter 17550 at_fn_diff_devnull "$at_stderr" || at_failed=: 17551 $at_diff expout "$at_stdout" || at_failed=: 17552 at_fn_check_status 0 $at_status "$at_srcdir/output.at:230" 17553 $at_failed && at_fn_log_failure 17554 $at_traceon; } 17555 17556 rm -rf xml-tests expout 17557 at_restore_special_files 17558 fi 17559 { set +x 17560 $as_echo "$at_srcdir/output.at:230: bison -o \"@{.c\" --defines=\"@{.h\" cxx.y" 17561 at_fn_check_prepare_trace "output.at:230" 17562 ( $at_check_trace; bison -o "@{.c" --defines="@{.h" cxx.y 17563 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17564 at_status=$? at_failed=false 17565 $at_check_filter 17566 at_fn_diff_devnull "$at_stderr" || at_failed=: 17567 at_fn_diff_devnull "$at_stdout" || at_failed=: 17568 at_fn_check_status 0 $at_status "$at_srcdir/output.at:230" 17569 $at_failed && at_fn_log_failure 17570 $at_traceon; } 17571 17572 17573 { set +x 17574 $as_echo "$at_srcdir/output.at:230: ls \"@{.c\" \"@{.h\"" 17575 at_fn_check_prepare_trace "output.at:230" 17576 ( $at_check_trace; ls "@{.c" "@{.h" 17577 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17578 at_status=$? at_failed=false 17579 $at_check_filter 17580 at_fn_diff_devnull "$at_stderr" || at_failed=: 17581 echo stdout:; cat "$at_stdout" 17582 at_fn_check_status 0 $at_status "$at_srcdir/output.at:230" 17583 $at_failed && at_fn_log_failure 17584 $at_traceon; } 17585 17586 17587 { set +x 17588 $as_echo "$at_srcdir/output.at:230: \$BISON_CXX_WORKS" 17589 at_fn_check_prepare_dynamic "$BISON_CXX_WORKS" "output.at:230" 17590 ( $at_check_trace; $BISON_CXX_WORKS 17591 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17592 at_status=$? at_failed=false 17593 $at_check_filter 17594 echo stderr:; cat "$at_stderr" 17595 echo stdout:; cat "$at_stdout" 17596 at_fn_check_status 0 $at_status "$at_srcdir/output.at:230" 17597 $at_failed && at_fn_log_failure 17598 $at_traceon; } 17599 17600 { set +x 17601 $as_echo "$at_srcdir/output.at:230: \$CXX \$CXXFLAGS \$CPPFLAGS -c -o cxx.o -c \"@{.c\" " 17602 at_fn_check_prepare_dynamic "$CXX $CXXFLAGS $CPPFLAGS -c -o cxx.o -c \"@{.c\" " "output.at:230" 17603 ( $at_check_trace; $CXX $CXXFLAGS $CPPFLAGS -c -o cxx.o -c "@{.c" 17604 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17605 at_status=$? at_failed=false 17606 $at_check_filter 17607 echo stderr:; cat "$at_stderr" 17608 echo stdout:; cat "$at_stdout" 17609 at_fn_check_status 0 $at_status "$at_srcdir/output.at:230" 17610 $at_failed && at_fn_log_failure 17611 $at_traceon; } 17612 17613 17614 17615 17616 set +x 17617 $at_times_p && times >"$at_times_file" 17618 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 17619 read at_status <"$at_status_file" 17620 #AT_STOP_82 17621 #AT_START_83 17622 at_fn_group_banner 83 'output.at:231' \ 17623 "Output file name: @}" " " 3 17624 at_xfail=no 17625 ( 17626 $as_echo "83. $at_setup_line: testing $at_desc ..." 17627 $at_traceon 17628 17629 17630 17631 # Skip if platform doesn't support file name. For example, Cygwin 17632 # doesn't support file names containing ":" or "\". 17633 { set +x 17634 $as_echo "$at_srcdir/output.at:231: touch \"@}.tmp\" || exit 77" 17635 at_fn_check_prepare_trace "output.at:231" 17636 ( $at_check_trace; touch "@}.tmp" || exit 77 17637 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17638 at_status=$? at_failed=false 17639 $at_check_filter 17640 at_fn_diff_devnull "$at_stderr" || at_failed=: 17641 at_fn_diff_devnull "$at_stdout" || at_failed=: 17642 at_fn_check_status 0 $at_status "$at_srcdir/output.at:231" 17643 $at_failed && at_fn_log_failure 17644 $at_traceon; } 17645 17646 17647 cat >glr.y <<'_ATEOF' 17648 %code top { 17649 #include <config.h> 17650 /* We don't need perfect functions for these tests. */ 17651 #undef malloc 17652 #undef memcmp 17653 #undef realloc 17654 } 17655 17656 %glr-parser 17657 %code { 17658 void yyerror ( const char *msg); 17659 int yylex (void); 17660 } 17661 %% 17662 start: {}; 17663 _ATEOF 17664 17665 17666 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 17667 at_save_special_files 17668 mkdir xml-tests 17669 # Don't combine these Bison invocations since we want to be sure that 17670 # --report=all isn't required to get the full XML file. 17671 { set +x 17672 $as_echo "$at_srcdir/output.at:231: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 17673 --graph=xml-tests/test.dot -o \"@}.c\" --defines=\"@}.h\" glr.y" 17674 at_fn_check_prepare_notrace 'an embedded newline' "output.at:231" 17675 ( $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 \ 17676 --graph=xml-tests/test.dot -o "@}.c" --defines="@}.h" glr.y 17677 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17678 at_status=$? at_failed=false 17679 $at_check_filter 17680 echo stderr:; cat "$at_stderr" 17681 echo stdout:; cat "$at_stdout" 17682 at_fn_check_status 0 $at_status "$at_srcdir/output.at:231" 17683 $at_failed && at_fn_log_failure 17684 $at_traceon; } 17685 17686 { set +x 17687 $as_echo "$at_srcdir/output.at:231: 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" 17688 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:231" 17689 ( $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 17690 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17691 at_status=$? at_failed=false 17692 $at_check_filter 17693 echo stderr:; cat "$at_stderr" 17694 echo stdout:; cat "$at_stdout" 17695 at_fn_check_status 0 $at_status "$at_srcdir/output.at:231" 17696 $at_failed && at_fn_log_failure 17697 $at_traceon; } 17698 17699 cp xml-tests/test.output expout 17700 { set +x 17701 $as_echo "$at_srcdir/output.at:231: \$XSLTPROC \\ 17702 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 17703 xml-tests/test.xml" 17704 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:231" 17705 ( $at_check_trace; $XSLTPROC \ 17706 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 17707 xml-tests/test.xml 17708 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17709 at_status=$? at_failed=false 17710 $at_check_filter 17711 at_fn_diff_devnull "$at_stderr" || at_failed=: 17712 $at_diff expout "$at_stdout" || at_failed=: 17713 at_fn_check_status 0 $at_status "$at_srcdir/output.at:231" 17714 $at_failed && at_fn_log_failure 17715 $at_traceon; } 17716 17717 sort xml-tests/test.dot > expout 17718 { set +x 17719 $as_echo "$at_srcdir/output.at:231: \$XSLTPROC \\ 17720 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 17721 xml-tests/test.xml | sort" 17722 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:231" 17723 ( $at_check_trace; $XSLTPROC \ 17724 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 17725 xml-tests/test.xml | sort 17726 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17727 at_status=$? at_failed=false 17728 $at_check_filter 17729 at_fn_diff_devnull "$at_stderr" || at_failed=: 17730 $at_diff expout "$at_stdout" || at_failed=: 17731 at_fn_check_status 0 $at_status "$at_srcdir/output.at:231" 17732 $at_failed && at_fn_log_failure 17733 $at_traceon; } 17734 17735 rm -rf xml-tests expout 17736 at_restore_special_files 17737 fi 17738 { set +x 17739 $as_echo "$at_srcdir/output.at:231: bison -o \"@}.c\" --defines=\"@}.h\" glr.y" 17740 at_fn_check_prepare_trace "output.at:231" 17741 ( $at_check_trace; bison -o "@}.c" --defines="@}.h" glr.y 17742 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17743 at_status=$? at_failed=false 17744 $at_check_filter 17745 at_fn_diff_devnull "$at_stderr" || at_failed=: 17746 at_fn_diff_devnull "$at_stdout" || at_failed=: 17747 at_fn_check_status 0 $at_status "$at_srcdir/output.at:231" 17748 $at_failed && at_fn_log_failure 17749 $at_traceon; } 17750 17751 17752 { set +x 17753 $as_echo "$at_srcdir/output.at:231: ls \"@}.c\" \"@}.h\"" 17754 at_fn_check_prepare_trace "output.at:231" 17755 ( $at_check_trace; ls "@}.c" "@}.h" 17756 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17757 at_status=$? at_failed=false 17758 $at_check_filter 17759 at_fn_diff_devnull "$at_stderr" || at_failed=: 17760 echo stdout:; cat "$at_stdout" 17761 at_fn_check_status 0 $at_status "$at_srcdir/output.at:231" 17762 $at_failed && at_fn_log_failure 17763 $at_traceon; } 17764 17765 { set +x 17766 $as_echo "$at_srcdir/output.at:231: \$BISON_C_WORKS" 17767 at_fn_check_prepare_dynamic "$BISON_C_WORKS" "output.at:231" 17768 ( $at_check_trace; $BISON_C_WORKS 17769 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17770 at_status=$? at_failed=false 17771 $at_check_filter 17772 echo stderr:; cat "$at_stderr" 17773 echo stdout:; cat "$at_stdout" 17774 at_fn_check_status 0 $at_status "$at_srcdir/output.at:231" 17775 $at_failed && at_fn_log_failure 17776 $at_traceon; } 17777 17778 { set +x 17779 $as_echo "$at_srcdir/output.at:231: \$CC \$CFLAGS \$CPPFLAGS -c -o glr.o -c \"@}.c\" " 17780 at_fn_check_prepare_dynamic "$CC $CFLAGS $CPPFLAGS -c -o glr.o -c \"@}.c\" " "output.at:231" 17781 ( $at_check_trace; $CC $CFLAGS $CPPFLAGS -c -o glr.o -c "@}.c" 17782 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17783 at_status=$? at_failed=false 17784 $at_check_filter 17785 echo stderr:; cat "$at_stderr" 17786 echo stdout:; cat "$at_stdout" 17787 at_fn_check_status 0 $at_status "$at_srcdir/output.at:231" 17788 $at_failed && at_fn_log_failure 17789 $at_traceon; } 17790 17791 17792 17793 cat >cxx.y <<'_ATEOF' 17794 %code top { 17795 #include <config.h> 17796 /* We don't need perfect functions for these tests. */ 17797 #undef malloc 17798 #undef memcmp 17799 #undef realloc 17800 } 17801 17802 %skeleton "lalr1.cc" 17803 %code { int yylex (yy::parser::semantic_type*); } 17804 %% 17805 start: {}; 17806 _ATEOF 17807 17808 17809 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 17810 at_save_special_files 17811 mkdir xml-tests 17812 # Don't combine these Bison invocations since we want to be sure that 17813 # --report=all isn't required to get the full XML file. 17814 { set +x 17815 $as_echo "$at_srcdir/output.at:231: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 17816 --graph=xml-tests/test.dot -o \"@}.c\" --defines=\"@}.h\" cxx.y" 17817 at_fn_check_prepare_notrace 'an embedded newline' "output.at:231" 17818 ( $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 \ 17819 --graph=xml-tests/test.dot -o "@}.c" --defines="@}.h" cxx.y 17820 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17821 at_status=$? at_failed=false 17822 $at_check_filter 17823 echo stderr:; cat "$at_stderr" 17824 echo stdout:; cat "$at_stdout" 17825 at_fn_check_status 0 $at_status "$at_srcdir/output.at:231" 17826 $at_failed && at_fn_log_failure 17827 $at_traceon; } 17828 17829 { set +x 17830 $as_echo "$at_srcdir/output.at:231: 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" 17831 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:231" 17832 ( $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 17833 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17834 at_status=$? at_failed=false 17835 $at_check_filter 17836 echo stderr:; cat "$at_stderr" 17837 echo stdout:; cat "$at_stdout" 17838 at_fn_check_status 0 $at_status "$at_srcdir/output.at:231" 17839 $at_failed && at_fn_log_failure 17840 $at_traceon; } 17841 17842 cp xml-tests/test.output expout 17843 { set +x 17844 $as_echo "$at_srcdir/output.at:231: \$XSLTPROC \\ 17845 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 17846 xml-tests/test.xml" 17847 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:231" 17848 ( $at_check_trace; $XSLTPROC \ 17849 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 17850 xml-tests/test.xml 17851 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17852 at_status=$? at_failed=false 17853 $at_check_filter 17854 at_fn_diff_devnull "$at_stderr" || at_failed=: 17855 $at_diff expout "$at_stdout" || at_failed=: 17856 at_fn_check_status 0 $at_status "$at_srcdir/output.at:231" 17857 $at_failed && at_fn_log_failure 17858 $at_traceon; } 17859 17860 sort xml-tests/test.dot > expout 17861 { set +x 17862 $as_echo "$at_srcdir/output.at:231: \$XSLTPROC \\ 17863 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 17864 xml-tests/test.xml | sort" 17865 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:231" 17866 ( $at_check_trace; $XSLTPROC \ 17867 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 17868 xml-tests/test.xml | sort 17869 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17870 at_status=$? at_failed=false 17871 $at_check_filter 17872 at_fn_diff_devnull "$at_stderr" || at_failed=: 17873 $at_diff expout "$at_stdout" || at_failed=: 17874 at_fn_check_status 0 $at_status "$at_srcdir/output.at:231" 17875 $at_failed && at_fn_log_failure 17876 $at_traceon; } 17877 17878 rm -rf xml-tests expout 17879 at_restore_special_files 17880 fi 17881 { set +x 17882 $as_echo "$at_srcdir/output.at:231: bison -o \"@}.c\" --defines=\"@}.h\" cxx.y" 17883 at_fn_check_prepare_trace "output.at:231" 17884 ( $at_check_trace; bison -o "@}.c" --defines="@}.h" cxx.y 17885 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17886 at_status=$? at_failed=false 17887 $at_check_filter 17888 at_fn_diff_devnull "$at_stderr" || at_failed=: 17889 at_fn_diff_devnull "$at_stdout" || at_failed=: 17890 at_fn_check_status 0 $at_status "$at_srcdir/output.at:231" 17891 $at_failed && at_fn_log_failure 17892 $at_traceon; } 17893 17894 17895 { set +x 17896 $as_echo "$at_srcdir/output.at:231: ls \"@}.c\" \"@}.h\"" 17897 at_fn_check_prepare_trace "output.at:231" 17898 ( $at_check_trace; ls "@}.c" "@}.h" 17899 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17900 at_status=$? at_failed=false 17901 $at_check_filter 17902 at_fn_diff_devnull "$at_stderr" || at_failed=: 17903 echo stdout:; cat "$at_stdout" 17904 at_fn_check_status 0 $at_status "$at_srcdir/output.at:231" 17905 $at_failed && at_fn_log_failure 17906 $at_traceon; } 17907 17908 17909 { set +x 17910 $as_echo "$at_srcdir/output.at:231: \$BISON_CXX_WORKS" 17911 at_fn_check_prepare_dynamic "$BISON_CXX_WORKS" "output.at:231" 17912 ( $at_check_trace; $BISON_CXX_WORKS 17913 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17914 at_status=$? at_failed=false 17915 $at_check_filter 17916 echo stderr:; cat "$at_stderr" 17917 echo stdout:; cat "$at_stdout" 17918 at_fn_check_status 0 $at_status "$at_srcdir/output.at:231" 17919 $at_failed && at_fn_log_failure 17920 $at_traceon; } 17921 17922 { set +x 17923 $as_echo "$at_srcdir/output.at:231: \$CXX \$CXXFLAGS \$CPPFLAGS -c -o cxx.o -c \"@}.c\" " 17924 at_fn_check_prepare_dynamic "$CXX $CXXFLAGS $CPPFLAGS -c -o cxx.o -c \"@}.c\" " "output.at:231" 17925 ( $at_check_trace; $CXX $CXXFLAGS $CPPFLAGS -c -o cxx.o -c "@}.c" 17926 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17927 at_status=$? at_failed=false 17928 $at_check_filter 17929 echo stderr:; cat "$at_stderr" 17930 echo stdout:; cat "$at_stdout" 17931 at_fn_check_status 0 $at_status "$at_srcdir/output.at:231" 17932 $at_failed && at_fn_log_failure 17933 $at_traceon; } 17934 17935 17936 17937 17938 set +x 17939 $at_times_p && times >"$at_times_file" 17940 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 17941 read at_status <"$at_status_file" 17942 #AT_STOP_83 17943 #AT_START_84 17944 at_fn_group_banner 84 'output.at:232' \ 17945 "Output file name: [" " " 3 17946 at_xfail=no 17947 ( 17948 $as_echo "84. $at_setup_line: testing $at_desc ..." 17949 $at_traceon 17950 17951 17952 17953 # Skip if platform doesn't support file name. For example, Cygwin 17954 # doesn't support file names containing ":" or "\". 17955 { set +x 17956 $as_echo "$at_srcdir/output.at:232: touch \"[.tmp\" || exit 77" 17957 at_fn_check_prepare_trace "output.at:232" 17958 ( $at_check_trace; touch "[.tmp" || exit 77 17959 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 17960 at_status=$? at_failed=false 17961 $at_check_filter 17962 at_fn_diff_devnull "$at_stderr" || at_failed=: 17963 at_fn_diff_devnull "$at_stdout" || at_failed=: 17964 at_fn_check_status 0 $at_status "$at_srcdir/output.at:232" 17965 $at_failed && at_fn_log_failure 17966 $at_traceon; } 17967 17968 17969 cat >glr.y <<'_ATEOF' 17970 %code top { 17971 #include <config.h> 17972 /* We don't need perfect functions for these tests. */ 17973 #undef malloc 17974 #undef memcmp 17975 #undef realloc 17976 } 17977 17978 %glr-parser 17979 %code { 17980 void yyerror ( const char *msg); 17981 int yylex (void); 17982 } 17983 %% 17984 start: {}; 17985 _ATEOF 17986 17987 17988 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 17989 at_save_special_files 17990 mkdir xml-tests 17991 # Don't combine these Bison invocations since we want to be sure that 17992 # --report=all isn't required to get the full XML file. 17993 { set +x 17994 $as_echo "$at_srcdir/output.at:232: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 17995 --graph=xml-tests/test.dot -o \"[.c\" --defines=\"[.h\" glr.y" 17996 at_fn_check_prepare_notrace 'an embedded newline' "output.at:232" 17997 ( $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 \ 17998 --graph=xml-tests/test.dot -o "[.c" --defines="[.h" glr.y 17999 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18000 at_status=$? at_failed=false 18001 $at_check_filter 18002 echo stderr:; cat "$at_stderr" 18003 echo stdout:; cat "$at_stdout" 18004 at_fn_check_status 0 $at_status "$at_srcdir/output.at:232" 18005 $at_failed && at_fn_log_failure 18006 $at_traceon; } 18007 18008 { set +x 18009 $as_echo "$at_srcdir/output.at:232: 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" 18010 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:232" 18011 ( $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 18012 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18013 at_status=$? at_failed=false 18014 $at_check_filter 18015 echo stderr:; cat "$at_stderr" 18016 echo stdout:; cat "$at_stdout" 18017 at_fn_check_status 0 $at_status "$at_srcdir/output.at:232" 18018 $at_failed && at_fn_log_failure 18019 $at_traceon; } 18020 18021 cp xml-tests/test.output expout 18022 { set +x 18023 $as_echo "$at_srcdir/output.at:232: \$XSLTPROC \\ 18024 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 18025 xml-tests/test.xml" 18026 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:232" 18027 ( $at_check_trace; $XSLTPROC \ 18028 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 18029 xml-tests/test.xml 18030 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18031 at_status=$? at_failed=false 18032 $at_check_filter 18033 at_fn_diff_devnull "$at_stderr" || at_failed=: 18034 $at_diff expout "$at_stdout" || at_failed=: 18035 at_fn_check_status 0 $at_status "$at_srcdir/output.at:232" 18036 $at_failed && at_fn_log_failure 18037 $at_traceon; } 18038 18039 sort xml-tests/test.dot > expout 18040 { set +x 18041 $as_echo "$at_srcdir/output.at:232: \$XSLTPROC \\ 18042 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 18043 xml-tests/test.xml | sort" 18044 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:232" 18045 ( $at_check_trace; $XSLTPROC \ 18046 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 18047 xml-tests/test.xml | sort 18048 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18049 at_status=$? at_failed=false 18050 $at_check_filter 18051 at_fn_diff_devnull "$at_stderr" || at_failed=: 18052 $at_diff expout "$at_stdout" || at_failed=: 18053 at_fn_check_status 0 $at_status "$at_srcdir/output.at:232" 18054 $at_failed && at_fn_log_failure 18055 $at_traceon; } 18056 18057 rm -rf xml-tests expout 18058 at_restore_special_files 18059 fi 18060 { set +x 18061 $as_echo "$at_srcdir/output.at:232: bison -o \"[.c\" --defines=\"[.h\" glr.y" 18062 at_fn_check_prepare_trace "output.at:232" 18063 ( $at_check_trace; bison -o "[.c" --defines="[.h" glr.y 18064 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18065 at_status=$? at_failed=false 18066 $at_check_filter 18067 at_fn_diff_devnull "$at_stderr" || at_failed=: 18068 at_fn_diff_devnull "$at_stdout" || at_failed=: 18069 at_fn_check_status 0 $at_status "$at_srcdir/output.at:232" 18070 $at_failed && at_fn_log_failure 18071 $at_traceon; } 18072 18073 18074 { set +x 18075 $as_echo "$at_srcdir/output.at:232: ls \"[.c\" \"[.h\"" 18076 at_fn_check_prepare_trace "output.at:232" 18077 ( $at_check_trace; ls "[.c" "[.h" 18078 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18079 at_status=$? at_failed=false 18080 $at_check_filter 18081 at_fn_diff_devnull "$at_stderr" || at_failed=: 18082 echo stdout:; cat "$at_stdout" 18083 at_fn_check_status 0 $at_status "$at_srcdir/output.at:232" 18084 $at_failed && at_fn_log_failure 18085 $at_traceon; } 18086 18087 { set +x 18088 $as_echo "$at_srcdir/output.at:232: \$BISON_C_WORKS" 18089 at_fn_check_prepare_dynamic "$BISON_C_WORKS" "output.at:232" 18090 ( $at_check_trace; $BISON_C_WORKS 18091 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18092 at_status=$? at_failed=false 18093 $at_check_filter 18094 echo stderr:; cat "$at_stderr" 18095 echo stdout:; cat "$at_stdout" 18096 at_fn_check_status 0 $at_status "$at_srcdir/output.at:232" 18097 $at_failed && at_fn_log_failure 18098 $at_traceon; } 18099 18100 { set +x 18101 $as_echo "$at_srcdir/output.at:232: \$CC \$CFLAGS \$CPPFLAGS -c -o glr.o -c \"[.c\" " 18102 at_fn_check_prepare_dynamic "$CC $CFLAGS $CPPFLAGS -c -o glr.o -c \"[.c\" " "output.at:232" 18103 ( $at_check_trace; $CC $CFLAGS $CPPFLAGS -c -o glr.o -c "[.c" 18104 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18105 at_status=$? at_failed=false 18106 $at_check_filter 18107 echo stderr:; cat "$at_stderr" 18108 echo stdout:; cat "$at_stdout" 18109 at_fn_check_status 0 $at_status "$at_srcdir/output.at:232" 18110 $at_failed && at_fn_log_failure 18111 $at_traceon; } 18112 18113 18114 18115 cat >cxx.y <<'_ATEOF' 18116 %code top { 18117 #include <config.h> 18118 /* We don't need perfect functions for these tests. */ 18119 #undef malloc 18120 #undef memcmp 18121 #undef realloc 18122 } 18123 18124 %skeleton "lalr1.cc" 18125 %code { int yylex (yy::parser::semantic_type*); } 18126 %% 18127 start: {}; 18128 _ATEOF 18129 18130 18131 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 18132 at_save_special_files 18133 mkdir xml-tests 18134 # Don't combine these Bison invocations since we want to be sure that 18135 # --report=all isn't required to get the full XML file. 18136 { set +x 18137 $as_echo "$at_srcdir/output.at:232: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 18138 --graph=xml-tests/test.dot -o \"[.c\" --defines=\"[.h\" cxx.y" 18139 at_fn_check_prepare_notrace 'an embedded newline' "output.at:232" 18140 ( $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 \ 18141 --graph=xml-tests/test.dot -o "[.c" --defines="[.h" cxx.y 18142 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18143 at_status=$? at_failed=false 18144 $at_check_filter 18145 echo stderr:; cat "$at_stderr" 18146 echo stdout:; cat "$at_stdout" 18147 at_fn_check_status 0 $at_status "$at_srcdir/output.at:232" 18148 $at_failed && at_fn_log_failure 18149 $at_traceon; } 18150 18151 { set +x 18152 $as_echo "$at_srcdir/output.at:232: 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" 18153 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:232" 18154 ( $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 18155 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18156 at_status=$? at_failed=false 18157 $at_check_filter 18158 echo stderr:; cat "$at_stderr" 18159 echo stdout:; cat "$at_stdout" 18160 at_fn_check_status 0 $at_status "$at_srcdir/output.at:232" 18161 $at_failed && at_fn_log_failure 18162 $at_traceon; } 18163 18164 cp xml-tests/test.output expout 18165 { set +x 18166 $as_echo "$at_srcdir/output.at:232: \$XSLTPROC \\ 18167 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 18168 xml-tests/test.xml" 18169 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:232" 18170 ( $at_check_trace; $XSLTPROC \ 18171 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 18172 xml-tests/test.xml 18173 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18174 at_status=$? at_failed=false 18175 $at_check_filter 18176 at_fn_diff_devnull "$at_stderr" || at_failed=: 18177 $at_diff expout "$at_stdout" || at_failed=: 18178 at_fn_check_status 0 $at_status "$at_srcdir/output.at:232" 18179 $at_failed && at_fn_log_failure 18180 $at_traceon; } 18181 18182 sort xml-tests/test.dot > expout 18183 { set +x 18184 $as_echo "$at_srcdir/output.at:232: \$XSLTPROC \\ 18185 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 18186 xml-tests/test.xml | sort" 18187 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:232" 18188 ( $at_check_trace; $XSLTPROC \ 18189 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 18190 xml-tests/test.xml | sort 18191 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18192 at_status=$? at_failed=false 18193 $at_check_filter 18194 at_fn_diff_devnull "$at_stderr" || at_failed=: 18195 $at_diff expout "$at_stdout" || at_failed=: 18196 at_fn_check_status 0 $at_status "$at_srcdir/output.at:232" 18197 $at_failed && at_fn_log_failure 18198 $at_traceon; } 18199 18200 rm -rf xml-tests expout 18201 at_restore_special_files 18202 fi 18203 { set +x 18204 $as_echo "$at_srcdir/output.at:232: bison -o \"[.c\" --defines=\"[.h\" cxx.y" 18205 at_fn_check_prepare_trace "output.at:232" 18206 ( $at_check_trace; bison -o "[.c" --defines="[.h" cxx.y 18207 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18208 at_status=$? at_failed=false 18209 $at_check_filter 18210 at_fn_diff_devnull "$at_stderr" || at_failed=: 18211 at_fn_diff_devnull "$at_stdout" || at_failed=: 18212 at_fn_check_status 0 $at_status "$at_srcdir/output.at:232" 18213 $at_failed && at_fn_log_failure 18214 $at_traceon; } 18215 18216 18217 { set +x 18218 $as_echo "$at_srcdir/output.at:232: ls \"[.c\" \"[.h\"" 18219 at_fn_check_prepare_trace "output.at:232" 18220 ( $at_check_trace; ls "[.c" "[.h" 18221 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18222 at_status=$? at_failed=false 18223 $at_check_filter 18224 at_fn_diff_devnull "$at_stderr" || at_failed=: 18225 echo stdout:; cat "$at_stdout" 18226 at_fn_check_status 0 $at_status "$at_srcdir/output.at:232" 18227 $at_failed && at_fn_log_failure 18228 $at_traceon; } 18229 18230 18231 { set +x 18232 $as_echo "$at_srcdir/output.at:232: \$BISON_CXX_WORKS" 18233 at_fn_check_prepare_dynamic "$BISON_CXX_WORKS" "output.at:232" 18234 ( $at_check_trace; $BISON_CXX_WORKS 18235 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18236 at_status=$? at_failed=false 18237 $at_check_filter 18238 echo stderr:; cat "$at_stderr" 18239 echo stdout:; cat "$at_stdout" 18240 at_fn_check_status 0 $at_status "$at_srcdir/output.at:232" 18241 $at_failed && at_fn_log_failure 18242 $at_traceon; } 18243 18244 { set +x 18245 $as_echo "$at_srcdir/output.at:232: \$CXX \$CXXFLAGS \$CPPFLAGS -c -o cxx.o -c \"[.c\" " 18246 at_fn_check_prepare_dynamic "$CXX $CXXFLAGS $CPPFLAGS -c -o cxx.o -c \"[.c\" " "output.at:232" 18247 ( $at_check_trace; $CXX $CXXFLAGS $CPPFLAGS -c -o cxx.o -c "[.c" 18248 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18249 at_status=$? at_failed=false 18250 $at_check_filter 18251 echo stderr:; cat "$at_stderr" 18252 echo stdout:; cat "$at_stdout" 18253 at_fn_check_status 0 $at_status "$at_srcdir/output.at:232" 18254 $at_failed && at_fn_log_failure 18255 $at_traceon; } 18256 18257 18258 18259 18260 set +x 18261 $at_times_p && times >"$at_times_file" 18262 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 18263 read at_status <"$at_status_file" 18264 #AT_STOP_84 18265 #AT_START_85 18266 at_fn_group_banner 85 'output.at:233' \ 18267 "Output file name: ]" " " 3 18268 at_xfail=no 18269 ( 18270 $as_echo "85. $at_setup_line: testing $at_desc ..." 18271 $at_traceon 18272 18273 18274 18275 # Skip if platform doesn't support file name. For example, Cygwin 18276 # doesn't support file names containing ":" or "\". 18277 { set +x 18278 $as_echo "$at_srcdir/output.at:233: touch \"].tmp\" || exit 77" 18279 at_fn_check_prepare_trace "output.at:233" 18280 ( $at_check_trace; touch "].tmp" || exit 77 18281 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18282 at_status=$? at_failed=false 18283 $at_check_filter 18284 at_fn_diff_devnull "$at_stderr" || at_failed=: 18285 at_fn_diff_devnull "$at_stdout" || at_failed=: 18286 at_fn_check_status 0 $at_status "$at_srcdir/output.at:233" 18287 $at_failed && at_fn_log_failure 18288 $at_traceon; } 18289 18290 18291 cat >glr.y <<'_ATEOF' 18292 %code top { 18293 #include <config.h> 18294 /* We don't need perfect functions for these tests. */ 18295 #undef malloc 18296 #undef memcmp 18297 #undef realloc 18298 } 18299 18300 %glr-parser 18301 %code { 18302 void yyerror ( const char *msg); 18303 int yylex (void); 18304 } 18305 %% 18306 start: {}; 18307 _ATEOF 18308 18309 18310 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 18311 at_save_special_files 18312 mkdir xml-tests 18313 # Don't combine these Bison invocations since we want to be sure that 18314 # --report=all isn't required to get the full XML file. 18315 { set +x 18316 $as_echo "$at_srcdir/output.at:233: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 18317 --graph=xml-tests/test.dot -o \"].c\" --defines=\"].h\" glr.y" 18318 at_fn_check_prepare_notrace 'an embedded newline' "output.at:233" 18319 ( $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 \ 18320 --graph=xml-tests/test.dot -o "].c" --defines="].h" glr.y 18321 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18322 at_status=$? at_failed=false 18323 $at_check_filter 18324 echo stderr:; cat "$at_stderr" 18325 echo stdout:; cat "$at_stdout" 18326 at_fn_check_status 0 $at_status "$at_srcdir/output.at:233" 18327 $at_failed && at_fn_log_failure 18328 $at_traceon; } 18329 18330 { set +x 18331 $as_echo "$at_srcdir/output.at:233: 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" 18332 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:233" 18333 ( $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 18334 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18335 at_status=$? at_failed=false 18336 $at_check_filter 18337 echo stderr:; cat "$at_stderr" 18338 echo stdout:; cat "$at_stdout" 18339 at_fn_check_status 0 $at_status "$at_srcdir/output.at:233" 18340 $at_failed && at_fn_log_failure 18341 $at_traceon; } 18342 18343 cp xml-tests/test.output expout 18344 { set +x 18345 $as_echo "$at_srcdir/output.at:233: \$XSLTPROC \\ 18346 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 18347 xml-tests/test.xml" 18348 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:233" 18349 ( $at_check_trace; $XSLTPROC \ 18350 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 18351 xml-tests/test.xml 18352 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18353 at_status=$? at_failed=false 18354 $at_check_filter 18355 at_fn_diff_devnull "$at_stderr" || at_failed=: 18356 $at_diff expout "$at_stdout" || at_failed=: 18357 at_fn_check_status 0 $at_status "$at_srcdir/output.at:233" 18358 $at_failed && at_fn_log_failure 18359 $at_traceon; } 18360 18361 sort xml-tests/test.dot > expout 18362 { set +x 18363 $as_echo "$at_srcdir/output.at:233: \$XSLTPROC \\ 18364 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 18365 xml-tests/test.xml | sort" 18366 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:233" 18367 ( $at_check_trace; $XSLTPROC \ 18368 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 18369 xml-tests/test.xml | sort 18370 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18371 at_status=$? at_failed=false 18372 $at_check_filter 18373 at_fn_diff_devnull "$at_stderr" || at_failed=: 18374 $at_diff expout "$at_stdout" || at_failed=: 18375 at_fn_check_status 0 $at_status "$at_srcdir/output.at:233" 18376 $at_failed && at_fn_log_failure 18377 $at_traceon; } 18378 18379 rm -rf xml-tests expout 18380 at_restore_special_files 18381 fi 18382 { set +x 18383 $as_echo "$at_srcdir/output.at:233: bison -o \"].c\" --defines=\"].h\" glr.y" 18384 at_fn_check_prepare_trace "output.at:233" 18385 ( $at_check_trace; bison -o "].c" --defines="].h" glr.y 18386 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18387 at_status=$? at_failed=false 18388 $at_check_filter 18389 at_fn_diff_devnull "$at_stderr" || at_failed=: 18390 at_fn_diff_devnull "$at_stdout" || at_failed=: 18391 at_fn_check_status 0 $at_status "$at_srcdir/output.at:233" 18392 $at_failed && at_fn_log_failure 18393 $at_traceon; } 18394 18395 18396 { set +x 18397 $as_echo "$at_srcdir/output.at:233: ls \"].c\" \"].h\"" 18398 at_fn_check_prepare_trace "output.at:233" 18399 ( $at_check_trace; ls "].c" "].h" 18400 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18401 at_status=$? at_failed=false 18402 $at_check_filter 18403 at_fn_diff_devnull "$at_stderr" || at_failed=: 18404 echo stdout:; cat "$at_stdout" 18405 at_fn_check_status 0 $at_status "$at_srcdir/output.at:233" 18406 $at_failed && at_fn_log_failure 18407 $at_traceon; } 18408 18409 { set +x 18410 $as_echo "$at_srcdir/output.at:233: \$BISON_C_WORKS" 18411 at_fn_check_prepare_dynamic "$BISON_C_WORKS" "output.at:233" 18412 ( $at_check_trace; $BISON_C_WORKS 18413 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18414 at_status=$? at_failed=false 18415 $at_check_filter 18416 echo stderr:; cat "$at_stderr" 18417 echo stdout:; cat "$at_stdout" 18418 at_fn_check_status 0 $at_status "$at_srcdir/output.at:233" 18419 $at_failed && at_fn_log_failure 18420 $at_traceon; } 18421 18422 { set +x 18423 $as_echo "$at_srcdir/output.at:233: \$CC \$CFLAGS \$CPPFLAGS -c -o glr.o -c \"].c\" " 18424 at_fn_check_prepare_dynamic "$CC $CFLAGS $CPPFLAGS -c -o glr.o -c \"].c\" " "output.at:233" 18425 ( $at_check_trace; $CC $CFLAGS $CPPFLAGS -c -o glr.o -c "].c" 18426 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18427 at_status=$? at_failed=false 18428 $at_check_filter 18429 echo stderr:; cat "$at_stderr" 18430 echo stdout:; cat "$at_stdout" 18431 at_fn_check_status 0 $at_status "$at_srcdir/output.at:233" 18432 $at_failed && at_fn_log_failure 18433 $at_traceon; } 18434 18435 18436 18437 cat >cxx.y <<'_ATEOF' 18438 %code top { 18439 #include <config.h> 18440 /* We don't need perfect functions for these tests. */ 18441 #undef malloc 18442 #undef memcmp 18443 #undef realloc 18444 } 18445 18446 %skeleton "lalr1.cc" 18447 %code { int yylex (yy::parser::semantic_type*); } 18448 %% 18449 start: {}; 18450 _ATEOF 18451 18452 18453 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 18454 at_save_special_files 18455 mkdir xml-tests 18456 # Don't combine these Bison invocations since we want to be sure that 18457 # --report=all isn't required to get the full XML file. 18458 { set +x 18459 $as_echo "$at_srcdir/output.at:233: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 18460 --graph=xml-tests/test.dot -o \"].c\" --defines=\"].h\" cxx.y" 18461 at_fn_check_prepare_notrace 'an embedded newline' "output.at:233" 18462 ( $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 \ 18463 --graph=xml-tests/test.dot -o "].c" --defines="].h" cxx.y 18464 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18465 at_status=$? at_failed=false 18466 $at_check_filter 18467 echo stderr:; cat "$at_stderr" 18468 echo stdout:; cat "$at_stdout" 18469 at_fn_check_status 0 $at_status "$at_srcdir/output.at:233" 18470 $at_failed && at_fn_log_failure 18471 $at_traceon; } 18472 18473 { set +x 18474 $as_echo "$at_srcdir/output.at:233: 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" 18475 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:233" 18476 ( $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 18477 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18478 at_status=$? at_failed=false 18479 $at_check_filter 18480 echo stderr:; cat "$at_stderr" 18481 echo stdout:; cat "$at_stdout" 18482 at_fn_check_status 0 $at_status "$at_srcdir/output.at:233" 18483 $at_failed && at_fn_log_failure 18484 $at_traceon; } 18485 18486 cp xml-tests/test.output expout 18487 { set +x 18488 $as_echo "$at_srcdir/output.at:233: \$XSLTPROC \\ 18489 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 18490 xml-tests/test.xml" 18491 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:233" 18492 ( $at_check_trace; $XSLTPROC \ 18493 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 18494 xml-tests/test.xml 18495 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18496 at_status=$? at_failed=false 18497 $at_check_filter 18498 at_fn_diff_devnull "$at_stderr" || at_failed=: 18499 $at_diff expout "$at_stdout" || at_failed=: 18500 at_fn_check_status 0 $at_status "$at_srcdir/output.at:233" 18501 $at_failed && at_fn_log_failure 18502 $at_traceon; } 18503 18504 sort xml-tests/test.dot > expout 18505 { set +x 18506 $as_echo "$at_srcdir/output.at:233: \$XSLTPROC \\ 18507 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 18508 xml-tests/test.xml | sort" 18509 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:233" 18510 ( $at_check_trace; $XSLTPROC \ 18511 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 18512 xml-tests/test.xml | sort 18513 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18514 at_status=$? at_failed=false 18515 $at_check_filter 18516 at_fn_diff_devnull "$at_stderr" || at_failed=: 18517 $at_diff expout "$at_stdout" || at_failed=: 18518 at_fn_check_status 0 $at_status "$at_srcdir/output.at:233" 18519 $at_failed && at_fn_log_failure 18520 $at_traceon; } 18521 18522 rm -rf xml-tests expout 18523 at_restore_special_files 18524 fi 18525 { set +x 18526 $as_echo "$at_srcdir/output.at:233: bison -o \"].c\" --defines=\"].h\" cxx.y" 18527 at_fn_check_prepare_trace "output.at:233" 18528 ( $at_check_trace; bison -o "].c" --defines="].h" cxx.y 18529 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18530 at_status=$? at_failed=false 18531 $at_check_filter 18532 at_fn_diff_devnull "$at_stderr" || at_failed=: 18533 at_fn_diff_devnull "$at_stdout" || at_failed=: 18534 at_fn_check_status 0 $at_status "$at_srcdir/output.at:233" 18535 $at_failed && at_fn_log_failure 18536 $at_traceon; } 18537 18538 18539 { set +x 18540 $as_echo "$at_srcdir/output.at:233: ls \"].c\" \"].h\"" 18541 at_fn_check_prepare_trace "output.at:233" 18542 ( $at_check_trace; ls "].c" "].h" 18543 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18544 at_status=$? at_failed=false 18545 $at_check_filter 18546 at_fn_diff_devnull "$at_stderr" || at_failed=: 18547 echo stdout:; cat "$at_stdout" 18548 at_fn_check_status 0 $at_status "$at_srcdir/output.at:233" 18549 $at_failed && at_fn_log_failure 18550 $at_traceon; } 18551 18552 18553 { set +x 18554 $as_echo "$at_srcdir/output.at:233: \$BISON_CXX_WORKS" 18555 at_fn_check_prepare_dynamic "$BISON_CXX_WORKS" "output.at:233" 18556 ( $at_check_trace; $BISON_CXX_WORKS 18557 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18558 at_status=$? at_failed=false 18559 $at_check_filter 18560 echo stderr:; cat "$at_stderr" 18561 echo stdout:; cat "$at_stdout" 18562 at_fn_check_status 0 $at_status "$at_srcdir/output.at:233" 18563 $at_failed && at_fn_log_failure 18564 $at_traceon; } 18565 18566 { set +x 18567 $as_echo "$at_srcdir/output.at:233: \$CXX \$CXXFLAGS \$CPPFLAGS -c -o cxx.o -c \"].c\" " 18568 at_fn_check_prepare_dynamic "$CXX $CXXFLAGS $CPPFLAGS -c -o cxx.o -c \"].c\" " "output.at:233" 18569 ( $at_check_trace; $CXX $CXXFLAGS $CPPFLAGS -c -o cxx.o -c "].c" 18570 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18571 at_status=$? at_failed=false 18572 $at_check_filter 18573 echo stderr:; cat "$at_stderr" 18574 echo stdout:; cat "$at_stdout" 18575 at_fn_check_status 0 $at_status "$at_srcdir/output.at:233" 18576 $at_failed && at_fn_log_failure 18577 $at_traceon; } 18578 18579 18580 18581 18582 set +x 18583 $at_times_p && times >"$at_times_file" 18584 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 18585 read at_status <"$at_status_file" 18586 #AT_STOP_85 18587 #AT_START_86 18588 at_fn_group_banner 86 'output.at:260' \ 18589 "Graph with no conflicts" " " 3 18590 at_xfail=no 18591 ( 18592 $as_echo "86. $at_setup_line: testing $at_desc ..." 18593 $at_traceon 18594 18595 18596 cat >input.y <<'_ATEOF' 18597 %% 18598 exp: a '?' b; 18599 a: ; 18600 b: 'b'; 18601 _ATEOF 18602 18603 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 18604 at_save_special_files 18605 mkdir xml-tests 18606 # Don't combine these Bison invocations since we want to be sure that 18607 # --report=all isn't required to get the full XML file. 18608 { set +x 18609 $as_echo "$at_srcdir/output.at:260: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 18610 --graph=xml-tests/test.dot -rall --graph input.y" 18611 at_fn_check_prepare_notrace 'an embedded newline' "output.at:260" 18612 ( $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 \ 18613 --graph=xml-tests/test.dot -rall --graph input.y 18614 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18615 at_status=$? at_failed=false 18616 $at_check_filter 18617 echo stderr:; cat "$at_stderr" 18618 echo stdout:; cat "$at_stdout" 18619 at_fn_check_status 0 $at_status "$at_srcdir/output.at:260" 18620 $at_failed && at_fn_log_failure 18621 $at_traceon; } 18622 18623 { set +x 18624 $as_echo "$at_srcdir/output.at:260: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -rall --graph input.y" 18625 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -rall --graph input.y" "output.at:260" 18626 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -rall --graph input.y 18627 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18628 at_status=$? at_failed=false 18629 $at_check_filter 18630 echo stderr:; cat "$at_stderr" 18631 echo stdout:; cat "$at_stdout" 18632 at_fn_check_status 0 $at_status "$at_srcdir/output.at:260" 18633 $at_failed && at_fn_log_failure 18634 $at_traceon; } 18635 18636 cp xml-tests/test.output expout 18637 { set +x 18638 $as_echo "$at_srcdir/output.at:260: \$XSLTPROC \\ 18639 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 18640 xml-tests/test.xml" 18641 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:260" 18642 ( $at_check_trace; $XSLTPROC \ 18643 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 18644 xml-tests/test.xml 18645 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18646 at_status=$? at_failed=false 18647 $at_check_filter 18648 at_fn_diff_devnull "$at_stderr" || at_failed=: 18649 $at_diff expout "$at_stdout" || at_failed=: 18650 at_fn_check_status 0 $at_status "$at_srcdir/output.at:260" 18651 $at_failed && at_fn_log_failure 18652 $at_traceon; } 18653 18654 sort xml-tests/test.dot > expout 18655 { set +x 18656 $as_echo "$at_srcdir/output.at:260: \$XSLTPROC \\ 18657 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 18658 xml-tests/test.xml | sort" 18659 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:260" 18660 ( $at_check_trace; $XSLTPROC \ 18661 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 18662 xml-tests/test.xml | sort 18663 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18664 at_status=$? at_failed=false 18665 $at_check_filter 18666 at_fn_diff_devnull "$at_stderr" || at_failed=: 18667 $at_diff expout "$at_stdout" || at_failed=: 18668 at_fn_check_status 0 $at_status "$at_srcdir/output.at:260" 18669 $at_failed && at_fn_log_failure 18670 $at_traceon; } 18671 18672 rm -rf xml-tests expout 18673 at_restore_special_files 18674 fi 18675 { set +x 18676 $as_echo "$at_srcdir/output.at:260: bison -rall --graph input.y" 18677 at_fn_check_prepare_trace "output.at:260" 18678 ( $at_check_trace; bison -rall --graph input.y 18679 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18680 at_status=$? at_failed=false 18681 $at_check_filter 18682 echo stderr:; cat "$at_stderr" 18683 at_fn_diff_devnull "$at_stdout" || at_failed=: 18684 at_fn_check_status 0 $at_status "$at_srcdir/output.at:260" 18685 $at_failed && at_fn_log_failure 18686 $at_traceon; } 18687 18688 18689 { set +x 18690 $as_echo "$at_srcdir/output.at:260: grep -v // input.dot" 18691 at_fn_check_prepare_trace "output.at:260" 18692 ( $at_check_trace; grep -v // input.dot 18693 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18694 at_status=$? at_failed=false 18695 $at_check_filter 18696 at_fn_diff_devnull "$at_stderr" || at_failed=: 18697 echo >>"$at_stdout"; $as_echo " 18698 digraph \"input.y\" 18699 { 18700 node [fontname = courier, shape = box, colorscheme = paired6] 18701 edge [fontname = courier] 18702 18703 0 [label=\"State 0\\n\\l 0 \$accept: . exp \$end\\l 1 exp: . a '?' b\\l 2 a: .\\l\"] 18704 0 -> 1 [style=dashed label=\"exp\"] 18705 0 -> 2 [style=dashed label=\"a\"] 18706 0 -> \"0R2\" [style=solid] 18707 \"0R2\" [label=\"R2\", fillcolor=3, shape=diamond, style=filled] 18708 1 [label=\"State 1\\n\\l 0 \$accept: exp . \$end\\l\"] 18709 1 -> 3 [style=solid label=\"\$end\"] 18710 2 [label=\"State 2\\n\\l 1 exp: a . '?' b\\l\"] 18711 2 -> 4 [style=solid label=\"'?'\"] 18712 3 [label=\"State 3\\n\\l 0 \$accept: exp \$end .\\l\"] 18713 3 -> \"3R0\" [style=solid] 18714 \"3R0\" [label=\"Acc\", fillcolor=1, shape=diamond, style=filled] 18715 4 [label=\"State 4\\n\\l 1 exp: a '?' . b\\l 3 b: . 'b'\\l\"] 18716 4 -> 5 [style=solid label=\"'b'\"] 18717 4 -> 6 [style=dashed label=\"b\"] 18718 5 [label=\"State 5\\n\\l 3 b: 'b' .\\l\"] 18719 5 -> \"5R3\" [style=solid] 18720 \"5R3\" [label=\"R3\", fillcolor=3, shape=diamond, style=filled] 18721 6 [label=\"State 6\\n\\l 1 exp: a '?' b .\\l\"] 18722 6 -> \"6R1\" [style=solid] 18723 \"6R1\" [label=\"R1\", fillcolor=3, shape=diamond, style=filled] 18724 } 18725 " | \ 18726 $at_diff - "$at_stdout" || at_failed=: 18727 at_fn_check_status 0 $at_status "$at_srcdir/output.at:260" 18728 $at_failed && at_fn_log_failure 18729 $at_traceon; } 18730 18731 set +x 18732 $at_times_p && times >"$at_times_file" 18733 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 18734 read at_status <"$at_status_file" 18735 #AT_STOP_86 18736 #AT_START_87 18737 at_fn_group_banner 87 'output.at:294' \ 18738 "Graph with unsolved S/R" " " 3 18739 at_xfail=no 18740 ( 18741 $as_echo "87. $at_setup_line: testing $at_desc ..." 18742 $at_traceon 18743 18744 18745 cat >input.y <<'_ATEOF' 18746 %% 18747 start: 18748 'a' 18749 | empty_a 'a' 18750 | 'b' 18751 | empty_b 'b' 18752 | 'c' 18753 | empty_c 'c' 18754 ; 18755 empty_a: %prec 'a'; 18756 empty_b: %prec 'b'; 18757 empty_c: %prec 'c'; 18758 _ATEOF 18759 18760 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 18761 at_save_special_files 18762 mkdir xml-tests 18763 # Don't combine these Bison invocations since we want to be sure that 18764 # --report=all isn't required to get the full XML file. 18765 { set +x 18766 $as_echo "$at_srcdir/output.at:294: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 18767 --graph=xml-tests/test.dot -rall --graph input.y" 18768 at_fn_check_prepare_notrace 'an embedded newline' "output.at:294" 18769 ( $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 \ 18770 --graph=xml-tests/test.dot -rall --graph input.y 18771 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18772 at_status=$? at_failed=false 18773 $at_check_filter 18774 echo stderr:; cat "$at_stderr" 18775 echo stdout:; cat "$at_stdout" 18776 at_fn_check_status 0 $at_status "$at_srcdir/output.at:294" 18777 $at_failed && at_fn_log_failure 18778 $at_traceon; } 18779 18780 { set +x 18781 $as_echo "$at_srcdir/output.at:294: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -rall --graph input.y" 18782 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -rall --graph input.y" "output.at:294" 18783 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -rall --graph input.y 18784 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18785 at_status=$? at_failed=false 18786 $at_check_filter 18787 echo stderr:; cat "$at_stderr" 18788 echo stdout:; cat "$at_stdout" 18789 at_fn_check_status 0 $at_status "$at_srcdir/output.at:294" 18790 $at_failed && at_fn_log_failure 18791 $at_traceon; } 18792 18793 cp xml-tests/test.output expout 18794 { set +x 18795 $as_echo "$at_srcdir/output.at:294: \$XSLTPROC \\ 18796 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 18797 xml-tests/test.xml" 18798 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:294" 18799 ( $at_check_trace; $XSLTPROC \ 18800 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 18801 xml-tests/test.xml 18802 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18803 at_status=$? at_failed=false 18804 $at_check_filter 18805 at_fn_diff_devnull "$at_stderr" || at_failed=: 18806 $at_diff expout "$at_stdout" || at_failed=: 18807 at_fn_check_status 0 $at_status "$at_srcdir/output.at:294" 18808 $at_failed && at_fn_log_failure 18809 $at_traceon; } 18810 18811 sort xml-tests/test.dot > expout 18812 { set +x 18813 $as_echo "$at_srcdir/output.at:294: \$XSLTPROC \\ 18814 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 18815 xml-tests/test.xml | sort" 18816 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:294" 18817 ( $at_check_trace; $XSLTPROC \ 18818 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 18819 xml-tests/test.xml | sort 18820 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18821 at_status=$? at_failed=false 18822 $at_check_filter 18823 at_fn_diff_devnull "$at_stderr" || at_failed=: 18824 $at_diff expout "$at_stdout" || at_failed=: 18825 at_fn_check_status 0 $at_status "$at_srcdir/output.at:294" 18826 $at_failed && at_fn_log_failure 18827 $at_traceon; } 18828 18829 rm -rf xml-tests expout 18830 at_restore_special_files 18831 fi 18832 { set +x 18833 $as_echo "$at_srcdir/output.at:294: bison -rall --graph input.y" 18834 at_fn_check_prepare_trace "output.at:294" 18835 ( $at_check_trace; bison -rall --graph input.y 18836 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18837 at_status=$? at_failed=false 18838 $at_check_filter 18839 echo stderr:; cat "$at_stderr" 18840 at_fn_diff_devnull "$at_stdout" || at_failed=: 18841 at_fn_check_status 0 $at_status "$at_srcdir/output.at:294" 18842 $at_failed && at_fn_log_failure 18843 $at_traceon; } 18844 18845 18846 { set +x 18847 $as_echo "$at_srcdir/output.at:294: grep -v // input.dot" 18848 at_fn_check_prepare_trace "output.at:294" 18849 ( $at_check_trace; grep -v // input.dot 18850 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18851 at_status=$? at_failed=false 18852 $at_check_filter 18853 at_fn_diff_devnull "$at_stderr" || at_failed=: 18854 echo >>"$at_stdout"; $as_echo " 18855 digraph \"input.y\" 18856 { 18857 node [fontname = courier, shape = box, colorscheme = paired6] 18858 edge [fontname = courier] 18859 18860 0 [label=\"State 0\\n\\l 0 \$accept: . start \$end\\l 1 start: . 'a'\\l 2 | . empty_a 'a'\\l 3 | . 'b'\\l 4 | . empty_b 'b'\\l 5 | . 'c'\\l 6 | . empty_c 'c'\\l 7 empty_a: . ['a']\\l 8 empty_b: . ['b']\\l 9 empty_c: . ['c']\\l\"] 18861 0 -> 1 [style=solid label=\"'a'\"] 18862 0 -> 2 [style=solid label=\"'b'\"] 18863 0 -> 3 [style=solid label=\"'c'\"] 18864 0 -> 4 [style=dashed label=\"start\"] 18865 0 -> 5 [style=dashed label=\"empty_a\"] 18866 0 -> 6 [style=dashed label=\"empty_b\"] 18867 0 -> 7 [style=dashed label=\"empty_c\"] 18868 0 -> \"0R7d\" [label=\"['a']\", style=solid] 18869 \"0R7d\" [label=\"R7\", fillcolor=5, shape=diamond, style=filled] 18870 0 -> \"0R8d\" [label=\"['b']\", style=solid] 18871 \"0R8d\" [label=\"R8\", fillcolor=5, shape=diamond, style=filled] 18872 0 -> \"0R9d\" [label=\"['c']\", style=solid] 18873 \"0R9d\" [label=\"R9\", fillcolor=5, shape=diamond, style=filled] 18874 1 [label=\"State 1\\n\\l 1 start: 'a' .\\l\"] 18875 1 -> \"1R1\" [style=solid] 18876 \"1R1\" [label=\"R1\", fillcolor=3, shape=diamond, style=filled] 18877 2 [label=\"State 2\\n\\l 3 start: 'b' .\\l\"] 18878 2 -> \"2R3\" [style=solid] 18879 \"2R3\" [label=\"R3\", fillcolor=3, shape=diamond, style=filled] 18880 3 [label=\"State 3\\n\\l 5 start: 'c' .\\l\"] 18881 3 -> \"3R5\" [style=solid] 18882 \"3R5\" [label=\"R5\", fillcolor=3, shape=diamond, style=filled] 18883 4 [label=\"State 4\\n\\l 0 \$accept: start . \$end\\l\"] 18884 4 -> 8 [style=solid label=\"\$end\"] 18885 5 [label=\"State 5\\n\\l 2 start: empty_a . 'a'\\l\"] 18886 5 -> 9 [style=solid label=\"'a'\"] 18887 6 [label=\"State 6\\n\\l 4 start: empty_b . 'b'\\l\"] 18888 6 -> 10 [style=solid label=\"'b'\"] 18889 7 [label=\"State 7\\n\\l 6 start: empty_c . 'c'\\l\"] 18890 7 -> 11 [style=solid label=\"'c'\"] 18891 8 [label=\"State 8\\n\\l 0 \$accept: start \$end .\\l\"] 18892 8 -> \"8R0\" [style=solid] 18893 \"8R0\" [label=\"Acc\", fillcolor=1, shape=diamond, style=filled] 18894 9 [label=\"State 9\\n\\l 2 start: empty_a 'a' .\\l\"] 18895 9 -> \"9R2\" [style=solid] 18896 \"9R2\" [label=\"R2\", fillcolor=3, shape=diamond, style=filled] 18897 10 [label=\"State 10\\n\\l 4 start: empty_b 'b' .\\l\"] 18898 10 -> \"10R4\" [style=solid] 18899 \"10R4\" [label=\"R4\", fillcolor=3, shape=diamond, style=filled] 18900 11 [label=\"State 11\\n\\l 6 start: empty_c 'c' .\\l\"] 18901 11 -> \"11R6\" [style=solid] 18902 \"11R6\" [label=\"R6\", fillcolor=3, shape=diamond, style=filled] 18903 } 18904 " | \ 18905 $at_diff - "$at_stdout" || at_failed=: 18906 at_fn_check_status 0 $at_status "$at_srcdir/output.at:294" 18907 $at_failed && at_fn_log_failure 18908 $at_traceon; } 18909 18910 set +x 18911 $at_times_p && times >"$at_times_file" 18912 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 18913 read at_status <"$at_status_file" 18914 #AT_STOP_87 18915 #AT_START_88 18916 at_fn_group_banner 88 'output.at:358' \ 18917 "Graph with solved S/R" " " 3 18918 at_xfail=no 18919 ( 18920 $as_echo "88. $at_setup_line: testing $at_desc ..." 18921 $at_traceon 18922 18923 18924 cat >input.y <<'_ATEOF' 18925 %left 'a' 18926 %right 'b' 18927 %right 'c' 18928 %% 18929 start: 18930 'a' 18931 | empty_a 'a' 18932 | 'b' 18933 | empty_b 'b' 18934 | 'c' 18935 | empty_c 'c' 18936 ; 18937 empty_a: %prec 'a'; 18938 empty_b: %prec 'b'; 18939 empty_c: %prec 'c'; 18940 _ATEOF 18941 18942 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 18943 at_save_special_files 18944 mkdir xml-tests 18945 # Don't combine these Bison invocations since we want to be sure that 18946 # --report=all isn't required to get the full XML file. 18947 { set +x 18948 $as_echo "$at_srcdir/output.at:358: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 18949 --graph=xml-tests/test.dot -rall --graph input.y" 18950 at_fn_check_prepare_notrace 'an embedded newline' "output.at:358" 18951 ( $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 \ 18952 --graph=xml-tests/test.dot -rall --graph input.y 18953 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18954 at_status=$? at_failed=false 18955 $at_check_filter 18956 echo stderr:; cat "$at_stderr" 18957 echo stdout:; cat "$at_stdout" 18958 at_fn_check_status 0 $at_status "$at_srcdir/output.at:358" 18959 $at_failed && at_fn_log_failure 18960 $at_traceon; } 18961 18962 { set +x 18963 $as_echo "$at_srcdir/output.at:358: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -rall --graph input.y" 18964 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -rall --graph input.y" "output.at:358" 18965 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -rall --graph input.y 18966 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18967 at_status=$? at_failed=false 18968 $at_check_filter 18969 echo stderr:; cat "$at_stderr" 18970 echo stdout:; cat "$at_stdout" 18971 at_fn_check_status 0 $at_status "$at_srcdir/output.at:358" 18972 $at_failed && at_fn_log_failure 18973 $at_traceon; } 18974 18975 cp xml-tests/test.output expout 18976 { set +x 18977 $as_echo "$at_srcdir/output.at:358: \$XSLTPROC \\ 18978 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 18979 xml-tests/test.xml" 18980 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:358" 18981 ( $at_check_trace; $XSLTPROC \ 18982 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 18983 xml-tests/test.xml 18984 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 18985 at_status=$? at_failed=false 18986 $at_check_filter 18987 at_fn_diff_devnull "$at_stderr" || at_failed=: 18988 $at_diff expout "$at_stdout" || at_failed=: 18989 at_fn_check_status 0 $at_status "$at_srcdir/output.at:358" 18990 $at_failed && at_fn_log_failure 18991 $at_traceon; } 18992 18993 sort xml-tests/test.dot > expout 18994 { set +x 18995 $as_echo "$at_srcdir/output.at:358: \$XSLTPROC \\ 18996 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 18997 xml-tests/test.xml | sort" 18998 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:358" 18999 ( $at_check_trace; $XSLTPROC \ 19000 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 19001 xml-tests/test.xml | sort 19002 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19003 at_status=$? at_failed=false 19004 $at_check_filter 19005 at_fn_diff_devnull "$at_stderr" || at_failed=: 19006 $at_diff expout "$at_stdout" || at_failed=: 19007 at_fn_check_status 0 $at_status "$at_srcdir/output.at:358" 19008 $at_failed && at_fn_log_failure 19009 $at_traceon; } 19010 19011 rm -rf xml-tests expout 19012 at_restore_special_files 19013 fi 19014 { set +x 19015 $as_echo "$at_srcdir/output.at:358: bison -rall --graph input.y" 19016 at_fn_check_prepare_trace "output.at:358" 19017 ( $at_check_trace; bison -rall --graph input.y 19018 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19019 at_status=$? at_failed=false 19020 $at_check_filter 19021 echo stderr:; cat "$at_stderr" 19022 at_fn_diff_devnull "$at_stdout" || at_failed=: 19023 at_fn_check_status 0 $at_status "$at_srcdir/output.at:358" 19024 $at_failed && at_fn_log_failure 19025 $at_traceon; } 19026 19027 19028 { set +x 19029 $as_echo "$at_srcdir/output.at:358: grep -v // input.dot" 19030 at_fn_check_prepare_trace "output.at:358" 19031 ( $at_check_trace; grep -v // input.dot 19032 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19033 at_status=$? at_failed=false 19034 $at_check_filter 19035 at_fn_diff_devnull "$at_stderr" || at_failed=: 19036 echo >>"$at_stdout"; $as_echo " 19037 digraph \"input.y\" 19038 { 19039 node [fontname = courier, shape = box, colorscheme = paired6] 19040 edge [fontname = courier] 19041 19042 0 [label=\"State 0\\n\\l 0 \$accept: . start \$end\\l 1 start: . 'a'\\l 2 | . empty_a 'a'\\l 3 | . 'b'\\l 4 | . empty_b 'b'\\l 5 | . 'c'\\l 6 | . empty_c 'c'\\l 7 empty_a: . ['a']\\l 8 empty_b: . []\\l 9 empty_c: . []\\l\"] 19043 0 -> 1 [style=solid label=\"'b'\"] 19044 0 -> 2 [style=solid label=\"'c'\"] 19045 0 -> 3 [style=dashed label=\"start\"] 19046 0 -> 4 [style=dashed label=\"empty_a\"] 19047 0 -> 5 [style=dashed label=\"empty_b\"] 19048 0 -> 6 [style=dashed label=\"empty_c\"] 19049 0 -> \"0R7\" [style=solid] 19050 \"0R7\" [label=\"R7\", fillcolor=3, shape=diamond, style=filled] 19051 1 [label=\"State 1\\n\\l 3 start: 'b' .\\l\"] 19052 1 -> \"1R3\" [style=solid] 19053 \"1R3\" [label=\"R3\", fillcolor=3, shape=diamond, style=filled] 19054 2 [label=\"State 2\\n\\l 5 start: 'c' .\\l\"] 19055 2 -> \"2R5\" [style=solid] 19056 \"2R5\" [label=\"R5\", fillcolor=3, shape=diamond, style=filled] 19057 3 [label=\"State 3\\n\\l 0 \$accept: start . \$end\\l\"] 19058 3 -> 7 [style=solid label=\"\$end\"] 19059 4 [label=\"State 4\\n\\l 2 start: empty_a . 'a'\\l\"] 19060 4 -> 8 [style=solid label=\"'a'\"] 19061 5 [label=\"State 5\\n\\l 4 start: empty_b . 'b'\\l\"] 19062 5 -> 9 [style=solid label=\"'b'\"] 19063 6 [label=\"State 6\\n\\l 6 start: empty_c . 'c'\\l\"] 19064 6 -> 10 [style=solid label=\"'c'\"] 19065 7 [label=\"State 7\\n\\l 0 \$accept: start \$end .\\l\"] 19066 7 -> \"7R0\" [style=solid] 19067 \"7R0\" [label=\"Acc\", fillcolor=1, shape=diamond, style=filled] 19068 8 [label=\"State 8\\n\\l 2 start: empty_a 'a' .\\l\"] 19069 8 -> \"8R2\" [style=solid] 19070 \"8R2\" [label=\"R2\", fillcolor=3, shape=diamond, style=filled] 19071 9 [label=\"State 9\\n\\l 4 start: empty_b 'b' .\\l\"] 19072 9 -> \"9R4\" [style=solid] 19073 \"9R4\" [label=\"R4\", fillcolor=3, shape=diamond, style=filled] 19074 10 [label=\"State 10\\n\\l 6 start: empty_c 'c' .\\l\"] 19075 10 -> \"10R6\" [style=solid] 19076 \"10R6\" [label=\"R6\", fillcolor=3, shape=diamond, style=filled] 19077 } 19078 " | \ 19079 $at_diff - "$at_stdout" || at_failed=: 19080 at_fn_check_status 0 $at_status "$at_srcdir/output.at:358" 19081 $at_failed && at_fn_log_failure 19082 $at_traceon; } 19083 19084 set +x 19085 $at_times_p && times >"$at_times_file" 19086 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 19087 read at_status <"$at_status_file" 19088 #AT_STOP_88 19089 #AT_START_89 19090 at_fn_group_banner 89 'output.at:417' \ 19091 "Graph with R/R" " " 3 19092 at_xfail=no 19093 ( 19094 $as_echo "89. $at_setup_line: testing $at_desc ..." 19095 $at_traceon 19096 19097 19098 cat >input.y <<'_ATEOF' 19099 %% 19100 exp: a | b; 19101 a: ; 19102 b: ; 19103 _ATEOF 19104 19105 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 19106 at_save_special_files 19107 mkdir xml-tests 19108 # Don't combine these Bison invocations since we want to be sure that 19109 # --report=all isn't required to get the full XML file. 19110 { set +x 19111 $as_echo "$at_srcdir/output.at:417: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 19112 --graph=xml-tests/test.dot -rall --graph input.y" 19113 at_fn_check_prepare_notrace 'an embedded newline' "output.at:417" 19114 ( $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 \ 19115 --graph=xml-tests/test.dot -rall --graph input.y 19116 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19117 at_status=$? at_failed=false 19118 $at_check_filter 19119 echo stderr:; cat "$at_stderr" 19120 echo stdout:; cat "$at_stdout" 19121 at_fn_check_status 0 $at_status "$at_srcdir/output.at:417" 19122 $at_failed && at_fn_log_failure 19123 $at_traceon; } 19124 19125 { set +x 19126 $as_echo "$at_srcdir/output.at:417: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -rall --graph input.y" 19127 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -rall --graph input.y" "output.at:417" 19128 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -rall --graph input.y 19129 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19130 at_status=$? at_failed=false 19131 $at_check_filter 19132 echo stderr:; cat "$at_stderr" 19133 echo stdout:; cat "$at_stdout" 19134 at_fn_check_status 0 $at_status "$at_srcdir/output.at:417" 19135 $at_failed && at_fn_log_failure 19136 $at_traceon; } 19137 19138 cp xml-tests/test.output expout 19139 { set +x 19140 $as_echo "$at_srcdir/output.at:417: \$XSLTPROC \\ 19141 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 19142 xml-tests/test.xml" 19143 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:417" 19144 ( $at_check_trace; $XSLTPROC \ 19145 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 19146 xml-tests/test.xml 19147 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19148 at_status=$? at_failed=false 19149 $at_check_filter 19150 at_fn_diff_devnull "$at_stderr" || at_failed=: 19151 $at_diff expout "$at_stdout" || at_failed=: 19152 at_fn_check_status 0 $at_status "$at_srcdir/output.at:417" 19153 $at_failed && at_fn_log_failure 19154 $at_traceon; } 19155 19156 sort xml-tests/test.dot > expout 19157 { set +x 19158 $as_echo "$at_srcdir/output.at:417: \$XSLTPROC \\ 19159 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 19160 xml-tests/test.xml | sort" 19161 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:417" 19162 ( $at_check_trace; $XSLTPROC \ 19163 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 19164 xml-tests/test.xml | sort 19165 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19166 at_status=$? at_failed=false 19167 $at_check_filter 19168 at_fn_diff_devnull "$at_stderr" || at_failed=: 19169 $at_diff expout "$at_stdout" || at_failed=: 19170 at_fn_check_status 0 $at_status "$at_srcdir/output.at:417" 19171 $at_failed && at_fn_log_failure 19172 $at_traceon; } 19173 19174 rm -rf xml-tests expout 19175 at_restore_special_files 19176 fi 19177 { set +x 19178 $as_echo "$at_srcdir/output.at:417: bison -rall --graph input.y" 19179 at_fn_check_prepare_trace "output.at:417" 19180 ( $at_check_trace; bison -rall --graph input.y 19181 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19182 at_status=$? at_failed=false 19183 $at_check_filter 19184 echo stderr:; cat "$at_stderr" 19185 at_fn_diff_devnull "$at_stdout" || at_failed=: 19186 at_fn_check_status 0 $at_status "$at_srcdir/output.at:417" 19187 $at_failed && at_fn_log_failure 19188 $at_traceon; } 19189 19190 19191 { set +x 19192 $as_echo "$at_srcdir/output.at:417: grep -v // input.dot" 19193 at_fn_check_prepare_trace "output.at:417" 19194 ( $at_check_trace; grep -v // input.dot 19195 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19196 at_status=$? at_failed=false 19197 $at_check_filter 19198 at_fn_diff_devnull "$at_stderr" || at_failed=: 19199 echo >>"$at_stdout"; $as_echo " 19200 digraph \"input.y\" 19201 { 19202 node [fontname = courier, shape = box, colorscheme = paired6] 19203 edge [fontname = courier] 19204 19205 0 [label=\"State 0\\n\\l 0 \$accept: . exp \$end\\l 1 exp: . a\\l 2 | . b\\l 3 a: . [\$end]\\l 4 b: . [\$end]\\l\"] 19206 0 -> 1 [style=dashed label=\"exp\"] 19207 0 -> 2 [style=dashed label=\"a\"] 19208 0 -> 3 [style=dashed label=\"b\"] 19209 0 -> \"0R3\" [style=solid] 19210 \"0R3\" [label=\"R3\", fillcolor=3, shape=diamond, style=filled] 19211 0 -> \"0R4d\" [label=\"[\$end]\", style=solid] 19212 \"0R4d\" [label=\"R4\", fillcolor=5, shape=diamond, style=filled] 19213 1 [label=\"State 1\\n\\l 0 \$accept: exp . \$end\\l\"] 19214 1 -> 4 [style=solid label=\"\$end\"] 19215 2 [label=\"State 2\\n\\l 1 exp: a .\\l\"] 19216 2 -> \"2R1\" [style=solid] 19217 \"2R1\" [label=\"R1\", fillcolor=3, shape=diamond, style=filled] 19218 3 [label=\"State 3\\n\\l 2 exp: b .\\l\"] 19219 3 -> \"3R2\" [style=solid] 19220 \"3R2\" [label=\"R2\", fillcolor=3, shape=diamond, style=filled] 19221 4 [label=\"State 4\\n\\l 0 \$accept: exp \$end .\\l\"] 19222 4 -> \"4R0\" [style=solid] 19223 \"4R0\" [label=\"Acc\", fillcolor=1, shape=diamond, style=filled] 19224 } 19225 " | \ 19226 $at_diff - "$at_stdout" || at_failed=: 19227 at_fn_check_status 0 $at_status "$at_srcdir/output.at:417" 19228 $at_failed && at_fn_log_failure 19229 $at_traceon; } 19230 19231 set +x 19232 $at_times_p && times >"$at_times_file" 19233 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 19234 read at_status <"$at_status_file" 19235 #AT_STOP_89 19236 #AT_START_90 19237 at_fn_group_banner 90 'output.at:449' \ 19238 "Graph with reductions with multiple LAT" " " 3 19239 at_xfail=no 19240 ( 19241 $as_echo "90. $at_setup_line: testing $at_desc ..." 19242 $at_traceon 19243 19244 19245 cat >input.y <<'_ATEOF' 19246 %% 19247 exp: a ';' | a ';' | a '.' | b '?' | b '!' | c '?' | c ';'; 19248 a: ; 19249 b: ; 19250 c: ; 19251 _ATEOF 19252 19253 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 19254 at_save_special_files 19255 mkdir xml-tests 19256 # Don't combine these Bison invocations since we want to be sure that 19257 # --report=all isn't required to get the full XML file. 19258 { set +x 19259 $as_echo "$at_srcdir/output.at:449: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 19260 --graph=xml-tests/test.dot -rall --graph input.y" 19261 at_fn_check_prepare_notrace 'an embedded newline' "output.at:449" 19262 ( $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 \ 19263 --graph=xml-tests/test.dot -rall --graph input.y 19264 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19265 at_status=$? at_failed=false 19266 $at_check_filter 19267 echo stderr:; cat "$at_stderr" 19268 echo stdout:; cat "$at_stdout" 19269 at_fn_check_status 0 $at_status "$at_srcdir/output.at:449" 19270 $at_failed && at_fn_log_failure 19271 $at_traceon; } 19272 19273 { set +x 19274 $as_echo "$at_srcdir/output.at:449: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -rall --graph input.y" 19275 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -rall --graph input.y" "output.at:449" 19276 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -rall --graph input.y 19277 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19278 at_status=$? at_failed=false 19279 $at_check_filter 19280 echo stderr:; cat "$at_stderr" 19281 echo stdout:; cat "$at_stdout" 19282 at_fn_check_status 0 $at_status "$at_srcdir/output.at:449" 19283 $at_failed && at_fn_log_failure 19284 $at_traceon; } 19285 19286 cp xml-tests/test.output expout 19287 { set +x 19288 $as_echo "$at_srcdir/output.at:449: \$XSLTPROC \\ 19289 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 19290 xml-tests/test.xml" 19291 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:449" 19292 ( $at_check_trace; $XSLTPROC \ 19293 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 19294 xml-tests/test.xml 19295 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19296 at_status=$? at_failed=false 19297 $at_check_filter 19298 at_fn_diff_devnull "$at_stderr" || at_failed=: 19299 $at_diff expout "$at_stdout" || at_failed=: 19300 at_fn_check_status 0 $at_status "$at_srcdir/output.at:449" 19301 $at_failed && at_fn_log_failure 19302 $at_traceon; } 19303 19304 sort xml-tests/test.dot > expout 19305 { set +x 19306 $as_echo "$at_srcdir/output.at:449: \$XSLTPROC \\ 19307 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 19308 xml-tests/test.xml | sort" 19309 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:449" 19310 ( $at_check_trace; $XSLTPROC \ 19311 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 19312 xml-tests/test.xml | sort 19313 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19314 at_status=$? at_failed=false 19315 $at_check_filter 19316 at_fn_diff_devnull "$at_stderr" || at_failed=: 19317 $at_diff expout "$at_stdout" || at_failed=: 19318 at_fn_check_status 0 $at_status "$at_srcdir/output.at:449" 19319 $at_failed && at_fn_log_failure 19320 $at_traceon; } 19321 19322 rm -rf xml-tests expout 19323 at_restore_special_files 19324 fi 19325 { set +x 19326 $as_echo "$at_srcdir/output.at:449: bison -rall --graph input.y" 19327 at_fn_check_prepare_trace "output.at:449" 19328 ( $at_check_trace; bison -rall --graph input.y 19329 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19330 at_status=$? at_failed=false 19331 $at_check_filter 19332 echo stderr:; cat "$at_stderr" 19333 at_fn_diff_devnull "$at_stdout" || at_failed=: 19334 at_fn_check_status 0 $at_status "$at_srcdir/output.at:449" 19335 $at_failed && at_fn_log_failure 19336 $at_traceon; } 19337 19338 19339 { set +x 19340 $as_echo "$at_srcdir/output.at:449: grep -v // input.dot" 19341 at_fn_check_prepare_trace "output.at:449" 19342 ( $at_check_trace; grep -v // input.dot 19343 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19344 at_status=$? at_failed=false 19345 $at_check_filter 19346 at_fn_diff_devnull "$at_stderr" || at_failed=: 19347 echo >>"$at_stdout"; $as_echo " 19348 digraph \"input.y\" 19349 { 19350 node [fontname = courier, shape = box, colorscheme = paired6] 19351 edge [fontname = courier] 19352 19353 0 [label=\"State 0\\n\\l 0 \$accept: . exp \$end\\l 1 exp: . a ';'\\l 2 | . a ';'\\l 3 | . a '.'\\l 4 | . b '?'\\l 5 | . b '!'\\l 6 | . c '?'\\l 7 | . c ';'\\l 8 a: . [';', '.']\\l 9 b: . ['?', '!']\\l 10 c: . [';', '?']\\l\"] 19354 0 -> 1 [style=dashed label=\"exp\"] 19355 0 -> 2 [style=dashed label=\"a\"] 19356 0 -> 3 [style=dashed label=\"b\"] 19357 0 -> 4 [style=dashed label=\"c\"] 19358 0 -> \"0R8\" [style=solid] 19359 \"0R8\" [label=\"R8\", fillcolor=3, shape=diamond, style=filled] 19360 0 -> \"0R9\" [label=\"['?', '!']\", style=solid] 19361 \"0R9\" [label=\"R9\", fillcolor=3, shape=diamond, style=filled] 19362 0 -> \"0R10d\" [label=\"[';', '?']\", style=solid] 19363 \"0R10d\" [label=\"R10\", fillcolor=5, shape=diamond, style=filled] 19364 1 [label=\"State 1\\n\\l 0 \$accept: exp . \$end\\l\"] 19365 1 -> 5 [style=solid label=\"\$end\"] 19366 2 [label=\"State 2\\n\\l 1 exp: a . ';'\\l 2 | a . ';'\\l 3 | a . '.'\\l\"] 19367 2 -> 6 [style=solid label=\"';'\"] 19368 2 -> 7 [style=solid label=\"'.'\"] 19369 3 [label=\"State 3\\n\\l 4 exp: b . '?'\\l 5 | b . '!'\\l\"] 19370 3 -> 8 [style=solid label=\"'?'\"] 19371 3 -> 9 [style=solid label=\"'!'\"] 19372 4 [label=\"State 4\\n\\l 6 exp: c . '?'\\l 7 | c . ';'\\l\"] 19373 4 -> 10 [style=solid label=\"';'\"] 19374 4 -> 11 [style=solid label=\"'?'\"] 19375 5 [label=\"State 5\\n\\l 0 \$accept: exp \$end .\\l\"] 19376 5 -> \"5R0\" [style=solid] 19377 \"5R0\" [label=\"Acc\", fillcolor=1, shape=diamond, style=filled] 19378 6 [label=\"State 6\\n\\l 1 exp: a ';' . [\$end]\\l 2 | a ';' . [\$end]\\l\"] 19379 6 -> \"6R1\" [style=solid] 19380 \"6R1\" [label=\"R1\", fillcolor=3, shape=diamond, style=filled] 19381 6 -> \"6R2d\" [label=\"[\$end]\", style=solid] 19382 \"6R2d\" [label=\"R2\", fillcolor=5, shape=diamond, style=filled] 19383 7 [label=\"State 7\\n\\l 3 exp: a '.' .\\l\"] 19384 7 -> \"7R3\" [style=solid] 19385 \"7R3\" [label=\"R3\", fillcolor=3, shape=diamond, style=filled] 19386 8 [label=\"State 8\\n\\l 4 exp: b '?' .\\l\"] 19387 8 -> \"8R4\" [style=solid] 19388 \"8R4\" [label=\"R4\", fillcolor=3, shape=diamond, style=filled] 19389 9 [label=\"State 9\\n\\l 5 exp: b '!' .\\l\"] 19390 9 -> \"9R5\" [style=solid] 19391 \"9R5\" [label=\"R5\", fillcolor=3, shape=diamond, style=filled] 19392 10 [label=\"State 10\\n\\l 7 exp: c ';' .\\l\"] 19393 10 -> \"10R7\" [style=solid] 19394 \"10R7\" [label=\"R7\", fillcolor=3, shape=diamond, style=filled] 19395 11 [label=\"State 11\\n\\l 6 exp: c '?' .\\l\"] 19396 11 -> \"11R6\" [style=solid] 19397 \"11R6\" [label=\"R6\", fillcolor=3, shape=diamond, style=filled] 19398 } 19399 " | \ 19400 $at_diff - "$at_stdout" || at_failed=: 19401 at_fn_check_status 0 $at_status "$at_srcdir/output.at:449" 19402 $at_failed && at_fn_log_failure 19403 $at_traceon; } 19404 19405 set +x 19406 $at_times_p && times >"$at_times_file" 19407 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 19408 read at_status <"$at_status_file" 19409 #AT_STOP_90 19410 #AT_START_91 19411 at_fn_group_banner 91 'output.at:508' \ 19412 "Graph with a reduction rule both enabled and disabled" "" 3 19413 at_xfail=no 19414 ( 19415 $as_echo "91. $at_setup_line: testing $at_desc ..." 19416 $at_traceon 19417 19418 19419 cat >input.y <<'_ATEOF' 19420 %% 19421 exp: ifexp | opexp | imm; 19422 ifexp: "if" exp "then" exp elseexp; 19423 elseexp: "else" exp | ; 19424 opexp: exp '+' exp; 19425 imm: '0'; 19426 _ATEOF 19427 19428 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 19429 at_save_special_files 19430 mkdir xml-tests 19431 # Don't combine these Bison invocations since we want to be sure that 19432 # --report=all isn't required to get the full XML file. 19433 { set +x 19434 $as_echo "$at_srcdir/output.at:508: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 19435 --graph=xml-tests/test.dot -rall --graph input.y" 19436 at_fn_check_prepare_notrace 'an embedded newline' "output.at:508" 19437 ( $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 \ 19438 --graph=xml-tests/test.dot -rall --graph input.y 19439 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19440 at_status=$? at_failed=false 19441 $at_check_filter 19442 echo stderr:; cat "$at_stderr" 19443 echo stdout:; cat "$at_stdout" 19444 at_fn_check_status 0 $at_status "$at_srcdir/output.at:508" 19445 $at_failed && at_fn_log_failure 19446 $at_traceon; } 19447 19448 { set +x 19449 $as_echo "$at_srcdir/output.at:508: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -rall --graph input.y" 19450 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -rall --graph input.y" "output.at:508" 19451 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -rall --graph input.y 19452 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19453 at_status=$? at_failed=false 19454 $at_check_filter 19455 echo stderr:; cat "$at_stderr" 19456 echo stdout:; cat "$at_stdout" 19457 at_fn_check_status 0 $at_status "$at_srcdir/output.at:508" 19458 $at_failed && at_fn_log_failure 19459 $at_traceon; } 19460 19461 cp xml-tests/test.output expout 19462 { set +x 19463 $as_echo "$at_srcdir/output.at:508: \$XSLTPROC \\ 19464 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 19465 xml-tests/test.xml" 19466 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:508" 19467 ( $at_check_trace; $XSLTPROC \ 19468 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 19469 xml-tests/test.xml 19470 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19471 at_status=$? at_failed=false 19472 $at_check_filter 19473 at_fn_diff_devnull "$at_stderr" || at_failed=: 19474 $at_diff expout "$at_stdout" || at_failed=: 19475 at_fn_check_status 0 $at_status "$at_srcdir/output.at:508" 19476 $at_failed && at_fn_log_failure 19477 $at_traceon; } 19478 19479 sort xml-tests/test.dot > expout 19480 { set +x 19481 $as_echo "$at_srcdir/output.at:508: \$XSLTPROC \\ 19482 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 19483 xml-tests/test.xml | sort" 19484 at_fn_check_prepare_notrace 'a `...` command substitution' "output.at:508" 19485 ( $at_check_trace; $XSLTPROC \ 19486 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 19487 xml-tests/test.xml | sort 19488 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19489 at_status=$? at_failed=false 19490 $at_check_filter 19491 at_fn_diff_devnull "$at_stderr" || at_failed=: 19492 $at_diff expout "$at_stdout" || at_failed=: 19493 at_fn_check_status 0 $at_status "$at_srcdir/output.at:508" 19494 $at_failed && at_fn_log_failure 19495 $at_traceon; } 19496 19497 rm -rf xml-tests expout 19498 at_restore_special_files 19499 fi 19500 { set +x 19501 $as_echo "$at_srcdir/output.at:508: bison -rall --graph input.y" 19502 at_fn_check_prepare_trace "output.at:508" 19503 ( $at_check_trace; bison -rall --graph input.y 19504 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19505 at_status=$? at_failed=false 19506 $at_check_filter 19507 echo stderr:; cat "$at_stderr" 19508 at_fn_diff_devnull "$at_stdout" || at_failed=: 19509 at_fn_check_status 0 $at_status "$at_srcdir/output.at:508" 19510 $at_failed && at_fn_log_failure 19511 $at_traceon; } 19512 19513 19514 { set +x 19515 $as_echo "$at_srcdir/output.at:508: grep -v // input.dot" 19516 at_fn_check_prepare_trace "output.at:508" 19517 ( $at_check_trace; grep -v // input.dot 19518 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19519 at_status=$? at_failed=false 19520 $at_check_filter 19521 at_fn_diff_devnull "$at_stderr" || at_failed=: 19522 echo >>"$at_stdout"; $as_echo " 19523 digraph \"input.y\" 19524 { 19525 node [fontname = courier, shape = box, colorscheme = paired6] 19526 edge [fontname = courier] 19527 19528 0 [label=\"State 0\\n\\l 0 \$accept: . exp \$end\\l 1 exp: . ifexp\\l 2 | . opexp\\l 3 | . imm\\l 4 ifexp: . \\\"if\\\" exp \\\"then\\\" exp elseexp\\l 7 opexp: . exp '+' exp\\l 8 imm: . '0'\\l\"] 19529 0 -> 1 [style=solid label=\"\\\"if\\\"\"] 19530 0 -> 2 [style=solid label=\"'0'\"] 19531 0 -> 3 [style=dashed label=\"exp\"] 19532 0 -> 4 [style=dashed label=\"ifexp\"] 19533 0 -> 5 [style=dashed label=\"opexp\"] 19534 0 -> 6 [style=dashed label=\"imm\"] 19535 1 [label=\"State 1\\n\\l 1 exp: . ifexp\\l 2 | . opexp\\l 3 | . imm\\l 4 ifexp: . \\\"if\\\" exp \\\"then\\\" exp elseexp\\l 4 | \\\"if\\\" . exp \\\"then\\\" exp elseexp\\l 7 opexp: . exp '+' exp\\l 8 imm: . '0'\\l\"] 19536 1 -> 1 [style=solid label=\"\\\"if\\\"\"] 19537 1 -> 2 [style=solid label=\"'0'\"] 19538 1 -> 7 [style=dashed label=\"exp\"] 19539 1 -> 4 [style=dashed label=\"ifexp\"] 19540 1 -> 5 [style=dashed label=\"opexp\"] 19541 1 -> 6 [style=dashed label=\"imm\"] 19542 2 [label=\"State 2\\n\\l 8 imm: '0' .\\l\"] 19543 2 -> \"2R8\" [style=solid] 19544 \"2R8\" [label=\"R8\", fillcolor=3, shape=diamond, style=filled] 19545 3 [label=\"State 3\\n\\l 0 \$accept: exp . \$end\\l 7 opexp: exp . '+' exp\\l\"] 19546 3 -> 8 [style=solid label=\"\$end\"] 19547 3 -> 9 [style=solid label=\"'+'\"] 19548 4 [label=\"State 4\\n\\l 1 exp: ifexp .\\l\"] 19549 4 -> \"4R1\" [style=solid] 19550 \"4R1\" [label=\"R1\", fillcolor=3, shape=diamond, style=filled] 19551 5 [label=\"State 5\\n\\l 2 exp: opexp .\\l\"] 19552 5 -> \"5R2\" [style=solid] 19553 \"5R2\" [label=\"R2\", fillcolor=3, shape=diamond, style=filled] 19554 6 [label=\"State 6\\n\\l 3 exp: imm .\\l\"] 19555 6 -> \"6R3\" [style=solid] 19556 \"6R3\" [label=\"R3\", fillcolor=3, shape=diamond, style=filled] 19557 7 [label=\"State 7\\n\\l 4 ifexp: \\\"if\\\" exp . \\\"then\\\" exp elseexp\\l 7 opexp: exp . '+' exp\\l\"] 19558 7 -> 10 [style=solid label=\"\\\"then\\\"\"] 19559 7 -> 9 [style=solid label=\"'+'\"] 19560 8 [label=\"State 8\\n\\l 0 \$accept: exp \$end .\\l\"] 19561 8 -> \"8R0\" [style=solid] 19562 \"8R0\" [label=\"Acc\", fillcolor=1, shape=diamond, style=filled] 19563 9 [label=\"State 9\\n\\l 1 exp: . ifexp\\l 2 | . opexp\\l 3 | . imm\\l 4 ifexp: . \\\"if\\\" exp \\\"then\\\" exp elseexp\\l 7 opexp: . exp '+' exp\\l 7 | exp '+' . exp\\l 8 imm: . '0'\\l\"] 19564 9 -> 1 [style=solid label=\"\\\"if\\\"\"] 19565 9 -> 2 [style=solid label=\"'0'\"] 19566 9 -> 11 [style=dashed label=\"exp\"] 19567 9 -> 4 [style=dashed label=\"ifexp\"] 19568 9 -> 5 [style=dashed label=\"opexp\"] 19569 9 -> 6 [style=dashed label=\"imm\"] 19570 10 [label=\"State 10\\n\\l 1 exp: . ifexp\\l 2 | . opexp\\l 3 | . imm\\l 4 ifexp: . \\\"if\\\" exp \\\"then\\\" exp elseexp\\l 4 | \\\"if\\\" exp \\\"then\\\" . exp elseexp\\l 7 opexp: . exp '+' exp\\l 8 imm: . '0'\\l\"] 19571 10 -> 1 [style=solid label=\"\\\"if\\\"\"] 19572 10 -> 2 [style=solid label=\"'0'\"] 19573 10 -> 12 [style=dashed label=\"exp\"] 19574 10 -> 4 [style=dashed label=\"ifexp\"] 19575 10 -> 5 [style=dashed label=\"opexp\"] 19576 10 -> 6 [style=dashed label=\"imm\"] 19577 11 [label=\"State 11\\n\\l 7 opexp: exp . '+' exp\\l 7 | exp '+' exp . [\$end, \\\"then\\\", \\\"else\\\", '+']\\l\"] 19578 11 -> 9 [style=solid label=\"'+'\"] 19579 11 -> \"11R7d\" [label=\"['+']\", style=solid] 19580 \"11R7d\" [label=\"R7\", fillcolor=5, shape=diamond, style=filled] 19581 11 -> \"11R7\" [style=solid] 19582 \"11R7\" [label=\"R7\", fillcolor=3, shape=diamond, style=filled] 19583 12 [label=\"State 12\\n\\l 4 ifexp: \\\"if\\\" exp \\\"then\\\" exp . elseexp\\l 5 elseexp: . \\\"else\\\" exp\\l 6 | . [\$end, \\\"then\\\", \\\"else\\\", '+']\\l 7 opexp: exp . '+' exp\\l\"] 19584 12 -> 13 [style=solid label=\"\\\"else\\\"\"] 19585 12 -> 9 [style=solid label=\"'+'\"] 19586 12 -> 14 [style=dashed label=\"elseexp\"] 19587 12 -> \"12R6d\" [label=\"[\\\"else\\\", '+']\", style=solid] 19588 \"12R6d\" [label=\"R6\", fillcolor=5, shape=diamond, style=filled] 19589 12 -> \"12R6\" [style=solid] 19590 \"12R6\" [label=\"R6\", fillcolor=3, shape=diamond, style=filled] 19591 13 [label=\"State 13\\n\\l 1 exp: . ifexp\\l 2 | . opexp\\l 3 | . imm\\l 4 ifexp: . \\\"if\\\" exp \\\"then\\\" exp elseexp\\l 5 elseexp: \\\"else\\\" . exp\\l 7 opexp: . exp '+' exp\\l 8 imm: . '0'\\l\"] 19592 13 -> 1 [style=solid label=\"\\\"if\\\"\"] 19593 13 -> 2 [style=solid label=\"'0'\"] 19594 13 -> 15 [style=dashed label=\"exp\"] 19595 13 -> 4 [style=dashed label=\"ifexp\"] 19596 13 -> 5 [style=dashed label=\"opexp\"] 19597 13 -> 6 [style=dashed label=\"imm\"] 19598 14 [label=\"State 14\\n\\l 4 ifexp: \\\"if\\\" exp \\\"then\\\" exp elseexp .\\l\"] 19599 14 -> \"14R4\" [style=solid] 19600 \"14R4\" [label=\"R4\", fillcolor=3, shape=diamond, style=filled] 19601 15 [label=\"State 15\\n\\l 5 elseexp: \\\"else\\\" exp . [\$end, \\\"then\\\", \\\"else\\\", '+']\\l 7 opexp: exp . '+' exp\\l\"] 19602 15 -> 9 [style=solid label=\"'+'\"] 19603 15 -> \"15R5d\" [label=\"['+']\", style=solid] 19604 \"15R5d\" [label=\"R5\", fillcolor=5, shape=diamond, style=filled] 19605 15 -> \"15R5\" [style=solid] 19606 \"15R5\" [label=\"R5\", fillcolor=3, shape=diamond, style=filled] 19607 } 19608 " | \ 19609 $at_diff - "$at_stdout" || at_failed=: 19610 at_fn_check_status 0 $at_status "$at_srcdir/output.at:508" 19611 $at_failed && at_fn_log_failure 19612 $at_traceon; } 19613 19614 set +x 19615 $at_times_p && times >"$at_times_file" 19616 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 19617 read at_status <"$at_status_file" 19618 #AT_STOP_91 19619 #AT_START_92 19620 at_fn_group_banner 92 'skeletons.at:24' \ 19621 "Relative skeleton file names" " " 4 19622 at_xfail=no 19623 ( 19624 $as_echo "92. $at_setup_line: testing $at_desc ..." 19625 $at_traceon 19626 19627 19628 { set +x 19629 $as_echo "$at_srcdir/skeletons.at:26: mkdir tmp" 19630 at_fn_check_prepare_trace "skeletons.at:26" 19631 ( $at_check_trace; mkdir tmp 19632 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19633 at_status=$? at_failed=false 19634 $at_check_filter 19635 at_fn_diff_devnull "$at_stderr" || at_failed=: 19636 at_fn_diff_devnull "$at_stdout" || at_failed=: 19637 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:26" 19638 $at_failed && at_fn_log_failure 19639 $at_traceon; } 19640 19641 19642 cat >tmp/skel.c <<'_ATEOF' 19643 m4_divert_push(0)dnl 19644 @output(b4_parser_file_name@)dnl 19645 b4_percent_define_get([[test]]) 19646 m4_divert_pop(0) 19647 _ATEOF 19648 19649 19650 cat >skel.c <<'_ATEOF' 19651 m4_divert_push(0)dnl 19652 @output(b4_parser_file_name@)dnl 19653 b4_percent_define_get([[test]]) -- Local 19654 m4_divert_pop(0) 19655 _ATEOF 19656 19657 19658 cat >tmp/input-gram.y <<'_ATEOF' 19659 %skeleton "./skel.c" 19660 %define test "Hello World" 19661 %% 19662 start: ; 19663 _ATEOF 19664 19665 19666 cat >input-gram.y <<'_ATEOF' 19667 %skeleton "./skel.c" 19668 %define test "Hello World" 19669 %% 19670 start: ; 19671 _ATEOF 19672 19673 19674 cat >tmp/input-cmd-line.y <<'_ATEOF' 19675 %define test "Hello World" 19676 %% 19677 start: ; 19678 _ATEOF 19679 19680 19681 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 19682 at_save_special_files 19683 mkdir xml-tests 19684 # Don't combine these Bison invocations since we want to be sure that 19685 # --report=all isn't required to get the full XML file. 19686 { set +x 19687 $as_echo "$at_srcdir/skeletons.at:62: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 19688 --graph=xml-tests/test.dot tmp/input-gram.y" 19689 at_fn_check_prepare_notrace 'an embedded newline' "skeletons.at:62" 19690 ( $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 \ 19691 --graph=xml-tests/test.dot tmp/input-gram.y 19692 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19693 at_status=$? at_failed=false 19694 $at_check_filter 19695 echo stderr:; cat "$at_stderr" 19696 echo stdout:; cat "$at_stdout" 19697 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:62" 19698 $at_failed && at_fn_log_failure 19699 $at_traceon; } 19700 19701 { set +x 19702 $as_echo "$at_srcdir/skeletons.at:62: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml tmp/input-gram.y" 19703 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml tmp/input-gram.y" "skeletons.at:62" 19704 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml tmp/input-gram.y 19705 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19706 at_status=$? at_failed=false 19707 $at_check_filter 19708 echo stderr:; cat "$at_stderr" 19709 echo stdout:; cat "$at_stdout" 19710 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:62" 19711 $at_failed && at_fn_log_failure 19712 $at_traceon; } 19713 19714 cp xml-tests/test.output expout 19715 { set +x 19716 $as_echo "$at_srcdir/skeletons.at:62: \$XSLTPROC \\ 19717 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 19718 xml-tests/test.xml" 19719 at_fn_check_prepare_notrace 'a `...` command substitution' "skeletons.at:62" 19720 ( $at_check_trace; $XSLTPROC \ 19721 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 19722 xml-tests/test.xml 19723 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19724 at_status=$? at_failed=false 19725 $at_check_filter 19726 at_fn_diff_devnull "$at_stderr" || at_failed=: 19727 $at_diff expout "$at_stdout" || at_failed=: 19728 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:62" 19729 $at_failed && at_fn_log_failure 19730 $at_traceon; } 19731 19732 sort xml-tests/test.dot > expout 19733 { set +x 19734 $as_echo "$at_srcdir/skeletons.at:62: \$XSLTPROC \\ 19735 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 19736 xml-tests/test.xml | sort" 19737 at_fn_check_prepare_notrace 'a `...` command substitution' "skeletons.at:62" 19738 ( $at_check_trace; $XSLTPROC \ 19739 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 19740 xml-tests/test.xml | sort 19741 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19742 at_status=$? at_failed=false 19743 $at_check_filter 19744 at_fn_diff_devnull "$at_stderr" || at_failed=: 19745 $at_diff expout "$at_stdout" || at_failed=: 19746 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:62" 19747 $at_failed && at_fn_log_failure 19748 $at_traceon; } 19749 19750 rm -rf xml-tests expout 19751 at_restore_special_files 19752 fi 19753 { set +x 19754 $as_echo "$at_srcdir/skeletons.at:62: bison tmp/input-gram.y" 19755 at_fn_check_prepare_trace "skeletons.at:62" 19756 ( $at_check_trace; bison tmp/input-gram.y 19757 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19758 at_status=$? at_failed=false 19759 $at_check_filter 19760 at_fn_diff_devnull "$at_stderr" || at_failed=: 19761 at_fn_diff_devnull "$at_stdout" || at_failed=: 19762 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:62" 19763 $at_failed && at_fn_log_failure 19764 $at_traceon; } 19765 19766 19767 { set +x 19768 $as_echo "$at_srcdir/skeletons.at:63: cat input-gram.tab.c" 19769 at_fn_check_prepare_trace "skeletons.at:63" 19770 ( $at_check_trace; cat input-gram.tab.c 19771 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19772 at_status=$? at_failed=false 19773 $at_check_filter 19774 at_fn_diff_devnull "$at_stderr" || at_failed=: 19775 echo >>"$at_stdout"; $as_echo "Hello World 19776 " | \ 19777 $at_diff - "$at_stdout" || at_failed=: 19778 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:63" 19779 $at_failed && at_fn_log_failure 19780 $at_traceon; } 19781 19782 19783 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 19784 at_save_special_files 19785 mkdir xml-tests 19786 # Don't combine these Bison invocations since we want to be sure that 19787 # --report=all isn't required to get the full XML file. 19788 { set +x 19789 $as_echo "$at_srcdir/skeletons.at:67: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 19790 --graph=xml-tests/test.dot input-gram.y" 19791 at_fn_check_prepare_notrace 'an embedded newline' "skeletons.at:67" 19792 ( $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 \ 19793 --graph=xml-tests/test.dot input-gram.y 19794 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19795 at_status=$? at_failed=false 19796 $at_check_filter 19797 echo stderr:; cat "$at_stderr" 19798 echo stdout:; cat "$at_stdout" 19799 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:67" 19800 $at_failed && at_fn_log_failure 19801 $at_traceon; } 19802 19803 { set +x 19804 $as_echo "$at_srcdir/skeletons.at:67: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input-gram.y" 19805 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-gram.y" "skeletons.at:67" 19806 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input-gram.y 19807 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19808 at_status=$? at_failed=false 19809 $at_check_filter 19810 echo stderr:; cat "$at_stderr" 19811 echo stdout:; cat "$at_stdout" 19812 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:67" 19813 $at_failed && at_fn_log_failure 19814 $at_traceon; } 19815 19816 cp xml-tests/test.output expout 19817 { set +x 19818 $as_echo "$at_srcdir/skeletons.at:67: \$XSLTPROC \\ 19819 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 19820 xml-tests/test.xml" 19821 at_fn_check_prepare_notrace 'a `...` command substitution' "skeletons.at:67" 19822 ( $at_check_trace; $XSLTPROC \ 19823 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 19824 xml-tests/test.xml 19825 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19826 at_status=$? at_failed=false 19827 $at_check_filter 19828 at_fn_diff_devnull "$at_stderr" || at_failed=: 19829 $at_diff expout "$at_stdout" || at_failed=: 19830 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:67" 19831 $at_failed && at_fn_log_failure 19832 $at_traceon; } 19833 19834 sort xml-tests/test.dot > expout 19835 { set +x 19836 $as_echo "$at_srcdir/skeletons.at:67: \$XSLTPROC \\ 19837 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 19838 xml-tests/test.xml | sort" 19839 at_fn_check_prepare_notrace 'a `...` command substitution' "skeletons.at:67" 19840 ( $at_check_trace; $XSLTPROC \ 19841 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 19842 xml-tests/test.xml | sort 19843 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19844 at_status=$? at_failed=false 19845 $at_check_filter 19846 at_fn_diff_devnull "$at_stderr" || at_failed=: 19847 $at_diff expout "$at_stdout" || at_failed=: 19848 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:67" 19849 $at_failed && at_fn_log_failure 19850 $at_traceon; } 19851 19852 rm -rf xml-tests expout 19853 at_restore_special_files 19854 fi 19855 { set +x 19856 $as_echo "$at_srcdir/skeletons.at:67: bison input-gram.y" 19857 at_fn_check_prepare_trace "skeletons.at:67" 19858 ( $at_check_trace; bison input-gram.y 19859 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19860 at_status=$? at_failed=false 19861 $at_check_filter 19862 at_fn_diff_devnull "$at_stderr" || at_failed=: 19863 at_fn_diff_devnull "$at_stdout" || at_failed=: 19864 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:67" 19865 $at_failed && at_fn_log_failure 19866 $at_traceon; } 19867 19868 19869 { set +x 19870 $as_echo "$at_srcdir/skeletons.at:68: cat input-gram.tab.c" 19871 at_fn_check_prepare_trace "skeletons.at:68" 19872 ( $at_check_trace; cat input-gram.tab.c 19873 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19874 at_status=$? at_failed=false 19875 $at_check_filter 19876 at_fn_diff_devnull "$at_stderr" || at_failed=: 19877 echo >>"$at_stdout"; $as_echo "Hello World -- Local 19878 " | \ 19879 $at_diff - "$at_stdout" || at_failed=: 19880 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:68" 19881 $at_failed && at_fn_log_failure 19882 $at_traceon; } 19883 19884 19885 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 19886 at_save_special_files 19887 mkdir xml-tests 19888 # Don't combine these Bison invocations since we want to be sure that 19889 # --report=all isn't required to get the full XML file. 19890 { set +x 19891 $as_echo "$at_srcdir/skeletons.at:72: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 19892 --graph=xml-tests/test.dot --skeleton=tmp/skel.c tmp/input-cmd-line.y" 19893 at_fn_check_prepare_notrace 'an embedded newline' "skeletons.at:72" 19894 ( $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 \ 19895 --graph=xml-tests/test.dot --skeleton=tmp/skel.c tmp/input-cmd-line.y 19896 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19897 at_status=$? at_failed=false 19898 $at_check_filter 19899 echo stderr:; cat "$at_stderr" 19900 echo stdout:; cat "$at_stdout" 19901 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:72" 19902 $at_failed && at_fn_log_failure 19903 $at_traceon; } 19904 19905 { set +x 19906 $as_echo "$at_srcdir/skeletons.at:72: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --skeleton=tmp/skel.c tmp/input-cmd-line.y" 19907 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --skeleton=tmp/skel.c tmp/input-cmd-line.y" "skeletons.at:72" 19908 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --skeleton=tmp/skel.c tmp/input-cmd-line.y 19909 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19910 at_status=$? at_failed=false 19911 $at_check_filter 19912 echo stderr:; cat "$at_stderr" 19913 echo stdout:; cat "$at_stdout" 19914 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:72" 19915 $at_failed && at_fn_log_failure 19916 $at_traceon; } 19917 19918 cp xml-tests/test.output expout 19919 { set +x 19920 $as_echo "$at_srcdir/skeletons.at:72: \$XSLTPROC \\ 19921 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 19922 xml-tests/test.xml" 19923 at_fn_check_prepare_notrace 'a `...` command substitution' "skeletons.at:72" 19924 ( $at_check_trace; $XSLTPROC \ 19925 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 19926 xml-tests/test.xml 19927 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19928 at_status=$? at_failed=false 19929 $at_check_filter 19930 at_fn_diff_devnull "$at_stderr" || at_failed=: 19931 $at_diff expout "$at_stdout" || at_failed=: 19932 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:72" 19933 $at_failed && at_fn_log_failure 19934 $at_traceon; } 19935 19936 sort xml-tests/test.dot > expout 19937 { set +x 19938 $as_echo "$at_srcdir/skeletons.at:72: \$XSLTPROC \\ 19939 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 19940 xml-tests/test.xml | sort" 19941 at_fn_check_prepare_notrace 'a `...` command substitution' "skeletons.at:72" 19942 ( $at_check_trace; $XSLTPROC \ 19943 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 19944 xml-tests/test.xml | sort 19945 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19946 at_status=$? at_failed=false 19947 $at_check_filter 19948 at_fn_diff_devnull "$at_stderr" || at_failed=: 19949 $at_diff expout "$at_stdout" || at_failed=: 19950 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:72" 19951 $at_failed && at_fn_log_failure 19952 $at_traceon; } 19953 19954 rm -rf xml-tests expout 19955 at_restore_special_files 19956 fi 19957 { set +x 19958 $as_echo "$at_srcdir/skeletons.at:72: bison --skeleton=tmp/skel.c tmp/input-cmd-line.y" 19959 at_fn_check_prepare_trace "skeletons.at:72" 19960 ( $at_check_trace; bison --skeleton=tmp/skel.c tmp/input-cmd-line.y 19961 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19962 at_status=$? at_failed=false 19963 $at_check_filter 19964 at_fn_diff_devnull "$at_stderr" || at_failed=: 19965 at_fn_diff_devnull "$at_stdout" || at_failed=: 19966 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:72" 19967 $at_failed && at_fn_log_failure 19968 $at_traceon; } 19969 19970 19971 { set +x 19972 $as_echo "$at_srcdir/skeletons.at:73: cat input-cmd-line.tab.c" 19973 at_fn_check_prepare_trace "skeletons.at:73" 19974 ( $at_check_trace; cat input-cmd-line.tab.c 19975 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 19976 at_status=$? at_failed=false 19977 $at_check_filter 19978 at_fn_diff_devnull "$at_stderr" || at_failed=: 19979 echo >>"$at_stdout"; $as_echo "Hello World 19980 " | \ 19981 $at_diff - "$at_stdout" || at_failed=: 19982 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:73" 19983 $at_failed && at_fn_log_failure 19984 $at_traceon; } 19985 19986 19987 set +x 19988 $at_times_p && times >"$at_times_file" 19989 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 19990 read at_status <"$at_status_file" 19991 #AT_STOP_92 19992 #AT_START_93 19993 at_fn_group_banner 93 'skeletons.at:84' \ 19994 "Installed skeleton file names" " " 4 19995 at_xfail=no 19996 ( 19997 $as_echo "93. $at_setup_line: testing $at_desc ..." 19998 $at_traceon 19999 20000 20001 20002 20003 20004 cat >input-cmd-line.y <<'_ATEOF' 20005 %code top { 20006 #include <config.h> 20007 /* We don't need perfect functions for these tests. */ 20008 #undef malloc 20009 #undef memcmp 20010 #undef realloc 20011 } 20012 20013 %{ 20014 #include <stdio.h> 20015 static void yyerror ( const char *msg); 20016 int yylex (void); 20017 %} 20018 20019 %error-verbose 20020 %token 'a' 20021 20022 %% 20023 20024 start: ; 20025 20026 %% 20027 20028 #include <stdio.h> 20029 /* A C error reporting function. */ 20030 static 20031 void yyerror ( const char *msg) 20032 { 20033 fprintf (stderr, "%s\n", msg); 20034 } 20035 int 20036 yylex (void) 20037 { 20038 return 'a'; 20039 } 20040 20041 int 20042 main (void) 20043 { 20044 return yyparse (); 20045 } 20046 _ATEOF 20047 20048 20049 20050 cat >input-gram.y <<'_ATEOF' 20051 %code top { 20052 #include <config.h> 20053 /* We don't need perfect functions for these tests. */ 20054 #undef malloc 20055 #undef memcmp 20056 #undef realloc 20057 } 20058 20059 %skeleton "yacc.c" 20060 %{ 20061 #include <stdio.h> 20062 static void yyerror ( const char *msg); 20063 int yylex (void); 20064 %} 20065 20066 %error-verbose 20067 %token 'a' 20068 20069 %% 20070 20071 start: ; 20072 20073 %% 20074 20075 #include <stdio.h> 20076 /* A C error reporting function. */ 20077 static 20078 void yyerror ( const char *msg) 20079 { 20080 fprintf (stderr, "%s\n", msg); 20081 } 20082 int 20083 yylex (void) 20084 { 20085 return 'a'; 20086 } 20087 20088 int 20089 main (void) 20090 { 20091 return yyparse (); 20092 } 20093 _ATEOF 20094 20095 20096 20097 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 20098 at_save_special_files 20099 mkdir xml-tests 20100 # Don't combine these Bison invocations since we want to be sure that 20101 # --report=all isn't required to get the full XML file. 20102 { set +x 20103 $as_echo "$at_srcdir/skeletons.at:124: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 20104 --graph=xml-tests/test.dot --skeleton=yacc.c -o input-cmd-line.c input-cmd-line.y" 20105 at_fn_check_prepare_notrace 'an embedded newline' "skeletons.at:124" 20106 ( $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 \ 20107 --graph=xml-tests/test.dot --skeleton=yacc.c -o input-cmd-line.c input-cmd-line.y 20108 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20109 at_status=$? at_failed=false 20110 $at_check_filter 20111 echo stderr:; cat "$at_stderr" 20112 echo stdout:; cat "$at_stdout" 20113 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:124" 20114 $at_failed && at_fn_log_failure 20115 $at_traceon; } 20116 20117 { set +x 20118 $as_echo "$at_srcdir/skeletons.at:124: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --skeleton=yacc.c -o input-cmd-line.c input-cmd-line.y" 20119 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --skeleton=yacc.c -o input-cmd-line.c input-cmd-line.y" "skeletons.at:124" 20120 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --skeleton=yacc.c -o input-cmd-line.c input-cmd-line.y 20121 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20122 at_status=$? at_failed=false 20123 $at_check_filter 20124 echo stderr:; cat "$at_stderr" 20125 echo stdout:; cat "$at_stdout" 20126 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:124" 20127 $at_failed && at_fn_log_failure 20128 $at_traceon; } 20129 20130 cp xml-tests/test.output expout 20131 { set +x 20132 $as_echo "$at_srcdir/skeletons.at:124: \$XSLTPROC \\ 20133 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 20134 xml-tests/test.xml" 20135 at_fn_check_prepare_notrace 'a `...` command substitution' "skeletons.at:124" 20136 ( $at_check_trace; $XSLTPROC \ 20137 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 20138 xml-tests/test.xml 20139 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20140 at_status=$? at_failed=false 20141 $at_check_filter 20142 at_fn_diff_devnull "$at_stderr" || at_failed=: 20143 $at_diff expout "$at_stdout" || at_failed=: 20144 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:124" 20145 $at_failed && at_fn_log_failure 20146 $at_traceon; } 20147 20148 sort xml-tests/test.dot > expout 20149 { set +x 20150 $as_echo "$at_srcdir/skeletons.at:124: \$XSLTPROC \\ 20151 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 20152 xml-tests/test.xml | sort" 20153 at_fn_check_prepare_notrace 'a `...` command substitution' "skeletons.at:124" 20154 ( $at_check_trace; $XSLTPROC \ 20155 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 20156 xml-tests/test.xml | sort 20157 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20158 at_status=$? at_failed=false 20159 $at_check_filter 20160 at_fn_diff_devnull "$at_stderr" || at_failed=: 20161 $at_diff expout "$at_stdout" || at_failed=: 20162 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:124" 20163 $at_failed && at_fn_log_failure 20164 $at_traceon; } 20165 20166 rm -rf xml-tests expout 20167 at_restore_special_files 20168 fi 20169 { set +x 20170 $as_echo "$at_srcdir/skeletons.at:124: bison --skeleton=yacc.c -o input-cmd-line.c input-cmd-line.y" 20171 at_fn_check_prepare_trace "skeletons.at:124" 20172 ( $at_check_trace; bison --skeleton=yacc.c -o input-cmd-line.c input-cmd-line.y 20173 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20174 at_status=$? at_failed=false 20175 $at_check_filter 20176 at_fn_diff_devnull "$at_stderr" || at_failed=: 20177 at_fn_diff_devnull "$at_stdout" || at_failed=: 20178 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:124" 20179 $at_failed && at_fn_log_failure 20180 $at_traceon; } 20181 20182 20183 { set +x 20184 $as_echo "$at_srcdir/skeletons.at:125: \$BISON_C_WORKS" 20185 at_fn_check_prepare_dynamic "$BISON_C_WORKS" "skeletons.at:125" 20186 ( $at_check_trace; $BISON_C_WORKS 20187 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20188 at_status=$? at_failed=false 20189 $at_check_filter 20190 echo stderr:; cat "$at_stderr" 20191 echo stdout:; cat "$at_stdout" 20192 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:125" 20193 $at_failed && at_fn_log_failure 20194 $at_traceon; } 20195 20196 { set +x 20197 $as_echo "$at_srcdir/skeletons.at:125: \$CC \$CFLAGS \$CPPFLAGS \$LDFLAGS -o input-cmd-line input-cmd-line.c \$LIBS" 20198 at_fn_check_prepare_dynamic "$CC $CFLAGS $CPPFLAGS $LDFLAGS -o input-cmd-line input-cmd-line.c $LIBS" "skeletons.at:125" 20199 ( $at_check_trace; $CC $CFLAGS $CPPFLAGS $LDFLAGS -o input-cmd-line input-cmd-line.c $LIBS 20200 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20201 at_status=$? at_failed=false 20202 $at_check_filter 20203 echo stderr:; cat "$at_stderr" 20204 echo stdout:; cat "$at_stdout" 20205 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:125" 20206 $at_failed && at_fn_log_failure 20207 $at_traceon; } 20208 20209 { set +x 20210 $as_echo "$at_srcdir/skeletons.at:126: \$PREPARSER ./input-cmd-line" 20211 at_fn_check_prepare_dynamic " $PREPARSER ./input-cmd-line" "skeletons.at:126" 20212 ( $at_check_trace; $PREPARSER ./input-cmd-line 20213 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20214 at_status=$? at_failed=false 20215 $at_check_filter 20216 echo stderr:; tee stderr <"$at_stderr" 20217 at_fn_diff_devnull "$at_stdout" || at_failed=: 20218 at_fn_check_status 1 $at_status "$at_srcdir/skeletons.at:126" 20219 $at_failed && at_fn_log_failure 20220 $at_traceon; } 20221 20222 { set +x 20223 $as_echo "$at_srcdir/skeletons.at:126: sed >&2 -e '/^profiling:.*:Merge mismatch for summaries/d' stderr" 20224 at_fn_check_prepare_trace "skeletons.at:126" 20225 ( $at_check_trace; sed >&2 -e '/^profiling:.*:Merge mismatch for summaries/d' stderr 20226 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20227 at_status=$? at_failed=false 20228 $at_check_filter 20229 echo >>"$at_stderr"; $as_echo "syntax error, unexpected 'a', expecting \$end 20230 " | \ 20231 $at_diff - "$at_stderr" || at_failed=: 20232 at_fn_diff_devnull "$at_stdout" || at_failed=: 20233 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:126" 20234 $at_failed && at_fn_log_failure 20235 $at_traceon; } 20236 20237 20238 20239 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 20240 at_save_special_files 20241 mkdir xml-tests 20242 # Don't combine these Bison invocations since we want to be sure that 20243 # --report=all isn't required to get the full XML file. 20244 { set +x 20245 $as_echo "$at_srcdir/skeletons.at:130: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 20246 --graph=xml-tests/test.dot -o input-gram.c input-gram.y" 20247 at_fn_check_prepare_notrace 'an embedded newline' "skeletons.at:130" 20248 ( $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 \ 20249 --graph=xml-tests/test.dot -o input-gram.c input-gram.y 20250 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20251 at_status=$? at_failed=false 20252 $at_check_filter 20253 echo stderr:; cat "$at_stderr" 20254 echo stdout:; cat "$at_stdout" 20255 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:130" 20256 $at_failed && at_fn_log_failure 20257 $at_traceon; } 20258 20259 { set +x 20260 $as_echo "$at_srcdir/skeletons.at:130: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o input-gram.c input-gram.y" 20261 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-gram.c input-gram.y" "skeletons.at:130" 20262 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -o input-gram.c input-gram.y 20263 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20264 at_status=$? at_failed=false 20265 $at_check_filter 20266 echo stderr:; cat "$at_stderr" 20267 echo stdout:; cat "$at_stdout" 20268 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:130" 20269 $at_failed && at_fn_log_failure 20270 $at_traceon; } 20271 20272 cp xml-tests/test.output expout 20273 { set +x 20274 $as_echo "$at_srcdir/skeletons.at:130: \$XSLTPROC \\ 20275 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 20276 xml-tests/test.xml" 20277 at_fn_check_prepare_notrace 'a `...` command substitution' "skeletons.at:130" 20278 ( $at_check_trace; $XSLTPROC \ 20279 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 20280 xml-tests/test.xml 20281 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20282 at_status=$? at_failed=false 20283 $at_check_filter 20284 at_fn_diff_devnull "$at_stderr" || at_failed=: 20285 $at_diff expout "$at_stdout" || at_failed=: 20286 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:130" 20287 $at_failed && at_fn_log_failure 20288 $at_traceon; } 20289 20290 sort xml-tests/test.dot > expout 20291 { set +x 20292 $as_echo "$at_srcdir/skeletons.at:130: \$XSLTPROC \\ 20293 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 20294 xml-tests/test.xml | sort" 20295 at_fn_check_prepare_notrace 'a `...` command substitution' "skeletons.at:130" 20296 ( $at_check_trace; $XSLTPROC \ 20297 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 20298 xml-tests/test.xml | sort 20299 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20300 at_status=$? at_failed=false 20301 $at_check_filter 20302 at_fn_diff_devnull "$at_stderr" || at_failed=: 20303 $at_diff expout "$at_stdout" || at_failed=: 20304 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:130" 20305 $at_failed && at_fn_log_failure 20306 $at_traceon; } 20307 20308 rm -rf xml-tests expout 20309 at_restore_special_files 20310 fi 20311 { set +x 20312 $as_echo "$at_srcdir/skeletons.at:130: bison -o input-gram.c input-gram.y" 20313 at_fn_check_prepare_trace "skeletons.at:130" 20314 ( $at_check_trace; bison -o input-gram.c input-gram.y 20315 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20316 at_status=$? at_failed=false 20317 $at_check_filter 20318 at_fn_diff_devnull "$at_stderr" || at_failed=: 20319 at_fn_diff_devnull "$at_stdout" || at_failed=: 20320 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:130" 20321 $at_failed && at_fn_log_failure 20322 $at_traceon; } 20323 20324 20325 { set +x 20326 $as_echo "$at_srcdir/skeletons.at:131: \$BISON_C_WORKS" 20327 at_fn_check_prepare_dynamic "$BISON_C_WORKS" "skeletons.at:131" 20328 ( $at_check_trace; $BISON_C_WORKS 20329 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20330 at_status=$? at_failed=false 20331 $at_check_filter 20332 echo stderr:; cat "$at_stderr" 20333 echo stdout:; cat "$at_stdout" 20334 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:131" 20335 $at_failed && at_fn_log_failure 20336 $at_traceon; } 20337 20338 { set +x 20339 $as_echo "$at_srcdir/skeletons.at:131: \$CC \$CFLAGS \$CPPFLAGS \$LDFLAGS -o input-gram input-gram.c \$LIBS" 20340 at_fn_check_prepare_dynamic "$CC $CFLAGS $CPPFLAGS $LDFLAGS -o input-gram input-gram.c $LIBS" "skeletons.at:131" 20341 ( $at_check_trace; $CC $CFLAGS $CPPFLAGS $LDFLAGS -o input-gram input-gram.c $LIBS 20342 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20343 at_status=$? at_failed=false 20344 $at_check_filter 20345 echo stderr:; cat "$at_stderr" 20346 echo stdout:; cat "$at_stdout" 20347 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:131" 20348 $at_failed && at_fn_log_failure 20349 $at_traceon; } 20350 20351 { set +x 20352 $as_echo "$at_srcdir/skeletons.at:132: \$PREPARSER ./input-gram" 20353 at_fn_check_prepare_dynamic " $PREPARSER ./input-gram" "skeletons.at:132" 20354 ( $at_check_trace; $PREPARSER ./input-gram 20355 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20356 at_status=$? at_failed=false 20357 $at_check_filter 20358 echo stderr:; tee stderr <"$at_stderr" 20359 at_fn_diff_devnull "$at_stdout" || at_failed=: 20360 at_fn_check_status 1 $at_status "$at_srcdir/skeletons.at:132" 20361 $at_failed && at_fn_log_failure 20362 $at_traceon; } 20363 20364 { set +x 20365 $as_echo "$at_srcdir/skeletons.at:132: sed >&2 -e '/^profiling:.*:Merge mismatch for summaries/d' stderr" 20366 at_fn_check_prepare_trace "skeletons.at:132" 20367 ( $at_check_trace; sed >&2 -e '/^profiling:.*:Merge mismatch for summaries/d' stderr 20368 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20369 at_status=$? at_failed=false 20370 $at_check_filter 20371 echo >>"$at_stderr"; $as_echo "syntax error, unexpected 'a', expecting \$end 20372 " | \ 20373 $at_diff - "$at_stderr" || at_failed=: 20374 at_fn_diff_devnull "$at_stdout" || at_failed=: 20375 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:132" 20376 $at_failed && at_fn_log_failure 20377 $at_traceon; } 20378 20379 20380 20381 20382 20383 20384 set +x 20385 $at_times_p && times >"$at_times_file" 20386 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 20387 read at_status <"$at_status_file" 20388 #AT_STOP_93 20389 #AT_START_94 20390 at_fn_group_banner 94 'skeletons.at:146' \ 20391 "%define Boolean variables: invalid skeleton defaults" "" 4 20392 at_xfail=no 20393 ( 20394 $as_echo "94. $at_setup_line: testing $at_desc ..." 20395 $at_traceon 20396 20397 20398 cat >skel.c <<'_ATEOF' 20399 b4_percent_define_default([[foo]], [[bogus value]]) 20400 b4_percent_define_flag_if([[foo]]) 20401 _ATEOF 20402 20403 20404 cat >input.y <<'_ATEOF' 20405 %skeleton "./skel.c" 20406 %% 20407 start: ; 20408 _ATEOF 20409 20410 20411 20412 { set +x 20413 $as_echo "$at_srcdir/skeletons.at:159: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 20414 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "skeletons.at:159" 20415 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 20416 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20417 at_status=$? at_failed=false 20418 $at_check_filter 20419 echo >>"$at_stderr"; $as_echo "<skeleton default value>: error: invalid value for %define Boolean variable 'foo' 20420 " | \ 20421 $at_diff - "$at_stderr" || at_failed=: 20422 at_fn_diff_devnull "$at_stdout" || at_failed=: 20423 at_fn_check_status 1 $at_status "$at_srcdir/skeletons.at:159" 20424 $at_failed && at_fn_log_failure 20425 $at_traceon; } 20426 20427 20428 20429 set +x 20430 $at_times_p && times >"$at_times_file" 20431 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 20432 read at_status <"$at_status_file" 20433 #AT_STOP_94 20434 #AT_START_95 20435 at_fn_group_banner 95 'skeletons.at:170' \ 20436 "Complaining during macro argument expansion" " " 4 20437 at_xfail=no 20438 ( 20439 $as_echo "95. $at_setup_line: testing $at_desc ..." 20440 $at_traceon 20441 20442 20443 cat >skel1.c <<'_ATEOF' 20444 m4_define([foow], [b4_warn([[foow fubar]])]) 20445 m4_define([foowat], [b4_warn_at([[foow.y:2.3]], 20446 [[foow.y:5.4]], [[foowat fubar]])]) 20447 m4_define([fooc], [b4_complain([[fooc fubar]])]) 20448 m4_define([foocat], [b4_complain_at([[fooc.y:1.1]], 20449 [[fooc.y:10.6]], [[foocat fubar]])]) 20450 m4_define([foof], [b4_fatal([[foof fubar]])]) 20451 m4_if(foow, [1], [yes]) 20452 m4_if(foowat, [1], [yes]) 20453 m4_if(fooc, [1], [yes]) 20454 m4_if(foocat, [1], [yes]) 20455 m4_if(foof, [1], [yes]) 20456 _ATEOF 20457 20458 20459 cat >input1.y <<'_ATEOF' 20460 %skeleton "./skel1.c" 20461 %% 20462 start: ; 20463 _ATEOF 20464 20465 20466 20467 { set +x 20468 $as_echo "$at_srcdir/skeletons.at:193: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input1.y" 20469 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input1.y" "skeletons.at:193" 20470 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input1.y 20471 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20472 at_status=$? at_failed=false 20473 $at_check_filter 20474 echo >>"$at_stderr"; $as_echo "input1.y: warning: foow fubar 20475 foow.y:2.3-5.3: warning: foowat fubar 20476 input1.y: error: fooc fubar 20477 fooc.y:1.1-10.5: error: foocat fubar 20478 input1.y: fatal error: foof fubar 20479 " | \ 20480 $at_diff - "$at_stderr" || at_failed=: 20481 at_fn_diff_devnull "$at_stdout" || at_failed=: 20482 at_fn_check_status 1 $at_status "$at_srcdir/skeletons.at:193" 20483 $at_failed && at_fn_log_failure 20484 $at_traceon; } 20485 20486 20487 20488 cat >skel2.c <<'_ATEOF' 20489 m4_define([foofat], [b4_fatal_at([[foof.y:12.11]], 20490 [[foof.y:100.123]], [[foofat fubar]])]) 20491 m4_if(foofat, [1], [yes]) 20492 _ATEOF 20493 20494 20495 cat >input2.y <<'_ATEOF' 20496 %skeleton "./skel2.c" 20497 %% 20498 start: ; 20499 _ATEOF 20500 20501 20502 20503 { set +x 20504 $as_echo "$at_srcdir/skeletons.at:213: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input2.y" 20505 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input2.y" "skeletons.at:213" 20506 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input2.y 20507 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20508 at_status=$? at_failed=false 20509 $at_check_filter 20510 echo >>"$at_stderr"; $as_echo "foof.y:12.11-100.122: fatal error: foofat fubar 20511 " | \ 20512 $at_diff - "$at_stderr" || at_failed=: 20513 at_fn_diff_devnull "$at_stdout" || at_failed=: 20514 at_fn_check_status 1 $at_status "$at_srcdir/skeletons.at:213" 20515 $at_failed && at_fn_log_failure 20516 $at_traceon; } 20517 20518 20519 20520 cat >skel3.c <<'_ATEOF' 20521 b4_complain_at(b4_percent_define_get_loc([[bogus]]), [[bad value]]) 20522 _ATEOF 20523 20524 20525 cat >input3.y <<'_ATEOF' 20526 %skeleton "./skel3.c" 20527 %% 20528 start: ; 20529 _ATEOF 20530 20531 20532 20533 { set +x 20534 $as_echo "$at_srcdir/skeletons.at:227: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input3.y" 20535 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input3.y" "skeletons.at:227" 20536 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input3.y 20537 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20538 at_status=$? at_failed=false 20539 $at_check_filter 20540 echo >>"$at_stderr"; $as_echo "input3.y: fatal error: b4_percent_define_get_loc: undefined %define variable 'bogus' 20541 " | \ 20542 $at_diff - "$at_stderr" || at_failed=: 20543 at_fn_diff_devnull "$at_stdout" || at_failed=: 20544 at_fn_check_status 1 $at_status "$at_srcdir/skeletons.at:227" 20545 $at_failed && at_fn_log_failure 20546 $at_traceon; } 20547 20548 20549 20550 cat >skel4.c <<'_ATEOF' 20551 b4_warn_at(b4_percent_define_get_syncline([[bogus]]), [[bad value]]) 20552 _ATEOF 20553 20554 20555 cat >input4.y <<'_ATEOF' 20556 %skeleton "./skel4.c" 20557 %% 20558 start: ; 20559 _ATEOF 20560 20561 20562 20563 { set +x 20564 $as_echo "$at_srcdir/skeletons.at:241: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input4.y" 20565 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input4.y" "skeletons.at:241" 20566 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input4.y 20567 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20568 at_status=$? at_failed=false 20569 $at_check_filter 20570 echo >>"$at_stderr"; $as_echo "input4.y: fatal error: b4_percent_define_get_syncline: undefined %define variable 'bogus' 20571 " | \ 20572 $at_diff - "$at_stderr" || at_failed=: 20573 at_fn_diff_devnull "$at_stdout" || at_failed=: 20574 at_fn_check_status 1 $at_status "$at_srcdir/skeletons.at:241" 20575 $at_failed && at_fn_log_failure 20576 $at_traceon; } 20577 20578 20579 20580 set +x 20581 $at_times_p && times >"$at_times_file" 20582 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 20583 read at_status <"$at_status_file" 20584 #AT_STOP_95 20585 #AT_START_96 20586 at_fn_group_banner 96 'skeletons.at:252' \ 20587 "Fatal errors make M4 exit immediately" " " 4 20588 at_xfail=no 20589 ( 20590 $as_echo "96. $at_setup_line: testing $at_desc ..." 20591 $at_traceon 20592 20593 20594 cat >skel1.c <<'_ATEOF' 20595 b4_complain([[non-fatal error]]) 20596 b4_fatal([[M4 should exit immediately here]]) 20597 m4_fatal([this should never be evaluated]) 20598 _ATEOF 20599 20600 20601 cat >input1.y <<'_ATEOF' 20602 %skeleton "./skel1.c" 20603 %% 20604 start: ; 20605 _ATEOF 20606 20607 20608 20609 { set +x 20610 $as_echo "$at_srcdir/skeletons.at:266: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input1.y" 20611 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input1.y" "skeletons.at:266" 20612 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input1.y 20613 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20614 at_status=$? at_failed=false 20615 $at_check_filter 20616 echo >>"$at_stderr"; $as_echo "input1.y: error: non-fatal error 20617 input1.y: fatal error: M4 should exit immediately here 20618 " | \ 20619 $at_diff - "$at_stderr" || at_failed=: 20620 at_fn_diff_devnull "$at_stdout" || at_failed=: 20621 at_fn_check_status 1 $at_status "$at_srcdir/skeletons.at:266" 20622 $at_failed && at_fn_log_failure 20623 $at_traceon; } 20624 20625 20626 20627 cat >skel2.c <<'_ATEOF' 20628 b4_warn([[morning]]) 20629 b4_fatal_at([[foo.y:1.5]], [[foo.y:1.7]], [[M4 should exit immediately here]]) 20630 m4_fatal([this should never be evaluated]) 20631 _ATEOF 20632 20633 20634 cat >input2.y <<'_ATEOF' 20635 %skeleton "./skel2.c" 20636 %% 20637 start: ; 20638 _ATEOF 20639 20640 20641 20642 { set +x 20643 $as_echo "$at_srcdir/skeletons.at:283: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input2.y" 20644 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input2.y" "skeletons.at:283" 20645 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input2.y 20646 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20647 at_status=$? at_failed=false 20648 $at_check_filter 20649 echo >>"$at_stderr"; $as_echo "input2.y: warning: morning 20650 foo.y:1.5-6: fatal error: M4 should exit immediately here 20651 " | \ 20652 $at_diff - "$at_stderr" || at_failed=: 20653 at_fn_diff_devnull "$at_stdout" || at_failed=: 20654 at_fn_check_status 1 $at_status "$at_srcdir/skeletons.at:283" 20655 $at_failed && at_fn_log_failure 20656 $at_traceon; } 20657 20658 20659 20660 set +x 20661 $at_times_p && times >"$at_times_file" 20662 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 20663 read at_status <"$at_status_file" 20664 #AT_STOP_96 20665 #AT_START_97 20666 at_fn_group_banner 97 'skeletons.at:306' \ 20667 "Fatal errors but M4 continues producing output" " " 4 20668 at_xfail=no 20669 ( 20670 $as_echo "97. $at_setup_line: testing $at_desc ..." 20671 $at_traceon 20672 20673 20674 cat >gen-skel.pl <<'_ATEOF' 20675 use warnings; 20676 use strict; 20677 my $M4 = "m4"; 20678 my $DNL = "d"."nl"; 20679 print "${M4}_divert_push(0)$DNL\n"; 20680 print '@output(@,@)', "\n"; 20681 (print "garbage"x10, "\n") for (1..1000); 20682 print "${M4}_divert_pop(0)\n"; 20683 _ATEOF 20684 20685 { set +x 20686 $as_echo "$at_srcdir/skeletons.at:318: \$PERL gen-skel.pl > skel.c || exit 77" 20687 at_fn_check_prepare_dynamic "$PERL gen-skel.pl > skel.c || exit 77" "skeletons.at:318" 20688 ( $at_check_trace; $PERL gen-skel.pl > skel.c || exit 77 20689 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20690 at_status=$? at_failed=false 20691 $at_check_filter 20692 at_fn_diff_devnull "$at_stderr" || at_failed=: 20693 at_fn_diff_devnull "$at_stdout" || at_failed=: 20694 at_fn_check_status 0 $at_status "$at_srcdir/skeletons.at:318" 20695 $at_failed && at_fn_log_failure 20696 $at_traceon; } 20697 20698 20699 cat >input.y <<'_ATEOF' 20700 %skeleton "./skel.c" 20701 %% 20702 start: ; 20703 _ATEOF 20704 20705 20706 20707 { set +x 20708 $as_echo "$at_srcdir/skeletons.at:326: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 20709 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "skeletons.at:326" 20710 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 20711 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20712 at_status=$? at_failed=false 20713 $at_check_filter 20714 echo >>"$at_stderr"; $as_echo "input.y: fatal error: too many arguments for @output directive in skeleton 20715 " | \ 20716 $at_diff - "$at_stderr" || at_failed=: 20717 at_fn_diff_devnull "$at_stdout" || at_failed=: 20718 at_fn_check_status 1 $at_status "$at_srcdir/skeletons.at:326" 20719 $at_failed && at_fn_log_failure 20720 $at_traceon; } 20721 20722 20723 20724 set +x 20725 $at_times_p && times >"$at_times_file" 20726 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 20727 read at_status <"$at_status_file" 20728 #AT_STOP_97 20729 #AT_START_98 20730 at_fn_group_banner 98 'sets.at:66' \ 20731 "Nullable" " " 5 20732 at_xfail=no 20733 ( 20734 $as_echo "98. $at_setup_line: testing $at_desc ..." 20735 $at_traceon 20736 20737 20738 # At some point, nullable had been smoking grass, and managed to say: 20739 # 20740 # Entering set_nullable 20741 # NULLABLE 20742 # 'e': yes 20743 # (null): no 20744 # ... 20745 20746 cat >input.y <<'_ATEOF' 20747 %% 20748 e: 'e' | /* Nothing */; 20749 _ATEOF 20750 20751 20752 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 20753 at_save_special_files 20754 mkdir xml-tests 20755 # Don't combine these Bison invocations since we want to be sure that 20756 # --report=all isn't required to get the full XML file. 20757 { set +x 20758 $as_echo "$at_srcdir/sets.at:81: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 20759 --graph=xml-tests/test.dot --trace=sets input.y" 20760 at_fn_check_prepare_notrace 'an embedded newline' "sets.at:81" 20761 ( $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 \ 20762 --graph=xml-tests/test.dot --trace=sets input.y 20763 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20764 at_status=$? at_failed=false 20765 $at_check_filter 20766 echo stderr:; cat "$at_stderr" 20767 echo stdout:; cat "$at_stdout" 20768 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:81" 20769 $at_failed && at_fn_log_failure 20770 $at_traceon; } 20771 20772 { set +x 20773 $as_echo "$at_srcdir/sets.at:81: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --trace=sets input.y" 20774 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --trace=sets input.y" "sets.at:81" 20775 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --trace=sets input.y 20776 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20777 at_status=$? at_failed=false 20778 $at_check_filter 20779 echo stderr:; cat "$at_stderr" 20780 echo stdout:; cat "$at_stdout" 20781 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:81" 20782 $at_failed && at_fn_log_failure 20783 $at_traceon; } 20784 20785 cp xml-tests/test.output expout 20786 { set +x 20787 $as_echo "$at_srcdir/sets.at:81: \$XSLTPROC \\ 20788 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 20789 xml-tests/test.xml" 20790 at_fn_check_prepare_notrace 'a `...` command substitution' "sets.at:81" 20791 ( $at_check_trace; $XSLTPROC \ 20792 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 20793 xml-tests/test.xml 20794 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20795 at_status=$? at_failed=false 20796 $at_check_filter 20797 at_fn_diff_devnull "$at_stderr" || at_failed=: 20798 $at_diff expout "$at_stdout" || at_failed=: 20799 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:81" 20800 $at_failed && at_fn_log_failure 20801 $at_traceon; } 20802 20803 sort xml-tests/test.dot > expout 20804 { set +x 20805 $as_echo "$at_srcdir/sets.at:81: \$XSLTPROC \\ 20806 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 20807 xml-tests/test.xml | sort" 20808 at_fn_check_prepare_notrace 'a `...` command substitution' "sets.at:81" 20809 ( $at_check_trace; $XSLTPROC \ 20810 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 20811 xml-tests/test.xml | sort 20812 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20813 at_status=$? at_failed=false 20814 $at_check_filter 20815 at_fn_diff_devnull "$at_stderr" || at_failed=: 20816 $at_diff expout "$at_stdout" || at_failed=: 20817 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:81" 20818 $at_failed && at_fn_log_failure 20819 $at_traceon; } 20820 20821 rm -rf xml-tests expout 20822 at_restore_special_files 20823 fi 20824 { set +x 20825 $as_echo "$at_srcdir/sets.at:81: bison --trace=sets input.y" 20826 at_fn_check_prepare_trace "sets.at:81" 20827 ( $at_check_trace; bison --trace=sets input.y 20828 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20829 at_status=$? at_failed=false 20830 $at_check_filter 20831 echo stderr:; tee stderr <"$at_stderr" 20832 at_fn_diff_devnull "$at_stdout" || at_failed=: 20833 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:81" 20834 $at_failed && at_fn_log_failure 20835 $at_traceon; } 20836 20837 20838 cat >extract.sed <<'_ATEOF' 20839 #n 20840 /^NULLABLE$/ { 20841 :null 20842 p 20843 n 20844 /^[ ]*$/ !b null 20845 } 20846 /^FIRSTS$/ { 20847 :firsts 20848 p 20849 n 20850 /^[ ]*$/ !b firsts 20851 } 20852 /^FDERIVES$/ { 20853 :fderiv 20854 p 20855 n 20856 /^[ ]*$/ !b fderiv 20857 } 20858 /^DERIVES$/ { 20859 :deriv 20860 p 20861 n 20862 /^[ ]*$/ !b deriv 20863 } 20864 _ATEOF 20865 20866 { set +x 20867 $as_echo "$at_srcdir/sets.at:82: sed -f extract.sed stderr" 20868 at_fn_check_prepare_trace "sets.at:82" 20869 ( $at_check_trace; sed -f extract.sed stderr 20870 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20871 at_status=$? at_failed=false 20872 $at_check_filter 20873 at_fn_diff_devnull "$at_stderr" || at_failed=: 20874 echo stdout:; tee stdout <"$at_stdout" 20875 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:82" 20876 $at_failed && at_fn_log_failure 20877 $at_traceon; } 20878 20879 { set +x 20880 $as_echo "$at_srcdir/sets.at:82: mv stdout sets" 20881 at_fn_check_prepare_trace "sets.at:82" 20882 ( $at_check_trace; mv stdout sets 20883 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20884 at_status=$? at_failed=false 20885 $at_check_filter 20886 at_fn_diff_devnull "$at_stderr" || at_failed=: 20887 at_fn_diff_devnull "$at_stdout" || at_failed=: 20888 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:82" 20889 $at_failed && at_fn_log_failure 20890 $at_traceon; } 20891 20892 20893 { set +x 20894 $as_echo "$at_srcdir/sets.at:83: cat sets" 20895 at_fn_check_prepare_trace "sets.at:83" 20896 ( $at_check_trace; cat sets 20897 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20898 at_status=$? at_failed=false 20899 $at_check_filter 20900 at_fn_diff_devnull "$at_stderr" || at_failed=: 20901 echo >>"$at_stdout"; $as_echo "DERIVES 20902 \$accept derives 20903 0 e \$end 20904 e derives 20905 1 'e' 20906 2 /* empty */ 20907 NULLABLE 20908 \$accept: no 20909 e: yes 20910 FIRSTS 20911 \$accept firsts 20912 \$accept 20913 e 20914 e firsts 20915 e 20916 FDERIVES 20917 \$accept derives 20918 0 e \$end 20919 1 'e' 20920 2 /* empty */ 20921 e derives 20922 1 'e' 20923 2 /* empty */ 20924 " | \ 20925 $at_diff - "$at_stdout" || at_failed=: 20926 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:83" 20927 $at_failed && at_fn_log_failure 20928 $at_traceon; } 20929 20930 20931 set +x 20932 $at_times_p && times >"$at_times_file" 20933 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 20934 read at_status <"$at_status_file" 20935 #AT_STOP_98 20936 #AT_START_99 20937 at_fn_group_banner 99 'sets.at:151' \ 20938 "Broken Closure" " " 5 20939 at_xfail=no 20940 ( 20941 $as_echo "99. $at_setup_line: testing $at_desc ..." 20942 $at_traceon 20943 20944 20945 cat >input.y <<'_ATEOF' 20946 %% 20947 a: b; 20948 b: c; 20949 c: d; 20950 d: e; 20951 e: f; 20952 f: g; 20953 g: h; 20954 h: 'h'; 20955 _ATEOF 20956 20957 20958 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 20959 at_save_special_files 20960 mkdir xml-tests 20961 # Don't combine these Bison invocations since we want to be sure that 20962 # --report=all isn't required to get the full XML file. 20963 { set +x 20964 $as_echo "$at_srcdir/sets.at:165: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 20965 --graph=xml-tests/test.dot --trace=sets input.y" 20966 at_fn_check_prepare_notrace 'an embedded newline' "sets.at:165" 20967 ( $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 \ 20968 --graph=xml-tests/test.dot --trace=sets input.y 20969 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20970 at_status=$? at_failed=false 20971 $at_check_filter 20972 echo stderr:; cat "$at_stderr" 20973 echo stdout:; cat "$at_stdout" 20974 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:165" 20975 $at_failed && at_fn_log_failure 20976 $at_traceon; } 20977 20978 { set +x 20979 $as_echo "$at_srcdir/sets.at:165: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --trace=sets input.y" 20980 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --trace=sets input.y" "sets.at:165" 20981 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --trace=sets input.y 20982 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 20983 at_status=$? at_failed=false 20984 $at_check_filter 20985 echo stderr:; cat "$at_stderr" 20986 echo stdout:; cat "$at_stdout" 20987 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:165" 20988 $at_failed && at_fn_log_failure 20989 $at_traceon; } 20990 20991 cp xml-tests/test.output expout 20992 { set +x 20993 $as_echo "$at_srcdir/sets.at:165: \$XSLTPROC \\ 20994 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 20995 xml-tests/test.xml" 20996 at_fn_check_prepare_notrace 'a `...` command substitution' "sets.at:165" 20997 ( $at_check_trace; $XSLTPROC \ 20998 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 20999 xml-tests/test.xml 21000 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21001 at_status=$? at_failed=false 21002 $at_check_filter 21003 at_fn_diff_devnull "$at_stderr" || at_failed=: 21004 $at_diff expout "$at_stdout" || at_failed=: 21005 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:165" 21006 $at_failed && at_fn_log_failure 21007 $at_traceon; } 21008 21009 sort xml-tests/test.dot > expout 21010 { set +x 21011 $as_echo "$at_srcdir/sets.at:165: \$XSLTPROC \\ 21012 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 21013 xml-tests/test.xml | sort" 21014 at_fn_check_prepare_notrace 'a `...` command substitution' "sets.at:165" 21015 ( $at_check_trace; $XSLTPROC \ 21016 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 21017 xml-tests/test.xml | sort 21018 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21019 at_status=$? at_failed=false 21020 $at_check_filter 21021 at_fn_diff_devnull "$at_stderr" || at_failed=: 21022 $at_diff expout "$at_stdout" || at_failed=: 21023 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:165" 21024 $at_failed && at_fn_log_failure 21025 $at_traceon; } 21026 21027 rm -rf xml-tests expout 21028 at_restore_special_files 21029 fi 21030 { set +x 21031 $as_echo "$at_srcdir/sets.at:165: bison --trace=sets input.y" 21032 at_fn_check_prepare_trace "sets.at:165" 21033 ( $at_check_trace; bison --trace=sets input.y 21034 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21035 at_status=$? at_failed=false 21036 $at_check_filter 21037 echo stderr:; tee stderr <"$at_stderr" 21038 at_fn_diff_devnull "$at_stdout" || at_failed=: 21039 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:165" 21040 $at_failed && at_fn_log_failure 21041 $at_traceon; } 21042 21043 21044 21045 { set +x 21046 $as_echo "$at_srcdir/sets.at:167: sed -n 's/[ ]*\$//;/^RTC: Firsts Output BEGIN/,/^RTC: Firsts Output END/p' stderr" 21047 at_fn_check_prepare_dynamic "sed -n 's/[ ]*$//;/^RTC: Firsts Output BEGIN/,/^RTC: Firsts Output END/p' stderr" "sets.at:167" 21048 ( $at_check_trace; sed -n 's/[ ]*$//;/^RTC: Firsts Output BEGIN/,/^RTC: Firsts Output END/p' stderr 21049 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21050 at_status=$? at_failed=false 21051 $at_check_filter 21052 at_fn_diff_devnull "$at_stderr" || at_failed=: 21053 echo >>"$at_stdout"; $as_echo "RTC: Firsts Output BEGIN 21054 21055 012345678 21056 .---------. 21057 0|111111111| 21058 1| 11111111| 21059 2| 1111111| 21060 3| 111111| 21061 4| 11111| 21062 5| 1111| 21063 6| 111| 21064 7| 11| 21065 8| 1| 21066 \`---------' 21067 RTC: Firsts Output END 21068 " | \ 21069 $at_diff - "$at_stdout" || at_failed=: 21070 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:167" 21071 $at_failed && at_fn_log_failure 21072 $at_traceon; } 21073 21074 21075 set +x 21076 $at_times_p && times >"$at_times_file" 21077 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 21078 read at_status <"$at_status_file" 21079 #AT_STOP_99 21080 #AT_START_100 21081 at_fn_group_banner 100 'sets.at:193' \ 21082 "Firsts" " " 5 21083 at_xfail=no 21084 ( 21085 $as_echo "100. $at_setup_line: testing $at_desc ..." 21086 $at_traceon 21087 21088 21089 cat >input.y <<'_ATEOF' 21090 %nonassoc '<' '>' 21091 %left '+' '-' 21092 %right '^' '=' 21093 %% 21094 exp: 21095 exp '<' exp 21096 | exp '>' exp 21097 | exp '+' exp 21098 | exp '-' exp 21099 | exp '^' exp 21100 | exp '=' exp 21101 | "exp" 21102 ; 21103 _ATEOF 21104 21105 21106 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 21107 at_save_special_files 21108 mkdir xml-tests 21109 # Don't combine these Bison invocations since we want to be sure that 21110 # --report=all isn't required to get the full XML file. 21111 { set +x 21112 $as_echo "$at_srcdir/sets.at:211: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 21113 --graph=xml-tests/test.dot --trace=sets input.y" 21114 at_fn_check_prepare_notrace 'an embedded newline' "sets.at:211" 21115 ( $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 \ 21116 --graph=xml-tests/test.dot --trace=sets input.y 21117 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21118 at_status=$? at_failed=false 21119 $at_check_filter 21120 echo stderr:; cat "$at_stderr" 21121 echo stdout:; cat "$at_stdout" 21122 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:211" 21123 $at_failed && at_fn_log_failure 21124 $at_traceon; } 21125 21126 { set +x 21127 $as_echo "$at_srcdir/sets.at:211: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --trace=sets input.y" 21128 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --trace=sets input.y" "sets.at:211" 21129 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --trace=sets input.y 21130 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21131 at_status=$? at_failed=false 21132 $at_check_filter 21133 echo stderr:; cat "$at_stderr" 21134 echo stdout:; cat "$at_stdout" 21135 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:211" 21136 $at_failed && at_fn_log_failure 21137 $at_traceon; } 21138 21139 cp xml-tests/test.output expout 21140 { set +x 21141 $as_echo "$at_srcdir/sets.at:211: \$XSLTPROC \\ 21142 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 21143 xml-tests/test.xml" 21144 at_fn_check_prepare_notrace 'a `...` command substitution' "sets.at:211" 21145 ( $at_check_trace; $XSLTPROC \ 21146 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 21147 xml-tests/test.xml 21148 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21149 at_status=$? at_failed=false 21150 $at_check_filter 21151 at_fn_diff_devnull "$at_stderr" || at_failed=: 21152 $at_diff expout "$at_stdout" || at_failed=: 21153 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:211" 21154 $at_failed && at_fn_log_failure 21155 $at_traceon; } 21156 21157 sort xml-tests/test.dot > expout 21158 { set +x 21159 $as_echo "$at_srcdir/sets.at:211: \$XSLTPROC \\ 21160 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 21161 xml-tests/test.xml | sort" 21162 at_fn_check_prepare_notrace 'a `...` command substitution' "sets.at:211" 21163 ( $at_check_trace; $XSLTPROC \ 21164 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 21165 xml-tests/test.xml | sort 21166 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21167 at_status=$? at_failed=false 21168 $at_check_filter 21169 at_fn_diff_devnull "$at_stderr" || at_failed=: 21170 $at_diff expout "$at_stdout" || at_failed=: 21171 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:211" 21172 $at_failed && at_fn_log_failure 21173 $at_traceon; } 21174 21175 rm -rf xml-tests expout 21176 at_restore_special_files 21177 fi 21178 { set +x 21179 $as_echo "$at_srcdir/sets.at:211: bison --trace=sets input.y" 21180 at_fn_check_prepare_trace "sets.at:211" 21181 ( $at_check_trace; bison --trace=sets input.y 21182 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21183 at_status=$? at_failed=false 21184 $at_check_filter 21185 echo stderr:; tee stderr <"$at_stderr" 21186 at_fn_diff_devnull "$at_stdout" || at_failed=: 21187 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:211" 21188 $at_failed && at_fn_log_failure 21189 $at_traceon; } 21190 21191 21192 cat >extract.sed <<'_ATEOF' 21193 #n 21194 /^NULLABLE$/ { 21195 :null 21196 p 21197 n 21198 /^[ ]*$/ !b null 21199 } 21200 /^FIRSTS$/ { 21201 :firsts 21202 p 21203 n 21204 /^[ ]*$/ !b firsts 21205 } 21206 /^FDERIVES$/ { 21207 :fderiv 21208 p 21209 n 21210 /^[ ]*$/ !b fderiv 21211 } 21212 /^DERIVES$/ { 21213 :deriv 21214 p 21215 n 21216 /^[ ]*$/ !b deriv 21217 } 21218 _ATEOF 21219 21220 { set +x 21221 $as_echo "$at_srcdir/sets.at:212: sed -f extract.sed stderr" 21222 at_fn_check_prepare_trace "sets.at:212" 21223 ( $at_check_trace; sed -f extract.sed stderr 21224 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21225 at_status=$? at_failed=false 21226 $at_check_filter 21227 at_fn_diff_devnull "$at_stderr" || at_failed=: 21228 echo stdout:; tee stdout <"$at_stdout" 21229 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:212" 21230 $at_failed && at_fn_log_failure 21231 $at_traceon; } 21232 21233 { set +x 21234 $as_echo "$at_srcdir/sets.at:212: mv stdout sets" 21235 at_fn_check_prepare_trace "sets.at:212" 21236 ( $at_check_trace; mv stdout sets 21237 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21238 at_status=$? at_failed=false 21239 $at_check_filter 21240 at_fn_diff_devnull "$at_stderr" || at_failed=: 21241 at_fn_diff_devnull "$at_stdout" || at_failed=: 21242 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:212" 21243 $at_failed && at_fn_log_failure 21244 $at_traceon; } 21245 21246 21247 { set +x 21248 $as_echo "$at_srcdir/sets.at:213: cat sets" 21249 at_fn_check_prepare_trace "sets.at:213" 21250 ( $at_check_trace; cat sets 21251 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21252 at_status=$? at_failed=false 21253 $at_check_filter 21254 at_fn_diff_devnull "$at_stderr" || at_failed=: 21255 echo >>"$at_stdout"; $as_echo "DERIVES 21256 \$accept derives 21257 0 exp \$end 21258 exp derives 21259 1 exp '<' exp 21260 2 exp '>' exp 21261 3 exp '+' exp 21262 4 exp '-' exp 21263 5 exp '^' exp 21264 6 exp '=' exp 21265 7 \"exp\" 21266 NULLABLE 21267 \$accept: no 21268 exp: no 21269 FIRSTS 21270 \$accept firsts 21271 \$accept 21272 exp 21273 exp firsts 21274 exp 21275 FDERIVES 21276 \$accept derives 21277 0 exp \$end 21278 1 exp '<' exp 21279 2 exp '>' exp 21280 3 exp '+' exp 21281 4 exp '-' exp 21282 5 exp '^' exp 21283 6 exp '=' exp 21284 7 \"exp\" 21285 exp derives 21286 1 exp '<' exp 21287 2 exp '>' exp 21288 3 exp '+' exp 21289 4 exp '-' exp 21290 5 exp '^' exp 21291 6 exp '=' exp 21292 7 \"exp\" 21293 " | \ 21294 $at_diff - "$at_stdout" || at_failed=: 21295 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:213" 21296 $at_failed && at_fn_log_failure 21297 $at_traceon; } 21298 21299 21300 set +x 21301 $at_times_p && times >"$at_times_file" 21302 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 21303 read at_status <"$at_status_file" 21304 #AT_STOP_100 21305 #AT_START_101 21306 at_fn_group_banner 101 'sets.at:269' \ 21307 "Accept" " " 5 21308 at_xfail=no 21309 ( 21310 $as_echo "101. $at_setup_line: testing $at_desc ..." 21311 $at_traceon 21312 21313 21314 cat >input.y <<'_ATEOF' 21315 %token END 0 21316 %% 21317 input: 21318 'a' 21319 | '(' input ')' 21320 | '(' error END 21321 ; 21322 _ATEOF 21323 21324 21325 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 21326 at_save_special_files 21327 mkdir xml-tests 21328 # Don't combine these Bison invocations since we want to be sure that 21329 # --report=all isn't required to get the full XML file. 21330 { set +x 21331 $as_echo "$at_srcdir/sets.at:281: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 21332 --graph=xml-tests/test.dot -v -o input.c input.y" 21333 at_fn_check_prepare_notrace 'an embedded newline' "sets.at:281" 21334 ( $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 \ 21335 --graph=xml-tests/test.dot -v -o input.c input.y 21336 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21337 at_status=$? at_failed=false 21338 $at_check_filter 21339 echo stderr:; cat "$at_stderr" 21340 echo stdout:; cat "$at_stdout" 21341 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:281" 21342 $at_failed && at_fn_log_failure 21343 $at_traceon; } 21344 21345 { set +x 21346 $as_echo "$at_srcdir/sets.at:281: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -v -o input.c input.y" 21347 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -v -o input.c input.y" "sets.at:281" 21348 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -v -o input.c input.y 21349 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21350 at_status=$? at_failed=false 21351 $at_check_filter 21352 echo stderr:; cat "$at_stderr" 21353 echo stdout:; cat "$at_stdout" 21354 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:281" 21355 $at_failed && at_fn_log_failure 21356 $at_traceon; } 21357 21358 cp xml-tests/test.output expout 21359 { set +x 21360 $as_echo "$at_srcdir/sets.at:281: \$XSLTPROC \\ 21361 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 21362 xml-tests/test.xml" 21363 at_fn_check_prepare_notrace 'a `...` command substitution' "sets.at:281" 21364 ( $at_check_trace; $XSLTPROC \ 21365 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 21366 xml-tests/test.xml 21367 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21368 at_status=$? at_failed=false 21369 $at_check_filter 21370 at_fn_diff_devnull "$at_stderr" || at_failed=: 21371 $at_diff expout "$at_stdout" || at_failed=: 21372 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:281" 21373 $at_failed && at_fn_log_failure 21374 $at_traceon; } 21375 21376 sort xml-tests/test.dot > expout 21377 { set +x 21378 $as_echo "$at_srcdir/sets.at:281: \$XSLTPROC \\ 21379 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 21380 xml-tests/test.xml | sort" 21381 at_fn_check_prepare_notrace 'a `...` command substitution' "sets.at:281" 21382 ( $at_check_trace; $XSLTPROC \ 21383 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 21384 xml-tests/test.xml | sort 21385 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21386 at_status=$? at_failed=false 21387 $at_check_filter 21388 at_fn_diff_devnull "$at_stderr" || at_failed=: 21389 $at_diff expout "$at_stdout" || at_failed=: 21390 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:281" 21391 $at_failed && at_fn_log_failure 21392 $at_traceon; } 21393 21394 rm -rf xml-tests expout 21395 at_restore_special_files 21396 fi 21397 { set +x 21398 $as_echo "$at_srcdir/sets.at:281: bison -v -o input.c input.y" 21399 at_fn_check_prepare_trace "sets.at:281" 21400 ( $at_check_trace; bison -v -o input.c input.y 21401 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21402 at_status=$? at_failed=false 21403 $at_check_filter 21404 at_fn_diff_devnull "$at_stderr" || at_failed=: 21405 at_fn_diff_devnull "$at_stdout" || at_failed=: 21406 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:281" 21407 $at_failed && at_fn_log_failure 21408 $at_traceon; } 21409 21410 21411 21412 # Get the final state in the parser. 21413 { set +x 21414 $as_echo "$at_srcdir/sets.at:284: sed -n 's/.*define YYFINAL *\\([0-9][0-9]*\\)/final state \\1/p' input.c" 21415 at_fn_check_prepare_trace "sets.at:284" 21416 ( $at_check_trace; sed -n 's/.*define YYFINAL *\([0-9][0-9]*\)/final state \1/p' input.c 21417 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21418 at_status=$? at_failed=false 21419 $at_check_filter 21420 at_fn_diff_devnull "$at_stderr" || at_failed=: 21421 echo stdout:; tee stdout <"$at_stdout" 21422 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:284" 21423 $at_failed && at_fn_log_failure 21424 $at_traceon; } 21425 21426 mv stdout expout 21427 21428 # Get the final state in the report, from the "accept" action.. 21429 { set +x 21430 $as_echo "$at_srcdir/sets.at:289: sed -n ' 21431 /^State \\(.*\\)/{ 21432 s//final state \\1/ 21433 x 21434 } 21435 / accept/{ 21436 x 21437 p 21438 q 21439 } 21440 ' input.output" 21441 at_fn_check_prepare_notrace 'an embedded newline' "sets.at:289" 21442 ( $at_check_trace; sed -n ' 21443 /^State \(.*\)/{ 21444 s//final state \1/ 21445 x 21446 } 21447 / accept/{ 21448 x 21449 p 21450 q 21451 } 21452 ' input.output 21453 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21454 at_status=$? at_failed=false 21455 $at_check_filter 21456 at_fn_diff_devnull "$at_stderr" || at_failed=: 21457 $at_diff expout "$at_stdout" || at_failed=: 21458 at_fn_check_status 0 $at_status "$at_srcdir/sets.at:289" 21459 $at_failed && at_fn_log_failure 21460 $at_traceon; } 21461 21462 21463 set +x 21464 $at_times_p && times >"$at_times_file" 21465 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 21466 read at_status <"$at_status_file" 21467 #AT_STOP_101 21468 #AT_START_102 21469 at_fn_group_banner 102 'reduce.at:25' \ 21470 "Useless Terminals" " " 6 21471 at_xfail=no 21472 ( 21473 $as_echo "102. $at_setup_line: testing $at_desc ..." 21474 $at_traceon 21475 21476 21477 cat >input.y <<'_ATEOF' 21478 %verbose 21479 %output "input.c" 21480 21481 %token useless1 21482 %token useless2 21483 %token useless3 21484 %token useless4 21485 %token useless5 21486 %token useless6 21487 %token useless7 21488 %token useless8 21489 %token useless9 21490 21491 %token useful 21492 %% 21493 exp: useful; 21494 _ATEOF 21495 21496 21497 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 21498 at_save_special_files 21499 mkdir xml-tests 21500 # Don't combine these Bison invocations since we want to be sure that 21501 # --report=all isn't required to get the full XML file. 21502 { set +x 21503 $as_echo "$at_srcdir/reduce.at:46: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 21504 --graph=xml-tests/test.dot input.y" 21505 at_fn_check_prepare_notrace 'an embedded newline' "reduce.at:46" 21506 ( $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 \ 21507 --graph=xml-tests/test.dot input.y 21508 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21509 at_status=$? at_failed=false 21510 $at_check_filter 21511 echo stderr:; cat "$at_stderr" 21512 echo stdout:; cat "$at_stdout" 21513 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:46" 21514 $at_failed && at_fn_log_failure 21515 $at_traceon; } 21516 21517 { set +x 21518 $as_echo "$at_srcdir/reduce.at:46: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y" 21519 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" "reduce.at:46" 21520 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y 21521 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21522 at_status=$? at_failed=false 21523 $at_check_filter 21524 echo stderr:; cat "$at_stderr" 21525 echo stdout:; cat "$at_stdout" 21526 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:46" 21527 $at_failed && at_fn_log_failure 21528 $at_traceon; } 21529 21530 cp xml-tests/test.output expout 21531 { set +x 21532 $as_echo "$at_srcdir/reduce.at:46: \$XSLTPROC \\ 21533 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 21534 xml-tests/test.xml" 21535 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:46" 21536 ( $at_check_trace; $XSLTPROC \ 21537 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 21538 xml-tests/test.xml 21539 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21540 at_status=$? at_failed=false 21541 $at_check_filter 21542 at_fn_diff_devnull "$at_stderr" || at_failed=: 21543 $at_diff expout "$at_stdout" || at_failed=: 21544 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:46" 21545 $at_failed && at_fn_log_failure 21546 $at_traceon; } 21547 21548 sort xml-tests/test.dot > expout 21549 { set +x 21550 $as_echo "$at_srcdir/reduce.at:46: \$XSLTPROC \\ 21551 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 21552 xml-tests/test.xml | sort" 21553 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:46" 21554 ( $at_check_trace; $XSLTPROC \ 21555 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 21556 xml-tests/test.xml | sort 21557 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21558 at_status=$? at_failed=false 21559 $at_check_filter 21560 at_fn_diff_devnull "$at_stderr" || at_failed=: 21561 $at_diff expout "$at_stdout" || at_failed=: 21562 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:46" 21563 $at_failed && at_fn_log_failure 21564 $at_traceon; } 21565 21566 rm -rf xml-tests expout 21567 at_restore_special_files 21568 fi 21569 { set +x 21570 $as_echo "$at_srcdir/reduce.at:46: bison input.y" 21571 at_fn_check_prepare_trace "reduce.at:46" 21572 ( $at_check_trace; bison input.y 21573 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21574 at_status=$? at_failed=false 21575 $at_check_filter 21576 at_fn_diff_devnull "$at_stderr" || at_failed=: 21577 at_fn_diff_devnull "$at_stdout" || at_failed=: 21578 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:46" 21579 $at_failed && at_fn_log_failure 21580 $at_traceon; } 21581 21582 21583 21584 { set +x 21585 $as_echo "$at_srcdir/reduce.at:48: sed -n '/^Grammar/q;/^\$/!p' input.output" 21586 at_fn_check_prepare_dynamic "sed -n '/^Grammar/q;/^$/!p' input.output" "reduce.at:48" 21587 ( $at_check_trace; sed -n '/^Grammar/q;/^$/!p' input.output 21588 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21589 at_status=$? at_failed=false 21590 $at_check_filter 21591 at_fn_diff_devnull "$at_stderr" || at_failed=: 21592 echo >>"$at_stdout"; $as_echo "Terminals unused in grammar 21593 useless1 21594 useless2 21595 useless3 21596 useless4 21597 useless5 21598 useless6 21599 useless7 21600 useless8 21601 useless9 21602 " | \ 21603 $at_diff - "$at_stdout" || at_failed=: 21604 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:48" 21605 $at_failed && at_fn_log_failure 21606 $at_traceon; } 21607 21608 21609 set +x 21610 $at_times_p && times >"$at_times_file" 21611 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 21612 read at_status <"$at_status_file" 21613 #AT_STOP_102 21614 #AT_START_103 21615 at_fn_group_banner 103 'reduce.at:69' \ 21616 "Useless Nonterminals" " " 6 21617 at_xfail=no 21618 ( 21619 $as_echo "103. $at_setup_line: testing $at_desc ..." 21620 $at_traceon 21621 21622 21623 cat >input.y <<'_ATEOF' 21624 %verbose 21625 %output "input.c" 21626 21627 %nterm useless1 21628 %nterm useless2 21629 %nterm useless3 21630 %nterm useless4 21631 %nterm useless5 21632 %nterm useless6 21633 %nterm useless7 21634 %nterm useless8 21635 %nterm useless9 21636 21637 %token useful 21638 %% 21639 exp: useful; 21640 _ATEOF 21641 21642 21643 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 21644 at_save_special_files 21645 mkdir xml-tests 21646 # Don't combine these Bison invocations since we want to be sure that 21647 # --report=all isn't required to get the full XML file. 21648 { set +x 21649 $as_echo "$at_srcdir/reduce.at:90: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 21650 --graph=xml-tests/test.dot input.y" 21651 at_fn_check_prepare_notrace 'an embedded newline' "reduce.at:90" 21652 ( $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 \ 21653 --graph=xml-tests/test.dot input.y 21654 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21655 at_status=$? at_failed=false 21656 $at_check_filter 21657 echo stderr:; cat "$at_stderr" 21658 echo stdout:; cat "$at_stdout" 21659 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:90" 21660 $at_failed && at_fn_log_failure 21661 $at_traceon; } 21662 21663 { set +x 21664 $as_echo "$at_srcdir/reduce.at:90: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y" 21665 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" "reduce.at:90" 21666 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y 21667 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21668 at_status=$? at_failed=false 21669 $at_check_filter 21670 echo stderr:; cat "$at_stderr" 21671 echo stdout:; cat "$at_stdout" 21672 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:90" 21673 $at_failed && at_fn_log_failure 21674 $at_traceon; } 21675 21676 cp xml-tests/test.output expout 21677 { set +x 21678 $as_echo "$at_srcdir/reduce.at:90: \$XSLTPROC \\ 21679 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 21680 xml-tests/test.xml" 21681 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:90" 21682 ( $at_check_trace; $XSLTPROC \ 21683 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 21684 xml-tests/test.xml 21685 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21686 at_status=$? at_failed=false 21687 $at_check_filter 21688 at_fn_diff_devnull "$at_stderr" || at_failed=: 21689 $at_diff expout "$at_stdout" || at_failed=: 21690 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:90" 21691 $at_failed && at_fn_log_failure 21692 $at_traceon; } 21693 21694 sort xml-tests/test.dot > expout 21695 { set +x 21696 $as_echo "$at_srcdir/reduce.at:90: \$XSLTPROC \\ 21697 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 21698 xml-tests/test.xml | sort" 21699 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:90" 21700 ( $at_check_trace; $XSLTPROC \ 21701 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 21702 xml-tests/test.xml | sort 21703 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21704 at_status=$? at_failed=false 21705 $at_check_filter 21706 at_fn_diff_devnull "$at_stderr" || at_failed=: 21707 $at_diff expout "$at_stdout" || at_failed=: 21708 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:90" 21709 $at_failed && at_fn_log_failure 21710 $at_traceon; } 21711 21712 rm -rf xml-tests expout 21713 at_restore_special_files 21714 fi 21715 { set +x 21716 $as_echo "$at_srcdir/reduce.at:90: bison input.y" 21717 at_fn_check_prepare_trace "reduce.at:90" 21718 ( $at_check_trace; bison input.y 21719 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21720 at_status=$? at_failed=false 21721 $at_check_filter 21722 echo >>"$at_stderr"; $as_echo "input.y: warning: 9 nonterminals useless in grammar 21723 input.y:4.8-15: warning: nonterminal useless in grammar: useless1 21724 input.y:5.8-15: warning: nonterminal useless in grammar: useless2 21725 input.y:6.8-15: warning: nonterminal useless in grammar: useless3 21726 input.y:7.8-15: warning: nonterminal useless in grammar: useless4 21727 input.y:8.8-15: warning: nonterminal useless in grammar: useless5 21728 input.y:9.8-15: warning: nonterminal useless in grammar: useless6 21729 input.y:10.8-15: warning: nonterminal useless in grammar: useless7 21730 input.y:11.8-15: warning: nonterminal useless in grammar: useless8 21731 input.y:12.8-15: warning: nonterminal useless in grammar: useless9 21732 " | \ 21733 $at_diff - "$at_stderr" || at_failed=: 21734 at_fn_diff_devnull "$at_stdout" || at_failed=: 21735 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:90" 21736 $at_failed && at_fn_log_failure 21737 $at_traceon; } 21738 21739 # Defining POSIXLY_CORRECT causes bison to complain if options are 21740 # added after the grammar file name, so skip these checks in that 21741 # case. 21742 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 21743 at_save_special_files 21744 21745 # To avoid expanding it repeatedly, store specified stdout. 21746 : >expout 21747 21748 # Run with -Werror. 21749 { set +x 21750 $as_echo "$at_srcdir/reduce.at:90: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Werror" 21751 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Werror" "reduce.at:90" 21752 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y -Werror 21753 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21754 at_status=$? at_failed=false 21755 $at_check_filter 21756 echo stderr:; tee stderr <"$at_stderr" 21757 $at_diff expout "$at_stdout" || at_failed=: 21758 at_fn_check_status 1 $at_status "$at_srcdir/reduce.at:90" 21759 $at_failed && at_fn_log_failure 21760 $at_traceon; } 21761 21762 21763 # Build expected stderr up to and including the "warnings being 21764 # treated as errors" message. 21765 cat >at-bison-check-warnings <<'_ATEOF' 21766 input.y: warning: 9 nonterminals useless in grammar 21767 input.y:4.8-15: warning: nonterminal useless in grammar: useless1 21768 input.y:5.8-15: warning: nonterminal useless in grammar: useless2 21769 input.y:6.8-15: warning: nonterminal useless in grammar: useless3 21770 input.y:7.8-15: warning: nonterminal useless in grammar: useless4 21771 input.y:8.8-15: warning: nonterminal useless in grammar: useless5 21772 input.y:9.8-15: warning: nonterminal useless in grammar: useless6 21773 input.y:10.8-15: warning: nonterminal useless in grammar: useless7 21774 input.y:11.8-15: warning: nonterminal useless in grammar: useless8 21775 input.y:12.8-15: warning: nonterminal useless in grammar: useless9 21776 _ATEOF 21777 21778 at_bison_check_first=`sed -n \ 21779 '/: warning: /{=;q;}' at-bison-check-warnings` 21780 : ${at_bison_check_first:=1} 21781 at_bison_check_first_tmp=`sed -n \ 21782 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 21783 : ${at_bison_check_first_tmp:=1} 21784 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 21785 at_bison_check_first=$at_bison_check_first_tmp 21786 fi 21787 if test $at_bison_check_first -gt 1; then 21788 sed -n "1,`expr $at_bison_check_first - 1`"p \ 21789 at-bison-check-warnings > experr 21790 fi 21791 echo 'bison: warnings being treated as errors' >> experr 21792 21793 # Finish building expected stderr and check. Unlike warnings, 21794 # complaints cause bison to exit early. Thus, with -Werror, bison 21795 # does not necessarily report all warnings that it does without 21796 # -Werror, but it at least reports one. 21797 at_bison_check_last=`sed -n '$=' stderr` 21798 : ${at_bison_check_last:=1} 21799 at_bison_check_last=`expr $at_bison_check_last - 1` 21800 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 21801 at-bison-check-warnings >> experr 21802 { set +x 21803 $as_echo "$at_srcdir/reduce.at:90: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 21804 stderr 1>&2" 21805 at_fn_check_prepare_notrace 'an embedded newline' "reduce.at:90" 21806 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 21807 stderr 1>&2 21808 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21809 at_status=$? at_failed=false 21810 $at_check_filter 21811 $at_diff experr "$at_stderr" || at_failed=: 21812 at_fn_diff_devnull "$at_stdout" || at_failed=: 21813 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:90" 21814 $at_failed && at_fn_log_failure 21815 $at_traceon; } 21816 21817 21818 # Now check --warnings=error. 21819 cp stderr experr 21820 { set +x 21821 $as_echo "$at_srcdir/reduce.at:90: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=error" 21822 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=error" "reduce.at:90" 21823 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y --warnings=error 21824 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21825 at_status=$? at_failed=false 21826 $at_check_filter 21827 $at_diff experr "$at_stderr" || at_failed=: 21828 $at_diff expout "$at_stdout" || at_failed=: 21829 at_fn_check_status 1 $at_status "$at_srcdir/reduce.at:90" 21830 $at_failed && at_fn_log_failure 21831 $at_traceon; } 21832 21833 21834 # Now check -Wnone and --warnings=none by making sure that 21835 # -Werror doesn't change the exit status when -Wnone or 21836 # --warnings=none is specified. 21837 { set +x 21838 $as_echo "$at_srcdir/reduce.at:90: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Wnone -Werror" 21839 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Wnone -Werror" "reduce.at:90" 21840 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y -Wnone -Werror 21841 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21842 at_status=$? at_failed=false 21843 $at_check_filter 21844 at_fn_diff_devnull "$at_stderr" || at_failed=: 21845 $at_diff expout "$at_stdout" || at_failed=: 21846 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:90" 21847 $at_failed && at_fn_log_failure 21848 $at_traceon; } 21849 21850 { set +x 21851 $as_echo "$at_srcdir/reduce.at:90: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror" 21852 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror" "reduce.at:90" 21853 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror 21854 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21855 at_status=$? at_failed=false 21856 $at_check_filter 21857 at_fn_diff_devnull "$at_stderr" || at_failed=: 21858 $at_diff expout "$at_stdout" || at_failed=: 21859 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:90" 21860 $at_failed && at_fn_log_failure 21861 $at_traceon; } 21862 21863 21864 at_restore_special_files 21865 fi 21866 21867 { set +x 21868 $as_echo "$at_srcdir/reduce.at:103: sed -n '/^Grammar/q;/^\$/!p' input.output" 21869 at_fn_check_prepare_dynamic "sed -n '/^Grammar/q;/^$/!p' input.output" "reduce.at:103" 21870 ( $at_check_trace; sed -n '/^Grammar/q;/^$/!p' input.output 21871 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21872 at_status=$? at_failed=false 21873 $at_check_filter 21874 at_fn_diff_devnull "$at_stderr" || at_failed=: 21875 echo >>"$at_stdout"; $as_echo "Nonterminals useless in grammar 21876 useless1 21877 useless2 21878 useless3 21879 useless4 21880 useless5 21881 useless6 21882 useless7 21883 useless8 21884 useless9 21885 " | \ 21886 $at_diff - "$at_stdout" || at_failed=: 21887 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:103" 21888 $at_failed && at_fn_log_failure 21889 $at_traceon; } 21890 21891 21892 set +x 21893 $at_times_p && times >"$at_times_file" 21894 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 21895 read at_status <"$at_status_file" 21896 #AT_STOP_103 21897 #AT_START_104 21898 at_fn_group_banner 104 'reduce.at:124' \ 21899 "Useless Rules" " " 6 21900 at_xfail=no 21901 ( 21902 $as_echo "104. $at_setup_line: testing $at_desc ..." 21903 $at_traceon 21904 21905 21906 21907 21908 cat >input.y <<'_ATEOF' 21909 %verbose 21910 %output "input.c" 21911 %token useful 21912 %% 21913 exp: useful; 21914 useless1: '1'; 21915 useless2: '2'; 21916 useless3: '3'; 21917 useless4: '4'; 21918 useless5: '5'; 21919 useless6: '6'; 21920 useless7: '7'; 21921 useless8: '8'; 21922 useless9: '9'; 21923 _ATEOF 21924 21925 21926 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 21927 at_save_special_files 21928 mkdir xml-tests 21929 # Don't combine these Bison invocations since we want to be sure that 21930 # --report=all isn't required to get the full XML file. 21931 { set +x 21932 $as_echo "$at_srcdir/reduce.at:145: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 21933 --graph=xml-tests/test.dot -fcaret input.y" 21934 at_fn_check_prepare_notrace 'an embedded newline' "reduce.at:145" 21935 ( $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 \ 21936 --graph=xml-tests/test.dot -fcaret input.y 21937 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21938 at_status=$? at_failed=false 21939 $at_check_filter 21940 echo stderr:; cat "$at_stderr" 21941 echo stdout:; cat "$at_stdout" 21942 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:145" 21943 $at_failed && at_fn_log_failure 21944 $at_traceon; } 21945 21946 { set +x 21947 $as_echo "$at_srcdir/reduce.at:145: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -fcaret input.y" 21948 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" "reduce.at:145" 21949 ( $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 21950 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21951 at_status=$? at_failed=false 21952 $at_check_filter 21953 echo stderr:; cat "$at_stderr" 21954 echo stdout:; cat "$at_stdout" 21955 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:145" 21956 $at_failed && at_fn_log_failure 21957 $at_traceon; } 21958 21959 cp xml-tests/test.output expout 21960 { set +x 21961 $as_echo "$at_srcdir/reduce.at:145: \$XSLTPROC \\ 21962 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 21963 xml-tests/test.xml" 21964 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:145" 21965 ( $at_check_trace; $XSLTPROC \ 21966 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 21967 xml-tests/test.xml 21968 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21969 at_status=$? at_failed=false 21970 $at_check_filter 21971 at_fn_diff_devnull "$at_stderr" || at_failed=: 21972 $at_diff expout "$at_stdout" || at_failed=: 21973 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:145" 21974 $at_failed && at_fn_log_failure 21975 $at_traceon; } 21976 21977 sort xml-tests/test.dot > expout 21978 { set +x 21979 $as_echo "$at_srcdir/reduce.at:145: \$XSLTPROC \\ 21980 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 21981 xml-tests/test.xml | sort" 21982 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:145" 21983 ( $at_check_trace; $XSLTPROC \ 21984 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 21985 xml-tests/test.xml | sort 21986 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 21987 at_status=$? at_failed=false 21988 $at_check_filter 21989 at_fn_diff_devnull "$at_stderr" || at_failed=: 21990 $at_diff expout "$at_stdout" || at_failed=: 21991 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:145" 21992 $at_failed && at_fn_log_failure 21993 $at_traceon; } 21994 21995 rm -rf xml-tests expout 21996 at_restore_special_files 21997 fi 21998 { set +x 21999 $as_echo "$at_srcdir/reduce.at:145: bison -fcaret input.y" 22000 at_fn_check_prepare_trace "reduce.at:145" 22001 ( $at_check_trace; bison -fcaret input.y 22002 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22003 at_status=$? at_failed=false 22004 $at_check_filter 22005 echo >>"$at_stderr"; $as_echo "input.y: warning: 9 nonterminals useless in grammar 22006 input.y: warning: 9 rules useless in grammar 22007 input.y:6.1-8: warning: nonterminal useless in grammar: useless1 22008 useless1: '1'; 22009 ^^^^^^^^ 22010 input.y:7.1-8: warning: nonterminal useless in grammar: useless2 22011 useless2: '2'; 22012 ^^^^^^^^ 22013 input.y:8.1-8: warning: nonterminal useless in grammar: useless3 22014 useless3: '3'; 22015 ^^^^^^^^ 22016 input.y:9.1-8: warning: nonterminal useless in grammar: useless4 22017 useless4: '4'; 22018 ^^^^^^^^ 22019 input.y:10.1-8: warning: nonterminal useless in grammar: useless5 22020 useless5: '5'; 22021 ^^^^^^^^ 22022 input.y:11.1-8: warning: nonterminal useless in grammar: useless6 22023 useless6: '6'; 22024 ^^^^^^^^ 22025 input.y:12.1-8: warning: nonterminal useless in grammar: useless7 22026 useless7: '7'; 22027 ^^^^^^^^ 22028 input.y:13.1-8: warning: nonterminal useless in grammar: useless8 22029 useless8: '8'; 22030 ^^^^^^^^ 22031 input.y:14.1-8: warning: nonterminal useless in grammar: useless9 22032 useless9: '9'; 22033 ^^^^^^^^ 22034 input.y:6.11-13: warning: rule useless in grammar 22035 useless1: '1'; 22036 ^^^ 22037 input.y:7.11-13: warning: rule useless in grammar 22038 useless2: '2'; 22039 ^^^ 22040 input.y:8.11-13: warning: rule useless in grammar 22041 useless3: '3'; 22042 ^^^ 22043 input.y:9.11-13: warning: rule useless in grammar 22044 useless4: '4'; 22045 ^^^ 22046 input.y:10.11-13: warning: rule useless in grammar 22047 useless5: '5'; 22048 ^^^ 22049 input.y:11.11-13: warning: rule useless in grammar 22050 useless6: '6'; 22051 ^^^ 22052 input.y:12.11-13: warning: rule useless in grammar 22053 useless7: '7'; 22054 ^^^ 22055 input.y:13.11-13: warning: rule useless in grammar 22056 useless8: '8'; 22057 ^^^ 22058 input.y:14.11-13: warning: rule useless in grammar 22059 useless9: '9'; 22060 ^^^ 22061 " | \ 22062 $at_diff - "$at_stderr" || at_failed=: 22063 at_fn_diff_devnull "$at_stdout" || at_failed=: 22064 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:145" 22065 $at_failed && at_fn_log_failure 22066 $at_traceon; } 22067 22068 # Defining POSIXLY_CORRECT causes bison to complain if options are 22069 # added after the grammar file name, so skip these checks in that 22070 # case. 22071 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 22072 at_save_special_files 22073 22074 # To avoid expanding it repeatedly, store specified stdout. 22075 : >expout 22076 22077 # Run with -Werror. 22078 { set +x 22079 $as_echo "$at_srcdir/reduce.at:145: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y -Werror" 22080 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y -Werror" "reduce.at:145" 22081 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -fcaret input.y -Werror 22082 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22083 at_status=$? at_failed=false 22084 $at_check_filter 22085 echo stderr:; tee stderr <"$at_stderr" 22086 $at_diff expout "$at_stdout" || at_failed=: 22087 at_fn_check_status 1 $at_status "$at_srcdir/reduce.at:145" 22088 $at_failed && at_fn_log_failure 22089 $at_traceon; } 22090 22091 22092 # Build expected stderr up to and including the "warnings being 22093 # treated as errors" message. 22094 cat >at-bison-check-warnings <<'_ATEOF' 22095 input.y: warning: 9 nonterminals useless in grammar 22096 input.y: warning: 9 rules useless in grammar 22097 input.y:6.1-8: warning: nonterminal useless in grammar: useless1 22098 useless1: '1'; 22099 ^^^^^^^^ 22100 input.y:7.1-8: warning: nonterminal useless in grammar: useless2 22101 useless2: '2'; 22102 ^^^^^^^^ 22103 input.y:8.1-8: warning: nonterminal useless in grammar: useless3 22104 useless3: '3'; 22105 ^^^^^^^^ 22106 input.y:9.1-8: warning: nonterminal useless in grammar: useless4 22107 useless4: '4'; 22108 ^^^^^^^^ 22109 input.y:10.1-8: warning: nonterminal useless in grammar: useless5 22110 useless5: '5'; 22111 ^^^^^^^^ 22112 input.y:11.1-8: warning: nonterminal useless in grammar: useless6 22113 useless6: '6'; 22114 ^^^^^^^^ 22115 input.y:12.1-8: warning: nonterminal useless in grammar: useless7 22116 useless7: '7'; 22117 ^^^^^^^^ 22118 input.y:13.1-8: warning: nonterminal useless in grammar: useless8 22119 useless8: '8'; 22120 ^^^^^^^^ 22121 input.y:14.1-8: warning: nonterminal useless in grammar: useless9 22122 useless9: '9'; 22123 ^^^^^^^^ 22124 input.y:6.11-13: warning: rule useless in grammar 22125 useless1: '1'; 22126 ^^^ 22127 input.y:7.11-13: warning: rule useless in grammar 22128 useless2: '2'; 22129 ^^^ 22130 input.y:8.11-13: warning: rule useless in grammar 22131 useless3: '3'; 22132 ^^^ 22133 input.y:9.11-13: warning: rule useless in grammar 22134 useless4: '4'; 22135 ^^^ 22136 input.y:10.11-13: warning: rule useless in grammar 22137 useless5: '5'; 22138 ^^^ 22139 input.y:11.11-13: warning: rule useless in grammar 22140 useless6: '6'; 22141 ^^^ 22142 input.y:12.11-13: warning: rule useless in grammar 22143 useless7: '7'; 22144 ^^^ 22145 input.y:13.11-13: warning: rule useless in grammar 22146 useless8: '8'; 22147 ^^^ 22148 input.y:14.11-13: warning: rule useless in grammar 22149 useless9: '9'; 22150 ^^^ 22151 _ATEOF 22152 22153 at_bison_check_first=`sed -n \ 22154 '/: warning: /{=;q;}' at-bison-check-warnings` 22155 : ${at_bison_check_first:=1} 22156 at_bison_check_first_tmp=`sed -n \ 22157 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 22158 : ${at_bison_check_first_tmp:=1} 22159 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 22160 at_bison_check_first=$at_bison_check_first_tmp 22161 fi 22162 if test $at_bison_check_first -gt 1; then 22163 sed -n "1,`expr $at_bison_check_first - 1`"p \ 22164 at-bison-check-warnings > experr 22165 fi 22166 echo 'bison: warnings being treated as errors' >> experr 22167 22168 # Finish building expected stderr and check. Unlike warnings, 22169 # complaints cause bison to exit early. Thus, with -Werror, bison 22170 # does not necessarily report all warnings that it does without 22171 # -Werror, but it at least reports one. 22172 at_bison_check_last=`sed -n '$=' stderr` 22173 : ${at_bison_check_last:=1} 22174 at_bison_check_last=`expr $at_bison_check_last - 1` 22175 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 22176 at-bison-check-warnings >> experr 22177 { set +x 22178 $as_echo "$at_srcdir/reduce.at:145: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 22179 stderr 1>&2" 22180 at_fn_check_prepare_notrace 'an embedded newline' "reduce.at:145" 22181 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 22182 stderr 1>&2 22183 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22184 at_status=$? at_failed=false 22185 $at_check_filter 22186 $at_diff experr "$at_stderr" || at_failed=: 22187 at_fn_diff_devnull "$at_stdout" || at_failed=: 22188 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:145" 22189 $at_failed && at_fn_log_failure 22190 $at_traceon; } 22191 22192 22193 # Now check --warnings=error. 22194 cp stderr experr 22195 { set +x 22196 $as_echo "$at_srcdir/reduce.at:145: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y --warnings=error" 22197 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y --warnings=error" "reduce.at:145" 22198 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -fcaret input.y --warnings=error 22199 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22200 at_status=$? at_failed=false 22201 $at_check_filter 22202 $at_diff experr "$at_stderr" || at_failed=: 22203 $at_diff expout "$at_stdout" || at_failed=: 22204 at_fn_check_status 1 $at_status "$at_srcdir/reduce.at:145" 22205 $at_failed && at_fn_log_failure 22206 $at_traceon; } 22207 22208 22209 # Now check -Wnone and --warnings=none by making sure that 22210 # -Werror doesn't change the exit status when -Wnone or 22211 # --warnings=none is specified. 22212 { set +x 22213 $as_echo "$at_srcdir/reduce.at:145: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y -Wnone -Werror" 22214 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y -Wnone -Werror" "reduce.at:145" 22215 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -fcaret input.y -Wnone -Werror 22216 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22217 at_status=$? at_failed=false 22218 $at_check_filter 22219 at_fn_diff_devnull "$at_stderr" || at_failed=: 22220 $at_diff expout "$at_stdout" || at_failed=: 22221 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:145" 22222 $at_failed && at_fn_log_failure 22223 $at_traceon; } 22224 22225 { set +x 22226 $as_echo "$at_srcdir/reduce.at:145: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret input.y --warnings=none -Werror" 22227 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" "reduce.at:145" 22228 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -fcaret input.y --warnings=none -Werror 22229 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22230 at_status=$? at_failed=false 22231 $at_check_filter 22232 at_fn_diff_devnull "$at_stderr" || at_failed=: 22233 $at_diff expout "$at_stdout" || at_failed=: 22234 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:145" 22235 $at_failed && at_fn_log_failure 22236 $at_traceon; } 22237 22238 22239 at_restore_special_files 22240 fi 22241 22242 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 22243 at_save_special_files 22244 mkdir xml-tests 22245 # Don't combine these Bison invocations since we want to be sure that 22246 # --report=all isn't required to get the full XML file. 22247 { set +x 22248 $as_echo "$at_srcdir/reduce.at:204: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 22249 --graph=xml-tests/test.dot input.y" 22250 at_fn_check_prepare_notrace 'an embedded newline' "reduce.at:204" 22251 ( $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 \ 22252 --graph=xml-tests/test.dot input.y 22253 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22254 at_status=$? at_failed=false 22255 $at_check_filter 22256 echo stderr:; cat "$at_stderr" 22257 echo stdout:; cat "$at_stdout" 22258 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:204" 22259 $at_failed && at_fn_log_failure 22260 $at_traceon; } 22261 22262 { set +x 22263 $as_echo "$at_srcdir/reduce.at:204: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y" 22264 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" "reduce.at:204" 22265 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y 22266 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22267 at_status=$? at_failed=false 22268 $at_check_filter 22269 echo stderr:; cat "$at_stderr" 22270 echo stdout:; cat "$at_stdout" 22271 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:204" 22272 $at_failed && at_fn_log_failure 22273 $at_traceon; } 22274 22275 cp xml-tests/test.output expout 22276 { set +x 22277 $as_echo "$at_srcdir/reduce.at:204: \$XSLTPROC \\ 22278 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 22279 xml-tests/test.xml" 22280 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:204" 22281 ( $at_check_trace; $XSLTPROC \ 22282 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 22283 xml-tests/test.xml 22284 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22285 at_status=$? at_failed=false 22286 $at_check_filter 22287 at_fn_diff_devnull "$at_stderr" || at_failed=: 22288 $at_diff expout "$at_stdout" || at_failed=: 22289 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:204" 22290 $at_failed && at_fn_log_failure 22291 $at_traceon; } 22292 22293 sort xml-tests/test.dot > expout 22294 { set +x 22295 $as_echo "$at_srcdir/reduce.at:204: \$XSLTPROC \\ 22296 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 22297 xml-tests/test.xml | sort" 22298 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:204" 22299 ( $at_check_trace; $XSLTPROC \ 22300 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 22301 xml-tests/test.xml | sort 22302 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22303 at_status=$? at_failed=false 22304 $at_check_filter 22305 at_fn_diff_devnull "$at_stderr" || at_failed=: 22306 $at_diff expout "$at_stdout" || at_failed=: 22307 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:204" 22308 $at_failed && at_fn_log_failure 22309 $at_traceon; } 22310 22311 rm -rf xml-tests expout 22312 at_restore_special_files 22313 fi 22314 { set +x 22315 $as_echo "$at_srcdir/reduce.at:204: bison input.y" 22316 at_fn_check_prepare_trace "reduce.at:204" 22317 ( $at_check_trace; bison input.y 22318 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22319 at_status=$? at_failed=false 22320 $at_check_filter 22321 echo >>"$at_stderr"; $as_echo "input.y: warning: 9 nonterminals useless in grammar 22322 input.y: warning: 9 rules useless in grammar 22323 input.y:6.1-8: warning: nonterminal useless in grammar: useless1 22324 input.y:7.1-8: warning: nonterminal useless in grammar: useless2 22325 input.y:8.1-8: warning: nonterminal useless in grammar: useless3 22326 input.y:9.1-8: warning: nonterminal useless in grammar: useless4 22327 input.y:10.1-8: warning: nonterminal useless in grammar: useless5 22328 input.y:11.1-8: warning: nonterminal useless in grammar: useless6 22329 input.y:12.1-8: warning: nonterminal useless in grammar: useless7 22330 input.y:13.1-8: warning: nonterminal useless in grammar: useless8 22331 input.y:14.1-8: warning: nonterminal useless in grammar: useless9 22332 input.y:6.11-13: warning: rule useless in grammar: useless1: '1' 22333 input.y:7.11-13: warning: rule useless in grammar: useless2: '2' 22334 input.y:8.11-13: warning: rule useless in grammar: useless3: '3' 22335 input.y:9.11-13: warning: rule useless in grammar: useless4: '4' 22336 input.y:10.11-13: warning: rule useless in grammar: useless5: '5' 22337 input.y:11.11-13: warning: rule useless in grammar: useless6: '6' 22338 input.y:12.11-13: warning: rule useless in grammar: useless7: '7' 22339 input.y:13.11-13: warning: rule useless in grammar: useless8: '8' 22340 input.y:14.11-13: warning: rule useless in grammar: useless9: '9' 22341 " | \ 22342 $at_diff - "$at_stderr" || at_failed=: 22343 at_fn_diff_devnull "$at_stdout" || at_failed=: 22344 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:204" 22345 $at_failed && at_fn_log_failure 22346 $at_traceon; } 22347 22348 # Defining POSIXLY_CORRECT causes bison to complain if options are 22349 # added after the grammar file name, so skip these checks in that 22350 # case. 22351 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 22352 at_save_special_files 22353 22354 # To avoid expanding it repeatedly, store specified stdout. 22355 : >expout 22356 22357 # Run with -Werror. 22358 { set +x 22359 $as_echo "$at_srcdir/reduce.at:204: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Werror" 22360 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Werror" "reduce.at:204" 22361 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y -Werror 22362 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22363 at_status=$? at_failed=false 22364 $at_check_filter 22365 echo stderr:; tee stderr <"$at_stderr" 22366 $at_diff expout "$at_stdout" || at_failed=: 22367 at_fn_check_status 1 $at_status "$at_srcdir/reduce.at:204" 22368 $at_failed && at_fn_log_failure 22369 $at_traceon; } 22370 22371 22372 # Build expected stderr up to and including the "warnings being 22373 # treated as errors" message. 22374 cat >at-bison-check-warnings <<'_ATEOF' 22375 input.y: warning: 9 nonterminals useless in grammar 22376 input.y: warning: 9 rules useless in grammar 22377 input.y:6.1-8: warning: nonterminal useless in grammar: useless1 22378 input.y:7.1-8: warning: nonterminal useless in grammar: useless2 22379 input.y:8.1-8: warning: nonterminal useless in grammar: useless3 22380 input.y:9.1-8: warning: nonterminal useless in grammar: useless4 22381 input.y:10.1-8: warning: nonterminal useless in grammar: useless5 22382 input.y:11.1-8: warning: nonterminal useless in grammar: useless6 22383 input.y:12.1-8: warning: nonterminal useless in grammar: useless7 22384 input.y:13.1-8: warning: nonterminal useless in grammar: useless8 22385 input.y:14.1-8: warning: nonterminal useless in grammar: useless9 22386 input.y:6.11-13: warning: rule useless in grammar: useless1: '1' 22387 input.y:7.11-13: warning: rule useless in grammar: useless2: '2' 22388 input.y:8.11-13: warning: rule useless in grammar: useless3: '3' 22389 input.y:9.11-13: warning: rule useless in grammar: useless4: '4' 22390 input.y:10.11-13: warning: rule useless in grammar: useless5: '5' 22391 input.y:11.11-13: warning: rule useless in grammar: useless6: '6' 22392 input.y:12.11-13: warning: rule useless in grammar: useless7: '7' 22393 input.y:13.11-13: warning: rule useless in grammar: useless8: '8' 22394 input.y:14.11-13: warning: rule useless in grammar: useless9: '9' 22395 _ATEOF 22396 22397 at_bison_check_first=`sed -n \ 22398 '/: warning: /{=;q;}' at-bison-check-warnings` 22399 : ${at_bison_check_first:=1} 22400 at_bison_check_first_tmp=`sed -n \ 22401 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 22402 : ${at_bison_check_first_tmp:=1} 22403 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 22404 at_bison_check_first=$at_bison_check_first_tmp 22405 fi 22406 if test $at_bison_check_first -gt 1; then 22407 sed -n "1,`expr $at_bison_check_first - 1`"p \ 22408 at-bison-check-warnings > experr 22409 fi 22410 echo 'bison: warnings being treated as errors' >> experr 22411 22412 # Finish building expected stderr and check. Unlike warnings, 22413 # complaints cause bison to exit early. Thus, with -Werror, bison 22414 # does not necessarily report all warnings that it does without 22415 # -Werror, but it at least reports one. 22416 at_bison_check_last=`sed -n '$=' stderr` 22417 : ${at_bison_check_last:=1} 22418 at_bison_check_last=`expr $at_bison_check_last - 1` 22419 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 22420 at-bison-check-warnings >> experr 22421 { set +x 22422 $as_echo "$at_srcdir/reduce.at:204: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 22423 stderr 1>&2" 22424 at_fn_check_prepare_notrace 'an embedded newline' "reduce.at:204" 22425 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 22426 stderr 1>&2 22427 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22428 at_status=$? at_failed=false 22429 $at_check_filter 22430 $at_diff experr "$at_stderr" || at_failed=: 22431 at_fn_diff_devnull "$at_stdout" || at_failed=: 22432 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:204" 22433 $at_failed && at_fn_log_failure 22434 $at_traceon; } 22435 22436 22437 # Now check --warnings=error. 22438 cp stderr experr 22439 { set +x 22440 $as_echo "$at_srcdir/reduce.at:204: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=error" 22441 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=error" "reduce.at:204" 22442 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y --warnings=error 22443 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22444 at_status=$? at_failed=false 22445 $at_check_filter 22446 $at_diff experr "$at_stderr" || at_failed=: 22447 $at_diff expout "$at_stdout" || at_failed=: 22448 at_fn_check_status 1 $at_status "$at_srcdir/reduce.at:204" 22449 $at_failed && at_fn_log_failure 22450 $at_traceon; } 22451 22452 22453 # Now check -Wnone and --warnings=none by making sure that 22454 # -Werror doesn't change the exit status when -Wnone or 22455 # --warnings=none is specified. 22456 { set +x 22457 $as_echo "$at_srcdir/reduce.at:204: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Wnone -Werror" 22458 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Wnone -Werror" "reduce.at:204" 22459 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y -Wnone -Werror 22460 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22461 at_status=$? at_failed=false 22462 $at_check_filter 22463 at_fn_diff_devnull "$at_stderr" || at_failed=: 22464 $at_diff expout "$at_stdout" || at_failed=: 22465 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:204" 22466 $at_failed && at_fn_log_failure 22467 $at_traceon; } 22468 22469 { set +x 22470 $as_echo "$at_srcdir/reduce.at:204: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror" 22471 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror" "reduce.at:204" 22472 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror 22473 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22474 at_status=$? at_failed=false 22475 $at_check_filter 22476 at_fn_diff_devnull "$at_stderr" || at_failed=: 22477 $at_diff expout "$at_stdout" || at_failed=: 22478 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:204" 22479 $at_failed && at_fn_log_failure 22480 $at_traceon; } 22481 22482 22483 at_restore_special_files 22484 fi 22485 22486 { set +x 22487 $as_echo "$at_srcdir/reduce.at:227: sed -n '/^Grammar/q;/^\$/!p' input.output" 22488 at_fn_check_prepare_dynamic "sed -n '/^Grammar/q;/^$/!p' input.output" "reduce.at:227" 22489 ( $at_check_trace; sed -n '/^Grammar/q;/^$/!p' input.output 22490 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22491 at_status=$? at_failed=false 22492 $at_check_filter 22493 at_fn_diff_devnull "$at_stderr" || at_failed=: 22494 echo >>"$at_stdout"; $as_echo "Nonterminals useless in grammar 22495 useless1 22496 useless2 22497 useless3 22498 useless4 22499 useless5 22500 useless6 22501 useless7 22502 useless8 22503 useless9 22504 Terminals unused in grammar 22505 '1' 22506 '2' 22507 '3' 22508 '4' 22509 '5' 22510 '6' 22511 '7' 22512 '8' 22513 '9' 22514 Rules useless in grammar 22515 2 useless1: '1' 22516 3 useless2: '2' 22517 4 useless3: '3' 22518 5 useless4: '4' 22519 6 useless5: '5' 22520 7 useless6: '6' 22521 8 useless7: '7' 22522 9 useless8: '8' 22523 10 useless9: '9' 22524 " | \ 22525 $at_diff - "$at_stdout" || at_failed=: 22526 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:227" 22527 $at_failed && at_fn_log_failure 22528 $at_traceon; } 22529 22530 22531 set +x 22532 $at_times_p && times >"$at_times_file" 22533 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 22534 read at_status <"$at_status_file" 22535 #AT_STOP_104 22536 #AT_START_105 22537 at_fn_group_banner 105 'reduce.at:271' \ 22538 "Reduced Automaton" " " 6 22539 at_xfail=no 22540 ( 22541 $as_echo "105. $at_setup_line: testing $at_desc ..." 22542 $at_traceon 22543 22544 22545 22546 22547 # The non reduced grammar. 22548 # ------------------------ 22549 cat >not-reduced.y <<'_ATEOF' 22550 /* A useless token. */ 22551 %token useless_token 22552 /* A useful one. */ 22553 %token useful 22554 %verbose 22555 %output "not-reduced.c" 22556 22557 %% 22558 22559 exp: useful { /* A useful action. */ } 22560 | non_productive { /* A non productive action. */ } 22561 ; 22562 22563 not_reachable: useful { /* A not reachable action. */ } 22564 ; 22565 22566 non_productive: non_productive useless_token 22567 { /* Another non productive action. */ } 22568 ; 22569 %% 22570 _ATEOF 22571 22572 22573 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 22574 at_save_special_files 22575 mkdir xml-tests 22576 # Don't combine these Bison invocations since we want to be sure that 22577 # --report=all isn't required to get the full XML file. 22578 { set +x 22579 $as_echo "$at_srcdir/reduce.at:300: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 22580 --graph=xml-tests/test.dot -fcaret not-reduced.y" 22581 at_fn_check_prepare_notrace 'an embedded newline' "reduce.at:300" 22582 ( $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 \ 22583 --graph=xml-tests/test.dot -fcaret not-reduced.y 22584 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22585 at_status=$? at_failed=false 22586 $at_check_filter 22587 echo stderr:; cat "$at_stderr" 22588 echo stdout:; cat "$at_stdout" 22589 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:300" 22590 $at_failed && at_fn_log_failure 22591 $at_traceon; } 22592 22593 { set +x 22594 $as_echo "$at_srcdir/reduce.at:300: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -fcaret not-reduced.y" 22595 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 not-reduced.y" "reduce.at:300" 22596 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml -fcaret not-reduced.y 22597 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22598 at_status=$? at_failed=false 22599 $at_check_filter 22600 echo stderr:; cat "$at_stderr" 22601 echo stdout:; cat "$at_stdout" 22602 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:300" 22603 $at_failed && at_fn_log_failure 22604 $at_traceon; } 22605 22606 cp xml-tests/test.output expout 22607 { set +x 22608 $as_echo "$at_srcdir/reduce.at:300: \$XSLTPROC \\ 22609 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 22610 xml-tests/test.xml" 22611 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:300" 22612 ( $at_check_trace; $XSLTPROC \ 22613 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 22614 xml-tests/test.xml 22615 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22616 at_status=$? at_failed=false 22617 $at_check_filter 22618 at_fn_diff_devnull "$at_stderr" || at_failed=: 22619 $at_diff expout "$at_stdout" || at_failed=: 22620 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:300" 22621 $at_failed && at_fn_log_failure 22622 $at_traceon; } 22623 22624 sort xml-tests/test.dot > expout 22625 { set +x 22626 $as_echo "$at_srcdir/reduce.at:300: \$XSLTPROC \\ 22627 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 22628 xml-tests/test.xml | sort" 22629 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:300" 22630 ( $at_check_trace; $XSLTPROC \ 22631 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 22632 xml-tests/test.xml | sort 22633 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22634 at_status=$? at_failed=false 22635 $at_check_filter 22636 at_fn_diff_devnull "$at_stderr" || at_failed=: 22637 $at_diff expout "$at_stdout" || at_failed=: 22638 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:300" 22639 $at_failed && at_fn_log_failure 22640 $at_traceon; } 22641 22642 rm -rf xml-tests expout 22643 at_restore_special_files 22644 fi 22645 { set +x 22646 $as_echo "$at_srcdir/reduce.at:300: bison -fcaret not-reduced.y" 22647 at_fn_check_prepare_trace "reduce.at:300" 22648 ( $at_check_trace; bison -fcaret not-reduced.y 22649 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22650 at_status=$? at_failed=false 22651 $at_check_filter 22652 echo >>"$at_stderr"; $as_echo "not-reduced.y: warning: 2 nonterminals useless in grammar 22653 not-reduced.y: warning: 3 rules useless in grammar 22654 not-reduced.y:14.1-13: warning: nonterminal useless in grammar: not_reachable 22655 not_reachable: useful { /* A not reachable action. */ } 22656 ^^^^^^^^^^^^^ 22657 not-reduced.y:11.6-19: warning: nonterminal useless in grammar: non_productive 22658 | non_productive { /* A non productive action. */ } 22659 ^^^^^^^^^^^^^^ 22660 not-reduced.y:11.6-57: warning: rule useless in grammar 22661 | non_productive { /* A non productive action. */ } 22662 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 22663 not-reduced.y:14.16-56: warning: rule useless in grammar 22664 not_reachable: useful { /* A not reachable action. */ } 22665 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 22666 not-reduced.y:17.17-18.63: warning: rule useless in grammar 22667 non_productive: non_productive useless_token 22668 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 22669 " | \ 22670 $at_diff - "$at_stderr" || at_failed=: 22671 at_fn_diff_devnull "$at_stdout" || at_failed=: 22672 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:300" 22673 $at_failed && at_fn_log_failure 22674 $at_traceon; } 22675 22676 # Defining POSIXLY_CORRECT causes bison to complain if options are 22677 # added after the grammar file name, so skip these checks in that 22678 # case. 22679 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 22680 at_save_special_files 22681 22682 # To avoid expanding it repeatedly, store specified stdout. 22683 : >expout 22684 22685 # Run with -Werror. 22686 { set +x 22687 $as_echo "$at_srcdir/reduce.at:300: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret not-reduced.y -Werror" 22688 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret not-reduced.y -Werror" "reduce.at:300" 22689 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -fcaret not-reduced.y -Werror 22690 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22691 at_status=$? at_failed=false 22692 $at_check_filter 22693 echo stderr:; tee stderr <"$at_stderr" 22694 $at_diff expout "$at_stdout" || at_failed=: 22695 at_fn_check_status 1 $at_status "$at_srcdir/reduce.at:300" 22696 $at_failed && at_fn_log_failure 22697 $at_traceon; } 22698 22699 22700 # Build expected stderr up to and including the "warnings being 22701 # treated as errors" message. 22702 cat >at-bison-check-warnings <<'_ATEOF' 22703 not-reduced.y: warning: 2 nonterminals useless in grammar 22704 not-reduced.y: warning: 3 rules useless in grammar 22705 not-reduced.y:14.1-13: warning: nonterminal useless in grammar: not_reachable 22706 not_reachable: useful { /* A not reachable action. */ } 22707 ^^^^^^^^^^^^^ 22708 not-reduced.y:11.6-19: warning: nonterminal useless in grammar: non_productive 22709 | non_productive { /* A non productive action. */ } 22710 ^^^^^^^^^^^^^^ 22711 not-reduced.y:11.6-57: warning: rule useless in grammar 22712 | non_productive { /* A non productive action. */ } 22713 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 22714 not-reduced.y:14.16-56: warning: rule useless in grammar 22715 not_reachable: useful { /* A not reachable action. */ } 22716 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 22717 not-reduced.y:17.17-18.63: warning: rule useless in grammar 22718 non_productive: non_productive useless_token 22719 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 22720 _ATEOF 22721 22722 at_bison_check_first=`sed -n \ 22723 '/: warning: /{=;q;}' at-bison-check-warnings` 22724 : ${at_bison_check_first:=1} 22725 at_bison_check_first_tmp=`sed -n \ 22726 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 22727 : ${at_bison_check_first_tmp:=1} 22728 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 22729 at_bison_check_first=$at_bison_check_first_tmp 22730 fi 22731 if test $at_bison_check_first -gt 1; then 22732 sed -n "1,`expr $at_bison_check_first - 1`"p \ 22733 at-bison-check-warnings > experr 22734 fi 22735 echo 'bison: warnings being treated as errors' >> experr 22736 22737 # Finish building expected stderr and check. Unlike warnings, 22738 # complaints cause bison to exit early. Thus, with -Werror, bison 22739 # does not necessarily report all warnings that it does without 22740 # -Werror, but it at least reports one. 22741 at_bison_check_last=`sed -n '$=' stderr` 22742 : ${at_bison_check_last:=1} 22743 at_bison_check_last=`expr $at_bison_check_last - 1` 22744 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 22745 at-bison-check-warnings >> experr 22746 { set +x 22747 $as_echo "$at_srcdir/reduce.at:300: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 22748 stderr 1>&2" 22749 at_fn_check_prepare_notrace 'an embedded newline' "reduce.at:300" 22750 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 22751 stderr 1>&2 22752 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22753 at_status=$? at_failed=false 22754 $at_check_filter 22755 $at_diff experr "$at_stderr" || at_failed=: 22756 at_fn_diff_devnull "$at_stdout" || at_failed=: 22757 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:300" 22758 $at_failed && at_fn_log_failure 22759 $at_traceon; } 22760 22761 22762 # Now check --warnings=error. 22763 cp stderr experr 22764 { set +x 22765 $as_echo "$at_srcdir/reduce.at:300: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret not-reduced.y --warnings=error" 22766 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret not-reduced.y --warnings=error" "reduce.at:300" 22767 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -fcaret not-reduced.y --warnings=error 22768 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22769 at_status=$? at_failed=false 22770 $at_check_filter 22771 $at_diff experr "$at_stderr" || at_failed=: 22772 $at_diff expout "$at_stdout" || at_failed=: 22773 at_fn_check_status 1 $at_status "$at_srcdir/reduce.at:300" 22774 $at_failed && at_fn_log_failure 22775 $at_traceon; } 22776 22777 22778 # Now check -Wnone and --warnings=none by making sure that 22779 # -Werror doesn't change the exit status when -Wnone or 22780 # --warnings=none is specified. 22781 { set +x 22782 $as_echo "$at_srcdir/reduce.at:300: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret not-reduced.y -Wnone -Werror" 22783 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret not-reduced.y -Wnone -Werror" "reduce.at:300" 22784 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -fcaret not-reduced.y -Wnone -Werror 22785 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22786 at_status=$? at_failed=false 22787 $at_check_filter 22788 at_fn_diff_devnull "$at_stderr" || at_failed=: 22789 $at_diff expout "$at_stdout" || at_failed=: 22790 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:300" 22791 $at_failed && at_fn_log_failure 22792 $at_traceon; } 22793 22794 { set +x 22795 $as_echo "$at_srcdir/reduce.at:300: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret not-reduced.y --warnings=none -Werror" 22796 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison -fcaret not-reduced.y --warnings=none -Werror" "reduce.at:300" 22797 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison -fcaret not-reduced.y --warnings=none -Werror 22798 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22799 at_status=$? at_failed=false 22800 $at_check_filter 22801 at_fn_diff_devnull "$at_stderr" || at_failed=: 22802 $at_diff expout "$at_stdout" || at_failed=: 22803 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:300" 22804 $at_failed && at_fn_log_failure 22805 $at_traceon; } 22806 22807 22808 at_restore_special_files 22809 fi 22810 22811 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 22812 at_save_special_files 22813 mkdir xml-tests 22814 # Don't combine these Bison invocations since we want to be sure that 22815 # --report=all isn't required to get the full XML file. 22816 { set +x 22817 $as_echo "$at_srcdir/reduce.at:320: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 22818 --graph=xml-tests/test.dot not-reduced.y" 22819 at_fn_check_prepare_notrace 'an embedded newline' "reduce.at:320" 22820 ( $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 \ 22821 --graph=xml-tests/test.dot not-reduced.y 22822 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22823 at_status=$? at_failed=false 22824 $at_check_filter 22825 echo stderr:; cat "$at_stderr" 22826 echo stdout:; cat "$at_stdout" 22827 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:320" 22828 $at_failed && at_fn_log_failure 22829 $at_traceon; } 22830 22831 { set +x 22832 $as_echo "$at_srcdir/reduce.at:320: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml not-reduced.y" 22833 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml not-reduced.y" "reduce.at:320" 22834 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml not-reduced.y 22835 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22836 at_status=$? at_failed=false 22837 $at_check_filter 22838 echo stderr:; cat "$at_stderr" 22839 echo stdout:; cat "$at_stdout" 22840 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:320" 22841 $at_failed && at_fn_log_failure 22842 $at_traceon; } 22843 22844 cp xml-tests/test.output expout 22845 { set +x 22846 $as_echo "$at_srcdir/reduce.at:320: \$XSLTPROC \\ 22847 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 22848 xml-tests/test.xml" 22849 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:320" 22850 ( $at_check_trace; $XSLTPROC \ 22851 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 22852 xml-tests/test.xml 22853 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22854 at_status=$? at_failed=false 22855 $at_check_filter 22856 at_fn_diff_devnull "$at_stderr" || at_failed=: 22857 $at_diff expout "$at_stdout" || at_failed=: 22858 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:320" 22859 $at_failed && at_fn_log_failure 22860 $at_traceon; } 22861 22862 sort xml-tests/test.dot > expout 22863 { set +x 22864 $as_echo "$at_srcdir/reduce.at:320: \$XSLTPROC \\ 22865 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 22866 xml-tests/test.xml | sort" 22867 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:320" 22868 ( $at_check_trace; $XSLTPROC \ 22869 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 22870 xml-tests/test.xml | sort 22871 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22872 at_status=$? at_failed=false 22873 $at_check_filter 22874 at_fn_diff_devnull "$at_stderr" || at_failed=: 22875 $at_diff expout "$at_stdout" || at_failed=: 22876 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:320" 22877 $at_failed && at_fn_log_failure 22878 $at_traceon; } 22879 22880 rm -rf xml-tests expout 22881 at_restore_special_files 22882 fi 22883 { set +x 22884 $as_echo "$at_srcdir/reduce.at:320: bison not-reduced.y" 22885 at_fn_check_prepare_trace "reduce.at:320" 22886 ( $at_check_trace; bison not-reduced.y 22887 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22888 at_status=$? at_failed=false 22889 $at_check_filter 22890 echo >>"$at_stderr"; $as_echo "not-reduced.y: warning: 2 nonterminals useless in grammar 22891 not-reduced.y: warning: 3 rules useless in grammar 22892 not-reduced.y:14.1-13: warning: nonterminal useless in grammar: not_reachable 22893 not-reduced.y:11.6-19: warning: nonterminal useless in grammar: non_productive 22894 not-reduced.y:11.6-57: warning: rule useless in grammar: exp: non_productive 22895 not-reduced.y:14.16-56: warning: rule useless in grammar: not_reachable: useful 22896 not-reduced.y:17.17-18.63: warning: rule useless in grammar: non_productive: non_productive useless_token 22897 " | \ 22898 $at_diff - "$at_stderr" || at_failed=: 22899 at_fn_diff_devnull "$at_stdout" || at_failed=: 22900 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:320" 22901 $at_failed && at_fn_log_failure 22902 $at_traceon; } 22903 22904 # Defining POSIXLY_CORRECT causes bison to complain if options are 22905 # added after the grammar file name, so skip these checks in that 22906 # case. 22907 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 22908 at_save_special_files 22909 22910 # To avoid expanding it repeatedly, store specified stdout. 22911 : >expout 22912 22913 # Run with -Werror. 22914 { set +x 22915 $as_echo "$at_srcdir/reduce.at:320: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison not-reduced.y -Werror" 22916 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison not-reduced.y -Werror" "reduce.at:320" 22917 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison not-reduced.y -Werror 22918 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22919 at_status=$? at_failed=false 22920 $at_check_filter 22921 echo stderr:; tee stderr <"$at_stderr" 22922 $at_diff expout "$at_stdout" || at_failed=: 22923 at_fn_check_status 1 $at_status "$at_srcdir/reduce.at:320" 22924 $at_failed && at_fn_log_failure 22925 $at_traceon; } 22926 22927 22928 # Build expected stderr up to and including the "warnings being 22929 # treated as errors" message. 22930 cat >at-bison-check-warnings <<'_ATEOF' 22931 not-reduced.y: warning: 2 nonterminals useless in grammar 22932 not-reduced.y: warning: 3 rules useless in grammar 22933 not-reduced.y:14.1-13: warning: nonterminal useless in grammar: not_reachable 22934 not-reduced.y:11.6-19: warning: nonterminal useless in grammar: non_productive 22935 not-reduced.y:11.6-57: warning: rule useless in grammar: exp: non_productive 22936 not-reduced.y:14.16-56: warning: rule useless in grammar: not_reachable: useful 22937 not-reduced.y:17.17-18.63: warning: rule useless in grammar: non_productive: non_productive useless_token 22938 _ATEOF 22939 22940 at_bison_check_first=`sed -n \ 22941 '/: warning: /{=;q;}' at-bison-check-warnings` 22942 : ${at_bison_check_first:=1} 22943 at_bison_check_first_tmp=`sed -n \ 22944 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 22945 : ${at_bison_check_first_tmp:=1} 22946 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 22947 at_bison_check_first=$at_bison_check_first_tmp 22948 fi 22949 if test $at_bison_check_first -gt 1; then 22950 sed -n "1,`expr $at_bison_check_first - 1`"p \ 22951 at-bison-check-warnings > experr 22952 fi 22953 echo 'bison: warnings being treated as errors' >> experr 22954 22955 # Finish building expected stderr and check. Unlike warnings, 22956 # complaints cause bison to exit early. Thus, with -Werror, bison 22957 # does not necessarily report all warnings that it does without 22958 # -Werror, but it at least reports one. 22959 at_bison_check_last=`sed -n '$=' stderr` 22960 : ${at_bison_check_last:=1} 22961 at_bison_check_last=`expr $at_bison_check_last - 1` 22962 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 22963 at-bison-check-warnings >> experr 22964 { set +x 22965 $as_echo "$at_srcdir/reduce.at:320: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 22966 stderr 1>&2" 22967 at_fn_check_prepare_notrace 'an embedded newline' "reduce.at:320" 22968 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 22969 stderr 1>&2 22970 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22971 at_status=$? at_failed=false 22972 $at_check_filter 22973 $at_diff experr "$at_stderr" || at_failed=: 22974 at_fn_diff_devnull "$at_stdout" || at_failed=: 22975 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:320" 22976 $at_failed && at_fn_log_failure 22977 $at_traceon; } 22978 22979 22980 # Now check --warnings=error. 22981 cp stderr experr 22982 { set +x 22983 $as_echo "$at_srcdir/reduce.at:320: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison not-reduced.y --warnings=error" 22984 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison not-reduced.y --warnings=error" "reduce.at:320" 22985 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison not-reduced.y --warnings=error 22986 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 22987 at_status=$? at_failed=false 22988 $at_check_filter 22989 $at_diff experr "$at_stderr" || at_failed=: 22990 $at_diff expout "$at_stdout" || at_failed=: 22991 at_fn_check_status 1 $at_status "$at_srcdir/reduce.at:320" 22992 $at_failed && at_fn_log_failure 22993 $at_traceon; } 22994 22995 22996 # Now check -Wnone and --warnings=none by making sure that 22997 # -Werror doesn't change the exit status when -Wnone or 22998 # --warnings=none is specified. 22999 { set +x 23000 $as_echo "$at_srcdir/reduce.at:320: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison not-reduced.y -Wnone -Werror" 23001 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison not-reduced.y -Wnone -Werror" "reduce.at:320" 23002 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison not-reduced.y -Wnone -Werror 23003 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23004 at_status=$? at_failed=false 23005 $at_check_filter 23006 at_fn_diff_devnull "$at_stderr" || at_failed=: 23007 $at_diff expout "$at_stdout" || at_failed=: 23008 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:320" 23009 $at_failed && at_fn_log_failure 23010 $at_traceon; } 23011 23012 { set +x 23013 $as_echo "$at_srcdir/reduce.at:320: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison not-reduced.y --warnings=none -Werror" 23014 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison not-reduced.y --warnings=none -Werror" "reduce.at:320" 23015 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison not-reduced.y --warnings=none -Werror 23016 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23017 at_status=$? at_failed=false 23018 $at_check_filter 23019 at_fn_diff_devnull "$at_stderr" || at_failed=: 23020 $at_diff expout "$at_stdout" || at_failed=: 23021 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:320" 23022 $at_failed && at_fn_log_failure 23023 $at_traceon; } 23024 23025 23026 at_restore_special_files 23027 fi 23028 23029 { set +x 23030 $as_echo "$at_srcdir/reduce.at:330: sed -n '/^Grammar/q;/^\$/!p' not-reduced.output" 23031 at_fn_check_prepare_dynamic "sed -n '/^Grammar/q;/^$/!p' not-reduced.output" "reduce.at:330" 23032 ( $at_check_trace; sed -n '/^Grammar/q;/^$/!p' not-reduced.output 23033 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23034 at_status=$? at_failed=false 23035 $at_check_filter 23036 at_fn_diff_devnull "$at_stderr" || at_failed=: 23037 echo >>"$at_stdout"; $as_echo "Nonterminals useless in grammar 23038 not_reachable 23039 non_productive 23040 Terminals unused in grammar 23041 useless_token 23042 Rules useless in grammar 23043 2 exp: non_productive 23044 3 not_reachable: useful 23045 4 non_productive: non_productive useless_token 23046 " | \ 23047 $at_diff - "$at_stdout" || at_failed=: 23048 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:330" 23049 $at_failed && at_fn_log_failure 23050 $at_traceon; } 23051 23052 23053 # The reduced grammar. 23054 # -------------------- 23055 cat >reduced.y <<'_ATEOF' 23056 /* A useless token. */ 23057 %token useless_token 23058 /* A useful one. */ 23059 %token useful 23060 %verbose 23061 %output "reduced.c" 23062 23063 %% 23064 23065 exp: useful { /* A useful action. */ } 23066 // | non_productive { /* A non productive action. */ } */ 23067 ; 23068 23069 //not_reachable: useful { /* A not reachable action. */ } 23070 // ; 23071 23072 //non_productive: non_productive useless_token 23073 // { /* Another non productive action. */ } 23074 // ; 23075 %% 23076 _ATEOF 23077 23078 23079 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 23080 at_save_special_files 23081 mkdir xml-tests 23082 # Don't combine these Bison invocations since we want to be sure that 23083 # --report=all isn't required to get the full XML file. 23084 { set +x 23085 $as_echo "$at_srcdir/reduce.at:367: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 23086 --graph=xml-tests/test.dot reduced.y" 23087 at_fn_check_prepare_notrace 'an embedded newline' "reduce.at:367" 23088 ( $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 \ 23089 --graph=xml-tests/test.dot reduced.y 23090 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23091 at_status=$? at_failed=false 23092 $at_check_filter 23093 echo stderr:; cat "$at_stderr" 23094 echo stdout:; cat "$at_stdout" 23095 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:367" 23096 $at_failed && at_fn_log_failure 23097 $at_traceon; } 23098 23099 { set +x 23100 $as_echo "$at_srcdir/reduce.at:367: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml reduced.y" 23101 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml reduced.y" "reduce.at:367" 23102 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml reduced.y 23103 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23104 at_status=$? at_failed=false 23105 $at_check_filter 23106 echo stderr:; cat "$at_stderr" 23107 echo stdout:; cat "$at_stdout" 23108 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:367" 23109 $at_failed && at_fn_log_failure 23110 $at_traceon; } 23111 23112 cp xml-tests/test.output expout 23113 { set +x 23114 $as_echo "$at_srcdir/reduce.at:367: \$XSLTPROC \\ 23115 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 23116 xml-tests/test.xml" 23117 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:367" 23118 ( $at_check_trace; $XSLTPROC \ 23119 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 23120 xml-tests/test.xml 23121 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23122 at_status=$? at_failed=false 23123 $at_check_filter 23124 at_fn_diff_devnull "$at_stderr" || at_failed=: 23125 $at_diff expout "$at_stdout" || at_failed=: 23126 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:367" 23127 $at_failed && at_fn_log_failure 23128 $at_traceon; } 23129 23130 sort xml-tests/test.dot > expout 23131 { set +x 23132 $as_echo "$at_srcdir/reduce.at:367: \$XSLTPROC \\ 23133 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 23134 xml-tests/test.xml | sort" 23135 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:367" 23136 ( $at_check_trace; $XSLTPROC \ 23137 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 23138 xml-tests/test.xml | sort 23139 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23140 at_status=$? at_failed=false 23141 $at_check_filter 23142 at_fn_diff_devnull "$at_stderr" || at_failed=: 23143 $at_diff expout "$at_stdout" || at_failed=: 23144 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:367" 23145 $at_failed && at_fn_log_failure 23146 $at_traceon; } 23147 23148 rm -rf xml-tests expout 23149 at_restore_special_files 23150 fi 23151 { set +x 23152 $as_echo "$at_srcdir/reduce.at:367: bison reduced.y" 23153 at_fn_check_prepare_trace "reduce.at:367" 23154 ( $at_check_trace; bison reduced.y 23155 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23156 at_status=$? at_failed=false 23157 $at_check_filter 23158 at_fn_diff_devnull "$at_stderr" || at_failed=: 23159 at_fn_diff_devnull "$at_stdout" || at_failed=: 23160 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:367" 23161 $at_failed && at_fn_log_failure 23162 $at_traceon; } 23163 23164 23165 23166 # Comparing the parsers. 23167 cp reduced.c expout 23168 { set +x 23169 $as_echo "$at_srcdir/reduce.at:371: sed 's/not-reduced/reduced/g' not-reduced.c" 23170 at_fn_check_prepare_trace "reduce.at:371" 23171 ( $at_check_trace; sed 's/not-reduced/reduced/g' not-reduced.c 23172 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23173 at_status=$? at_failed=false 23174 $at_check_filter 23175 at_fn_diff_devnull "$at_stderr" || at_failed=: 23176 $at_diff expout "$at_stdout" || at_failed=: 23177 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:371" 23178 $at_failed && at_fn_log_failure 23179 $at_traceon; } 23180 23181 23182 set +x 23183 $at_times_p && times >"$at_times_file" 23184 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 23185 read at_status <"$at_status_file" 23186 #AT_STOP_105 23187 #AT_START_106 23188 at_fn_group_banner 106 'reduce.at:381' \ 23189 "Underivable Rules" " " 6 23190 at_xfail=no 23191 ( 23192 $as_echo "106. $at_setup_line: testing $at_desc ..." 23193 $at_traceon 23194 23195 23196 23197 23198 cat >input.y <<'_ATEOF' 23199 %verbose 23200 %output "input.c" 23201 %token useful 23202 %% 23203 exp: useful | underivable; 23204 underivable: indirection; 23205 indirection: underivable; 23206 _ATEOF 23207 23208 23209 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 23210 at_save_special_files 23211 mkdir xml-tests 23212 # Don't combine these Bison invocations since we want to be sure that 23213 # --report=all isn't required to get the full XML file. 23214 { set +x 23215 $as_echo "$at_srcdir/reduce.at:395: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 23216 --graph=xml-tests/test.dot input.y" 23217 at_fn_check_prepare_notrace 'an embedded newline' "reduce.at:395" 23218 ( $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 \ 23219 --graph=xml-tests/test.dot input.y 23220 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23221 at_status=$? at_failed=false 23222 $at_check_filter 23223 echo stderr:; cat "$at_stderr" 23224 echo stdout:; cat "$at_stdout" 23225 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:395" 23226 $at_failed && at_fn_log_failure 23227 $at_traceon; } 23228 23229 { set +x 23230 $as_echo "$at_srcdir/reduce.at:395: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y" 23231 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" "reduce.at:395" 23232 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml input.y 23233 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23234 at_status=$? at_failed=false 23235 $at_check_filter 23236 echo stderr:; cat "$at_stderr" 23237 echo stdout:; cat "$at_stdout" 23238 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:395" 23239 $at_failed && at_fn_log_failure 23240 $at_traceon; } 23241 23242 cp xml-tests/test.output expout 23243 { set +x 23244 $as_echo "$at_srcdir/reduce.at:395: \$XSLTPROC \\ 23245 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 23246 xml-tests/test.xml" 23247 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:395" 23248 ( $at_check_trace; $XSLTPROC \ 23249 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 23250 xml-tests/test.xml 23251 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23252 at_status=$? at_failed=false 23253 $at_check_filter 23254 at_fn_diff_devnull "$at_stderr" || at_failed=: 23255 $at_diff expout "$at_stdout" || at_failed=: 23256 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:395" 23257 $at_failed && at_fn_log_failure 23258 $at_traceon; } 23259 23260 sort xml-tests/test.dot > expout 23261 { set +x 23262 $as_echo "$at_srcdir/reduce.at:395: \$XSLTPROC \\ 23263 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 23264 xml-tests/test.xml | sort" 23265 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:395" 23266 ( $at_check_trace; $XSLTPROC \ 23267 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 23268 xml-tests/test.xml | sort 23269 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23270 at_status=$? at_failed=false 23271 $at_check_filter 23272 at_fn_diff_devnull "$at_stderr" || at_failed=: 23273 $at_diff expout "$at_stdout" || at_failed=: 23274 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:395" 23275 $at_failed && at_fn_log_failure 23276 $at_traceon; } 23277 23278 rm -rf xml-tests expout 23279 at_restore_special_files 23280 fi 23281 { set +x 23282 $as_echo "$at_srcdir/reduce.at:395: bison input.y" 23283 at_fn_check_prepare_trace "reduce.at:395" 23284 ( $at_check_trace; bison input.y 23285 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23286 at_status=$? at_failed=false 23287 $at_check_filter 23288 echo >>"$at_stderr"; $as_echo "input.y: warning: 2 nonterminals useless in grammar 23289 input.y: warning: 3 rules useless in grammar 23290 input.y:5.15-25: warning: nonterminal useless in grammar: underivable 23291 input.y:6.14-24: warning: nonterminal useless in grammar: indirection 23292 input.y:5.15-25: warning: rule useless in grammar: exp: underivable 23293 input.y:6.14-24: warning: rule useless in grammar: underivable: indirection 23294 input.y:7.14-24: warning: rule useless in grammar: indirection: underivable 23295 " | \ 23296 $at_diff - "$at_stderr" || at_failed=: 23297 at_fn_diff_devnull "$at_stdout" || at_failed=: 23298 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:395" 23299 $at_failed && at_fn_log_failure 23300 $at_traceon; } 23301 23302 # Defining POSIXLY_CORRECT causes bison to complain if options are 23303 # added after the grammar file name, so skip these checks in that 23304 # case. 23305 if test "$POSIXLY_CORRECT_IS_EXPORTED" = false; then 23306 at_save_special_files 23307 23308 # To avoid expanding it repeatedly, store specified stdout. 23309 : >expout 23310 23311 # Run with -Werror. 23312 { set +x 23313 $as_echo "$at_srcdir/reduce.at:395: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Werror" 23314 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Werror" "reduce.at:395" 23315 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y -Werror 23316 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23317 at_status=$? at_failed=false 23318 $at_check_filter 23319 echo stderr:; tee stderr <"$at_stderr" 23320 $at_diff expout "$at_stdout" || at_failed=: 23321 at_fn_check_status 1 $at_status "$at_srcdir/reduce.at:395" 23322 $at_failed && at_fn_log_failure 23323 $at_traceon; } 23324 23325 23326 # Build expected stderr up to and including the "warnings being 23327 # treated as errors" message. 23328 cat >at-bison-check-warnings <<'_ATEOF' 23329 input.y: warning: 2 nonterminals useless in grammar 23330 input.y: warning: 3 rules useless in grammar 23331 input.y:5.15-25: warning: nonterminal useless in grammar: underivable 23332 input.y:6.14-24: warning: nonterminal useless in grammar: indirection 23333 input.y:5.15-25: warning: rule useless in grammar: exp: underivable 23334 input.y:6.14-24: warning: rule useless in grammar: underivable: indirection 23335 input.y:7.14-24: warning: rule useless in grammar: indirection: underivable 23336 _ATEOF 23337 23338 at_bison_check_first=`sed -n \ 23339 '/: warning: /{=;q;}' at-bison-check-warnings` 23340 : ${at_bison_check_first:=1} 23341 at_bison_check_first_tmp=`sed -n \ 23342 '/conflicts: [0-9].*reduce$/{=;q;}' at-bison-check-warnings` 23343 : ${at_bison_check_first_tmp:=1} 23344 if test $at_bison_check_first_tmp -lt $at_bison_check_first; then 23345 at_bison_check_first=$at_bison_check_first_tmp 23346 fi 23347 if test $at_bison_check_first -gt 1; then 23348 sed -n "1,`expr $at_bison_check_first - 1`"p \ 23349 at-bison-check-warnings > experr 23350 fi 23351 echo 'bison: warnings being treated as errors' >> experr 23352 23353 # Finish building expected stderr and check. Unlike warnings, 23354 # complaints cause bison to exit early. Thus, with -Werror, bison 23355 # does not necessarily report all warnings that it does without 23356 # -Werror, but it at least reports one. 23357 at_bison_check_last=`sed -n '$=' stderr` 23358 : ${at_bison_check_last:=1} 23359 at_bison_check_last=`expr $at_bison_check_last - 1` 23360 sed -n "$at_bison_check_first,$at_bison_check_last"p \ 23361 at-bison-check-warnings >> experr 23362 { set +x 23363 $as_echo "$at_srcdir/reduce.at:395: sed 's,.*/\\(bison: warnings being treated as errors\\)\$,\\1,' \\ 23364 stderr 1>&2" 23365 at_fn_check_prepare_notrace 'an embedded newline' "reduce.at:395" 23366 ( $at_check_trace; sed 's,.*/\(bison: warnings being treated as errors\)$,\1,' \ 23367 stderr 1>&2 23368 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23369 at_status=$? at_failed=false 23370 $at_check_filter 23371 $at_diff experr "$at_stderr" || at_failed=: 23372 at_fn_diff_devnull "$at_stdout" || at_failed=: 23373 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:395" 23374 $at_failed && at_fn_log_failure 23375 $at_traceon; } 23376 23377 23378 # Now check --warnings=error. 23379 cp stderr experr 23380 { set +x 23381 $as_echo "$at_srcdir/reduce.at:395: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=error" 23382 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=error" "reduce.at:395" 23383 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y --warnings=error 23384 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23385 at_status=$? at_failed=false 23386 $at_check_filter 23387 $at_diff experr "$at_stderr" || at_failed=: 23388 $at_diff expout "$at_stdout" || at_failed=: 23389 at_fn_check_status 1 $at_status "$at_srcdir/reduce.at:395" 23390 $at_failed && at_fn_log_failure 23391 $at_traceon; } 23392 23393 23394 # Now check -Wnone and --warnings=none by making sure that 23395 # -Werror doesn't change the exit status when -Wnone or 23396 # --warnings=none is specified. 23397 { set +x 23398 $as_echo "$at_srcdir/reduce.at:395: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Wnone -Werror" 23399 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y -Wnone -Werror" "reduce.at:395" 23400 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y -Wnone -Werror 23401 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23402 at_status=$? at_failed=false 23403 $at_check_filter 23404 at_fn_diff_devnull "$at_stderr" || at_failed=: 23405 $at_diff expout "$at_stdout" || at_failed=: 23406 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:395" 23407 $at_failed && at_fn_log_failure 23408 $at_traceon; } 23409 23410 { set +x 23411 $as_echo "$at_srcdir/reduce.at:395: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror" 23412 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror" "reduce.at:395" 23413 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y --warnings=none -Werror 23414 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23415 at_status=$? at_failed=false 23416 $at_check_filter 23417 at_fn_diff_devnull "$at_stderr" || at_failed=: 23418 $at_diff expout "$at_stdout" || at_failed=: 23419 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:395" 23420 $at_failed && at_fn_log_failure 23421 $at_traceon; } 23422 23423 23424 at_restore_special_files 23425 fi 23426 23427 { set +x 23428 $as_echo "$at_srcdir/reduce.at:405: sed -n '/^Grammar/q;/^\$/!p' input.output" 23429 at_fn_check_prepare_dynamic "sed -n '/^Grammar/q;/^$/!p' input.output" "reduce.at:405" 23430 ( $at_check_trace; sed -n '/^Grammar/q;/^$/!p' input.output 23431 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23432 at_status=$? at_failed=false 23433 $at_check_filter 23434 at_fn_diff_devnull "$at_stderr" || at_failed=: 23435 echo >>"$at_stdout"; $as_echo "Nonterminals useless in grammar 23436 underivable 23437 indirection 23438 Rules useless in grammar 23439 2 exp: underivable 23440 3 underivable: indirection 23441 4 indirection: underivable 23442 " | \ 23443 $at_diff - "$at_stdout" || at_failed=: 23444 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:405" 23445 $at_failed && at_fn_log_failure 23446 $at_traceon; } 23447 23448 23449 set +x 23450 $at_times_p && times >"$at_times_file" 23451 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 23452 read at_status <"$at_status_file" 23453 #AT_STOP_106 23454 #AT_START_107 23455 at_fn_group_banner 107 'reduce.at:423' \ 23456 "Empty Language" " " 6 23457 at_xfail=no 23458 ( 23459 $as_echo "107. $at_setup_line: testing $at_desc ..." 23460 $at_traceon 23461 23462 23463 cat >input.y <<'_ATEOF' 23464 %output "input.c" 23465 %% 23466 exp: exp; 23467 _ATEOF 23468 23469 23470 23471 { set +x 23472 $as_echo "$at_srcdir/reduce.at:431: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" 23473 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison input.y" "reduce.at:431" 23474 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison input.y 23475 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23476 at_status=$? at_failed=false 23477 $at_check_filter 23478 echo >>"$at_stderr"; $as_echo "input.y: warning: 2 nonterminals useless in grammar 23479 input.y: warning: 2 rules useless in grammar 23480 input.y:3.1-3: fatal error: start symbol exp does not derive any sentence 23481 " | \ 23482 $at_diff - "$at_stderr" || at_failed=: 23483 at_fn_diff_devnull "$at_stdout" || at_failed=: 23484 at_fn_check_status 1 $at_status "$at_srcdir/reduce.at:431" 23485 $at_failed && at_fn_log_failure 23486 $at_traceon; } 23487 23488 23489 23490 set +x 23491 $at_times_p && times >"$at_times_file" 23492 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 23493 read at_status <"$at_status_file" 23494 #AT_STOP_107 23495 #AT_START_108 23496 at_fn_group_banner 108 'reduce.at:474' \ 23497 "no %define lr.type: Single State Split" " " 6 23498 at_xfail=no 23499 ( 23500 $as_echo "108. $at_setup_line: testing $at_desc ..." 23501 $at_traceon 23502 23503 23504 cat >input.y <<'_ATEOF' 23505 %code top { 23506 #include <config.h> 23507 /* We don't need perfect functions for these tests. */ 23508 #undef malloc 23509 #undef memcmp 23510 #undef realloc 23511 } 23512 23513 %code { 23514 #include <stdio.h> 23515 static void yyerror ( const char *msg); 23516 static int yylex (void); 23517 } 23518 23519 %left 'a' 23520 // Conflict resolution renders state 12 unreachable for canonical LR(1). We 23521 // keep it so that the paser table diff is easier to code. 23522 %define lr.keep-unreachable-states 23523 23524 %% 23525 23526 23527 S: 'a' A 'a' /* rule 1 */ 23528 | 'b' A 'b' /* rule 2 */ 23529 | 'c' c /* rule 3 */ 23530 ; 23531 23532 /* A conflict should appear after the first 'a' in rules 4 and 5 but only after 23533 having shifted the first 'a' in rule 1. However, when LALR(1) merging is 23534 chosen, the state containing that conflict is reused after having seen the 23535 first 'b' in rule 2 and then the first 'a' in rules 4 and 5. In both cases, 23536 because of the merged state, if the next token is an 'a', the %left forces a 23537 reduction action with rule 5. In the latter case, only a shift is actually 23538 grammatically correct. Thus, the parser would report a syntax error for the 23539 grammatically correct sentence "baab" because it would encounter a syntax 23540 error after that incorrect reduction. 23541 23542 Despite not being LALR(1), Menhir version 20070322 suffers from this problem 23543 as well. It uses David Pager's weak compatibility test for merging states. 23544 Bison and Menhir accept non-LR(1) grammars with conflict resolution. Pager 23545 designed his algorithm only for LR(1) grammars. */ 23546 A: 'a' 'a' /* rule 4 */ 23547 | 'a' /* rule 5 */ 23548 ; 23549 23550 /* Rule 3, rule 6, and rule 7 ensure that Bison does not report rule 4 as 23551 useless after conflict resolution. This proves that, even though LALR(1) 23552 generates incorrect parser tables sometimes, Bison will not necessarily 23553 produce any warning to help the user realize it. */ 23554 c: 'a' 'b' /* rule 6 */ 23555 | A /* rule 7 */ 23556 ; 23557 23558 23559 %% 23560 #include <stdio.h> 23561 /* A C error reporting function. */ 23562 static 23563 void yyerror ( const char *msg) 23564 { 23565 fprintf (stderr, "%s\n", msg); 23566 } 23567 static int 23568 yylex (void) 23569 { 23570 static int const input[] = { 23571 'b', 'a', 'a', 'b', 0 23572 }; 23573 static int const *inputp = input; 23574 return *inputp++; 23575 } 23576 23577 int 23578 main (void) 23579 { 23580 return yyparse (); 23581 } 23582 _ATEOF 23583 23584 23585 23586 # In some versions of Autoconf, AT_CHECK invokes AS_ESCAPE before 23587 # expanding macros, so it corrupts some special characters in the 23588 # macros. To avoid this, expand now and pass it the result with proper 23589 # string quotation. Assume args 7 through 12 expand to properly quoted 23590 # strings. 23591 23592 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 23593 at_save_special_files 23594 mkdir xml-tests 23595 # Don't combine these Bison invocations since we want to be sure that 23596 # --report=all isn't required to get the full XML file. 23597 { set +x 23598 $as_echo "$at_srcdir/reduce.at:474: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 23599 --graph=xml-tests/test.dot --report=all --defines -o input.c input.y" 23600 at_fn_check_prepare_notrace 'an embedded newline' "reduce.at:474" 23601 ( $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 \ 23602 --graph=xml-tests/test.dot --report=all --defines -o input.c input.y 23603 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23604 at_status=$? at_failed=false 23605 $at_check_filter 23606 echo stderr:; cat "$at_stderr" 23607 echo stdout:; cat "$at_stdout" 23608 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 23609 $at_failed && at_fn_log_failure 23610 $at_traceon; } 23611 23612 { set +x 23613 $as_echo "$at_srcdir/reduce.at:474: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --report=all --defines -o input.c input.y" 23614 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --report=all --defines -o input.c input.y" "reduce.at:474" 23615 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --report=all --defines -o input.c input.y 23616 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23617 at_status=$? at_failed=false 23618 $at_check_filter 23619 echo stderr:; cat "$at_stderr" 23620 echo stdout:; cat "$at_stdout" 23621 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 23622 $at_failed && at_fn_log_failure 23623 $at_traceon; } 23624 23625 cp xml-tests/test.output expout 23626 { set +x 23627 $as_echo "$at_srcdir/reduce.at:474: \$XSLTPROC \\ 23628 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 23629 xml-tests/test.xml" 23630 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:474" 23631 ( $at_check_trace; $XSLTPROC \ 23632 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 23633 xml-tests/test.xml 23634 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23635 at_status=$? at_failed=false 23636 $at_check_filter 23637 at_fn_diff_devnull "$at_stderr" || at_failed=: 23638 $at_diff expout "$at_stdout" || at_failed=: 23639 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 23640 $at_failed && at_fn_log_failure 23641 $at_traceon; } 23642 23643 sort xml-tests/test.dot > expout 23644 { set +x 23645 $as_echo "$at_srcdir/reduce.at:474: \$XSLTPROC \\ 23646 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 23647 xml-tests/test.xml | sort" 23648 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:474" 23649 ( $at_check_trace; $XSLTPROC \ 23650 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 23651 xml-tests/test.xml | sort 23652 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23653 at_status=$? at_failed=false 23654 $at_check_filter 23655 at_fn_diff_devnull "$at_stderr" || at_failed=: 23656 $at_diff expout "$at_stdout" || at_failed=: 23657 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 23658 $at_failed && at_fn_log_failure 23659 $at_traceon; } 23660 23661 rm -rf xml-tests expout 23662 at_restore_special_files 23663 fi 23664 { set +x 23665 $as_echo "$at_srcdir/reduce.at:474: bison --report=all --defines -o input.c input.y" 23666 at_fn_check_prepare_trace "reduce.at:474" 23667 ( $at_check_trace; bison --report=all --defines -o input.c input.y 23668 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23669 at_status=$? at_failed=false 23670 $at_check_filter 23671 at_fn_diff_devnull "$at_stderr" || at_failed=: 23672 at_fn_diff_devnull "$at_stdout" || at_failed=: 23673 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 23674 $at_failed && at_fn_log_failure 23675 $at_traceon; } 23676 23677 23678 23679 { set +x 23680 $as_echo "$at_srcdir/reduce.at:474: sed -n '/^State 0\$/,\$p' input.output" 23681 at_fn_check_prepare_dynamic "sed -n '/^State 0$/,$p' input.output" "reduce.at:474" 23682 ( $at_check_trace; sed -n '/^State 0$/,$p' input.output 23683 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23684 at_status=$? at_failed=false 23685 $at_check_filter 23686 at_fn_diff_devnull "$at_stderr" || at_failed=: 23687 echo >>"$at_stdout"; $as_echo "State 0 23688 23689 0 \$accept: . S \$end 23690 1 S: . 'a' A 'a' 23691 2 | . 'b' A 'b' 23692 3 | . 'c' c 23693 23694 'a' shift, and go to state 1 23695 'b' shift, and go to state 2 23696 'c' shift, and go to state 3 23697 23698 S go to state 4 23699 23700 23701 State 1 23702 23703 1 S: 'a' . A 'a' 23704 4 A: . 'a' 'a' 23705 5 | . 'a' 23706 23707 'a' shift, and go to state 5 23708 23709 A go to state 6 23710 23711 23712 State 2 23713 23714 2 S: 'b' . A 'b' 23715 4 A: . 'a' 'a' 23716 5 | . 'a' 23717 23718 'a' shift, and go to state 5 23719 23720 A go to state 7 23721 23722 23723 State 3 23724 23725 3 S: 'c' . c 23726 4 A: . 'a' 'a' 23727 5 | . 'a' 23728 6 c: . 'a' 'b' 23729 7 | . A 23730 23731 'a' shift, and go to state 8 23732 23733 A go to state 9 23734 c go to state 10 23735 23736 23737 State 4 23738 23739 0 \$accept: S . \$end 23740 23741 \$end shift, and go to state 11 23742 23743 23744 State 5 23745 23746 4 A: 'a' . 'a' 23747 5 | 'a' . ['a', 'b'] 23748 23749 \$default reduce using rule 5 (A) 23750 23751 Conflict between rule 5 and token 'a' resolved as reduce (%left 'a'). 23752 23753 23754 State 6 23755 23756 1 S: 'a' A . 'a' 23757 23758 'a' shift, and go to state 13 23759 23760 23761 State 7 23762 23763 2 S: 'b' A . 'b' 23764 23765 'b' shift, and go to state 14 23766 23767 23768 State 8 23769 23770 4 A: 'a' . 'a' 23771 5 | 'a' . [\$end] 23772 6 c: 'a' . 'b' 23773 23774 'a' shift, and go to state 12 23775 'b' shift, and go to state 15 23776 23777 \$default reduce using rule 5 (A) 23778 23779 23780 State 9 23781 23782 7 c: A . 23783 23784 \$default reduce using rule 7 (c) 23785 23786 23787 State 10 23788 23789 3 S: 'c' c . 23790 23791 \$default reduce using rule 3 (S) 23792 23793 23794 State 11 23795 23796 0 \$accept: S \$end . 23797 23798 \$default accept 23799 23800 23801 State 12 23802 23803 4 A: 'a' 'a' . 23804 23805 \$default reduce using rule 4 (A) 23806 23807 23808 State 13 23809 23810 1 S: 'a' A 'a' . 23811 23812 \$default reduce using rule 1 (S) 23813 23814 23815 State 14 23816 23817 2 S: 'b' A 'b' . 23818 23819 \$default reduce using rule 2 (S) 23820 23821 23822 State 15 23823 23824 6 c: 'a' 'b' . 23825 23826 \$default reduce using rule 6 (c) 23827 " | \ 23828 $at_diff - "$at_stdout" || at_failed=: 23829 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 23830 $at_failed && at_fn_log_failure 23831 $at_traceon; } 23832 23833 23834 23835 23836 # Canonical LR generates very large tables, resulting in very long 23837 # files with #line directives that may overflow what the standards 23838 # (C90 and C++98) guarantee: 32767. In that case, GCC's -pedantic 23839 # will issue an error. 23840 # 23841 # There is no "" around `wc` since some indent the result. 23842 23843 { set +x 23844 $as_echo "$at_srcdir/reduce.at:474: \$BISON_C_WORKS" 23845 at_fn_check_prepare_dynamic "$BISON_C_WORKS" "reduce.at:474" 23846 ( $at_check_trace; $BISON_C_WORKS 23847 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23848 at_status=$? at_failed=false 23849 $at_check_filter 23850 echo stderr:; cat "$at_stderr" 23851 echo stdout:; cat "$at_stdout" 23852 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 23853 $at_failed && at_fn_log_failure 23854 $at_traceon; } 23855 23856 { set +x 23857 $as_echo "$at_srcdir/reduce.at:474: \$CC \$CFLAGS \$CPPFLAGS \$LDFLAGS -o input input.c \$LIBS" 23858 at_fn_check_prepare_dynamic "$CC $CFLAGS $CPPFLAGS $LDFLAGS -o input input.c $LIBS" "reduce.at:474" 23859 ( $at_check_trace; $CC $CFLAGS $CPPFLAGS $LDFLAGS -o input input.c $LIBS 23860 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23861 at_status=$? at_failed=false 23862 $at_check_filter 23863 echo stderr:; cat "$at_stderr" 23864 echo stdout:; cat "$at_stdout" 23865 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 23866 $at_failed && at_fn_log_failure 23867 $at_traceon; } 23868 23869 23870 { set +x 23871 $as_echo "$at_srcdir/reduce.at:474: \$PREPARSER ./input" 23872 at_fn_check_prepare_dynamic " $PREPARSER ./input" "reduce.at:474" 23873 ( $at_check_trace; $PREPARSER ./input 23874 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23875 at_status=$? at_failed=false 23876 $at_check_filter 23877 echo stderr:; tee stderr <"$at_stderr" 23878 at_fn_diff_devnull "$at_stdout" || at_failed=: 23879 at_fn_check_status 1 $at_status "$at_srcdir/reduce.at:474" 23880 $at_failed && at_fn_log_failure 23881 $at_traceon; } 23882 23883 { set +x 23884 $as_echo "$at_srcdir/reduce.at:474: sed >&2 -e '/^profiling:.*:Merge mismatch for summaries/d' stderr" 23885 at_fn_check_prepare_trace "reduce.at:474" 23886 ( $at_check_trace; sed >&2 -e '/^profiling:.*:Merge mismatch for summaries/d' stderr 23887 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 23888 at_status=$? at_failed=false 23889 $at_check_filter 23890 echo >>"$at_stderr"; $as_echo "syntax error 23891 " | \ 23892 $at_diff - "$at_stderr" || at_failed=: 23893 at_fn_diff_devnull "$at_stdout" || at_failed=: 23894 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 23895 $at_failed && at_fn_log_failure 23896 $at_traceon; } 23897 23898 23899 23900 23901 set +x 23902 $at_times_p && times >"$at_times_file" 23903 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 23904 read at_status <"$at_status_file" 23905 #AT_STOP_108 23906 #AT_START_109 23907 at_fn_group_banner 109 'reduce.at:474' \ 23908 "%define lr.type lalr: Single State Split" " " 6 23909 at_xfail=no 23910 ( 23911 $as_echo "109. $at_setup_line: testing $at_desc ..." 23912 $at_traceon 23913 23914 23915 cat >input.y <<'_ATEOF' 23916 %code top { 23917 #include <config.h> 23918 /* We don't need perfect functions for these tests. */ 23919 #undef malloc 23920 #undef memcmp 23921 #undef realloc 23922 } 23923 23924 %code { 23925 #include <stdio.h> 23926 static void yyerror ( const char *msg); 23927 static int yylex (void); 23928 } 23929 23930 %define lr.type lalr 23931 %left 'a' 23932 // Conflict resolution renders state 12 unreachable for canonical LR(1). We 23933 // keep it so that the paser table diff is easier to code. 23934 %define lr.keep-unreachable-states 23935 23936 %% 23937 23938 23939 S: 'a' A 'a' /* rule 1 */ 23940 | 'b' A 'b' /* rule 2 */ 23941 | 'c' c /* rule 3 */ 23942 ; 23943 23944 /* A conflict should appear after the first 'a' in rules 4 and 5 but only after 23945 having shifted the first 'a' in rule 1. However, when LALR(1) merging is 23946 chosen, the state containing that conflict is reused after having seen the 23947 first 'b' in rule 2 and then the first 'a' in rules 4 and 5. In both cases, 23948 because of the merged state, if the next token is an 'a', the %left forces a 23949 reduction action with rule 5. In the latter case, only a shift is actually 23950 grammatically correct. Thus, the parser would report a syntax error for the 23951 grammatically correct sentence "baab" because it would encounter a syntax 23952 error after that incorrect reduction. 23953 23954 Despite not being LALR(1), Menhir version 20070322 suffers from this problem 23955 as well. It uses David Pager's weak compatibility test for merging states. 23956 Bison and Menhir accept non-LR(1) grammars with conflict resolution. Pager 23957 designed his algorithm only for LR(1) grammars. */ 23958 A: 'a' 'a' /* rule 4 */ 23959 | 'a' /* rule 5 */ 23960 ; 23961 23962 /* Rule 3, rule 6, and rule 7 ensure that Bison does not report rule 4 as 23963 useless after conflict resolution. This proves that, even though LALR(1) 23964 generates incorrect parser tables sometimes, Bison will not necessarily 23965 produce any warning to help the user realize it. */ 23966 c: 'a' 'b' /* rule 6 */ 23967 | A /* rule 7 */ 23968 ; 23969 23970 23971 %% 23972 #include <stdio.h> 23973 /* A C error reporting function. */ 23974 static 23975 void yyerror ( const char *msg) 23976 { 23977 fprintf (stderr, "%s\n", msg); 23978 } 23979 static int 23980 yylex (void) 23981 { 23982 static int const input[] = { 23983 'b', 'a', 'a', 'b', 0 23984 }; 23985 static int const *inputp = input; 23986 return *inputp++; 23987 } 23988 23989 int 23990 main (void) 23991 { 23992 return yyparse (); 23993 } 23994 _ATEOF 23995 23996 23997 23998 # In some versions of Autoconf, AT_CHECK invokes AS_ESCAPE before 23999 # expanding macros, so it corrupts some special characters in the 24000 # macros. To avoid this, expand now and pass it the result with proper 24001 # string quotation. Assume args 7 through 12 expand to properly quoted 24002 # strings. 24003 24004 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 24005 at_save_special_files 24006 mkdir xml-tests 24007 # Don't combine these Bison invocations since we want to be sure that 24008 # --report=all isn't required to get the full XML file. 24009 { set +x 24010 $as_echo "$at_srcdir/reduce.at:474: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 24011 --graph=xml-tests/test.dot --report=all --defines -o input.c input.y" 24012 at_fn_check_prepare_notrace 'an embedded newline' "reduce.at:474" 24013 ( $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 \ 24014 --graph=xml-tests/test.dot --report=all --defines -o input.c input.y 24015 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24016 at_status=$? at_failed=false 24017 $at_check_filter 24018 echo stderr:; cat "$at_stderr" 24019 echo stdout:; cat "$at_stdout" 24020 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24021 $at_failed && at_fn_log_failure 24022 $at_traceon; } 24023 24024 { set +x 24025 $as_echo "$at_srcdir/reduce.at:474: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --report=all --defines -o input.c input.y" 24026 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --report=all --defines -o input.c input.y" "reduce.at:474" 24027 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --report=all --defines -o input.c input.y 24028 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24029 at_status=$? at_failed=false 24030 $at_check_filter 24031 echo stderr:; cat "$at_stderr" 24032 echo stdout:; cat "$at_stdout" 24033 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24034 $at_failed && at_fn_log_failure 24035 $at_traceon; } 24036 24037 cp xml-tests/test.output expout 24038 { set +x 24039 $as_echo "$at_srcdir/reduce.at:474: \$XSLTPROC \\ 24040 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 24041 xml-tests/test.xml" 24042 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:474" 24043 ( $at_check_trace; $XSLTPROC \ 24044 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 24045 xml-tests/test.xml 24046 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24047 at_status=$? at_failed=false 24048 $at_check_filter 24049 at_fn_diff_devnull "$at_stderr" || at_failed=: 24050 $at_diff expout "$at_stdout" || at_failed=: 24051 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24052 $at_failed && at_fn_log_failure 24053 $at_traceon; } 24054 24055 sort xml-tests/test.dot > expout 24056 { set +x 24057 $as_echo "$at_srcdir/reduce.at:474: \$XSLTPROC \\ 24058 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 24059 xml-tests/test.xml | sort" 24060 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:474" 24061 ( $at_check_trace; $XSLTPROC \ 24062 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 24063 xml-tests/test.xml | sort 24064 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24065 at_status=$? at_failed=false 24066 $at_check_filter 24067 at_fn_diff_devnull "$at_stderr" || at_failed=: 24068 $at_diff expout "$at_stdout" || at_failed=: 24069 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24070 $at_failed && at_fn_log_failure 24071 $at_traceon; } 24072 24073 rm -rf xml-tests expout 24074 at_restore_special_files 24075 fi 24076 { set +x 24077 $as_echo "$at_srcdir/reduce.at:474: bison --report=all --defines -o input.c input.y" 24078 at_fn_check_prepare_trace "reduce.at:474" 24079 ( $at_check_trace; bison --report=all --defines -o input.c input.y 24080 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24081 at_status=$? at_failed=false 24082 $at_check_filter 24083 at_fn_diff_devnull "$at_stderr" || at_failed=: 24084 at_fn_diff_devnull "$at_stdout" || at_failed=: 24085 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24086 $at_failed && at_fn_log_failure 24087 $at_traceon; } 24088 24089 24090 24091 { set +x 24092 $as_echo "$at_srcdir/reduce.at:474: sed -n '/^State 0\$/,\$p' input.output" 24093 at_fn_check_prepare_dynamic "sed -n '/^State 0$/,$p' input.output" "reduce.at:474" 24094 ( $at_check_trace; sed -n '/^State 0$/,$p' input.output 24095 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24096 at_status=$? at_failed=false 24097 $at_check_filter 24098 at_fn_diff_devnull "$at_stderr" || at_failed=: 24099 echo >>"$at_stdout"; $as_echo "State 0 24100 24101 0 \$accept: . S \$end 24102 1 S: . 'a' A 'a' 24103 2 | . 'b' A 'b' 24104 3 | . 'c' c 24105 24106 'a' shift, and go to state 1 24107 'b' shift, and go to state 2 24108 'c' shift, and go to state 3 24109 24110 S go to state 4 24111 24112 24113 State 1 24114 24115 1 S: 'a' . A 'a' 24116 4 A: . 'a' 'a' 24117 5 | . 'a' 24118 24119 'a' shift, and go to state 5 24120 24121 A go to state 6 24122 24123 24124 State 2 24125 24126 2 S: 'b' . A 'b' 24127 4 A: . 'a' 'a' 24128 5 | . 'a' 24129 24130 'a' shift, and go to state 5 24131 24132 A go to state 7 24133 24134 24135 State 3 24136 24137 3 S: 'c' . c 24138 4 A: . 'a' 'a' 24139 5 | . 'a' 24140 6 c: . 'a' 'b' 24141 7 | . A 24142 24143 'a' shift, and go to state 8 24144 24145 A go to state 9 24146 c go to state 10 24147 24148 24149 State 4 24150 24151 0 \$accept: S . \$end 24152 24153 \$end shift, and go to state 11 24154 24155 24156 State 5 24157 24158 4 A: 'a' . 'a' 24159 5 | 'a' . ['a', 'b'] 24160 24161 \$default reduce using rule 5 (A) 24162 24163 Conflict between rule 5 and token 'a' resolved as reduce (%left 'a'). 24164 24165 24166 State 6 24167 24168 1 S: 'a' A . 'a' 24169 24170 'a' shift, and go to state 13 24171 24172 24173 State 7 24174 24175 2 S: 'b' A . 'b' 24176 24177 'b' shift, and go to state 14 24178 24179 24180 State 8 24181 24182 4 A: 'a' . 'a' 24183 5 | 'a' . [\$end] 24184 6 c: 'a' . 'b' 24185 24186 'a' shift, and go to state 12 24187 'b' shift, and go to state 15 24188 24189 \$default reduce using rule 5 (A) 24190 24191 24192 State 9 24193 24194 7 c: A . 24195 24196 \$default reduce using rule 7 (c) 24197 24198 24199 State 10 24200 24201 3 S: 'c' c . 24202 24203 \$default reduce using rule 3 (S) 24204 24205 24206 State 11 24207 24208 0 \$accept: S \$end . 24209 24210 \$default accept 24211 24212 24213 State 12 24214 24215 4 A: 'a' 'a' . 24216 24217 \$default reduce using rule 4 (A) 24218 24219 24220 State 13 24221 24222 1 S: 'a' A 'a' . 24223 24224 \$default reduce using rule 1 (S) 24225 24226 24227 State 14 24228 24229 2 S: 'b' A 'b' . 24230 24231 \$default reduce using rule 2 (S) 24232 24233 24234 State 15 24235 24236 6 c: 'a' 'b' . 24237 24238 \$default reduce using rule 6 (c) 24239 " | \ 24240 $at_diff - "$at_stdout" || at_failed=: 24241 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24242 $at_failed && at_fn_log_failure 24243 $at_traceon; } 24244 24245 24246 24247 24248 # Canonical LR generates very large tables, resulting in very long 24249 # files with #line directives that may overflow what the standards 24250 # (C90 and C++98) guarantee: 32767. In that case, GCC's -pedantic 24251 # will issue an error. 24252 # 24253 # There is no "" around `wc` since some indent the result. 24254 24255 { set +x 24256 $as_echo "$at_srcdir/reduce.at:474: \$BISON_C_WORKS" 24257 at_fn_check_prepare_dynamic "$BISON_C_WORKS" "reduce.at:474" 24258 ( $at_check_trace; $BISON_C_WORKS 24259 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24260 at_status=$? at_failed=false 24261 $at_check_filter 24262 echo stderr:; cat "$at_stderr" 24263 echo stdout:; cat "$at_stdout" 24264 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24265 $at_failed && at_fn_log_failure 24266 $at_traceon; } 24267 24268 { set +x 24269 $as_echo "$at_srcdir/reduce.at:474: \$CC \$CFLAGS \$CPPFLAGS \$LDFLAGS -o input input.c \$LIBS" 24270 at_fn_check_prepare_dynamic "$CC $CFLAGS $CPPFLAGS $LDFLAGS -o input input.c $LIBS" "reduce.at:474" 24271 ( $at_check_trace; $CC $CFLAGS $CPPFLAGS $LDFLAGS -o input input.c $LIBS 24272 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24273 at_status=$? at_failed=false 24274 $at_check_filter 24275 echo stderr:; cat "$at_stderr" 24276 echo stdout:; cat "$at_stdout" 24277 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24278 $at_failed && at_fn_log_failure 24279 $at_traceon; } 24280 24281 24282 { set +x 24283 $as_echo "$at_srcdir/reduce.at:474: \$PREPARSER ./input" 24284 at_fn_check_prepare_dynamic " $PREPARSER ./input" "reduce.at:474" 24285 ( $at_check_trace; $PREPARSER ./input 24286 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24287 at_status=$? at_failed=false 24288 $at_check_filter 24289 echo stderr:; tee stderr <"$at_stderr" 24290 at_fn_diff_devnull "$at_stdout" || at_failed=: 24291 at_fn_check_status 1 $at_status "$at_srcdir/reduce.at:474" 24292 $at_failed && at_fn_log_failure 24293 $at_traceon; } 24294 24295 { set +x 24296 $as_echo "$at_srcdir/reduce.at:474: sed >&2 -e '/^profiling:.*:Merge mismatch for summaries/d' stderr" 24297 at_fn_check_prepare_trace "reduce.at:474" 24298 ( $at_check_trace; sed >&2 -e '/^profiling:.*:Merge mismatch for summaries/d' stderr 24299 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24300 at_status=$? at_failed=false 24301 $at_check_filter 24302 echo >>"$at_stderr"; $as_echo "syntax error 24303 " | \ 24304 $at_diff - "$at_stderr" || at_failed=: 24305 at_fn_diff_devnull "$at_stdout" || at_failed=: 24306 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24307 $at_failed && at_fn_log_failure 24308 $at_traceon; } 24309 24310 24311 24312 24313 set +x 24314 $at_times_p && times >"$at_times_file" 24315 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 24316 read at_status <"$at_status_file" 24317 #AT_STOP_109 24318 #AT_START_110 24319 at_fn_group_banner 110 'reduce.at:474' \ 24320 "%define lr.type ielr: Single State Split" " " 6 24321 at_xfail=no 24322 ( 24323 $as_echo "110. $at_setup_line: testing $at_desc ..." 24324 $at_traceon 24325 24326 24327 cat >input.y <<'_ATEOF' 24328 %code top { 24329 #include <config.h> 24330 /* We don't need perfect functions for these tests. */ 24331 #undef malloc 24332 #undef memcmp 24333 #undef realloc 24334 } 24335 24336 %code { 24337 #include <stdio.h> 24338 static void yyerror ( const char *msg); 24339 static int yylex (void); 24340 } 24341 24342 %define lr.type ielr 24343 %left 'a' 24344 // Conflict resolution renders state 12 unreachable for canonical LR(1). We 24345 // keep it so that the paser table diff is easier to code. 24346 %define lr.keep-unreachable-states 24347 24348 %% 24349 24350 24351 S: 'a' A 'a' /* rule 1 */ 24352 | 'b' A 'b' /* rule 2 */ 24353 | 'c' c /* rule 3 */ 24354 ; 24355 24356 /* A conflict should appear after the first 'a' in rules 4 and 5 but only after 24357 having shifted the first 'a' in rule 1. However, when LALR(1) merging is 24358 chosen, the state containing that conflict is reused after having seen the 24359 first 'b' in rule 2 and then the first 'a' in rules 4 and 5. In both cases, 24360 because of the merged state, if the next token is an 'a', the %left forces a 24361 reduction action with rule 5. In the latter case, only a shift is actually 24362 grammatically correct. Thus, the parser would report a syntax error for the 24363 grammatically correct sentence "baab" because it would encounter a syntax 24364 error after that incorrect reduction. 24365 24366 Despite not being LALR(1), Menhir version 20070322 suffers from this problem 24367 as well. It uses David Pager's weak compatibility test for merging states. 24368 Bison and Menhir accept non-LR(1) grammars with conflict resolution. Pager 24369 designed his algorithm only for LR(1) grammars. */ 24370 A: 'a' 'a' /* rule 4 */ 24371 | 'a' /* rule 5 */ 24372 ; 24373 24374 /* Rule 3, rule 6, and rule 7 ensure that Bison does not report rule 4 as 24375 useless after conflict resolution. This proves that, even though LALR(1) 24376 generates incorrect parser tables sometimes, Bison will not necessarily 24377 produce any warning to help the user realize it. */ 24378 c: 'a' 'b' /* rule 6 */ 24379 | A /* rule 7 */ 24380 ; 24381 24382 24383 %% 24384 #include <stdio.h> 24385 /* A C error reporting function. */ 24386 static 24387 void yyerror ( const char *msg) 24388 { 24389 fprintf (stderr, "%s\n", msg); 24390 } 24391 static int 24392 yylex (void) 24393 { 24394 static int const input[] = { 24395 'b', 'a', 'a', 'b', 0 24396 }; 24397 static int const *inputp = input; 24398 return *inputp++; 24399 } 24400 24401 int 24402 main (void) 24403 { 24404 return yyparse (); 24405 } 24406 _ATEOF 24407 24408 24409 24410 # In some versions of Autoconf, AT_CHECK invokes AS_ESCAPE before 24411 # expanding macros, so it corrupts some special characters in the 24412 # macros. To avoid this, expand now and pass it the result with proper 24413 # string quotation. Assume args 7 through 12 expand to properly quoted 24414 # strings. 24415 24416 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 24417 at_save_special_files 24418 mkdir xml-tests 24419 # Don't combine these Bison invocations since we want to be sure that 24420 # --report=all isn't required to get the full XML file. 24421 { set +x 24422 $as_echo "$at_srcdir/reduce.at:474: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 24423 --graph=xml-tests/test.dot --report=all --defines -o input.c input.y" 24424 at_fn_check_prepare_notrace 'an embedded newline' "reduce.at:474" 24425 ( $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 \ 24426 --graph=xml-tests/test.dot --report=all --defines -o input.c input.y 24427 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24428 at_status=$? at_failed=false 24429 $at_check_filter 24430 echo stderr:; cat "$at_stderr" 24431 echo stdout:; cat "$at_stdout" 24432 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24433 $at_failed && at_fn_log_failure 24434 $at_traceon; } 24435 24436 { set +x 24437 $as_echo "$at_srcdir/reduce.at:474: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --report=all --defines -o input.c input.y" 24438 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --report=all --defines -o input.c input.y" "reduce.at:474" 24439 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --report=all --defines -o input.c input.y 24440 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24441 at_status=$? at_failed=false 24442 $at_check_filter 24443 echo stderr:; cat "$at_stderr" 24444 echo stdout:; cat "$at_stdout" 24445 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24446 $at_failed && at_fn_log_failure 24447 $at_traceon; } 24448 24449 cp xml-tests/test.output expout 24450 { set +x 24451 $as_echo "$at_srcdir/reduce.at:474: \$XSLTPROC \\ 24452 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 24453 xml-tests/test.xml" 24454 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:474" 24455 ( $at_check_trace; $XSLTPROC \ 24456 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 24457 xml-tests/test.xml 24458 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24459 at_status=$? at_failed=false 24460 $at_check_filter 24461 at_fn_diff_devnull "$at_stderr" || at_failed=: 24462 $at_diff expout "$at_stdout" || at_failed=: 24463 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24464 $at_failed && at_fn_log_failure 24465 $at_traceon; } 24466 24467 sort xml-tests/test.dot > expout 24468 { set +x 24469 $as_echo "$at_srcdir/reduce.at:474: \$XSLTPROC \\ 24470 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 24471 xml-tests/test.xml | sort" 24472 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:474" 24473 ( $at_check_trace; $XSLTPROC \ 24474 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 24475 xml-tests/test.xml | sort 24476 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24477 at_status=$? at_failed=false 24478 $at_check_filter 24479 at_fn_diff_devnull "$at_stderr" || at_failed=: 24480 $at_diff expout "$at_stdout" || at_failed=: 24481 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24482 $at_failed && at_fn_log_failure 24483 $at_traceon; } 24484 24485 rm -rf xml-tests expout 24486 at_restore_special_files 24487 fi 24488 { set +x 24489 $as_echo "$at_srcdir/reduce.at:474: bison --report=all --defines -o input.c input.y" 24490 at_fn_check_prepare_trace "reduce.at:474" 24491 ( $at_check_trace; bison --report=all --defines -o input.c input.y 24492 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24493 at_status=$? at_failed=false 24494 $at_check_filter 24495 at_fn_diff_devnull "$at_stderr" || at_failed=: 24496 at_fn_diff_devnull "$at_stdout" || at_failed=: 24497 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24498 $at_failed && at_fn_log_failure 24499 $at_traceon; } 24500 24501 24502 24503 { set +x 24504 $as_echo "$at_srcdir/reduce.at:474: sed -n '/^State 0\$/,\$p' input.output" 24505 at_fn_check_prepare_dynamic "sed -n '/^State 0$/,$p' input.output" "reduce.at:474" 24506 ( $at_check_trace; sed -n '/^State 0$/,$p' input.output 24507 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24508 at_status=$? at_failed=false 24509 $at_check_filter 24510 at_fn_diff_devnull "$at_stderr" || at_failed=: 24511 echo >>"$at_stdout"; $as_echo "State 0 24512 24513 0 \$accept: . S \$end 24514 1 S: . 'a' A 'a' 24515 2 | . 'b' A 'b' 24516 3 | . 'c' c 24517 24518 'a' shift, and go to state 1 24519 'b' shift, and go to state 2 24520 'c' shift, and go to state 3 24521 24522 S go to state 4 24523 24524 24525 State 1 24526 24527 1 S: 'a' . A 'a' 24528 4 A: . 'a' 'a' 24529 5 | . 'a' 24530 24531 'a' shift, and go to state 5 24532 24533 A go to state 6 24534 24535 24536 State 2 24537 24538 2 S: 'b' . A 'b' 24539 4 A: . 'a' 'a' 24540 5 | . 'a' 24541 24542 'a' shift, and go to state 16 24543 24544 A go to state 7 24545 24546 24547 State 3 24548 24549 3 S: 'c' . c 24550 4 A: . 'a' 'a' 24551 5 | . 'a' 24552 6 c: . 'a' 'b' 24553 7 | . A 24554 24555 'a' shift, and go to state 8 24556 24557 A go to state 9 24558 c go to state 10 24559 24560 24561 State 4 24562 24563 0 \$accept: S . \$end 24564 24565 \$end shift, and go to state 11 24566 24567 24568 State 5 24569 24570 4 A: 'a' . 'a' 24571 5 | 'a' . ['a'] 24572 24573 \$default reduce using rule 5 (A) 24574 24575 Conflict between rule 5 and token 'a' resolved as reduce (%left 'a'). 24576 24577 24578 State 6 24579 24580 1 S: 'a' A . 'a' 24581 24582 'a' shift, and go to state 13 24583 24584 24585 State 7 24586 24587 2 S: 'b' A . 'b' 24588 24589 'b' shift, and go to state 14 24590 24591 24592 State 8 24593 24594 4 A: 'a' . 'a' 24595 5 | 'a' . [\$end] 24596 6 c: 'a' . 'b' 24597 24598 'a' shift, and go to state 12 24599 'b' shift, and go to state 15 24600 24601 \$default reduce using rule 5 (A) 24602 24603 24604 State 9 24605 24606 7 c: A . 24607 24608 \$default reduce using rule 7 (c) 24609 24610 24611 State 10 24612 24613 3 S: 'c' c . 24614 24615 \$default reduce using rule 3 (S) 24616 24617 24618 State 11 24619 24620 0 \$accept: S \$end . 24621 24622 \$default accept 24623 24624 24625 State 12 24626 24627 4 A: 'a' 'a' . 24628 24629 \$default reduce using rule 4 (A) 24630 24631 24632 State 13 24633 24634 1 S: 'a' A 'a' . 24635 24636 \$default reduce using rule 1 (S) 24637 24638 24639 State 14 24640 24641 2 S: 'b' A 'b' . 24642 24643 \$default reduce using rule 2 (S) 24644 24645 24646 State 15 24647 24648 6 c: 'a' 'b' . 24649 24650 \$default reduce using rule 6 (c) 24651 24652 24653 State 16 24654 24655 4 A: 'a' . 'a' 24656 5 | 'a' . ['b'] 24657 24658 'a' shift, and go to state 12 24659 24660 \$default reduce using rule 5 (A) 24661 " | \ 24662 $at_diff - "$at_stdout" || at_failed=: 24663 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24664 $at_failed && at_fn_log_failure 24665 $at_traceon; } 24666 24667 24668 24669 24670 # Canonical LR generates very large tables, resulting in very long 24671 # files with #line directives that may overflow what the standards 24672 # (C90 and C++98) guarantee: 32767. In that case, GCC's -pedantic 24673 # will issue an error. 24674 # 24675 # There is no "" around `wc` since some indent the result. 24676 24677 { set +x 24678 $as_echo "$at_srcdir/reduce.at:474: \$BISON_C_WORKS" 24679 at_fn_check_prepare_dynamic "$BISON_C_WORKS" "reduce.at:474" 24680 ( $at_check_trace; $BISON_C_WORKS 24681 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24682 at_status=$? at_failed=false 24683 $at_check_filter 24684 echo stderr:; cat "$at_stderr" 24685 echo stdout:; cat "$at_stdout" 24686 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24687 $at_failed && at_fn_log_failure 24688 $at_traceon; } 24689 24690 { set +x 24691 $as_echo "$at_srcdir/reduce.at:474: \$CC \$CFLAGS \$CPPFLAGS \$LDFLAGS -o input input.c \$LIBS" 24692 at_fn_check_prepare_dynamic "$CC $CFLAGS $CPPFLAGS $LDFLAGS -o input input.c $LIBS" "reduce.at:474" 24693 ( $at_check_trace; $CC $CFLAGS $CPPFLAGS $LDFLAGS -o input input.c $LIBS 24694 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24695 at_status=$? at_failed=false 24696 $at_check_filter 24697 echo stderr:; cat "$at_stderr" 24698 echo stdout:; cat "$at_stdout" 24699 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24700 $at_failed && at_fn_log_failure 24701 $at_traceon; } 24702 24703 24704 { set +x 24705 $as_echo "$at_srcdir/reduce.at:474: \$PREPARSER ./input" 24706 at_fn_check_prepare_dynamic " $PREPARSER ./input" "reduce.at:474" 24707 ( $at_check_trace; $PREPARSER ./input 24708 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24709 at_status=$? at_failed=false 24710 $at_check_filter 24711 echo stderr:; tee stderr <"$at_stderr" 24712 at_fn_diff_devnull "$at_stdout" || at_failed=: 24713 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24714 $at_failed && at_fn_log_failure 24715 $at_traceon; } 24716 24717 { set +x 24718 $as_echo "$at_srcdir/reduce.at:474: sed >&2 -e '/^profiling:.*:Merge mismatch for summaries/d' stderr" 24719 at_fn_check_prepare_trace "reduce.at:474" 24720 ( $at_check_trace; sed >&2 -e '/^profiling:.*:Merge mismatch for summaries/d' stderr 24721 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24722 at_status=$? at_failed=false 24723 $at_check_filter 24724 at_fn_diff_devnull "$at_stderr" || at_failed=: 24725 at_fn_diff_devnull "$at_stdout" || at_failed=: 24726 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24727 $at_failed && at_fn_log_failure 24728 $at_traceon; } 24729 24730 24731 24732 24733 set +x 24734 $at_times_p && times >"$at_times_file" 24735 ) 5>&1 2>&1 7>&- | eval $at_tee_pipe 24736 read at_status <"$at_status_file" 24737 #AT_STOP_110 24738 #AT_START_111 24739 at_fn_group_banner 111 'reduce.at:474' \ 24740 "%define lr.type canonical-lr: Single State Split" "" 6 24741 at_xfail=no 24742 ( 24743 $as_echo "111. $at_setup_line: testing $at_desc ..." 24744 $at_traceon 24745 24746 24747 cat >input.y <<'_ATEOF' 24748 %code top { 24749 #include <config.h> 24750 /* We don't need perfect functions for these tests. */ 24751 #undef malloc 24752 #undef memcmp 24753 #undef realloc 24754 } 24755 24756 %code { 24757 #include <stdio.h> 24758 static void yyerror ( const char *msg); 24759 static int yylex (void); 24760 } 24761 24762 %define lr.type canonical-lr 24763 %left 'a' 24764 // Conflict resolution renders state 12 unreachable for canonical LR(1). We 24765 // keep it so that the paser table diff is easier to code. 24766 %define lr.keep-unreachable-states 24767 24768 %% 24769 24770 24771 S: 'a' A 'a' /* rule 1 */ 24772 | 'b' A 'b' /* rule 2 */ 24773 | 'c' c /* rule 3 */ 24774 ; 24775 24776 /* A conflict should appear after the first 'a' in rules 4 and 5 but only after 24777 having shifted the first 'a' in rule 1. However, when LALR(1) merging is 24778 chosen, the state containing that conflict is reused after having seen the 24779 first 'b' in rule 2 and then the first 'a' in rules 4 and 5. In both cases, 24780 because of the merged state, if the next token is an 'a', the %left forces a 24781 reduction action with rule 5. In the latter case, only a shift is actually 24782 grammatically correct. Thus, the parser would report a syntax error for the 24783 grammatically correct sentence "baab" because it would encounter a syntax 24784 error after that incorrect reduction. 24785 24786 Despite not being LALR(1), Menhir version 20070322 suffers from this problem 24787 as well. It uses David Pager's weak compatibility test for merging states. 24788 Bison and Menhir accept non-LR(1) grammars with conflict resolution. Pager 24789 designed his algorithm only for LR(1) grammars. */ 24790 A: 'a' 'a' /* rule 4 */ 24791 | 'a' /* rule 5 */ 24792 ; 24793 24794 /* Rule 3, rule 6, and rule 7 ensure that Bison does not report rule 4 as 24795 useless after conflict resolution. This proves that, even though LALR(1) 24796 generates incorrect parser tables sometimes, Bison will not necessarily 24797 produce any warning to help the user realize it. */ 24798 c: 'a' 'b' /* rule 6 */ 24799 | A /* rule 7 */ 24800 ; 24801 24802 24803 %% 24804 #include <stdio.h> 24805 /* A C error reporting function. */ 24806 static 24807 void yyerror ( const char *msg) 24808 { 24809 fprintf (stderr, "%s\n", msg); 24810 } 24811 static int 24812 yylex (void) 24813 { 24814 static int const input[] = { 24815 'b', 'a', 'a', 'b', 0 24816 }; 24817 static int const *inputp = input; 24818 return *inputp++; 24819 } 24820 24821 int 24822 main (void) 24823 { 24824 return yyparse (); 24825 } 24826 _ATEOF 24827 24828 24829 24830 # In some versions of Autoconf, AT_CHECK invokes AS_ESCAPE before 24831 # expanding macros, so it corrupts some special characters in the 24832 # macros. To avoid this, expand now and pass it the result with proper 24833 # string quotation. Assume args 7 through 12 expand to properly quoted 24834 # strings. 24835 24836 if test x"$BISON_TEST_XML" = x1 && test x"$XSLTPROC" != x""; then 24837 at_save_special_files 24838 mkdir xml-tests 24839 # Don't combine these Bison invocations since we want to be sure that 24840 # --report=all isn't required to get the full XML file. 24841 { set +x 24842 $as_echo "$at_srcdir/reduce.at:474: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --report=all --report-file=xml-tests/test.output \\ 24843 --graph=xml-tests/test.dot --report=all --defines -o input.c input.y" 24844 at_fn_check_prepare_notrace 'an embedded newline' "reduce.at:474" 24845 ( $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 \ 24846 --graph=xml-tests/test.dot --report=all --defines -o input.c input.y 24847 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24848 at_status=$? at_failed=false 24849 $at_check_filter 24850 echo stderr:; cat "$at_stderr" 24851 echo stdout:; cat "$at_stdout" 24852 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24853 $at_failed && at_fn_log_failure 24854 $at_traceon; } 24855 24856 { set +x 24857 $as_echo "$at_srcdir/reduce.at:474: VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --report=all --defines -o input.c input.y" 24858 at_fn_check_prepare_dynamic "VALGRIND_OPTS=\"$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --report=all --defines -o input.c input.y" "reduce.at:474" 24859 ( $at_check_trace; VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --xml=xml-tests/test.xml --report=all --defines -o input.c input.y 24860 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24861 at_status=$? at_failed=false 24862 $at_check_filter 24863 echo stderr:; cat "$at_stderr" 24864 echo stdout:; cat "$at_stdout" 24865 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24866 $at_failed && at_fn_log_failure 24867 $at_traceon; } 24868 24869 cp xml-tests/test.output expout 24870 { set +x 24871 $as_echo "$at_srcdir/reduce.at:474: \$XSLTPROC \\ 24872 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2text.xsl \\ 24873 xml-tests/test.xml" 24874 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:474" 24875 ( $at_check_trace; $XSLTPROC \ 24876 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2text.xsl \ 24877 xml-tests/test.xml 24878 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24879 at_status=$? at_failed=false 24880 $at_check_filter 24881 at_fn_diff_devnull "$at_stderr" || at_failed=: 24882 $at_diff expout "$at_stdout" || at_failed=: 24883 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24884 $at_failed && at_fn_log_failure 24885 $at_traceon; } 24886 24887 sort xml-tests/test.dot > expout 24888 { set +x 24889 $as_echo "$at_srcdir/reduce.at:474: \$XSLTPROC \\ 24890 \`VALGRIND_OPTS=\"\$VALGRIND_OPTS --leak-check=summary --show-reachable=no\"; export VALGRIND_OPTS; bison --print-datadir\`/xslt/xml2dot.xsl \\ 24891 xml-tests/test.xml | sort" 24892 at_fn_check_prepare_notrace 'a `...` command substitution' "reduce.at:474" 24893 ( $at_check_trace; $XSLTPROC \ 24894 `VALGRIND_OPTS="$VALGRIND_OPTS --leak-check=summary --show-reachable=no"; export VALGRIND_OPTS; bison --print-datadir`/xslt/xml2dot.xsl \ 24895 xml-tests/test.xml | sort 24896 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24897 at_status=$? at_failed=false 24898 $at_check_filter 24899 at_fn_diff_devnull "$at_stderr" || at_failed=: 24900 $at_diff expout "$at_stdout" || at_failed=: 24901 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24902 $at_failed && at_fn_log_failure 24903 $at_traceon; } 24904 24905 rm -rf xml-tests expout 24906 at_restore_special_files 24907 fi 24908 { set +x 24909 $as_echo "$at_srcdir/reduce.at:474: bison --report=all --defines -o input.c input.y" 24910 at_fn_check_prepare_trace "reduce.at:474" 24911 ( $at_check_trace; bison --report=all --defines -o input.c input.y 24912 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24913 at_status=$? at_failed=false 24914 $at_check_filter 24915 at_fn_diff_devnull "$at_stderr" || at_failed=: 24916 at_fn_diff_devnull "$at_stdout" || at_failed=: 24917 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 24918 $at_failed && at_fn_log_failure 24919 $at_traceon; } 24920 24921 24922 24923 { set +x 24924 $as_echo "$at_srcdir/reduce.at:474: sed -n '/^State 0\$/,\$p' input.output" 24925 at_fn_check_prepare_dynamic "sed -n '/^State 0$/,$p' input.output" "reduce.at:474" 24926 ( $at_check_trace; sed -n '/^State 0$/,$p' input.output 24927 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 24928 at_status=$? at_failed=false 24929 $at_check_filter 24930 at_fn_diff_devnull "$at_stderr" || at_failed=: 24931 echo >>"$at_stdout"; $as_echo "State 0 24932 24933 0 \$accept: . S \$end 24934 1 S: . 'a' A 'a' 24935 2 | . 'b' A 'b' 24936 3 | . 'c' c 24937 24938 'a' shift, and go to state 1 24939 'b' shift, and go to state 2 24940 'c' shift, and go to state 3 24941 24942 S go to state 4 24943 24944 24945 State 1 24946 24947 1 S: 'a' . A 'a' 24948 4 A: . 'a' 'a' 24949 5 | . 'a' 24950 24951 'a' shift, and go to state 5 24952 24953 A go to state 6 24954 24955 24956 State 2 24957 24958 2 S: 'b' . A 'b' 24959 4 A: . 'a' 'a' 24960 5 | . 'a' 24961 24962 'a' shift, and go to state 16 24963 24964 A go to state 7 24965 24966 24967 State 3 24968 24969 3 S: 'c' . c 24970 4 A: . 'a' 'a' 24971 5 | . 'a' 24972 6 c: . 'a' 'b' 24973 7 | . A 24974 24975 'a' shift, and go to state 8 24976 24977 A go to state 9 24978 c go to state 10 24979 24980 24981 State 4 24982 24983 0 \$accept: S . \$end 24984 24985 \$end shift, and go to state 11 24986 24987 24988 State 5 24989 24990 4 A: 'a' . 'a' 24991 5 | 'a' . ['a'] 24992 24993 'a' reduce using rule 5 (A) 24994 24995 Conflict between rule 5 and token 'a' resolved as reduce (%left 'a'). 24996 24997 24998 State 6 24999 25000 1 S: 'a' A . 'a' 25001 25002 'a' shift, and go to state 13 25003 25004 25005 State 7 25006 25007 2 S: 'b' A . 'b' 25008 25009 'b' shift, and go to state 14 25010 25011 25012 State 8 25013 25014 4 A: 'a' . 'a' 25015 5 | 'a' . [\$end] 25016 6 c: 'a' . 'b' 25017 25018 'a' shift, and go to state 17 25019 'b' shift, and go to state 15 25020 25021 \$end reduce using rule 5 (A) 25022 25023 25024 State 9 25025 25026 7 c: A . [\$end] 25027 25028 \$end reduce using rule 7 (c) 25029 25030 25031 State 10 25032 25033 3 S: 'c' c . [\$end] 25034 25035 \$end reduce using rule 3 (S) 25036 25037 25038 State 11 25039 25040 0 \$accept: S \$end . 25041 25042 \$default accept 25043 25044 25045 State 12 25046 25047 4 A: 'a' 'a' . ['a'] 25048 25049 'a' reduce using rule 4 (A) 25050 25051 25052 State 13 25053 25054 1 S: 'a' A 'a' . [\$end] 25055 25056 \$end reduce using rule 1 (S) 25057 25058 25059 State 14 25060 25061 2 S: 'b' A 'b' . [\$end] 25062 25063 \$end reduce using rule 2 (S) 25064 25065 25066 State 15 25067 25068 6 c: 'a' 'b' . [\$end] 25069 25070 \$end reduce using rule 6 (c) 25071 25072 25073 State 16 25074 25075 4 A: 'a' . 'a' 25076 5 | 'a' . ['b'] 25077 25078 'a' shift, and go to state 18 25079 25080 'b' reduce using rule 5 (A) 25081 25082 25083 State 17 25084 25085 4 A: 'a' 'a' . [\$end] 25086 25087 \$end reduce using rule 4 (A) 25088 25089 25090 State 18 25091 25092 4 A: 'a' 'a' . ['b'] 25093 25094 'b' reduce using rule 4 (A) 25095 " | \ 25096 $at_diff - "$at_stdout" || at_failed=: 25097 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 25098 $at_failed && at_fn_log_failure 25099 $at_traceon; } 25100 25101 25102 25103 25104 # Canonical LR generates very large tables, resulting in very long 25105 # files with #line directives that may overflow what the standards 25106 # (C90 and C++98) guarantee: 32767. In that case, GCC's -pedantic 25107 # will issue an error. 25108 # 25109 # There is no "" around `wc` since some indent the result. 25110 if test 32767 -lt `wc -l < input.c`; then 25111 CFLAGS=`echo " $CFLAGS " | sed -e 's/ -pedantic //'` 25112 CXXFLAGS=`echo " $CXXFLAGS " | sed -e 's/ -pedantic //'` 25113 fi 25114 { set +x 25115 $as_echo "$at_srcdir/reduce.at:474: \$BISON_C_WORKS" 25116 at_fn_check_prepare_dynamic "$BISON_C_WORKS" "reduce.at:474" 25117 ( $at_check_trace; $BISON_C_WORKS 25118 ) >>"$at_stdout" 2>>"$at_stderr" 5>&- 25119 at_status=$? at_failed=false 25120 $at_check_filter 25121 echo stderr:; cat "$at_stderr" 25122 echo stdout:; cat "$at_stdout" 25123 at_fn_check_status 0 $at_status "$at_srcdir/reduce.at:474" 25124 $at_failed && at_fn_log_failur