| 136 | | # Required to use basename. |
| | 136 | # CDPATH. |
| | 137 | (unset CDPATH) >/dev/null 2>&1 && unset CDPATH |
| | 138 | |
| | 139 | if test "x$CONFIG_SHELL" = x; then |
| | 140 | as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : |
| | 141 | emulate sh |
| | 142 | NULLCMD=: |
| | 143 | # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which |
| | 144 | # is contrary to our usage. Disable this feature. |
| | 145 | alias -g '\${1+\"\$@\"}'='\"\$@\"' |
| | 146 | setopt NO_GLOB_SUBST |
| | 147 | else |
| | 148 | case \`(set -o) 2>/dev/null\` in #( |
| | 149 | *posix*) : |
| | 150 | set -o posix ;; #( |
| | 151 | *) : |
| | 152 | ;; |
| | 153 | esac |
| | 154 | fi |
| | 155 | " |
| | 156 | as_required="as_fn_return () { (exit \$1); } |
| | 157 | as_fn_success () { as_fn_return 0; } |
| | 158 | as_fn_failure () { as_fn_return 1; } |
| | 159 | as_fn_ret_success () { return 0; } |
| | 160 | as_fn_ret_failure () { return 1; } |
| | 161 | |
| | 162 | exitcode=0 |
| | 163 | as_fn_success || { exitcode=1; echo as_fn_success failed.; } |
| | 164 | as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } |
| | 165 | as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } |
| | 166 | as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } |
| | 167 | if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : |
| | 168 | |
| | 169 | else |
| | 170 | exitcode=1; echo positional parameters were not saved. |
| | 171 | fi |
| | 172 | test x\$exitcode = x0 || exit 1" |
| | 173 | as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO |
| | 174 | as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO |
| | 175 | eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && |
| | 176 | test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 |
| | 177 | |
| | 178 | test -n \"\${ZSH_VERSION+set}\${BASH_VERSION+set}\" || ( |
| | 179 | ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' |
| | 180 | ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO |
| | 181 | ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO |
| | 182 | PATH=/empty FPATH=/empty; export PATH FPATH |
| | 183 | test \"X\`printf %s \$ECHO\`\" = \"X\$ECHO\" \\ |
| | 184 | || test \"X\`print -r -- \$ECHO\`\" = \"X\$ECHO\" ) || exit 1 |
| | 185 | test \$(( 1 + 1 )) = 2 || exit 1" |
| | 186 | if (eval "$as_required") 2>/dev/null; then : |
| | 187 | as_have_required=yes |
| | 188 | else |
| | 189 | as_have_required=no |
| | 190 | fi |
| | 191 | if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : |
| | 192 | |
| | 193 | else |
| | 194 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 195 | as_found=false |
| | 196 | for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH |
| | 197 | do |
| | 198 | IFS=$as_save_IFS |
| | 199 | test -z "$as_dir" && as_dir=. |
| | 200 | as_found=: |
| | 201 | case $as_dir in #( |
| | 202 | /*) |
| | 203 | for as_base in sh bash ksh sh5; do |
| | 204 | # Try only shells that exist, to save several forks. |
| | 205 | as_shell=$as_dir/$as_base |
| | 206 | if { test -f "$as_shell" || test -f "$as_shell.exe"; } && |
| | 207 | { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : |
| | 208 | CONFIG_SHELL=$as_shell as_have_required=yes |
| | 209 | if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : |
| | 210 | break 2 |
| | 211 | fi |
| | 212 | fi |
| | 213 | done;; |
| | 214 | esac |
| | 215 | as_found=false |
| | 216 | done |
| | 217 | $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && |
| | 218 | { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : |
| | 219 | CONFIG_SHELL=$SHELL as_have_required=yes |
| | 220 | fi; } |
| | 221 | IFS=$as_save_IFS |
| | 222 | |
| | 223 | |
| | 224 | if test "x$CONFIG_SHELL" != x; then : |
| | 225 | # We cannot yet assume a decent shell, so we have to provide a |
| | 226 | # neutralization value for shells without unset; and this also |
| | 227 | # works around shells that cannot unset nonexistent variables. |
| | 228 | # Preserve -v and -x to the replacement shell. |
| | 229 | BASH_ENV=/dev/null |
| | 230 | ENV=/dev/null |
| | 231 | (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV |
| | 232 | export CONFIG_SHELL |
| | 233 | case $- in # (((( |
| | 234 | *v*x* | *x*v* ) as_opts=-vx ;; |
| | 235 | *v* ) as_opts=-v ;; |
| | 236 | *x* ) as_opts=-x ;; |
| | 237 | * ) as_opts= ;; |
| | 238 | esac |
| | 239 | exec "$CONFIG_SHELL" $as_opts "$as_myself" ${1+"$@"} |
| | 240 | fi |
| | 241 | |
| | 242 | if test x$as_have_required = xno; then : |
| | 243 | $as_echo "$0: This script requires a shell more modern than all" |
| | 244 | $as_echo "$0: the shells that I found on your system." |
| | 245 | if test x${ZSH_VERSION+set} = xset ; then |
| | 246 | $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" |
| | 247 | $as_echo "$0: be upgraded to zsh 4.3.4 or later." |
| | 248 | else |
| | 249 | $as_echo "$0: Please tell bug-autoconf@gnu.org and |
| | 250 | $0: ren@mathematik.uni-kl.de about your system, including |
| | 251 | $0: any error possibly output before this message. Then |
| | 252 | $0: install a modern shell, or manually run the script |
| | 253 | $0: under such a shell if you do have one." |
| | 254 | fi |
| | 255 | exit 1 |
| | 256 | fi |
| | 257 | fi |
| | 258 | fi |
| | 259 | SHELL=${CONFIG_SHELL-/bin/sh} |
| | 260 | export SHELL |
| | 261 | # Unset more variables known to interfere with behavior of common tools. |
| | 262 | CLICOLOR_FORCE= GREP_OPTIONS= |
| | 263 | unset CLICOLOR_FORCE GREP_OPTIONS |
| | 264 | |
| | 265 | ## --------------------- ## |
| | 266 | ## M4sh Shell Functions. ## |
| | 267 | ## --------------------- ## |
| | 268 | # as_fn_unset VAR |
| | 269 | # --------------- |
| | 270 | # Portably unset VAR. |
| | 271 | as_fn_unset () |
| | 272 | { |
| | 273 | { eval $1=; unset $1;} |
| | 274 | } |
| | 275 | as_unset=as_fn_unset |
| | 276 | |
| | 277 | # as_fn_set_status STATUS |
| | 278 | # ----------------------- |
| | 279 | # Set $? to STATUS, without forking. |
| | 280 | as_fn_set_status () |
| | 281 | { |
| | 282 | return $1 |
| | 283 | } # as_fn_set_status |
| | 284 | |
| | 285 | # as_fn_exit STATUS |
| | 286 | # ----------------- |
| | 287 | # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. |
| | 288 | as_fn_exit () |
| | 289 | { |
| | 290 | set +e |
| | 291 | as_fn_set_status $1 |
| | 292 | exit $1 |
| | 293 | } # as_fn_exit |
| | 294 | |
| | 295 | # as_fn_mkdir_p |
| | 296 | # ------------- |
| | 297 | # Create "$as_dir" as a directory, including parents if necessary. |
| | 298 | as_fn_mkdir_p () |
| | 299 | { |
| | 300 | |
| | 301 | case $as_dir in #( |
| | 302 | -*) as_dir=./$as_dir;; |
| | 303 | esac |
| | 304 | test -d "$as_dir" || eval $as_mkdir_p || { |
| | 305 | as_dirs= |
| | 306 | while :; do |
| | 307 | case $as_dir in #( |
| | 308 | *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( |
| | 309 | *) as_qdir=$as_dir;; |
| | 310 | esac |
| | 311 | as_dirs="'$as_qdir' $as_dirs" |
| | 312 | as_dir=`$as_dirname -- "$as_dir" || |
| | 313 | $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ |
| | 314 | X"$as_dir" : 'X\(//\)[^/]' \| \ |
| | 315 | X"$as_dir" : 'X\(//\)$' \| \ |
| | 316 | X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || |
| | 317 | $as_echo X"$as_dir" | |
| | 318 | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ |
| | 319 | s//\1/ |
| | 320 | q |
| | 321 | } |
| | 322 | /^X\(\/\/\)[^/].*/{ |
| | 323 | s//\1/ |
| | 324 | q |
| | 325 | } |
| | 326 | /^X\(\/\/\)$/{ |
| | 327 | s//\1/ |
| | 328 | q |
| | 329 | } |
| | 330 | /^X\(\/\).*/{ |
| | 331 | s//\1/ |
| | 332 | q |
| | 333 | } |
| | 334 | s/.*/./; q'` |
| | 335 | test -d "$as_dir" && break |
| | 336 | done |
| | 337 | test -z "$as_dirs" || eval "mkdir $as_dirs" |
| | 338 | } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" |
| | 339 | |
| | 340 | |
| | 341 | } # as_fn_mkdir_p |
| | 342 | # as_fn_append VAR VALUE |
| | 343 | # ---------------------- |
| | 344 | # Append the text in VALUE to the end of the definition contained in VAR. Take |
| | 345 | # advantage of any shell optimizations that allow amortized linear growth over |
| | 346 | # repeated appends, instead of the typical quadratic growth present in naive |
| | 347 | # implementations. |
| | 348 | if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : |
| | 349 | eval 'as_fn_append () |
| | 350 | { |
| | 351 | eval $1+=\$2 |
| | 352 | }' |
| | 353 | else |
| | 354 | as_fn_append () |
| | 355 | { |
| | 356 | eval $1=\$$1\$2 |
| | 357 | } |
| | 358 | fi # as_fn_append |
| | 359 | |
| | 360 | # as_fn_arith ARG... |
| | 361 | # ------------------ |
| | 362 | # Perform arithmetic evaluation on the ARGs, and store the result in the |
| | 363 | # global $as_val. Take advantage of shells that can avoid forks. The arguments |
| | 364 | # must be portable across $(()) and expr. |
| | 365 | if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : |
| | 366 | eval 'as_fn_arith () |
| | 367 | { |
| | 368 | as_val=$(( $* )) |
| | 369 | }' |
| | 370 | else |
| | 371 | as_fn_arith () |
| | 372 | { |
| | 373 | as_val=`expr "$@" || test $? -eq 1` |
| | 374 | } |
| | 375 | fi # as_fn_arith |
| | 376 | |
| | 377 | |
| | 378 | # as_fn_error STATUS ERROR [LINENO LOG_FD] |
| | 379 | # ---------------------------------------- |
| | 380 | # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are |
| | 381 | # provided, also output the error to LOG_FD, referencing LINENO. Then exit the |
| | 382 | # script with STATUS, using 1 if that was 0. |
| | 383 | as_fn_error () |
| | 384 | { |
| | 385 | as_status=$1; test $as_status -eq 0 && as_status=1 |
| | 386 | if test "$4"; then |
| | 387 | as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack |
| | 388 | $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 |
| | 389 | fi |
| | 390 | $as_echo "$as_me: error: $2" >&2 |
| | 391 | as_fn_exit $as_status |
| | 392 | } # as_fn_error |
| | 393 | |
| 171 | | # CDPATH. |
| 172 | | $as_unset CDPATH |
| 173 | | |
| 174 | | |
| 175 | | if test "x$CONFIG_SHELL" = x; then |
| 176 | | if (eval ":") 2>/dev/null; then |
| 177 | | as_have_required=yes |
| 178 | | else |
| 179 | | as_have_required=no |
| 180 | | fi |
| 181 | | |
| 182 | | if test $as_have_required = yes && (eval ": |
| 183 | | (as_func_return () { |
| 184 | | (exit \$1) |
| 185 | | } |
| 186 | | as_func_success () { |
| 187 | | as_func_return 0 |
| 188 | | } |
| 189 | | as_func_failure () { |
| 190 | | as_func_return 1 |
| 191 | | } |
| 192 | | as_func_ret_success () { |
| 193 | | return 0 |
| 194 | | } |
| 195 | | as_func_ret_failure () { |
| 196 | | return 1 |
| 197 | | } |
| 198 | | |
| 199 | | exitcode=0 |
| 200 | | if as_func_success; then |
| 201 | | : |
| 202 | | else |
| 203 | | exitcode=1 |
| 204 | | echo as_func_success failed. |
| 205 | | fi |
| 206 | | |
| 207 | | if as_func_failure; then |
| 208 | | exitcode=1 |
| 209 | | echo as_func_failure succeeded. |
| 210 | | fi |
| 211 | | |
| 212 | | if as_func_ret_success; then |
| 213 | | : |
| 214 | | else |
| 215 | | exitcode=1 |
| 216 | | echo as_func_ret_success failed. |
| 217 | | fi |
| 218 | | |
| 219 | | if as_func_ret_failure; then |
| 220 | | exitcode=1 |
| 221 | | echo as_func_ret_failure succeeded. |
| 222 | | fi |
| 223 | | |
| 224 | | if ( set x; as_func_ret_success y && test x = \"\$1\" ); then |
| 225 | | : |
| 226 | | else |
| 227 | | exitcode=1 |
| 228 | | echo positional parameters were not saved. |
| 229 | | fi |
| 230 | | |
| 231 | | test \$exitcode = 0) || { (exit 1); exit 1; } |
| 232 | | |
| 233 | | ( |
| 234 | | as_lineno_1=\$LINENO |
| 235 | | as_lineno_2=\$LINENO |
| 236 | | test \"x\$as_lineno_1\" != \"x\$as_lineno_2\" && |
| 237 | | test \"x\`expr \$as_lineno_1 + 1\`\" = \"x\$as_lineno_2\") || { (exit 1); exit 1; } |
| 238 | | ") 2> /dev/null; then |
| 239 | | : |
| 240 | | else |
| 241 | | as_candidate_shells= |
| 242 | | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| 243 | | for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH |
| 244 | | do |
| 245 | | IFS=$as_save_IFS |
| 246 | | test -z "$as_dir" && as_dir=. |
| 247 | | case $as_dir in |
| 248 | | /*) |
| 249 | | for as_base in sh bash ksh sh5; do |
| 250 | | as_candidate_shells="$as_candidate_shells $as_dir/$as_base" |
| 251 | | done;; |
| 252 | | esac |
| 253 | | done |
| 254 | | IFS=$as_save_IFS |
| 255 | | |
| 256 | | |
| 257 | | for as_shell in $as_candidate_shells $SHELL; do |
| 258 | | # Try only shells that exist, to save several forks. |
| 259 | | if { test -f "$as_shell" || test -f "$as_shell.exe"; } && |
| 260 | | { ("$as_shell") 2> /dev/null <<\_ASEOF |
| 261 | | if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then |
| 262 | | emulate sh |
| 263 | | NULLCMD=: |
| 264 | | # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which |
| 265 | | # is contrary to our usage. Disable this feature. |
| 266 | | alias -g '${1+"$@"}'='"$@"' |
| 267 | | setopt NO_GLOB_SUBST |
| 268 | | else |
| 269 | | case `(set -o) 2>/dev/null` in |
| 270 | | *posix*) set -o posix ;; |
| 271 | | esac |
| 272 | | |
| 273 | | fi |
| 274 | | |
| 275 | | |
| 276 | | : |
| 277 | | _ASEOF |
| 278 | | }; then |
| 279 | | CONFIG_SHELL=$as_shell |
| 280 | | as_have_required=yes |
| 281 | | if { "$as_shell" 2> /dev/null <<\_ASEOF |
| 282 | | if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then |
| 283 | | emulate sh |
| 284 | | NULLCMD=: |
| 285 | | # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which |
| 286 | | # is contrary to our usage. Disable this feature. |
| 287 | | alias -g '${1+"$@"}'='"$@"' |
| 288 | | setopt NO_GLOB_SUBST |
| 289 | | else |
| 290 | | case `(set -o) 2>/dev/null` in |
| 291 | | *posix*) set -o posix ;; |
| 292 | | esac |
| 293 | | |
| 294 | | fi |
| 295 | | |
| 296 | | |
| 297 | | : |
| 298 | | (as_func_return () { |
| 299 | | (exit $1) |
| 300 | | } |
| 301 | | as_func_success () { |
| 302 | | as_func_return 0 |
| 303 | | } |
| 304 | | as_func_failure () { |
| 305 | | as_func_return 1 |
| 306 | | } |
| 307 | | as_func_ret_success () { |
| 308 | | return 0 |
| 309 | | } |
| 310 | | as_func_ret_failure () { |
| 311 | | return 1 |
| 312 | | } |
| 313 | | |
| 314 | | exitcode=0 |
| 315 | | if as_func_success; then |
| 316 | | : |
| 317 | | else |
| 318 | | exitcode=1 |
| 319 | | echo as_func_success failed. |
| 320 | | fi |
| 321 | | |
| 322 | | if as_func_failure; then |
| 323 | | exitcode=1 |
| 324 | | echo as_func_failure succeeded. |
| 325 | | fi |
| 326 | | |
| 327 | | if as_func_ret_success; then |
| 328 | | : |
| 329 | | else |
| 330 | | exitcode=1 |
| 331 | | echo as_func_ret_success failed. |
| 332 | | fi |
| 333 | | |
| 334 | | if as_func_ret_failure; then |
| 335 | | exitcode=1 |
| 336 | | echo as_func_ret_failure succeeded. |
| 337 | | fi |
| 338 | | |
| 339 | | if ( set x; as_func_ret_success y && test x = "$1" ); then |
| 340 | | : |
| 341 | | else |
| 342 | | exitcode=1 |
| 343 | | echo positional parameters were not saved. |
| 344 | | fi |
| 345 | | |
| 346 | | test $exitcode = 0) || { (exit 1); exit 1; } |
| 347 | | |
| 348 | | ( |
| 349 | | as_lineno_1=$LINENO |
| 350 | | as_lineno_2=$LINENO |
| 351 | | test "x$as_lineno_1" != "x$as_lineno_2" && |
| 352 | | test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2") || { (exit 1); exit 1; } |
| 353 | | |
| 354 | | _ASEOF |
| 355 | | }; then |
| 356 | | break |
| 357 | | fi |
| 358 | | |
| 359 | | fi |
| 360 | | |
| 361 | | done |
| 362 | | |
| 363 | | if test "x$CONFIG_SHELL" != x; then |
| 364 | | for as_var in BASH_ENV ENV |
| 365 | | do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var |
| 366 | | done |
| 367 | | export CONFIG_SHELL |
| 368 | | exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"} |
| 369 | | fi |
| 370 | | |
| 371 | | |
| 372 | | if test $as_have_required = no; then |
| 373 | | echo This script requires a shell more modern than all the |
| 374 | | echo shells that I found on your system. Please install a |
| 375 | | echo modern shell, or manually run the script under such a |
| 376 | | echo shell if you do have one. |
| 377 | | { (exit 1); exit 1; } |
| 378 | | fi |
| 379 | | |
| 380 | | |
| 381 | | fi |
| 382 | | |
| 383 | | fi |
| 384 | | |
| 385 | | |
| 386 | | |
| 387 | | (eval "as_func_return () { |
| 388 | | (exit \$1) |
| 389 | | } |
| 390 | | as_func_success () { |
| 391 | | as_func_return 0 |
| 392 | | } |
| 393 | | as_func_failure () { |
| 394 | | as_func_return 1 |
| 395 | | } |
| 396 | | as_func_ret_success () { |
| 397 | | return 0 |
| 398 | | } |
| 399 | | as_func_ret_failure () { |
| 400 | | return 1 |
| 401 | | } |
| 402 | | |
| 403 | | exitcode=0 |
| 404 | | if as_func_success; then |
| 405 | | : |
| 406 | | else |
| 407 | | exitcode=1 |
| 408 | | echo as_func_success failed. |
| 409 | | fi |
| 410 | | |
| 411 | | if as_func_failure; then |
| 412 | | exitcode=1 |
| 413 | | echo as_func_failure succeeded. |
| 414 | | fi |
| 415 | | |
| 416 | | if as_func_ret_success; then |
| 417 | | : |
| 418 | | else |
| 419 | | exitcode=1 |
| 420 | | echo as_func_ret_success failed. |
| 421 | | fi |
| 422 | | |
| 423 | | if as_func_ret_failure; then |
| 424 | | exitcode=1 |
| 425 | | echo as_func_ret_failure succeeded. |
| 426 | | fi |
| 427 | | |
| 428 | | if ( set x; as_func_ret_success y && test x = \"\$1\" ); then |
| 429 | | : |
| 430 | | else |
| 431 | | exitcode=1 |
| 432 | | echo positional parameters were not saved. |
| 433 | | fi |
| 434 | | |
| 435 | | test \$exitcode = 0") || { |
| 436 | | echo No shell found that supports shell functions. |
| 437 | | echo Please tell bug-autoconf@gnu.org about your system, |
| 438 | | echo including any error possibly output before this message. |
| 439 | | echo This can help us improve future autoconf versions. |
| 440 | | echo Configuration will now proceed without shell functions. |
| 441 | | } |
| 442 | | |
| 443 | | |
| 444 | | |
| 445 | | as_lineno_1=$LINENO |
| 446 | | as_lineno_2=$LINENO |
| 447 | | test "x$as_lineno_1" != "x$as_lineno_2" && |
| 448 | | test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || { |
| 449 | | |
| 450 | | # Create $as_me.lineno as a copy of $as_myself, but with $LINENO |
| 451 | | # uniformly replaced by the line number. The first 'sed' inserts a |
| 452 | | # line-number line after each line using $LINENO; the second 'sed' |
| 453 | | # does the real work. The second script uses 'N' to pair each |
| 454 | | # line-number line with the line containing $LINENO, and appends |
| 455 | | # trailing '-' during substitution so that $LINENO is not a special |
| 456 | | # case at line end. |
| 457 | | # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the |
| 458 | | # scripts with optimization help from Paolo Bonzini. Blame Lee |
| 459 | | # E. McMahon (1931-1989) for sed's syntax. :-) |
| | 432 | # Avoid depending upon Character Ranges. |
| | 433 | as_cr_letters='abcdefghijklmnopqrstuvwxyz' |
| | 434 | as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' |
| | 435 | as_cr_Letters=$as_cr_letters$as_cr_LETTERS |
| | 436 | as_cr_digits='0123456789' |
| | 437 | as_cr_alnum=$as_cr_Letters$as_cr_digits |
| | 438 | |
| | 439 | |
| | 440 | as_lineno_1=$LINENO as_lineno_1a=$LINENO |
| | 441 | as_lineno_2=$LINENO as_lineno_2a=$LINENO |
| | 442 | eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && |
| | 443 | test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { |
| | 444 | # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) |
| | 1501 | |
| | 1502 | ## ------------------------ ## |
| | 1503 | ## Autoconf initialization. ## |
| | 1504 | ## ------------------------ ## |
| | 1505 | |
| | 1506 | # ac_fn_c_try_compile LINENO |
| | 1507 | # -------------------------- |
| | 1508 | # Try to compile conftest.$ac_ext, and return whether this succeeded. |
| | 1509 | ac_fn_c_try_compile () |
| | 1510 | { |
| | 1511 | as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack |
| | 1512 | rm -f conftest.$ac_objext |
| | 1513 | if { { ac_try="$ac_compile" |
| | 1514 | case "(($ac_try" in |
| | 1515 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 1516 | *) ac_try_echo=$ac_try;; |
| | 1517 | esac |
| | 1518 | eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" |
| | 1519 | $as_echo "$ac_try_echo"; } >&5 |
| | 1520 | (eval "$ac_compile") 2>conftest.err |
| | 1521 | ac_status=$? |
| | 1522 | if test -s conftest.err; then |
| | 1523 | grep -v '^ *+' conftest.err >conftest.er1 |
| | 1524 | cat conftest.er1 >&5 |
| | 1525 | mv -f conftest.er1 conftest.err |
| | 1526 | fi |
| | 1527 | $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 |
| | 1528 | test $ac_status = 0; } && { |
| | 1529 | test -z "$ac_c_werror_flag" || |
| | 1530 | test ! -s conftest.err |
| | 1531 | } && test -s conftest.$ac_objext; then : |
| | 1532 | ac_retval=0 |
| | 1533 | else |
| | 1534 | $as_echo "$as_me: failed program was:" >&5 |
| | 1535 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 1536 | |
| | 1537 | ac_retval=1 |
| | 1538 | fi |
| | 1539 | eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno |
| | 1540 | as_fn_set_status $ac_retval |
| | 1541 | |
| | 1542 | } # ac_fn_c_try_compile |
| | 1543 | |
| | 1544 | # ac_fn_cxx_try_compile LINENO |
| | 1545 | # ---------------------------- |
| | 1546 | # Try to compile conftest.$ac_ext, and return whether this succeeded. |
| | 1547 | ac_fn_cxx_try_compile () |
| | 1548 | { |
| | 1549 | as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack |
| | 1550 | rm -f conftest.$ac_objext |
| | 1551 | if { { ac_try="$ac_compile" |
| | 1552 | case "(($ac_try" in |
| | 1553 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 1554 | *) ac_try_echo=$ac_try;; |
| | 1555 | esac |
| | 1556 | eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" |
| | 1557 | $as_echo "$ac_try_echo"; } >&5 |
| | 1558 | (eval "$ac_compile") 2>conftest.err |
| | 1559 | ac_status=$? |
| | 1560 | if test -s conftest.err; then |
| | 1561 | grep -v '^ *+' conftest.err >conftest.er1 |
| | 1562 | cat conftest.er1 >&5 |
| | 1563 | mv -f conftest.er1 conftest.err |
| | 1564 | fi |
| | 1565 | $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 |
| | 1566 | test $ac_status = 0; } && { |
| | 1567 | test -z "$ac_cxx_werror_flag" || |
| | 1568 | test ! -s conftest.err |
| | 1569 | } && test -s conftest.$ac_objext; then : |
| | 1570 | ac_retval=0 |
| | 1571 | else |
| | 1572 | $as_echo "$as_me: failed program was:" >&5 |
| | 1573 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 1574 | |
| | 1575 | ac_retval=1 |
| | 1576 | fi |
| | 1577 | eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno |
| | 1578 | as_fn_set_status $ac_retval |
| | 1579 | |
| | 1580 | } # ac_fn_cxx_try_compile |
| | 1581 | |
| | 1582 | # ac_fn_c_try_link LINENO |
| | 1583 | # ----------------------- |
| | 1584 | # Try to link conftest.$ac_ext, and return whether this succeeded. |
| | 1585 | ac_fn_c_try_link () |
| | 1586 | { |
| | 1587 | as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack |
| | 1588 | rm -f conftest.$ac_objext conftest$ac_exeext |
| | 1589 | if { { ac_try="$ac_link" |
| | 1590 | case "(($ac_try" in |
| | 1591 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 1592 | *) ac_try_echo=$ac_try;; |
| | 1593 | esac |
| | 1594 | eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" |
| | 1595 | $as_echo "$ac_try_echo"; } >&5 |
| | 1596 | (eval "$ac_link") 2>conftest.err |
| | 1597 | ac_status=$? |
| | 1598 | if test -s conftest.err; then |
| | 1599 | grep -v '^ *+' conftest.err >conftest.er1 |
| | 1600 | cat conftest.er1 >&5 |
| | 1601 | mv -f conftest.er1 conftest.err |
| | 1602 | fi |
| | 1603 | $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 |
| | 1604 | test $ac_status = 0; } && { |
| | 1605 | test -z "$ac_c_werror_flag" || |
| | 1606 | test ! -s conftest.err |
| | 1607 | } && test -s conftest$ac_exeext && { |
| | 1608 | test "$cross_compiling" = yes || |
| | 1609 | $as_test_x conftest$ac_exeext |
| | 1610 | }; then : |
| | 1611 | ac_retval=0 |
| | 1612 | else |
| | 1613 | $as_echo "$as_me: failed program was:" >&5 |
| | 1614 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 1615 | |
| | 1616 | ac_retval=1 |
| | 1617 | fi |
| | 1618 | # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information |
| | 1619 | # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would |
| | 1620 | # interfere with the next link command; also delete a directory that is |
| | 1621 | # left behind by Apple's compiler. We do this before executing the actions. |
| | 1622 | rm -rf conftest.dSYM conftest_ipa8_conftest.oo |
| | 1623 | eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno |
| | 1624 | as_fn_set_status $ac_retval |
| | 1625 | |
| | 1626 | } # ac_fn_c_try_link |
| | 1627 | |
| | 1628 | # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES |
| | 1629 | # ------------------------------------------------------- |
| | 1630 | # Tests whether HEADER exists and can be compiled using the include files in |
| | 1631 | # INCLUDES, setting the cache variable VAR accordingly. |
| | 1632 | ac_fn_c_check_header_compile () |
| | 1633 | { |
| | 1634 | as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack |
| | 1635 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 |
| | 1636 | $as_echo_n "checking for $2... " >&6; } |
| | 1637 | if eval \${$3+:} false; then : |
| | 1638 | $as_echo_n "(cached) " >&6 |
| | 1639 | else |
| | 1640 | cat confdefs.h - <<_ACEOF >conftest.$ac_ext |
| | 1641 | /* end confdefs.h. */ |
| | 1642 | $4 |
| | 1643 | #include <$2> |
| | 1644 | _ACEOF |
| | 1645 | if ac_fn_c_try_compile "$LINENO"; then : |
| | 1646 | eval "$3=yes" |
| | 1647 | else |
| | 1648 | eval "$3=no" |
| | 1649 | fi |
| | 1650 | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| | 1651 | fi |
| | 1652 | eval ac_res=\$$3 |
| | 1653 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 |
| | 1654 | $as_echo "$ac_res" >&6; } |
| | 1655 | eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno |
| | 1656 | |
| | 1657 | } # ac_fn_c_check_header_compile |
| | 1658 | |
| | 1659 | # ac_fn_c_try_cpp LINENO |
| | 1660 | # ---------------------- |
| | 1661 | # Try to preprocess conftest.$ac_ext, and return whether this succeeded. |
| | 1662 | ac_fn_c_try_cpp () |
| | 1663 | { |
| | 1664 | as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack |
| | 1665 | if { { ac_try="$ac_cpp conftest.$ac_ext" |
| | 1666 | case "(($ac_try" in |
| | 1667 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 1668 | *) ac_try_echo=$ac_try;; |
| | 1669 | esac |
| | 1670 | eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" |
| | 1671 | $as_echo "$ac_try_echo"; } >&5 |
| | 1672 | (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err |
| | 1673 | ac_status=$? |
| | 1674 | if test -s conftest.err; then |
| | 1675 | grep -v '^ *+' conftest.err >conftest.er1 |
| | 1676 | cat conftest.er1 >&5 |
| | 1677 | mv -f conftest.er1 conftest.err |
| | 1678 | fi |
| | 1679 | $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 |
| | 1680 | test $ac_status = 0; } > conftest.i && { |
| | 1681 | test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || |
| | 1682 | test ! -s conftest.err |
| | 1683 | }; then : |
| | 1684 | ac_retval=0 |
| | 1685 | else |
| | 1686 | $as_echo "$as_me: failed program was:" >&5 |
| | 1687 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 1688 | |
| | 1689 | ac_retval=1 |
| | 1690 | fi |
| | 1691 | eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno |
| | 1692 | as_fn_set_status $ac_retval |
| | 1693 | |
| | 1694 | } # ac_fn_c_try_cpp |
| | 1695 | |
| | 1696 | # ac_fn_c_try_run LINENO |
| | 1697 | # ---------------------- |
| | 1698 | # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes |
| | 1699 | # that executables *can* be run. |
| | 1700 | ac_fn_c_try_run () |
| | 1701 | { |
| | 1702 | as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack |
| | 1703 | if { { ac_try="$ac_link" |
| | 1704 | case "(($ac_try" in |
| | 1705 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 1706 | *) ac_try_echo=$ac_try;; |
| | 1707 | esac |
| | 1708 | eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" |
| | 1709 | $as_echo "$ac_try_echo"; } >&5 |
| | 1710 | (eval "$ac_link") 2>&5 |
| | 1711 | ac_status=$? |
| | 1712 | $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 |
| | 1713 | test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' |
| | 1714 | { { case "(($ac_try" in |
| | 1715 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 1716 | *) ac_try_echo=$ac_try;; |
| | 1717 | esac |
| | 1718 | eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" |
| | 1719 | $as_echo "$ac_try_echo"; } >&5 |
| | 1720 | (eval "$ac_try") 2>&5 |
| | 1721 | ac_status=$? |
| | 1722 | $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 |
| | 1723 | test $ac_status = 0; }; }; then : |
| | 1724 | ac_retval=0 |
| | 1725 | else |
| | 1726 | $as_echo "$as_me: program exited with status $ac_status" >&5 |
| | 1727 | $as_echo "$as_me: failed program was:" >&5 |
| | 1728 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 1729 | |
| | 1730 | ac_retval=$ac_status |
| | 1731 | fi |
| | 1732 | rm -rf conftest.dSYM conftest_ipa8_conftest.oo |
| | 1733 | eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno |
| | 1734 | as_fn_set_status $ac_retval |
| | 1735 | |
| | 1736 | } # ac_fn_c_try_run |
| | 1737 | |
| | 1738 | # ac_fn_c_check_func LINENO FUNC VAR |
| | 1739 | # ---------------------------------- |
| | 1740 | # Tests whether FUNC exists, setting the cache variable VAR accordingly |
| | 1741 | ac_fn_c_check_func () |
| | 1742 | { |
| | 1743 | as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack |
| | 1744 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 |
| | 1745 | $as_echo_n "checking for $2... " >&6; } |
| | 1746 | if eval \${$3+:} false; then : |
| | 1747 | $as_echo_n "(cached) " >&6 |
| | 1748 | else |
| | 1749 | cat confdefs.h - <<_ACEOF >conftest.$ac_ext |
| | 1750 | /* end confdefs.h. */ |
| | 1751 | /* Define $2 to an innocuous variant, in case <limits.h> declares $2. |
| | 1752 | For example, HP-UX 11i <limits.h> declares gettimeofday. */ |
| | 1753 | #define $2 innocuous_$2 |
| | 1754 | |
| | 1755 | /* System header to define __stub macros and hopefully few prototypes, |
| | 1756 | which can conflict with char $2 (); below. |
| | 1757 | Prefer <limits.h> to <assert.h> if __STDC__ is defined, since |
| | 1758 | <limits.h> exists even on freestanding compilers. */ |
| | 1759 | |
| | 1760 | #ifdef __STDC__ |
| | 1761 | # include <limits.h> |
| | 1762 | #else |
| | 1763 | # include <assert.h> |
| | 1764 | #endif |
| | 1765 | |
| | 1766 | #undef $2 |
| | 1767 | |
| | 1768 | /* Override any GCC internal prototype to avoid an error. |
| | 1769 | Use char because int might match the return type of a GCC |
| | 1770 | builtin and then its argument prototype would still apply. */ |
| | 1771 | #ifdef __cplusplus |
| | 1772 | extern "C" |
| | 1773 | #endif |
| | 1774 | char $2 (); |
| | 1775 | /* The GNU C library defines this for functions which it implements |
| | 1776 | to always fail with ENOSYS. Some functions are actually named |
| | 1777 | something starting with __ and the normal name is an alias. */ |
| | 1778 | #if defined __stub_$2 || defined __stub___$2 |
| | 1779 | choke me |
| | 1780 | #endif |
| | 1781 | |
| | 1782 | int |
| | 1783 | main () |
| | 1784 | { |
| | 1785 | return $2 (); |
| | 1786 | ; |
| | 1787 | return 0; |
| | 1788 | } |
| | 1789 | _ACEOF |
| | 1790 | if ac_fn_c_try_link "$LINENO"; then : |
| | 1791 | eval "$3=yes" |
| | 1792 | else |
| | 1793 | eval "$3=no" |
| | 1794 | fi |
| | 1795 | rm -f core conftest.err conftest.$ac_objext \ |
| | 1796 | conftest$ac_exeext conftest.$ac_ext |
| | 1797 | fi |
| | 1798 | eval ac_res=\$$3 |
| | 1799 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 |
| | 1800 | $as_echo "$ac_res" >&6; } |
| | 1801 | eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno |
| | 1802 | |
| | 1803 | } # ac_fn_c_check_func |
| | 1804 | |
| | 1805 | # ac_fn_cxx_try_cpp LINENO |
| | 1806 | # ------------------------ |
| | 1807 | # Try to preprocess conftest.$ac_ext, and return whether this succeeded. |
| | 1808 | ac_fn_cxx_try_cpp () |
| | 1809 | { |
| | 1810 | as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack |
| | 1811 | if { { ac_try="$ac_cpp conftest.$ac_ext" |
| | 1812 | case "(($ac_try" in |
| | 1813 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 1814 | *) ac_try_echo=$ac_try;; |
| | 1815 | esac |
| | 1816 | eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" |
| | 1817 | $as_echo "$ac_try_echo"; } >&5 |
| | 1818 | (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err |
| | 1819 | ac_status=$? |
| | 1820 | if test -s conftest.err; then |
| | 1821 | grep -v '^ *+' conftest.err >conftest.er1 |
| | 1822 | cat conftest.er1 >&5 |
| | 1823 | mv -f conftest.er1 conftest.err |
| | 1824 | fi |
| | 1825 | $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 |
| | 1826 | test $ac_status = 0; } > conftest.i && { |
| | 1827 | test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" || |
| | 1828 | test ! -s conftest.err |
| | 1829 | }; then : |
| | 1830 | ac_retval=0 |
| | 1831 | else |
| | 1832 | $as_echo "$as_me: failed program was:" >&5 |
| | 1833 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 1834 | |
| | 1835 | ac_retval=1 |
| | 1836 | fi |
| | 1837 | eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno |
| | 1838 | as_fn_set_status $ac_retval |
| | 1839 | |
| | 1840 | } # ac_fn_cxx_try_cpp |
| | 1841 | |
| | 1842 | # ac_fn_cxx_try_link LINENO |
| | 1843 | # ------------------------- |
| | 1844 | # Try to link conftest.$ac_ext, and return whether this succeeded. |
| | 1845 | ac_fn_cxx_try_link () |
| | 1846 | { |
| | 1847 | as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack |
| | 1848 | rm -f conftest.$ac_objext conftest$ac_exeext |
| | 1849 | if { { ac_try="$ac_link" |
| | 1850 | case "(($ac_try" in |
| | 1851 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 1852 | *) ac_try_echo=$ac_try;; |
| | 1853 | esac |
| | 1854 | eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" |
| | 1855 | $as_echo "$ac_try_echo"; } >&5 |
| | 1856 | (eval "$ac_link") 2>conftest.err |
| | 1857 | ac_status=$? |
| | 1858 | if test -s conftest.err; then |
| | 1859 | grep -v '^ *+' conftest.err >conftest.er1 |
| | 1860 | cat conftest.er1 >&5 |
| | 1861 | mv -f conftest.er1 conftest.err |
| | 1862 | fi |
| | 1863 | $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 |
| | 1864 | test $ac_status = 0; } && { |
| | 1865 | test -z "$ac_cxx_werror_flag" || |
| | 1866 | test ! -s conftest.err |
| | 1867 | } && test -s conftest$ac_exeext && { |
| | 1868 | test "$cross_compiling" = yes || |
| | 1869 | $as_test_x conftest$ac_exeext |
| | 1870 | }; then : |
| | 1871 | ac_retval=0 |
| | 1872 | else |
| | 1873 | $as_echo "$as_me: failed program was:" >&5 |
| | 1874 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 1875 | |
| | 1876 | ac_retval=1 |
| | 1877 | fi |
| | 1878 | # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information |
| | 1879 | # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would |
| | 1880 | # interfere with the next link command; also delete a directory that is |
| | 1881 | # left behind by Apple's compiler. We do this before executing the actions. |
| | 1882 | rm -rf conftest.dSYM conftest_ipa8_conftest.oo |
| | 1883 | eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno |
| | 1884 | as_fn_set_status $ac_retval |
| | 1885 | |
| | 1886 | } # ac_fn_cxx_try_link |
| | 1887 | |
| | 1888 | # ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES |
| | 1889 | # ------------------------------------------------------- |
| | 1890 | # Tests whether HEADER exists, giving a warning if it cannot be compiled using |
| | 1891 | # the include files in INCLUDES and setting the cache variable VAR |
| | 1892 | # accordingly. |
| | 1893 | ac_fn_c_check_header_mongrel () |
| | 1894 | { |
| | 1895 | as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack |
| | 1896 | if eval \${$3+:} false; then : |
| | 1897 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 |
| | 1898 | $as_echo_n "checking for $2... " >&6; } |
| | 1899 | if eval \${$3+:} false; then : |
| | 1900 | $as_echo_n "(cached) " >&6 |
| | 1901 | fi |
| | 1902 | eval ac_res=\$$3 |
| | 1903 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 |
| | 1904 | $as_echo "$ac_res" >&6; } |
| | 1905 | else |
| | 1906 | # Is the header compilable? |
| | 1907 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5 |
| | 1908 | $as_echo_n "checking $2 usability... " >&6; } |
| | 1909 | cat confdefs.h - <<_ACEOF >conftest.$ac_ext |
| | 1910 | /* end confdefs.h. */ |
| | 1911 | $4 |
| | 1912 | #include <$2> |
| | 1913 | _ACEOF |
| | 1914 | if ac_fn_c_try_compile "$LINENO"; then : |
| | 1915 | ac_header_compiler=yes |
| | 1916 | else |
| | 1917 | ac_header_compiler=no |
| | 1918 | fi |
| | 1919 | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| | 1920 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5 |
| | 1921 | $as_echo "$ac_header_compiler" >&6; } |
| | 1922 | |
| | 1923 | # Is the header present? |
| | 1924 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5 |
| | 1925 | $as_echo_n "checking $2 presence... " >&6; } |
| | 1926 | cat confdefs.h - <<_ACEOF >conftest.$ac_ext |
| | 1927 | /* end confdefs.h. */ |
| | 1928 | #include <$2> |
| | 1929 | _ACEOF |
| | 1930 | if ac_fn_c_try_cpp "$LINENO"; then : |
| | 1931 | ac_header_preproc=yes |
| | 1932 | else |
| | 1933 | ac_header_preproc=no |
| | 1934 | fi |
| | 1935 | rm -f conftest.err conftest.i conftest.$ac_ext |
| | 1936 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5 |
| | 1937 | $as_echo "$ac_header_preproc" >&6; } |
| | 1938 | |
| | 1939 | # So? What about this header? |
| | 1940 | case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #(( |
| | 1941 | yes:no: ) |
| | 1942 | { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5 |
| | 1943 | $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;} |
| | 1944 | { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 |
| | 1945 | $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} |
| | 1946 | ;; |
| | 1947 | no:yes:* ) |
| | 1948 | { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5 |
| | 1949 | $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;} |
| | 1950 | { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5 |
| | 1951 | $as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;} |
| | 1952 | { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5 |
| | 1953 | $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;} |
| | 1954 | { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5 |
| | 1955 | $as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;} |
| | 1956 | { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 |
| | 1957 | $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} |
| | 1958 | ( $as_echo "## --------------------------------------- ## |
| | 1959 | ## Report this to ren@mathematik.uni-kl.de ## |
| | 1960 | ## --------------------------------------- ##" |
| | 1961 | ) | sed "s/^/$as_me: WARNING: /" >&2 |
| | 1962 | ;; |
| | 1963 | esac |
| | 1964 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 |
| | 1965 | $as_echo_n "checking for $2... " >&6; } |
| | 1966 | if eval \${$3+:} false; then : |
| | 1967 | $as_echo_n "(cached) " >&6 |
| | 1968 | else |
| | 1969 | eval "$3=\$ac_header_compiler" |
| | 1970 | fi |
| | 1971 | eval ac_res=\$$3 |
| | 1972 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 |
| | 1973 | $as_echo "$ac_res" >&6; } |
| | 1974 | fi |
| | 1975 | eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno |
| | 1976 | |
| | 1977 | } # ac_fn_c_check_header_mongrel |
| 1791 | | # Checks for programs. |
| | 2334 | |
| | 2335 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable maintainer-specific portions of Makefiles" >&5 |
| | 2336 | $as_echo_n "checking whether to enable maintainer-specific portions of Makefiles... " >&6; } |
| | 2337 | # Check whether --enable-maintainer-mode was given. |
| | 2338 | if test "${enable_maintainer_mode+set}" = set; then : |
| | 2339 | enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval |
| | 2340 | else |
| | 2341 | USE_MAINTAINER_MODE=no |
| | 2342 | fi |
| | 2343 | |
| | 2344 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $USE_MAINTAINER_MODE" >&5 |
| | 2345 | $as_echo "$USE_MAINTAINER_MODE" >&6; } |
| | 2346 | if test $USE_MAINTAINER_MODE = yes; then |
| | 2347 | MAINTAINER_MODE_TRUE= |
| | 2348 | MAINTAINER_MODE_FALSE='#' |
| | 2349 | else |
| | 2350 | MAINTAINER_MODE_TRUE='#' |
| | 2351 | MAINTAINER_MODE_FALSE= |
| | 2352 | fi |
| | 2353 | |
| | 2354 | MAINT=$MAINTAINER_MODE_TRUE |
| | 2355 | |
| | 2356 | |
| | 2357 | am__api_version='1.11' |
| | 2358 | |
| | 2359 | ac_aux_dir= |
| | 2360 | for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do |
| | 2361 | if test -f "$ac_dir/install-sh"; then |
| | 2362 | ac_aux_dir=$ac_dir |
| | 2363 | ac_install_sh="$ac_aux_dir/install-sh -c" |
| | 2364 | break |
| | 2365 | elif test -f "$ac_dir/install.sh"; then |
| | 2366 | ac_aux_dir=$ac_dir |
| | 2367 | ac_install_sh="$ac_aux_dir/install.sh -c" |
| | 2368 | break |
| | 2369 | elif test -f "$ac_dir/shtool"; then |
| | 2370 | ac_aux_dir=$ac_dir |
| | 2371 | ac_install_sh="$ac_aux_dir/shtool install -c" |
| | 2372 | break |
| | 2373 | fi |
| | 2374 | done |
| | 2375 | if test -z "$ac_aux_dir"; then |
| | 2376 | as_fn_error $? "cannot find install-sh, install.sh, or shtool in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$LINENO" 5 |
| | 2377 | fi |
| | 2378 | |
| | 2379 | # These three variables are undocumented and unsupported, |
| | 2380 | # and are intended to be withdrawn in a future Autoconf release. |
| | 2381 | # They can cause serious problems if a builder's source tree is in a directory |
| | 2382 | # whose full name contains unusual characters. |
| | 2383 | ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var. |
| | 2384 | ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var. |
| | 2385 | ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. |
| | 2386 | |
| | 2387 | |
| | 2388 | # Find a good install program. We prefer a C program (faster), |
| | 2389 | # so one script is as good as another. But avoid the broken or |
| | 2390 | # incompatible versions: |
| | 2391 | # SysV /etc/install, /usr/sbin/install |
| | 2392 | # SunOS /usr/etc/install |
| | 2393 | # IRIX /sbin/install |
| | 2394 | # AIX /bin/install |
| | 2395 | # AmigaOS /C/install, which installs bootblocks on floppy discs |
| | 2396 | # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag |
| | 2397 | # AFS /usr/afsws/bin/install, which mishandles nonexistent args |
| | 2398 | # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" |
| | 2399 | # OS/2's system install, which has a completely different semantic |
| | 2400 | # ./install, which can be erroneously created by make from ./install.sh. |
| | 2401 | # Reject install programs that cannot install multiple files. |
| | 2402 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5 |
| | 2403 | $as_echo_n "checking for a BSD-compatible install... " >&6; } |
| | 2404 | if test -z "$INSTALL"; then |
| | 2405 | if ${ac_cv_path_install+:} false; then : |
| | 2406 | $as_echo_n "(cached) " >&6 |
| | 2407 | else |
| | 2408 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 2409 | for as_dir in $PATH |
| | 2410 | do |
| | 2411 | IFS=$as_save_IFS |
| | 2412 | test -z "$as_dir" && as_dir=. |
| | 2413 | # Account for people who put trailing slashes in PATH elements. |
| | 2414 | case $as_dir/ in #(( |
| | 2415 | ./ | .// | /[cC]/* | \ |
| | 2416 | /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \ |
| | 2417 | ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \ |
| | 2418 | /usr/ucb/* ) ;; |
| | 2419 | *) |
| | 2420 | # OSF1 and SCO ODT 3.0 have their own names for install. |
| | 2421 | # Don't use installbsd from OSF since it installs stuff as root |
| | 2422 | # by default. |
| | 2423 | for ac_prog in ginstall scoinst install; do |
| | 2424 | for ac_exec_ext in '' $ac_executable_extensions; do |
| | 2425 | if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then |
| | 2426 | if test $ac_prog = install && |
| | 2427 | grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then |
| | 2428 | # AIX install. It has an incompatible calling convention. |
| | 2429 | : |
| | 2430 | elif test $ac_prog = install && |
| | 2431 | grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then |
| | 2432 | # program-specific install script used by HP pwplus--don't use. |
| | 2433 | : |
| | 2434 | else |
| | 2435 | rm -rf conftest.one conftest.two conftest.dir |
| | 2436 | echo one > conftest.one |
| | 2437 | echo two > conftest.two |
| | 2438 | mkdir conftest.dir |
| | 2439 | if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" && |
| | 2440 | test -s conftest.one && test -s conftest.two && |
| | 2441 | test -s conftest.dir/conftest.one && |
| | 2442 | test -s conftest.dir/conftest.two |
| | 2443 | then |
| | 2444 | ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c" |
| | 2445 | break 3 |
| | 2446 | fi |
| | 2447 | fi |
| | 2448 | fi |
| | 2449 | done |
| | 2450 | done |
| | 2451 | ;; |
| | 2452 | esac |
| | 2453 | |
| | 2454 | done |
| | 2455 | IFS=$as_save_IFS |
| | 2456 | |
| | 2457 | rm -rf conftest.one conftest.two conftest.dir |
| | 2458 | |
| | 2459 | fi |
| | 2460 | if test "${ac_cv_path_install+set}" = set; then |
| | 2461 | INSTALL=$ac_cv_path_install |
| | 2462 | else |
| | 2463 | # As a last resort, use the slow shell script. Don't cache a |
| | 2464 | # value for INSTALL within a source directory, because that will |
| | 2465 | # break other packages using the cache if that directory is |
| | 2466 | # removed, or if the value is a relative name. |
| | 2467 | INSTALL=$ac_install_sh |
| | 2468 | fi |
| | 2469 | fi |
| | 2470 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5 |
| | 2471 | $as_echo "$INSTALL" >&6; } |
| | 2472 | |
| | 2473 | # Use test -z because SunOS4 sh mishandles braces in ${var-val}. |
| | 2474 | # It thinks the first close brace ends the variable substitution. |
| | 2475 | test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' |
| | 2476 | |
| | 2477 | test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}' |
| | 2478 | |
| | 2479 | test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' |
| | 2480 | |
| | 2481 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5 |
| | 2482 | $as_echo_n "checking whether build environment is sane... " >&6; } |
| | 2483 | # Just in case |
| | 2484 | sleep 1 |
| | 2485 | echo timestamp > conftest.file |
| | 2486 | # Reject unsafe characters in $srcdir or the absolute working directory |
| | 2487 | # name. Accept space and tab only in the latter. |
| | 2488 | am_lf=' |
| | 2489 | ' |
| | 2490 | case `pwd` in |
| | 2491 | *[\\\"\#\$\&\'\`$am_lf]*) |
| | 2492 | as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;; |
| | 2493 | esac |
| | 2494 | case $srcdir in |
| | 2495 | *[\\\"\#\$\&\'\`$am_lf\ \ ]*) |
| | 2496 | as_fn_error $? "unsafe srcdir value: \`$srcdir'" "$LINENO" 5;; |
| | 2497 | esac |
| | 2498 | |
| | 2499 | # Do `set' in a subshell so we don't clobber the current shell's |
| | 2500 | # arguments. Must try -L first in case configure is actually a |
| | 2501 | # symlink; some systems play weird games with the mod time of symlinks |
| | 2502 | # (eg FreeBSD returns the mod time of the symlink's containing |
| | 2503 | # directory). |
| | 2504 | if ( |
| | 2505 | set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null` |
| | 2506 | if test "$*" = "X"; then |
| | 2507 | # -L didn't work. |
| | 2508 | set X `ls -t "$srcdir/configure" conftest.file` |
| | 2509 | fi |
| | 2510 | rm -f conftest.file |
| | 2511 | if test "$*" != "X $srcdir/configure conftest.file" \ |
| | 2512 | && test "$*" != "X conftest.file $srcdir/configure"; then |
| | 2513 | |
| | 2514 | # If neither matched, then we have a broken ls. This can happen |
| | 2515 | # if, for instance, CONFIG_SHELL is bash and it inherits a |
| | 2516 | # broken ls alias from the environment. This has actually |
| | 2517 | # happened. Such a system could not be considered "sane". |
| | 2518 | as_fn_error $? "ls -t appears to fail. Make sure there is not a broken |
| | 2519 | alias in your environment" "$LINENO" 5 |
| | 2520 | fi |
| | 2521 | |
| | 2522 | test "$2" = conftest.file |
| | 2523 | ) |
| | 2524 | then |
| | 2525 | # Ok. |
| | 2526 | : |
| | 2527 | else |
| | 2528 | as_fn_error $? "newly created file is older than distributed files! |
| | 2529 | Check your system clock" "$LINENO" 5 |
| | 2530 | fi |
| | 2531 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 |
| | 2532 | $as_echo "yes" >&6; } |
| | 2533 | test "$program_prefix" != NONE && |
| | 2534 | program_transform_name="s&^&$program_prefix&;$program_transform_name" |
| | 2535 | # Use a double $ so make ignores it. |
| | 2536 | test "$program_suffix" != NONE && |
| | 2537 | program_transform_name="s&\$&$program_suffix&;$program_transform_name" |
| | 2538 | # Double any \ or $. |
| | 2539 | # By default was `s,x,x', remove it if useless. |
| | 2540 | ac_script='s/[\\$]/&&/g;s/;s,x,x,$//' |
| | 2541 | program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"` |
| | 2542 | |
| | 2543 | # expand $ac_aux_dir to an absolute path |
| | 2544 | am_aux_dir=`cd $ac_aux_dir && pwd` |
| | 2545 | |
| | 2546 | if test x"${MISSING+set}" != xset; then |
| | 2547 | case $am_aux_dir in |
| | 2548 | *\ * | *\ *) |
| | 2549 | MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;; |
| | 2550 | *) |
| | 2551 | MISSING="\${SHELL} $am_aux_dir/missing" ;; |
| | 2552 | esac |
| | 2553 | fi |
| | 2554 | # Use eval to expand $SHELL |
| | 2555 | if eval "$MISSING --run true"; then |
| | 2556 | am_missing_run="$MISSING --run " |
| | 2557 | else |
| | 2558 | am_missing_run= |
| | 2559 | { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`missing' script is too old or missing" >&5 |
| | 2560 | $as_echo "$as_me: WARNING: \`missing' script is too old or missing" >&2;} |
| | 2561 | fi |
| | 2562 | |
| | 2563 | if test x"${install_sh}" != xset; then |
| | 2564 | case $am_aux_dir in |
| | 2565 | *\ * | *\ *) |
| | 2566 | install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;; |
| | 2567 | *) |
| | 2568 | install_sh="\${SHELL} $am_aux_dir/install-sh" |
| | 2569 | esac |
| | 2570 | fi |
| | 2571 | |
| | 2572 | # Installed binaries are usually stripped using `strip' when the user |
| | 2573 | # run `make install-strip'. However `strip' might not be the right |
| | 2574 | # tool to use in cross-compilation environments, therefore Automake |
| | 2575 | # will honor the `STRIP' environment variable to overrule this program. |
| | 2576 | if test "$cross_compiling" != no; then |
| | 2577 | if test -n "$ac_tool_prefix"; then |
| | 2578 | # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. |
| | 2579 | set dummy ${ac_tool_prefix}strip; ac_word=$2 |
| | 2580 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 |
| | 2581 | $as_echo_n "checking for $ac_word... " >&6; } |
| | 2582 | if ${ac_cv_prog_STRIP+:} false; then : |
| | 2583 | $as_echo_n "(cached) " >&6 |
| | 2584 | else |
| | 2585 | if test -n "$STRIP"; then |
| | 2586 | ac_cv_prog_STRIP="$STRIP" # Let the user override the test. |
| | 2587 | else |
| | 2588 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 2589 | for as_dir in $PATH |
| | 2590 | do |
| | 2591 | IFS=$as_save_IFS |
| | 2592 | test -z "$as_dir" && as_dir=. |
| | 2593 | for ac_exec_ext in '' $ac_executable_extensions; do |
| | 2594 | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| | 2595 | ac_cv_prog_STRIP="${ac_tool_prefix}strip" |
| | 2596 | $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| | 2597 | break 2 |
| | 2598 | fi |
| | 2599 | done |
| | 2600 | done |
| | 2601 | IFS=$as_save_IFS |
| | 2602 | |
| | 2603 | fi |
| | 2604 | fi |
| | 2605 | STRIP=$ac_cv_prog_STRIP |
| | 2606 | if test -n "$STRIP"; then |
| | 2607 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 |
| | 2608 | $as_echo "$STRIP" >&6; } |
| | 2609 | else |
| | 2610 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 |
| | 2611 | $as_echo "no" >&6; } |
| | 2612 | fi |
| | 2613 | |
| | 2614 | |
| | 2615 | fi |
| | 2616 | if test -z "$ac_cv_prog_STRIP"; then |
| | 2617 | ac_ct_STRIP=$STRIP |
| | 2618 | # Extract the first word of "strip", so it can be a program name with args. |
| | 2619 | set dummy strip; ac_word=$2 |
| | 2620 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 |
| | 2621 | $as_echo_n "checking for $ac_word... " >&6; } |
| | 2622 | if ${ac_cv_prog_ac_ct_STRIP+:} false; then : |
| | 2623 | $as_echo_n "(cached) " >&6 |
| | 2624 | else |
| | 2625 | if test -n "$ac_ct_STRIP"; then |
| | 2626 | ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. |
| | 2627 | else |
| | 2628 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 2629 | for as_dir in $PATH |
| | 2630 | do |
| | 2631 | IFS=$as_save_IFS |
| | 2632 | test -z "$as_dir" && as_dir=. |
| | 2633 | for ac_exec_ext in '' $ac_executable_extensions; do |
| | 2634 | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| | 2635 | ac_cv_prog_ac_ct_STRIP="strip" |
| | 2636 | $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| | 2637 | break 2 |
| | 2638 | fi |
| | 2639 | done |
| | 2640 | done |
| | 2641 | IFS=$as_save_IFS |
| | 2642 | |
| | 2643 | fi |
| | 2644 | fi |
| | 2645 | ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP |
| | 2646 | if test -n "$ac_ct_STRIP"; then |
| | 2647 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 |
| | 2648 | $as_echo "$ac_ct_STRIP" >&6; } |
| | 2649 | else |
| | 2650 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 |
| | 2651 | $as_echo "no" >&6; } |
| | 2652 | fi |
| | 2653 | |
| | 2654 | if test "x$ac_ct_STRIP" = x; then |
| | 2655 | STRIP=":" |
| | 2656 | else |
| | 2657 | case $cross_compiling:$ac_tool_warned in |
| | 2658 | yes:) |
| | 2659 | { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 |
| | 2660 | $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} |
| | 2661 | ac_tool_warned=yes ;; |
| | 2662 | esac |
| | 2663 | STRIP=$ac_ct_STRIP |
| | 2664 | fi |
| | 2665 | else |
| | 2666 | STRIP="$ac_cv_prog_STRIP" |
| | 2667 | fi |
| | 2668 | |
| | 2669 | fi |
| | 2670 | INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s" |
| | 2671 | |
| | 2672 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a thread-safe mkdir -p" >&5 |
| | 2673 | $as_echo_n "checking for a thread-safe mkdir -p... " >&6; } |
| | 2674 | if test -z "$MKDIR_P"; then |
| | 2675 | if ${ac_cv_path_mkdir+:} false; then : |
| | 2676 | $as_echo_n "(cached) " >&6 |
| | 2677 | else |
| | 2678 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 2679 | for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin |
| | 2680 | do |
| | 2681 | IFS=$as_save_IFS |
| | 2682 | test -z "$as_dir" && as_dir=. |
| | 2683 | for ac_prog in mkdir gmkdir; do |
| | 2684 | for ac_exec_ext in '' $ac_executable_extensions; do |
| | 2685 | { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; } || continue |
| | 2686 | case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #( |
| | 2687 | 'mkdir (GNU coreutils) '* | \ |
| | 2688 | 'mkdir (coreutils) '* | \ |
| | 2689 | 'mkdir (fileutils) '4.1*) |
| | 2690 | ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext |
| | 2691 | break 3;; |
| | 2692 | esac |
| | 2693 | done |
| | 2694 | done |
| | 2695 | done |
| | 2696 | IFS=$as_save_IFS |
| | 2697 | |
| | 2698 | fi |
| | 2699 | |
| | 2700 | test -d ./--version && rmdir ./--version |
| | 2701 | if test "${ac_cv_path_mkdir+set}" = set; then |
| | 2702 | MKDIR_P="$ac_cv_path_mkdir -p" |
| | 2703 | else |
| | 2704 | # As a last resort, use the slow shell script. Don't cache a |
| | 2705 | # value for MKDIR_P within a source directory, because that will |
| | 2706 | # break other packages using the cache if that directory is |
| | 2707 | # removed, or if the value is a relative name. |
| | 2708 | MKDIR_P="$ac_install_sh -d" |
| | 2709 | fi |
| | 2710 | fi |
| | 2711 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5 |
| | 2712 | $as_echo "$MKDIR_P" >&6; } |
| | 2713 | |
| | 2714 | mkdir_p="$MKDIR_P" |
| | 2715 | case $mkdir_p in |
| | 2716 | [\\/$]* | ?:[\\/]*) ;; |
| | 2717 | */*) mkdir_p="\$(top_builddir)/$mkdir_p" ;; |
| | 2718 | esac |
| | 2719 | |
| | 2720 | for ac_prog in gawk mawk nawk awk |
| | 2721 | do |
| | 2722 | # Extract the first word of "$ac_prog", so it can be a program name with args. |
| | 2723 | set dummy $ac_prog; ac_word=$2 |
| | 2724 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 |
| | 2725 | $as_echo_n "checking for $ac_word... " >&6; } |
| | 2726 | if ${ac_cv_prog_AWK+:} false; then : |
| | 2727 | $as_echo_n "(cached) " >&6 |
| | 2728 | else |
| | 2729 | if test -n "$AWK"; then |
| | 2730 | ac_cv_prog_AWK="$AWK" # Let the user override the test. |
| | 2731 | else |
| | 2732 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 2733 | for as_dir in $PATH |
| | 2734 | do |
| | 2735 | IFS=$as_save_IFS |
| | 2736 | test -z "$as_dir" && as_dir=. |
| | 2737 | for ac_exec_ext in '' $ac_executable_extensions; do |
| | 2738 | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| | 2739 | ac_cv_prog_AWK="$ac_prog" |
| | 2740 | $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| | 2741 | break 2 |
| | 2742 | fi |
| | 2743 | done |
| | 2744 | done |
| | 2745 | IFS=$as_save_IFS |
| | 2746 | |
| | 2747 | fi |
| | 2748 | fi |
| | 2749 | AWK=$ac_cv_prog_AWK |
| | 2750 | if test -n "$AWK"; then |
| | 2751 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 |
| | 2752 | $as_echo "$AWK" >&6; } |
| | 2753 | else |
| | 2754 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 |
| | 2755 | $as_echo "no" >&6; } |
| | 2756 | fi |
| | 2757 | |
| | 2758 | |
| | 2759 | test -n "$AWK" && break |
| | 2760 | done |
| | 2761 | |
| | 2762 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5 |
| | 2763 | $as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; } |
| | 2764 | set x ${MAKE-make} |
| | 2765 | ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'` |
| | 2766 | if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then : |
| | 2767 | $as_echo_n "(cached) " >&6 |
| | 2768 | else |
| | 2769 | cat >conftest.make <<\_ACEOF |
| | 2770 | SHELL = /bin/sh |
| | 2771 | all: |
| | 2772 | @echo '@@@%%%=$(MAKE)=@@@%%%' |
| | 2773 | _ACEOF |
| | 2774 | # GNU make sometimes prints "make[1]: Entering ...", which would confuse us. |
| | 2775 | case `${MAKE-make} -f conftest.make 2>/dev/null` in |
| | 2776 | *@@@%%%=?*=@@@%%%*) |
| | 2777 | eval ac_cv_prog_make_${ac_make}_set=yes;; |
| | 2778 | *) |
| | 2779 | eval ac_cv_prog_make_${ac_make}_set=no;; |
| | 2780 | esac |
| | 2781 | rm -f conftest.make |
| | 2782 | fi |
| | 2783 | if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then |
| | 2784 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 |
| | 2785 | $as_echo "yes" >&6; } |
| | 2786 | SET_MAKE= |
| | 2787 | else |
| | 2788 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 |
| | 2789 | $as_echo "no" >&6; } |
| | 2790 | SET_MAKE="MAKE=${MAKE-make}" |
| | 2791 | fi |
| | 2792 | |
| | 2793 | rm -rf .tst 2>/dev/null |
| | 2794 | mkdir .tst 2>/dev/null |
| | 2795 | if test -d .tst; then |
| | 2796 | am__leading_dot=. |
| | 2797 | else |
| | 2798 | am__leading_dot=_ |
| | 2799 | fi |
| | 2800 | rmdir .tst 2>/dev/null |
| | 2801 | |
| | 2802 | if test "`cd $srcdir && pwd`" != "`pwd`"; then |
| | 2803 | # Use -I$(srcdir) only when $(srcdir) != ., so that make's output |
| | 2804 | # is not polluted with repeated "-I." |
| | 2805 | am__isrc=' -I$(srcdir)' |
| | 2806 | # test to see if srcdir already configured |
| | 2807 | if test -f $srcdir/config.status; then |
| | 2808 | as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5 |
| | 2809 | fi |
| | 2810 | fi |
| | 2811 | |
| | 2812 | # test whether we have cygpath |
| | 2813 | if test -z "$CYGPATH_W"; then |
| | 2814 | if (cygpath --version) >/dev/null 2>/dev/null; then |
| | 2815 | CYGPATH_W='cygpath -w' |
| | 2816 | else |
| | 2817 | CYGPATH_W=echo |
| | 2818 | fi |
| | 2819 | fi |
| | 2820 | |
| | 2821 | |
| | 2822 | # Define the identity of the package. |
| | 2823 | PACKAGE='libgfan' |
| | 2824 | VERSION='0.1' |
| | 2825 | |
| | 2826 | |
| | 2827 | cat >>confdefs.h <<_ACEOF |
| | 2828 | #define PACKAGE "$PACKAGE" |
| | 2829 | _ACEOF |
| | 2830 | |
| | 2831 | |
| | 2832 | cat >>confdefs.h <<_ACEOF |
| | 2833 | #define VERSION "$VERSION" |
| | 2834 | _ACEOF |
| | 2835 | |
| | 2836 | # Some tools Automake needs. |
| | 2837 | |
| | 2838 | ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"} |
| | 2839 | |
| | 2840 | |
| | 2841 | AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"} |
| | 2842 | |
| | 2843 | |
| | 2844 | AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"} |
| | 2845 | |
| | 2846 | |
| | 2847 | AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"} |
| | 2848 | |
| | 2849 | |
| | 2850 | MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"} |
| | 2851 | |
| | 2852 | # We need awk for the "check" target. The system "awk" is bad on |
| | 2853 | # some platforms. |
| | 2854 | # Always define AMTAR for backward compatibility. Yes, it's still used |
| | 2855 | # in the wild :-( We should find a proper way to deprecate it ... |
| | 2856 | AMTAR='$${TAR-tar}' |
| | 2857 | |
| | 2858 | am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -' |
| | 2859 | |
| | 2860 | |
| | 2861 | |
| | 2862 | |
| | 2863 | # -Wno-extra-portability -Werror silent-rules |
| | 2864 | # Check whether --enable-silent-rules was given. |
| | 2865 | if test "${enable_silent_rules+set}" = set; then : |
| | 2866 | enableval=$enable_silent_rules; |
| | 2867 | fi |
| | 2868 | |
| | 2869 | case $enable_silent_rules in |
| | 2870 | yes) AM_DEFAULT_VERBOSITY=0;; |
| | 2871 | no) AM_DEFAULT_VERBOSITY=1;; |
| | 2872 | *) AM_DEFAULT_VERBOSITY=1;; |
| | 2873 | esac |
| | 2874 | am_make=${MAKE-make} |
| | 2875 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5 |
| | 2876 | $as_echo_n "checking whether $am_make supports nested variables... " >&6; } |
| | 2877 | if ${am_cv_make_support_nested_variables+:} false; then : |
| | 2878 | $as_echo_n "(cached) " >&6 |
| | 2879 | else |
| | 2880 | if $as_echo 'TRUE=$(BAR$(V)) |
| | 2881 | BAR0=false |
| | 2882 | BAR1=true |
| | 2883 | V=1 |
| | 2884 | am__doit: |
| | 2885 | @$(TRUE) |
| | 2886 | .PHONY: am__doit' | $am_make -f - >/dev/null 2>&1; then |
| | 2887 | am_cv_make_support_nested_variables=yes |
| | 2888 | else |
| | 2889 | am_cv_make_support_nested_variables=no |
| | 2890 | fi |
| | 2891 | fi |
| | 2892 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5 |
| | 2893 | $as_echo "$am_cv_make_support_nested_variables" >&6; } |
| | 2894 | if test $am_cv_make_support_nested_variables = yes; then |
| | 2895 | AM_V='$(V)' |
| | 2896 | AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)' |
| | 2897 | else |
| | 2898 | AM_V=$AM_DEFAULT_VERBOSITY |
| | 2899 | AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY |
| | 2900 | fi |
| | 2901 | AM_BACKSLASH='\' |
| | 2902 | |
| | 2903 | DEPDIR="${am__leading_dot}deps" |
| | 2904 | |
| | 2905 | ac_config_commands="$ac_config_commands depfiles" |
| | 2906 | |
| | 2907 | |
| | 2908 | am_make=${MAKE-make} |
| | 2909 | cat > confinc << 'END' |
| | 2910 | am__doit: |
| | 2911 | @echo this is the am__doit target |
| | 2912 | .PHONY: am__doit |
| | 2913 | END |
| | 2914 | # If we don't find an include directive, just comment out the code. |
| | 2915 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5 |
| | 2916 | $as_echo_n "checking for style of include used by $am_make... " >&6; } |
| | 2917 | am__include="#" |
| | 2918 | am__quote= |
| | 2919 | _am_result=none |
| | 2920 | # First try GNU make style include. |
| | 2921 | echo "include confinc" > confmf |
| | 2922 | # Ignore all kinds of additional output from `make'. |
| | 2923 | case `$am_make -s -f confmf 2> /dev/null` in #( |
| | 2924 | *the\ am__doit\ target*) |
| | 2925 | am__include=include |
| | 2926 | am__quote= |
| | 2927 | _am_result=GNU |
| | 2928 | ;; |
| | 2929 | esac |
| | 2930 | # Now try BSD make style include. |
| | 2931 | if test "$am__include" = "#"; then |
| | 2932 | echo '.include "confinc"' > confmf |
| | 2933 | case `$am_make -s -f confmf 2> /dev/null` in #( |
| | 2934 | *the\ am__doit\ target*) |
| | 2935 | am__include=.include |
| | 2936 | am__quote="\"" |
| | 2937 | _am_result=BSD |
| | 2938 | ;; |
| | 2939 | esac |
| | 2940 | fi |
| | 2941 | |
| | 2942 | |
| | 2943 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5 |
| | 2944 | $as_echo "$_am_result" >&6; } |
| | 2945 | rm -f confinc confmf |
| | 2946 | |
| | 2947 | # Check whether --enable-dependency-tracking was given. |
| | 2948 | if test "${enable_dependency_tracking+set}" = set; then : |
| | 2949 | enableval=$enable_dependency_tracking; |
| | 2950 | fi |
| | 2951 | |
| | 2952 | if test "x$enable_dependency_tracking" != xno; then |
| | 2953 | am_depcomp="$ac_aux_dir/depcomp" |
| | 2954 | AMDEPBACKSLASH='\' |
| | 2955 | am__nodep='_no' |
| | 2956 | fi |
| | 2957 | if test "x$enable_dependency_tracking" != xno; then |
| | 2958 | AMDEP_TRUE= |
| | 2959 | AMDEP_FALSE='#' |
| | 2960 | else |
| | 2961 | AMDEP_TRUE='#' |
| | 2962 | AMDEP_FALSE= |
| | 2963 | fi |
| | 2964 | |
| | 2965 | |
| | 3755 | |
| | 3756 | depcc="$CC" am_compiler_list= |
| | 3757 | |
| | 3758 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 |
| | 3759 | $as_echo_n "checking dependency style of $depcc... " >&6; } |
| | 3760 | if ${am_cv_CC_dependencies_compiler_type+:} false; then : |
| | 3761 | $as_echo_n "(cached) " >&6 |
| | 3762 | else |
| | 3763 | if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then |
| | 3764 | # We make a subdir and do the tests there. Otherwise we can end up |
| | 3765 | # making bogus files that we don't know about and never remove. For |
| | 3766 | # instance it was reported that on HP-UX the gcc test will end up |
| | 3767 | # making a dummy file named `D' -- because `-MD' means `put the output |
| | 3768 | # in D'. |
| | 3769 | rm -rf conftest.dir |
| | 3770 | mkdir conftest.dir |
| | 3771 | # Copy depcomp to subdir because otherwise we won't find it if we're |
| | 3772 | # using a relative directory. |
| | 3773 | cp "$am_depcomp" conftest.dir |
| | 3774 | cd conftest.dir |
| | 3775 | # We will build objects and dependencies in a subdirectory because |
| | 3776 | # it helps to detect inapplicable dependency modes. For instance |
| | 3777 | # both Tru64's cc and ICC support -MD to output dependencies as a |
| | 3778 | # side effect of compilation, but ICC will put the dependencies in |
| | 3779 | # the current directory while Tru64 will put them in the object |
| | 3780 | # directory. |
| | 3781 | mkdir sub |
| | 3782 | |
| | 3783 | am_cv_CC_dependencies_compiler_type=none |
| | 3784 | if test "$am_compiler_list" = ""; then |
| | 3785 | am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` |
| | 3786 | fi |
| | 3787 | am__universal=false |
| | 3788 | case " $depcc " in #( |
| | 3789 | *\ -arch\ *\ -arch\ *) am__universal=true ;; |
| | 3790 | esac |
| | 3791 | |
| | 3792 | for depmode in $am_compiler_list; do |
| | 3793 | # Setup a source with many dependencies, because some compilers |
| | 3794 | # like to wrap large dependency lists on column 80 (with \), and |
| | 3795 | # we should not choose a depcomp mode which is confused by this. |
| | 3796 | # |
| | 3797 | # We need to recreate these files for each test, as the compiler may |
| | 3798 | # overwrite some of them when testing with obscure command lines. |
| | 3799 | # This happens at least with the AIX C compiler. |
| | 3800 | : > sub/conftest.c |
| | 3801 | for i in 1 2 3 4 5 6; do |
| | 3802 | echo '#include "conftst'$i'.h"' >> sub/conftest.c |
| | 3803 | # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with |
| | 3804 | # Solaris 8's {/usr,}/bin/sh. |
| | 3805 | touch sub/conftst$i.h |
| | 3806 | done |
| | 3807 | echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf |
| | 3808 | |
| | 3809 | # We check with `-c' and `-o' for the sake of the "dashmstdout" |
| | 3810 | # mode. It turns out that the SunPro C++ compiler does not properly |
| | 3811 | # handle `-M -o', and we need to detect this. Also, some Intel |
| | 3812 | # versions had trouble with output in subdirs |
| | 3813 | am__obj=sub/conftest.${OBJEXT-o} |
| | 3814 | am__minus_obj="-o $am__obj" |
| | 3815 | case $depmode in |
| | 3816 | gcc) |
| | 3817 | # This depmode causes a compiler race in universal mode. |
| | 3818 | test "$am__universal" = false || continue |
| | 3819 | ;; |
| | 3820 | nosideeffect) |
| | 3821 | # after this tag, mechanisms are not by side-effect, so they'll |
| | 3822 | # only be used when explicitly requested |
| | 3823 | if test "x$enable_dependency_tracking" = xyes; then |
| | 3824 | continue |
| | 3825 | else |
| | 3826 | break |
| | 3827 | fi |
| | 3828 | ;; |
| | 3829 | msvc7 | msvc7msys | msvisualcpp | msvcmsys) |
| | 3830 | # This compiler won't grok `-c -o', but also, the minuso test has |
| | 3831 | # not run yet. These depmodes are late enough in the game, and |
| | 3832 | # so weak that their functioning should not be impacted. |
| | 3833 | am__obj=conftest.${OBJEXT-o} |
| | 3834 | am__minus_obj= |
| | 3835 | ;; |
| | 3836 | none) break ;; |
| | 3837 | esac |
| | 3838 | if depmode=$depmode \ |
| | 3839 | source=sub/conftest.c object=$am__obj \ |
| | 3840 | depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ |
| | 3841 | $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ |
| | 3842 | >/dev/null 2>conftest.err && |
| | 3843 | grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && |
| | 3844 | grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && |
| | 3845 | grep $am__obj sub/conftest.Po > /dev/null 2>&1 && |
| | 3846 | ${MAKE-make} -s -f confmf > /dev/null 2>&1; then |
| | 3847 | # icc doesn't choke on unknown options, it will just issue warnings |
| | 3848 | # or remarks (even with -Werror). So we grep stderr for any message |
| | 3849 | # that says an option was ignored or not supported. |
| | 3850 | # When given -MP, icc 7.0 and 7.1 complain thusly: |
| | 3851 | # icc: Command line warning: ignoring option '-M'; no argument required |
| | 3852 | # The diagnosis changed in icc 8.0: |
| | 3853 | # icc: Command line remark: option '-MP' not supported |
| | 3854 | if (grep 'ignoring option' conftest.err || |
| | 3855 | grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else |
| | 3856 | am_cv_CC_dependencies_compiler_type=$depmode |
| | 3857 | break |
| | 3858 | fi |
| | 3859 | fi |
| | 3860 | done |
| | 3861 | |
| | 3862 | cd .. |
| | 3863 | rm -rf conftest.dir |
| | 3864 | else |
| | 3865 | am_cv_CC_dependencies_compiler_type=none |
| | 3866 | fi |
| | 3867 | |
| | 3868 | fi |
| | 3869 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5 |
| | 3870 | $as_echo "$am_cv_CC_dependencies_compiler_type" >&6; } |
| | 3871 | CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type |
| | 3872 | |
| | 3873 | if |
| | 3874 | test "x$enable_dependency_tracking" != xno \ |
| | 3875 | && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then |
| | 3876 | am__fastdepCC_TRUE= |
| | 3877 | am__fastdepCC_FALSE='#' |
| | 3878 | else |
| | 3879 | am__fastdepCC_TRUE='#' |
| | 3880 | am__fastdepCC_FALSE= |
| | 3881 | fi |
| | 3882 | |
| | 3883 | |
| | 3884 | |
| | 3885 | if test -n "$ac_tool_prefix"; then |
| | 3886 | for ac_prog in ar lib "link -lib" |
| | 3887 | do |
| | 3888 | # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. |
| | 3889 | set dummy $ac_tool_prefix$ac_prog; ac_word=$2 |
| | 3890 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 |
| | 3891 | $as_echo_n "checking for $ac_word... " >&6; } |
| | 3892 | if ${ac_cv_prog_AR+:} false; then : |
| | 3893 | $as_echo_n "(cached) " >&6 |
| | 3894 | else |
| | 3895 | if test -n "$AR"; then |
| | 3896 | ac_cv_prog_AR="$AR" # Let the user override the test. |
| | 3897 | else |
| | 3898 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 3899 | for as_dir in $PATH |
| | 3900 | do |
| | 3901 | IFS=$as_save_IFS |
| | 3902 | test -z "$as_dir" && as_dir=. |
| | 3903 | for ac_exec_ext in '' $ac_executable_extensions; do |
| | 3904 | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| | 3905 | ac_cv_prog_AR="$ac_tool_prefix$ac_prog" |
| | 3906 | $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| | 3907 | break 2 |
| | 3908 | fi |
| | 3909 | done |
| | 3910 | done |
| | 3911 | IFS=$as_save_IFS |
| | 3912 | |
| | 3913 | fi |
| | 3914 | fi |
| | 3915 | AR=$ac_cv_prog_AR |
| | 3916 | if test -n "$AR"; then |
| | 3917 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5 |
| | 3918 | $as_echo "$AR" >&6; } |
| | 3919 | else |
| | 3920 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 |
| | 3921 | $as_echo "no" >&6; } |
| | 3922 | fi |
| | 3923 | |
| | 3924 | |
| | 3925 | test -n "$AR" && break |
| | 3926 | done |
| | 3927 | fi |
| | 3928 | if test -z "$AR"; then |
| | 3929 | ac_ct_AR=$AR |
| | 3930 | for ac_prog in ar lib "link -lib" |
| | 3931 | do |
| | 3932 | # Extract the first word of "$ac_prog", so it can be a program name with args. |
| | 3933 | set dummy $ac_prog; ac_word=$2 |
| | 3934 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 |
| | 3935 | $as_echo_n "checking for $ac_word... " >&6; } |
| | 3936 | if ${ac_cv_prog_ac_ct_AR+:} false; then : |
| | 3937 | $as_echo_n "(cached) " >&6 |
| | 3938 | else |
| | 3939 | if test -n "$ac_ct_AR"; then |
| | 3940 | ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test. |
| | 3941 | else |
| | 3942 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 3943 | for as_dir in $PATH |
| | 3944 | do |
| | 3945 | IFS=$as_save_IFS |
| | 3946 | test -z "$as_dir" && as_dir=. |
| | 3947 | for ac_exec_ext in '' $ac_executable_extensions; do |
| | 3948 | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| | 3949 | ac_cv_prog_ac_ct_AR="$ac_prog" |
| | 3950 | $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| | 3951 | break 2 |
| | 3952 | fi |
| | 3953 | done |
| | 3954 | done |
| | 3955 | IFS=$as_save_IFS |
| | 3956 | |
| | 3957 | fi |
| | 3958 | fi |
| | 3959 | ac_ct_AR=$ac_cv_prog_ac_ct_AR |
| | 3960 | if test -n "$ac_ct_AR"; then |
| | 3961 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5 |
| | 3962 | $as_echo "$ac_ct_AR" >&6; } |
| | 3963 | else |
| | 3964 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 |
| | 3965 | $as_echo "no" >&6; } |
| | 3966 | fi |
| | 3967 | |
| | 3968 | |
| | 3969 | test -n "$ac_ct_AR" && break |
| | 3970 | done |
| | 3971 | |
| | 3972 | if test "x$ac_ct_AR" = x; then |
| | 3973 | AR="false" |
| | 3974 | else |
| | 3975 | case $cross_compiling:$ac_tool_warned in |
| | 3976 | yes:) |
| | 3977 | { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 |
| | 3978 | $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} |
| | 3979 | ac_tool_warned=yes ;; |
| | 3980 | esac |
| | 3981 | AR=$ac_ct_AR |
| | 3982 | fi |
| | 3983 | fi |
| | 3984 | |
| | 3985 | : ${AR=ar} |
| | 3986 | |
| | 3987 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking the archiver ($AR) interface" >&5 |
| | 3988 | $as_echo_n "checking the archiver ($AR) interface... " >&6; } |
| | 3989 | if ${am_cv_ar_interface+:} false; then : |
| | 3990 | $as_echo_n "(cached) " >&6 |
| | 3991 | else |
| | 3992 | am_cv_ar_interface=ar |
| | 3993 | cat confdefs.h - <<_ACEOF >conftest.$ac_ext |
| | 3994 | /* end confdefs.h. */ |
| | 3995 | int some_variable = 0; |
| | 3996 | _ACEOF |
| | 3997 | if ac_fn_c_try_compile "$LINENO"; then : |
| | 3998 | am_ar_try='$AR cru libconftest.a conftest.$ac_objext >&5' |
| | 3999 | { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$am_ar_try\""; } >&5 |
| | 4000 | (eval $am_ar_try) 2>&5 |
| | 4001 | ac_status=$? |
| | 4002 | $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 |
| | 4003 | test $ac_status = 0; } |
| | 4004 | if test "$ac_status" -eq 0; then |
| | 4005 | am_cv_ar_interface=ar |
| | 4006 | else |
| | 4007 | am_ar_try='$AR -NOLOGO -OUT:conftest.lib conftest.$ac_objext >&5' |
| | 4008 | { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$am_ar_try\""; } >&5 |
| | 4009 | (eval $am_ar_try) 2>&5 |
| | 4010 | ac_status=$? |
| | 4011 | $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 |
| | 4012 | test $ac_status = 0; } |
| | 4013 | if test "$ac_status" -eq 0; then |
| | 4014 | am_cv_ar_interface=lib |
| | 4015 | else |
| | 4016 | am_cv_ar_interface=unknown |
| | 4017 | fi |
| | 4018 | fi |
| | 4019 | rm -f conftest.lib libconftest.a |
| | 4020 | |
| | 4021 | fi |
| | 4022 | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| | 4023 | |
| | 4024 | fi |
| | 4025 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_ar_interface" >&5 |
| | 4026 | $as_echo "$am_cv_ar_interface" >&6; } |
| | 4027 | |
| | 4028 | case $am_cv_ar_interface in |
| | 4029 | ar) |
| | 4030 | ;; |
| | 4031 | lib) |
| | 4032 | # Microsoft lib, so override with the ar-lib wrapper script. |
| | 4033 | # FIXME: It is wrong to rewrite AR. |
| | 4034 | # But if we don't then we get into trouble of one sort or another. |
| | 4035 | # A longer-term fix would be to have automake use am__AR in this case, |
| | 4036 | # and then we could set am__AR="$am_aux_dir/ar-lib \$(AR)" or something |
| | 4037 | # similar. |
| | 4038 | AR="$am_aux_dir/ar-lib $AR" |
| | 4039 | ;; |
| | 4040 | unknown) |
| | 4041 | as_fn_error $? "could not determine $AR interface" "$LINENO" 5 |
| | 4042 | ;; |
| | 4043 | esac |
| | 4044 | |
| | 4045 | |
| | 4046 | # Checks for programs. |
| | 4047 | ac_ext=c |
| | 4048 | ac_cpp='$CPP $CPPFLAGS' |
| | 4049 | ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' |
| | 4050 | ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' |
| | 4051 | ac_compiler_gnu=$ac_cv_c_compiler_gnu |
| | 4052 | if test -n "$ac_tool_prefix"; then |
| | 4053 | # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. |
| | 4054 | set dummy ${ac_tool_prefix}gcc; ac_word=$2 |
| | 4055 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 |
| | 4056 | $as_echo_n "checking for $ac_word... " >&6; } |
| | 4057 | if ${ac_cv_prog_CC+:} false; then : |
| | 4058 | $as_echo_n "(cached) " >&6 |
| | 4059 | else |
| | 4060 | if test -n "$CC"; then |
| | 4061 | ac_cv_prog_CC="$CC" # Let the user override the test. |
| | 4062 | else |
| | 4063 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 4064 | for as_dir in $PATH |
| | 4065 | do |
| | 4066 | IFS=$as_save_IFS |
| | 4067 | test -z "$as_dir" && as_dir=. |
| | 4068 | for ac_exec_ext in '' $ac_executable_extensions; do |
| | 4069 | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| | 4070 | ac_cv_prog_CC="${ac_tool_prefix}gcc" |
| | 4071 | $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| | 4072 | break 2 |
| | 4073 | fi |
| | 4074 | done |
| | 4075 | done |
| | 4076 | IFS=$as_save_IFS |
| | 4077 | |
| | 4078 | fi |
| | 4079 | fi |
| | 4080 | CC=$ac_cv_prog_CC |
| | 4081 | if test -n "$CC"; then |
| | 4082 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 |
| | 4083 | $as_echo "$CC" >&6; } |
| | 4084 | else |
| | 4085 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 |
| | 4086 | $as_echo "no" >&6; } |
| | 4087 | fi |
| | 4088 | |
| | 4089 | |
| | 4090 | fi |
| | 4091 | if test -z "$ac_cv_prog_CC"; then |
| | 4092 | ac_ct_CC=$CC |
| | 4093 | # Extract the first word of "gcc", so it can be a program name with args. |
| | 4094 | set dummy gcc; ac_word=$2 |
| | 4095 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 |
| | 4096 | $as_echo_n "checking for $ac_word... " >&6; } |
| | 4097 | if ${ac_cv_prog_ac_ct_CC+:} false; then : |
| | 4098 | $as_echo_n "(cached) " >&6 |
| | 4099 | else |
| | 4100 | if test -n "$ac_ct_CC"; then |
| | 4101 | ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. |
| | 4102 | else |
| | 4103 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 4104 | for as_dir in $PATH |
| | 4105 | do |
| | 4106 | IFS=$as_save_IFS |
| | 4107 | test -z "$as_dir" && as_dir=. |
| | 4108 | for ac_exec_ext in '' $ac_executable_extensions; do |
| | 4109 | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| | 4110 | ac_cv_prog_ac_ct_CC="gcc" |
| | 4111 | $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| | 4112 | break 2 |
| | 4113 | fi |
| | 4114 | done |
| | 4115 | done |
| | 4116 | IFS=$as_save_IFS |
| | 4117 | |
| | 4118 | fi |
| | 4119 | fi |
| | 4120 | ac_ct_CC=$ac_cv_prog_ac_ct_CC |
| | 4121 | if test -n "$ac_ct_CC"; then |
| | 4122 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 |
| | 4123 | $as_echo "$ac_ct_CC" >&6; } |
| | 4124 | else |
| | 4125 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 |
| | 4126 | $as_echo "no" >&6; } |
| | 4127 | fi |
| | 4128 | |
| | 4129 | if test "x$ac_ct_CC" = x; then |
| | 4130 | CC="" |
| | 4131 | else |
| | 4132 | case $cross_compiling:$ac_tool_warned in |
| | 4133 | yes:) |
| | 4134 | { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 |
| | 4135 | $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} |
| | 4136 | ac_tool_warned=yes ;; |
| | 4137 | esac |
| | 4138 | CC=$ac_ct_CC |
| | 4139 | fi |
| | 4140 | else |
| | 4141 | CC="$ac_cv_prog_CC" |
| | 4142 | fi |
| | 4143 | |
| | 4144 | if test -z "$CC"; then |
| | 4145 | if test -n "$ac_tool_prefix"; then |
| | 4146 | # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. |
| | 4147 | set dummy ${ac_tool_prefix}cc; ac_word=$2 |
| | 4148 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 |
| | 4149 | $as_echo_n "checking for $ac_word... " >&6; } |
| | 4150 | if ${ac_cv_prog_CC+:} false; then : |
| | 4151 | $as_echo_n "(cached) " >&6 |
| | 4152 | else |
| | 4153 | if test -n "$CC"; then |
| | 4154 | ac_cv_prog_CC="$CC" # Let the user override the test. |
| | 4155 | else |
| | 4156 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 4157 | for as_dir in $PATH |
| | 4158 | do |
| | 4159 | IFS=$as_save_IFS |
| | 4160 | test -z "$as_dir" && as_dir=. |
| | 4161 | for ac_exec_ext in '' $ac_executable_extensions; do |
| | 4162 | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| | 4163 | ac_cv_prog_CC="${ac_tool_prefix}cc" |
| | 4164 | $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| | 4165 | break 2 |
| | 4166 | fi |
| | 4167 | done |
| | 4168 | done |
| | 4169 | IFS=$as_save_IFS |
| | 4170 | |
| | 4171 | fi |
| | 4172 | fi |
| | 4173 | CC=$ac_cv_prog_CC |
| | 4174 | if test -n "$CC"; then |
| | 4175 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 |
| | 4176 | $as_echo "$CC" >&6; } |
| | 4177 | else |
| | 4178 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 |
| | 4179 | $as_echo "no" >&6; } |
| | 4180 | fi |
| | 4181 | |
| | 4182 | |
| | 4183 | fi |
| | 4184 | fi |
| | 4185 | if test -z "$CC"; then |
| | 4186 | # Extract the first word of "cc", so it can be a program name with args. |
| | 4187 | set dummy cc; ac_word=$2 |
| | 4188 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 |
| | 4189 | $as_echo_n "checking for $ac_word... " >&6; } |
| | 4190 | if ${ac_cv_prog_CC+:} false; then : |
| | 4191 | $as_echo_n "(cached) " >&6 |
| | 4192 | else |
| | 4193 | if test -n "$CC"; then |
| | 4194 | ac_cv_prog_CC="$CC" # Let the user override the test. |
| | 4195 | else |
| | 4196 | ac_prog_rejected=no |
| | 4197 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 4198 | for as_dir in $PATH |
| | 4199 | do |
| | 4200 | IFS=$as_save_IFS |
| | 4201 | test -z "$as_dir" && as_dir=. |
| | 4202 | for ac_exec_ext in '' $ac_executable_extensions; do |
| | 4203 | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| | 4204 | if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then |
| | 4205 | ac_prog_rejected=yes |
| | 4206 | continue |
| | 4207 | fi |
| | 4208 | ac_cv_prog_CC="cc" |
| | 4209 | $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| | 4210 | break 2 |
| | 4211 | fi |
| | 4212 | done |
| | 4213 | done |
| | 4214 | IFS=$as_save_IFS |
| | 4215 | |
| | 4216 | if test $ac_prog_rejected = yes; then |
| | 4217 | # We found a bogon in the path, so make sure we never use it. |
| | 4218 | set dummy $ac_cv_prog_CC |
| | 4219 | shift |
| | 4220 | if test $# != 0; then |
| | 4221 | # We chose a different compiler from the bogus one. |
| | 4222 | # However, it has the same basename, so the bogon will be chosen |
| | 4223 | # first if we set CC to just the basename; use the full file name. |
| | 4224 | shift |
| | 4225 | ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" |
| | 4226 | fi |
| | 4227 | fi |
| | 4228 | fi |
| | 4229 | fi |
| | 4230 | CC=$ac_cv_prog_CC |
| | 4231 | if test -n "$CC"; then |
| | 4232 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 |
| | 4233 | $as_echo "$CC" >&6; } |
| | 4234 | else |
| | 4235 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 |
| | 4236 | $as_echo "no" >&6; } |
| | 4237 | fi |
| | 4238 | |
| | 4239 | |
| | 4240 | fi |
| | 4241 | if test -z "$CC"; then |
| | 4242 | if test -n "$ac_tool_prefix"; then |
| | 4243 | for ac_prog in cl.exe |
| | 4244 | do |
| | 4245 | # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. |
| | 4246 | set dummy $ac_tool_prefix$ac_prog; ac_word=$2 |
| | 4247 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 |
| | 4248 | $as_echo_n "checking for $ac_word... " >&6; } |
| | 4249 | if ${ac_cv_prog_CC+:} false; then : |
| | 4250 | $as_echo_n "(cached) " >&6 |
| | 4251 | else |
| | 4252 | if test -n "$CC"; then |
| | 4253 | ac_cv_prog_CC="$CC" # Let the user override the test. |
| | 4254 | else |
| | 4255 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 4256 | for as_dir in $PATH |
| | 4257 | do |
| | 4258 | IFS=$as_save_IFS |
| | 4259 | test -z "$as_dir" && as_dir=. |
| | 4260 | for ac_exec_ext in '' $ac_executable_extensions; do |
| | 4261 | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| | 4262 | ac_cv_prog_CC="$ac_tool_prefix$ac_prog" |
| | 4263 | $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| | 4264 | break 2 |
| | 4265 | fi |
| | 4266 | done |
| | 4267 | done |
| | 4268 | IFS=$as_save_IFS |
| | 4269 | |
| | 4270 | fi |
| | 4271 | fi |
| | 4272 | CC=$ac_cv_prog_CC |
| | 4273 | if test -n "$CC"; then |
| | 4274 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 |
| | 4275 | $as_echo "$CC" >&6; } |
| | 4276 | else |
| | 4277 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 |
| | 4278 | $as_echo "no" >&6; } |
| | 4279 | fi |
| | 4280 | |
| | 4281 | |
| | 4282 | test -n "$CC" && break |
| | 4283 | done |
| | 4284 | fi |
| | 4285 | if test -z "$CC"; then |
| | 4286 | ac_ct_CC=$CC |
| | 4287 | for ac_prog in cl.exe |
| | 4288 | do |
| | 4289 | # Extract the first word of "$ac_prog", so it can be a program name with args. |
| | 4290 | set dummy $ac_prog; ac_word=$2 |
| | 4291 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 |
| | 4292 | $as_echo_n "checking for $ac_word... " >&6; } |
| | 4293 | if ${ac_cv_prog_ac_ct_CC+:} false; then : |
| | 4294 | $as_echo_n "(cached) " >&6 |
| | 4295 | else |
| | 4296 | if test -n "$ac_ct_CC"; then |
| | 4297 | ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. |
| | 4298 | else |
| | 4299 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 4300 | for as_dir in $PATH |
| | 4301 | do |
| | 4302 | IFS=$as_save_IFS |
| | 4303 | test -z "$as_dir" && as_dir=. |
| | 4304 | for ac_exec_ext in '' $ac_executable_extensions; do |
| | 4305 | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| | 4306 | ac_cv_prog_ac_ct_CC="$ac_prog" |
| | 4307 | $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| | 4308 | break 2 |
| | 4309 | fi |
| | 4310 | done |
| | 4311 | done |
| | 4312 | IFS=$as_save_IFS |
| | 4313 | |
| | 4314 | fi |
| | 4315 | fi |
| | 4316 | ac_ct_CC=$ac_cv_prog_ac_ct_CC |
| | 4317 | if test -n "$ac_ct_CC"; then |
| | 4318 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 |
| | 4319 | $as_echo "$ac_ct_CC" >&6; } |
| | 4320 | else |
| | 4321 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 |
| | 4322 | $as_echo "no" >&6; } |
| | 4323 | fi |
| | 4324 | |
| | 4325 | |
| | 4326 | test -n "$ac_ct_CC" && break |
| | 4327 | done |
| | 4328 | |
| | 4329 | if test "x$ac_ct_CC" = x; then |
| | 4330 | CC="" |
| | 4331 | else |
| | 4332 | case $cross_compiling:$ac_tool_warned in |
| | 4333 | yes:) |
| | 4334 | { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 |
| | 4335 | $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} |
| | 4336 | ac_tool_warned=yes ;; |
| | 4337 | esac |
| | 4338 | CC=$ac_ct_CC |
| | 4339 | fi |
| | 4340 | fi |
| | 4341 | |
| | 4342 | fi |
| | 4343 | |
| | 4344 | |
| | 4345 | test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 |
| | 4346 | $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} |
| | 4347 | as_fn_error $? "no acceptable C compiler found in \$PATH |
| | 4348 | See \`config.log' for more details" "$LINENO" 5; } |
| | 4349 | |
| | 4350 | # Provide some information about the compiler. |
| | 4351 | $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 |
| | 4352 | set X $ac_compile |
| | 4353 | ac_compiler=$2 |
| | 4354 | for ac_option in --version -v -V -qversion; do |
| | 4355 | { { ac_try="$ac_compiler $ac_option >&5" |
| | 4356 | case "(($ac_try" in |
| | 4357 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 4358 | *) ac_try_echo=$ac_try;; |
| | 4359 | esac |
| | 4360 | eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" |
| | 4361 | $as_echo "$ac_try_echo"; } >&5 |
| | 4362 | (eval "$ac_compiler $ac_option >&5") 2>conftest.err |
| | 4363 | ac_status=$? |
| | 4364 | if test -s conftest.err; then |
| | 4365 | sed '10a\ |
| | 4366 | ... rest of stderr output deleted ... |
| | 4367 | 10q' conftest.err >conftest.er1 |
| | 4368 | cat conftest.er1 >&5 |
| | 4369 | fi |
| | 4370 | rm -f conftest.er1 conftest.err |
| | 4371 | $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 |
| | 4372 | test $ac_status = 0; } |
| | 4373 | done |
| | 4374 | |
| | 4375 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 |
| | 4376 | $as_echo_n "checking whether we are using the GNU C compiler... " >&6; } |
| | 4377 | if ${ac_cv_c_compiler_gnu+:} false; then : |
| | 4378 | $as_echo_n "(cached) " >&6 |
| | 4379 | else |
| | 4380 | cat confdefs.h - <<_ACEOF >conftest.$ac_ext |
| | 4381 | /* end confdefs.h. */ |
| | 4382 | |
| | 4383 | int |
| | 4384 | main () |
| | 4385 | { |
| | 4386 | #ifndef __GNUC__ |
| | 4387 | choke me |
| | 4388 | #endif |
| | 4389 | |
| | 4390 | ; |
| | 4391 | return 0; |
| | 4392 | } |
| | 4393 | _ACEOF |
| | 4394 | if ac_fn_c_try_compile "$LINENO"; then : |
| | 4395 | ac_compiler_gnu=yes |
| | 4396 | else |
| | 4397 | ac_compiler_gnu=no |
| | 4398 | fi |
| | 4399 | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| | 4400 | ac_cv_c_compiler_gnu=$ac_compiler_gnu |
| | 4401 | |
| | 4402 | fi |
| | 4403 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 |
| | 4404 | $as_echo "$ac_cv_c_compiler_gnu" >&6; } |
| | 4405 | if test $ac_compiler_gnu = yes; then |
| | 4406 | GCC=yes |
| | 4407 | else |
| | 4408 | GCC= |
| | 4409 | fi |
| | 4410 | ac_test_CFLAGS=${CFLAGS+set} |
| | 4411 | ac_save_CFLAGS=$CFLAGS |
| | 4412 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 |
| | 4413 | $as_echo_n "checking whether $CC accepts -g... " >&6; } |
| | 4414 | if ${ac_cv_prog_cc_g+:} false; then : |
| | 4415 | $as_echo_n "(cached) " >&6 |
| | 4416 | else |
| | 4417 | ac_save_c_werror_flag=$ac_c_werror_flag |
| | 4418 | ac_c_werror_flag=yes |
| | 4419 | ac_cv_prog_cc_g=no |
| | 4420 | CFLAGS="-g" |
| | 4421 | cat confdefs.h - <<_ACEOF >conftest.$ac_ext |
| | 4422 | /* end confdefs.h. */ |
| | 4423 | |
| | 4424 | int |
| | 4425 | main () |
| | 4426 | { |
| | 4427 | |
| | 4428 | ; |
| | 4429 | return 0; |
| | 4430 | } |
| | 4431 | _ACEOF |
| | 4432 | if ac_fn_c_try_compile "$LINENO"; then : |
| | 4433 | ac_cv_prog_cc_g=yes |
| | 4434 | else |
| | 4435 | CFLAGS="" |
| | 4436 | cat confdefs.h - <<_ACEOF >conftest.$ac_ext |
| | 4437 | /* end confdefs.h. */ |
| | 4438 | |
| | 4439 | int |
| | 4440 | main () |
| | 4441 | { |
| | 4442 | |
| | 4443 | ; |
| | 4444 | return 0; |
| | 4445 | } |
| | 4446 | _ACEOF |
| | 4447 | if ac_fn_c_try_compile "$LINENO"; then : |
| | 4448 | |
| | 4449 | else |
| | 4450 | ac_c_werror_flag=$ac_save_c_werror_flag |
| | 4451 | CFLAGS="-g" |
| | 4452 | cat confdefs.h - <<_ACEOF >conftest.$ac_ext |
| | 4453 | /* end confdefs.h. */ |
| | 4454 | |
| | 4455 | int |
| | 4456 | main () |
| | 4457 | { |
| | 4458 | |
| | 4459 | ; |
| | 4460 | return 0; |
| | 4461 | } |
| | 4462 | _ACEOF |
| | 4463 | if ac_fn_c_try_compile "$LINENO"; then : |
| | 4464 | ac_cv_prog_cc_g=yes |
| | 4465 | fi |
| | 4466 | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| | 4467 | fi |
| | 4468 | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| | 4469 | fi |
| | 4470 | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| | 4471 | ac_c_werror_flag=$ac_save_c_werror_flag |
| | 4472 | fi |
| | 4473 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 |
| | 4474 | $as_echo "$ac_cv_prog_cc_g" >&6; } |
| | 4475 | if test "$ac_test_CFLAGS" = set; then |
| | 4476 | CFLAGS=$ac_save_CFLAGS |
| | 4477 | elif test $ac_cv_prog_cc_g = yes; then |
| | 4478 | if test "$GCC" = yes; then |
| | 4479 | CFLAGS="-g -O2" |
| | 4480 | else |
| | 4481 | CFLAGS="-g" |
| | 4482 | fi |
| | 4483 | else |
| | 4484 | if test "$GCC" = yes; then |
| | 4485 | CFLAGS="-O2" |
| | 4486 | else |
| | 4487 | CFLAGS= |
| | 4488 | fi |
| | 4489 | fi |
| | 4490 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 |
| | 4491 | $as_echo_n "checking for $CC option to accept ISO C89... " >&6; } |
| | 4492 | if ${ac_cv_prog_cc_c89+:} false; then : |
| | 4493 | $as_echo_n "(cached) " >&6 |
| | 4494 | else |
| | 4495 | ac_cv_prog_cc_c89=no |
| | 4496 | ac_save_CC=$CC |
| | 4497 | cat confdefs.h - <<_ACEOF >conftest.$ac_ext |
| | 4498 | /* end confdefs.h. */ |
| | 4499 | #include <stdarg.h> |
| | 4500 | #include <stdio.h> |
| | 4501 | #include <sys/types.h> |
| | 4502 | #include <sys/stat.h> |
| | 4503 | /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ |
| | 4504 | struct buf { int x; }; |
| | 4505 | FILE * (*rcsopen) (struct buf *, struct stat *, int); |
| | 4506 | static char *e (p, i) |
| | 4507 | char **p; |
| | 4508 | int i; |
| | 4509 | { |
| | 4510 | return p[i]; |
| | 4511 | } |
| | 4512 | static char *f (char * (*g) (char **, int), char **p, ...) |
| | 4513 | { |
| | 4514 | char *s; |
| | 4515 | va_list v; |
| | 4516 | va_start (v,p); |
| | 4517 | s = g (p, va_arg (v,int)); |
| | 4518 | va_end (v); |
| | 4519 | return s; |
| | 4520 | } |
| | 4521 | |
| | 4522 | /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has |
| | 4523 | function prototypes and stuff, but not '\xHH' hex character constants. |
| | 4524 | These don't provoke an error unfortunately, instead are silently treated |
| | 4525 | as 'x'. The following induces an error, until -std is added to get |
| | 4526 | proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an |
| | 4527 | array size at least. It's necessary to write '\x00'==0 to get something |
| | 4528 | that's true only with -std. */ |
| | 4529 | int osf4_cc_array ['\x00' == 0 ? 1 : -1]; |
| | 4530 | |
| | 4531 | /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters |
| | 4532 | inside strings and character constants. */ |
| | 4533 | #define FOO(x) 'x' |
| | 4534 | int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; |
| | 4535 | |
| | 4536 | int test (int i, double x); |
| | 4537 | struct s1 {int (*f) (int a);}; |
| | 4538 | struct s2 {int (*f) (double a);}; |
| | 4539 | int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); |
| | 4540 | int argc; |
| | 4541 | char **argv; |
| | 4542 | int |
| | 4543 | main () |
| | 4544 | { |
| | 4545 | return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; |
| | 4546 | ; |
| | 4547 | return 0; |
| | 4548 | } |
| | 4549 | _ACEOF |
| | 4550 | for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ |
| | 4551 | -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" |
| | 4552 | do |
| | 4553 | CC="$ac_save_CC $ac_arg" |
| | 4554 | if ac_fn_c_try_compile "$LINENO"; then : |
| | 4555 | ac_cv_prog_cc_c89=$ac_arg |
| | 4556 | fi |
| | 4557 | rm -f core conftest.err conftest.$ac_objext |
| | 4558 | test "x$ac_cv_prog_cc_c89" != "xno" && break |
| | 4559 | done |
| | 4560 | rm -f conftest.$ac_ext |
| | 4561 | CC=$ac_save_CC |
| | 4562 | |
| | 4563 | fi |
| | 4564 | # AC_CACHE_VAL |
| | 4565 | case "x$ac_cv_prog_cc_c89" in |
| | 4566 | x) |
| | 4567 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 |
| | 4568 | $as_echo "none needed" >&6; } ;; |
| | 4569 | xno) |
| | 4570 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 |
| | 4571 | $as_echo "unsupported" >&6; } ;; |
| | 4572 | *) |
| | 4573 | CC="$CC $ac_cv_prog_cc_c89" |
| | 4574 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 |
| | 4575 | $as_echo "$ac_cv_prog_cc_c89" >&6; } ;; |
| | 4576 | esac |
| | 4577 | if test "x$ac_cv_prog_cc_c89" != xno; then : |
| | 4578 | |
| | 4579 | fi |
| | 4580 | |
| | 4581 | ac_ext=c |
| | 4582 | ac_cpp='$CPP $CPPFLAGS' |
| | 4583 | ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' |
| | 4584 | ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' |
| | 4585 | ac_compiler_gnu=$ac_cv_c_compiler_gnu |
| | 4586 | |
| | 4587 | depcc="$CC" am_compiler_list= |
| | 4588 | |
| | 4589 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 |
| | 4590 | $as_echo_n "checking dependency style of $depcc... " >&6; } |
| | 4591 | if ${am_cv_CC_dependencies_compiler_type+:} false; then : |
| | 4592 | $as_echo_n "(cached) " >&6 |
| | 4593 | else |
| | 4594 | if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then |
| | 4595 | # We make a subdir and do the tests there. Otherwise we can end up |
| | 4596 | # making bogus files that we don't know about and never remove. For |
| | 4597 | # instance it was reported that on HP-UX the gcc test will end up |
| | 4598 | # making a dummy file named `D' -- because `-MD' means `put the output |
| | 4599 | # in D'. |
| | 4600 | rm -rf conftest.dir |
| | 4601 | mkdir conftest.dir |
| | 4602 | # Copy depcomp to subdir because otherwise we won't find it if we're |
| | 4603 | # using a relative directory. |
| | 4604 | cp "$am_depcomp" conftest.dir |
| | 4605 | cd conftest.dir |
| | 4606 | # We will build objects and dependencies in a subdirectory because |
| | 4607 | # it helps to detect inapplicable dependency modes. For instance |
| | 4608 | # both Tru64's cc and ICC support -MD to output dependencies as a |
| | 4609 | # side effect of compilation, but ICC will put the dependencies in |
| | 4610 | # the current directory while Tru64 will put them in the object |
| | 4611 | # directory. |
| | 4612 | mkdir sub |
| | 4613 | |
| | 4614 | am_cv_CC_dependencies_compiler_type=none |
| | 4615 | if test "$am_compiler_list" = ""; then |
| | 4616 | am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` |
| | 4617 | fi |
| | 4618 | am__universal=false |
| | 4619 | case " $depcc " in #( |
| | 4620 | *\ -arch\ *\ -arch\ *) am__universal=true ;; |
| | 4621 | esac |
| | 4622 | |
| | 4623 | for depmode in $am_compiler_list; do |
| | 4624 | # Setup a source with many dependencies, because some compilers |
| | 4625 | # like to wrap large dependency lists on column 80 (with \), and |
| | 4626 | # we should not choose a depcomp mode which is confused by this. |
| | 4627 | # |
| | 4628 | # We need to recreate these files for each test, as the compiler may |
| | 4629 | # overwrite some of them when testing with obscure command lines. |
| | 4630 | # This happens at least with the AIX C compiler. |
| | 4631 | : > sub/conftest.c |
| | 4632 | for i in 1 2 3 4 5 6; do |
| | 4633 | echo '#include "conftst'$i'.h"' >> sub/conftest.c |
| | 4634 | # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with |
| | 4635 | # Solaris 8's {/usr,}/bin/sh. |
| | 4636 | touch sub/conftst$i.h |
| | 4637 | done |
| | 4638 | echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf |
| | 4639 | |
| | 4640 | # We check with `-c' and `-o' for the sake of the "dashmstdout" |
| | 4641 | # mode. It turns out that the SunPro C++ compiler does not properly |
| | 4642 | # handle `-M -o', and we need to detect this. Also, some Intel |
| | 4643 | # versions had trouble with output in subdirs |
| | 4644 | am__obj=sub/conftest.${OBJEXT-o} |
| | 4645 | am__minus_obj="-o $am__obj" |
| | 4646 | case $depmode in |
| | 4647 | gcc) |
| | 4648 | # This depmode causes a compiler race in universal mode. |
| | 4649 | test "$am__universal" = false || continue |
| | 4650 | ;; |
| | 4651 | nosideeffect) |
| | 4652 | # after this tag, mechanisms are not by side-effect, so they'll |
| | 4653 | # only be used when explicitly requested |
| | 4654 | if test "x$enable_dependency_tracking" = xyes; then |
| | 4655 | continue |
| | 4656 | else |
| | 4657 | break |
| | 4658 | fi |
| | 4659 | ;; |
| | 4660 | msvc7 | msvc7msys | msvisualcpp | msvcmsys) |
| | 4661 | # This compiler won't grok `-c -o', but also, the minuso test has |
| | 4662 | # not run yet. These depmodes are late enough in the game, and |
| | 4663 | # so weak that their functioning should not be impacted. |
| | 4664 | am__obj=conftest.${OBJEXT-o} |
| | 4665 | am__minus_obj= |
| | 4666 | ;; |
| | 4667 | none) break ;; |
| | 4668 | esac |
| | 4669 | if depmode=$depmode \ |
| | 4670 | source=sub/conftest.c object=$am__obj \ |
| | 4671 | depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ |
| | 4672 | $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ |
| | 4673 | >/dev/null 2>conftest.err && |
| | 4674 | grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && |
| | 4675 | grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && |
| | 4676 | grep $am__obj sub/conftest.Po > /dev/null 2>&1 && |
| | 4677 | ${MAKE-make} -s -f confmf > /dev/null 2>&1; then |
| | 4678 | # icc doesn't choke on unknown options, it will just issue warnings |
| | 4679 | # or remarks (even with -Werror). So we grep stderr for any message |
| | 4680 | # that says an option was ignored or not supported. |
| | 4681 | # When given -MP, icc 7.0 and 7.1 complain thusly: |
| | 4682 | # icc: Command line warning: ignoring option '-M'; no argument required |
| | 4683 | # The diagnosis changed in icc 8.0: |
| | 4684 | # icc: Command line remark: option '-MP' not supported |
| | 4685 | if (grep 'ignoring option' conftest.err || |
| | 4686 | grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else |
| | 4687 | am_cv_CC_dependencies_compiler_type=$depmode |
| | 4688 | break |
| | 4689 | fi |
| | 4690 | fi |
| | 4691 | done |
| | 4692 | |
| | 4693 | cd .. |
| | 4694 | rm -rf conftest.dir |
| | 4695 | else |
| | 4696 | am_cv_CC_dependencies_compiler_type=none |
| | 4697 | fi |
| | 4698 | |
| | 4699 | fi |
| | 4700 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5 |
| | 4701 | $as_echo "$am_cv_CC_dependencies_compiler_type" >&6; } |
| | 4702 | CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type |
| | 4703 | |
| | 4704 | if |
| | 4705 | test "x$enable_dependency_tracking" != xno \ |
| | 4706 | && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then |
| | 4707 | am__fastdepCC_TRUE= |
| | 4708 | am__fastdepCC_FALSE='#' |
| | 4709 | else |
| | 4710 | am__fastdepCC_TRUE='#' |
| | 4711 | am__fastdepCC_FALSE= |
| | 4712 | fi |
| | 4713 | |
| 3131 | | done |
| 3132 | | done |
| 3133 | | IFS=$as_save_IFS |
| 3134 | | |
| 3135 | | fi |
| 3136 | | fi |
| 3137 | | RANLIB=$ac_cv_prog_RANLIB |
| 3138 | | if test -n "$RANLIB"; then |
| 3139 | | { $as_echo "$as_me:$LINENO: result: $RANLIB" >&5 |
| 3140 | | $as_echo "$RANLIB" >&6; } |
| 3141 | | else |
| 3142 | | { $as_echo "$as_me:$LINENO: result: no" >&5 |
| 3143 | | $as_echo "no" >&6; } |
| 3144 | | fi |
| 3145 | | |
| 3146 | | |
| 3147 | | fi |
| 3148 | | if test -z "$ac_cv_prog_RANLIB"; then |
| 3149 | | ac_ct_RANLIB=$RANLIB |
| 3150 | | # Extract the first word of "ranlib", so it can be a program name with args. |
| 3151 | | set dummy ranlib; ac_word=$2 |
| 3152 | | { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5 |
| 3153 | | $as_echo_n "checking for $ac_word... " >&6; } |
| 3154 | | if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then |
| 3155 | | $as_echo_n "(cached) " >&6 |
| 3156 | | else |
| 3157 | | if test -n "$ac_ct_RANLIB"; then |
| 3158 | | ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test. |
| 3159 | | else |
| 3160 | | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| 3161 | | for as_dir in $PATH |
| 3162 | | do |
| 3163 | | IFS=$as_save_IFS |
| 3164 | | test -z "$as_dir" && as_dir=. |
| 3165 | | for ac_exec_ext in '' $ac_executable_extensions; do |
| 3166 | | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| 3167 | | ac_cv_prog_ac_ct_RANLIB="ranlib" |
| 3168 | | $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| 3169 | | break 2 |
| 3170 | | fi |
| 3171 | | done |
| 3172 | | done |
| 3173 | | IFS=$as_save_IFS |
| 3174 | | |
| 3175 | | fi |
| 3176 | | fi |
| 3177 | | ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB |
| 3178 | | if test -n "$ac_ct_RANLIB"; then |
| 3179 | | { $as_echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5 |
| 3180 | | $as_echo "$ac_ct_RANLIB" >&6; } |
| 3181 | | else |
| 3182 | | { $as_echo "$as_me:$LINENO: result: no" >&5 |
| 3183 | | $as_echo "no" >&6; } |
| 3184 | | fi |
| 3185 | | |
| 3186 | | if test "x$ac_ct_RANLIB" = x; then |
| 3187 | | RANLIB=":" |
| 3188 | | else |
| 3189 | | case $cross_compiling:$ac_tool_warned in |
| 3190 | | yes:) |
| 3191 | | { $as_echo "$as_me:$LINENO: WARNING: using cross tools not prefixed with host triplet" >&5 |
| 3192 | | $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} |
| 3193 | | ac_tool_warned=yes ;; |
| 3194 | | esac |
| 3195 | | RANLIB=$ac_ct_RANLIB |
| 3196 | | fi |
| 3197 | | else |
| 3198 | | RANLIB="$ac_cv_prog_RANLIB" |
| 3199 | | fi |
| 3200 | | |
| 3201 | | |
| 3202 | | # Checks for libraries. |
| 3203 | | |
| 3204 | | # Checks for header files. |
| 3205 | | |
| 3206 | | ac_ext=c |
| 3207 | | ac_cpp='$CPP $CPPFLAGS' |
| 3208 | | ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' |
| 3209 | | ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' |
| 3210 | | ac_compiler_gnu=$ac_cv_c_compiler_gnu |
| 3211 | | { $as_echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5 |
| 3212 | | $as_echo_n "checking how to run the C preprocessor... " >&6; } |
| 3213 | | # On Suns, sometimes $CPP names a directory. |
| 3214 | | if test -n "$CPP" && test -d "$CPP"; then |
| 3215 | | CPP= |
| 3216 | | fi |
| 3217 | | if test -z "$CPP"; then |
| 3218 | | if test "${ac_cv_prog_CPP+set}" = set; then |
| 3219 | | $as_echo_n "(cached) " >&6 |
| 3220 | | else |
| 3221 | | # Double quotes because CPP needs to be expanded |
| 3222 | | for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" |
| 3223 | | do |
| 3224 | | ac_preproc_ok=false |
| 3225 | | for ac_c_preproc_warn_flag in '' yes |
| 3226 | | do |
| 3227 | | # Use a header file that comes with gcc, so configuring glibc |
| 3228 | | # with a fresh cross-compiler works. |
| 3229 | | # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since |
| 3230 | | # <limits.h> exists even on freestanding compilers. |
| 3231 | | # On the NeXT, cc -E runs the code through the compiler's parser, |
| 3232 | | # not just through cpp. "Syntax error" is here to catch this case. |
| 3233 | | cat >conftest.$ac_ext <<_ACEOF |
| 3234 | | /* confdefs.h. */ |
| 3235 | | _ACEOF |
| 3236 | | cat confdefs.h >>conftest.$ac_ext |
| 3237 | | cat >>conftest.$ac_ext <<_ACEOF |
| 3238 | | /* end confdefs.h. */ |
| 3239 | | #ifdef __STDC__ |
| 3240 | | # include <limits.h> |
| 3241 | | #else |
| 3242 | | # include <assert.h> |
| 3243 | | #endif |
| 3244 | | Syntax error |
| 3245 | | _ACEOF |
| 3246 | | if { (ac_try="$ac_cpp conftest.$ac_ext" |
| 3247 | | case "(($ac_try" in |
| 3248 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 3249 | | *) ac_try_echo=$ac_try;; |
| 3250 | | esac |
| 3251 | | eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\"" |
| 3252 | | $as_echo "$ac_try_echo") >&5 |
| 3253 | | (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 |
| 3254 | | ac_status=$? |
| 3255 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 3256 | | rm -f conftest.er1 |
| 3257 | | cat conftest.err >&5 |
| 3258 | | $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 3259 | | (exit $ac_status); } >/dev/null && { |
| 3260 | | test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || |
| 3261 | | test ! -s conftest.err |
| 3262 | | }; then |
| 3263 | | : |
| 3264 | | else |
| 3265 | | $as_echo "$as_me: failed program was:" >&5 |
| 3266 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 3267 | | |
| 3268 | | # Broken: fails on valid input. |
| 3269 | | continue |
| 3270 | | fi |
| 3271 | | |
| 3272 | | rm -f conftest.err conftest.$ac_ext |
| 3273 | | |
| 3274 | | # OK, works on sane cases. Now check whether nonexistent headers |
| 3275 | | # can be detected and how. |
| 3276 | | cat >conftest.$ac_ext <<_ACEOF |
| 3277 | | /* confdefs.h. */ |
| 3278 | | _ACEOF |
| 3279 | | cat confdefs.h >>conftest.$ac_ext |
| 3280 | | cat >>conftest.$ac_ext <<_ACEOF |
| 3281 | | /* end confdefs.h. */ |
| 3282 | | #include <ac_nonexistent.h> |
| 3283 | | _ACEOF |
| 3284 | | if { (ac_try="$ac_cpp conftest.$ac_ext" |
| 3285 | | case "(($ac_try" in |
| 3286 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 3287 | | *) ac_try_echo=$ac_try;; |
| 3288 | | esac |
| 3289 | | eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\"" |
| 3290 | | $as_echo "$ac_try_echo") >&5 |
| 3291 | | (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 |
| 3292 | | ac_status=$? |
| 3293 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 3294 | | rm -f conftest.er1 |
| 3295 | | cat conftest.err >&5 |
| 3296 | | $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 3297 | | (exit $ac_status); } >/dev/null && { |
| 3298 | | test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || |
| 3299 | | test ! -s conftest.err |
| 3300 | | }; then |
| 3301 | | # Broken: success on invalid input. |
| 3302 | | continue |
| 3303 | | else |
| 3304 | | $as_echo "$as_me: failed program was:" >&5 |
| 3305 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 3306 | | |
| 3307 | | # Passes both tests. |
| 3308 | | ac_preproc_ok=: |
| 3309 | | break |
| 3310 | | fi |
| 3311 | | |
| 3312 | | rm -f conftest.err conftest.$ac_ext |
| 3313 | | |
| 3314 | | done |
| 3315 | | # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. |
| 3316 | | rm -f conftest.err conftest.$ac_ext |
| 3317 | | if $ac_preproc_ok; then |
| 3318 | | break |
| 3319 | | fi |
| 3320 | | |
| 3321 | | done |
| 3322 | | ac_cv_prog_CPP=$CPP |
| 3323 | | |
| 3324 | | fi |
| 3325 | | CPP=$ac_cv_prog_CPP |
| 3326 | | else |
| 3327 | | ac_cv_prog_CPP=$CPP |
| 3328 | | fi |
| 3329 | | { $as_echo "$as_me:$LINENO: result: $CPP" >&5 |
| 3330 | | $as_echo "$CPP" >&6; } |
| 3331 | | ac_preproc_ok=false |
| 3332 | | for ac_c_preproc_warn_flag in '' yes |
| 3333 | | do |
| 3334 | | # Use a header file that comes with gcc, so configuring glibc |
| 3335 | | # with a fresh cross-compiler works. |
| 3336 | | # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since |
| 3337 | | # <limits.h> exists even on freestanding compilers. |
| 3338 | | # On the NeXT, cc -E runs the code through the compiler's parser, |
| 3339 | | # not just through cpp. "Syntax error" is here to catch this case. |
| 3340 | | cat >conftest.$ac_ext <<_ACEOF |
| 3341 | | /* confdefs.h. */ |
| 3342 | | _ACEOF |
| 3343 | | cat confdefs.h >>conftest.$ac_ext |
| 3344 | | cat >>conftest.$ac_ext <<_ACEOF |
| 3345 | | /* end confdefs.h. */ |
| 3346 | | #ifdef __STDC__ |
| 3347 | | # include <limits.h> |
| 3348 | | #else |
| 3349 | | # include <assert.h> |
| 3350 | | #endif |
| 3351 | | Syntax error |
| 3352 | | _ACEOF |
| 3353 | | if { (ac_try="$ac_cpp conftest.$ac_ext" |
| 3354 | | case "(($ac_try" in |
| 3355 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 3356 | | *) ac_try_echo=$ac_try;; |
| 3357 | | esac |
| 3358 | | eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\"" |
| 3359 | | $as_echo "$ac_try_echo") >&5 |
| 3360 | | (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 |
| 3361 | | ac_status=$? |
| 3362 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 3363 | | rm -f conftest.er1 |
| 3364 | | cat conftest.err >&5 |
| 3365 | | $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 3366 | | (exit $ac_status); } >/dev/null && { |
| 3367 | | test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || |
| 3368 | | test ! -s conftest.err |
| 3369 | | }; then |
| 3370 | | : |
| 3371 | | else |
| 3372 | | $as_echo "$as_me: failed program was:" >&5 |
| 3373 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 3374 | | |
| 3375 | | # Broken: fails on valid input. |
| 3376 | | continue |
| 3377 | | fi |
| 3378 | | |
| 3379 | | rm -f conftest.err conftest.$ac_ext |
| 3380 | | |
| 3381 | | # OK, works on sane cases. Now check whether nonexistent headers |
| 3382 | | # can be detected and how. |
| 3383 | | cat >conftest.$ac_ext <<_ACEOF |
| 3384 | | /* confdefs.h. */ |
| 3385 | | _ACEOF |
| 3386 | | cat confdefs.h >>conftest.$ac_ext |
| 3387 | | cat >>conftest.$ac_ext <<_ACEOF |
| 3388 | | /* end confdefs.h. */ |
| 3389 | | #include <ac_nonexistent.h> |
| 3390 | | _ACEOF |
| 3391 | | if { (ac_try="$ac_cpp conftest.$ac_ext" |
| 3392 | | case "(($ac_try" in |
| 3393 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 3394 | | *) ac_try_echo=$ac_try;; |
| 3395 | | esac |
| 3396 | | eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\"" |
| 3397 | | $as_echo "$ac_try_echo") >&5 |
| 3398 | | (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 |
| 3399 | | ac_status=$? |
| 3400 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 3401 | | rm -f conftest.er1 |
| 3402 | | cat conftest.err >&5 |
| 3403 | | $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 3404 | | (exit $ac_status); } >/dev/null && { |
| 3405 | | test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || |
| 3406 | | test ! -s conftest.err |
| 3407 | | }; then |
| 3408 | | # Broken: success on invalid input. |
| 3409 | | continue |
| 3410 | | else |
| 3411 | | $as_echo "$as_me: failed program was:" >&5 |
| 3412 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 3413 | | |
| 3414 | | # Passes both tests. |
| 3415 | | ac_preproc_ok=: |
| 3416 | | break |
| 3417 | | fi |
| 3418 | | |
| 3419 | | rm -f conftest.err conftest.$ac_ext |
| 3420 | | |
| 3421 | | done |
| 3422 | | # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. |
| 3423 | | rm -f conftest.err conftest.$ac_ext |
| 3424 | | if $ac_preproc_ok; then |
| 3425 | | : |
| 3426 | | else |
| 3427 | | { { $as_echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5 |
| 3428 | | $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} |
| 3429 | | { { $as_echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check |
| 3430 | | See \`config.log' for more details." >&5 |
| 3431 | | $as_echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check |
| 3432 | | See \`config.log' for more details." >&2;} |
| 3433 | | { (exit 1); exit 1; }; }; } |
| 3434 | | fi |
| 3435 | | |
| 3436 | | ac_ext=c |
| 3437 | | ac_cpp='$CPP $CPPFLAGS' |
| 3438 | | ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' |
| 3439 | | ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' |
| 3440 | | ac_compiler_gnu=$ac_cv_c_compiler_gnu |
| 3441 | | |
| 3442 | | |
| 3443 | | { $as_echo "$as_me:$LINENO: checking for grep that handles long lines and -e" >&5 |
| | 5339 | else |
| | 5340 | ac_cv_path_SED=$SED |
| | 5341 | fi |
| | 5342 | |
| | 5343 | fi |
| | 5344 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5 |
| | 5345 | $as_echo "$ac_cv_path_SED" >&6; } |
| | 5346 | SED="$ac_cv_path_SED" |
| | 5347 | rm -f conftest.sed |
| | 5348 | |
| | 5349 | test -z "$SED" && SED=sed |
| | 5350 | Xsed="$SED -e 1s/^X//" |
| | 5351 | |
| | 5352 | |
| | 5353 | |
| | 5354 | |
| | 5355 | |
| | 5356 | |
| | 5357 | |
| | 5358 | |
| | 5359 | |
| | 5360 | |
| | 5361 | |
| | 5362 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 |
| 3577 | | { $as_echo "$as_me:$LINENO: checking for ANSI C header files" >&5 |
| | 5492 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5 |
| | 5493 | $as_echo_n "checking for fgrep... " >&6; } |
| | 5494 | if ${ac_cv_path_FGREP+:} false; then : |
| | 5495 | $as_echo_n "(cached) " >&6 |
| | 5496 | else |
| | 5497 | if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1 |
| | 5498 | then ac_cv_path_FGREP="$GREP -F" |
| | 5499 | else |
| | 5500 | if test -z "$FGREP"; then |
| | 5501 | ac_path_FGREP_found=false |
| | 5502 | # Loop through the user's path and test for each of PROGNAME-LIST |
| | 5503 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 5504 | for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin |
| | 5505 | do |
| | 5506 | IFS=$as_save_IFS |
| | 5507 | test -z "$as_dir" && as_dir=. |
| | 5508 | for ac_prog in fgrep; do |
| | 5509 | for ac_exec_ext in '' $ac_executable_extensions; do |
| | 5510 | ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext" |
| | 5511 | { test -f "$ac_path_FGREP" && $as_test_x "$ac_path_FGREP"; } || continue |
| | 5512 | # Check for GNU ac_path_FGREP and select it if it is found. |
| | 5513 | # Check for GNU $ac_path_FGREP |
| | 5514 | case `"$ac_path_FGREP" --version 2>&1` in |
| | 5515 | *GNU*) |
| | 5516 | ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;; |
| | 5517 | *) |
| | 5518 | ac_count=0 |
| | 5519 | $as_echo_n 0123456789 >"conftest.in" |
| | 5520 | while : |
| | 5521 | do |
| | 5522 | cat "conftest.in" "conftest.in" >"conftest.tmp" |
| | 5523 | mv "conftest.tmp" "conftest.in" |
| | 5524 | cp "conftest.in" "conftest.nl" |
| | 5525 | $as_echo 'FGREP' >> "conftest.nl" |
| | 5526 | "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break |
| | 5527 | diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break |
| | 5528 | as_fn_arith $ac_count + 1 && ac_count=$as_val |
| | 5529 | if test $ac_count -gt ${ac_path_FGREP_max-0}; then |
| | 5530 | # Best one so far, save it but keep looking for a better one |
| | 5531 | ac_cv_path_FGREP="$ac_path_FGREP" |
| | 5532 | ac_path_FGREP_max=$ac_count |
| | 5533 | fi |
| | 5534 | # 10*(2^10) chars as input seems more than enough |
| | 5535 | test $ac_count -gt 10 && break |
| | 5536 | done |
| | 5537 | rm -f conftest.in conftest.tmp conftest.nl conftest.out;; |
| | 5538 | esac |
| | 5539 | |
| | 5540 | $ac_path_FGREP_found && break 3 |
| | 5541 | done |
| | 5542 | done |
| | 5543 | done |
| | 5544 | IFS=$as_save_IFS |
| | 5545 | if test -z "$ac_cv_path_FGREP"; then |
| | 5546 | as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 |
| | 5547 | fi |
| | 5548 | else |
| | 5549 | ac_cv_path_FGREP=$FGREP |
| | 5550 | fi |
| | 5551 | |
| | 5552 | fi |
| | 5553 | fi |
| | 5554 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5 |
| | 5555 | $as_echo "$ac_cv_path_FGREP" >&6; } |
| | 5556 | FGREP="$ac_cv_path_FGREP" |
| | 5557 | |
| | 5558 | |
| | 5559 | test -z "$GREP" && GREP=grep |
| | 5560 | |
| | 5561 | |
| | 5562 | |
| | 5563 | |
| | 5564 | |
| | 5565 | |
| | 5566 | |
| | 5567 | |
| | 5568 | |
| | 5569 | |
| | 5570 | |
| | 5571 | |
| | 5572 | |
| | 5573 | |
| | 5574 | |
| | 5575 | |
| | 5576 | |
| | 5577 | |
| | 5578 | |
| | 5579 | # Check whether --with-gnu-ld was given. |
| | 5580 | if test "${with_gnu_ld+set}" = set; then : |
| | 5581 | withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes |
| | 5582 | else |
| | 5583 | with_gnu_ld=no |
| | 5584 | fi |
| | 5585 | |
| | 5586 | ac_prog=ld |
| | 5587 | if test "$GCC" = yes; then |
| | 5588 | # Check if gcc -print-prog-name=ld gives a path. |
| | 5589 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 |
| | 5590 | $as_echo_n "checking for ld used by $CC... " >&6; } |
| | 5591 | case $host in |
| | 5592 | *-*-mingw*) |
| | 5593 | # gcc leaves a trailing carriage return which upsets mingw |
| | 5594 | ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; |
| | 5595 | *) |
| | 5596 | ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; |
| | 5597 | esac |
| | 5598 | case $ac_prog in |
| | 5599 | # Accept absolute paths. |
| | 5600 | [\\/]* | ?:[\\/]*) |
| | 5601 | re_direlt='/[^/][^/]*/\.\./' |
| | 5602 | # Canonicalize the pathname of ld |
| | 5603 | ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'` |
| | 5604 | while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do |
| | 5605 | ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"` |
| | 5606 | done |
| | 5607 | test -z "$LD" && LD="$ac_prog" |
| | 5608 | ;; |
| | 5609 | "") |
| | 5610 | # If it fails, then pretend we aren't using GCC. |
| | 5611 | ac_prog=ld |
| | 5612 | ;; |
| | 5613 | *) |
| | 5614 | # If it is relative, then search for the first ld in PATH. |
| | 5615 | with_gnu_ld=unknown |
| | 5616 | ;; |
| | 5617 | esac |
| | 5618 | elif test "$with_gnu_ld" = yes; then |
| | 5619 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 |
| | 5620 | $as_echo_n "checking for GNU ld... " >&6; } |
| | 5621 | else |
| | 5622 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 |
| | 5623 | $as_echo_n "checking for non-GNU ld... " >&6; } |
| | 5624 | fi |
| | 5625 | if ${lt_cv_path_LD+:} false; then : |
| | 5626 | $as_echo_n "(cached) " >&6 |
| | 5627 | else |
| | 5628 | if test -z "$LD"; then |
| | 5629 | lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR |
| | 5630 | for ac_dir in $PATH; do |
| | 5631 | IFS="$lt_save_ifs" |
| | 5632 | test -z "$ac_dir" && ac_dir=. |
| | 5633 | if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then |
| | 5634 | lt_cv_path_LD="$ac_dir/$ac_prog" |
| | 5635 | # Check to see if the program is GNU ld. I'd rather use --version, |
| | 5636 | # but apparently some variants of GNU ld only accept -v. |
| | 5637 | # Break only if it was the GNU/non-GNU ld that we prefer. |
| | 5638 | case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in |
| | 5639 | *GNU* | *'with BFD'*) |
| | 5640 | test "$with_gnu_ld" != no && break |
| | 5641 | ;; |
| | 5642 | *) |
| | 5643 | test "$with_gnu_ld" != yes && break |
| | 5644 | ;; |
| | 5645 | esac |
| | 5646 | fi |
| | 5647 | done |
| | 5648 | IFS="$lt_save_ifs" |
| | 5649 | else |
| | 5650 | lt_cv_path_LD="$LD" # Let the user override the test with a path. |
| | 5651 | fi |
| | 5652 | fi |
| | 5653 | |
| | 5654 | LD="$lt_cv_path_LD" |
| | 5655 | if test -n "$LD"; then |
| | 5656 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD" >&5 |
| | 5657 | $as_echo "$LD" >&6; } |
| | 5658 | else |
| | 5659 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 |
| | 5660 | $as_echo "no" >&6; } |
| | 5661 | fi |
| | 5662 | test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5 |
| | 5663 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 |
| | 5664 | $as_echo_n "checking if the linker ($LD) is GNU ld... " >&6; } |
| | 5665 | if ${lt_cv_prog_gnu_ld+:} false; then : |
| | 5666 | $as_echo_n "(cached) " >&6 |
| | 5667 | else |
| | 5668 | # I'd rather use --version here, but apparently some GNU lds only accept -v. |
| | 5669 | case `$LD -v 2>&1 </dev/null` in |
| | 5670 | *GNU* | *'with BFD'*) |
| | 5671 | lt_cv_prog_gnu_ld=yes |
| | 5672 | ;; |
| | 5673 | *) |
| | 5674 | lt_cv_prog_gnu_ld=no |
| | 5675 | ;; |
| | 5676 | esac |
| | 5677 | fi |
| | 5678 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5 |
| | 5679 | $as_echo "$lt_cv_prog_gnu_ld" >&6; } |
| | 5680 | with_gnu_ld=$lt_cv_prog_gnu_ld |
| | 5681 | |
| | 5682 | |
| | 5683 | |
| | 5684 | |
| | 5685 | |
| | 5686 | |
| | 5687 | |
| | 5688 | |
| | 5689 | |
| | 5690 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5 |
| | 5691 | $as_echo_n "checking for BSD- or MS-compatible name lister (nm)... " >&6; } |
| | 5692 | if ${lt_cv_path_NM+:} false; then : |
| | 5693 | $as_echo_n "(cached) " >&6 |
| | 5694 | else |
| | 5695 | if test -n "$NM"; then |
| | 5696 | # Let the user override the test. |
| | 5697 | lt_cv_path_NM="$NM" |
| | 5698 | else |
| | 5699 | lt_nm_to_check="${ac_tool_prefix}nm" |
| | 5700 | if test -n "$ac_tool_prefix" && test "$build" = "$host"; then |
| | 5701 | lt_nm_to_check="$lt_nm_to_check nm" |
| | 5702 | fi |
| | 5703 | for lt_tmp_nm in $lt_nm_to_check; do |
| | 5704 | lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR |
| | 5705 | for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do |
| | 5706 | IFS="$lt_save_ifs" |
| | 5707 | test -z "$ac_dir" && ac_dir=. |
| | 5708 | tmp_nm="$ac_dir/$lt_tmp_nm" |
| | 5709 | if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then |
| | 5710 | # Check to see if the nm accepts a BSD-compat flag. |
| | 5711 | # Adding the `sed 1q' prevents false positives on HP-UX, which says: |
| | 5712 | # nm: unknown option "B" ignored |
| | 5713 | # Tru64's nm complains that /dev/null is an invalid object file |
| | 5714 | case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in |
| | 5715 | */dev/null* | *'Invalid file or object type'*) |
| | 5716 | lt_cv_path_NM="$tmp_nm -B" |
| | 5717 | break |
| | 5718 | ;; |
| | 5719 | *) |
| | 5720 | case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in |
| | 5721 | */dev/null*) |
| | 5722 | lt_cv_path_NM="$tmp_nm -p" |
| | 5723 | break |
| | 5724 | ;; |
| | 5725 | *) |
| | 5726 | lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but |
| | 5727 | continue # so that we can try to find one that supports BSD flags |
| | 5728 | ;; |
| | 5729 | esac |
| | 5730 | ;; |
| | 5731 | esac |
| | 5732 | fi |
| | 5733 | done |
| | 5734 | IFS="$lt_save_ifs" |
| | 5735 | done |
| | 5736 | : ${lt_cv_path_NM=no} |
| | 5737 | fi |
| | 5738 | fi |
| | 5739 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5 |
| | 5740 | $as_echo "$lt_cv_path_NM" >&6; } |
| | 5741 | if test "$lt_cv_path_NM" != "no"; then |
| | 5742 | NM="$lt_cv_path_NM" |
| | 5743 | else |
| | 5744 | # Didn't find any BSD compatible name lister, look for dumpbin. |
| | 5745 | if test -n "$DUMPBIN"; then : |
| | 5746 | # Let the user override the test. |
| | 5747 | else |
| | 5748 | if test -n "$ac_tool_prefix"; then |
| | 5749 | for ac_prog in dumpbin "link -dump" |
| | 5750 | do |
| | 5751 | # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. |
| | 5752 | set dummy $ac_tool_prefix$ac_prog; ac_word=$2 |
| | 5753 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 |
| | 5754 | $as_echo_n "checking for $ac_word... " >&6; } |
| | 5755 | if ${ac_cv_prog_DUMPBIN+:} false; then : |
| | 5756 | $as_echo_n "(cached) " >&6 |
| | 5757 | else |
| | 5758 | if test -n "$DUMPBIN"; then |
| | 5759 | ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test. |
| | 5760 | else |
| | 5761 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 5762 | for as_dir in $PATH |
| | 5763 | do |
| | 5764 | IFS=$as_save_IFS |
| | 5765 | test -z "$as_dir" && as_dir=. |
| | 5766 | for ac_exec_ext in '' $ac_executable_extensions; do |
| | 5767 | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| | 5768 | ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog" |
| | 5769 | $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| | 5770 | break 2 |
| | 5771 | fi |
| | 5772 | done |
| | 5773 | done |
| | 5774 | IFS=$as_save_IFS |
| | 5775 | |
| | 5776 | fi |
| | 5777 | fi |
| | 5778 | DUMPBIN=$ac_cv_prog_DUMPBIN |
| | 5779 | if test -n "$DUMPBIN"; then |
| | 5780 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5 |
| | 5781 | $as_echo "$DUMPBIN" >&6; } |
| | 5782 | else |
| | 5783 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 |
| | 5784 | $as_echo "no" >&6; } |
| | 5785 | fi |
| | 5786 | |
| | 5787 | |
| | 5788 | test -n "$DUMPBIN" && break |
| | 5789 | done |
| | 5790 | fi |
| | 5791 | if test -z "$DUMPBIN"; then |
| | 5792 | ac_ct_DUMPBIN=$DUMPBIN |
| | 5793 | for ac_prog in dumpbin "link -dump" |
| | 5794 | do |
| | 5795 | # Extract the first word of "$ac_prog", so it can be a program name with args. |
| | 5796 | set dummy $ac_prog; ac_word=$2 |
| | 5797 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 |
| | 5798 | $as_echo_n "checking for $ac_word... " >&6; } |
| | 5799 | if ${ac_cv_prog_ac_ct_DUMPBIN+:} false; then : |
| | 5800 | $as_echo_n "(cached) " >&6 |
| | 5801 | else |
| | 5802 | if test -n "$ac_ct_DUMPBIN"; then |
| | 5803 | ac_cv_prog_ac_ct_DUMPBIN="$ac_ct_DUMPBIN" # Let the user override the test. |
| | 5804 | else |
| | 5805 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 5806 | for as_dir in $PATH |
| | 5807 | do |
| | 5808 | IFS=$as_save_IFS |
| | 5809 | test -z "$as_dir" && as_dir=. |
| | 5810 | for ac_exec_ext in '' $ac_executable_extensions; do |
| | 5811 | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| | 5812 | ac_cv_prog_ac_ct_DUMPBIN="$ac_prog" |
| | 5813 | $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| | 5814 | break 2 |
| | 5815 | fi |
| | 5816 | done |
| | 5817 | done |
| | 5818 | IFS=$as_save_IFS |
| | 5819 | |
| | 5820 | fi |
| | 5821 | fi |
| | 5822 | ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN |
| | 5823 | if test -n "$ac_ct_DUMPBIN"; then |
| | 5824 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5 |
| | 5825 | $as_echo "$ac_ct_DUMPBIN" >&6; } |
| | 5826 | else |
| | 5827 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 |
| | 5828 | $as_echo "no" >&6; } |
| | 5829 | fi |
| | 5830 | |
| | 5831 | |
| | 5832 | test -n "$ac_ct_DUMPBIN" && break |
| | 5833 | done |
| | 5834 | |
| | 5835 | if test "x$ac_ct_DUMPBIN" = x; then |
| | 5836 | DUMPBIN=":" |
| | 5837 | else |
| | 5838 | case $cross_compiling:$ac_tool_warned in |
| | 5839 | yes:) |
| | 5840 | { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 |
| | 5841 | $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} |
| | 5842 | ac_tool_warned=yes ;; |
| | 5843 | esac |
| | 5844 | DUMPBIN=$ac_ct_DUMPBIN |
| | 5845 | fi |
| | 5846 | fi |
| | 5847 | |
| | 5848 | case `$DUMPBIN -symbols /dev/null 2>&1 | sed '1q'` in |
| | 5849 | *COFF*) |
| | 5850 | DUMPBIN="$DUMPBIN -symbols" |
| | 5851 | ;; |
| | 5852 | *) |
| | 5853 | DUMPBIN=: |
| | 5854 | ;; |
| | 5855 | esac |
| | 5856 | fi |
| | 5857 | |
| | 5858 | if test "$DUMPBIN" != ":"; then |
| | 5859 | NM="$DUMPBIN" |
| | 5860 | fi |
| | 5861 | fi |
| | 5862 | test -z "$NM" && NM=nm |
| | 5863 | |
| | 5864 | |
| | 5865 | |
| | 5866 | |
| | 5867 | |
| | 5868 | |
| | 5869 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5 |
| | 5870 | $as_echo_n "checking the name lister ($NM) interface... " >&6; } |
| | 5871 | if ${lt_cv_nm_interface+:} false; then : |
| | 5872 | $as_echo_n "(cached) " >&6 |
| | 5873 | else |
| | 5874 | lt_cv_nm_interface="BSD nm" |
| | 5875 | echo "int some_variable = 0;" > conftest.$ac_ext |
| | 5876 | (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&5) |
| | 5877 | (eval "$ac_compile" 2>conftest.err) |
| | 5878 | cat conftest.err >&5 |
| | 5879 | (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&5) |
| | 5880 | (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out) |
| | 5881 | cat conftest.err >&5 |
| | 5882 | (eval echo "\"\$as_me:$LINENO: output\"" >&5) |
| | 5883 | cat conftest.out >&5 |
| | 5884 | if $GREP 'External.*some_variable' conftest.out > /dev/null; then |
| | 5885 | lt_cv_nm_interface="MS dumpbin" |
| | 5886 | fi |
| | 5887 | rm -f conftest* |
| | 5888 | fi |
| | 5889 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5 |
| | 5890 | $as_echo "$lt_cv_nm_interface" >&6; } |
| | 5891 | |
| | 5892 | # find the maximum length of command line arguments |
| | 5893 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5 |
| | 5894 | $as_echo_n "checking the maximum length of command line arguments... " >&6; } |
| | 5895 | if ${lt_cv_sys_max_cmd_len+:} false; then : |
| | 5896 | $as_echo_n "(cached) " >&6 |
| | 5897 | else |
| | 5898 | i=0 |
| | 5899 | teststring="ABCD" |
| | 5900 | |
| | 5901 | case $build_os in |
| | 5902 | msdosdjgpp*) |
| | 5903 | # On DJGPP, this test can blow up pretty badly due to problems in libc |
| | 5904 | # (any single argument exceeding 2000 bytes causes a buffer overrun |
| | 5905 | # during glob expansion). Even if it were fixed, the result of this |
| | 5906 | # check would be larger than it should be. |
| | 5907 | lt_cv_sys_max_cmd_len=12288; # 12K is about right |
| | 5908 | ;; |
| | 5909 | |
| | 5910 | gnu*) |
| | 5911 | # Under GNU Hurd, this test is not required because there is |
| | 5912 | # no limit to the length of command line arguments. |
| | 5913 | # Libtool will interpret -1 as no limit whatsoever |
| | 5914 | lt_cv_sys_max_cmd_len=-1; |
| | 5915 | ;; |
| | 5916 | |
| | 5917 | cygwin* | mingw* | cegcc*) |
| | 5918 | # On Win9x/ME, this test blows up -- it succeeds, but takes |
| | 5919 | # about 5 minutes as the teststring grows exponentially. |
| | 5920 | # Worse, since 9x/ME are not pre-emptively multitasking, |
| | 5921 | # you end up with a "frozen" computer, even though with patience |
| | 5922 | # the test eventually succeeds (with a max line length of 256k). |
| | 5923 | # Instead, let's just punt: use the minimum linelength reported by |
| | 5924 | # all of the supported platforms: 8192 (on NT/2K/XP). |
| | 5925 | lt_cv_sys_max_cmd_len=8192; |
| | 5926 | ;; |
| | 5927 | |
| | 5928 | mint*) |
| | 5929 | # On MiNT this can take a long time and run out of memory. |
| | 5930 | lt_cv_sys_max_cmd_len=8192; |
| | 5931 | ;; |
| | 5932 | |
| | 5933 | amigaos*) |
| | 5934 | # On AmigaOS with pdksh, this test takes hours, literally. |
| | 5935 | # So we just punt and use a minimum line length of 8192. |
| | 5936 | lt_cv_sys_max_cmd_len=8192; |
| | 5937 | ;; |
| | 5938 | |
| | 5939 | netbsd* | freebsd* | openbsd* | darwin* | dragonfly*) |
| | 5940 | # This has been around since 386BSD, at least. Likely further. |
| | 5941 | if test -x /sbin/sysctl; then |
| | 5942 | lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax` |
| | 5943 | elif test -x /usr/sbin/sysctl; then |
| | 5944 | lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax` |
| | 5945 | else |
| | 5946 | lt_cv_sys_max_cmd_len=65536 # usable default for all BSDs |
| | 5947 | fi |
| | 5948 | # And add a safety zone |
| | 5949 | lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` |
| | 5950 | lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` |
| | 5951 | ;; |
| | 5952 | |
| | 5953 | interix*) |
| | 5954 | # We know the value 262144 and hardcode it with a safety zone (like BSD) |
| | 5955 | lt_cv_sys_max_cmd_len=196608 |
| | 5956 | ;; |
| | 5957 | |
| | 5958 | os2*) |
| | 5959 | # The test takes a long time on OS/2. |
| | 5960 | lt_cv_sys_max_cmd_len=8192 |
| | 5961 | ;; |
| | 5962 | |
| | 5963 | osf*) |
| | 5964 | # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure |
| | 5965 | # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not |
| | 5966 | # nice to cause kernel panics so lets avoid the loop below. |
| | 5967 | # First set a reasonable default. |
| | 5968 | lt_cv_sys_max_cmd_len=16384 |
| | 5969 | # |
| | 5970 | if test -x /sbin/sysconfig; then |
| | 5971 | case `/sbin/sysconfig -q proc exec_disable_arg_limit` in |
| | 5972 | *1*) lt_cv_sys_max_cmd_len=-1 ;; |
| | 5973 | esac |
| | 5974 | fi |
| | 5975 | ;; |
| | 5976 | sco3.2v5*) |
| | 5977 | lt_cv_sys_max_cmd_len=102400 |
| | 5978 | ;; |
| | 5979 | sysv5* | sco5v6* | sysv4.2uw2*) |
| | 5980 | kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null` |
| | 5981 | if test -n "$kargmax"; then |
| | 5982 | lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[ ]//'` |
| | 5983 | else |
| | 5984 | lt_cv_sys_max_cmd_len=32768 |
| | 5985 | fi |
| | 5986 | ;; |
| | 5987 | *) |
| | 5988 | lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null` |
| | 5989 | if test -n "$lt_cv_sys_max_cmd_len"; then |
| | 5990 | lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` |
| | 5991 | lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` |
| | 5992 | else |
| | 5993 | # Make teststring a little bigger before we do anything with it. |
| | 5994 | # a 1K string should be a reasonable start. |
| | 5995 | for i in 1 2 3 4 5 6 7 8 ; do |
| | 5996 | teststring=$teststring$teststring |
| | 5997 | done |
| | 5998 | SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}} |
| | 5999 | # If test is not a shell built-in, we'll probably end up computing a |
| | 6000 | # maximum length that is only half of the actual maximum length, but |
| | 6001 | # we can't tell. |
| | 6002 | while { test "X"`env echo "$teststring$teststring" 2>/dev/null` \ |
| | 6003 | = "X$teststring$teststring"; } >/dev/null 2>&1 && |
| | 6004 | test $i != 17 # 1/2 MB should be enough |
| | 6005 | do |
| | 6006 | i=`expr $i + 1` |
| | 6007 | teststring=$teststring$teststring |
| | 6008 | done |
| | 6009 | # Only check the string length outside the loop. |
| | 6010 | lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1` |
| | 6011 | teststring= |
| | 6012 | # Add a significant safety factor because C++ compilers can tack on |
| | 6013 | # massive amounts of additional arguments before passing them to the |
| | 6014 | # linker. It appears as though 1/2 is a usable value. |
| | 6015 | lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2` |
| | 6016 | fi |
| | 6017 | ;; |
| | 6018 | esac |
| | 6019 | |
| | 6020 | fi |
| | 6021 | |
| | 6022 | if test -n $lt_cv_sys_max_cmd_len ; then |
| | 6023 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5 |
| | 6024 | $as_echo "$lt_cv_sys_max_cmd_len" >&6; } |
| | 6025 | else |
| | 6026 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5 |
| | 6027 | $as_echo "none" >&6; } |
| | 6028 | fi |
| | 6029 | max_cmd_len=$lt_cv_sys_max_cmd_len |
| | 6030 | |
| | 6031 | |
| | 6032 | |
| | 6033 | |
| | 6034 | |
| | 6035 | |
| | 6036 | : ${CP="cp -f"} |
| | 6037 | : ${MV="mv -f"} |
| | 6038 | : ${RM="rm -f"} |
| | 6039 | |
| | 6040 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands some XSI constructs" >&5 |
| | 6041 | $as_echo_n "checking whether the shell understands some XSI constructs... " >&6; } |
| | 6042 | # Try some XSI features |
| | 6043 | xsi_shell=no |
| | 6044 | ( _lt_dummy="a/b/c" |
| | 6045 | test "${_lt_dummy##*/},${_lt_dummy%/*},${_lt_dummy#??}"${_lt_dummy%"$_lt_dummy"}, \ |
| | 6046 | = c,a/b,b/c, \ |
| | 6047 | && eval 'test $(( 1 + 1 )) -eq 2 \ |
| | 6048 | && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \ |
| | 6049 | && xsi_shell=yes |
| | 6050 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $xsi_shell" >&5 |
| | 6051 | $as_echo "$xsi_shell" >&6; } |
| | 6052 | |
| | 6053 | |
| | 6054 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands \"+=\"" >&5 |
| | 6055 | $as_echo_n "checking whether the shell understands \"+=\"... " >&6; } |
| | 6056 | lt_shell_append=no |
| | 6057 | ( foo=bar; set foo baz; eval "$1+=\$2" && test "$foo" = barbaz ) \ |
| | 6058 | >/dev/null 2>&1 \ |
| | 6059 | && lt_shell_append=yes |
| | 6060 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_shell_append" >&5 |
| | 6061 | $as_echo "$lt_shell_append" >&6; } |
| | 6062 | |
| | 6063 | |
| | 6064 | if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then |
| | 6065 | lt_unset=unset |
| | 6066 | else |
| | 6067 | lt_unset=false |
| | 6068 | fi |
| | 6069 | |
| | 6070 | |
| | 6071 | |
| | 6072 | |
| | 6073 | |
| | 6074 | # test EBCDIC or ASCII |
| | 6075 | case `echo X|tr X '\101'` in |
| | 6076 | A) # ASCII based system |
| | 6077 | # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr |
| | 6078 | lt_SP2NL='tr \040 \012' |
| | 6079 | lt_NL2SP='tr \015\012 \040\040' |
| | 6080 | ;; |
| | 6081 | *) # EBCDIC based system |
| | 6082 | lt_SP2NL='tr \100 \n' |
| | 6083 | lt_NL2SP='tr \r\n \100\100' |
| | 6084 | ;; |
| | 6085 | esac |
| | 6086 | |
| | 6087 | |
| | 6088 | |
| | 6089 | |
| | 6090 | |
| | 6091 | |
| | 6092 | |
| | 6093 | |
| | 6094 | |
| | 6095 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to $host format" >&5 |
| | 6096 | $as_echo_n "checking how to convert $build file names to $host format... " >&6; } |
| | 6097 | if ${lt_cv_to_host_file_cmd+:} false; then : |
| | 6098 | $as_echo_n "(cached) " >&6 |
| | 6099 | else |
| | 6100 | case $host in |
| | 6101 | *-*-mingw* ) |
| | 6102 | case $build in |
| | 6103 | *-*-mingw* ) # actually msys |
| | 6104 | lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32 |
| | 6105 | ;; |
| | 6106 | *-*-cygwin* ) |
| | 6107 | lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32 |
| | 6108 | ;; |
| | 6109 | * ) # otherwise, assume *nix |
| | 6110 | lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32 |
| | 6111 | ;; |
| | 6112 | esac |
| | 6113 | ;; |
| | 6114 | *-*-cygwin* ) |
| | 6115 | case $build in |
| | 6116 | *-*-mingw* ) # actually msys |
| | 6117 | lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin |
| | 6118 | ;; |
| | 6119 | *-*-cygwin* ) |
| | 6120 | lt_cv_to_host_file_cmd=func_convert_file_noop |
| | 6121 | ;; |
| | 6122 | * ) # otherwise, assume *nix |
| | 6123 | lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin |
| | 6124 | ;; |
| | 6125 | esac |
| | 6126 | ;; |
| | 6127 | * ) # unhandled hosts (and "normal" native builds) |
| | 6128 | lt_cv_to_host_file_cmd=func_convert_file_noop |
| | 6129 | ;; |
| | 6130 | esac |
| | 6131 | |
| | 6132 | fi |
| | 6133 | |
| | 6134 | to_host_file_cmd=$lt_cv_to_host_file_cmd |
| | 6135 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_host_file_cmd" >&5 |
| | 6136 | $as_echo "$lt_cv_to_host_file_cmd" >&6; } |
| | 6137 | |
| | 6138 | |
| | 6139 | |
| | 6140 | |
| | 6141 | |
| | 6142 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to toolchain format" >&5 |
| | 6143 | $as_echo_n "checking how to convert $build file names to toolchain format... " >&6; } |
| | 6144 | if ${lt_cv_to_tool_file_cmd+:} false; then : |
| | 6145 | $as_echo_n "(cached) " >&6 |
| | 6146 | else |
| | 6147 | #assume ordinary cross tools, or native build. |
| | 6148 | lt_cv_to_tool_file_cmd=func_convert_file_noop |
| | 6149 | case $host in |
| | 6150 | *-*-mingw* ) |
| | 6151 | case $build in |
| | 6152 | *-*-mingw* ) # actually msys |
| | 6153 | lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32 |
| | 6154 | ;; |
| | 6155 | esac |
| | 6156 | ;; |
| | 6157 | esac |
| | 6158 | |
| | 6159 | fi |
| | 6160 | |
| | 6161 | to_tool_file_cmd=$lt_cv_to_tool_file_cmd |
| | 6162 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_tool_file_cmd" >&5 |
| | 6163 | $as_echo "$lt_cv_to_tool_file_cmd" >&6; } |
| | 6164 | |
| | 6165 | |
| | 6166 | |
| | 6167 | |
| | 6168 | |
| | 6169 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5 |
| | 6170 | $as_echo_n "checking for $LD option to reload object files... " >&6; } |
| | 6171 | if ${lt_cv_ld_reload_flag+:} false; then : |
| | 6172 | $as_echo_n "(cached) " >&6 |
| | 6173 | else |
| | 6174 | lt_cv_ld_reload_flag='-r' |
| | 6175 | fi |
| | 6176 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5 |
| | 6177 | $as_echo "$lt_cv_ld_reload_flag" >&6; } |
| | 6178 | reload_flag=$lt_cv_ld_reload_flag |
| | 6179 | case $reload_flag in |
| | 6180 | "" | " "*) ;; |
| | 6181 | *) reload_flag=" $reload_flag" ;; |
| | 6182 | esac |
| | 6183 | reload_cmds='$LD$reload_flag -o $output$reload_objs' |
| | 6184 | case $host_os in |
| | 6185 | cygwin* | mingw* | pw32* | cegcc*) |
| | 6186 | if test "$GCC" != yes; then |
| | 6187 | reload_cmds=false |
| | 6188 | fi |
| | 6189 | ;; |
| | 6190 | darwin*) |
| | 6191 | if test "$GCC" = yes; then |
| | 6192 | reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs' |
| | 6193 | else |
| | 6194 | reload_cmds='$LD$reload_flag -o $output$reload_objs' |
| | 6195 | fi |
| | 6196 | ;; |
| | 6197 | esac |
| | 6198 | |
| | 6199 | |
| | 6200 | |
| | 6201 | |
| | 6202 | |
| | 6203 | |
| | 6204 | |
| | 6205 | |
| | 6206 | |
| | 6207 | if test -n "$ac_tool_prefix"; then |
| | 6208 | # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args. |
| | 6209 | set dummy ${ac_tool_prefix}objdump; ac_word=$2 |
| | 6210 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 |
| | 6211 | $as_echo_n "checking for $ac_word... " >&6; } |
| | 6212 | if ${ac_cv_prog_OBJDUMP+:} false; then : |
| | 6213 | $as_echo_n "(cached) " >&6 |
| | 6214 | else |
| | 6215 | if test -n "$OBJDUMP"; then |
| | 6216 | ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test. |
| | 6217 | else |
| | 6218 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 6219 | for as_dir in $PATH |
| | 6220 | do |
| | 6221 | IFS=$as_save_IFS |
| | 6222 | test -z "$as_dir" && as_dir=. |
| | 6223 | for ac_exec_ext in '' $ac_executable_extensions; do |
| | 6224 | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| | 6225 | ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump" |
| | 6226 | $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| | 6227 | break 2 |
| | 6228 | fi |
| | 6229 | done |
| | 6230 | done |
| | 6231 | IFS=$as_save_IFS |
| | 6232 | |
| | 6233 | fi |
| | 6234 | fi |
| | 6235 | OBJDUMP=$ac_cv_prog_OBJDUMP |
| | 6236 | if test -n "$OBJDUMP"; then |
| | 6237 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5 |
| | 6238 | $as_echo "$OBJDUMP" >&6; } |
| | 6239 | else |
| | 6240 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 |
| | 6241 | $as_echo "no" >&6; } |
| | 6242 | fi |
| | 6243 | |
| | 6244 | |
| | 6245 | fi |
| | 6246 | if test -z "$ac_cv_prog_OBJDUMP"; then |
| | 6247 | ac_ct_OBJDUMP=$OBJDUMP |
| | 6248 | # Extract the first word of "objdump", so it can be a program name with args. |
| | 6249 | set dummy objdump; ac_word=$2 |
| | 6250 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 |
| | 6251 | $as_echo_n "checking for $ac_word... " >&6; } |
| | 6252 | if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then : |
| | 6253 | $as_echo_n "(cached) " >&6 |
| | 6254 | else |
| | 6255 | if test -n "$ac_ct_OBJDUMP"; then |
| | 6256 | ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test. |
| | 6257 | else |
| | 6258 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 6259 | for as_dir in $PATH |
| | 6260 | do |
| | 6261 | IFS=$as_save_IFS |
| | 6262 | test -z "$as_dir" && as_dir=. |
| | 6263 | for ac_exec_ext in '' $ac_executable_extensions; do |
| | 6264 | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| | 6265 | ac_cv_prog_ac_ct_OBJDUMP="objdump" |
| | 6266 | $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| | 6267 | break 2 |
| | 6268 | fi |
| | 6269 | done |
| | 6270 | done |
| | 6271 | IFS=$as_save_IFS |
| | 6272 | |
| | 6273 | fi |
| | 6274 | fi |
| | 6275 | ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP |
| | 6276 | if test -n "$ac_ct_OBJDUMP"; then |
| | 6277 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5 |
| | 6278 | $as_echo "$ac_ct_OBJDUMP" >&6; } |
| | 6279 | else |
| | 6280 | { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 |
| | 6281 | $as_echo "no" >&6; } |
| | 6282 | fi |
| | 6283 | |
| | 6284 | if test "x$ac_ct_OBJDUMP" = x; then |
| | 6285 | OBJDUMP="false" |
| | 6286 | else |
| | 6287 | case $cross_compiling:$ac_tool_warned in |
| | 6288 | yes:) |
| | 6289 | { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 |
| | 6290 | $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} |
| | 6291 | ac_tool_warned=yes ;; |
| | 6292 | esac |
| | 6293 | OBJDUMP=$ac_ct_OBJDUMP |
| | 6294 | fi |
| | 6295 | else |
| | 6296 | OBJDUMP="$ac_cv_prog_OBJDUMP" |
| | 6297 | fi |
| | 6298 | |
| | 6299 | test -z "$OBJDUMP" && OBJDUMP=objdump |
| | 6300 | |
| | 6301 | |
| | 6302 | |
| | 6303 | |
| | 6304 | |
| | 6305 | |
| | 6306 | |
| | 6307 | |
| | 6308 | |
| | 6309 | { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5 |
| | 6310 | $as_echo_n "checking how to recognize dependent libraries... " >&6; } |
| | 6311 | if ${lt_cv_deplibs_check_method+:} false; then : |
| | 6312 | $as_echo_n "(cached) " >&6 |
| | 6313 | else |
| | 6314 | lt_cv_file_magic_cmd='$MAGIC_CMD' |
| | 6315 | lt_cv_file_magic_test_file= |
| | 6316 | lt_cv_deplibs_check_method='unknown' |
| | 6317 | # Need to set the preceding variable on all platforms that support |
| | 6318 | # interlibrary dependencies. |
| | 6319 | # 'none' -- dependencies not supported. |
| | 6320 | # `unknown' -- same as none, but documents that we really don't know. |
| | 6321 | # 'pass_all' -- all dependencies passed with no checks. |
| | 6322 | # 'test_compile' -- check by making test program. |
| | 6323 | # 'file_magic [[regex]]' -- check by looking for files in library path |
| | 6324 | # which responds to the $file_magic_cmd with a given extended regex. |
| | 6325 | # If you have `file' or equivalent on your system and you're not sure |
| | 6326 | # whether `pass_all' will *always* work, you probably want this one. |
| | 6327 | |
| | 6328 | case $host_os in |
| | 6329 | aix[4-9]*) |
| | 6330 | lt_cv_deplibs_check_method=pass_all |
| | 6331 | ;; |
| | 6332 | |
| | 6333 | beos*) |
| | 6334 | lt_cv_deplibs_check_method=pass_all |
| | 6335 | ;; |
| | 6336 | |
| | 6337 | bsdi[45]*) |
| | 6338 | lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)' |
| | 6339 | lt_cv_file_magic_cmd='/usr/bin/file -L' |
| | 6340 | lt_cv_file_magic_test_file=/shlib/libc.so |
| | 6341 | ;; |
| | 6342 | |
| | 6343 | cygwin*) |
| | 6344 | # func_win32_libid is a shell function defined in ltmain.sh |
| | 6345 | lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL' |
| | 6346 | lt_cv_file_magic_cmd='func_win32_libid' |
| | 6347 | ;; |
| | 6348 | |
| | 6349 | mingw* | pw32*) |
| | 6350 | # Base MSYS/MinGW do not provide the 'file' command needed by |
| | 6351 | # func_win32_libid shell function, so use a weaker test based on 'objdump', |
| | 6352 | # unless we find 'file', for example because we are cross-compiling. |
| | 6353 | # func_win32_libid assumes BSD nm, so disallow it if using MS dumpbin. |
| | 6354 | if ( test "$lt_cv_nm_interface" = "BSD nm" && file / ) >/dev/null 2>&1; then |
| | 6355 | lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL' |
| | 6356 | lt_cv_file_magic_cmd='func_win32_libid' |
| | 6357 | else |
| | 6358 | # Keep this pattern in sync with the one in func_win32_libid. |
| | 6359 | lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' |
| | 6360 | lt_cv_file_magic_cmd='$OBJDUMP -f' |
| | 6361 | fi |
| | 6362 | ;; |
| | 6363 | |
| | 6364 | cegcc*) |
| | 6365 | # use the weaker test based on 'objdump'. See mingw*. |
