libgfortran/configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59 for GNU Fortran Runtime Library 0.2.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME='GNU Fortran Runtime Library'
 269 PACKAGE_TARNAME='libgfortran'
 270 PACKAGE_VERSION='0.2'
 271 PACKAGE_STRING='GNU Fortran Runtime Library 0.2'
 272 PACKAGE_BUGREPORT=''
 273
 274 # Factoring default headers for most tests.
 275 ac_includes_default="\
 276 #include <stdio.h>
 277 #if HAVE_SYS_TYPES_H
 278 # include <sys/types.h>
 279 #endif
 280 #if HAVE_SYS_STAT_H
 281 # include <sys/stat.h>
 282 #endif
 283 #if STDC_HEADERS
 284 # include <stdlib.h>
 285 # include <stddef.h>
 286 #else
 287 # if HAVE_STDLIB_H
 288 #  include <stdlib.h>
 289 # endif
 290 #endif
 291 #if HAVE_STRING_H
 292 # if !STDC_HEADERS && HAVE_MEMORY_H
 293 #  include <memory.h>
 294 # endif
 295 # include <string.h>
 296 #endif
 297 #if HAVE_STRINGS_H
 298 # include <strings.h>
 299 #endif
 300 #if HAVE_INTTYPES_H
 301 # include <inttypes.h>
 302 #else
 303 # if HAVE_STDINT_H
 304 #  include <stdint.h>
 305 # endif
 306 #endif
 307 #if HAVE_UNISTD_H
 308 # include <unistd.h>
 309 #endif"
 310
 311 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA CYGPATH_W PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM mkdir_p AWK SET_MAKE am__leading_dot AMTAR am__tar am__untar MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT multi_basedir toolexecdir toolexeclibdir CC ac_ct_CC EXEEXT OBJEXT AM_FCFLAGS AM_CFLAGS AS ac_ct_AS AR ac_ct_AR RANLIB ac_ct_RANLIB LN_S LIBTOOL enable_shared enable_static FC FCFLAGS LDFLAGS ac_ct_FC extra_ldflags_libgfortran CPP CPPFLAGS EGREP FPU_HOST_HEADER LIBOBJS LTLIBOBJS'
 312 ac_subst_files=''
 313
 314 # Initialize some variables set by options.
 315 ac_init_help=
 316 ac_init_version=false
 317 # The variables have the same names as the options, with
 318 # dashes changed to underlines.
 319 cache_file=/dev/null
 320 exec_prefix=NONE
 321 no_create=
 322 no_recursion=
 323 prefix=NONE
 324 program_prefix=NONE
 325 program_suffix=NONE
 326 program_transform_name=s,x,x,
 327 silent=
 328 site=
 329 srcdir=
 330 verbose=
 331 x_includes=NONE
 332 x_libraries=NONE
 333
 334 # Installation directory options.
 335 # These are left unexpanded so users can "make install exec_prefix=/foo"
 336 # and all the variables that are supposed to be based on exec_prefix
 337 # by default will actually change.
 338 # Use braces instead of parens because sh, perl, etc. also accept them.
 339 bindir='${exec_prefix}/bin'
 340 sbindir='${exec_prefix}/sbin'
 341 libexecdir='${exec_prefix}/libexec'
 342 datadir='${prefix}/share'
 343 sysconfdir='${prefix}/etc'
 344 sharedstatedir='${prefix}/com'
 345 localstatedir='${prefix}/var'
 346 libdir='${exec_prefix}/lib'
 347 includedir='${prefix}/include'
 348 oldincludedir='/usr/include'
 349 infodir='${prefix}/info'
 350 mandir='${prefix}/man'
 351
 352 ac_prev=
 353 for ac_option
 354 do
 355   # If the previous option needs an argument, assign it.
 356   if test -n "$ac_prev"; then
 357     eval "$ac_prev=\$ac_option"
 358     ac_prev=
 359     continue
 360   fi
 361
 362   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 363
 364   # Accept the important Cygnus configure options, so we can diagnose typos.
 365
 366   case $ac_option in
 367
 368   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 369     ac_prev=bindir ;;
 370   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 371     bindir=$ac_optarg ;;
 372
 373   -build | --build | --buil | --bui | --bu)
 374     ac_prev=build_alias ;;
 375   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 376     build_alias=$ac_optarg ;;
 377
 378   -cache-file | --cache-file | --cache-fil | --cache-fi \
 379   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 380     ac_prev=cache_file ;;
 381   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 382   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 383     cache_file=$ac_optarg ;;
 384
 385   --config-cache | -C)
 386     cache_file=config.cache ;;
 387
 388   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 389     ac_prev=datadir ;;
 390   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 391   | --da=*)
 392     datadir=$ac_optarg ;;
 393
 394   -disable-* | --disable-*)
 395     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 396     # Reject names that are not valid shell variable names.
 397     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 398       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 399    { (exit 1); exit 1; }; }
 400     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 401     eval "enable_$ac_feature=no" ;;
 402
 403   -enable-* | --enable-*)
 404     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 405     # Reject names that are not valid shell variable names.
 406     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 407       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 408    { (exit 1); exit 1; }; }
 409     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 410     case $ac_option in
 411       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 412       *) ac_optarg=yes ;;
 413     esac
 414     eval "enable_$ac_feature='$ac_optarg'" ;;
 415
 416   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 417   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 418   | --exec | --exe | --ex)
 419     ac_prev=exec_prefix ;;
 420   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 421   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 422   | --exec=* | --exe=* | --ex=*)
 423     exec_prefix=$ac_optarg ;;
 424
 425   -gas | --gas | --ga | --g)
 426     # Obsolete; use --with-gas.
 427     with_gas=yes ;;
 428
 429   -help | --help | --hel | --he | -h)
 430     ac_init_help=long ;;
 431   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 432     ac_init_help=recursive ;;
 433   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 434     ac_init_help=short ;;
 435
 436   -host | --host | --hos | --ho)
 437     ac_prev=host_alias ;;
 438   -host=* | --host=* | --hos=* | --ho=*)
 439     host_alias=$ac_optarg ;;
 440
 441   -includedir | --includedir | --includedi | --included | --include \
 442   | --includ | --inclu | --incl | --inc)
 443     ac_prev=includedir ;;
 444   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 445   | --includ=* | --inclu=* | --incl=* | --inc=*)
 446     includedir=$ac_optarg ;;
 447
 448   -infodir | --infodir | --infodi | --infod | --info | --inf)
 449     ac_prev=infodir ;;
 450   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 451     infodir=$ac_optarg ;;
 452
 453   -libdir | --libdir | --libdi | --libd)
 454     ac_prev=libdir ;;
 455   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 456     libdir=$ac_optarg ;;
 457
 458   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 459   | --libexe | --libex | --libe)
 460     ac_prev=libexecdir ;;
 461   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 462   | --libexe=* | --libex=* | --libe=*)
 463     libexecdir=$ac_optarg ;;
 464
 465   -localstatedir | --localstatedir | --localstatedi | --localstated \
 466   | --localstate | --localstat | --localsta | --localst \
 467   | --locals | --local | --loca | --loc | --lo)
 468     ac_prev=localstatedir ;;
 469   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 470   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 471   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 472     localstatedir=$ac_optarg ;;
 473
 474   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 475     ac_prev=mandir ;;
 476   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 477     mandir=$ac_optarg ;;
 478
 479   -nfp | --nfp | --nf)
 480     # Obsolete; use --without-fp.
 481     with_fp=no ;;
 482
 483   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 484   | --no-cr | --no-c | -n)
 485     no_create=yes ;;
 486
 487   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 488   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 489     no_recursion=yes ;;
 490
 491   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 492   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 493   | --oldin | --oldi | --old | --ol | --o)
 494     ac_prev=oldincludedir ;;
 495   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 496   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 497   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 498     oldincludedir=$ac_optarg ;;
 499
 500   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 501     ac_prev=prefix ;;
 502   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 503     prefix=$ac_optarg ;;
 504
 505   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 506   | --program-pre | --program-pr | --program-p)
 507     ac_prev=program_prefix ;;
 508   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 509   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 510     program_prefix=$ac_optarg ;;
 511
 512   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 513   | --program-suf | --program-su | --program-s)
 514     ac_prev=program_suffix ;;
 515   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 516   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 517     program_suffix=$ac_optarg ;;
 518
 519   -program-transform-name | --program-transform-name \
 520   | --program-transform-nam | --program-transform-na \
 521   | --program-transform-n | --program-transform- \
 522   | --program-transform | --program-transfor \
 523   | --program-transfo | --program-transf \
 524   | --program-trans | --program-tran \
 525   | --progr-tra | --program-tr | --program-t)
 526     ac_prev=program_transform_name ;;
 527   -program-transform-name=* | --program-transform-name=* \
 528   | --program-transform-nam=* | --program-transform-na=* \
 529   | --program-transform-n=* | --program-transform-=* \
 530   | --program-transform=* | --program-transfor=* \
 531   | --program-transfo=* | --program-transf=* \
 532   | --program-trans=* | --program-tran=* \
 533   | --progr-tra=* | --program-tr=* | --program-t=*)
 534     program_transform_name=$ac_optarg ;;
 535
 536   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 537   | -silent | --silent | --silen | --sile | --sil)
 538     silent=yes ;;
 539
 540   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 541     ac_prev=sbindir ;;
 542   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 543   | --sbi=* | --sb=*)
 544     sbindir=$ac_optarg ;;
 545
 546   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 547   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 548   | --sharedst | --shareds | --shared | --share | --shar \
 549   | --sha | --sh)
 550     ac_prev=sharedstatedir ;;
 551   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 552   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 553   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 554   | --sha=* | --sh=*)
 555     sharedstatedir=$ac_optarg ;;
 556
 557   -site | --site | --sit)
 558     ac_prev=site ;;
 559   -site=* | --site=* | --sit=*)
 560     site=$ac_optarg ;;
 561
 562   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 563     ac_prev=srcdir ;;
 564   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 565     srcdir=$ac_optarg ;;
 566
 567   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 568   | --syscon | --sysco | --sysc | --sys | --sy)
 569     ac_prev=sysconfdir ;;
 570   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 571   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 572     sysconfdir=$ac_optarg ;;
 573
 574   -target | --target | --targe | --targ | --tar | --ta | --t)
 575     ac_prev=target_alias ;;
 576   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 577     target_alias=$ac_optarg ;;
 578
 579   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 580     verbose=yes ;;
 581
 582   -version | --version | --versio | --versi | --vers | -V)
 583     ac_init_version=: ;;
 584
 585   -with-* | --with-*)
 586     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 587     # Reject names that are not valid shell variable names.
 588     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 589       { echo "$as_me: error: invalid package name: $ac_package" >&2
 590    { (exit 1); exit 1; }; }
 591     ac_package=`echo $ac_package| sed 's/-/_/g'`
 592     case $ac_option in
 593       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 594       *) ac_optarg=yes ;;
 595     esac
 596     eval "with_$ac_package='$ac_optarg'" ;;
 597
 598   -without-* | --without-*)
 599     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 600     # Reject names that are not valid shell variable names.
 601     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 602       { echo "$as_me: error: invalid package name: $ac_package" >&2
 603    { (exit 1); exit 1; }; }
 604     ac_package=`echo $ac_package | sed 's/-/_/g'`
 605     eval "with_$ac_package=no" ;;
 606
 607   --x)
 608     # Obsolete; use --with-x.
 609     with_x=yes ;;
 610
 611   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 612   | --x-incl | --x-inc | --x-in | --x-i)
 613     ac_prev=x_includes ;;
 614   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 615   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 616     x_includes=$ac_optarg ;;
 617
 618   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 619   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 620     ac_prev=x_libraries ;;
 621   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 622   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 623     x_libraries=$ac_optarg ;;
 624
 625   -*) { echo "$as_me: error: unrecognized option: $ac_option
 626 Try \`$0 --help' for more information." >&2
 627    { (exit 1); exit 1; }; }
 628     ;;
 629
 630   *=*)
 631     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 632     # Reject names that are not valid shell variable names.
 633     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 634       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 635    { (exit 1); exit 1; }; }
 636     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 637     eval "$ac_envvar='$ac_optarg'"
 638     export $ac_envvar ;;
 639
 640   *)
 641     # FIXME: should be removed in autoconf 3.0.
 642     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 643     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 644       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 645     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 646     ;;
 647
 648   esac
 649 done
 650
 651 if test -n "$ac_prev"; then
 652   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 653   { echo "$as_me: error: missing argument to $ac_option" >&2
 654    { (exit 1); exit 1; }; }
 655 fi
 656
 657 # Be sure to have absolute paths.
 658 for ac_var in exec_prefix prefix
 659 do
 660   eval ac_val=$`echo $ac_var`
 661   case $ac_val in
 662     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 663     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 664    { (exit 1); exit 1; }; };;
 665   esac
 666 done
 667
 668 # Be sure to have absolute paths.
 669 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 670               localstatedir libdir includedir oldincludedir infodir mandir
 671 do
 672   eval ac_val=$`echo $ac_var`
 673   case $ac_val in
 674     [\\/$]* | ?:[\\/]* ) ;;
 675     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 676    { (exit 1); exit 1; }; };;
 677   esac
 678 done
 679
 680 # There might be people who depend on the old broken behavior: `$host'
 681 # used to hold the argument of --host etc.
 682 # FIXME: To remove some day.
 683 build=$build_alias
 684 host=$host_alias
 685 target=$target_alias
 686
 687 # FIXME: To remove some day.
 688 if test "x$host_alias" != x; then
 689   if test "x$build_alias" = x; then
 690     cross_compiling=maybe
 691     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 692     If a cross compiler is detected then cross compile mode will be used." >&2
 693   elif test "x$build_alias" != "x$host_alias"; then
 694     cross_compiling=yes
 695   fi
 696 fi
 697
 698 ac_tool_prefix=
 699 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 700
 701 test "$silent" = yes && exec 6>/dev/null
 702
 703
 704 # Find the source files, if location was not specified.
 705 if test -z "$srcdir"; then
 706   ac_srcdir_defaulted=yes
 707   # Try the directory containing this script, then its parent.
 708   ac_confdir=`(dirname "$0") 2>/dev/null ||
 709 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 710          X"$0" : 'X\(//\)[^/]' \| \
 711          X"$0" : 'X\(//\)$' \| \
 712          X"$0" : 'X\(/\)' \| \
 713          .     : '\(.\)' 2>/dev/null ||
 714 echo X"$0" |
 715     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 716           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 717           /^X\(\/\/\)$/{ s//\1/; q; }
 718           /^X\(\/\).*/{ s//\1/; q; }
 719           s/.*/./; q'`
 720   srcdir=$ac_confdir
 721   if test ! -r $srcdir/$ac_unique_file; then
 722     srcdir=..
 723   fi
 724 else
 725   ac_srcdir_defaulted=no
 726 fi
 727 if test ! -r $srcdir/$ac_unique_file; then
 728   if test "$ac_srcdir_defaulted" = yes; then
 729     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 730    { (exit 1); exit 1; }; }
 731   else
 732     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 733    { (exit 1); exit 1; }; }
 734   fi
 735 fi
 736 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 737   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 738    { (exit 1); exit 1; }; }
 739 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 740 ac_env_build_alias_set=${build_alias+set}
 741 ac_env_build_alias_value=$build_alias
 742 ac_cv_env_build_alias_set=${build_alias+set}
 743 ac_cv_env_build_alias_value=$build_alias
 744 ac_env_host_alias_set=${host_alias+set}
 745 ac_env_host_alias_value=$host_alias
 746 ac_cv_env_host_alias_set=${host_alias+set}
 747 ac_cv_env_host_alias_value=$host_alias
 748 ac_env_target_alias_set=${target_alias+set}
 749 ac_env_target_alias_value=$target_alias
 750 ac_cv_env_target_alias_set=${target_alias+set}
 751 ac_cv_env_target_alias_value=$target_alias
 752 ac_env_FC_set=${FC+set}
 753 ac_env_FC_value=$FC
 754 ac_cv_env_FC_set=${FC+set}
 755 ac_cv_env_FC_value=$FC
 756 ac_env_FCFLAGS_set=${FCFLAGS+set}
 757 ac_env_FCFLAGS_value=$FCFLAGS
 758 ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
 759 ac_cv_env_FCFLAGS_value=$FCFLAGS
 760 ac_env_LDFLAGS_set=${LDFLAGS+set}
 761 ac_env_LDFLAGS_value=$LDFLAGS
 762 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 763 ac_cv_env_LDFLAGS_value=$LDFLAGS
 764 ac_env_CPP_set=${CPP+set}
 765 ac_env_CPP_value=$CPP
 766 ac_cv_env_CPP_set=${CPP+set}
 767 ac_cv_env_CPP_value=$CPP
 768 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 769 ac_env_CPPFLAGS_value=$CPPFLAGS
 770 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 771 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 772
 773 #
 774 # Report the --help message.
 775 #
 776 if test "$ac_init_help" = "long"; then
 777   # Omit some internal or obsolete options to make the list less imposing.
 778   # This message is too long to be a string in the A/UX 3.1 sh.
 779   cat <<_ACEOF
 780 \`configure' configures GNU Fortran Runtime Library 0.2 to adapt to many kinds of systems.
 781
 782 Usage: $0 [OPTION]... [VAR=VALUE]...
 783
 784 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 785 VAR=VALUE.  See below for descriptions of some of the useful variables.
 786
 787 Defaults for the options are specified in brackets.
 788
 789 Configuration:
 790   -h, --help              display this help and exit
 791       --help=short        display options specific to this package
 792       --help=recursive    display the short help of all the included packages
 793   -V, --version           display version information and exit
 794   -q, --quiet, --silent   do not print \`checking...' messages
 795       --cache-file=FILE   cache test results in FILE [disabled]
 796   -C, --config-cache      alias for \`--cache-file=config.cache'
 797   -n, --no-create         do not create output files
 798       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 799
 800 _ACEOF
 801
 802   cat <<_ACEOF
 803 Installation directories:
 804   --prefix=PREFIX         install architecture-independent files in PREFIX
 805                           [$ac_default_prefix]
 806   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 807                           [PREFIX]
 808
 809 By default, \`make install' will install all the files in
 810 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 811 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 812 for instance \`--prefix=\$HOME'.
 813
 814 For better control, use the options below.
 815
 816 Fine tuning of the installation directories:
 817   --bindir=DIR           user executables [EPREFIX/bin]
 818   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 819   --libexecdir=DIR       program executables [EPREFIX/libexec]
 820   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 821   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 822   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 823   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 824   --libdir=DIR           object code libraries [EPREFIX/lib]
 825   --includedir=DIR       C header files [PREFIX/include]
 826   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 827   --infodir=DIR          info documentation [PREFIX/info]
 828   --mandir=DIR           man documentation [PREFIX/man]
 829 _ACEOF
 830
 831   cat <<\_ACEOF
 832
 833 Program names:
 834   --program-prefix=PREFIX            prepend PREFIX to installed program names
 835   --program-suffix=SUFFIX            append SUFFIX to installed program names
 836   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 837
 838 System types:
 839   --build=BUILD     configure for building on BUILD [guessed]
 840   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 841   --target=TARGET   configure for building compilers for TARGET [HOST]
 842 _ACEOF
 843 fi
 844
 845 if test -n "$ac_init_help"; then
 846   case $ac_init_help in
 847      short | recursive ) echo "Configuration of GNU Fortran Runtime Library 0.2:";;
 848    esac
 849   cat <<\_ACEOF
 850
 851 Optional Features:
 852   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 853   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 854   --enable-version-specific-runtime-libs    Specify that runtime libraries should be installed in a compiler-specific directory
 855   --enable-maintainer-mode  enable make rules and dependencies not useful
 856                           (and sometimes confusing) to the casual installer
 857   --enable-multilib       build many library versions (default)
 858   --enable-shared=PKGS  build shared libraries default=yes
 859   --enable-static=PKGS  build static libraries default=yes
 860   --enable-fast-install=PKGS  optimize for fast installation default=yes
 861   --disable-libtool-lock  avoid locking (might break parallel builds)
 862   --disable-largefile     omit support for large files
 863
 864 Optional Packages:
 865   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 866   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 867   --with-gnu-ld           assume the C compiler uses GNU ld default=no
 868   --with-pic              try to use only PIC/non-PIC objects default=use both
 869
 870 Some influential environment variables:
 871   CC          C compiler command
 872   CFLAGS      C compiler flags
 873   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 874               nonstandard directory <lib dir>
 875   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 876               headers in a nonstandard directory <include dir>
 877   FC          Fortran compiler command
 878   FCFLAGS     Fortran compiler flags
 879   CPP         C preprocessor
 880
 881 Use these variables to override the choices made by `configure' or to help
 882 it to find libraries and programs with nonstandard names/locations.
 883
 884 _ACEOF
 885 fi
 886
 887 if test "$ac_init_help" = "recursive"; then
 888   # If there are subdirs, report their specific --help.
 889   ac_popdir=`pwd`
 890   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
 891     test -d $ac_dir || continue
 892     ac_builddir=.
 893
 894 if test "$ac_dir" != .; then
 895   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
 896   # A "../" for each directory in $ac_dir_suffix.
 897   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
 898 else
 899   ac_dir_suffix= ac_top_builddir=
 900 fi
 901
 902 case $srcdir in
 903   .)  # No --srcdir option.  We are building in place.
 904     ac_srcdir=.
 905     if test -z "$ac_top_builddir"; then
 906        ac_top_srcdir=.
 907     else
 908        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
 909     fi ;;
 910   [\\/]* | ?:[\\/]* )  # Absolute path.
 911     ac_srcdir=$srcdir$ac_dir_suffix;
 912     ac_top_srcdir=$srcdir ;;
 913   *) # Relative path.
 914     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
 915     ac_top_srcdir=$ac_top_builddir$srcdir ;;
 916 esac
 917
 918 # Do not use `cd foo && pwd` to compute absolute paths, because
 919 # the directories may not exist.
 920 case `pwd` in
 921 .) ac_abs_builddir="$ac_dir";;
 922 *)
 923   case "$ac_dir" in
 924   .) ac_abs_builddir=`pwd`;;
 925   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
 926   *) ac_abs_builddir=`pwd`/"$ac_dir";;
 927   esac;;
 928 esac
 929 case $ac_abs_builddir in
 930 .) ac_abs_top_builddir=${ac_top_builddir}.;;
 931 *)
 932   case ${ac_top_builddir}. in
 933   .) ac_abs_top_builddir=$ac_abs_builddir;;
 934   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
 935   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
 936   esac;;
 937 esac
 938 case $ac_abs_builddir in
 939 .) ac_abs_srcdir=$ac_srcdir;;
 940 *)
 941   case $ac_srcdir in
 942   .) ac_abs_srcdir=$ac_abs_builddir;;
 943   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
 944   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
 945   esac;;
 946 esac
 947 case $ac_abs_builddir in
 948 .) ac_abs_top_srcdir=$ac_top_srcdir;;
 949 *)
 950   case $ac_top_srcdir in
 951   .) ac_abs_top_srcdir=$ac_abs_builddir;;
 952   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
 953   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
 954   esac;;
 955 esac
 956
 957     cd $ac_dir
 958     # Check for guested configure; otherwise get Cygnus style configure.
 959     if test -f $ac_srcdir/configure.gnu; then
 960       echo
 961       $SHELL $ac_srcdir/configure.gnu  --help=recursive
 962     elif test -f $ac_srcdir/configure; then
 963       echo
 964       $SHELL $ac_srcdir/configure  --help=recursive
 965     elif test -f $ac_srcdir/configure.ac ||
 966            test -f $ac_srcdir/configure.in; then
 967       echo
 968       $ac_configure --help
 969     else
 970       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
 971     fi
 972     cd $ac_popdir
 973   done
 974 fi
 975
 976 test -n "$ac_init_help" && exit 0
 977 if $ac_init_version; then
 978   cat <<\_ACEOF
 979 GNU Fortran Runtime Library configure 0.2
 980 generated by GNU Autoconf 2.59
 981
 982 Copyright (C) 2003 Free Software Foundation, Inc.
 983 This configure script is free software; the Free Software Foundation
 984 gives unlimited permission to copy, distribute and modify it.
 985 _ACEOF
 986   exit 0
 987 fi
 988 exec 5>config.log
 989 cat >&5 <<_ACEOF
 990 This file contains any messages produced by compilers while
 991 running configure, to aid debugging if configure makes a mistake.
 992
 993 It was created by GNU Fortran Runtime Library $as_me 0.2, which was
 994 generated by GNU Autoconf 2.59.  Invocation command line was
 995
 996   $ $0 $@
 997
 998 _ACEOF
 999 {
1000 cat <<_ASUNAME
1001 ## --------- ##
1002 ## Platform. ##
1003 ## --------- ##
1004
1005 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1006 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1007 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1008 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1009 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1010
1011 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1012 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1013
1014 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1015 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1016 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1017 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1018 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1019 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1020 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1021
1022 _ASUNAME
1023
1024 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1025 for as_dir in $PATH
1026 do
1027   IFS=$as_save_IFS
1028   test -z "$as_dir" && as_dir=.
1029   echo "PATH: $as_dir"
1030 done
1031
1032 } >&5
1033
1034 cat >&5 <<_ACEOF
1035
1036
1037 ## ----------- ##
1038 ## Core tests. ##
1039 ## ----------- ##
1040
1041 _ACEOF
1042
1043
1044 # Keep a trace of the command line.
1045 # Strip out --no-create and --no-recursion so they do not pile up.
1046 # Strip out --silent because we don't want to record it for future runs.
1047 # Also quote any args containing shell meta-characters.
1048 # Make two passes to allow for proper duplicate-argument suppression.
1049 ac_configure_args=
1050 ac_configure_args0=
1051 ac_configure_args1=
1052 ac_sep=
1053 ac_must_keep_next=false
1054 for ac_pass in 1 2
1055 do
1056   for ac_arg
1057   do
1058     case $ac_arg in
1059     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1060     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1061     | -silent | --silent | --silen | --sile | --sil)
1062       continue ;;
1063     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1064       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1065     esac
1066     case $ac_pass in
1067     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1068     2)
1069       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1070       if test $ac_must_keep_next = true; then
1071         ac_must_keep_next=false # Got value, back to normal.
1072       else
1073         case $ac_arg in
1074           *=* | --config-cache | -C | -disable-* | --disable-* \
1075           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1076           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1077           | -with-* | --with-* | -without-* | --without-* | --x)
1078             case "$ac_configure_args0 " in
1079               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1080             esac
1081             ;;
1082           -* ) ac_must_keep_next=true ;;
1083         esac
1084       fi
1085       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1086       # Get rid of the leading space.
1087       ac_sep=" "
1088       ;;
1089     esac
1090   done
1091 done
1092 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1093 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1094
1095 # When interrupted or exit'd, cleanup temporary files, and complete
1096 # config.log.  We remove comments because anyway the quotes in there
1097 # would cause problems or look ugly.
1098 # WARNING: Be sure not to use single quotes in there, as some shells,
1099 # such as our DU 5.0 friend, will then `close' the trap.
1100 trap 'exit_status=$?
1101   # Save into config.log some information that might help in debugging.
1102   {
1103     echo
1104
1105     cat <<\_ASBOX
1106 ## ---------------- ##
1107 ## Cache variables. ##
1108 ## ---------------- ##
1109 _ASBOX
1110     echo
1111     # The following way of writing the cache mishandles newlines in values,
1112 {
1113   (set) 2>&1 |
1114     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1115     *ac_space=\ *)
1116       sed -n \
1117         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1118           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1119       ;;
1120     *)
1121       sed -n \
1122         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1123       ;;
1124     esac;
1125 }
1126     echo
1127
1128     cat <<\_ASBOX
1129 ## ----------------- ##
1130 ## Output variables. ##
1131 ## ----------------- ##
1132 _ASBOX
1133     echo
1134     for ac_var in $ac_subst_vars
1135     do
1136       eval ac_val=$`echo $ac_var`
1137       echo "$ac_var='"'"'$ac_val'"'"'"
1138     done | sort
1139     echo
1140
1141     if test -n "$ac_subst_files"; then
1142       cat <<\_ASBOX
1143 ## ------------- ##
1144 ## Output files. ##
1145 ## ------------- ##
1146 _ASBOX
1147       echo
1148       for ac_var in $ac_subst_files
1149       do
1150         eval ac_val=$`echo $ac_var`
1151         echo "$ac_var='"'"'$ac_val'"'"'"
1152       done | sort
1153       echo
1154     fi
1155
1156     if test -s confdefs.h; then
1157       cat <<\_ASBOX
1158 ## ----------- ##
1159 ## confdefs.h. ##
1160 ## ----------- ##
1161 _ASBOX
1162       echo
1163       sed "/^$/d" confdefs.h | sort
1164       echo
1165     fi
1166     test "$ac_signal" != 0 &&
1167       echo "$as_me: caught signal $ac_signal"
1168     echo "$as_me: exit $exit_status"
1169   } >&5
1170   rm -f core *.core &&
1171   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1172     exit $exit_status
1173      ' 0
1174 for ac_signal in 1 2 13 15; do
1175   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1176 done
1177 ac_signal=0
1178
1179 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1180 rm -rf conftest* confdefs.h
1181 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1182 echo >confdefs.h
1183
1184 # Predefined preprocessor variables.
1185
1186 cat >>confdefs.h <<_ACEOF
1187 #define PACKAGE_NAME "$PACKAGE_NAME"
1188 _ACEOF
1189
1190
1191 cat >>confdefs.h <<_ACEOF
1192 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1193 _ACEOF
1194
1195
1196 cat >>confdefs.h <<_ACEOF
1197 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1198 _ACEOF
1199
1200
1201 cat >>confdefs.h <<_ACEOF
1202 #define PACKAGE_STRING "$PACKAGE_STRING"
1203 _ACEOF
1204
1205
1206 cat >>confdefs.h <<_ACEOF
1207 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1208 _ACEOF
1209
1210
1211 # Let the site file select an alternate cache file if it wants to.
1212 # Prefer explicitly selected file to automatically selected ones.
1213 if test -z "$CONFIG_SITE"; then
1214   if test "x$prefix" != xNONE; then
1215     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1216   else
1217     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1218   fi
1219 fi
1220 for ac_site_file in $CONFIG_SITE; do
1221   if test -r "$ac_site_file"; then
1222     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1223 echo "$as_me: loading site script $ac_site_file" >&6;}
1224     sed 's/^/| /' "$ac_site_file" >&5
1225     . "$ac_site_file"
1226   fi
1227 done
1228
1229 if test -r "$cache_file"; then
1230   # Some versions of bash will fail to source /dev/null (special
1231   # files actually), so we avoid doing that.
1232   if test -f "$cache_file"; then
1233     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1234 echo "$as_me: loading cache $cache_file" >&6;}
1235     case $cache_file in
1236       [\\/]* | ?:[\\/]* ) . $cache_file;;
1237       *)                      . ./$cache_file;;
1238     esac
1239   fi
1240 else
1241   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1242 echo "$as_me: creating cache $cache_file" >&6;}
1243   >$cache_file
1244 fi
1245
1246 # Check that the precious variables saved in the cache have kept the same
1247 # value.
1248 ac_cache_corrupted=false
1249 for ac_var in `(set) 2>&1 |
1250                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1251   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1252   eval ac_new_set=\$ac_env_${ac_var}_set
1253   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1254   eval ac_new_val="\$ac_env_${ac_var}_value"
1255   case $ac_old_set,$ac_new_set in
1256     set,)
1257       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1258 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1259       ac_cache_corrupted=: ;;
1260     ,set)
1261       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1262 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1263       ac_cache_corrupted=: ;;
1264     ,);;
1265     *)
1266       if test "x$ac_old_val" != "x$ac_new_val"; then
1267         { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1268 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1269         { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1270 echo "$as_me:   former value:  $ac_old_val" >&2;}
1271         { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1272 echo "$as_me:   current value: $ac_new_val" >&2;}
1273         ac_cache_corrupted=:
1274       fi;;
1275   esac
1276   # Pass precious variables to config.status.
1277   if test "$ac_new_set" = set; then
1278     case $ac_new_val in
1279     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1280       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1281     *) ac_arg=$ac_var=$ac_new_val ;;
1282     esac
1283     case " $ac_configure_args " in
1284       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1285       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1286     esac
1287   fi
1288 done
1289 if $ac_cache_corrupted; then
1290   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1291 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1292   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1293 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1294    { (exit 1); exit 1; }; }
1295 fi
1296
1297 ac_ext=c
1298 ac_cpp='$CPP $CPPFLAGS'
1299 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1300 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1301 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329           ac_config_headers="$ac_config_headers config.h"
1330
1331
1332 # -------
1333 # Options
1334 # -------
1335
1336 echo "$as_me:$LINENO: checking for --enable-version-specific-runtime-libs" >&5
1337 echo $ECHO_N "checking for --enable-version-specific-runtime-libs... $ECHO_C" >&6
1338 # Check whether --enable-version-specific-runtime-libs or --disable-version-specific-runtime-libs was given.
1339 if test "${enable_version_specific_runtime_libs+set}" = set; then
1340   enableval="$enable_version_specific_runtime_libs"
1341   case "$enableval" in
1342  yes) version_specific_libs=yes ;;
1343  no)  version_specific_libs=no ;;
1344  *)   { { echo "$as_me:$LINENO: error: Unknown argument to enable/disable version-specific libs" >&5
1345 echo "$as_me: error: Unknown argument to enable/disable version-specific libs" >&2;}
1346    { (exit 1); exit 1; }; };;
1347  esac
1348 else
1349   version_specific_libs=no
1350 fi;
1351 echo "$as_me:$LINENO: result: $version_specific_libs" >&5
1352 echo "${ECHO_T}$version_specific_libs" >&6
1353
1354
1355 # Gets build, host, target, *_vendor, *_cpu, *_os, etc.
1356 #
1357 # You will slowly go insane if you do not grok the following fact:  when
1358 # building this library, the top-level /target/ becomes the library's /host/.
1359 #
1360 # configure then causes --target to default to --host, exactly like any
1361 # other package using autoconf.  Therefore, 'target' and 'host' will
1362 # always be the same.  This makes sense both for native and cross compilers
1363 # just think about it for a little while.  :-)
1364 #
1365 # Also, if this library is being configured as part of a cross compiler, the
1366 # top-level configure script will pass the "real" host as $with_cross_host.
1367 #
1368 # Do not delete or change the following two lines.  For why, see
1369 # http://gcc.gnu.org/ml/libstdc++/2003-07/msg00451.html
1370 ac_aux_dir=
1371 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1372   if test -f $ac_dir/install-sh; then
1373     ac_aux_dir=$ac_dir
1374     ac_install_sh="$ac_aux_dir/install-sh -c"
1375     break
1376   elif test -f $ac_dir/install.sh; then
1377     ac_aux_dir=$ac_dir
1378     ac_install_sh="$ac_aux_dir/install.sh -c"
1379     break
1380   elif test -f $ac_dir/shtool; then
1381     ac_aux_dir=$ac_dir
1382     ac_install_sh="$ac_aux_dir/shtool install -c"
1383     break
1384   fi
1385 done
1386 if test -z "$ac_aux_dir"; then
1387   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1388 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1389    { (exit 1); exit 1; }; }
1390 fi
1391 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1392 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1393 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1394
1395 # Make sure we can run config.sub.
1396 $ac_config_sub sun4 >/dev/null 2>&1 ||
1397   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1398 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1399    { (exit 1); exit 1; }; }
1400
1401 echo "$as_me:$LINENO: checking build system type" >&5
1402 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1403 if test "${ac_cv_build+set}" = set; then
1404   echo $ECHO_N "(cached) $ECHO_C" >&6
1405 else
1406   ac_cv_build_alias=$build_alias
1407 test -z "$ac_cv_build_alias" &&
1408   ac_cv_build_alias=`$ac_config_guess`
1409 test -z "$ac_cv_build_alias" &&
1410   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1411 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1412    { (exit 1); exit 1; }; }
1413 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1414   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1415 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1416    { (exit 1); exit 1; }; }
1417
1418 fi
1419 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1420 echo "${ECHO_T}$ac_cv_build" >&6
1421 build=$ac_cv_build
1422 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1423 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1424 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1425
1426
1427 echo "$as_me:$LINENO: checking host system type" >&5
1428 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1429 if test "${ac_cv_host+set}" = set; then
1430   echo $ECHO_N "(cached) $ECHO_C" >&6
1431 else
1432   ac_cv_host_alias=$host_alias
1433 test -z "$ac_cv_host_alias" &&
1434   ac_cv_host_alias=$ac_cv_build_alias
1435 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1436   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1437 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1438    { (exit 1); exit 1; }; }
1439
1440 fi
1441 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1442 echo "${ECHO_T}$ac_cv_host" >&6
1443 host=$ac_cv_host
1444 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1445 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1446 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1447
1448
1449 echo "$as_me:$LINENO: checking target system type" >&5
1450 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1451 if test "${ac_cv_target+set}" = set; then
1452   echo $ECHO_N "(cached) $ECHO_C" >&6
1453 else
1454   ac_cv_target_alias=$target_alias
1455 test "x$ac_cv_target_alias" = "x" &&
1456   ac_cv_target_alias=$ac_cv_host_alias
1457 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1458   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1459 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1460    { (exit 1); exit 1; }; }
1461
1462 fi
1463 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1464 echo "${ECHO_T}$ac_cv_target" >&6
1465 target=$ac_cv_target
1466 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1467 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1468 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1469
1470
1471 # The aliases save the names the user supplied, while $host etc.
1472 # will get canonicalized.
1473 test -n "$target_alias" &&
1474   test "$program_prefix$program_suffix$program_transform_name" = \
1475     NONENONEs,x,x, &&
1476   program_prefix=${target_alias}-
1477 target_alias=${target_alias-$host_alias}
1478
1479 # Sets up automake.  Must come after AC_CANONICAL_SYSTEM.  Each of the
1480 # following is magically included in AUTOMAKE_OPTIONS in each Makefile.am.
1481 #  1.8.2:  minimum required version
1482 #  no-define:  PACKAGE and VERSION will not be #define'd in config.h (a bunch
1483 #              of other PACKAGE_* variables will, however, and there's nothing
1484 #              we can do about that; they come from AC_INIT).
1485 #  foreign:  we don't follow the normal rules for GNU packages (no COPYING
1486 #            file in the top srcdir, etc, etc), so stop complaining.
1487 #  no-dependencies:  turns off auto dependency generation (just for now)
1488 #  -Wall:  turns on all automake warnings...
1489 #  -Wno-portability:  ...except this one, since GNU make is required.
1490 am__api_version="1.9"
1491 # Find a good install program.  We prefer a C program (faster),
1492 # so one script is as good as another.  But avoid the broken or
1493 # incompatible versions:
1494 # SysV /etc/install, /usr/sbin/install
1495 # SunOS /usr/etc/install
1496 # IRIX /sbin/install
1497 # AIX /bin/install
1498 # AmigaOS /C/install, which installs bootblocks on floppy discs
1499 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1500 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1501 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1502 # OS/2's system install, which has a completely different semantic
1503 # ./install, which can be erroneously created by make from ./install.sh.
1504 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1505 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1506 if test -z "$INSTALL"; then
1507 if test "${ac_cv_path_install+set}" = set; then
1508   echo $ECHO_N "(cached) $ECHO_C" >&6
1509 else
1510   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1511 for as_dir in $PATH
1512 do
1513   IFS=$as_save_IFS
1514   test -z "$as_dir" && as_dir=.
1515   # Account for people who put trailing slashes in PATH elements.
1516 case $as_dir/ in
1517   ./ | .// | /cC/* | \
1518   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1519   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1520   /usr/ucb/* ) ;;
1521   *)
1522     # OSF1 and SCO ODT 3.0 have their own names for install.
1523     # Don't use installbsd from OSF since it installs stuff as root
1524     # by default.
1525     for ac_prog in ginstall scoinst install; do
1526       for ac_exec_ext in '' $ac_executable_extensions; do
1527         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1528           if test $ac_prog = install &&
1529             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1530             # AIX install.  It has an incompatible calling convention.
1531             :
1532           elif test $ac_prog = install &&
1533             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1534             # program-specific install script used by HP pwplus--don't use.
1535             :
1536           else
1537             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1538             break 3
1539           fi
1540         fi
1541       done
1542     done
1543     ;;
1544 esac
1545 done
1546
1547
1548 fi
1549   if test "${ac_cv_path_install+set}" = set; then
1550     INSTALL=$ac_cv_path_install
1551   else
1552     # As a last resort, use the slow shell script.  We don't cache a
1553     # path for INSTALL within a source directory, because that will
1554     # break other packages using the cache if that directory is
1555     # removed, or if the path is relative.
1556     INSTALL=$ac_install_sh
1557   fi
1558 fi
1559 echo "$as_me:$LINENO: result: $INSTALL" >&5
1560 echo "${ECHO_T}$INSTALL" >&6
1561
1562 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1563 # It thinks the first close brace ends the variable substitution.
1564 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1565
1566 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1567
1568 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1569
1570 echo "$as_me:$LINENO: checking whether build environment is sane" >&5
1571 echo $ECHO_N "checking whether build environment is sane... $ECHO_C" >&6
1572 # Just in case
1573 sleep 1
1574 echo timestamp > conftest.file
1575 # Do `set' in a subshell so we don't clobber the current shell's
1576 # arguments.  Must try -L first in case configure is actually a
1577 # symlink; some systems play weird games with the mod time of symlinks
1578 # (eg FreeBSD returns the mod time of the symlink's containing
1579 # directory).
1580 if (
1581    set X `ls -Lt $srcdir/configure conftest.file 2> /dev/null`
1582    if test "$*" = "X"; then
1583       # -L didn't work.
1584       set X `ls -t $srcdir/configure conftest.file`
1585    fi
1586    rm -f conftest.file
1587    if test "$*" != "X $srcdir/configure conftest.file" \
1588       && test "$*" != "X conftest.file $srcdir/configure"; then
1589
1590       # If neither matched, then we have a broken ls.  This can happen
1591       # if, for instance, CONFIG_SHELL is bash and it inherits a
1592       # broken ls alias from the environment.  This has actually
1593       # happened.  Such a system could not be considered "sane".
1594       { { echo "$as_me:$LINENO: error: ls -t appears to fail.  Make sure there is not a broken
1595 alias in your environment" >&5
1596 echo "$as_me: error: ls -t appears to fail.  Make sure there is not a broken
1597 alias in your environment" >&2;}
1598    { (exit 1); exit 1; }; }
1599    fi
1600
1601    test "$2" = conftest.file
1602    )
1603 then
1604    # Ok.
1605    :
1606 else
1607    { { echo "$as_me:$LINENO: error: newly created file is older than distributed files!
1608 Check your system clock" >&5
1609 echo "$as_me: error: newly created file is older than distributed files!
1610 Check your system clock" >&2;}
1611    { (exit 1); exit 1; }; }
1612 fi
1613 echo "$as_me:$LINENO: result: yes" >&5
1614 echo "${ECHO_T}yes" >&6
1615 test "$program_prefix" != NONE &&
1616   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1617 # Use a double $ so make ignores it.
1618 test "$program_suffix" != NONE &&
1619   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1620 # Double any \ or $.  echo might interpret backslashes.
1621 # By default was `s,x,x', remove it if useless.
1622 cat <<\_ACEOF >conftest.sed
1623 s/[\\$]/&&/g;s/;s,x,x,$//
1624 _ACEOF
1625 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1626 rm conftest.sed
1627
1628 # expand $ac_aux_dir to an absolute path
1629 am_aux_dir=`cd $ac_aux_dir && pwd`
1630
1631 test x"${MISSING+set}" = xset || MISSING="\${SHELL} $am_aux_dir/missing"
1632 # Use eval to expand $SHELL
1633 if eval "$MISSING --run true"; then
1634   am_missing_run="$MISSING --run "
1635 else
1636   am_missing_run=
1637   { echo "$as_me:$LINENO: WARNING: \`missing' script is too old or missing" >&5
1638 echo "$as_me: WARNING: \`missing' script is too old or missing" >&2;}
1639 fi
1640
1641 if mkdir -p --version . >/dev/null 2>&1 && test ! -d ./--version; then
1642   # We used to keeping the `.' as first argument, in order to
1643   # allow $(mkdir_p) to be used without argument.  As in
1644   #   $(mkdir_p) $(somedir)
1645   # where $(somedir) is conditionally defined.  However this is wrong
1646   # for two reasons:
1647   #  1. if the package is installed by a user who cannot write `.'
1648   #     make install will fail,
1649   #  2. the above comment should most certainly read
1650   #     $(mkdir_p) $(DESTDIR)$(somedir)
1651   #     so it does not work when $(somedir) is undefined and
1652   #     $(DESTDIR) is not.
1653   #  To support the latter case, we have to write
1654   #     test -z "$(somedir)" || $(mkdir_p) $(DESTDIR)$(somedir),
1655   #  so the `.' trick is pointless.
1656   mkdir_p='mkdir -p --'
1657 else
1658   # On NextStep and OpenStep, the `mkdir' command does not
1659   # recognize any option.  It will interpret all options as
1660   # directories to create, and then abort because `.' already
1661   # exists.
1662   for d in ./-p ./--version;
1663   do
1664     test -d $d && rmdir $d
1665   done
1666   # $(mkinstalldirs) is defined by Automake if mkinstalldirs exists.
1667   if test -f "$ac_aux_dir/mkinstalldirs"; then
1668     mkdir_p='$(mkinstalldirs)'
1669   else
1670     mkdir_p='$(install_sh) -d'
1671   fi
1672 fi
1673
1674 for ac_prog in gawk mawk nawk awk
1675 do
1676   # Extract the first word of "$ac_prog", so it can be a program name with args.
1677 set dummy $ac_prog; ac_word=$2
1678 echo "$as_me:$LINENO: checking for $ac_word" >&5
1679 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1680 if test "${ac_cv_prog_AWK+set}" = set; then
1681   echo $ECHO_N "(cached) $ECHO_C" >&6
1682 else
1683   if test -n "$AWK"; then
1684   ac_cv_prog_AWK="$AWK" # Let the user override the test.
1685 else
1686 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1687 for as_dir in $PATH
1688 do
1689   IFS=$as_save_IFS
1690   test -z "$as_dir" && as_dir=.
1691   for ac_exec_ext in '' $ac_executable_extensions; do
1692   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1693     ac_cv_prog_AWK="$ac_prog"
1694     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1695     break 2
1696   fi
1697 done
1698 done
1699
1700 fi
1701 fi
1702 AWK=$ac_cv_prog_AWK
1703 if test -n "$AWK"; then
1704   echo "$as_me:$LINENO: result: $AWK" >&5
1705 echo "${ECHO_T}$AWK" >&6
1706 else
1707   echo "$as_me:$LINENO: result: no" >&5
1708 echo "${ECHO_T}no" >&6
1709 fi
1710
1711   test -n "$AWK" && break
1712 done
1713
1714 echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
1715 echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
1716 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
1717 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
1718   echo $ECHO_N "(cached) $ECHO_C" >&6
1719 else
1720   cat >conftest.make <<\_ACEOF
1721 all:
1722         @echo 'ac_maketemp="$(MAKE)"'
1723 _ACEOF
1724 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
1725 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
1726 if test -n "$ac_maketemp"; then
1727   eval ac_cv_prog_make_${ac_make}_set=yes
1728 else
1729   eval ac_cv_prog_make_${ac_make}_set=no
1730 fi
1731 rm -f conftest.make
1732 fi
1733 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
1734   echo "$as_me:$LINENO: result: yes" >&5
1735 echo "${ECHO_T}yes" >&6
1736   SET_MAKE=
1737 else
1738   echo "$as_me:$LINENO: result: no" >&5
1739 echo "${ECHO_T}no" >&6
1740   SET_MAKE="MAKE=${MAKE-make}"
1741 fi
1742
1743 rm -rf .tst 2>/dev/null
1744 mkdir .tst 2>/dev/null
1745 if test -d .tst; then
1746   am__leading_dot=.
1747 else
1748   am__leading_dot=_
1749 fi
1750 rmdir .tst 2>/dev/null
1751
1752 # test to see if srcdir already configured
1753 if test "`cd $srcdir && pwd`" != "`pwd`" &&
1754    test -f $srcdir/config.status; then
1755   { { echo "$as_me:$LINENO: error: source directory already configured; run \"make distclean\" there first" >&5
1756 echo "$as_me: error: source directory already configured; run \"make distclean\" there first" >&2;}
1757    { (exit 1); exit 1; }; }
1758 fi
1759
1760 # test whether we have cygpath
1761 if test -z "$CYGPATH_W"; then
1762   if (cygpath --version) >/dev/null 2>/dev/null; then
1763     CYGPATH_W='cygpath -w'
1764   else
1765     CYGPATH_W=echo
1766   fi
1767 fi
1768
1769
1770 # Define the identity of the package.
1771  PACKAGE='libgfortran'
1772  VERSION='0.2'
1773
1774
1775 # Some tools Automake needs.
1776
1777 ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}
1778
1779
1780 AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}
1781
1782
1783 AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}
1784
1785
1786 AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}
1787
1788
1789 MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
1790
1791 install_sh=${install_sh-"$am_aux_dir/install-sh"}
1792
1793 # Installed binaries are usually stripped using `strip' when the user
1794 # run `make install-strip'.  However `strip' might not be the right
1795 # tool to use in cross-compilation environments, therefore Automake
1796 # will honor the `STRIP' environment variable to overrule this program.
1797 if test "$cross_compiling" != no; then
1798   if test -n "$ac_tool_prefix"; then
1799   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
1800 set dummy ${ac_tool_prefix}strip; ac_word=$2
1801 echo "$as_me:$LINENO: checking for $ac_word" >&5
1802 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1803 if test "${ac_cv_prog_STRIP+set}" = set; then
1804   echo $ECHO_N "(cached) $ECHO_C" >&6
1805 else
1806   if test -n "$STRIP"; then
1807   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
1808 else
1809 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1810 for as_dir in $PATH
1811 do
1812   IFS=$as_save_IFS
1813   test -z "$as_dir" && as_dir=.
1814   for ac_exec_ext in '' $ac_executable_extensions; do
1815   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1816     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
1817     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1818     break 2
1819   fi
1820 done
1821 done
1822
1823 fi
1824 fi
1825 STRIP=$ac_cv_prog_STRIP
1826 if test -n "$STRIP"; then
1827   echo "$as_me:$LINENO: result: $STRIP" >&5
1828 echo "${ECHO_T}$STRIP" >&6
1829 else
1830   echo "$as_me:$LINENO: result: no" >&5
1831 echo "${ECHO_T}no" >&6
1832 fi
1833
1834 fi
1835 if test -z "$ac_cv_prog_STRIP"; then
1836   ac_ct_STRIP=$STRIP
1837   # Extract the first word of "strip", so it can be a program name with args.
1838 set dummy strip; ac_word=$2
1839 echo "$as_me:$LINENO: checking for $ac_word" >&5
1840 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1841 if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
1842   echo $ECHO_N "(cached) $ECHO_C" >&6
1843 else
1844   if test -n "$ac_ct_STRIP"; then
1845   ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
1846 else
1847 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1848 for as_dir in $PATH
1849 do
1850   IFS=$as_save_IFS
1851   test -z "$as_dir" && as_dir=.
1852   for ac_exec_ext in '' $ac_executable_extensions; do
1853   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1854     ac_cv_prog_ac_ct_STRIP="strip"
1855     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1856     break 2
1857   fi
1858 done
1859 done
1860
1861   test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
1862 fi
1863 fi
1864 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
1865 if test -n "$ac_ct_STRIP"; then
1866   echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
1867 echo "${ECHO_T}$ac_ct_STRIP" >&6
1868 else
1869   echo "$as_me:$LINENO: result: no" >&5
1870 echo "${ECHO_T}no" >&6
1871 fi
1872
1873   STRIP=$ac_ct_STRIP
1874 else
1875   STRIP="$ac_cv_prog_STRIP"
1876 fi
1877
1878 fi
1879 INSTALL_STRIP_PROGRAM="\${SHELL} \$(install_sh) -c -s"
1880
1881 # We need awk for the "check" target.  The system "awk" is bad on
1882 # some platforms.
1883 # Always define AMTAR for backward compatibility.
1884
1885 AMTAR=${AMTAR-"${am_missing_run}tar"}
1886
1887 am__tar='${AMTAR} chof - "$$tardir"'; am__untar='${AMTAR} xf -'
1888
1889
1890
1891
1892
1893
1894 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
1895 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
1896     # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
1897 if test "${enable_maintainer_mode+set}" = set; then
1898   enableval="$enable_maintainer_mode"
1899   USE_MAINTAINER_MODE=$enableval
1900 else
1901   USE_MAINTAINER_MODE=no
1902 fi;
1903   echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
1904 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
1905
1906
1907 if test $USE_MAINTAINER_MODE = yes; then
1908   MAINTAINER_MODE_TRUE=
1909   MAINTAINER_MODE_FALSE='#'
1910 else
1911   MAINTAINER_MODE_TRUE='#'
1912   MAINTAINER_MODE_FALSE=
1913 fi
1914
1915   MAINT=$MAINTAINER_MODE_TRUE
1916
1917
1918 # Default to --enable-multilib
1919 # Check whether --enable-multilib or --disable-multilib was given.
1920 if test "${enable_multilib+set}" = set; then
1921   enableval="$enable_multilib"
1922   case "$enableval" in
1923   yes) multilib=yes ;;
1924   no)  multilib=no ;;
1925   *)   { { echo "$as_me:$LINENO: error: bad value $enableval for multilib option" >&5
1926 echo "$as_me: error: bad value $enableval for multilib option" >&2;}
1927    { (exit 1); exit 1; }; } ;;
1928  esac
1929 else
1930   multilib=yes
1931 fi;
1932
1933 # We may get other options which we leave undocumented:
1934 # --with-target-subdir, --with-multisrctop, --with-multisubdir
1935 # See config-ml.in if you want the gory details.
1936
1937 if test "$srcdir" = "."; then
1938   if test "$with_target_subdir" != "."; then
1939     multi_basedir="$srcdir/$with_multisrctop../.."
1940   else
1941     multi_basedir="$srcdir/$with_multisrctop.."
1942   fi
1943 else
1944   multi_basedir="$srcdir/.."
1945 fi
1946
1947
1948           ac_config_commands="$ac_config_commands default-1"
1949
1950
1951 # Handy for debugging:
1952 #AC_MSG_NOTICE($build / $host / $target / $host_alias / $target_alias); sleep 5
1953
1954 # Are we being configured with some form of cross compiler?
1955 # NB: We don't actually need to know this just now, but when, say, a test
1956 #     suite is included, we'll have to know.
1957 if test "$build" != "$host"; then
1958   LIBGFOR_IS_NATIVE=false
1959
1960 else
1961   LIBGFOR_IS_NATIVE=true
1962 fi
1963
1964 # Calculate toolexeclibdir
1965 # Also toolexecdir, though it's only used in toolexeclibdir
1966 case ${version_specific_libs} in
1967   yes)
1968     # Need the gcc compiler version to know where to install libraries
1969     # and header files if --enable-version-specific-runtime-libs option
1970     # is selected.
1971     toolexecdir='$(libdir)/gcc/$(target_alias)'
1972     toolexeclibdir='$(toolexecdir)/$(gcc_version)$(MULTISUBDIR)'
1973     ;;
1974   no)
1975     if test -n "$with_cross_host" &&
1976        test x"$with_cross_host" != x"no"; then
1977       # Install a library built with a cross compiler in tooldir, not libdir.
1978       toolexecdir='$(exec_prefix)/$(target_alias)'
1979       toolexeclibdir='$(toolexecdir)/lib'
1980     else
1981       toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
1982       toolexeclibdir='$(libdir)'
1983     fi
1984     multi_os_directory=`$CC -print-multi-os-directory`
1985     case $multi_os_directory in
1986       .) ;; # Avoid trailing /.
1987       *) toolexeclibdir=$toolexeclibdir/$multi_os_directory ;;
1988     esac
1989     ;;
1990 esac
1991
1992
1993
1994 # Check the compiler.
1995 # The same as in boehm-gc and libstdc++. Have to borrow it from there.
1996 # We must force CC to /not/ be precious variables; otherwise
1997 # the wrong, non-multilib-adjusted value will be used in multilibs.
1998 # As a side effect, we have to subst CFLAGS ourselves.
1999
2000
2001
2002 ac_ext=c
2003 ac_cpp='$CPP $CPPFLAGS'
2004 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2005 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2006 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2007 if test -n "$ac_tool_prefix"; then
2008   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2009 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2010 echo "$as_me:$LINENO: checking for $ac_word" >&5
2011 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2012 if test "${ac_cv_prog_CC+set}" = set; then
2013   echo $ECHO_N "(cached) $ECHO_C" >&6
2014 else
2015   if test -n "$CC"; then
2016   ac_cv_prog_CC="$CC" # Let the user override the test.
2017 else
2018 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2019 for as_dir in $PATH
2020 do
2021   IFS=$as_save_IFS
2022   test -z "$as_dir" && as_dir=.
2023   for ac_exec_ext in '' $ac_executable_extensions; do
2024   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2025     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2026     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2027     break 2
2028   fi
2029 done
2030 done
2031
2032 fi
2033 fi
2034 CC=$ac_cv_prog_CC
2035 if test -n "$CC"; then
2036   echo "$as_me:$LINENO: result: $CC" >&5
2037 echo "${ECHO_T}$CC" >&6
2038 else
2039   echo "$as_me:$LINENO: result: no" >&5
2040 echo "${ECHO_T}no" >&6
2041 fi
2042
2043 fi
2044 if test -z "$ac_cv_prog_CC"; then
2045   ac_ct_CC=$CC
2046   # Extract the first word of "gcc", so it can be a program name with args.
2047 set dummy gcc; ac_word=$2
2048 echo "$as_me:$LINENO: checking for $ac_word" >&5
2049 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2050 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2051   echo $ECHO_N "(cached) $ECHO_C" >&6
2052 else
2053   if test -n "$ac_ct_CC"; then
2054   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2055 else
2056 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2057 for as_dir in $PATH
2058 do
2059   IFS=$as_save_IFS
2060   test -z "$as_dir" && as_dir=.
2061   for ac_exec_ext in '' $ac_executable_extensions; do
2062   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2063     ac_cv_prog_ac_ct_CC="gcc"
2064     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2065     break 2
2066   fi
2067 done
2068 done
2069
2070 fi
2071 fi
2072 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2073 if test -n "$ac_ct_CC"; then
2074   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2075 echo "${ECHO_T}$ac_ct_CC" >&6
2076 else
2077   echo "$as_me:$LINENO: result: no" >&5
2078 echo "${ECHO_T}no" >&6
2079 fi
2080
2081   CC=$ac_ct_CC
2082 else
2083   CC="$ac_cv_prog_CC"
2084 fi
2085
2086 if test -z "$CC"; then
2087   if test -n "$ac_tool_prefix"; then
2088   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2089 set dummy ${ac_tool_prefix}cc; ac_word=$2
2090 echo "$as_me:$LINENO: checking for $ac_word" >&5
2091 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2092 if test "${ac_cv_prog_CC+set}" = set; then
2093   echo $ECHO_N "(cached) $ECHO_C" >&6
2094 else
2095   if test -n "$CC"; then
2096   ac_cv_prog_CC="$CC" # Let the user override the test.
2097 else
2098 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2099 for as_dir in $PATH
2100 do
2101   IFS=$as_save_IFS
2102   test -z "$as_dir" && as_dir=.
2103   for ac_exec_ext in '' $ac_executable_extensions; do
2104   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2105     ac_cv_prog_CC="${ac_tool_prefix}cc"
2106     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2107     break 2
2108   fi
2109 done
2110 done
2111
2112 fi
2113 fi
2114 CC=$ac_cv_prog_CC
2115 if test -n "$CC"; then
2116   echo "$as_me:$LINENO: result: $CC" >&5
2117 echo "${ECHO_T}$CC" >&6
2118 else
2119   echo "$as_me:$LINENO: result: no" >&5
2120 echo "${ECHO_T}no" >&6
2121 fi
2122
2123 fi
2124 if test -z "$ac_cv_prog_CC"; then
2125   ac_ct_CC=$CC
2126   # Extract the first word of "cc", so it can be a program name with args.
2127 set dummy cc; ac_word=$2
2128 echo "$as_me:$LINENO: checking for $ac_word" >&5
2129 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2130 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2131   echo $ECHO_N "(cached) $ECHO_C" >&6
2132 else
2133   if test -n "$ac_ct_CC"; then
2134   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2135 else
2136 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2137 for as_dir in $PATH
2138 do
2139   IFS=$as_save_IFS
2140   test -z "$as_dir" && as_dir=.
2141   for ac_exec_ext in '' $ac_executable_extensions; do
2142   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2143     ac_cv_prog_ac_ct_CC="cc"
2144     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2145     break 2
2146   fi
2147 done
2148 done
2149
2150 fi
2151 fi
2152 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2153 if test -n "$ac_ct_CC"; then
2154   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2155 echo "${ECHO_T}$ac_ct_CC" >&6
2156 else
2157   echo "$as_me:$LINENO: result: no" >&5
2158 echo "${ECHO_T}no" >&6
2159 fi
2160
2161   CC=$ac_ct_CC
2162 else
2163   CC="$ac_cv_prog_CC"
2164 fi
2165
2166 fi
2167 if test -z "$CC"; then
2168   # Extract the first word of "cc", so it can be a program name with args.
2169 set dummy cc; ac_word=$2
2170 echo "$as_me:$LINENO: checking for $ac_word" >&5
2171 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2172 if test "${ac_cv_prog_CC+set}" = set; then
2173   echo $ECHO_N "(cached) $ECHO_C" >&6
2174 else
2175   if test -n "$CC"; then
2176   ac_cv_prog_CC="$CC" # Let the user override the test.
2177 else
2178   ac_prog_rejected=no
2179 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2180 for as_dir in $PATH
2181 do
2182   IFS=$as_save_IFS
2183   test -z "$as_dir" && as_dir=.
2184   for ac_exec_ext in '' $ac_executable_extensions; do
2185   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2186     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2187        ac_prog_rejected=yes
2188        continue
2189      fi
2190     ac_cv_prog_CC="cc"
2191     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2192     break 2
2193   fi
2194 done
2195 done
2196
2197 if test $ac_prog_rejected = yes; then
2198   # We found a bogon in the path, so make sure we never use it.
2199   set dummy $ac_cv_prog_CC
2200   shift
2201   if test $# != 0; then
2202     # We chose a different compiler from the bogus one.
2203     # However, it has the same basename, so the bogon will be chosen
2204     # first if we set CC to just the basename; use the full file name.
2205     shift
2206     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
2207   fi
2208 fi
2209 fi
2210 fi
2211 CC=$ac_cv_prog_CC
2212 if test -n "$CC"; then
2213   echo "$as_me:$LINENO: result: $CC" >&5
2214 echo "${ECHO_T}$CC" >&6
2215 else
2216   echo "$as_me:$LINENO: result: no" >&5
2217 echo "${ECHO_T}no" >&6
2218 fi
2219
2220 fi
2221 if test -z "$CC"; then
2222   if test -n "$ac_tool_prefix"; then
2223   for ac_prog in cl
2224   do
2225     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2226 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2227 echo "$as_me:$LINENO: checking for $ac_word" >&5
2228 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2229 if test "${ac_cv_prog_CC+set}" = set; then
2230   echo $ECHO_N "(cached) $ECHO_C" >&6
2231 else
2232   if test -n "$CC"; then
2233   ac_cv_prog_CC="$CC" # Let the user override the test.
2234 else
2235 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2236 for as_dir in $PATH
2237 do
2238   IFS=$as_save_IFS
2239   test -z "$as_dir" && as_dir=.
2240   for ac_exec_ext in '' $ac_executable_extensions; do
2241   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2242     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2243     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2244     break 2
2245   fi
2246 done
2247 done
2248
2249 fi
2250 fi
2251 CC=$ac_cv_prog_CC
2252 if test -n "$CC"; then
2253   echo "$as_me:$LINENO: result: $CC" >&5
2254 echo "${ECHO_T}$CC" >&6
2255 else
2256   echo "$as_me:$LINENO: result: no" >&5
2257 echo "${ECHO_T}no" >&6
2258 fi
2259
2260     test -n "$CC" && break
2261   done
2262 fi
2263 if test -z "$CC"; then
2264   ac_ct_CC=$CC
2265   for ac_prog in cl
2266 do
2267   # Extract the first word of "$ac_prog", so it can be a program name with args.
2268 set dummy $ac_prog; ac_word=$2
2269 echo "$as_me:$LINENO: checking for $ac_word" >&5
2270 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2271 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2272   echo $ECHO_N "(cached) $ECHO_C" >&6
2273 else
2274   if test -n "$ac_ct_CC"; then
2275   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2276 else
2277 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2278 for as_dir in $PATH
2279 do
2280   IFS=$as_save_IFS
2281   test -z "$as_dir" && as_dir=.
2282   for ac_exec_ext in '' $ac_executable_extensions; do
2283   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2284     ac_cv_prog_ac_ct_CC="$ac_prog"
2285     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2286     break 2
2287   fi
2288 done
2289 done
2290
2291 fi
2292 fi
2293 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2294 if test -n "$ac_ct_CC"; then
2295   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2296 echo "${ECHO_T}$ac_ct_CC" >&6
2297 else
2298   echo "$as_me:$LINENO: result: no" >&5
2299 echo "${ECHO_T}no" >&6
2300 fi
2301
2302   test -n "$ac_ct_CC" && break
2303 done
2304
2305   CC=$ac_ct_CC
2306 fi
2307
2308 fi
2309
2310
2311 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2312 See \`config.log' for more details." >&5
2313 echo "$as_me: error: no acceptable C compiler found in \$PATH
2314 See \`config.log' for more details." >&2;}
2315    { (exit 1); exit 1; }; }
2316
2317 # Provide some information about the compiler.
2318 echo "$as_me:$LINENO:" \
2319      "checking for C compiler version" >&5
2320 ac_compiler=`set X $ac_compile; echo $2`
2321 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2322   (eval $ac_compiler --version </dev/null >&5) 2>&5
2323   ac_status=$?
2324   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2325   (exit $ac_status); }
2326 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2327   (eval $ac_compiler -v </dev/null >&5) 2>&5
2328   ac_status=$?
2329   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2330   (exit $ac_status); }
2331 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2332   (eval $ac_compiler -V </dev/null >&5) 2>&5
2333   ac_status=$?
2334   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2335   (exit $ac_status); }
2336
2337 cat >conftest.$ac_ext <<_ACEOF
2338 /* confdefs.h.  */
2339 _ACEOF
2340 cat confdefs.h >>conftest.$ac_ext
2341 cat >>conftest.$ac_ext <<_ACEOF
2342 /* end confdefs.h.  */
2343
2344 int
2345 main ()
2346 {
2347
2348   ;
2349   return 0;
2350 }
2351 _ACEOF
2352 # FIXME: Cleanup?
2353 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
2354   (eval $ac_link) 2>&5
2355   ac_status=$?
2356   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2357   (exit $ac_status); }; then
2358   gcc_no_link=no
2359 else
2360   gcc_no_link=yes
2361 fi
2362
2363 if test x$gcc_no_link = xyes; then
2364   # Setting cross_compile will disable run tests; it will
2365   # also disable AC_CHECK_FILE but that's generally
2366   # correct if we can't link.
2367   cross_compiling=yes
2368   EXEEXT=
2369 else
2370   cat >conftest.$ac_ext <<_ACEOF
2371 /* confdefs.h.  */
2372 _ACEOF
2373 cat confdefs.h >>conftest.$ac_ext
2374 cat >>conftest.$ac_ext <<_ACEOF
2375 /* end confdefs.h.  */
2376
2377 int
2378 main ()
2379 {
2380
2381   ;
2382   return 0;
2383 }
2384 _ACEOF
2385 ac_clean_files_save=$ac_clean_files
2386 ac_clean_files="$ac_clean_files a.out a.exe b.out"
2387 # Try to create an executable without -o first, disregard a.out.
2388 # It will help us diagnose broken compilers, and finding out an intuition
2389 # of exeext.
2390 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
2391 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
2392 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
2393 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
2394   (eval $ac_link_default) 2>&5
2395   ac_status=$?
2396   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2397   (exit $ac_status); }; then
2398   # Find the output, starting from the most likely.  This scheme is
2399 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
2400 # resort.
2401
2402 # Be careful to initialize this variable, since it used to be cached.
2403 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
2404 ac_cv_exeext=
2405 # b.out is created by i960 compilers.
2406 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
2407 do
2408   test -f "$ac_file" || continue
2409   case $ac_file in
2410     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
2411         ;;
2412     conftest.$ac_ext )
2413         # This is the source file.
2414         ;;
2415     [ab].out )
2416         # We found the default executable, but exeext='' is most
2417         # certainly right.
2418         break;;
2419     *.* )
2420         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
2421         # FIXME: I believe we export ac_cv_exeext for Libtool,
2422         # but it would be cool to find out if it's true.  Does anybody
2423         # maintain Libtool? --akim.
2424         export ac_cv_exeext
2425         break;;
2426     * )
2427         break;;
2428   esac
2429 done
2430 else
2431   echo "$as_me: failed program was:" >&5
2432 sed 's/^/| /' conftest.$ac_ext >&5
2433
2434 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
2435 See \`config.log' for more details." >&5
2436 echo "$as_me: error: C compiler cannot create executables
2437 See \`config.log' for more details." >&2;}
2438    { (exit 77); exit 77; }; }
2439 fi
2440
2441 ac_exeext=$ac_cv_exeext
2442 echo "$as_me:$LINENO: result: $ac_file" >&5
2443 echo "${ECHO_T}$ac_file" >&6
2444
2445 # Check the compiler produces executables we can run.  If not, either
2446 # the compiler is broken, or we cross compile.
2447 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
2448 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
2449 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
2450 # If not cross compiling, check that we can run a simple program.
2451 if test "$cross_compiling" != yes; then
2452   if { ac_try='./$ac_file'
2453   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2454   (eval $ac_try) 2>&5
2455   ac_status=$?
2456   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2457   (exit $ac_status); }; }; then
2458     cross_compiling=no
2459   else
2460     if test "$cross_compiling" = maybe; then
2461         cross_compiling=yes
2462     else
2463         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
2464 If you meant to cross compile, use \`--host'.
2465 See \`config.log' for more details." >&5
2466 echo "$as_me: error: cannot run C compiled programs.
2467 If you meant to cross compile, use \`--host'.
2468 See \`config.log' for more details." >&2;}
2469    { (exit 1); exit 1; }; }
2470     fi
2471   fi
2472 fi
2473 echo "$as_me:$LINENO: result: yes" >&5
2474 echo "${ECHO_T}yes" >&6
2475
2476 rm -f a.out a.exe conftest$ac_cv_exeext b.out
2477 ac_clean_files=$ac_clean_files_save
2478 # Check the compiler produces executables we can run.  If not, either
2479 # the compiler is broken, or we cross compile.
2480 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
2481 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
2482 echo "$as_me:$LINENO: result: $cross_compiling" >&5
2483 echo "${ECHO_T}$cross_compiling" >&6
2484
2485 echo "$as_me:$LINENO: checking for suffix of executables" >&5
2486 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
2487 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
2488   (eval $ac_link) 2>&5
2489   ac_status=$?
2490   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2491   (exit $ac_status); }; then
2492   # If both `conftest.exe' and `conftest' are `present' (well, observable)
2493 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
2494 # work properly (i.e., refer to `conftest.exe'), while it won't with
2495 # `rm'.
2496 for ac_file in conftest.exe conftest conftest.*; do
2497   test -f "$ac_file" || continue
2498   case $ac_file in
2499     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
2500     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
2501           export ac_cv_exeext
2502           break;;
2503     * ) break;;
2504   esac
2505 done
2506 else
2507   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
2508 See \`config.log' for more details." >&5
2509 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
2510 See \`config.log' for more details." >&2;}
2511    { (exit 1); exit 1; }; }
2512 fi
2513
2514 rm -f conftest$ac_cv_exeext
2515 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
2516 echo "${ECHO_T}$ac_cv_exeext" >&6
2517
2518 rm -f conftest.$ac_ext
2519 EXEEXT=$ac_cv_exeext
2520 ac_exeext=$EXEEXT
2521 fi
2522 echo "$as_me:$LINENO: checking for suffix of object files" >&5
2523 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
2524 if test "${ac_cv_objext+set}" = set; then
2525   echo $ECHO_N "(cached) $ECHO_C" >&6
2526 else
2527   cat >conftest.$ac_ext <<_ACEOF
2528 /* confdefs.h.  */
2529 _ACEOF
2530 cat confdefs.h >>conftest.$ac_ext
2531 cat >>conftest.$ac_ext <<_ACEOF
2532 /* end confdefs.h.  */
2533
2534 int
2535 main ()
2536 {
2537
2538   ;
2539   return 0;
2540 }
2541 _ACEOF
2542 rm -f conftest.o conftest.obj
2543 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2544   (eval $ac_compile) 2>&5
2545   ac_status=$?
2546   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2547   (exit $ac_status); }; then
2548   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
2549   case $ac_file in
2550     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
2551     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
2552        break;;
2553   esac
2554 done
2555 else
2556   echo "$as_me: failed program was:" >&5
2557 sed 's/^/| /' conftest.$ac_ext >&5
2558
2559 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
2560 See \`config.log' for more details." >&5
2561 echo "$as_me: error: cannot compute suffix of object files: cannot compile
2562 See \`config.log' for more details." >&2;}
2563    { (exit 1); exit 1; }; }
2564 fi
2565
2566 rm -f conftest.$ac_cv_objext conftest.$ac_ext
2567 fi
2568 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
2569 echo "${ECHO_T}$ac_cv_objext" >&6
2570 OBJEXT=$ac_cv_objext
2571 ac_objext=$OBJEXT
2572 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2573 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2574 if test "${ac_cv_c_compiler_gnu+set}" = set; then
2575   echo $ECHO_N "(cached) $ECHO_C" >&6
2576 else
2577   cat >conftest.$ac_ext <<_ACEOF
2578 /* confdefs.h.  */
2579 _ACEOF
2580 cat confdefs.h >>conftest.$ac_ext
2581 cat >>conftest.$ac_ext <<_ACEOF
2582 /* end confdefs.h.  */
2583
2584 int
2585 main ()
2586 {
2587 #ifndef __GNUC__
2588        choke me
2589 #endif
2590
2591   ;
2592   return 0;
2593 }
2594 _ACEOF
2595 rm -f conftest.$ac_objext
2596 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2597   (eval $ac_compile) 2>conftest.er1
2598   ac_status=$?
2599   grep -v '^ *+' conftest.er1 >conftest.err
2600   rm -f conftest.er1
2601   cat conftest.err >&5
2602   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2603   (exit $ac_status); } &&
2604          { ac_try='test -z "$ac_c_werror_flag"
2605                          || test ! -s conftest.err'
2606   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2607   (eval $ac_try) 2>&5
2608   ac_status=$?
2609   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2610   (exit $ac_status); }; } &&
2611          { ac_try='test -s conftest.$ac_objext'
2612   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2613   (eval $ac_try) 2>&5
2614   ac_status=$?
2615   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2616   (exit $ac_status); }; }; then
2617   ac_compiler_gnu=yes
2618 else
2619   echo "$as_me: failed program was:" >&5
2620 sed 's/^/| /' conftest.$ac_ext >&5
2621
2622 ac_compiler_gnu=no
2623 fi
2624 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2625 ac_cv_c_compiler_gnu=$ac_compiler_gnu
2626
2627 fi
2628 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2629 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2630 GCC=`test $ac_compiler_gnu = yes && echo yes`
2631 ac_test_CFLAGS=${CFLAGS+set}
2632 ac_save_CFLAGS=$CFLAGS
2633 CFLAGS="-g"
2634 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2635 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2636 if test "${ac_cv_prog_cc_g+set}" = set; then
2637   echo $ECHO_N "(cached) $ECHO_C" >&6
2638 else
2639   cat >conftest.$ac_ext <<_ACEOF
2640 /* confdefs.h.  */
2641 _ACEOF
2642 cat confdefs.h >>conftest.$ac_ext
2643 cat >>conftest.$ac_ext <<_ACEOF
2644 /* end confdefs.h.  */
2645
2646 int
2647 main ()
2648 {
2649
2650   ;
2651   return 0;
2652 }
2653 _ACEOF
2654 rm -f conftest.$ac_objext
2655 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2656   (eval $ac_compile) 2>conftest.er1
2657   ac_status=$?
2658   grep -v '^ *+' conftest.er1 >conftest.err
2659   rm -f conftest.er1
2660   cat conftest.err >&5
2661   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2662   (exit $ac_status); } &&
2663          { ac_try='test -z "$ac_c_werror_flag"
2664                          || test ! -s conftest.err'
2665   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2666   (eval $ac_try) 2>&5
2667   ac_status=$?
2668   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2669   (exit $ac_status); }; } &&
2670          { ac_try='test -s conftest.$ac_objext'
2671   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2672   (eval $ac_try) 2>&5
2673   ac_status=$?
2674   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2675   (exit $ac_status); }; }; then
2676   ac_cv_prog_cc_g=yes
2677 else
2678   echo "$as_me: failed program was:" >&5
2679 sed 's/^/| /' conftest.$ac_ext >&5
2680
2681 ac_cv_prog_cc_g=no
2682 fi
2683 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2684 fi
2685 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2686 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2687 if test "$ac_test_CFLAGS" = set; then
2688   CFLAGS=$ac_save_CFLAGS
2689 elif test $ac_cv_prog_cc_g = yes; then
2690   if test "$GCC" = yes; then
2691     CFLAGS="-g -O2"
2692   else
2693     CFLAGS="-g"
2694   fi
2695 else
2696   if test "$GCC" = yes; then
2697     CFLAGS="-O2"
2698   else
2699     CFLAGS=
2700   fi
2701 fi
2702 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2703 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2704 if test "${ac_cv_prog_cc_stdc+set}" = set; then
2705   echo $ECHO_N "(cached) $ECHO_C" >&6
2706 else
2707   ac_cv_prog_cc_stdc=no
2708 ac_save_CC=$CC
2709 cat >conftest.$ac_ext <<_ACEOF
2710 /* confdefs.h.  */
2711 _ACEOF
2712 cat confdefs.h >>conftest.$ac_ext
2713 cat >>conftest.$ac_ext <<_ACEOF
2714 /* end confdefs.h.  */
2715 #include <stdarg.h>
2716 #include <stdio.h>
2717 #include <sys/types.h>
2718 #include <sys/stat.h>
2719 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2720 struct buf { int x; };
2721 FILE * (*rcsopen) (struct buf *, struct stat *, int);
2722 static char *e (p, i)
2723      char **p;
2724      int i;
2725 {
2726   return p[i];
2727 }
2728 static char *f (char * (*g) (char **, int), char **p, ...)
2729 {
2730   char *s;
2731   va_list v;
2732   va_start (v,p);
2733   s = g (p, va_arg (v,int));
2734   va_end (v);
2735   return s;
2736 }
2737
2738 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2739    function prototypes and stuff, but not '\xHH' hex character constants.
2740    These don't provoke an error unfortunately, instead are silently treated
2741    as 'x'.  The following induces an error, until -std1 is added to get
2742    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2743    array size at least.  It's necessary to write '\x00'==0 to get something
2744    that's true only with -std1.  */
2745 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2746
2747 int test (int i, double x);
2748 struct s1 {int (*f) (int a);};
2749 struct s2 {int (*f) (double a);};
2750 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2751 int argc;
2752 char **argv;
2753 int
2754 main ()
2755 {
2756 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2757   ;
2758   return 0;
2759 }
2760 _ACEOF
2761 # Don't try gcc -ansi; that turns off useful extensions and
2762 # breaks some systems' header files.
2763 # AIX                   -qlanglvl=ansi
2764 # Ultrix and OSF/1      -std1
2765 # HP-UX 10.20 and later -Ae
2766 # HP-UX older versions  -Aa -D_HPUX_SOURCE
2767 # SVR4                  -Xc -D__EXTENSIONS__
2768 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2769 do
2770   CC="$ac_save_CC $ac_arg"
2771   rm -f conftest.$ac_objext
2772 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2773   (eval $ac_compile) 2>conftest.er1
2774   ac_status=$?
2775   grep -v '^ *+' conftest.er1 >conftest.err
2776   rm -f conftest.er1
2777   cat conftest.err >&5
2778   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2779   (exit $ac_status); } &&
2780          { ac_try='test -z "$ac_c_werror_flag"
2781                          || test ! -s conftest.err'
2782   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2783   (eval $ac_try) 2>&5
2784   ac_status=$?
2785   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2786   (exit $ac_status); }; } &&
2787          { ac_try='test -s conftest.$ac_objext'
2788   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2789   (eval $ac_try) 2>&5
2790   ac_status=$?
2791   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2792   (exit $ac_status); }; }; then
2793   ac_cv_prog_cc_stdc=$ac_arg
2794 break
2795 else
2796   echo "$as_me: failed program was:" >&5
2797 sed 's/^/| /' conftest.$ac_ext >&5
2798
2799 fi
2800 rm -f conftest.err conftest.$ac_objext
2801 done
2802 rm -f conftest.$ac_ext conftest.$ac_objext
2803 CC=$ac_save_CC
2804
2805 fi
2806
2807 case "x$ac_cv_prog_cc_stdc" in
2808   x|xno)
2809     echo "$as_me:$LINENO: result: none needed" >&5
2810 echo "${ECHO_T}none needed" >&6 ;;
2811   *)
2812     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2813 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2814     CC="$CC $ac_cv_prog_cc_stdc" ;;
2815 esac
2816
2817 # Some people use a C++ compiler to compile C.  Since we use `exit',
2818 # in C++ we need to declare it.  In case someone uses the same compiler
2819 # for both compiling C and C++ we need to have the C++ compiler decide
2820 # the declaration of exit, since it's the most demanding environment.
2821 cat >conftest.$ac_ext <<_ACEOF
2822 #ifndef __cplusplus
2823   choke me
2824 #endif
2825 _ACEOF
2826 rm -f conftest.$ac_objext
2827 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2828   (eval $ac_compile) 2>conftest.er1
2829   ac_status=$?
2830   grep -v '^ *+' conftest.er1 >conftest.err
2831   rm -f conftest.er1
2832   cat conftest.err >&5
2833   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2834   (exit $ac_status); } &&
2835          { ac_try='test -z "$ac_c_werror_flag"
2836                          || test ! -s conftest.err'
2837   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2838   (eval $ac_try) 2>&5
2839   ac_status=$?
2840   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2841   (exit $ac_status); }; } &&
2842          { ac_try='test -s conftest.$ac_objext'
2843   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2844   (eval $ac_try) 2>&5
2845   ac_status=$?
2846   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2847   (exit $ac_status); }; }; then
2848   for ac_declaration in \
2849    '' \
2850    'extern "C" void std::exit (int) throw (); using std::exit;' \
2851    'extern "C" void std::exit (int); using std::exit;' \
2852    'extern "C" void exit (int) throw ();' \
2853    'extern "C" void exit (int);' \
2854    'void exit (int);'
2855 do
2856   cat >conftest.$ac_ext <<_ACEOF
2857 /* confdefs.h.  */
2858 _ACEOF
2859 cat confdefs.h >>conftest.$ac_ext
2860 cat >>conftest.$ac_ext <<_ACEOF
2861 /* end confdefs.h.  */
2862 $ac_declaration
2863 #include <stdlib.h>
2864 int
2865 main ()
2866 {
2867 exit (42);
2868   ;
2869   return 0;
2870 }
2871 _ACEOF
2872 rm -f conftest.$ac_objext
2873 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2874   (eval $ac_compile) 2>conftest.er1
2875   ac_status=$?
2876   grep -v '^ *+' conftest.er1 >conftest.err
2877   rm -f conftest.er1
2878   cat conftest.err >&5
2879   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2880   (exit $ac_status); } &&
2881          { ac_try='test -z "$ac_c_werror_flag"
2882                          || test ! -s conftest.err'
2883   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2884   (eval $ac_try) 2>&5
2885   ac_status=$?
2886   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2887   (exit $ac_status); }; } &&
2888          { ac_try='test -s conftest.$ac_objext'
2889   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2890   (eval $ac_try) 2>&5
2891   ac_status=$?
2892   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2893   (exit $ac_status); }; }; then
2894   :
2895 else
2896   echo "$as_me: failed program was:" >&5
2897 sed 's/^/| /' conftest.$ac_ext >&5
2898
2899 continue
2900 fi
2901 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2902   cat >conftest.$ac_ext <<_ACEOF
2903 /* confdefs.h.  */
2904 _ACEOF
2905 cat confdefs.h >>conftest.$ac_ext
2906 cat >>conftest.$ac_ext <<_ACEOF
2907 /* end confdefs.h.  */
2908 $ac_declaration
2909 int
2910 main ()
2911 {
2912 exit (42);
2913   ;
2914   return 0;
2915 }
2916 _ACEOF
2917 rm -f conftest.$ac_objext
2918 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2919   (eval $ac_compile) 2>conftest.er1
2920   ac_status=$?
2921   grep -v '^ *+' conftest.er1 >conftest.err
2922   rm -f conftest.er1
2923   cat conftest.err >&5
2924   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2925   (exit $ac_status); } &&
2926          { ac_try='test -z "$ac_c_werror_flag"
2927                          || test ! -s conftest.err'
2928   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2929   (eval $ac_try) 2>&5
2930   ac_status=$?
2931   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2932   (exit $ac_status); }; } &&
2933          { ac_try='test -s conftest.$ac_objext'
2934   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2935   (eval $ac_try) 2>&5
2936   ac_status=$?
2937   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2938   (exit $ac_status); }; }; then
2939   break
2940 else
2941   echo "$as_me: failed program was:" >&5
2942 sed 's/^/| /' conftest.$ac_ext >&5
2943
2944 fi
2945 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2946 done
2947 rm -f conftest*
2948 if test -n "$ac_declaration"; then
2949   echo '#ifdef __cplusplus' >>confdefs.h
2950   echo $ac_declaration      >>confdefs.h
2951   echo '#endif'             >>confdefs.h
2952 fi
2953
2954 else
2955   echo "$as_me: failed program was:" >&5
2956 sed 's/^/| /' conftest.$ac_ext >&5
2957
2958 fi
2959 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2960 ac_ext=c
2961 ac_cpp='$CPP $CPPFLAGS'
2962 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2963 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2964 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2965
2966
2967
2968 # Add -Wall -fno-repack-arrays -fno-underscoring if we are using GCC.
2969 if test "x$GCC" = "xyes"; then
2970   AM_FCFLAGS="-I . -Wall -fno-repack-arrays -fno-underscoring"
2971   ## We like to use C99 routines when available.  This makes sure that
2972   ## __STDC_VERSION__ is set such that libc includes make them available.
2973   AM_CFLAGS="-std=gnu99 -Wall -Wstrict-prototypes -Wmissing-prototypes -Wold-style-definition -Wextra -Wwrite-strings"
2974 fi
2975
2976
2977
2978 # Find other programs we need.
2979 if test -n "$ac_tool_prefix"; then
2980   # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
2981 set dummy ${ac_tool_prefix}as; ac_word=$2
2982 echo "$as_me:$LINENO: checking for $ac_word" >&5
2983 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2984 if test "${ac_cv_prog_AS+set}" = set; then
2985   echo $ECHO_N "(cached) $ECHO_C" >&6
2986 else
2987   if test -n "$AS"; then
2988   ac_cv_prog_AS="$AS" # Let the user override the test.
2989 else
2990 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2991 for as_dir in $PATH
2992 do
2993   IFS=$as_save_IFS
2994   test -z "$as_dir" && as_dir=.
2995   for ac_exec_ext in '' $ac_executable_extensions; do
2996   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2997     ac_cv_prog_AS="${ac_tool_prefix}as"
2998     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2999     break 2
3000   fi
3001 done
3002 done
3003
3004 fi
3005 fi
3006 AS=$ac_cv_prog_AS
3007 if test -n "$AS"; then
3008   echo "$as_me:$LINENO: result: $AS" >&5
3009 echo "${ECHO_T}$AS" >&6
3010 else
3011   echo "$as_me:$LINENO: result: no" >&5
3012 echo "${ECHO_T}no" >&6
3013 fi
3014
3015 fi
3016 if test -z "$ac_cv_prog_AS"; then
3017   ac_ct_AS=$AS
3018   # Extract the first word of "as", so it can be a program name with args.
3019 set dummy as; ac_word=$2
3020 echo "$as_me:$LINENO: checking for $ac_word" >&5
3021 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3022 if test "${ac_cv_prog_ac_ct_AS+set}" = set; then
3023   echo $ECHO_N "(cached) $ECHO_C" >&6
3024 else
3025   if test -n "$ac_ct_AS"; then
3026   ac_cv_prog_ac_ct_AS="$ac_ct_AS" # Let the user override the test.
3027 else
3028 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3029 for as_dir in $PATH
3030 do
3031   IFS=$as_save_IFS
3032   test -z "$as_dir" && as_dir=.
3033   for ac_exec_ext in '' $ac_executable_extensions; do
3034   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3035     ac_cv_prog_ac_ct_AS="as"
3036     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3037     break 2
3038   fi
3039 done
3040 done
3041
3042 fi
3043 fi
3044 ac_ct_AS=$ac_cv_prog_ac_ct_AS
3045 if test -n "$ac_ct_AS"; then
3046   echo "$as_me:$LINENO: result: $ac_ct_AS" >&5
3047 echo "${ECHO_T}$ac_ct_AS" >&6
3048 else
3049   echo "$as_me:$LINENO: result: no" >&5
3050 echo "${ECHO_T}no" >&6
3051 fi
3052
3053   AS=$ac_ct_AS
3054 else
3055   AS="$ac_cv_prog_AS"
3056 fi
3057
3058 if test -n "$ac_tool_prefix"; then
3059   # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
3060 set dummy ${ac_tool_prefix}ar; ac_word=$2
3061 echo "$as_me:$LINENO: checking for $ac_word" >&5
3062 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3063 if test "${ac_cv_prog_AR+set}" = set; then
3064   echo $ECHO_N "(cached) $ECHO_C" >&6
3065 else
3066   if test -n "$AR"; then
3067   ac_cv_prog_AR="$AR" # Let the user override the test.
3068 else
3069 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3070 for as_dir in $PATH
3071 do
3072   IFS=$as_save_IFS
3073   test -z "$as_dir" && as_dir=.
3074   for ac_exec_ext in '' $ac_executable_extensions; do
3075   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3076     ac_cv_prog_AR="${ac_tool_prefix}ar"
3077     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3078     break 2
3079   fi
3080 done
3081 done
3082
3083 fi
3084 fi
3085 AR=$ac_cv_prog_AR
3086 if test -n "$AR"; then
3087   echo "$as_me:$LINENO: result: $AR" >&5
3088 echo "${ECHO_T}$AR" >&6
3089 else
3090   echo "$as_me:$LINENO: result: no" >&5
3091 echo "${ECHO_T}no" >&6
3092 fi
3093
3094 fi
3095 if test -z "$ac_cv_prog_AR"; then
3096   ac_ct_AR=$AR
3097   # Extract the first word of "ar", so it can be a program name with args.
3098 set dummy ar; ac_word=$2
3099 echo "$as_me:$LINENO: checking for $ac_word" >&5
3100 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3101 if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
3102   echo $ECHO_N "(cached) $ECHO_C" >&6
3103 else
3104   if test -n "$ac_ct_AR"; then
3105   ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
3106 else
3107 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3108 for as_dir in $PATH
3109 do
3110   IFS=$as_save_IFS
3111   test -z "$as_dir" && as_dir=.
3112   for ac_exec_ext in '' $ac_executable_extensions; do
3113   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3114     ac_cv_prog_ac_ct_AR="ar"
3115     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3116     break 2
3117   fi
3118 done
3119 done
3120
3121 fi
3122 fi
3123 ac_ct_AR=$ac_cv_prog_ac_ct_AR
3124 if test -n "$ac_ct_AR"; then
3125   echo "$as_me:$LINENO: result: $ac_ct_AR" >&5
3126 echo "${ECHO_T}$ac_ct_AR" >&6
3127 else
3128   echo "$as_me:$LINENO: result: no" >&5
3129 echo "${ECHO_T}no" >&6
3130 fi
3131
3132   AR=$ac_ct_AR
3133 else
3134   AR="$ac_cv_prog_AR"
3135 fi
3136
3137 if test -n "$ac_tool_prefix"; then
3138   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3139 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3140 echo "$as_me:$LINENO: checking for $ac_word" >&5
3141 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3142 if test "${ac_cv_prog_RANLIB+set}" = set; then
3143   echo $ECHO_N "(cached) $ECHO_C" >&6
3144 else
3145   if test -n "$RANLIB"; then
3146   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3147 else
3148 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3149 for as_dir in $PATH
3150 do
3151   IFS=$as_save_IFS
3152   test -z "$as_dir" && as_dir=.
3153   for ac_exec_ext in '' $ac_executable_extensions; do
3154   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3155     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3156     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3157     break 2
3158   fi
3159 done
3160 done
3161
3162 fi
3163 fi
3164 RANLIB=$ac_cv_prog_RANLIB
3165 if test -n "$RANLIB"; then
3166   echo "$as_me:$LINENO: result: $RANLIB" >&5
3167 echo "${ECHO_T}$RANLIB" >&6
3168 else
3169   echo "$as_me:$LINENO: result: no" >&5
3170 echo "${ECHO_T}no" >&6
3171 fi
3172
3173 fi
3174 if test -z "$ac_cv_prog_RANLIB"; then
3175   ac_ct_RANLIB=$RANLIB
3176   # Extract the first word of "ranlib", so it can be a program name with args.
3177 set dummy ranlib; ac_word=$2
3178 echo "$as_me:$LINENO: checking for $ac_word" >&5
3179 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3180 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3181   echo $ECHO_N "(cached) $ECHO_C" >&6
3182 else
3183   if test -n "$ac_ct_RANLIB"; then
3184   ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3185 else
3186 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3187 for as_dir in $PATH
3188 do
3189   IFS=$as_save_IFS
3190   test -z "$as_dir" && as_dir=.
3191   for ac_exec_ext in '' $ac_executable_extensions; do
3192   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3193     ac_cv_prog_ac_ct_RANLIB="ranlib"
3194     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3195     break 2
3196   fi
3197 done
3198 done
3199
3200   test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB="ranlib-not-found-in-path-error"
3201 fi
3202 fi
3203 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3204 if test -n "$ac_ct_RANLIB"; then
3205   echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3206 echo "${ECHO_T}$ac_ct_RANLIB" >&6
3207 else
3208   echo "$as_me:$LINENO: result: no" >&5
3209 echo "${ECHO_T}no" >&6
3210 fi
3211
3212   RANLIB=$ac_ct_RANLIB
3213 else
3214   RANLIB="$ac_cv_prog_RANLIB"
3215 fi
3216
3217 echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3218 echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3219 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3220 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3221   echo $ECHO_N "(cached) $ECHO_C" >&6
3222 else
3223   cat >conftest.make <<\_ACEOF
3224 all:
3225         @echo 'ac_maketemp="$(MAKE)"'
3226 _ACEOF
3227 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3228 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3229 if test -n "$ac_maketemp"; then
3230   eval ac_cv_prog_make_${ac_make}_set=yes
3231 else
3232   eval ac_cv_prog_make_${ac_make}_set=no
3233 fi
3234 rm -f conftest.make
3235 fi
3236 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3237   echo "$as_me:$LINENO: result: yes" >&5
3238 echo "${ECHO_T}yes" >&6
3239   SET_MAKE=
3240 else
3241   echo "$as_me:$LINENO: result: no" >&5
3242 echo "${ECHO_T}no" >&6
3243   SET_MAKE="MAKE=${MAKE-make}"
3244 fi
3245
3246 # Find a good install program.  We prefer a C program (faster),
3247 # so one script is as good as another.  But avoid the broken or
3248 # incompatible versions:
3249 # SysV /etc/install, /usr/sbin/install
3250 # SunOS /usr/etc/install
3251 # IRIX /sbin/install
3252 # AIX /bin/install
3253 # AmigaOS /C/install, which installs bootblocks on floppy discs
3254 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3255 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3256 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3257 # OS/2's system install, which has a completely different semantic
3258 # ./install, which can be erroneously created by make from ./install.sh.
3259 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3260 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3261 if test -z "$INSTALL"; then
3262 if test "${ac_cv_path_install+set}" = set; then
3263   echo $ECHO_N "(cached) $ECHO_C" >&6
3264 else
3265   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3266 for as_dir in $PATH
3267 do
3268   IFS=$as_save_IFS
3269   test -z "$as_dir" && as_dir=.
3270   # Account for people who put trailing slashes in PATH elements.
3271 case $as_dir/ in
3272   ./ | .// | /cC/* | \
3273   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3274   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3275   /usr/ucb/* ) ;;
3276   *)
3277     # OSF1 and SCO ODT 3.0 have their own names for install.
3278     # Don't use installbsd from OSF since it installs stuff as root
3279     # by default.
3280     for ac_prog in ginstall scoinst install; do
3281       for ac_exec_ext in '' $ac_executable_extensions; do
3282         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3283           if test $ac_prog = install &&
3284             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3285             # AIX install.  It has an incompatible calling convention.
3286             :
3287           elif test $ac_prog = install &&
3288             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3289             # program-specific install script used by HP pwplus--don't use.
3290             :
3291           else
3292             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3293             break 3
3294           fi
3295         fi
3296       done
3297     done
3298     ;;
3299 esac
3300 done
3301
3302
3303 fi
3304   if test "${ac_cv_path_install+set}" = set; then
3305     INSTALL=$ac_cv_path_install
3306   else
3307     # As a last resort, use the slow shell script.  We don't cache a
3308     # path for INSTALL within a source directory, because that will
3309     # break other packages using the cache if that directory is
3310     # removed, or if the path is relative.
3311     INSTALL=$ac_install_sh
3312   fi
3313 fi
3314 echo "$as_me:$LINENO: result: $INSTALL" >&5
3315 echo "${ECHO_T}$INSTALL" >&6
3316
3317 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3318 # It thinks the first close brace ends the variable substitution.
3319 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3320
3321 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3322
3323 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3324
3325
3326 # Configure libtool
3327 #AC_MSG_NOTICE([====== Starting libtool configuration])
3328
3329 # Check whether --enable-shared or --disable-shared was given.
3330 if test "${enable_shared+set}" = set; then
3331   enableval="$enable_shared"
3332   p=${PACKAGE-default}
3333 case $enableval in
3334 yes) enable_shared=yes ;;
3335 no) enable_shared=no ;;
3336 *)
3337   enable_shared=no
3338   # Look at the argument we got.  We use all the common list separators.
3339   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3340   for pkg in $enableval; do
3341     if test "X$pkg" = "X$p"; then
3342       enable_shared=yes
3343     fi
3344   done
3345   IFS="$ac_save_ifs"
3346   ;;
3347 esac
3348 else
3349   enable_shared=yes
3350 fi;
3351 # Check whether --enable-static or --disable-static was given.
3352 if test "${enable_static+set}" = set; then
3353   enableval="$enable_static"
3354   p=${PACKAGE-default}
3355 case $enableval in
3356 yes) enable_static=yes ;;
3357 no) enable_static=no ;;
3358 *)
3359   enable_static=no
3360   # Look at the argument we got.  We use all the common list separators.
3361   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3362   for pkg in $enableval; do
3363     if test "X$pkg" = "X$p"; then
3364       enable_static=yes
3365     fi
3366   done
3367   IFS="$ac_save_ifs"
3368   ;;
3369 esac
3370 else
3371   enable_static=yes
3372 fi;
3373 # Check whether --enable-fast-install or --disable-fast-install was given.
3374 if test "${enable_fast_install+set}" = set; then
3375   enableval="$enable_fast_install"
3376   p=${PACKAGE-default}
3377 case $enableval in
3378 yes) enable_fast_install=yes ;;
3379 no) enable_fast_install=no ;;
3380 *)
3381   enable_fast_install=no
3382   # Look at the argument we got.  We use all the common list separators.
3383   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3384   for pkg in $enableval; do
3385     if test "X$pkg" = "X$p"; then
3386       enable_fast_install=yes
3387     fi
3388   done
3389   IFS="$ac_save_ifs"
3390   ;;
3391 esac
3392 else
3393   enable_fast_install=yes
3394 fi;
3395
3396 # Check whether --with-gnu-ld or --without-gnu-ld was given.
3397 if test "${with_gnu_ld+set}" = set; then
3398   withval="$with_gnu_ld"
3399   test "$withval" = no || with_gnu_ld=yes
3400 else
3401   with_gnu_ld=no
3402 fi;
3403 ac_prog=ld
3404 if test "$GCC" = yes; then
3405   # Check if gcc -print-prog-name=ld gives a path.
3406   echo "$as_me:$LINENO: checking for ld used by GCC" >&5
3407 echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6
3408   case $host in
3409   *-*-mingw*)
3410     # gcc leaves a trailing carriage return which upsets mingw
3411     ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
3412   *)
3413     ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
3414   esac
3415   case $ac_prog in
3416     # Accept absolute paths.
3417     [\\/]* | [A-Za-z]:[\\/]*)
3418       re_direlt='/[^/][^/]*/\.\./'
3419       # Canonicalize the path of ld
3420       ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
3421       while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
3422         ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
3423       done
3424       test -z "$LD" && LD="$ac_prog"
3425       ;;
3426   "")
3427     # If it fails, then pretend we aren't using GCC.
3428     ac_prog=ld
3429     ;;
3430   *)
3431     # If it is relative, then search for the first ld in PATH.
3432     with_gnu_ld=unknown
3433     ;;
3434   esac
3435 elif test "$with_gnu_ld" = yes; then
3436   echo "$as_me:$LINENO: checking for GNU ld" >&5
3437 echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6
3438 else
3439   echo "$as_me:$LINENO: checking for non-GNU ld" >&5
3440 echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6
3441 fi
3442 if test "${lt_cv_path_LD+set}" = set; then
3443   echo $ECHO_N "(cached) $ECHO_C" >&6
3444 else
3445   if test -z "$LD"; then
3446   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
3447   for ac_dir in $PATH; do
3448     test -z "$ac_dir" && ac_dir=.
3449     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
3450       lt_cv_path_LD="$ac_dir/$ac_prog"
3451       # Check to see if the program is GNU ld.  I'd rather use --version,
3452       # but apparently some GNU ld's only accept -v.
3453       # Break only if it was the GNU/non-GNU ld that we prefer.
3454       if "$lt_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
3455         test "$with_gnu_ld" != no && break
3456       else
3457         test "$with_gnu_ld" != yes && break
3458       fi
3459     fi
3460   done
3461   IFS="$ac_save_ifs"
3462 else
3463   lt_cv_path_LD="$LD" # Let the user override the test with a path.
3464 fi
3465 fi
3466
3467 LD="$lt_cv_path_LD"
3468 if test -n "$LD"; then
3469   echo "$as_me:$LINENO: result: $LD" >&5
3470 echo "${ECHO_T}$LD" >&6
3471 else
3472   echo "$as_me:$LINENO: result: no" >&5
3473 echo "${ECHO_T}no" >&6
3474 fi
3475 test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5
3476 echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}
3477    { (exit 1); exit 1; }; }
3478 echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
3479 echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6
3480 if test "${lt_cv_prog_gnu_ld+set}" = set; then
3481   echo $ECHO_N "(cached) $ECHO_C" >&6
3482 else
3483   # I'd rather use --version here, but apparently some GNU ld's only accept -v.
3484 if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
3485   lt_cv_prog_gnu_ld=yes
3486 else
3487   lt_cv_prog_gnu_ld=no
3488 fi
3489 fi
3490 echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
3491 echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6
3492 with_gnu_ld=$lt_cv_prog_gnu_ld
3493
3494
3495 echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
3496 echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6
3497 if test "${lt_cv_ld_reload_flag+set}" = set; then
3498   echo $ECHO_N "(cached) $ECHO_C" >&6
3499 else
3500   lt_cv_ld_reload_flag='-r'
3501 fi
3502 echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
3503 echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6
3504 reload_flag=$lt_cv_ld_reload_flag
3505 test -n "$reload_flag" && reload_flag=" $reload_flag"
3506
3507 echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
3508 echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6
3509 if test "${lt_cv_path_NM+set}" = set; then
3510   echo $ECHO_N "(cached) $ECHO_C" >&6
3511 else
3512   if test -n "$NM"; then
3513   # Let the user override the test.
3514   lt_cv_path_NM="$NM"
3515 else
3516   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
3517   for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
3518     test -z "$ac_dir" && ac_dir=.
3519     tmp_nm=$ac_dir/${ac_tool_prefix}nm
3520     if test -f $tmp_nm || test -f $tmp_nm$ac_exeext ; then
3521       # Check to see if the nm accepts a BSD-compat flag.
3522       # Adding the `sed 1q' prevents false positives on HP-UX, which says:
3523       #   nm: unknown option "B" ignored
3524       # Tru64's nm complains that /dev/null is an invalid object file
3525       if ($tmp_nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep '(/dev/null|Invalid file or object type)' >/dev/null; then
3526         lt_cv_path_NM="$tmp_nm -B"
3527         break
3528       elif ($tmp_nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
3529         lt_cv_path_NM="$tmp_nm -p"
3530         break
3531       else
3532         lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
3533         continue # so that we can try to find one that supports BSD flags
3534       fi
3535     fi
3536   done
3537   IFS="$ac_save_ifs"
3538   test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm
3539 fi
3540 fi
3541
3542 NM="$lt_cv_path_NM"
3543 echo "$as_me:$LINENO: result: $NM" >&5
3544 echo "${ECHO_T}$NM" >&6
3545
3546 echo "$as_me:$LINENO: checking whether ln -s works" >&5
3547 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3548 LN_S=$as_ln_s
3549 if test "$LN_S" = "ln -s"; then
3550   echo "$as_me:$LINENO: result: yes" >&5
3551 echo "${ECHO_T}yes" >&6
3552 else
3553   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3554 echo "${ECHO_T}no, using $LN_S" >&6
3555 fi
3556
3557 echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5
3558 echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6
3559 if test "${lt_cv_deplibs_check_method+set}" = set; then
3560   echo $ECHO_N "(cached) $ECHO_C" >&6
3561 else
3562   lt_cv_file_magic_cmd='$MAGIC_CMD'
3563 lt_cv_file_magic_test_file=
3564 lt_cv_deplibs_check_method='unknown'
3565 # Need to set the preceding variable on all platforms that support
3566 # interlibrary dependencies.
3567 # 'none' -- dependencies not supported.
3568 # `unknown' -- same as none, but documents that we really don't know.
3569 # 'pass_all' -- all dependencies passed with no checks.
3570 # 'test_compile' -- check by making test program.
3571 # 'file_magic [regex]' -- check by looking for files in library path
3572 # which responds to the $file_magic_cmd with a given egrep regex.
3573 # If you have `file' or equivalent on your system and you're not sure
3574 # whether `pass_all' will *always* work, you probably want this one.
3575
3576 case $host_os in
3577 aix*)
3578   lt_cv_deplibs_check_method=pass_all
3579   ;;
3580
3581 beos*)
3582   lt_cv_deplibs_check_method=pass_all
3583   ;;
3584
3585 bsdi4*)
3586   lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
3587   lt_cv_file_magic_cmd='/usr/bin/file -L'
3588   lt_cv_file_magic_test_file=/shlib/libc.so
3589   ;;
3590
3591 cygwin* | mingw* |pw32*)
3592   lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
3593   lt_cv_file_magic_cmd='$OBJDUMP -f'
3594   ;;
3595
3596 darwin* | rhapsody*)
3597   # this will be overwritten by pass_all, but leave it in just in case
3598   lt_cv_deplibs_check_method='file_magic Mach-O dynamically linked shared library'
3599   lt_cv_file_magic_cmd='/usr/bin/file -L'
3600   case "$host_os" in
3601   rhapsody* | darwin1.012)
3602     lt_cv_file_magic_test_file='/System/Library/Frameworks/System.framework/System'
3603     ;;
3604   *) # Darwin 1.3 on
3605     lt_cv_file_magic_test_file='/usr/lib/libSystem.dylib'
3606     ;;
3607   esac
3608   lt_cv_deplibs_check_method=pass_all
3609   ;;
3610
3611 freebsd* | kfreebsd*-gnu)
3612   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
3613     case $host_cpu in
3614     i*86 )
3615       # Not sure whether the presence of OpenBSD here was a mistake.
3616       # Let's accept both of them until this is cleared up.
3617       lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[3-9]86 (compact )?demand paged shared library'
3618       lt_cv_file_magic_cmd=/usr/bin/file
3619       lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
3620       ;;
3621     esac
3622   else
3623     lt_cv_deplibs_check_method=pass_all
3624   fi
3625   ;;
3626
3627 gnu*)
3628   lt_cv_deplibs_check_method=pass_all
3629   ;;
3630
3631 hpux10.20*|hpux11*)
3632   case $host_cpu in
3633   hppa*)
3634     lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library'
3635     lt_cv_file_magic_cmd=/usr/bin/file
3636     lt_cv_file_magic_test_file=/usr/lib/libc.sl
3637     ;;
3638   ia64*)
3639     lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
3640     lt_cv_file_magic_cmd=/usr/bin/file
3641     lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
3642     ;;
3643   esac
3644   ;;
3645
3646 irix5* | irix6*)
3647   case $host_os in
3648   irix5*)
3649     # this will be overridden with pass_all, but let us keep it just in case
3650     lt_cv_deplibs_check_method="file_magic ELF 32-bit MSB dynamic lib MIPS - version 1"
3651     ;;
3652   *)
3653     case $LD in
3654     *-32|*"-32 ") libmagic=32-bit;;
3655     *-n32|*"-n32 ") libmagic=N32;;
3656     *-64|*"-64 ") libmagic=64-bit;;
3657     *) libmagic=never-match;;
3658     esac
3659     # this will be overridden with pass_all, but let us keep it just in case
3660     lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[1234] dynamic lib MIPS - version 1"
3661     ;;
3662   esac
3663   lt_cv_file_magic_test_file=`echo /lib${libsuff}/libc.so*`
3664   lt_cv_deplibs_check_method=pass_all
3665   ;;
3666
3667 # This must be Linux ELF.
3668 linux-gnu*)
3669   lt_cv_deplibs_check_method=pass_all
3670   ;;
3671
3672 netbsd* | knetbsd*-gnu)
3673   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
3674     lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so\.[0-9]+\.[0-9]+$'
3675   else
3676     lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so$'
3677   fi
3678   ;;
3679
3680 newsos6)
3681   lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'
3682   lt_cv_file_magic_cmd=/usr/bin/file
3683   lt_cv_file_magic_test_file=/usr/lib/libnls.so
3684   ;;
3685
3686 osf3* | osf4* | osf5*)
3687   # this will be overridden with pass_all, but let us keep it just in case
3688   lt_cv_deplibs_check_method='file_magic COFF format alpha shared library'
3689   lt_cv_file_magic_test_file=/shlib/libc.so
3690   lt_cv_deplibs_check_method=pass_all
3691   ;;
3692
3693 sco3.2v5*)
3694   lt_cv_deplibs_check_method=pass_all
3695   ;;
3696
3697 solaris*)
3698   lt_cv_deplibs_check_method=pass_all
3699   lt_cv_file_magic_test_file=/lib/libc.so
3700   ;;
3701
3702 sysv5uw[78]* | sysv4*uw2*)
3703   lt_cv_deplibs_check_method=pass_all
3704   ;;
3705
3706 sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
3707   case $host_vendor in
3708   ncr)
3709     lt_cv_deplibs_check_method=pass_all
3710     ;;
3711   motorola)
3712     lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'
3713     lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
3714     ;;
3715   esac
3716   ;;
3717 esac
3718
3719 fi
3720 echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
3721 echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6
3722 file_magic_cmd=$lt_cv_file_magic_cmd
3723 deplibs_check_method=$lt_cv_deplibs_check_method
3724
3725
3726
3727
3728
3729 # Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
3730
3731 # find the maximum length of command line arguments
3732 echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
3733 echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6
3734 if test "${lt_cv_sys_max_cmd_len+set}" = set; then
3735   echo $ECHO_N "(cached) $ECHO_C" >&6
3736 else
3737     i=0
3738   teststring="ABCD"
3739
3740   case $build_os in
3741   msdosdjgpp*)
3742     # On DJGPP, this test can blow up pretty badly due to problems in libc
3743     # (any single argument exceeding 2000 bytes causes a buffer overrun
3744     # during glob expansion).  Even if it were fixed, the result of this
3745     # check would be larger than it should be.
3746     lt_cv_sys_max_cmd_len=12288;    # 12K is about right
3747     ;;
3748
3749   cygwin* | mingw*)
3750     # On Win9x/ME, this test blows up -- it succeeds, but takes
3751     # about 5 minutes as the teststring grows exponentially.
3752     # Worse, since 9x/ME are not pre-emptively multitasking,
3753     # you end up with a "frozen" computer, even though with patience
3754     # the test eventually succeeds (with a max line length of 256k).
3755     # Instead, let's just punt: use the minimum linelength reported by
3756     # all of the supported platforms: 8192 (on NT/2K/XP).
3757     lt_cv_sys_max_cmd_len=8192;
3758     ;;
3759
3760   amigaos*)
3761     # On AmigaOS with pdksh, this test takes hours, literally.
3762     # So we just punt and use a minimum line length of 8192.
3763     lt_cv_sys_max_cmd_len=8192;
3764     ;;
3765
3766   netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
3767     # This has been around since 386BSD, at least.  Likely further.
3768     if test -x /sbin/sysctl; then
3769       lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
3770     elif test -x /usr/sbin/sysctl; then
3771       lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
3772     else
3773       lt_cv_sys_max_cmd_len=65536 # usable default for *BSD
3774     fi
3775     # And add a safety zone
3776     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
3777     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
3778     ;;
3779   esac
3780
3781 fi
3782
3783 if test -n "$lt_cv_sys_max_cmd_len" ; then
3784   echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
3785 echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6
3786 else
3787   echo "$as_me:$LINENO: result: none" >&5
3788 echo "${ECHO_T}none" >&6
3789 fi
3790
3791
3792 # Only perform the check for file, if the check method requires it
3793 case $deplibs_check_method in
3794 file_magic*)
3795   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
3796     echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
3797 echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6
3798 if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
3799   echo $ECHO_N "(cached) $ECHO_C" >&6
3800 else
3801   case $MAGIC_CMD in
3802   /*)
3803   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
3804   ;;
3805   ?:/*)
3806   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
3807   ;;
3808   *)
3809   ac_save_MAGIC_CMD="$MAGIC_CMD"
3810   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3811   ac_dummy="/usr/bin:$PATH"
3812   for ac_dir in $ac_dummy; do
3813     test -z "$ac_dir" && ac_dir=.
3814     if test -f $ac_dir/${ac_tool_prefix}file; then
3815       lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
3816       if test -n "$file_magic_test_file"; then
3817         case $deplibs_check_method in
3818         "file_magic "*)
3819           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
3820           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
3821           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
3822             egrep "$file_magic_regex" > /dev/null; then
3823             :
3824           else
3825             cat <<EOF 1>&2
3826
3827 *** Warning: the command libtool uses to detect shared libraries,
3828 *** $file_magic_cmd, produces output that libtool cannot recognize.
3829 *** The result is that libtool may fail to recognize shared libraries
3830 *** as such.  This will affect the creation of libtool libraries that
3831 *** depend on shared libraries, but programs linked with such libtool
3832 *** libraries will work regardless of this problem.  Nevertheless, you
3833 *** may want to report the problem to your system manager and/or to
3834 *** bug-libtool@gnu.org
3835
3836 EOF
3837           fi ;;
3838         esac
3839       fi
3840       break
3841     fi
3842   done
3843   IFS="$ac_save_ifs"
3844   MAGIC_CMD="$ac_save_MAGIC_CMD"
3845   ;;
3846 esac
3847 fi
3848
3849 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
3850 if test -n "$MAGIC_CMD"; then
3851   echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
3852 echo "${ECHO_T}$MAGIC_CMD" >&6
3853 else
3854   echo "$as_me:$LINENO: result: no" >&5
3855 echo "${ECHO_T}no" >&6
3856 fi
3857
3858 if test -z "$lt_cv_path_MAGIC_CMD"; then
3859   if test -n "$ac_tool_prefix"; then
3860     echo "$as_me:$LINENO: checking for file" >&5
3861 echo $ECHO_N "checking for file... $ECHO_C" >&6
3862 if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
3863   echo $ECHO_N "(cached) $ECHO_C" >&6
3864 else
3865   case $MAGIC_CMD in
3866   /*)
3867   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
3868   ;;
3869   ?:/*)
3870   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
3871   ;;
3872   *)
3873   ac_save_MAGIC_CMD="$MAGIC_CMD"
3874   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3875   ac_dummy="/usr/bin:$PATH"
3876   for ac_dir in $ac_dummy; do
3877     test -z "$ac_dir" && ac_dir=.
3878     if test -f $ac_dir/file; then
3879       lt_cv_path_MAGIC_CMD="$ac_dir/file"
3880       if test -n "$file_magic_test_file"; then
3881         case $deplibs_check_method in
3882         "file_magic "*)
3883           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
3884           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
3885           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
3886             egrep "$file_magic_regex" > /dev/null; then
3887             :
3888           else
3889             cat <<EOF 1>&2
3890
3891 *** Warning: the command libtool uses to detect shared libraries,
3892 *** $file_magic_cmd, produces output that libtool cannot recognize.
3893 *** The result is that libtool may fail to recognize shared libraries
3894 *** as such.  This will affect the creation of libtool libraries that
3895 *** depend on shared libraries, but programs linked with such libtool
3896 *** libraries will work regardless of this problem.  Nevertheless, you
3897 *** may want to report the problem to your system manager and/or to
3898 *** bug-libtool@gnu.org
3899
3900 EOF
3901           fi ;;
3902         esac
3903       fi
3904       break
3905     fi
3906   done
3907   IFS="$ac_save_ifs"
3908   MAGIC_CMD="$ac_save_MAGIC_CMD"
3909   ;;
3910 esac
3911 fi
3912
3913 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
3914 if test -n "$MAGIC_CMD"; then
3915   echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
3916 echo "${ECHO_T}$MAGIC_CMD" >&6
3917 else
3918   echo "$as_me:$LINENO: result: no" >&5
3919 echo "${ECHO_T}no" >&6
3920 fi
3921
3922   else
3923     MAGIC_CMD=:
3924   fi
3925 fi
3926
3927   fi
3928   ;;
3929 esac
3930
3931 if test -n "$ac_tool_prefix"; then
3932   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3933 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3934 echo "$as_me:$LINENO: checking for $ac_word" >&5
3935 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3936 if test "${ac_cv_prog_RANLIB+set}" = set; then
3937   echo $ECHO_N "(cached) $ECHO_C" >&6
3938 else
3939   if test -n "$RANLIB"; then
3940   ac_cv_prog_RANLIB="$RANLIB" # 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 $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3949     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3950     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3951     break 2
3952   fi
3953 done
3954 done
3955
3956 fi
3957 fi
3958 RANLIB=$ac_cv_prog_RANLIB
3959 if test -n "$RANLIB"; then
3960   echo "$as_me:$LINENO: result: $RANLIB" >&5
3961 echo "${ECHO_T}$RANLIB" >&6
3962 else
3963   echo "$as_me:$LINENO: result: no" >&5
3964 echo "${ECHO_T}no" >&6
3965 fi
3966
3967 fi
3968 if test -z "$ac_cv_prog_RANLIB"; then
3969   ac_ct_RANLIB=$RANLIB
3970   # Extract the first word of "ranlib", so it can be a program name with args.
3971 set dummy ranlib; ac_word=$2
3972 echo "$as_me:$LINENO: checking for $ac_word" >&5
3973 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3974 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3975   echo $ECHO_N "(cached) $ECHO_C" >&6
3976 else
3977   if test -n "$ac_ct_RANLIB"; then
3978   ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3979 else
3980 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3981 for as_dir in $PATH
3982 do
3983   IFS=$as_save_IFS
3984   test -z "$as_dir" && as_dir=.
3985   for ac_exec_ext in '' $ac_executable_extensions; do
3986   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3987     ac_cv_prog_ac_ct_RANLIB="ranlib"
3988     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3989     break 2
3990   fi
3991 done
3992 done
3993
3994   test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3995 fi
3996 fi
3997 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3998 if test -n "$ac_ct_RANLIB"; then
3999   echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
4000 echo "${ECHO_T}$ac_ct_RANLIB" >&6
4001 else
4002   echo "$as_me:$LINENO: result: no" >&5
4003 echo "${ECHO_T}no" >&6
4004 fi
4005
4006   RANLIB=$ac_ct_RANLIB
4007 else
4008   RANLIB="$ac_cv_prog_RANLIB"
4009 fi
4010
4011 if test -n "$ac_tool_prefix"; then
4012   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
4013 set dummy ${ac_tool_prefix}strip; ac_word=$2
4014 echo "$as_me:$LINENO: checking for $ac_word" >&5
4015 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4016 if test "${ac_cv_prog_STRIP+set}" = set; then
4017   echo $ECHO_N "(cached) $ECHO_C" >&6
4018 else
4019   if test -n "$STRIP"; then
4020   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
4021 else
4022 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4023 for as_dir in $PATH
4024 do
4025   IFS=$as_save_IFS
4026   test -z "$as_dir" && as_dir=.
4027   for ac_exec_ext in '' $ac_executable_extensions; do
4028   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4029     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
4030     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4031     break 2
4032   fi
4033 done
4034 done
4035
4036 fi
4037 fi
4038 STRIP=$ac_cv_prog_STRIP
4039 if test -n "$STRIP"; then
4040   echo "$as_me:$LINENO: result: $STRIP" >&5
4041 echo "${ECHO_T}$STRIP" >&6
4042 else
4043   echo "$as_me:$LINENO: result: no" >&5
4044 echo "${ECHO_T}no" >&6
4045 fi
4046
4047 fi
4048 if test -z "$ac_cv_prog_STRIP"; then
4049   ac_ct_STRIP=$STRIP
4050   # Extract the first word of "strip", so it can be a program name with args.
4051 set dummy strip; ac_word=$2
4052 echo "$as_me:$LINENO: checking for $ac_word" >&5
4053 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4054 if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
4055   echo $ECHO_N "(cached) $ECHO_C" >&6
4056 else
4057   if test -n "$ac_ct_STRIP"; then
4058   ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
4059 else
4060 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4061 for as_dir in $PATH
4062 do
4063   IFS=$as_save_IFS
4064   test -z "$as_dir" && as_dir=.
4065   for ac_exec_ext in '' $ac_executable_extensions; do
4066   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4067     ac_cv_prog_ac_ct_STRIP="strip"
4068     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4069     break 2
4070   fi
4071 done
4072 done
4073
4074   test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
4075 fi
4076 fi
4077 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
4078 if test -n "$ac_ct_STRIP"; then
4079   echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
4080 echo "${ECHO_T}$ac_ct_STRIP" >&6
4081 else
4082   echo "$as_me:$LINENO: result: no" >&5
4083 echo "${ECHO_T}no" >&6
4084 fi
4085
4086   STRIP=$ac_ct_STRIP
4087 else
4088   STRIP="$ac_cv_prog_STRIP"
4089 fi
4090
4091
4092 # Check for any special flags to pass to ltconfig.
4093 libtool_flags="--cache-file=$cache_file"
4094 test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
4095 test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
4096 test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
4097 test "$GCC" = yes && libtool_flags="$libtool_flags --with-gcc"
4098 test "$lt_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
4099
4100
4101 # Check whether --enable-libtool-lock or --disable-libtool-lock was given.
4102 if test "${enable_libtool_lock+set}" = set; then
4103   enableval="$enable_libtool_lock"
4104
4105 fi;
4106 test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
4107 test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
4108
4109
4110 # Check whether --with-pic or --without-pic was given.
4111 if test "${with_pic+set}" = set; then
4112   withval="$with_pic"
4113   pic_mode="$withval"
4114 else
4115   pic_mode=default
4116 fi;
4117 test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic"
4118 test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
4119
4120 # Some flags need to be propagated to the compiler or linker for good
4121 # libtool support.
4122 case $host in
4123 *-*-irix6*)
4124   # Find out which ABI we are using.
4125   echo '#line 4125 "configure"' > conftest.$ac_ext
4126   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4127   (eval $ac_compile) 2>&5
4128   ac_status=$?
4129   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4130   (exit $ac_status); }; then
4131    if test "$lt_cv_prog_gnu_ld" = yes; then
4132     case `/usr/bin/file conftest.$ac_objext` in
4133     *32-bit*)
4134       LD="${LD-ld} -melf32bsmip"
4135       ;;
4136     *N32*)
4137       LD="${LD-ld} -melf32bmipn32"
4138       ;;
4139     *64-bit*)
4140       LD="${LD-ld} -melf64bmip"
4141       ;;
4142     esac
4143    else
4144     case `/usr/bin/file conftest.$ac_objext` in
4145     *32-bit*)
4146       LD="${LD-ld} -32"
4147       ;;
4148     *N32*)
4149       LD="${LD-ld} -n32"
4150       ;;
4151     *64-bit*)
4152       LD="${LD-ld} -64"
4153       ;;
4154     esac
4155    fi
4156   fi
4157   rm -rf conftest*
4158   ;;
4159
4160 ia64-*-hpux*)
4161   # Find out which ABI we are using.
4162   echo 'int i;' > conftest.$ac_ext
4163   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4164   (eval $ac_compile) 2>&5
4165   ac_status=$?
4166   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4167   (exit $ac_status); }; then
4168     case "`/usr/bin/file conftest.o`" in
4169     *ELF-32*)
4170       HPUX_IA64_MODE="32"
4171       ;;
4172     *ELF-64*)
4173       HPUX_IA64_MODE="64"
4174       ;;
4175     esac
4176   fi
4177   rm -rf conftest*
4178   ;;
4179
4180 x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*)
4181   # Find out which ABI we are using.
4182   echo 'int i;' > conftest.$ac_ext
4183   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4184   (eval $ac_compile) 2>&5
4185   ac_status=$?
4186   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4187   (exit $ac_status); }; then
4188     case "`/usr/bin/file conftest.o`" in
4189     *32-bit*)
4190       case $host in
4191         x86_64-*linux*)
4192           LD="${LD-ld} -m elf_i386"
4193           ;;
4194         ppc64-*linux*|powerpc64-*linux*)
4195           LD="${LD-ld} -m elf32ppclinux"
4196           ;;
4197         s390x-*linux*)
4198           LD="${LD-ld} -m elf_s390"
4199           ;;
4200         sparc64-*linux*)
4201           LD="${LD-ld} -m elf32_sparc"
4202           ;;
4203       esac
4204       ;;
4205     *64-bit*)
4206       case $host in
4207         x86_64-*linux*)
4208           LD="${LD-ld} -m elf_x86_64"
4209           ;;
4210         ppc*-*linux*|powerpc*-*linux*)
4211           LD="${LD-ld} -m elf64ppc"
4212           ;;
4213         s390*-*linux*)
4214           LD="${LD-ld} -m elf64_s390"
4215           ;;
4216         sparc*-*linux*)
4217           LD="${LD-ld} -m elf64_sparc"
4218           ;;
4219       esac
4220       ;;
4221     esac
4222   fi
4223   rm -rf conftest*
4224   ;;
4225
4226 *-*-sco3.2v5*)
4227   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
4228   SAVE_CFLAGS="$CFLAGS"
4229   CFLAGS="$CFLAGS -belf"
4230   echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
4231 echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6
4232 if test "${lt_cv_cc_needs_belf+set}" = set; then
4233   echo $ECHO_N "(cached) $ECHO_C" >&6
4234 else
4235
4236
4237      ac_ext=c
4238 ac_cpp='$CPP $CPPFLAGS'
4239 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4240 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4241 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4242
4243      if test x$gcc_no_link = xyes; then
4244   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
4245 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
4246    { (exit 1); exit 1; }; }
4247 fi
4248 cat >conftest.$ac_ext <<_ACEOF
4249 /* confdefs.h.  */
4250 _ACEOF
4251 cat confdefs.h >>conftest.$ac_ext
4252 cat >>conftest.$ac_ext <<_ACEOF
4253 /* end confdefs.h.  */
4254
4255 int
4256 main ()
4257 {
4258
4259   ;
4260   return 0;
4261 }
4262 _ACEOF
4263 rm -f conftest.$ac_objext conftest$ac_exeext
4264 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4265   (eval $ac_link) 2>conftest.er1
4266   ac_status=$?
4267   grep -v '^ *+' conftest.er1 >conftest.err
4268   rm -f conftest.er1
4269   cat conftest.err >&5
4270   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4271   (exit $ac_status); } &&
4272          { ac_try='test -z "$ac_c_werror_flag"
4273                          || test ! -s conftest.err'
4274   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4275   (eval $ac_try) 2>&5
4276   ac_status=$?
4277   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4278   (exit $ac_status); }; } &&
4279          { ac_try='test -s conftest$ac_exeext'
4280   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4281   (eval $ac_try) 2>&5
4282   ac_status=$?
4283   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4284   (exit $ac_status); }; }; then
4285   lt_cv_cc_needs_belf=yes
4286 else
4287   echo "$as_me: failed program was:" >&5
4288 sed 's/^/| /' conftest.$ac_ext >&5
4289
4290 lt_cv_cc_needs_belf=no
4291 fi
4292 rm -f conftest.err conftest.$ac_objext \
4293       conftest$ac_exeext conftest.$ac_ext
4294      ac_ext=c
4295 ac_cpp='$CPP $CPPFLAGS'
4296 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4297 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4298 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4299
4300 fi
4301 echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
4302 echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6
4303   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
4304     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
4305     CFLAGS="$SAVE_CFLAGS"
4306   fi
4307   ;;
4308
4309
4310 esac
4311
4312
4313 # Save cache, so that ltconfig can load it
4314 cat >confcache <<\_ACEOF
4315 # This file is a shell script that caches the results of configure
4316 # tests run on this system so they can be shared between configure
4317 # scripts and configure runs, see configure's option --config-cache.
4318 # It is not useful on other systems.  If it contains results you don't
4319 # want to keep, you may remove or edit it.
4320 #
4321 # config.status only pays attention to the cache file if you give it
4322 # the --recheck option to rerun configure.
4323 #
4324 # `ac_cv_env_foo' variables (set or unset) will be overridden when
4325 # loading this file, other *unset* `ac_cv_foo' will be assigned the
4326 # following values.
4327
4328 _ACEOF
4329
4330 # The following way of writing the cache mishandles newlines in values,
4331 # but we know of no workaround that is simple, portable, and efficient.
4332 # So, don't put newlines in cache variables' values.
4333 # Ultrix sh set writes to stderr and can't be redirected directly,
4334 # and sets the high bit in the cache file unless we assign to the vars.
4335 {
4336   (set) 2>&1 |
4337     case `(ac_space=' '; set | grep ac_space) 2>&1` in
4338     *ac_space=\ *)
4339       # `set' does not quote correctly, so add quotes (double-quote
4340       # substitution turns \\\\ into \\, and sed turns \\ into \).
4341       sed -n \
4342         "s/'/'\\\\''/g;
4343           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
4344       ;;
4345     *)
4346       # `set' quotes correctly as required by POSIX, so do not add quotes.
4347       sed -n \
4348         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
4349       ;;
4350     esac;
4351 } |
4352   sed '
4353      t clear
4354      : clear
4355      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
4356      t end
4357      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
4358      : end' >>confcache
4359 if diff $cache_file confcache >/dev/null 2>&1; then :; else
4360   if test -w $cache_file; then
4361     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
4362     cat confcache >$cache_file
4363   else
4364     echo "not updating unwritable cache $cache_file"
4365   fi
4366 fi
4367 rm -f confcache
4368
4369 # Actually configure libtool.  ac_aux_dir is where install-sh is found.
4370 AR="$AR" LTCC="$CC" CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
4371 MAGIC_CMD="$MAGIC_CMD" LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
4372 LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \
4373 AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \
4374 objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \
4375 deplibs_check_method="$deplibs_check_method" file_magic_cmd="$file_magic_cmd" \
4376 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
4377 $libtool_flags --no-verify --build="$build" $ac_aux_dir/ltmain.sh $host \
4378 || { { echo "$as_me:$LINENO: error: libtool configure failed" >&5
4379 echo "$as_me: error: libtool configure failed" >&2;}
4380    { (exit 1); exit 1; }; }
4381
4382 # Reload cache, that may have been modified by ltconfig
4383 if test -r "$cache_file"; then
4384   # Some versions of bash will fail to source /dev/null (special
4385   # files actually), so we avoid doing that.
4386   if test -f "$cache_file"; then
4387     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
4388 echo "$as_me: loading cache $cache_file" >&6;}
4389     case $cache_file in
4390       [\\/]* | ?:[\\/]* ) . $cache_file;;
4391       *)                      . ./$cache_file;;
4392     esac
4393   fi
4394 else
4395   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
4396 echo "$as_me: creating cache $cache_file" >&6;}
4397   >$cache_file
4398 fi
4399
4400
4401 # This can be used to rebuild libtool when needed
4402 LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh $ac_aux_dir/ltcf-c.sh"
4403
4404 # Always use our own libtool.
4405 LIBTOOL='$(SHELL) $(top_builddir)/libtool'
4406
4407 # Redirect the config.log output again, so that the ltconfig log is not
4408 # clobbered by the next message.
4409 exec 5>>./config.log
4410
4411
4412
4413
4414
4415
4416
4417
4418 #AC_MSG_NOTICE([====== Finished libtool configuration]) ; sleep 10
4419
4420 # We need gfortran to compile parts of the library
4421 #AC_PROG_FC(gfortran)
4422 FC="$GFORTRAN"
4423 ac_ext=${FC_SRCEXT-f}
4424 ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4425 ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4426 ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4427 if test -n "$ac_tool_prefix"; then
4428   for ac_prog in gfortran
4429   do
4430     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4431 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4432 echo "$as_me:$LINENO: checking for $ac_word" >&5
4433 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4434 if test "${ac_cv_prog_FC+set}" = set; then
4435   echo $ECHO_N "(cached) $ECHO_C" >&6
4436 else
4437   if test -n "$FC"; then
4438   ac_cv_prog_FC="$FC" # Let the user override the test.
4439 else
4440 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4441 for as_dir in $PATH
4442 do
4443   IFS=$as_save_IFS
4444   test -z "$as_dir" && as_dir=.
4445   for ac_exec_ext in '' $ac_executable_extensions; do
4446   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4447     ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
4448     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4449     break 2
4450   fi
4451 done
4452 done
4453
4454 fi
4455 fi
4456 FC=$ac_cv_prog_FC
4457 if test -n "$FC"; then
4458   echo "$as_me:$LINENO: result: $FC" >&5
4459 echo "${ECHO_T}$FC" >&6
4460 else
4461   echo "$as_me:$LINENO: result: no" >&5
4462 echo "${ECHO_T}no" >&6
4463 fi
4464
4465     test -n "$FC" && break
4466   done
4467 fi
4468 if test -z "$FC"; then
4469   ac_ct_FC=$FC
4470   for ac_prog in gfortran
4471 do
4472   # Extract the first word of "$ac_prog", so it can be a program name with args.
4473 set dummy $ac_prog; ac_word=$2
4474 echo "$as_me:$LINENO: checking for $ac_word" >&5
4475 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4476 if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
4477   echo $ECHO_N "(cached) $ECHO_C" >&6
4478 else
4479   if test -n "$ac_ct_FC"; then
4480   ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
4481 else
4482 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4483 for as_dir in $PATH
4484 do
4485   IFS=$as_save_IFS
4486   test -z "$as_dir" && as_dir=.
4487   for ac_exec_ext in '' $ac_executable_extensions; do
4488   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4489     ac_cv_prog_ac_ct_FC="$ac_prog"
4490     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4491     break 2
4492   fi
4493 done
4494 done
4495
4496 fi
4497 fi
4498 ac_ct_FC=$ac_cv_prog_ac_ct_FC
4499 if test -n "$ac_ct_FC"; then
4500   echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
4501 echo "${ECHO_T}$ac_ct_FC" >&6
4502 else
4503   echo "$as_me:$LINENO: result: no" >&5
4504 echo "${ECHO_T}no" >&6
4505 fi
4506
4507   test -n "$ac_ct_FC" && break
4508 done
4509
4510   FC=$ac_ct_FC
4511 fi
4512
4513
4514 # Provide some information about the compiler.
4515 echo "$as_me:4515:" \
4516      "checking for Fortran compiler version" >&5
4517 ac_compiler=`set X $ac_compile; echo $2`
4518 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
4519   (eval $ac_compiler --version </dev/null >&5) 2>&5
4520   ac_status=$?
4521   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4522   (exit $ac_status); }
4523 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
4524   (eval $ac_compiler -v </dev/null >&5) 2>&5
4525   ac_status=$?
4526   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4527   (exit $ac_status); }
4528 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
4529   (eval $ac_compiler -V </dev/null >&5) 2>&5
4530   ac_status=$?
4531   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4532   (exit $ac_status); }
4533 rm -f a.out
4534
4535 # If we don't use `.F' as extension, the preprocessor is not run on the
4536 # input file.  (Note that this only needs to work for GNU compilers.)
4537 ac_save_ext=$ac_ext
4538 ac_ext=F
4539 echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
4540 echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
4541 if test "${ac_cv_fc_compiler_gnu+set}" = set; then
4542   echo $ECHO_N "(cached) $ECHO_C" >&6
4543 else
4544   cat >conftest.$ac_ext <<_ACEOF
4545       program main
4546 #ifndef __GNUC__
4547        choke me
4548 #endif
4549
4550       end
4551 _ACEOF
4552 rm -f conftest.$ac_objext
4553 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4554   (eval $ac_compile) 2>conftest.er1
4555   ac_status=$?
4556   grep -v '^ *+' conftest.er1 >conftest.err
4557   rm -f conftest.er1
4558   cat conftest.err >&5
4559   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4560   (exit $ac_status); } &&
4561          { ac_try='test -z "$ac_fc_werror_flag"
4562                          || test ! -s conftest.err'
4563   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4564   (eval $ac_try) 2>&5
4565   ac_status=$?
4566   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4567   (exit $ac_status); }; } &&
4568          { ac_try='test -s conftest.$ac_objext'
4569   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4570   (eval $ac_try) 2>&5
4571   ac_status=$?
4572   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4573   (exit $ac_status); }; }; then
4574   ac_compiler_gnu=yes
4575 else
4576   echo "$as_me: failed program was:" >&5
4577 sed 's/^/| /' conftest.$ac_ext >&5
4578
4579 ac_compiler_gnu=no
4580 fi
4581 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4582 ac_cv_fc_compiler_gnu=$ac_compiler_gnu
4583
4584 fi
4585 echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
4586 echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
4587 ac_ext=$ac_save_ext
4588 ac_test_FFLAGS=${FCFLAGS+set}
4589 ac_save_FFLAGS=$FCFLAGS
4590 FCFLAGS=
4591 echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
4592 echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
4593 if test "${ac_cv_prog_fc_g+set}" = set; then
4594   echo $ECHO_N "(cached) $ECHO_C" >&6
4595 else
4596   FCFLAGS=-g
4597 cat >conftest.$ac_ext <<_ACEOF
4598       program main
4599
4600       end
4601 _ACEOF
4602 rm -f conftest.$ac_objext
4603 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4604   (eval $ac_compile) 2>conftest.er1
4605   ac_status=$?
4606   grep -v '^ *+' conftest.er1 >conftest.err
4607   rm -f conftest.er1
4608   cat conftest.err >&5
4609   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4610   (exit $ac_status); } &&
4611          { ac_try='test -z "$ac_fc_werror_flag"
4612                          || test ! -s conftest.err'
4613   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4614   (eval $ac_try) 2>&5
4615   ac_status=$?
4616   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4617   (exit $ac_status); }; } &&
4618          { ac_try='test -s conftest.$ac_objext'
4619   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4620   (eval $ac_try) 2>&5
4621   ac_status=$?
4622   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4623   (exit $ac_status); }; }; then
4624   ac_cv_prog_fc_g=yes
4625 else
4626   echo "$as_me: failed program was:" >&5
4627 sed 's/^/| /' conftest.$ac_ext >&5
4628
4629 ac_cv_prog_fc_g=no
4630 fi
4631 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4632
4633 fi
4634 echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
4635 echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
4636 if test "$ac_test_FFLAGS" = set; then
4637   FCFLAGS=$ac_save_FFLAGS
4638 elif test $ac_cv_prog_fc_g = yes; then
4639   if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4640     FCFLAGS="-g -O2"
4641   else
4642     FCFLAGS="-g"
4643   fi
4644 else
4645   if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4646     FCFLAGS="-O2"
4647   else
4648     FCFLAGS=
4649   fi
4650 fi
4651
4652 ac_ext=c
4653 ac_cpp='$CPP $CPPFLAGS'
4654 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4655 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4656 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4657
4658
4659 # extra LD Flags which are required for targets
4660 case "${host}" in
4661   *-darwin*)
4662     # Darwin needs -single_module when linking libgfortran
4663     extra_ldflags_libgfortran=-Wl,-single_module
4664     ;;
4665 esac
4666
4667
4668 # Check whether --enable-largefile or --disable-largefile was given.
4669 if test "${enable_largefile+set}" = set; then
4670   enableval="$enable_largefile"
4671
4672 fi;
4673 if test "$enable_largefile" != no; then
4674
4675   echo "$as_me:$LINENO: checking for special C compiler options needed for large files" >&5
4676 echo $ECHO_N "checking for special C compiler options needed for large files... $ECHO_C" >&6
4677 if test "${ac_cv_sys_largefile_CC+set}" = set; then
4678   echo $ECHO_N "(cached) $ECHO_C" >&6
4679 else
4680   ac_cv_sys_largefile_CC=no
4681      if test "$GCC" != yes; then
4682        ac_save_CC=$CC
4683        while :; do
4684          # IRIX 6.2 and later do not support large files by default,
4685          # so use the C compiler's -n32 option if that helps.
4686          cat >conftest.$ac_ext <<_ACEOF
4687 /* confdefs.h.  */
4688 _ACEOF
4689 cat confdefs.h >>conftest.$ac_ext
4690 cat >>conftest.$ac_ext <<_ACEOF
4691 /* end confdefs.h.  */
4692 #include <sys/types.h>
4693  /* Check that off_t can represent 2**63 - 1 correctly.
4694     We can't simply define LARGE_OFF_T to be 9223372036854775807,
4695     since some C++ compilers masquerading as C compilers
4696     incorrectly reject 9223372036854775807.  */
4697 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4698   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4699                        && LARGE_OFF_T % 2147483647 == 1)
4700                       ? 1 : -1];
4701 int
4702 main ()
4703 {
4704
4705   ;
4706   return 0;
4707 }
4708 _ACEOF
4709          rm -f conftest.$ac_objext
4710 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4711   (eval $ac_compile) 2>conftest.er1
4712   ac_status=$?
4713   grep -v '^ *+' conftest.er1 >conftest.err
4714   rm -f conftest.er1
4715   cat conftest.err >&5
4716   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4717   (exit $ac_status); } &&
4718          { ac_try='test -z "$ac_c_werror_flag"
4719                          || test ! -s conftest.err'
4720   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4721   (eval $ac_try) 2>&5
4722   ac_status=$?
4723   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4724   (exit $ac_status); }; } &&
4725          { ac_try='test -s conftest.$ac_objext'
4726   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4727   (eval $ac_try) 2>&5
4728   ac_status=$?
4729   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4730   (exit $ac_status); }; }; then
4731   break
4732 else
4733   echo "$as_me: failed program was:" >&5
4734 sed 's/^/| /' conftest.$ac_ext >&5
4735
4736 fi
4737 rm -f conftest.err conftest.$ac_objext
4738          CC="$CC -n32"
4739          rm -f conftest.$ac_objext
4740 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4741   (eval $ac_compile) 2>conftest.er1
4742   ac_status=$?
4743   grep -v '^ *+' conftest.er1 >conftest.err
4744   rm -f conftest.er1
4745   cat conftest.err >&5
4746   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4747   (exit $ac_status); } &&
4748          { ac_try='test -z "$ac_c_werror_flag"
4749                          || test ! -s conftest.err'
4750   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4751   (eval $ac_try) 2>&5
4752   ac_status=$?
4753   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4754   (exit $ac_status); }; } &&
4755          { ac_try='test -s conftest.$ac_objext'
4756   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4757   (eval $ac_try) 2>&5
4758   ac_status=$?
4759   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4760   (exit $ac_status); }; }; then
4761   ac_cv_sys_largefile_CC=' -n32'; break
4762 else
4763   echo "$as_me: failed program was:" >&5
4764 sed 's/^/| /' conftest.$ac_ext >&5
4765
4766 fi
4767 rm -f conftest.err conftest.$ac_objext
4768          break
4769        done
4770        CC=$ac_save_CC
4771        rm -f conftest.$ac_ext
4772     fi
4773 fi
4774 echo "$as_me:$LINENO: result: $ac_cv_sys_largefile_CC" >&5
4775 echo "${ECHO_T}$ac_cv_sys_largefile_CC" >&6
4776   if test "$ac_cv_sys_largefile_CC" != no; then
4777     CC=$CC$ac_cv_sys_largefile_CC
4778   fi
4779
4780   echo "$as_me:$LINENO: checking for _FILE_OFFSET_BITS value needed for large files" >&5
4781 echo $ECHO_N "checking for _FILE_OFFSET_BITS value needed for large files... $ECHO_C" >&6
4782 if test "${ac_cv_sys_file_offset_bits+set}" = set; then
4783   echo $ECHO_N "(cached) $ECHO_C" >&6
4784 else
4785   while :; do
4786   ac_cv_sys_file_offset_bits=no
4787   cat >conftest.$ac_ext <<_ACEOF
4788 /* confdefs.h.  */
4789 _ACEOF
4790 cat confdefs.h >>conftest.$ac_ext
4791 cat >>conftest.$ac_ext <<_ACEOF
4792 /* end confdefs.h.  */
4793 #include <sys/types.h>
4794  /* Check that off_t can represent 2**63 - 1 correctly.
4795     We can't simply define LARGE_OFF_T to be 9223372036854775807,
4796     since some C++ compilers masquerading as C compilers
4797     incorrectly reject 9223372036854775807.  */
4798 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4799   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4800                        && LARGE_OFF_T % 2147483647 == 1)
4801                       ? 1 : -1];
4802 int
4803 main ()
4804 {
4805
4806   ;
4807   return 0;
4808 }
4809 _ACEOF
4810 rm -f conftest.$ac_objext
4811 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4812   (eval $ac_compile) 2>conftest.er1
4813   ac_status=$?
4814   grep -v '^ *+' conftest.er1 >conftest.err
4815   rm -f conftest.er1
4816   cat conftest.err >&5
4817   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4818   (exit $ac_status); } &&
4819          { ac_try='test -z "$ac_c_werror_flag"
4820                          || test ! -s conftest.err'
4821   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4822   (eval $ac_try) 2>&5
4823   ac_status=$?
4824   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4825   (exit $ac_status); }; } &&
4826          { ac_try='test -s conftest.$ac_objext'
4827   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4828   (eval $ac_try) 2>&5
4829   ac_status=$?
4830   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4831   (exit $ac_status); }; }; then
4832   break
4833 else
4834   echo "$as_me: failed program was:" >&5
4835 sed 's/^/| /' conftest.$ac_ext >&5
4836
4837 fi
4838 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4839   cat >conftest.$ac_ext <<_ACEOF
4840 /* confdefs.h.  */
4841 _ACEOF
4842 cat confdefs.h >>conftest.$ac_ext
4843 cat >>conftest.$ac_ext <<_ACEOF
4844 /* end confdefs.h.  */
4845 #define _FILE_OFFSET_BITS 64
4846 #include <sys/types.h>
4847  /* Check that off_t can represent 2**63 - 1 correctly.
4848     We can't simply define LARGE_OFF_T to be 9223372036854775807,
4849     since some C++ compilers masquerading as C compilers
4850     incorrectly reject 9223372036854775807.  */
4851 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4852   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4853                        && LARGE_OFF_T % 2147483647 == 1)
4854                       ? 1 : -1];
4855 int
4856 main ()
4857 {
4858
4859   ;
4860   return 0;
4861 }
4862 _ACEOF
4863 rm -f conftest.$ac_objext
4864 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4865   (eval $ac_compile) 2>conftest.er1
4866   ac_status=$?
4867   grep -v '^ *+' conftest.er1 >conftest.err
4868   rm -f conftest.er1
4869   cat conftest.err >&5
4870   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4871   (exit $ac_status); } &&
4872          { ac_try='test -z "$ac_c_werror_flag"
4873                          || test ! -s conftest.err'
4874   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4875   (eval $ac_try) 2>&5
4876   ac_status=$?
4877   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4878   (exit $ac_status); }; } &&
4879          { ac_try='test -s conftest.$ac_objext'
4880   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4881   (eval $ac_try) 2>&5
4882   ac_status=$?
4883   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4884   (exit $ac_status); }; }; then
4885   ac_cv_sys_file_offset_bits=64; break
4886 else
4887   echo "$as_me: failed program was:" >&5
4888 sed 's/^/| /' conftest.$ac_ext >&5
4889
4890 fi
4891 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4892   break
4893 done
4894 fi
4895 echo "$as_me:$LINENO: result: $ac_cv_sys_file_offset_bits" >&5
4896 echo "${ECHO_T}$ac_cv_sys_file_offset_bits" >&6
4897 if test "$ac_cv_sys_file_offset_bits" != no; then
4898
4899 cat >>confdefs.h <<_ACEOF
4900 #define _FILE_OFFSET_BITS $ac_cv_sys_file_offset_bits
4901 _ACEOF
4902
4903 fi
4904 rm -f conftest*
4905   echo "$as_me:$LINENO: checking for _LARGE_FILES value needed for large files" >&5
4906 echo $ECHO_N "checking for _LARGE_FILES value needed for large files... $ECHO_C" >&6
4907 if test "${ac_cv_sys_large_files+set}" = set; then
4908   echo $ECHO_N "(cached) $ECHO_C" >&6
4909 else
4910   while :; do
4911   ac_cv_sys_large_files=no
4912   cat >conftest.$ac_ext <<_ACEOF
4913 /* confdefs.h.  */
4914 _ACEOF
4915 cat confdefs.h >>conftest.$ac_ext
4916 cat >>conftest.$ac_ext <<_ACEOF
4917 /* end confdefs.h.  */
4918 #include <sys/types.h>
4919  /* Check that off_t can represent 2**63 - 1 correctly.
4920     We can't simply define LARGE_OFF_T to be 9223372036854775807,
4921     since some C++ compilers masquerading as C compilers
4922     incorrectly reject 9223372036854775807.  */
4923 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4924   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4925                        && LARGE_OFF_T % 2147483647 == 1)
4926                       ? 1 : -1];
4927 int
4928 main ()
4929 {
4930
4931   ;
4932   return 0;
4933 }
4934 _ACEOF
4935 rm -f conftest.$ac_objext
4936 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4937   (eval $ac_compile) 2>conftest.er1
4938   ac_status=$?
4939   grep -v '^ *+' conftest.er1 >conftest.err
4940   rm -f conftest.er1
4941   cat conftest.err >&5
4942   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4943   (exit $ac_status); } &&
4944          { ac_try='test -z "$ac_c_werror_flag"
4945                          || test ! -s conftest.err'
4946   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4947   (eval $ac_try) 2>&5
4948   ac_status=$?
4949   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4950   (exit $ac_status); }; } &&
4951          { ac_try='test -s conftest.$ac_objext'
4952   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4953   (eval $ac_try) 2>&5
4954   ac_status=$?
4955   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4956   (exit $ac_status); }; }; then
4957   break
4958 else
4959   echo "$as_me: failed program was:" >&5
4960 sed 's/^/| /' conftest.$ac_ext >&5
4961
4962 fi
4963 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4964   cat >conftest.$ac_ext <<_ACEOF
4965 /* confdefs.h.  */
4966 _ACEOF
4967 cat confdefs.h >>conftest.$ac_ext
4968 cat >>conftest.$ac_ext <<_ACEOF
4969 /* end confdefs.h.  */
4970 #define _LARGE_FILES 1
4971 #include <sys/types.h>
4972  /* Check that off_t can represent 2**63 - 1 correctly.
4973     We can't simply define LARGE_OFF_T to be 9223372036854775807,
4974     since some C++ compilers masquerading as C compilers
4975     incorrectly reject 9223372036854775807.  */
4976 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4977   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4978                        && LARGE_OFF_T % 2147483647 == 1)
4979                       ? 1 : -1];
4980 int
4981 main ()
4982 {
4983
4984   ;
4985   return 0;
4986 }
4987 _ACEOF
4988 rm -f conftest.$ac_objext
4989 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4990   (eval $ac_compile) 2>conftest.er1
4991   ac_status=$?
4992   grep -v '^ *+' conftest.er1 >conftest.err
4993   rm -f conftest.er1
4994   cat conftest.err >&5
4995   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4996   (exit $ac_status); } &&
4997          { ac_try='test -z "$ac_c_werror_flag"
4998                          || test ! -s conftest.err'
4999   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5000   (eval $ac_try) 2>&5
5001   ac_status=$?
5002   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5003   (exit $ac_status); }; } &&
5004          { ac_try='test -s conftest.$ac_objext'
5005   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5006   (eval $ac_try) 2>&5
5007   ac_status=$?
5008   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5009   (exit $ac_status); }; }; then
5010   ac_cv_sys_large_files=1; break
5011 else
5012   echo "$as_me: failed program was:" >&5
5013 sed 's/^/| /' conftest.$ac_ext >&5
5014
5015 fi
5016 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5017   break
5018 done
5019 fi
5020 echo "$as_me:$LINENO: result: $ac_cv_sys_large_files" >&5
5021 echo "${ECHO_T}$ac_cv_sys_large_files" >&6
5022 if test "$ac_cv_sys_large_files" != no; then
5023
5024 cat >>confdefs.h <<_ACEOF
5025 #define _LARGE_FILES $ac_cv_sys_large_files
5026 _ACEOF
5027
5028 fi
5029 rm -f conftest*
5030 fi
5031
5032 if test x$gcc_no_link = xyes; then
5033   if test "x${ac_cv_func_mmap_fixed_mapped+set}" != xset; then
5034     ac_cv_func_mmap_fixed_mapped=no
5035   fi
5036 fi
5037 if test "x${ac_cv_func_mmap_fixed_mapped}" != xno; then
5038   ac_ext=c
5039 ac_cpp='$CPP $CPPFLAGS'
5040 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5041 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5042 ac_compiler_gnu=$ac_cv_c_compiler_gnu
5043 echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
5044 echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
5045 # On Suns, sometimes $CPP names a directory.
5046 if test -n "$CPP" && test -d "$CPP"; then
5047   CPP=
5048 fi
5049 if test -z "$CPP"; then
5050   if test "${ac_cv_prog_CPP+set}" = set; then
5051   echo $ECHO_N "(cached) $ECHO_C" >&6
5052 else
5053       # Double quotes because CPP needs to be expanded
5054     for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
5055     do
5056       ac_preproc_ok=false
5057 for ac_c_preproc_warn_flag in '' yes
5058 do
5059   # Use a header file that comes with gcc, so configuring glibc
5060   # with a fresh cross-compiler works.
5061   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5062   # <limits.h> exists even on freestanding compilers.
5063   # On the NeXT, cc -E runs the code through the compiler's parser,
5064   # not just through cpp. "Syntax error" is here to catch this case.
5065   cat >conftest.$ac_ext <<_ACEOF
5066 /* confdefs.h.  */
5067 _ACEOF
5068 cat confdefs.h >>conftest.$ac_ext
5069 cat >>conftest.$ac_ext <<_ACEOF
5070 /* end confdefs.h.  */
5071 #ifdef __STDC__
5072 # include <limits.h>
5073 #else
5074 # include <assert.h>
5075 #endif
5076                      Syntax error
5077 _ACEOF
5078 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5079   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5080   ac_status=$?
5081   grep -v '^ *+' conftest.er1 >conftest.err
5082   rm -f conftest.er1
5083   cat conftest.err >&5
5084   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5085   (exit $ac_status); } >/dev/null; then
5086   if test -s conftest.err; then
5087     ac_cpp_err=$ac_c_preproc_warn_flag
5088     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5089   else
5090     ac_cpp_err=
5091   fi
5092 else
5093   ac_cpp_err=yes
5094 fi
5095 if test -z "$ac_cpp_err"; then
5096   :
5097 else
5098   echo "$as_me: failed program was:" >&5
5099 sed 's/^/| /' conftest.$ac_ext >&5
5100
5101   # Broken: fails on valid input.
5102 continue
5103 fi
5104 rm -f conftest.err conftest.$ac_ext
5105
5106   # OK, works on sane cases.  Now check whether non-existent headers
5107   # can be detected and how.
5108   cat >conftest.$ac_ext <<_ACEOF
5109 /* confdefs.h.  */
5110 _ACEOF
5111 cat confdefs.h >>conftest.$ac_ext
5112 cat >>conftest.$ac_ext <<_ACEOF
5113 /* end confdefs.h.  */
5114 #include <ac_nonexistent.h>
5115 _ACEOF
5116 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5117   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5118   ac_status=$?
5119   grep -v '^ *+' conftest.er1 >conftest.err
5120   rm -f conftest.er1
5121   cat conftest.err >&5
5122   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5123   (exit $ac_status); } >/dev/null; then
5124   if test -s conftest.err; then
5125     ac_cpp_err=$ac_c_preproc_warn_flag
5126     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5127   else
5128     ac_cpp_err=
5129   fi
5130 else
5131   ac_cpp_err=yes
5132 fi
5133 if test -z "$ac_cpp_err"; then
5134   # Broken: success on invalid input.
5135 continue
5136 else
5137   echo "$as_me: failed program was:" >&5
5138 sed 's/^/| /' conftest.$ac_ext >&5
5139
5140   # Passes both tests.
5141 ac_preproc_ok=:
5142 break
5143 fi
5144 rm -f conftest.err conftest.$ac_ext
5145
5146 done
5147 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5148 rm -f conftest.err conftest.$ac_ext
5149 if $ac_preproc_ok; then
5150   break
5151 fi
5152
5153     done
5154     ac_cv_prog_CPP=$CPP
5155
5156 fi
5157   CPP=$ac_cv_prog_CPP
5158 else
5159   ac_cv_prog_CPP=$CPP
5160 fi
5161 echo "$as_me:$LINENO: result: $CPP" >&5
5162 echo "${ECHO_T}$CPP" >&6
5163 ac_preproc_ok=false
5164 for ac_c_preproc_warn_flag in '' yes
5165 do
5166   # Use a header file that comes with gcc, so configuring glibc
5167   # with a fresh cross-compiler works.
5168   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5169   # <limits.h> exists even on freestanding compilers.
5170   # On the NeXT, cc -E runs the code through the compiler's parser,
5171   # not just through cpp. "Syntax error" is here to catch this case.
5172   cat >conftest.$ac_ext <<_ACEOF
5173 /* confdefs.h.  */
5174 _ACEOF
5175 cat confdefs.h >>conftest.$ac_ext
5176 cat >>conftest.$ac_ext <<_ACEOF
5177 /* end confdefs.h.  */
5178 #ifdef __STDC__
5179 # include <limits.h>
5180 #else
5181 # include <assert.h>
5182 #endif
5183                      Syntax error
5184 _ACEOF
5185 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5186   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5187   ac_status=$?
5188   grep -v '^ *+' conftest.er1 >conftest.err
5189   rm -f conftest.er1
5190   cat conftest.err >&5
5191   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5192   (exit $ac_status); } >/dev/null; then
5193   if test -s conftest.err; then
5194     ac_cpp_err=$ac_c_preproc_warn_flag
5195     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5196   else
5197     ac_cpp_err=
5198   fi
5199 else
5200   ac_cpp_err=yes
5201 fi
5202 if test -z "$ac_cpp_err"; then
5203   :
5204 else
5205   echo "$as_me: failed program was:" >&5
5206 sed 's/^/| /' conftest.$ac_ext >&5
5207
5208   # Broken: fails on valid input.
5209 continue
5210 fi
5211 rm -f conftest.err conftest.$ac_ext
5212
5213   # OK, works on sane cases.  Now check whether non-existent headers
5214   # can be detected and how.
5215   cat >conftest.$ac_ext <<_ACEOF
5216 /* confdefs.h.  */
5217 _ACEOF
5218 cat confdefs.h >>conftest.$ac_ext
5219 cat >>conftest.$ac_ext <<_ACEOF
5220 /* end confdefs.h.  */
5221 #include <ac_nonexistent.h>
5222 _ACEOF
5223 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5224   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5225   ac_status=$?
5226   grep -v '^ *+' conftest.er1 >conftest.err
5227   rm -f conftest.er1
5228   cat conftest.err >&5
5229   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5230   (exit $ac_status); } >/dev/null; then
5231   if test -s conftest.err; then
5232     ac_cpp_err=$ac_c_preproc_warn_flag
5233     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5234   else
5235     ac_cpp_err=
5236   fi
5237 else
5238   ac_cpp_err=yes
5239 fi
5240 if test -z "$ac_cpp_err"; then
5241   # Broken: success on invalid input.
5242 continue
5243 else
5244   echo "$as_me: failed program was:" >&5
5245 sed 's/^/| /' conftest.$ac_ext >&5
5246
5247   # Passes both tests.
5248 ac_preproc_ok=:
5249 break
5250 fi
5251 rm -f conftest.err conftest.$ac_ext
5252
5253 done
5254 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5255 rm -f conftest.err conftest.$ac_ext
5256 if $ac_preproc_ok; then
5257   :
5258 else
5259   { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
5260 See \`config.log' for more details." >&5
5261 echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
5262 See \`config.log' for more details." >&2;}
5263    { (exit 1); exit 1; }; }
5264 fi
5265
5266 ac_ext=c
5267 ac_cpp='$CPP $CPPFLAGS'
5268 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5269 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5270 ac_compiler_gnu=$ac_cv_c_compiler_gnu
5271
5272
5273 echo "$as_me:$LINENO: checking for egrep" >&5
5274 echo $ECHO_N "checking for egrep... $ECHO_C" >&6
5275 if test "${ac_cv_prog_egrep+set}" = set; then
5276   echo $ECHO_N "(cached) $ECHO_C" >&6
5277 else
5278   if echo a | (grep -E '(a|b)') >/dev/null 2>&1
5279     then ac_cv_prog_egrep='grep -E'
5280     else ac_cv_prog_egrep='egrep'
5281     fi
5282 fi
5283 echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
5284 echo "${ECHO_T}$ac_cv_prog_egrep" >&6
5285  EGREP=$ac_cv_prog_egrep
5286
5287
5288 echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5289 echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5290 if test "${ac_cv_header_stdc+set}" = set; then
5291   echo $ECHO_N "(cached) $ECHO_C" >&6
5292 else
5293   cat >conftest.$ac_ext <<_ACEOF
5294 /* confdefs.h.  */
5295 _ACEOF
5296 cat confdefs.h >>conftest.$ac_ext
5297 cat >>conftest.$ac_ext <<_ACEOF
5298 /* end confdefs.h.  */
5299 #include <stdlib.h>
5300 #include <stdarg.h>
5301 #include <string.h>
5302 #include <float.h>
5303
5304 int
5305 main ()
5306 {
5307
5308   ;
5309   return 0;
5310 }
5311 _ACEOF
5312 rm -f conftest.$ac_objext
5313 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5314   (eval $ac_compile) 2>conftest.er1
5315   ac_status=$?
5316   grep -v '^ *+' conftest.er1 >conftest.err
5317   rm -f conftest.er1
5318   cat conftest.err >&5
5319   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5320   (exit $ac_status); } &&
5321          { ac_try='test -z "$ac_c_werror_flag"
5322                          || test ! -s conftest.err'
5323   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5324   (eval $ac_try) 2>&5
5325   ac_status=$?
5326   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5327   (exit $ac_status); }; } &&
5328          { ac_try='test -s conftest.$ac_objext'
5329   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5330   (eval $ac_try) 2>&5
5331   ac_status=$?
5332   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5333   (exit $ac_status); }; }; then
5334   ac_cv_header_stdc=yes
5335 else
5336   echo "$as_me: failed program was:" >&5
5337 sed 's/^/| /' conftest.$ac_ext >&5
5338
5339 ac_cv_header_stdc=no
5340 fi
5341 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5342
5343 if test $ac_cv_header_stdc = yes; then
5344   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5345   cat >conftest.$ac_ext <<_ACEOF
5346 /* confdefs.h.  */
5347 _ACEOF
5348 cat confdefs.h >>conftest.$ac_ext
5349 cat >>conftest.$ac_ext <<_ACEOF
5350 /* end confdefs.h.  */
5351 #include <string.h>
5352
5353 _ACEOF
5354 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5355   $EGREP "memchr" >/dev/null 2>&1; then
5356   :
5357 else
5358   ac_cv_header_stdc=no
5359 fi
5360 rm -f conftest*
5361
5362 fi
5363
5364 if test $ac_cv_header_stdc = yes; then
5365   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5366   cat >conftest.$ac_ext <<_ACEOF
5367 /* confdefs.h.  */
5368 _ACEOF
5369 cat confdefs.h >>conftest.$ac_ext
5370 cat >>conftest.$ac_ext <<_ACEOF
5371 /* end confdefs.h.  */
5372 #include <stdlib.h>
5373
5374 _ACEOF
5375 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5376   $EGREP "free" >/dev/null 2>&1; then
5377   :
5378 else
5379   ac_cv_header_stdc=no
5380 fi
5381 rm -f conftest*
5382
5383 fi
5384
5385 if test $ac_cv_header_stdc = yes; then
5386   # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5387   if test "$cross_compiling" = yes; then
5388   :
5389 else
5390   cat >conftest.$ac_ext <<_ACEOF
5391 /* confdefs.h.  */
5392 _ACEOF
5393 cat confdefs.h >>conftest.$ac_ext
5394 cat >>conftest.$ac_ext <<_ACEOF
5395 /* end confdefs.h.  */
5396 #include <ctype.h>
5397 #if ((' ' & 0x0FF) == 0x020)
5398 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5399 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5400 #else
5401 # define ISLOWER(c) \
5402                    (('a' <= (c) && (c) <= 'i') \
5403                      || ('j' <= (c) && (c) <= 'r') \
5404                      || ('s' <= (c) && (c) <= 'z'))
5405 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5406 #endif
5407
5408 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5409 int
5410 main ()
5411 {
5412   int i;
5413   for (i = 0; i < 256; i++)
5414     if (XOR (islower (i), ISLOWER (i))
5415         || toupper (i) != TOUPPER (i))
5416       exit(2);
5417   exit (0);
5418 }
5419 _ACEOF
5420 rm -f conftest$ac_exeext
5421 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5422   (eval $ac_link) 2>&5
5423   ac_status=$?
5424   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5425   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5426   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5427   (eval $ac_try) 2>&5
5428   ac_status=$?
5429   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5430   (exit $ac_status); }; }; then
5431   :
5432 else
5433   echo "$as_me: program exited with status $ac_status" >&5
5434 echo "$as_me: failed program was:" >&5
5435 sed 's/^/| /' conftest.$ac_ext >&5
5436
5437 ( exit $ac_status )
5438 ac_cv_header_stdc=no
5439 fi
5440 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5441 fi
5442 fi
5443 fi
5444 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5445 echo "${ECHO_T}$ac_cv_header_stdc" >&6
5446 if test $ac_cv_header_stdc = yes; then
5447
5448 cat >>confdefs.h <<\_ACEOF
5449 #define STDC_HEADERS 1
5450 _ACEOF
5451
5452 fi
5453
5454 # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5455
5456
5457
5458
5459
5460
5461
5462
5463
5464 for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5465                   inttypes.h stdint.h unistd.h
5466 do
5467 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5468 echo "$as_me:$LINENO: checking for $ac_header" >&5
5469 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5470 if eval "test \"\${$as_ac_Header+set}\" = set"; then
5471   echo $ECHO_N "(cached) $ECHO_C" >&6
5472 else
5473   cat >conftest.$ac_ext <<_ACEOF
5474 /* confdefs.h.  */
5475 _ACEOF
5476 cat confdefs.h >>conftest.$ac_ext
5477 cat >>conftest.$ac_ext <<_ACEOF
5478 /* end confdefs.h.  */
5479 $ac_includes_default
5480
5481 #include <$ac_header>
5482 _ACEOF
5483 rm -f conftest.$ac_objext
5484 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5485   (eval $ac_compile) 2>conftest.er1
5486   ac_status=$?
5487   grep -v '^ *+' conftest.er1 >conftest.err
5488   rm -f conftest.er1
5489   cat conftest.err >&5
5490   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5491   (exit $ac_status); } &&
5492          { ac_try='test -z "$ac_c_werror_flag"
5493                          || test ! -s conftest.err'
5494   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5495   (eval $ac_try) 2>&5
5496   ac_status=$?
5497   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5498   (exit $ac_status); }; } &&
5499          { ac_try='test -s conftest.$ac_objext'
5500   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5501   (eval $ac_try) 2>&5
5502   ac_status=$?
5503   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5504   (exit $ac_status); }; }; then
5505   eval "$as_ac_Header=yes"
5506 else
5507   echo "$as_me: failed program was:" >&5
5508 sed 's/^/| /' conftest.$ac_ext >&5
5509
5510 eval "$as_ac_Header=no"
5511 fi
5512 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5513 fi
5514 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5515 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5516 if test `eval echo '${'$as_ac_Header'}'` = yes; then
5517   cat >>confdefs.h <<_ACEOF
5518 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5519 _ACEOF
5520
5521 fi
5522
5523 done
5524
5525
5526
5527
5528 for ac_header in stdlib.h unistd.h
5529 do
5530 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5531 if eval "test \"\${$as_ac_Header+set}\" = set"; then
5532   echo "$as_me:$LINENO: checking for $ac_header" >&5
5533 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5534 if eval "test \"\${$as_ac_Header+set}\" = set"; then
5535   echo $ECHO_N "(cached) $ECHO_C" >&6
5536 fi
5537 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5538 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5539 else
5540   # Is the header compilable?
5541 echo "$as_me:$LINENO: checking $ac_header usability" >&5
5542 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
5543 cat >conftest.$ac_ext <<_ACEOF
5544 /* confdefs.h.  */
5545 _ACEOF
5546 cat confdefs.h >>conftest.$ac_ext
5547 cat >>conftest.$ac_ext <<_ACEOF
5548 /* end confdefs.h.  */
5549 $ac_includes_default
5550 #include <$ac_header>
5551 _ACEOF
5552 rm -f conftest.$ac_objext
5553 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5554   (eval $ac_compile) 2>conftest.er1
5555   ac_status=$?
5556   grep -v '^ *+' conftest.er1 >conftest.err
5557   rm -f conftest.er1
5558   cat conftest.err >&5
5559   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5560   (exit $ac_status); } &&
5561          { ac_try='test -z "$ac_c_werror_flag"
5562                          || test ! -s conftest.err'
5563   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5564   (eval $ac_try) 2>&5
5565   ac_status=$?
5566   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5567   (exit $ac_status); }; } &&
5568          { ac_try='test -s conftest.$ac_objext'
5569   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5570   (eval $ac_try) 2>&5
5571   ac_status=$?
5572   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5573   (exit $ac_status); }; }; then
5574   ac_header_compiler=yes
5575 else
5576   echo "$as_me: failed program was:" >&5
5577 sed 's/^/| /' conftest.$ac_ext >&5
5578
5579 ac_header_compiler=no
5580 fi
5581 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5582 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5583 echo "${ECHO_T}$ac_header_compiler" >&6
5584
5585 # Is the header present?
5586 echo "$as_me:$LINENO: checking $ac_header presence" >&5
5587 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
5588 cat >conftest.$ac_ext <<_ACEOF
5589 /* confdefs.h.  */
5590 _ACEOF
5591 cat confdefs.h >>conftest.$ac_ext
5592 cat >>conftest.$ac_ext <<_ACEOF
5593 /* end confdefs.h.  */
5594 #include <$ac_header>
5595 _ACEOF
5596 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5597   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5598   ac_status=$?
5599   grep -v '^ *+' conftest.er1 >conftest.err
5600   rm -f conftest.er1
5601   cat conftest.err >&5
5602   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5603   (exit $ac_status); } >/dev/null; then
5604   if test -s conftest.err; then
5605     ac_cpp_err=$ac_c_preproc_warn_flag
5606     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5607   else
5608     ac_cpp_err=
5609   fi
5610 else
5611   ac_cpp_err=yes
5612 fi
5613 if test -z "$ac_cpp_err"; then
5614   ac_header_preproc=yes
5615 else
5616   echo "$as_me: failed program was:" >&5
5617 sed 's/^/| /' conftest.$ac_ext >&5
5618
5619   ac_header_preproc=no
5620 fi
5621 rm -f conftest.err conftest.$ac_ext
5622 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5623 echo "${ECHO_T}$ac_header_preproc" >&6
5624
5625 # So?  What about this header?
5626 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5627   yes:no: )
5628     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
5629 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
5630     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
5631 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
5632     ac_header_preproc=yes
5633     ;;
5634   no:yes:* )
5635     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
5636 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
5637     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
5638 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
5639     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
5640 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
5641     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
5642 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
5643     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
5644 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
5645     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
5646 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
5647     (
5648       cat <<\_ASBOX
5649 ## ------------------------------------------------------ ##
5650 ## Report this to the GNU Fortran Runtime Library lists.  ##
5651 ## ------------------------------------------------------ ##
5652 _ASBOX
5653     ) |
5654       sed "s/^/$as_me: WARNING:     /" >&2
5655     ;;
5656 esac
5657 echo "$as_me:$LINENO: checking for $ac_header" >&5
5658 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5659 if eval "test \"\${$as_ac_Header+set}\" = set"; then
5660   echo $ECHO_N "(cached) $ECHO_C" >&6
5661 else
5662   eval "$as_ac_Header=\$ac_header_preproc"
5663 fi
5664 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5665 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5666
5667 fi
5668 if test `eval echo '${'$as_ac_Header'}'` = yes; then
5669   cat >>confdefs.h <<_ACEOF
5670 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5671 _ACEOF
5672
5673 fi
5674
5675 done
5676
5677
5678 for ac_func in getpagesize
5679 do
5680 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
5681 echo "$as_me:$LINENO: checking for $ac_func" >&5
5682 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
5683 if eval "test \"\${$as_ac_var+set}\" = set"; then
5684   echo $ECHO_N "(cached) $ECHO_C" >&6
5685 else
5686   if test x$gcc_no_link = xyes; then
5687   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
5688 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
5689    { (exit 1); exit 1; }; }
5690 fi
5691 cat >conftest.$ac_ext <<_ACEOF
5692 /* confdefs.h.  */
5693 _ACEOF
5694 cat confdefs.h >>conftest.$ac_ext
5695 cat >>conftest.$ac_ext <<_ACEOF
5696 /* end confdefs.h.  */
5697 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
5698    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
5699 #define $ac_func innocuous_$ac_func
5700
5701 /* System header to define __stub macros and hopefully few prototypes,
5702     which can conflict with char $ac_func (); below.
5703     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5704     <limits.h> exists even on freestanding compilers.  */
5705
5706 #ifdef __STDC__
5707 # include <limits.h>
5708 #else
5709 # include <assert.h>
5710 #endif
5711
5712 #undef $ac_func
5713
5714 /* Override any gcc2 internal prototype to avoid an error.  */
5715 #ifdef __cplusplus
5716 extern "C"
5717 {
5718 #endif
5719 /* We use char because int might match the return type of a gcc2
5720    builtin and then its argument prototype would still apply.  */
5721 char $ac_func ();
5722 /* The GNU C library defines this for functions which it implements
5723     to always fail with ENOSYS.  Some functions are actually named
5724     something starting with __ and the normal name is an alias.  */
5725 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5726 choke me
5727 #else
5728 char (*f) () = $ac_func;
5729 #endif
5730 #ifdef __cplusplus
5731 }
5732 #endif
5733
5734 int
5735 main ()
5736 {
5737 return f != $ac_func;
5738   ;
5739   return 0;
5740 }
5741 _ACEOF
5742 rm -f conftest.$ac_objext conftest$ac_exeext
5743 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5744   (eval $ac_link) 2>conftest.er1
5745   ac_status=$?
5746   grep -v '^ *+' conftest.er1 >conftest.err
5747   rm -f conftest.er1
5748   cat conftest.err >&5
5749   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5750   (exit $ac_status); } &&
5751          { ac_try='test -z "$ac_c_werror_flag"
5752                          || test ! -s conftest.err'
5753   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5754   (eval $ac_try) 2>&5
5755   ac_status=$?
5756   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5757   (exit $ac_status); }; } &&
5758          { ac_try='test -s conftest$ac_exeext'
5759   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5760   (eval $ac_try) 2>&5
5761   ac_status=$?
5762   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5763   (exit $ac_status); }; }; then
5764   eval "$as_ac_var=yes"
5765 else
5766   echo "$as_me: failed program was:" >&5
5767 sed 's/^/| /' conftest.$ac_ext >&5
5768
5769 eval "$as_ac_var=no"
5770 fi
5771 rm -f conftest.err conftest.$ac_objext \
5772       conftest$ac_exeext conftest.$ac_ext
5773 fi
5774 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
5775 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
5776 if test `eval echo '${'$as_ac_var'}'` = yes; then
5777   cat >>confdefs.h <<_ACEOF
5778 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
5779 _ACEOF
5780
5781 fi
5782 done
5783
5784 echo "$as_me:$LINENO: checking for working mmap" >&5
5785 echo $ECHO_N "checking for working mmap... $ECHO_C" >&6
5786 if test "${ac_cv_func_mmap_fixed_mapped+set}" = set; then
5787   echo $ECHO_N "(cached) $ECHO_C" >&6
5788 else
5789   if test "$cross_compiling" = yes; then
5790   ac_cv_func_mmap_fixed_mapped=no
5791 else
5792   cat >conftest.$ac_ext <<_ACEOF
5793 /* confdefs.h.  */
5794 _ACEOF
5795 cat confdefs.h >>conftest.$ac_ext
5796 cat >>conftest.$ac_ext <<_ACEOF
5797 /* end confdefs.h.  */
5798 $ac_includes_default
5799 /* malloc might have been renamed as rpl_malloc. */
5800 #undef malloc
5801
5802 /* Thanks to Mike Haertel and Jim Avera for this test.
5803    Here is a matrix of mmap possibilities:
5804         mmap private not fixed
5805         mmap private fixed at somewhere currently unmapped
5806         mmap private fixed at somewhere already mapped
5807         mmap shared not fixed
5808         mmap shared fixed at somewhere currently unmapped
5809         mmap shared fixed at somewhere already mapped
5810    For private mappings, we should verify that changes cannot be read()
5811    back from the file, nor mmap's back from the file at a different
5812    address.  (There have been systems where private was not correctly
5813    implemented like the infamous i386 svr4.0, and systems where the
5814    VM page cache was not coherent with the file system buffer cache
5815    like early versions of FreeBSD and possibly contemporary NetBSD.)
5816    For shared mappings, we should conversely verify that changes get
5817    propagated back to all the places they're supposed to be.
5818
5819    Grep wants private fixed already mapped.
5820    The main things grep needs to know about mmap are:
5821    * does it exist and is it safe to write into the mmap'd area
5822    * how to use it (BSD variants)  */
5823
5824 #include <fcntl.h>
5825 #include <sys/mman.h>
5826
5827 #if !STDC_HEADERS && !HAVE_STDLIB_H
5828 char *malloc ();
5829 #endif
5830
5831 /* This mess was copied from the GNU getpagesize.h.  */
5832 #if !HAVE_GETPAGESIZE
5833 /* Assume that all systems that can run configure have sys/param.h.  */
5834 # if !HAVE_SYS_PARAM_H
5835 #  define HAVE_SYS_PARAM_H 1
5836 # endif
5837
5838 # ifdef _SC_PAGESIZE
5839 #  define getpagesize() sysconf(_SC_PAGESIZE)
5840 # else /* no _SC_PAGESIZE */
5841 #  if HAVE_SYS_PARAM_H
5842 #   include <sys/param.h>
5843 #   ifdef EXEC_PAGESIZE
5844 #    define getpagesize() EXEC_PAGESIZE
5845 #   else /* no EXEC_PAGESIZE */
5846 #    ifdef NBPG
5847 #     define getpagesize() NBPG * CLSIZE
5848 #     ifndef CLSIZE
5849 #      define CLSIZE 1
5850 #     endif /* no CLSIZE */
5851 #    else /* no NBPG */
5852 #     ifdef NBPC
5853 #      define getpagesize() NBPC
5854 #     else /* no NBPC */
5855 #      ifdef PAGESIZE
5856 #       define getpagesize() PAGESIZE
5857 #      endif /* PAGESIZE */
5858 #     endif /* no NBPC */
5859 #    endif /* no NBPG */
5860 #   endif /* no EXEC_PAGESIZE */
5861 #  else /* no HAVE_SYS_PARAM_H */
5862 #   define getpagesize() 8192   /* punt totally */
5863 #  endif /* no HAVE_SYS_PARAM_H */
5864 # endif /* no _SC_PAGESIZE */
5865
5866 #endif /* no HAVE_GETPAGESIZE */
5867
5868 int
5869 main ()
5870 {
5871   char *data, *data2, *data3;
5872   int i, pagesize;
5873   int fd;
5874
5875   pagesize = getpagesize ();
5876
5877   /* First, make a file with some known garbage in it. */
5878   data = (char *) malloc (pagesize);
5879   if (!data)
5880     exit (1);
5881   for (i = 0; i < pagesize; ++i)
5882     *(data + i) = rand ();
5883   umask (0);
5884   fd = creat ("conftest.mmap", 0600);
5885   if (fd < 0)
5886     exit (1);
5887   if (write (fd, data, pagesize) != pagesize)
5888     exit (1);
5889   close (fd);
5890
5891   /* Next, try to mmap the file at a fixed address which already has
5892      something else allocated at it.  If we can, also make sure that
5893      we see the same garbage.  */
5894   fd = open ("conftest.mmap", O_RDWR);
5895   if (fd < 0)
5896     exit (1);
5897   data2 = (char *) malloc (2 * pagesize);
5898   if (!data2)
5899     exit (1);
5900   data2 += (pagesize - ((long) data2 & (pagesize - 1))) & (pagesize - 1);
5901   if (data2 != mmap (data2, pagesize, PROT_READ | PROT_WRITE,
5902                      MAP_PRIVATE | MAP_FIXED, fd, 0L))
5903     exit (1);
5904   for (i = 0; i < pagesize; ++i)
5905     if (*(data + i) != *(data2 + i))
5906       exit (1);
5907
5908   /* Finally, make sure that changes to the mapped area do not
5909      percolate back to the file as seen by read().  (This is a bug on
5910      some variants of i386 svr4.0.)  */
5911   for (i = 0; i < pagesize; ++i)
5912     *(data2 + i) = *(data2 + i) + 1;
5913   data3 = (char *) malloc (pagesize);
5914   if (!data3)
5915     exit (1);
5916   if (read (fd, data3, pagesize) != pagesize)
5917     exit (1);
5918   for (i = 0; i < pagesize; ++i)
5919     if (*(data + i) != *(data3 + i))
5920       exit (1);
5921   close (fd);
5922   exit (0);
5923 }
5924 _ACEOF
5925 rm -f conftest$ac_exeext
5926 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5927   (eval $ac_link) 2>&5
5928   ac_status=$?
5929   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5930   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5931   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5932   (eval $ac_try) 2>&5
5933   ac_status=$?
5934   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5935   (exit $ac_status); }; }; then
5936   ac_cv_func_mmap_fixed_mapped=yes
5937 else
5938   echo "$as_me: program exited with status $ac_status" >&5
5939 echo "$as_me: failed program was:" >&5
5940 sed 's/^/| /' conftest.$ac_ext >&5
5941
5942 ( exit $ac_status )
5943 ac_cv_func_mmap_fixed_mapped=no
5944 fi
5945 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5946 fi
5947 fi
5948 echo "$as_me:$LINENO: result: $ac_cv_func_mmap_fixed_mapped" >&5
5949 echo "${ECHO_T}$ac_cv_func_mmap_fixed_mapped" >&6
5950 if test $ac_cv_func_mmap_fixed_mapped = yes; then
5951
5952 cat >>confdefs.h <<\_ACEOF
5953 #define HAVE_MMAP 1
5954 _ACEOF
5955
5956 fi
5957 rm -f conftest.mmap
5958
5959 fi
5960 echo "$as_me:$LINENO: checking for off_t" >&5
5961 echo $ECHO_N "checking for off_t... $ECHO_C" >&6
5962 if test "${ac_cv_type_off_t+set}" = set; then
5963   echo $ECHO_N "(cached) $ECHO_C" >&6
5964 else
5965   cat >conftest.$ac_ext <<_ACEOF
5966 /* confdefs.h.  */
5967 _ACEOF
5968 cat confdefs.h >>conftest.$ac_ext
5969 cat >>conftest.$ac_ext <<_ACEOF
5970 /* end confdefs.h.  */
5971 $ac_includes_default
5972 int
5973 main ()
5974 {
5975 if ((off_t *) 0)
5976   return 0;
5977 if (sizeof (off_t))
5978   return 0;
5979   ;
5980   return 0;
5981 }
5982 _ACEOF
5983 rm -f conftest.$ac_objext
5984 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5985   (eval $ac_compile) 2>conftest.er1
5986   ac_status=$?
5987   grep -v '^ *+' conftest.er1 >conftest.err
5988   rm -f conftest.er1
5989   cat conftest.err >&5
5990   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5991   (exit $ac_status); } &&
5992          { ac_try='test -z "$ac_c_werror_flag"
5993                          || test ! -s conftest.err'
5994   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5995   (eval $ac_try) 2>&5
5996   ac_status=$?
5997   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5998   (exit $ac_status); }; } &&
5999          { ac_try='test -s conftest.$ac_objext'
6000   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6001   (eval $ac_try) 2>&5
6002   ac_status=$?
6003   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6004   (exit $ac_status); }; }; then
6005   ac_cv_type_off_t=yes
6006 else
6007   echo "$as_me: failed program was:" >&5
6008 sed 's/^/| /' conftest.$ac_ext >&5
6009
6010 ac_cv_type_off_t=no
6011 fi
6012 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6013 fi
6014 echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5
6015 echo "${ECHO_T}$ac_cv_type_off_t" >&6
6016 if test $ac_cv_type_off_t = yes; then
6017   :
6018 else
6019
6020 cat >>confdefs.h <<_ACEOF
6021 #define off_t long
6022 _ACEOF
6023
6024 fi
6025
6026
6027 # check header files
6028 echo "$as_me:$LINENO: checking for ANSI C header files" >&5
6029 echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
6030 if test "${ac_cv_header_stdc+set}" = set; then
6031   echo $ECHO_N "(cached) $ECHO_C" >&6
6032 else
6033   cat >conftest.$ac_ext <<_ACEOF
6034 /* confdefs.h.  */
6035 _ACEOF
6036 cat confdefs.h >>conftest.$ac_ext
6037 cat >>conftest.$ac_ext <<_ACEOF
6038 /* end confdefs.h.  */
6039 #include <stdlib.h>
6040 #include <stdarg.h>
6041 #include <string.h>
6042 #include <float.h>
6043
6044 int
6045 main ()
6046 {
6047
6048   ;
6049   return 0;
6050 }
6051 _ACEOF
6052 rm -f conftest.$ac_objext
6053 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6054   (eval $ac_compile) 2>conftest.er1
6055   ac_status=$?
6056   grep -v '^ *+' conftest.er1 >conftest.err
6057   rm -f conftest.er1
6058   cat conftest.err >&5
6059   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6060   (exit $ac_status); } &&
6061          { ac_try='test -z "$ac_c_werror_flag"
6062                          || test ! -s conftest.err'
6063   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6064   (eval $ac_try) 2>&5
6065   ac_status=$?
6066   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6067   (exit $ac_status); }; } &&
6068          { ac_try='test -s conftest.$ac_objext'
6069   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6070   (eval $ac_try) 2>&5
6071   ac_status=$?
6072   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6073   (exit $ac_status); }; }; then
6074   ac_cv_header_stdc=yes
6075 else
6076   echo "$as_me: failed program was:" >&5
6077 sed 's/^/| /' conftest.$ac_ext >&5
6078
6079 ac_cv_header_stdc=no
6080 fi
6081 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6082
6083 if test $ac_cv_header_stdc = yes; then
6084   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
6085   cat >conftest.$ac_ext <<_ACEOF
6086 /* confdefs.h.  */
6087 _ACEOF
6088 cat confdefs.h >>conftest.$ac_ext
6089 cat >>conftest.$ac_ext <<_ACEOF
6090 /* end confdefs.h.  */
6091 #include <string.h>
6092
6093 _ACEOF
6094 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6095   $EGREP "memchr" >/dev/null 2>&1; then
6096   :
6097 else
6098   ac_cv_header_stdc=no
6099 fi
6100 rm -f conftest*
6101
6102 fi
6103
6104 if test $ac_cv_header_stdc = yes; then
6105   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
6106   cat >conftest.$ac_ext <<_ACEOF
6107 /* confdefs.h.  */
6108 _ACEOF
6109 cat confdefs.h >>conftest.$ac_ext
6110 cat >>conftest.$ac_ext <<_ACEOF
6111 /* end confdefs.h.  */
6112 #include <stdlib.h>
6113
6114 _ACEOF
6115 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6116   $EGREP "free" >/dev/null 2>&1; then
6117   :
6118 else
6119   ac_cv_header_stdc=no
6120 fi
6121 rm -f conftest*
6122
6123 fi
6124
6125 if test $ac_cv_header_stdc = yes; then
6126   # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
6127   if test "$cross_compiling" = yes; then
6128   :
6129 else
6130   cat >conftest.$ac_ext <<_ACEOF
6131 /* confdefs.h.  */
6132 _ACEOF
6133 cat confdefs.h >>conftest.$ac_ext
6134 cat >>conftest.$ac_ext <<_ACEOF
6135 /* end confdefs.h.  */
6136 #include <ctype.h>
6137 #if ((' ' & 0x0FF) == 0x020)
6138 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
6139 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
6140 #else
6141 # define ISLOWER(c) \
6142                    (('a' <= (c) && (c) <= 'i') \
6143                      || ('j' <= (c) && (c) <= 'r') \
6144                      || ('s' <= (c) && (c) <= 'z'))
6145 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
6146 #endif
6147
6148 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
6149 int
6150 main ()
6151 {
6152   int i;
6153   for (i = 0; i < 256; i++)
6154     if (XOR (islower (i), ISLOWER (i))
6155         || toupper (i) != TOUPPER (i))
6156       exit(2);
6157   exit (0);
6158 }
6159 _ACEOF
6160 rm -f conftest$ac_exeext
6161 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6162   (eval $ac_link) 2>&5
6163   ac_status=$?
6164   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6165   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
6166   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6167   (eval $ac_try) 2>&5
6168   ac_status=$?
6169   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6170   (exit $ac_status); }; }; then
6171   :
6172 else
6173   echo "$as_me: program exited with status $ac_status" >&5
6174 echo "$as_me: failed program was:" >&5
6175 sed 's/^/| /' conftest.$ac_ext >&5
6176
6177 ( exit $ac_status )
6178 ac_cv_header_stdc=no
6179 fi
6180 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
6181 fi
6182 fi
6183 fi
6184 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
6185 echo "${ECHO_T}$ac_cv_header_stdc" >&6
6186 if test $ac_cv_header_stdc = yes; then
6187
6188 cat >>confdefs.h <<\_ACEOF
6189 #define STDC_HEADERS 1
6190 _ACEOF
6191
6192 fi
6193
6194
6195
6196
6197
6198
6199
6200
6201 for ac_header in stdlib.h stdio.h string.h stddef.h math.h unistd.h signal.h
6202 do
6203 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6204 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6205   echo "$as_me:$LINENO: checking for $ac_header" >&5
6206 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6207 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6208   echo $ECHO_N "(cached) $ECHO_C" >&6
6209 fi
6210 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6211 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6212 else
6213   # Is the header compilable?
6214 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6215 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6216 cat >conftest.$ac_ext <<_ACEOF
6217 /* confdefs.h.  */
6218 _ACEOF
6219 cat confdefs.h >>conftest.$ac_ext
6220 cat >>conftest.$ac_ext <<_ACEOF
6221 /* end confdefs.h.  */
6222 $ac_includes_default
6223 #include <$ac_header>
6224 _ACEOF
6225 rm -f conftest.$ac_objext
6226 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6227   (eval $ac_compile) 2>conftest.er1
6228   ac_status=$?
6229   grep -v '^ *+' conftest.er1 >conftest.err
6230   rm -f conftest.er1
6231   cat conftest.err >&5
6232   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6233   (exit $ac_status); } &&
6234          { ac_try='test -z "$ac_c_werror_flag"
6235                          || test ! -s conftest.err'
6236   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6237   (eval $ac_try) 2>&5
6238   ac_status=$?
6239   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6240   (exit $ac_status); }; } &&
6241          { ac_try='test -s conftest.$ac_objext'
6242   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6243   (eval $ac_try) 2>&5
6244   ac_status=$?
6245   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6246   (exit $ac_status); }; }; then
6247   ac_header_compiler=yes
6248 else
6249   echo "$as_me: failed program was:" >&5
6250 sed 's/^/| /' conftest.$ac_ext >&5
6251
6252 ac_header_compiler=no
6253 fi
6254 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6255 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6256 echo "${ECHO_T}$ac_header_compiler" >&6
6257
6258 # Is the header present?
6259 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6260 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6261 cat >conftest.$ac_ext <<_ACEOF
6262 /* confdefs.h.  */
6263 _ACEOF
6264 cat confdefs.h >>conftest.$ac_ext
6265 cat >>conftest.$ac_ext <<_ACEOF
6266 /* end confdefs.h.  */
6267 #include <$ac_header>
6268 _ACEOF
6269 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6270   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6271   ac_status=$?
6272   grep -v '^ *+' conftest.er1 >conftest.err
6273   rm -f conftest.er1
6274   cat conftest.err >&5
6275   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6276   (exit $ac_status); } >/dev/null; then
6277   if test -s conftest.err; then
6278     ac_cpp_err=$ac_c_preproc_warn_flag
6279     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6280   else
6281     ac_cpp_err=
6282   fi
6283 else
6284   ac_cpp_err=yes
6285 fi
6286 if test -z "$ac_cpp_err"; then
6287   ac_header_preproc=yes
6288 else
6289   echo "$as_me: failed program was:" >&5
6290 sed 's/^/| /' conftest.$ac_ext >&5
6291
6292   ac_header_preproc=no
6293 fi
6294 rm -f conftest.err conftest.$ac_ext
6295 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6296 echo "${ECHO_T}$ac_header_preproc" >&6
6297
6298 # So?  What about this header?
6299 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6300   yes:no: )
6301     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6302 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6303     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6304 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6305     ac_header_preproc=yes
6306     ;;
6307   no:yes:* )
6308     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6309 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6310     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6311 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6312     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6313 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6314     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6315 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6316     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6317 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6318     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6319 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6320     (
6321       cat <<\_ASBOX
6322 ## ------------------------------------------------------ ##
6323 ## Report this to the GNU Fortran Runtime Library lists.  ##
6324 ## ------------------------------------------------------ ##
6325 _ASBOX
6326     ) |
6327       sed "s/^/$as_me: WARNING:     /" >&2
6328     ;;
6329 esac
6330 echo "$as_me:$LINENO: checking for $ac_header" >&5
6331 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6332 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6333   echo $ECHO_N "(cached) $ECHO_C" >&6
6334 else
6335   eval "$as_ac_Header=\$ac_header_preproc"
6336 fi
6337 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6338 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6339
6340 fi
6341 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6342   cat >>confdefs.h <<_ACEOF
6343 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6344 _ACEOF
6345
6346 fi
6347
6348 done
6349
6350
6351
6352
6353
6354
6355 for ac_header in time.h sys/params.h sys/time.h sys/times.h sys/resource.h
6356 do
6357 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6358 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6359   echo "$as_me:$LINENO: checking for $ac_header" >&5
6360 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6361 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6362   echo $ECHO_N "(cached) $ECHO_C" >&6
6363 fi
6364 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6365 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6366 else
6367   # Is the header compilable?
6368 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6369 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6370 cat >conftest.$ac_ext <<_ACEOF
6371 /* confdefs.h.  */
6372 _ACEOF
6373 cat confdefs.h >>conftest.$ac_ext
6374 cat >>conftest.$ac_ext <<_ACEOF
6375 /* end confdefs.h.  */
6376 $ac_includes_default
6377 #include <$ac_header>
6378 _ACEOF
6379 rm -f conftest.$ac_objext
6380 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6381   (eval $ac_compile) 2>conftest.er1
6382   ac_status=$?
6383   grep -v '^ *+' conftest.er1 >conftest.err
6384   rm -f conftest.er1
6385   cat conftest.err >&5
6386   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6387   (exit $ac_status); } &&
6388          { ac_try='test -z "$ac_c_werror_flag"
6389                          || test ! -s conftest.err'
6390   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6391   (eval $ac_try) 2>&5
6392   ac_status=$?
6393   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6394   (exit $ac_status); }; } &&
6395          { ac_try='test -s conftest.$ac_objext'
6396   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6397   (eval $ac_try) 2>&5
6398   ac_status=$?
6399   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6400   (exit $ac_status); }; }; then
6401   ac_header_compiler=yes
6402 else
6403   echo "$as_me: failed program was:" >&5
6404 sed 's/^/| /' conftest.$ac_ext >&5
6405
6406 ac_header_compiler=no
6407 fi
6408 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6409 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6410 echo "${ECHO_T}$ac_header_compiler" >&6
6411
6412 # Is the header present?
6413 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6414 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6415 cat >conftest.$ac_ext <<_ACEOF
6416 /* confdefs.h.  */
6417 _ACEOF
6418 cat confdefs.h >>conftest.$ac_ext
6419 cat >>conftest.$ac_ext <<_ACEOF
6420 /* end confdefs.h.  */
6421 #include <$ac_header>
6422 _ACEOF
6423 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6424   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6425   ac_status=$?
6426   grep -v '^ *+' conftest.er1 >conftest.err
6427   rm -f conftest.er1
6428   cat conftest.err >&5
6429   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6430   (exit $ac_status); } >/dev/null; then
6431   if test -s conftest.err; then
6432     ac_cpp_err=$ac_c_preproc_warn_flag
6433     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6434   else
6435     ac_cpp_err=
6436   fi
6437 else
6438   ac_cpp_err=yes
6439 fi
6440 if test -z "$ac_cpp_err"; then
6441   ac_header_preproc=yes
6442 else
6443   echo "$as_me: failed program was:" >&5
6444 sed 's/^/| /' conftest.$ac_ext >&5
6445
6446   ac_header_preproc=no
6447 fi
6448 rm -f conftest.err conftest.$ac_ext
6449 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6450 echo "${ECHO_T}$ac_header_preproc" >&6
6451
6452 # So?  What about this header?
6453 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6454   yes:no: )
6455     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6456 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6457     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6458 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6459     ac_header_preproc=yes
6460     ;;
6461   no:yes:* )
6462     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6463 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6464     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6465 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6466     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6467 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6468     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6469 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6470     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6471 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6472     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6473 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6474     (
6475       cat <<\_ASBOX
6476 ## ------------------------------------------------------ ##
6477 ## Report this to the GNU Fortran Runtime Library lists.  ##
6478 ## ------------------------------------------------------ ##
6479 _ASBOX
6480     ) |
6481       sed "s/^/$as_me: WARNING:     /" >&2
6482     ;;
6483 esac
6484 echo "$as_me:$LINENO: checking for $ac_header" >&5
6485 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6486 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6487   echo $ECHO_N "(cached) $ECHO_C" >&6
6488 else
6489   eval "$as_ac_Header=\$ac_header_preproc"
6490 fi
6491 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6492 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6493
6494 fi
6495 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6496   cat >>confdefs.h <<_ACEOF
6497 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6498 _ACEOF
6499
6500 fi
6501
6502 done
6503
6504
6505
6506
6507
6508
6509 for ac_header in sys/mman.h sys/types.h sys/stat.h floatingpoint.h ieeefp.h
6510 do
6511 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6512 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6513   echo "$as_me:$LINENO: checking for $ac_header" >&5
6514 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6515 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6516   echo $ECHO_N "(cached) $ECHO_C" >&6
6517 fi
6518 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6519 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6520 else
6521   # Is the header compilable?
6522 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6523 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6524 cat >conftest.$ac_ext <<_ACEOF
6525 /* confdefs.h.  */
6526 _ACEOF
6527 cat confdefs.h >>conftest.$ac_ext
6528 cat >>conftest.$ac_ext <<_ACEOF
6529 /* end confdefs.h.  */
6530 $ac_includes_default
6531 #include <$ac_header>
6532 _ACEOF
6533 rm -f conftest.$ac_objext
6534 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6535   (eval $ac_compile) 2>conftest.er1
6536   ac_status=$?
6537   grep -v '^ *+' conftest.er1 >conftest.err
6538   rm -f conftest.er1
6539   cat conftest.err >&5
6540   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6541   (exit $ac_status); } &&
6542          { ac_try='test -z "$ac_c_werror_flag"
6543                          || test ! -s conftest.err'
6544   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6545   (eval $ac_try) 2>&5
6546   ac_status=$?
6547   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6548   (exit $ac_status); }; } &&
6549          { ac_try='test -s conftest.$ac_objext'
6550   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6551   (eval $ac_try) 2>&5
6552   ac_status=$?
6553   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6554   (exit $ac_status); }; }; then
6555   ac_header_compiler=yes
6556 else
6557   echo "$as_me: failed program was:" >&5
6558 sed 's/^/| /' conftest.$ac_ext >&5
6559
6560 ac_header_compiler=no
6561 fi
6562 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6563 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6564 echo "${ECHO_T}$ac_header_compiler" >&6
6565
6566 # Is the header present?
6567 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6568 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6569 cat >conftest.$ac_ext <<_ACEOF
6570 /* confdefs.h.  */
6571 _ACEOF
6572 cat confdefs.h >>conftest.$ac_ext
6573 cat >>conftest.$ac_ext <<_ACEOF
6574 /* end confdefs.h.  */
6575 #include <$ac_header>
6576 _ACEOF
6577 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6578   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6579   ac_status=$?
6580   grep -v '^ *+' conftest.er1 >conftest.err
6581   rm -f conftest.er1
6582   cat conftest.err >&5
6583   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6584   (exit $ac_status); } >/dev/null; then
6585   if test -s conftest.err; then
6586     ac_cpp_err=$ac_c_preproc_warn_flag
6587     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6588   else
6589     ac_cpp_err=
6590   fi
6591 else
6592   ac_cpp_err=yes
6593 fi
6594 if test -z "$ac_cpp_err"; then
6595   ac_header_preproc=yes
6596 else
6597   echo "$as_me: failed program was:" >&5
6598 sed 's/^/| /' conftest.$ac_ext >&5
6599
6600   ac_header_preproc=no
6601 fi
6602 rm -f conftest.err conftest.$ac_ext
6603 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6604 echo "${ECHO_T}$ac_header_preproc" >&6
6605
6606 # So?  What about this header?
6607 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6608   yes:no: )
6609     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6610 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6611     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6612 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6613     ac_header_preproc=yes
6614     ;;
6615   no:yes:* )
6616     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6617 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6618     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6619 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6620     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6621 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6622     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6623 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6624     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6625 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6626     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6627 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6628     (
6629       cat <<\_ASBOX
6630 ## ------------------------------------------------------ ##
6631 ## Report this to the GNU Fortran Runtime Library lists.  ##
6632 ## ------------------------------------------------------ ##
6633 _ASBOX
6634     ) |
6635       sed "s/^/$as_me: WARNING:     /" >&2
6636     ;;
6637 esac
6638 echo "$as_me:$LINENO: checking for $ac_header" >&5
6639 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6640 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6641   echo $ECHO_N "(cached) $ECHO_C" >&6
6642 else
6643   eval "$as_ac_Header=\$ac_header_preproc"
6644 fi
6645 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6646 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6647
6648 fi
6649 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6650   cat >>confdefs.h <<_ACEOF
6651 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6652 _ACEOF
6653
6654 fi
6655
6656 done
6657
6658
6659
6660
6661 for ac_header in fenv.h fptrap.h float.h
6662 do
6663 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6664 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6665   echo "$as_me:$LINENO: checking for $ac_header" >&5
6666 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6667 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6668   echo $ECHO_N "(cached) $ECHO_C" >&6
6669 fi
6670 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6671 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6672 else
6673   # Is the header compilable?
6674 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6675 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6676 cat >conftest.$ac_ext <<_ACEOF
6677 /* confdefs.h.  */
6678 _ACEOF
6679 cat confdefs.h >>conftest.$ac_ext
6680 cat >>conftest.$ac_ext <<_ACEOF
6681 /* end confdefs.h.  */
6682 $ac_includes_default
6683 #include <$ac_header>
6684 _ACEOF
6685 rm -f conftest.$ac_objext
6686 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6687   (eval $ac_compile) 2>conftest.er1
6688   ac_status=$?
6689   grep -v '^ *+' conftest.er1 >conftest.err
6690   rm -f conftest.er1
6691   cat conftest.err >&5
6692   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6693   (exit $ac_status); } &&
6694          { ac_try='test -z "$ac_c_werror_flag"
6695                          || test ! -s conftest.err'
6696   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6697   (eval $ac_try) 2>&5
6698   ac_status=$?
6699   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6700   (exit $ac_status); }; } &&
6701          { ac_try='test -s conftest.$ac_objext'
6702   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6703   (eval $ac_try) 2>&5
6704   ac_status=$?
6705   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6706   (exit $ac_status); }; }; then
6707   ac_header_compiler=yes
6708 else
6709   echo "$as_me: failed program was:" >&5
6710 sed 's/^/| /' conftest.$ac_ext >&5
6711
6712 ac_header_compiler=no
6713 fi
6714 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6715 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6716 echo "${ECHO_T}$ac_header_compiler" >&6
6717
6718 # Is the header present?
6719 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6720 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6721 cat >conftest.$ac_ext <<_ACEOF
6722 /* confdefs.h.  */
6723 _ACEOF
6724 cat confdefs.h >>conftest.$ac_ext
6725 cat >>conftest.$ac_ext <<_ACEOF
6726 /* end confdefs.h.  */
6727 #include <$ac_header>
6728 _ACEOF
6729 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6730   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6731   ac_status=$?
6732   grep -v '^ *+' conftest.er1 >conftest.err
6733   rm -f conftest.er1
6734   cat conftest.err >&5
6735   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6736   (exit $ac_status); } >/dev/null; then
6737   if test -s conftest.err; then
6738     ac_cpp_err=$ac_c_preproc_warn_flag
6739     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6740   else
6741     ac_cpp_err=
6742   fi
6743 else
6744   ac_cpp_err=yes
6745 fi
6746 if test -z "$ac_cpp_err"; then
6747   ac_header_preproc=yes
6748 else
6749   echo "$as_me: failed program was:" >&5
6750 sed 's/^/| /' conftest.$ac_ext >&5
6751
6752   ac_header_preproc=no
6753 fi
6754 rm -f conftest.err conftest.$ac_ext
6755 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6756 echo "${ECHO_T}$ac_header_preproc" >&6
6757
6758 # So?  What about this header?
6759 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6760   yes:no: )
6761     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6762 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6763     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6764 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6765     ac_header_preproc=yes
6766     ;;
6767   no:yes:* )
6768     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6769 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6770     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6771 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6772     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6773 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6774     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6775 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6776     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6777 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6778     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6779 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6780     (
6781       cat <<\_ASBOX
6782 ## ------------------------------------------------------ ##
6783 ## Report this to the GNU Fortran Runtime Library lists.  ##
6784 ## ------------------------------------------------------ ##
6785 _ASBOX
6786     ) |
6787       sed "s/^/$as_me: WARNING:     /" >&2
6788     ;;
6789 esac
6790 echo "$as_me:$LINENO: checking for $ac_header" >&5
6791 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6792 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6793   echo $ECHO_N "(cached) $ECHO_C" >&6
6794 else
6795   eval "$as_ac_Header=\$ac_header_preproc"
6796 fi
6797 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6798 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6799
6800 fi
6801 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6802   cat >>confdefs.h <<_ACEOF
6803 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6804 _ACEOF
6805
6806 fi
6807
6808 done
6809
6810 if test "${ac_cv_header_complex_h+set}" = set; then
6811   echo "$as_me:$LINENO: checking for complex.h" >&5
6812 echo $ECHO_N "checking for complex.h... $ECHO_C" >&6
6813 if test "${ac_cv_header_complex_h+set}" = set; then
6814   echo $ECHO_N "(cached) $ECHO_C" >&6
6815 fi
6816 echo "$as_me:$LINENO: result: $ac_cv_header_complex_h" >&5
6817 echo "${ECHO_T}$ac_cv_header_complex_h" >&6
6818 else
6819   # Is the header compilable?
6820 echo "$as_me:$LINENO: checking complex.h usability" >&5
6821 echo $ECHO_N "checking complex.h usability... $ECHO_C" >&6
6822 cat >conftest.$ac_ext <<_ACEOF
6823 /* confdefs.h.  */
6824 _ACEOF
6825 cat confdefs.h >>conftest.$ac_ext
6826 cat >>conftest.$ac_ext <<_ACEOF
6827 /* end confdefs.h.  */
6828 $ac_includes_default
6829 #include <complex.h>
6830 _ACEOF
6831 rm -f conftest.$ac_objext
6832 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6833   (eval $ac_compile) 2>conftest.er1
6834   ac_status=$?
6835   grep -v '^ *+' conftest.er1 >conftest.err
6836   rm -f conftest.er1
6837   cat conftest.err >&5
6838   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6839   (exit $ac_status); } &&
6840          { ac_try='test -z "$ac_c_werror_flag"
6841                          || test ! -s conftest.err'
6842   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6843   (eval $ac_try) 2>&5
6844   ac_status=$?
6845   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6846   (exit $ac_status); }; } &&
6847          { ac_try='test -s conftest.$ac_objext'
6848   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6849   (eval $ac_try) 2>&5
6850   ac_status=$?
6851   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6852   (exit $ac_status); }; }; then
6853   ac_header_compiler=yes
6854 else
6855   echo "$as_me: failed program was:" >&5
6856 sed 's/^/| /' conftest.$ac_ext >&5
6857
6858 ac_header_compiler=no
6859 fi
6860 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6861 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6862 echo "${ECHO_T}$ac_header_compiler" >&6
6863
6864 # Is the header present?
6865 echo "$as_me:$LINENO: checking complex.h presence" >&5
6866 echo $ECHO_N "checking complex.h presence... $ECHO_C" >&6
6867 cat >conftest.$ac_ext <<_ACEOF
6868 /* confdefs.h.  */
6869 _ACEOF
6870 cat confdefs.h >>conftest.$ac_ext
6871 cat >>conftest.$ac_ext <<_ACEOF
6872 /* end confdefs.h.  */
6873 #include <complex.h>
6874 _ACEOF
6875 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6876   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6877   ac_status=$?
6878   grep -v '^ *+' conftest.er1 >conftest.err
6879   rm -f conftest.er1
6880   cat conftest.err >&5
6881   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6882   (exit $ac_status); } >/dev/null; then
6883   if test -s conftest.err; then
6884     ac_cpp_err=$ac_c_preproc_warn_flag
6885     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6886   else
6887     ac_cpp_err=
6888   fi
6889 else
6890   ac_cpp_err=yes
6891 fi
6892 if test -z "$ac_cpp_err"; then
6893   ac_header_preproc=yes
6894 else
6895   echo "$as_me: failed program was:" >&5
6896 sed 's/^/| /' conftest.$ac_ext >&5
6897
6898   ac_header_preproc=no
6899 fi
6900 rm -f conftest.err conftest.$ac_ext
6901 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6902 echo "${ECHO_T}$ac_header_preproc" >&6
6903
6904 # So?  What about this header?
6905 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6906   yes:no: )
6907     { echo "$as_me:$LINENO: WARNING: complex.h: accepted by the compiler, rejected by the preprocessor!" >&5
6908 echo "$as_me: WARNING: complex.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6909     { echo "$as_me:$LINENO: WARNING: complex.h: proceeding with the compiler's result" >&5
6910 echo "$as_me: WARNING: complex.h: proceeding with the compiler's result" >&2;}
6911     ac_header_preproc=yes
6912     ;;
6913   no:yes:* )
6914     { echo "$as_me:$LINENO: WARNING: complex.h: present but cannot be compiled" >&5
6915 echo "$as_me: WARNING: complex.h: present but cannot be compiled" >&2;}
6916     { echo "$as_me:$LINENO: WARNING: complex.h:     check for missing prerequisite headers?" >&5
6917 echo "$as_me: WARNING: complex.h:     check for missing prerequisite headers?" >&2;}
6918     { echo "$as_me:$LINENO: WARNING: complex.h: see the Autoconf documentation" >&5
6919 echo "$as_me: WARNING: complex.h: see the Autoconf documentation" >&2;}
6920     { echo "$as_me:$LINENO: WARNING: complex.h:     section \"Present But Cannot Be Compiled\"" >&5
6921 echo "$as_me: WARNING: complex.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6922     { echo "$as_me:$LINENO: WARNING: complex.h: proceeding with the preprocessor's result" >&5
6923 echo "$as_me: WARNING: complex.h: proceeding with the preprocessor's result" >&2;}
6924     { echo "$as_me:$LINENO: WARNING: complex.h: in the future, the compiler will take precedence" >&5
6925 echo "$as_me: WARNING: complex.h: in the future, the compiler will take precedence" >&2;}
6926     (
6927       cat <<\_ASBOX
6928 ## ------------------------------------------------------ ##
6929 ## Report this to the GNU Fortran Runtime Library lists.  ##
6930 ## ------------------------------------------------------ ##
6931 _ASBOX
6932     ) |
6933       sed "s/^/$as_me: WARNING:     /" >&2
6934     ;;
6935 esac
6936 echo "$as_me:$LINENO: checking for complex.h" >&5
6937 echo $ECHO_N "checking for complex.h... $ECHO_C" >&6
6938 if test "${ac_cv_header_complex_h+set}" = set; then
6939   echo $ECHO_N "(cached) $ECHO_C" >&6
6940 else
6941   ac_cv_header_complex_h=$ac_header_preproc
6942 fi
6943 echo "$as_me:$LINENO: result: $ac_cv_header_complex_h" >&5
6944 echo "${ECHO_T}$ac_cv_header_complex_h" >&6
6945
6946 fi
6947 if test $ac_cv_header_complex_h = yes; then
6948
6949 cat >>confdefs.h <<\_ACEOF
6950 #define HAVE_COMPLEX_H 1
6951 _ACEOF
6952
6953 fi
6954
6955
6956
6957 echo "$as_me:$LINENO: checking for struct stat.st_blksize" >&5
6958 echo $ECHO_N "checking for struct stat.st_blksize... $ECHO_C" >&6
6959 if test "${ac_cv_member_struct_stat_st_blksize+set}" = set; then
6960   echo $ECHO_N "(cached) $ECHO_C" >&6
6961 else
6962   cat >conftest.$ac_ext <<_ACEOF
6963 /* confdefs.h.  */
6964 _ACEOF
6965 cat confdefs.h >>conftest.$ac_ext
6966 cat >>conftest.$ac_ext <<_ACEOF
6967 /* end confdefs.h.  */
6968 $ac_includes_default
6969 int
6970 main ()
6971 {
6972 static struct stat ac_aggr;
6973 if (ac_aggr.st_blksize)
6974 return 0;
6975   ;
6976   return 0;
6977 }
6978 _ACEOF
6979 rm -f conftest.$ac_objext
6980 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6981   (eval $ac_compile) 2>conftest.er1
6982   ac_status=$?
6983   grep -v '^ *+' conftest.er1 >conftest.err
6984   rm -f conftest.er1
6985   cat conftest.err >&5
6986   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6987   (exit $ac_status); } &&
6988          { ac_try='test -z "$ac_c_werror_flag"
6989                          || test ! -s conftest.err'
6990   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6991   (eval $ac_try) 2>&5
6992   ac_status=$?
6993   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6994   (exit $ac_status); }; } &&
6995          { ac_try='test -s conftest.$ac_objext'
6996   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6997   (eval $ac_try) 2>&5
6998   ac_status=$?
6999   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7000   (exit $ac_status); }; }; then
7001   ac_cv_member_struct_stat_st_blksize=yes
7002 else
7003   echo "$as_me: failed program was:" >&5
7004 sed 's/^/| /' conftest.$ac_ext >&5
7005
7006 cat >conftest.$ac_ext <<_ACEOF
7007 /* confdefs.h.  */
7008 _ACEOF
7009 cat confdefs.h >>conftest.$ac_ext
7010 cat >>conftest.$ac_ext <<_ACEOF
7011 /* end confdefs.h.  */
7012 $ac_includes_default
7013 int
7014 main ()
7015 {
7016 static struct stat ac_aggr;
7017 if (sizeof ac_aggr.st_blksize)
7018 return 0;
7019   ;
7020   return 0;
7021 }
7022 _ACEOF
7023 rm -f conftest.$ac_objext
7024 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7025   (eval $ac_compile) 2>conftest.er1
7026   ac_status=$?
7027   grep -v '^ *+' conftest.er1 >conftest.err
7028   rm -f conftest.er1
7029   cat conftest.err >&5
7030   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7031   (exit $ac_status); } &&
7032          { ac_try='test -z "$ac_c_werror_flag"
7033                          || test ! -s conftest.err'
7034   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7035   (eval $ac_try) 2>&5
7036   ac_status=$?
7037   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7038   (exit $ac_status); }; } &&
7039          { ac_try='test -s conftest.$ac_objext'
7040   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7041   (eval $ac_try) 2>&5
7042   ac_status=$?
7043   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7044   (exit $ac_status); }; }; then
7045   ac_cv_member_struct_stat_st_blksize=yes
7046 else
7047   echo "$as_me: failed program was:" >&5
7048 sed 's/^/| /' conftest.$ac_ext >&5
7049
7050 ac_cv_member_struct_stat_st_blksize=no
7051 fi
7052 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7053 fi
7054 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7055 fi
7056 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blksize" >&5
7057 echo "${ECHO_T}$ac_cv_member_struct_stat_st_blksize" >&6
7058 if test $ac_cv_member_struct_stat_st_blksize = yes; then
7059
7060 cat >>confdefs.h <<_ACEOF
7061 #define HAVE_STRUCT_STAT_ST_BLKSIZE 1
7062 _ACEOF
7063
7064
7065 fi
7066
7067 echo "$as_me:$LINENO: checking for struct stat.st_blocks" >&5
7068 echo $ECHO_N "checking for struct stat.st_blocks... $ECHO_C" >&6
7069 if test "${ac_cv_member_struct_stat_st_blocks+set}" = set; then
7070   echo $ECHO_N "(cached) $ECHO_C" >&6
7071 else
7072   cat >conftest.$ac_ext <<_ACEOF
7073 /* confdefs.h.  */
7074 _ACEOF
7075 cat confdefs.h >>conftest.$ac_ext
7076 cat >>conftest.$ac_ext <<_ACEOF
7077 /* end confdefs.h.  */
7078 $ac_includes_default
7079 int
7080 main ()
7081 {
7082 static struct stat ac_aggr;
7083 if (ac_aggr.st_blocks)
7084 return 0;
7085   ;
7086   return 0;
7087 }
7088 _ACEOF
7089 rm -f conftest.$ac_objext
7090 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7091   (eval $ac_compile) 2>conftest.er1
7092   ac_status=$?
7093   grep -v '^ *+' conftest.er1 >conftest.err
7094   rm -f conftest.er1
7095   cat conftest.err >&5
7096   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7097   (exit $ac_status); } &&
7098          { ac_try='test -z "$ac_c_werror_flag"
7099                          || test ! -s conftest.err'
7100   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7101   (eval $ac_try) 2>&5
7102   ac_status=$?
7103   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7104   (exit $ac_status); }; } &&
7105          { ac_try='test -s conftest.$ac_objext'
7106   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7107   (eval $ac_try) 2>&5
7108   ac_status=$?
7109   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7110   (exit $ac_status); }; }; then
7111   ac_cv_member_struct_stat_st_blocks=yes
7112 else
7113   echo "$as_me: failed program was:" >&5
7114 sed 's/^/| /' conftest.$ac_ext >&5
7115
7116 cat >conftest.$ac_ext <<_ACEOF
7117 /* confdefs.h.  */
7118 _ACEOF
7119 cat confdefs.h >>conftest.$ac_ext
7120 cat >>conftest.$ac_ext <<_ACEOF
7121 /* end confdefs.h.  */
7122 $ac_includes_default
7123 int
7124 main ()
7125 {
7126 static struct stat ac_aggr;
7127 if (sizeof ac_aggr.st_blocks)
7128 return 0;
7129   ;
7130   return 0;
7131 }
7132 _ACEOF
7133 rm -f conftest.$ac_objext
7134 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7135   (eval $ac_compile) 2>conftest.er1
7136   ac_status=$?
7137   grep -v '^ *+' conftest.er1 >conftest.err
7138   rm -f conftest.er1
7139   cat conftest.err >&5
7140   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7141   (exit $ac_status); } &&
7142          { ac_try='test -z "$ac_c_werror_flag"
7143                          || test ! -s conftest.err'
7144   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7145   (eval $ac_try) 2>&5
7146   ac_status=$?
7147   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7148   (exit $ac_status); }; } &&
7149          { ac_try='test -s conftest.$ac_objext'
7150   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7151   (eval $ac_try) 2>&5
7152   ac_status=$?
7153   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7154   (exit $ac_status); }; }; then
7155   ac_cv_member_struct_stat_st_blocks=yes
7156 else
7157   echo "$as_me: failed program was:" >&5
7158 sed 's/^/| /' conftest.$ac_ext >&5
7159
7160 ac_cv_member_struct_stat_st_blocks=no
7161 fi
7162 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7163 fi
7164 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7165 fi
7166 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blocks" >&5
7167 echo "${ECHO_T}$ac_cv_member_struct_stat_st_blocks" >&6
7168 if test $ac_cv_member_struct_stat_st_blocks = yes; then
7169
7170 cat >>confdefs.h <<_ACEOF
7171 #define HAVE_STRUCT_STAT_ST_BLOCKS 1
7172 _ACEOF
7173
7174
7175 fi
7176
7177 echo "$as_me:$LINENO: checking for struct stat.st_rdev" >&5
7178 echo $ECHO_N "checking for struct stat.st_rdev... $ECHO_C" >&6
7179 if test "${ac_cv_member_struct_stat_st_rdev+set}" = set; then
7180   echo $ECHO_N "(cached) $ECHO_C" >&6
7181 else
7182   cat >conftest.$ac_ext <<_ACEOF
7183 /* confdefs.h.  */
7184 _ACEOF
7185 cat confdefs.h >>conftest.$ac_ext
7186 cat >>conftest.$ac_ext <<_ACEOF
7187 /* end confdefs.h.  */
7188 $ac_includes_default
7189 int
7190 main ()
7191 {
7192 static struct stat ac_aggr;
7193 if (ac_aggr.st_rdev)
7194 return 0;
7195   ;
7196   return 0;
7197 }
7198 _ACEOF
7199 rm -f conftest.$ac_objext
7200 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7201   (eval $ac_compile) 2>conftest.er1
7202   ac_status=$?
7203   grep -v '^ *+' conftest.er1 >conftest.err
7204   rm -f conftest.er1
7205   cat conftest.err >&5
7206   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7207   (exit $ac_status); } &&
7208          { ac_try='test -z "$ac_c_werror_flag"
7209                          || test ! -s conftest.err'
7210   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7211   (eval $ac_try) 2>&5
7212   ac_status=$?
7213   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7214   (exit $ac_status); }; } &&
7215          { ac_try='test -s conftest.$ac_objext'
7216   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7217   (eval $ac_try) 2>&5
7218   ac_status=$?
7219   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7220   (exit $ac_status); }; }; then
7221   ac_cv_member_struct_stat_st_rdev=yes
7222 else
7223   echo "$as_me: failed program was:" >&5
7224 sed 's/^/| /' conftest.$ac_ext >&5
7225
7226 cat >conftest.$ac_ext <<_ACEOF
7227 /* confdefs.h.  */
7228 _ACEOF
7229 cat confdefs.h >>conftest.$ac_ext
7230 cat >>conftest.$ac_ext <<_ACEOF
7231 /* end confdefs.h.  */
7232 $ac_includes_default
7233 int
7234 main ()
7235 {
7236 static struct stat ac_aggr;
7237 if (sizeof ac_aggr.st_rdev)
7238 return 0;
7239   ;
7240   return 0;
7241 }
7242 _ACEOF
7243 rm -f conftest.$ac_objext
7244 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7245   (eval $ac_compile) 2>conftest.er1
7246   ac_status=$?
7247   grep -v '^ *+' conftest.er1 >conftest.err
7248   rm -f conftest.er1
7249   cat conftest.err >&5
7250   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7251   (exit $ac_status); } &&
7252          { ac_try='test -z "$ac_c_werror_flag"
7253                          || test ! -s conftest.err'
7254   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7255   (eval $ac_try) 2>&5
7256   ac_status=$?
7257   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7258   (exit $ac_status); }; } &&
7259          { ac_try='test -s conftest.$ac_objext'
7260   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7261   (eval $ac_try) 2>&5
7262   ac_status=$?
7263   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7264   (exit $ac_status); }; }; then
7265   ac_cv_member_struct_stat_st_rdev=yes
7266 else
7267   echo "$as_me: failed program was:" >&5
7268 sed 's/^/| /' conftest.$ac_ext >&5
7269
7270 ac_cv_member_struct_stat_st_rdev=no
7271 fi
7272 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7273 fi
7274 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7275 fi
7276 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_rdev" >&5
7277 echo "${ECHO_T}$ac_cv_member_struct_stat_st_rdev" >&6
7278 if test $ac_cv_member_struct_stat_st_rdev = yes; then
7279
7280 cat >>confdefs.h <<_ACEOF
7281 #define HAVE_STRUCT_STAT_ST_RDEV 1
7282 _ACEOF
7283
7284
7285 fi
7286
7287
7288 # Check for library functions.
7289
7290
7291
7292
7293
7294
7295
7296
7297 for ac_func in getrusage times mkstemp strtof strtold snprintf ftruncate chsize
7298 do
7299 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7300 echo "$as_me:$LINENO: checking for $ac_func" >&5
7301 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7302 if eval "test \"\${$as_ac_var+set}\" = set"; then
7303   echo $ECHO_N "(cached) $ECHO_C" >&6
7304 else
7305   if test x$gcc_no_link = xyes; then
7306   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7307 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7308    { (exit 1); exit 1; }; }
7309 fi
7310 cat >conftest.$ac_ext <<_ACEOF
7311 /* confdefs.h.  */
7312 _ACEOF
7313 cat confdefs.h >>conftest.$ac_ext
7314 cat >>conftest.$ac_ext <<_ACEOF
7315 /* end confdefs.h.  */
7316 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7317    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7318 #define $ac_func innocuous_$ac_func
7319
7320 /* System header to define __stub macros and hopefully few prototypes,
7321     which can conflict with char $ac_func (); below.
7322     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7323     <limits.h> exists even on freestanding compilers.  */
7324
7325 #ifdef __STDC__
7326 # include <limits.h>
7327 #else
7328 # include <assert.h>
7329 #endif
7330
7331 #undef $ac_func
7332
7333 /* Override any gcc2 internal prototype to avoid an error.  */
7334 #ifdef __cplusplus
7335 extern "C"
7336 {
7337 #endif
7338 /* We use char because int might match the return type of a gcc2
7339    builtin and then its argument prototype would still apply.  */
7340 char $ac_func ();
7341 /* The GNU C library defines this for functions which it implements
7342     to always fail with ENOSYS.  Some functions are actually named
7343     something starting with __ and the normal name is an alias.  */
7344 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7345 choke me
7346 #else
7347 char (*f) () = $ac_func;
7348 #endif
7349 #ifdef __cplusplus
7350 }
7351 #endif
7352
7353 int
7354 main ()
7355 {
7356 return f != $ac_func;
7357   ;
7358   return 0;
7359 }
7360 _ACEOF
7361 rm -f conftest.$ac_objext conftest$ac_exeext
7362 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7363   (eval $ac_link) 2>conftest.er1
7364   ac_status=$?
7365   grep -v '^ *+' conftest.er1 >conftest.err
7366   rm -f conftest.er1
7367   cat conftest.err >&5
7368   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7369   (exit $ac_status); } &&
7370          { ac_try='test -z "$ac_c_werror_flag"
7371                          || test ! -s conftest.err'
7372   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7373   (eval $ac_try) 2>&5
7374   ac_status=$?
7375   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7376   (exit $ac_status); }; } &&
7377          { ac_try='test -s conftest$ac_exeext'
7378   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7379   (eval $ac_try) 2>&5
7380   ac_status=$?
7381   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7382   (exit $ac_status); }; }; then
7383   eval "$as_ac_var=yes"
7384 else
7385   echo "$as_me: failed program was:" >&5
7386 sed 's/^/| /' conftest.$ac_ext >&5
7387
7388 eval "$as_ac_var=no"
7389 fi
7390 rm -f conftest.err conftest.$ac_objext \
7391       conftest$ac_exeext conftest.$ac_ext
7392 fi
7393 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7394 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7395 if test `eval echo '${'$as_ac_var'}'` = yes; then
7396   cat >>confdefs.h <<_ACEOF
7397 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7398 _ACEOF
7399
7400 fi
7401 done
7402
7403
7404
7405
7406
7407
7408
7409
7410
7411 for ac_func in chdir strerror getlogin gethostname kill link symlink perror
7412 do
7413 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7414 echo "$as_me:$LINENO: checking for $ac_func" >&5
7415 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7416 if eval "test \"\${$as_ac_var+set}\" = set"; then
7417   echo $ECHO_N "(cached) $ECHO_C" >&6
7418 else
7419   if test x$gcc_no_link = xyes; then
7420   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7421 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7422    { (exit 1); exit 1; }; }
7423 fi
7424 cat >conftest.$ac_ext <<_ACEOF
7425 /* confdefs.h.  */
7426 _ACEOF
7427 cat confdefs.h >>conftest.$ac_ext
7428 cat >>conftest.$ac_ext <<_ACEOF
7429 /* end confdefs.h.  */
7430 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7431    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7432 #define $ac_func innocuous_$ac_func
7433
7434 /* System header to define __stub macros and hopefully few prototypes,
7435     which can conflict with char $ac_func (); below.
7436     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7437     <limits.h> exists even on freestanding compilers.  */
7438
7439 #ifdef __STDC__
7440 # include <limits.h>
7441 #else
7442 # include <assert.h>
7443 #endif
7444
7445 #undef $ac_func
7446
7447 /* Override any gcc2 internal prototype to avoid an error.  */
7448 #ifdef __cplusplus
7449 extern "C"
7450 {
7451 #endif
7452 /* We use char because int might match the return type of a gcc2
7453    builtin and then its argument prototype would still apply.  */
7454 char $ac_func ();
7455 /* The GNU C library defines this for functions which it implements
7456     to always fail with ENOSYS.  Some functions are actually named
7457     something starting with __ and the normal name is an alias.  */
7458 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7459 choke me
7460 #else
7461 char (*f) () = $ac_func;
7462 #endif
7463 #ifdef __cplusplus
7464 }
7465 #endif
7466
7467 int
7468 main ()
7469 {
7470 return f != $ac_func;
7471   ;
7472   return 0;
7473 }
7474 _ACEOF
7475 rm -f conftest.$ac_objext conftest$ac_exeext
7476 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7477   (eval $ac_link) 2>conftest.er1
7478   ac_status=$?
7479   grep -v '^ *+' conftest.er1 >conftest.err
7480   rm -f conftest.er1
7481   cat conftest.err >&5
7482   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7483   (exit $ac_status); } &&
7484          { ac_try='test -z "$ac_c_werror_flag"
7485                          || test ! -s conftest.err'
7486   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7487   (eval $ac_try) 2>&5
7488   ac_status=$?
7489   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7490   (exit $ac_status); }; } &&
7491          { ac_try='test -s conftest$ac_exeext'
7492   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7493   (eval $ac_try) 2>&5
7494   ac_status=$?
7495   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7496   (exit $ac_status); }; }; then
7497   eval "$as_ac_var=yes"
7498 else
7499   echo "$as_me: failed program was:" >&5
7500 sed 's/^/| /' conftest.$ac_ext >&5
7501
7502 eval "$as_ac_var=no"
7503 fi
7504 rm -f conftest.err conftest.$ac_objext \
7505       conftest$ac_exeext conftest.$ac_ext
7506 fi
7507 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7508 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7509 if test `eval echo '${'$as_ac_var'}'` = yes; then
7510   cat >>confdefs.h <<_ACEOF
7511 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7512 _ACEOF
7513
7514 fi
7515 done
7516
7517
7518
7519
7520
7521
7522
7523 for ac_func in sleep time ttyname signal alarm ctime
7524 do
7525 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7526 echo "$as_me:$LINENO: checking for $ac_func" >&5
7527 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7528 if eval "test \"\${$as_ac_var+set}\" = set"; then
7529   echo $ECHO_N "(cached) $ECHO_C" >&6
7530 else
7531   if test x$gcc_no_link = xyes; then
7532   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7533 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7534    { (exit 1); exit 1; }; }
7535 fi
7536 cat >conftest.$ac_ext <<_ACEOF
7537 /* confdefs.h.  */
7538 _ACEOF
7539 cat confdefs.h >>conftest.$ac_ext
7540 cat >>conftest.$ac_ext <<_ACEOF
7541 /* end confdefs.h.  */
7542 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7543    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7544 #define $ac_func innocuous_$ac_func
7545
7546 /* System header to define __stub macros and hopefully few prototypes,
7547     which can conflict with char $ac_func (); below.
7548     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7549     <limits.h> exists even on freestanding compilers.  */
7550
7551 #ifdef __STDC__
7552 # include <limits.h>
7553 #else
7554 # include <assert.h>
7555 #endif
7556
7557 #undef $ac_func
7558
7559 /* Override any gcc2 internal prototype to avoid an error.  */
7560 #ifdef __cplusplus
7561 extern "C"
7562 {
7563 #endif
7564 /* We use char because int might match the return type of a gcc2
7565    builtin and then its argument prototype would still apply.  */
7566 char $ac_func ();
7567 /* The GNU C library defines this for functions which it implements
7568     to always fail with ENOSYS.  Some functions are actually named
7569     something starting with __ and the normal name is an alias.  */
7570 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7571 choke me
7572 #else
7573 char (*f) () = $ac_func;
7574 #endif
7575 #ifdef __cplusplus
7576 }
7577 #endif
7578
7579 int
7580 main ()
7581 {
7582 return f != $ac_func;
7583   ;
7584   return 0;
7585 }
7586 _ACEOF
7587 rm -f conftest.$ac_objext conftest$ac_exeext
7588 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7589   (eval $ac_link) 2>conftest.er1
7590   ac_status=$?
7591   grep -v '^ *+' conftest.er1 >conftest.err
7592   rm -f conftest.er1
7593   cat conftest.err >&5
7594   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7595   (exit $ac_status); } &&
7596          { ac_try='test -z "$ac_c_werror_flag"
7597                          || test ! -s conftest.err'
7598   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7599   (eval $ac_try) 2>&5
7600   ac_status=$?
7601   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7602   (exit $ac_status); }; } &&
7603          { ac_try='test -s conftest$ac_exeext'
7604   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7605   (eval $ac_try) 2>&5
7606   ac_status=$?
7607   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7608   (exit $ac_status); }; }; then
7609   eval "$as_ac_var=yes"
7610 else
7611   echo "$as_me: failed program was:" >&5
7612 sed 's/^/| /' conftest.$ac_ext >&5
7613
7614 eval "$as_ac_var=no"
7615 fi
7616 rm -f conftest.err conftest.$ac_objext \
7617       conftest$ac_exeext conftest.$ac_ext
7618 fi
7619 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7620 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7621 if test `eval echo '${'$as_ac_var'}'` = yes; then
7622   cat >>confdefs.h <<_ACEOF
7623 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7624 _ACEOF
7625
7626 fi
7627 done
7628
7629
7630 # Check libc for getgid, getpid, getuid
7631 echo "$as_me:$LINENO: checking for getgid in -lc" >&5
7632 echo $ECHO_N "checking for getgid in -lc... $ECHO_C" >&6
7633 if test "${ac_cv_lib_c_getgid+set}" = set; then
7634   echo $ECHO_N "(cached) $ECHO_C" >&6
7635 else
7636   ac_check_lib_save_LIBS=$LIBS
7637 LIBS="-lc  $LIBS"
7638 if test x$gcc_no_link = xyes; then
7639   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7640 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7641    { (exit 1); exit 1; }; }
7642 fi
7643 cat >conftest.$ac_ext <<_ACEOF
7644 /* confdefs.h.  */
7645 _ACEOF
7646 cat confdefs.h >>conftest.$ac_ext
7647 cat >>conftest.$ac_ext <<_ACEOF
7648 /* end confdefs.h.  */
7649
7650 /* Override any gcc2 internal prototype to avoid an error.  */
7651 #ifdef __cplusplus
7652 extern "C"
7653 #endif
7654 /* We use char because int might match the return type of a gcc2
7655    builtin and then its argument prototype would still apply.  */
7656 char getgid ();
7657 int
7658 main ()
7659 {
7660 getgid ();
7661   ;
7662   return 0;
7663 }
7664 _ACEOF
7665 rm -f conftest.$ac_objext conftest$ac_exeext
7666 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7667   (eval $ac_link) 2>conftest.er1
7668   ac_status=$?
7669   grep -v '^ *+' conftest.er1 >conftest.err
7670   rm -f conftest.er1
7671   cat conftest.err >&5
7672   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7673   (exit $ac_status); } &&
7674          { ac_try='test -z "$ac_c_werror_flag"
7675                          || test ! -s conftest.err'
7676   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7677   (eval $ac_try) 2>&5
7678   ac_status=$?
7679   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7680   (exit $ac_status); }; } &&
7681          { ac_try='test -s conftest$ac_exeext'
7682   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7683   (eval $ac_try) 2>&5
7684   ac_status=$?
7685   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7686   (exit $ac_status); }; }; then
7687   ac_cv_lib_c_getgid=yes
7688 else
7689   echo "$as_me: failed program was:" >&5
7690 sed 's/^/| /' conftest.$ac_ext >&5
7691
7692 ac_cv_lib_c_getgid=no
7693 fi
7694 rm -f conftest.err conftest.$ac_objext \
7695       conftest$ac_exeext conftest.$ac_ext
7696 LIBS=$ac_check_lib_save_LIBS
7697 fi
7698 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getgid" >&5
7699 echo "${ECHO_T}$ac_cv_lib_c_getgid" >&6
7700 if test $ac_cv_lib_c_getgid = yes; then
7701
7702 cat >>confdefs.h <<\_ACEOF
7703 #define HAVE_GETGID 1
7704 _ACEOF
7705
7706 fi
7707
7708 echo "$as_me:$LINENO: checking for getpid in -lc" >&5
7709 echo $ECHO_N "checking for getpid in -lc... $ECHO_C" >&6
7710 if test "${ac_cv_lib_c_getpid+set}" = set; then
7711   echo $ECHO_N "(cached) $ECHO_C" >&6
7712 else
7713   ac_check_lib_save_LIBS=$LIBS
7714 LIBS="-lc  $LIBS"
7715 if test x$gcc_no_link = xyes; then
7716   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7717 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7718    { (exit 1); exit 1; }; }
7719 fi
7720 cat >conftest.$ac_ext <<_ACEOF
7721 /* confdefs.h.  */
7722 _ACEOF
7723 cat confdefs.h >>conftest.$ac_ext
7724 cat >>conftest.$ac_ext <<_ACEOF
7725 /* end confdefs.h.  */
7726
7727 /* Override any gcc2 internal prototype to avoid an error.  */
7728 #ifdef __cplusplus
7729 extern "C"
7730 #endif
7731 /* We use char because int might match the return type of a gcc2
7732    builtin and then its argument prototype would still apply.  */
7733 char getpid ();
7734 int
7735 main ()
7736 {
7737 getpid ();
7738   ;
7739   return 0;
7740 }
7741 _ACEOF
7742 rm -f conftest.$ac_objext conftest$ac_exeext
7743 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7744   (eval $ac_link) 2>conftest.er1
7745   ac_status=$?
7746   grep -v '^ *+' conftest.er1 >conftest.err
7747   rm -f conftest.er1
7748   cat conftest.err >&5
7749   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7750   (exit $ac_status); } &&
7751          { ac_try='test -z "$ac_c_werror_flag"
7752                          || test ! -s conftest.err'
7753   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7754   (eval $ac_try) 2>&5
7755   ac_status=$?
7756   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7757   (exit $ac_status); }; } &&
7758          { ac_try='test -s conftest$ac_exeext'
7759   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7760   (eval $ac_try) 2>&5
7761   ac_status=$?
7762   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7763   (exit $ac_status); }; }; then
7764   ac_cv_lib_c_getpid=yes
7765 else
7766   echo "$as_me: failed program was:" >&5
7767 sed 's/^/| /' conftest.$ac_ext >&5
7768
7769 ac_cv_lib_c_getpid=no
7770 fi
7771 rm -f conftest.err conftest.$ac_objext \
7772       conftest$ac_exeext conftest.$ac_ext
7773 LIBS=$ac_check_lib_save_LIBS
7774 fi
7775 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getpid" >&5
7776 echo "${ECHO_T}$ac_cv_lib_c_getpid" >&6
7777 if test $ac_cv_lib_c_getpid = yes; then
7778
7779 cat >>confdefs.h <<\_ACEOF
7780 #define HAVE_GETPID 1
7781 _ACEOF
7782
7783 fi
7784
7785 echo "$as_me:$LINENO: checking for getuid in -lc" >&5
7786 echo $ECHO_N "checking for getuid in -lc... $ECHO_C" >&6
7787 if test "${ac_cv_lib_c_getuid+set}" = set; then
7788   echo $ECHO_N "(cached) $ECHO_C" >&6
7789 else
7790   ac_check_lib_save_LIBS=$LIBS
7791 LIBS="-lc  $LIBS"
7792 if test x$gcc_no_link = xyes; then
7793   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7794 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7795    { (exit 1); exit 1; }; }
7796 fi
7797 cat >conftest.$ac_ext <<_ACEOF
7798 /* confdefs.h.  */
7799 _ACEOF
7800 cat confdefs.h >>conftest.$ac_ext
7801 cat >>conftest.$ac_ext <<_ACEOF
7802 /* end confdefs.h.  */
7803
7804 /* Override any gcc2 internal prototype to avoid an error.  */
7805 #ifdef __cplusplus
7806 extern "C"
7807 #endif
7808 /* We use char because int might match the return type of a gcc2
7809    builtin and then its argument prototype would still apply.  */
7810 char getuid ();
7811 int
7812 main ()
7813 {
7814 getuid ();
7815   ;
7816   return 0;
7817 }
7818 _ACEOF
7819 rm -f conftest.$ac_objext conftest$ac_exeext
7820 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7821   (eval $ac_link) 2>conftest.er1
7822   ac_status=$?
7823   grep -v '^ *+' conftest.er1 >conftest.err
7824   rm -f conftest.er1
7825   cat conftest.err >&5
7826   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7827   (exit $ac_status); } &&
7828          { ac_try='test -z "$ac_c_werror_flag"
7829                          || test ! -s conftest.err'
7830   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7831   (eval $ac_try) 2>&5
7832   ac_status=$?
7833   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7834   (exit $ac_status); }; } &&
7835          { ac_try='test -s conftest$ac_exeext'
7836   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7837   (eval $ac_try) 2>&5
7838   ac_status=$?
7839   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7840   (exit $ac_status); }; }; then
7841   ac_cv_lib_c_getuid=yes
7842 else
7843   echo "$as_me: failed program was:" >&5
7844 sed 's/^/| /' conftest.$ac_ext >&5
7845
7846 ac_cv_lib_c_getuid=no
7847 fi
7848 rm -f conftest.err conftest.$ac_objext \
7849       conftest$ac_exeext conftest.$ac_ext
7850 LIBS=$ac_check_lib_save_LIBS
7851 fi
7852 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getuid" >&5
7853 echo "${ECHO_T}$ac_cv_lib_c_getuid" >&6
7854 if test $ac_cv_lib_c_getuid = yes; then
7855
7856 cat >>confdefs.h <<\_ACEOF
7857 #define HAVE_GETUID 1
7858 _ACEOF
7859
7860 fi
7861
7862
7863 # Check for C99 (and other IEEE) math functions
7864 # ??? This list seems awful long. Is there a better way to test for these?
7865 echo "$as_me:$LINENO: checking for acosf in -lm" >&5
7866 echo $ECHO_N "checking for acosf in -lm... $ECHO_C" >&6
7867 if test "${ac_cv_lib_m_acosf+set}" = set; then
7868   echo $ECHO_N "(cached) $ECHO_C" >&6
7869 else
7870   ac_check_lib_save_LIBS=$LIBS
7871 LIBS="-lm  $LIBS"
7872 if test x$gcc_no_link = xyes; then
7873   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7874 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7875    { (exit 1); exit 1; }; }
7876 fi
7877 cat >conftest.$ac_ext <<_ACEOF
7878 /* confdefs.h.  */
7879 _ACEOF
7880 cat confdefs.h >>conftest.$ac_ext
7881 cat >>conftest.$ac_ext <<_ACEOF
7882 /* end confdefs.h.  */
7883
7884 /* Override any gcc2 internal prototype to avoid an error.  */
7885 #ifdef __cplusplus
7886 extern "C"
7887 #endif
7888 /* We use char because int might match the return type of a gcc2
7889    builtin and then its argument prototype would still apply.  */
7890 char acosf ();
7891 int
7892 main ()
7893 {
7894 acosf ();
7895   ;
7896   return 0;
7897 }
7898 _ACEOF
7899 rm -f conftest.$ac_objext conftest$ac_exeext
7900 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7901   (eval $ac_link) 2>conftest.er1
7902   ac_status=$?
7903   grep -v '^ *+' conftest.er1 >conftest.err
7904   rm -f conftest.er1
7905   cat conftest.err >&5
7906   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7907   (exit $ac_status); } &&
7908          { ac_try='test -z "$ac_c_werror_flag"
7909                          || test ! -s conftest.err'
7910   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7911   (eval $ac_try) 2>&5
7912   ac_status=$?
7913   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7914   (exit $ac_status); }; } &&
7915          { ac_try='test -s conftest$ac_exeext'
7916   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7917   (eval $ac_try) 2>&5
7918   ac_status=$?
7919   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7920   (exit $ac_status); }; }; then
7921   ac_cv_lib_m_acosf=yes
7922 else
7923   echo "$as_me: failed program was:" >&5
7924 sed 's/^/| /' conftest.$ac_ext >&5
7925
7926 ac_cv_lib_m_acosf=no
7927 fi
7928 rm -f conftest.err conftest.$ac_objext \
7929       conftest$ac_exeext conftest.$ac_ext
7930 LIBS=$ac_check_lib_save_LIBS
7931 fi
7932 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosf" >&5
7933 echo "${ECHO_T}$ac_cv_lib_m_acosf" >&6
7934 if test $ac_cv_lib_m_acosf = yes; then
7935
7936 cat >>confdefs.h <<\_ACEOF
7937 #define HAVE_ACOSF 1
7938 _ACEOF
7939
7940 fi
7941
7942 echo "$as_me:$LINENO: checking for acos in -lm" >&5
7943 echo $ECHO_N "checking for acos in -lm... $ECHO_C" >&6
7944 if test "${ac_cv_lib_m_acos+set}" = set; then
7945   echo $ECHO_N "(cached) $ECHO_C" >&6
7946 else
7947   ac_check_lib_save_LIBS=$LIBS
7948 LIBS="-lm  $LIBS"
7949 if test x$gcc_no_link = xyes; then
7950   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7951 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7952    { (exit 1); exit 1; }; }
7953 fi
7954 cat >conftest.$ac_ext <<_ACEOF
7955 /* confdefs.h.  */
7956 _ACEOF
7957 cat confdefs.h >>conftest.$ac_ext
7958 cat >>conftest.$ac_ext <<_ACEOF
7959 /* end confdefs.h.  */
7960
7961 /* Override any gcc2 internal prototype to avoid an error.  */
7962 #ifdef __cplusplus
7963 extern "C"
7964 #endif
7965 /* We use char because int might match the return type of a gcc2
7966    builtin and then its argument prototype would still apply.  */
7967 char acos ();
7968 int
7969 main ()
7970 {
7971 acos ();
7972   ;
7973   return 0;
7974 }
7975 _ACEOF
7976 rm -f conftest.$ac_objext conftest$ac_exeext
7977 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7978   (eval $ac_link) 2>conftest.er1
7979   ac_status=$?
7980   grep -v '^ *+' conftest.er1 >conftest.err
7981   rm -f conftest.er1
7982   cat conftest.err >&5
7983   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7984   (exit $ac_status); } &&
7985          { ac_try='test -z "$ac_c_werror_flag"
7986                          || test ! -s conftest.err'
7987   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7988   (eval $ac_try) 2>&5
7989   ac_status=$?
7990   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7991   (exit $ac_status); }; } &&
7992          { ac_try='test -s conftest$ac_exeext'
7993   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7994   (eval $ac_try) 2>&5
7995   ac_status=$?
7996   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7997   (exit $ac_status); }; }; then
7998   ac_cv_lib_m_acos=yes
7999 else
8000   echo "$as_me: failed program was:" >&5
8001 sed 's/^/| /' conftest.$ac_ext >&5
8002
8003 ac_cv_lib_m_acos=no
8004 fi
8005 rm -f conftest.err conftest.$ac_objext \
8006       conftest$ac_exeext conftest.$ac_ext
8007 LIBS=$ac_check_lib_save_LIBS
8008 fi
8009 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acos" >&5
8010 echo "${ECHO_T}$ac_cv_lib_m_acos" >&6
8011 if test $ac_cv_lib_m_acos = yes; then
8012
8013 cat >>confdefs.h <<\_ACEOF
8014 #define HAVE_ACOS 1
8015 _ACEOF
8016
8017 fi
8018
8019 echo "$as_me:$LINENO: checking for acosl in -lm" >&5
8020 echo $ECHO_N "checking for acosl in -lm... $ECHO_C" >&6
8021 if test "${ac_cv_lib_m_acosl+set}" = set; then
8022   echo $ECHO_N "(cached) $ECHO_C" >&6
8023 else
8024   ac_check_lib_save_LIBS=$LIBS
8025 LIBS="-lm  $LIBS"
8026 if test x$gcc_no_link = xyes; then
8027   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8028 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8029    { (exit 1); exit 1; }; }
8030 fi
8031 cat >conftest.$ac_ext <<_ACEOF
8032 /* confdefs.h.  */
8033 _ACEOF
8034 cat confdefs.h >>conftest.$ac_ext
8035 cat >>conftest.$ac_ext <<_ACEOF
8036 /* end confdefs.h.  */
8037
8038 /* Override any gcc2 internal prototype to avoid an error.  */
8039 #ifdef __cplusplus
8040 extern "C"
8041 #endif
8042 /* We use char because int might match the return type of a gcc2
8043    builtin and then its argument prototype would still apply.  */
8044 char acosl ();
8045 int
8046 main ()
8047 {
8048 acosl ();
8049   ;
8050   return 0;
8051 }
8052 _ACEOF
8053 rm -f conftest.$ac_objext conftest$ac_exeext
8054 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8055   (eval $ac_link) 2>conftest.er1
8056   ac_status=$?
8057   grep -v '^ *+' conftest.er1 >conftest.err
8058   rm -f conftest.er1
8059   cat conftest.err >&5
8060   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8061   (exit $ac_status); } &&
8062          { ac_try='test -z "$ac_c_werror_flag"
8063                          || test ! -s conftest.err'
8064   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8065   (eval $ac_try) 2>&5
8066   ac_status=$?
8067   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8068   (exit $ac_status); }; } &&
8069          { ac_try='test -s conftest$ac_exeext'
8070   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8071   (eval $ac_try) 2>&5
8072   ac_status=$?
8073   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8074   (exit $ac_status); }; }; then
8075   ac_cv_lib_m_acosl=yes
8076 else
8077   echo "$as_me: failed program was:" >&5
8078 sed 's/^/| /' conftest.$ac_ext >&5
8079
8080 ac_cv_lib_m_acosl=no
8081 fi
8082 rm -f conftest.err conftest.$ac_objext \
8083       conftest$ac_exeext conftest.$ac_ext
8084 LIBS=$ac_check_lib_save_LIBS
8085 fi
8086 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosl" >&5
8087 echo "${ECHO_T}$ac_cv_lib_m_acosl" >&6
8088 if test $ac_cv_lib_m_acosl = yes; then
8089
8090 cat >>confdefs.h <<\_ACEOF
8091 #define HAVE_ACOSL 1
8092 _ACEOF
8093
8094 fi
8095
8096 echo "$as_me:$LINENO: checking for acoshf in -lm" >&5
8097 echo $ECHO_N "checking for acoshf in -lm... $ECHO_C" >&6
8098 if test "${ac_cv_lib_m_acoshf+set}" = set; then
8099   echo $ECHO_N "(cached) $ECHO_C" >&6
8100 else
8101   ac_check_lib_save_LIBS=$LIBS
8102 LIBS="-lm  $LIBS"
8103 if test x$gcc_no_link = xyes; then
8104   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8105 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8106    { (exit 1); exit 1; }; }
8107 fi
8108 cat >conftest.$ac_ext <<_ACEOF
8109 /* confdefs.h.  */
8110 _ACEOF
8111 cat confdefs.h >>conftest.$ac_ext
8112 cat >>conftest.$ac_ext <<_ACEOF
8113 /* end confdefs.h.  */
8114
8115 /* Override any gcc2 internal prototype to avoid an error.  */
8116 #ifdef __cplusplus
8117 extern "C"
8118 #endif
8119 /* We use char because int might match the return type of a gcc2
8120    builtin and then its argument prototype would still apply.  */
8121 char acoshf ();
8122 int
8123 main ()
8124 {
8125 acoshf ();
8126   ;
8127   return 0;
8128 }
8129 _ACEOF
8130 rm -f conftest.$ac_objext conftest$ac_exeext
8131 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8132   (eval $ac_link) 2>conftest.er1
8133   ac_status=$?
8134   grep -v '^ *+' conftest.er1 >conftest.err
8135   rm -f conftest.er1
8136   cat conftest.err >&5
8137   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8138   (exit $ac_status); } &&
8139          { ac_try='test -z "$ac_c_werror_flag"
8140                          || test ! -s conftest.err'
8141   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8142   (eval $ac_try) 2>&5
8143   ac_status=$?
8144   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8145   (exit $ac_status); }; } &&
8146          { ac_try='test -s conftest$ac_exeext'
8147   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8148   (eval $ac_try) 2>&5
8149   ac_status=$?
8150   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8151   (exit $ac_status); }; }; then
8152   ac_cv_lib_m_acoshf=yes
8153 else
8154   echo "$as_me: failed program was:" >&5
8155 sed 's/^/| /' conftest.$ac_ext >&5
8156
8157 ac_cv_lib_m_acoshf=no
8158 fi
8159 rm -f conftest.err conftest.$ac_objext \
8160       conftest$ac_exeext conftest.$ac_ext
8161 LIBS=$ac_check_lib_save_LIBS
8162 fi
8163 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acoshf" >&5
8164 echo "${ECHO_T}$ac_cv_lib_m_acoshf" >&6
8165 if test $ac_cv_lib_m_acoshf = yes; then
8166
8167 cat >>confdefs.h <<\_ACEOF
8168 #define HAVE_ACOSHF 1
8169 _ACEOF
8170
8171 fi
8172
8173 echo "$as_me:$LINENO: checking for acosh in -lm" >&5
8174 echo $ECHO_N "checking for acosh in -lm... $ECHO_C" >&6
8175 if test "${ac_cv_lib_m_acosh+set}" = set; then
8176   echo $ECHO_N "(cached) $ECHO_C" >&6
8177 else
8178   ac_check_lib_save_LIBS=$LIBS
8179 LIBS="-lm  $LIBS"
8180 if test x$gcc_no_link = xyes; then
8181   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8182 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8183    { (exit 1); exit 1; }; }
8184 fi
8185 cat >conftest.$ac_ext <<_ACEOF
8186 /* confdefs.h.  */
8187 _ACEOF
8188 cat confdefs.h >>conftest.$ac_ext
8189 cat >>conftest.$ac_ext <<_ACEOF
8190 /* end confdefs.h.  */
8191
8192 /* Override any gcc2 internal prototype to avoid an error.  */
8193 #ifdef __cplusplus
8194 extern "C"
8195 #endif
8196 /* We use char because int might match the return type of a gcc2
8197    builtin and then its argument prototype would still apply.  */
8198 char acosh ();
8199 int
8200 main ()
8201 {
8202 acosh ();
8203   ;
8204   return 0;
8205 }
8206 _ACEOF
8207 rm -f conftest.$ac_objext conftest$ac_exeext
8208 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8209   (eval $ac_link) 2>conftest.er1
8210   ac_status=$?
8211   grep -v '^ *+' conftest.er1 >conftest.err
8212   rm -f conftest.er1
8213   cat conftest.err >&5
8214   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8215   (exit $ac_status); } &&
8216          { ac_try='test -z "$ac_c_werror_flag"
8217                          || test ! -s conftest.err'
8218   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8219   (eval $ac_try) 2>&5
8220   ac_status=$?
8221   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8222   (exit $ac_status); }; } &&
8223          { ac_try='test -s conftest$ac_exeext'
8224   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8225   (eval $ac_try) 2>&5
8226   ac_status=$?
8227   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8228   (exit $ac_status); }; }; then
8229   ac_cv_lib_m_acosh=yes
8230 else
8231   echo "$as_me: failed program was:" >&5
8232 sed 's/^/| /' conftest.$ac_ext >&5
8233
8234 ac_cv_lib_m_acosh=no
8235 fi
8236 rm -f conftest.err conftest.$ac_objext \
8237       conftest$ac_exeext conftest.$ac_ext
8238 LIBS=$ac_check_lib_save_LIBS
8239 fi
8240 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosh" >&5
8241 echo "${ECHO_T}$ac_cv_lib_m_acosh" >&6
8242 if test $ac_cv_lib_m_acosh = yes; then
8243
8244 cat >>confdefs.h <<\_ACEOF
8245 #define HAVE_ACOSH 1
8246 _ACEOF
8247
8248 fi
8249
8250 echo "$as_me:$LINENO: checking for acoshl in -lm" >&5
8251 echo $ECHO_N "checking for acoshl in -lm... $ECHO_C" >&6
8252 if test "${ac_cv_lib_m_acoshl+set}" = set; then
8253   echo $ECHO_N "(cached) $ECHO_C" >&6
8254 else
8255   ac_check_lib_save_LIBS=$LIBS
8256 LIBS="-lm  $LIBS"
8257 if test x$gcc_no_link = xyes; then
8258   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8259 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8260    { (exit 1); exit 1; }; }
8261 fi
8262 cat >conftest.$ac_ext <<_ACEOF
8263 /* confdefs.h.  */
8264 _ACEOF
8265 cat confdefs.h >>conftest.$ac_ext
8266 cat >>conftest.$ac_ext <<_ACEOF
8267 /* end confdefs.h.  */
8268
8269 /* Override any gcc2 internal prototype to avoid an error.  */
8270 #ifdef __cplusplus
8271 extern "C"
8272 #endif
8273 /* We use char because int might match the return type of a gcc2
8274    builtin and then its argument prototype would still apply.  */
8275 char acoshl ();
8276 int
8277 main ()
8278 {
8279 acoshl ();
8280   ;
8281   return 0;
8282 }
8283 _ACEOF
8284 rm -f conftest.$ac_objext conftest$ac_exeext
8285 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8286   (eval $ac_link) 2>conftest.er1
8287   ac_status=$?
8288   grep -v '^ *+' conftest.er1 >conftest.err
8289   rm -f conftest.er1
8290   cat conftest.err >&5
8291   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8292   (exit $ac_status); } &&
8293          { ac_try='test -z "$ac_c_werror_flag"
8294                          || test ! -s conftest.err'
8295   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8296   (eval $ac_try) 2>&5
8297   ac_status=$?
8298   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8299   (exit $ac_status); }; } &&
8300          { ac_try='test -s conftest$ac_exeext'
8301   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8302   (eval $ac_try) 2>&5
8303   ac_status=$?
8304   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8305   (exit $ac_status); }; }; then
8306   ac_cv_lib_m_acoshl=yes
8307 else
8308   echo "$as_me: failed program was:" >&5
8309 sed 's/^/| /' conftest.$ac_ext >&5
8310
8311 ac_cv_lib_m_acoshl=no
8312 fi
8313 rm -f conftest.err conftest.$ac_objext \
8314       conftest$ac_exeext conftest.$ac_ext
8315 LIBS=$ac_check_lib_save_LIBS
8316 fi
8317 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acoshl" >&5
8318 echo "${ECHO_T}$ac_cv_lib_m_acoshl" >&6
8319 if test $ac_cv_lib_m_acoshl = yes; then
8320
8321 cat >>confdefs.h <<\_ACEOF
8322 #define HAVE_ACOSHL 1
8323 _ACEOF
8324
8325 fi
8326
8327 echo "$as_me:$LINENO: checking for asinf in -lm" >&5
8328 echo $ECHO_N "checking for asinf in -lm... $ECHO_C" >&6
8329 if test "${ac_cv_lib_m_asinf+set}" = set; then
8330   echo $ECHO_N "(cached) $ECHO_C" >&6
8331 else
8332   ac_check_lib_save_LIBS=$LIBS
8333 LIBS="-lm  $LIBS"
8334 if test x$gcc_no_link = xyes; then
8335   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8336 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8337    { (exit 1); exit 1; }; }
8338 fi
8339 cat >conftest.$ac_ext <<_ACEOF
8340 /* confdefs.h.  */
8341 _ACEOF
8342 cat confdefs.h >>conftest.$ac_ext
8343 cat >>conftest.$ac_ext <<_ACEOF
8344 /* end confdefs.h.  */
8345
8346 /* Override any gcc2 internal prototype to avoid an error.  */
8347 #ifdef __cplusplus
8348 extern "C"
8349 #endif
8350 /* We use char because int might match the return type of a gcc2
8351    builtin and then its argument prototype would still apply.  */
8352 char asinf ();
8353 int
8354 main ()
8355 {
8356 asinf ();
8357   ;
8358   return 0;
8359 }
8360 _ACEOF
8361 rm -f conftest.$ac_objext conftest$ac_exeext
8362 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8363   (eval $ac_link) 2>conftest.er1
8364   ac_status=$?
8365   grep -v '^ *+' conftest.er1 >conftest.err
8366   rm -f conftest.er1
8367   cat conftest.err >&5
8368   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8369   (exit $ac_status); } &&
8370          { ac_try='test -z "$ac_c_werror_flag"
8371                          || test ! -s conftest.err'
8372   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8373   (eval $ac_try) 2>&5
8374   ac_status=$?
8375   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8376   (exit $ac_status); }; } &&
8377          { ac_try='test -s conftest$ac_exeext'
8378   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8379   (eval $ac_try) 2>&5
8380   ac_status=$?
8381   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8382   (exit $ac_status); }; }; then
8383   ac_cv_lib_m_asinf=yes
8384 else
8385   echo "$as_me: failed program was:" >&5
8386 sed 's/^/| /' conftest.$ac_ext >&5
8387
8388 ac_cv_lib_m_asinf=no
8389 fi
8390 rm -f conftest.err conftest.$ac_objext \
8391       conftest$ac_exeext conftest.$ac_ext
8392 LIBS=$ac_check_lib_save_LIBS
8393 fi
8394 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinf" >&5
8395 echo "${ECHO_T}$ac_cv_lib_m_asinf" >&6
8396 if test $ac_cv_lib_m_asinf = yes; then
8397
8398 cat >>confdefs.h <<\_ACEOF
8399 #define HAVE_ASINF 1
8400 _ACEOF
8401
8402 fi
8403
8404 echo "$as_me:$LINENO: checking for asin in -lm" >&5
8405 echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
8406 if test "${ac_cv_lib_m_asin+set}" = set; then
8407   echo $ECHO_N "(cached) $ECHO_C" >&6
8408 else
8409   ac_check_lib_save_LIBS=$LIBS
8410 LIBS="-lm  $LIBS"
8411 if test x$gcc_no_link = xyes; then
8412   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8413 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8414    { (exit 1); exit 1; }; }
8415 fi
8416 cat >conftest.$ac_ext <<_ACEOF
8417 /* confdefs.h.  */
8418 _ACEOF
8419 cat confdefs.h >>conftest.$ac_ext
8420 cat >>conftest.$ac_ext <<_ACEOF
8421 /* end confdefs.h.  */
8422
8423 /* Override any gcc2 internal prototype to avoid an error.  */
8424 #ifdef __cplusplus
8425 extern "C"
8426 #endif
8427 /* We use char because int might match the return type of a gcc2
8428    builtin and then its argument prototype would still apply.  */
8429 char asin ();
8430 int
8431 main ()
8432 {
8433 asin ();
8434   ;
8435   return 0;
8436 }
8437 _ACEOF
8438 rm -f conftest.$ac_objext conftest$ac_exeext
8439 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8440   (eval $ac_link) 2>conftest.er1
8441   ac_status=$?
8442   grep -v '^ *+' conftest.er1 >conftest.err
8443   rm -f conftest.er1
8444   cat conftest.err >&5
8445   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8446   (exit $ac_status); } &&
8447          { ac_try='test -z "$ac_c_werror_flag"
8448                          || test ! -s conftest.err'
8449   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8450   (eval $ac_try) 2>&5
8451   ac_status=$?
8452   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8453   (exit $ac_status); }; } &&
8454          { ac_try='test -s conftest$ac_exeext'
8455   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8456   (eval $ac_try) 2>&5
8457   ac_status=$?
8458   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8459   (exit $ac_status); }; }; then
8460   ac_cv_lib_m_asin=yes
8461 else
8462   echo "$as_me: failed program was:" >&5
8463 sed 's/^/| /' conftest.$ac_ext >&5
8464
8465 ac_cv_lib_m_asin=no
8466 fi
8467 rm -f conftest.err conftest.$ac_objext \
8468       conftest$ac_exeext conftest.$ac_ext
8469 LIBS=$ac_check_lib_save_LIBS
8470 fi
8471 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
8472 echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
8473 if test $ac_cv_lib_m_asin = yes; then
8474
8475 cat >>confdefs.h <<\_ACEOF
8476 #define HAVE_ASIN 1
8477 _ACEOF
8478
8479 fi
8480
8481 echo "$as_me:$LINENO: checking for asinl in -lm" >&5
8482 echo $ECHO_N "checking for asinl in -lm... $ECHO_C" >&6
8483 if test "${ac_cv_lib_m_asinl+set}" = set; then
8484   echo $ECHO_N "(cached) $ECHO_C" >&6
8485 else
8486   ac_check_lib_save_LIBS=$LIBS
8487 LIBS="-lm  $LIBS"
8488 if test x$gcc_no_link = xyes; then
8489   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8490 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8491    { (exit 1); exit 1; }; }
8492 fi
8493 cat >conftest.$ac_ext <<_ACEOF
8494 /* confdefs.h.  */
8495 _ACEOF
8496 cat confdefs.h >>conftest.$ac_ext
8497 cat >>conftest.$ac_ext <<_ACEOF
8498 /* end confdefs.h.  */
8499
8500 /* Override any gcc2 internal prototype to avoid an error.  */
8501 #ifdef __cplusplus
8502 extern "C"
8503 #endif
8504 /* We use char because int might match the return type of a gcc2
8505    builtin and then its argument prototype would still apply.  */
8506 char asinl ();
8507 int
8508 main ()
8509 {
8510 asinl ();
8511   ;
8512   return 0;
8513 }
8514 _ACEOF
8515 rm -f conftest.$ac_objext conftest$ac_exeext
8516 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8517   (eval $ac_link) 2>conftest.er1
8518   ac_status=$?
8519   grep -v '^ *+' conftest.er1 >conftest.err
8520   rm -f conftest.er1
8521   cat conftest.err >&5
8522   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8523   (exit $ac_status); } &&
8524          { ac_try='test -z "$ac_c_werror_flag"
8525                          || test ! -s conftest.err'
8526   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8527   (eval $ac_try) 2>&5
8528   ac_status=$?
8529   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8530   (exit $ac_status); }; } &&
8531          { ac_try='test -s conftest$ac_exeext'
8532   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8533   (eval $ac_try) 2>&5
8534   ac_status=$?
8535   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8536   (exit $ac_status); }; }; then
8537   ac_cv_lib_m_asinl=yes
8538 else
8539   echo "$as_me: failed program was:" >&5
8540 sed 's/^/| /' conftest.$ac_ext >&5
8541
8542 ac_cv_lib_m_asinl=no
8543 fi
8544 rm -f conftest.err conftest.$ac_objext \
8545       conftest$ac_exeext conftest.$ac_ext
8546 LIBS=$ac_check_lib_save_LIBS
8547 fi
8548 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinl" >&5
8549 echo "${ECHO_T}$ac_cv_lib_m_asinl" >&6
8550 if test $ac_cv_lib_m_asinl = yes; then
8551
8552 cat >>confdefs.h <<\_ACEOF
8553 #define HAVE_ASINL 1
8554 _ACEOF
8555
8556 fi
8557
8558 echo "$as_me:$LINENO: checking for asinhf in -lm" >&5
8559 echo $ECHO_N "checking for asinhf in -lm... $ECHO_C" >&6
8560 if test "${ac_cv_lib_m_asinhf+set}" = set; then
8561   echo $ECHO_N "(cached) $ECHO_C" >&6
8562 else
8563   ac_check_lib_save_LIBS=$LIBS
8564 LIBS="-lm  $LIBS"
8565 if test x$gcc_no_link = xyes; then
8566   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8567 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8568    { (exit 1); exit 1; }; }
8569 fi
8570 cat >conftest.$ac_ext <<_ACEOF
8571 /* confdefs.h.  */
8572 _ACEOF
8573 cat confdefs.h >>conftest.$ac_ext
8574 cat >>conftest.$ac_ext <<_ACEOF
8575 /* end confdefs.h.  */
8576
8577 /* Override any gcc2 internal prototype to avoid an error.  */
8578 #ifdef __cplusplus
8579 extern "C"
8580 #endif
8581 /* We use char because int might match the return type of a gcc2
8582    builtin and then its argument prototype would still apply.  */
8583 char asinhf ();
8584 int
8585 main ()
8586 {
8587 asinhf ();
8588   ;
8589   return 0;
8590 }
8591 _ACEOF
8592 rm -f conftest.$ac_objext conftest$ac_exeext
8593 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8594   (eval $ac_link) 2>conftest.er1
8595   ac_status=$?
8596   grep -v '^ *+' conftest.er1 >conftest.err
8597   rm -f conftest.er1
8598   cat conftest.err >&5
8599   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8600   (exit $ac_status); } &&
8601          { ac_try='test -z "$ac_c_werror_flag"
8602                          || test ! -s conftest.err'
8603   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8604   (eval $ac_try) 2>&5
8605   ac_status=$?
8606   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8607   (exit $ac_status); }; } &&
8608          { ac_try='test -s conftest$ac_exeext'
8609   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8610   (eval $ac_try) 2>&5
8611   ac_status=$?
8612   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8613   (exit $ac_status); }; }; then
8614   ac_cv_lib_m_asinhf=yes
8615 else
8616   echo "$as_me: failed program was:" >&5
8617 sed 's/^/| /' conftest.$ac_ext >&5
8618
8619 ac_cv_lib_m_asinhf=no
8620 fi
8621 rm -f conftest.err conftest.$ac_objext \
8622       conftest$ac_exeext conftest.$ac_ext
8623 LIBS=$ac_check_lib_save_LIBS
8624 fi
8625 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinhf" >&5
8626 echo "${ECHO_T}$ac_cv_lib_m_asinhf" >&6
8627 if test $ac_cv_lib_m_asinhf = yes; then
8628
8629 cat >>confdefs.h <<\_ACEOF
8630 #define HAVE_ASINHF 1
8631 _ACEOF
8632
8633 fi
8634
8635 echo "$as_me:$LINENO: checking for asinh in -lm" >&5
8636 echo $ECHO_N "checking for asinh in -lm... $ECHO_C" >&6
8637 if test "${ac_cv_lib_m_asinh+set}" = set; then
8638   echo $ECHO_N "(cached) $ECHO_C" >&6
8639 else
8640   ac_check_lib_save_LIBS=$LIBS
8641 LIBS="-lm  $LIBS"
8642 if test x$gcc_no_link = xyes; then
8643   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8644 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8645    { (exit 1); exit 1; }; }
8646 fi
8647 cat >conftest.$ac_ext <<_ACEOF
8648 /* confdefs.h.  */
8649 _ACEOF
8650 cat confdefs.h >>conftest.$ac_ext
8651 cat >>conftest.$ac_ext <<_ACEOF
8652 /* end confdefs.h.  */
8653
8654 /* Override any gcc2 internal prototype to avoid an error.  */
8655 #ifdef __cplusplus
8656 extern "C"
8657 #endif
8658 /* We use char because int might match the return type of a gcc2
8659    builtin and then its argument prototype would still apply.  */
8660 char asinh ();
8661 int
8662 main ()
8663 {
8664 asinh ();
8665   ;
8666   return 0;
8667 }
8668 _ACEOF
8669 rm -f conftest.$ac_objext conftest$ac_exeext
8670 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8671   (eval $ac_link) 2>conftest.er1
8672   ac_status=$?
8673   grep -v '^ *+' conftest.er1 >conftest.err
8674   rm -f conftest.er1
8675   cat conftest.err >&5
8676   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8677   (exit $ac_status); } &&
8678          { ac_try='test -z "$ac_c_werror_flag"
8679                          || test ! -s conftest.err'
8680   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8681   (eval $ac_try) 2>&5
8682   ac_status=$?
8683   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8684   (exit $ac_status); }; } &&
8685          { ac_try='test -s conftest$ac_exeext'
8686   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8687   (eval $ac_try) 2>&5
8688   ac_status=$?
8689   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8690   (exit $ac_status); }; }; then
8691   ac_cv_lib_m_asinh=yes
8692 else
8693   echo "$as_me: failed program was:" >&5
8694 sed 's/^/| /' conftest.$ac_ext >&5
8695
8696 ac_cv_lib_m_asinh=no
8697 fi
8698 rm -f conftest.err conftest.$ac_objext \
8699       conftest$ac_exeext conftest.$ac_ext
8700 LIBS=$ac_check_lib_save_LIBS
8701 fi
8702 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinh" >&5
8703 echo "${ECHO_T}$ac_cv_lib_m_asinh" >&6
8704 if test $ac_cv_lib_m_asinh = yes; then
8705
8706 cat >>confdefs.h <<\_ACEOF
8707 #define HAVE_ASINH 1
8708 _ACEOF
8709
8710 fi
8711
8712 echo "$as_me:$LINENO: checking for asinhl in -lm" >&5
8713 echo $ECHO_N "checking for asinhl in -lm... $ECHO_C" >&6
8714 if test "${ac_cv_lib_m_asinhl+set}" = set; then
8715   echo $ECHO_N "(cached) $ECHO_C" >&6
8716 else
8717   ac_check_lib_save_LIBS=$LIBS
8718 LIBS="-lm  $LIBS"
8719 if test x$gcc_no_link = xyes; then
8720   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8721 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8722    { (exit 1); exit 1; }; }
8723 fi
8724 cat >conftest.$ac_ext <<_ACEOF
8725 /* confdefs.h.  */
8726 _ACEOF
8727 cat confdefs.h >>conftest.$ac_ext
8728 cat >>conftest.$ac_ext <<_ACEOF
8729 /* end confdefs.h.  */
8730
8731 /* Override any gcc2 internal prototype to avoid an error.  */
8732 #ifdef __cplusplus
8733 extern "C"
8734 #endif
8735 /* We use char because int might match the return type of a gcc2
8736    builtin and then its argument prototype would still apply.  */
8737 char asinhl ();
8738 int
8739 main ()
8740 {
8741 asinhl ();
8742   ;
8743   return 0;
8744 }
8745 _ACEOF
8746 rm -f conftest.$ac_objext conftest$ac_exeext
8747 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8748   (eval $ac_link) 2>conftest.er1
8749   ac_status=$?
8750   grep -v '^ *+' conftest.er1 >conftest.err
8751   rm -f conftest.er1
8752   cat conftest.err >&5
8753   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8754   (exit $ac_status); } &&
8755          { ac_try='test -z "$ac_c_werror_flag"
8756                          || test ! -s conftest.err'
8757   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8758   (eval $ac_try) 2>&5
8759   ac_status=$?
8760   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8761   (exit $ac_status); }; } &&
8762          { ac_try='test -s conftest$ac_exeext'
8763   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8764   (eval $ac_try) 2>&5
8765   ac_status=$?
8766   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8767   (exit $ac_status); }; }; then
8768   ac_cv_lib_m_asinhl=yes
8769 else
8770   echo "$as_me: failed program was:" >&5
8771 sed 's/^/| /' conftest.$ac_ext >&5
8772
8773 ac_cv_lib_m_asinhl=no
8774 fi
8775 rm -f conftest.err conftest.$ac_objext \
8776       conftest$ac_exeext conftest.$ac_ext
8777 LIBS=$ac_check_lib_save_LIBS
8778 fi
8779 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinhl" >&5
8780 echo "${ECHO_T}$ac_cv_lib_m_asinhl" >&6
8781 if test $ac_cv_lib_m_asinhl = yes; then
8782
8783 cat >>confdefs.h <<\_ACEOF
8784 #define HAVE_ASINHL 1
8785 _ACEOF
8786
8787 fi
8788
8789 echo "$as_me:$LINENO: checking for atan2f in -lm" >&5
8790 echo $ECHO_N "checking for atan2f in -lm... $ECHO_C" >&6
8791 if test "${ac_cv_lib_m_atan2f+set}" = set; then
8792   echo $ECHO_N "(cached) $ECHO_C" >&6
8793 else
8794   ac_check_lib_save_LIBS=$LIBS
8795 LIBS="-lm  $LIBS"
8796 if test x$gcc_no_link = xyes; then
8797   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8798 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8799    { (exit 1); exit 1; }; }
8800 fi
8801 cat >conftest.$ac_ext <<_ACEOF
8802 /* confdefs.h.  */
8803 _ACEOF
8804 cat confdefs.h >>conftest.$ac_ext
8805 cat >>conftest.$ac_ext <<_ACEOF
8806 /* end confdefs.h.  */
8807
8808 /* Override any gcc2 internal prototype to avoid an error.  */
8809 #ifdef __cplusplus
8810 extern "C"
8811 #endif
8812 /* We use char because int might match the return type of a gcc2
8813    builtin and then its argument prototype would still apply.  */
8814 char atan2f ();
8815 int
8816 main ()
8817 {
8818 atan2f ();
8819   ;
8820   return 0;
8821 }
8822 _ACEOF
8823 rm -f conftest.$ac_objext conftest$ac_exeext
8824 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8825   (eval $ac_link) 2>conftest.er1
8826   ac_status=$?
8827   grep -v '^ *+' conftest.er1 >conftest.err
8828   rm -f conftest.er1
8829   cat conftest.err >&5
8830   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8831   (exit $ac_status); } &&
8832          { ac_try='test -z "$ac_c_werror_flag"
8833                          || test ! -s conftest.err'
8834   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8835   (eval $ac_try) 2>&5
8836   ac_status=$?
8837   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8838   (exit $ac_status); }; } &&
8839          { ac_try='test -s conftest$ac_exeext'
8840   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8841   (eval $ac_try) 2>&5
8842   ac_status=$?
8843   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8844   (exit $ac_status); }; }; then
8845   ac_cv_lib_m_atan2f=yes
8846 else
8847   echo "$as_me: failed program was:" >&5
8848 sed 's/^/| /' conftest.$ac_ext >&5
8849
8850 ac_cv_lib_m_atan2f=no
8851 fi
8852 rm -f conftest.err conftest.$ac_objext \
8853       conftest$ac_exeext conftest.$ac_ext
8854 LIBS=$ac_check_lib_save_LIBS
8855 fi
8856 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2f" >&5
8857 echo "${ECHO_T}$ac_cv_lib_m_atan2f" >&6
8858 if test $ac_cv_lib_m_atan2f = yes; then
8859
8860 cat >>confdefs.h <<\_ACEOF
8861 #define HAVE_ATAN2F 1
8862 _ACEOF
8863
8864 fi
8865
8866 echo "$as_me:$LINENO: checking for atan2 in -lm" >&5
8867 echo $ECHO_N "checking for atan2 in -lm... $ECHO_C" >&6
8868 if test "${ac_cv_lib_m_atan2+set}" = set; then
8869   echo $ECHO_N "(cached) $ECHO_C" >&6
8870 else
8871   ac_check_lib_save_LIBS=$LIBS
8872 LIBS="-lm  $LIBS"
8873 if test x$gcc_no_link = xyes; then
8874   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8875 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8876    { (exit 1); exit 1; }; }
8877 fi
8878 cat >conftest.$ac_ext <<_ACEOF
8879 /* confdefs.h.  */
8880 _ACEOF
8881 cat confdefs.h >>conftest.$ac_ext
8882 cat >>conftest.$ac_ext <<_ACEOF
8883 /* end confdefs.h.  */
8884
8885 /* Override any gcc2 internal prototype to avoid an error.  */
8886 #ifdef __cplusplus
8887 extern "C"
8888 #endif
8889 /* We use char because int might match the return type of a gcc2
8890    builtin and then its argument prototype would still apply.  */
8891 char atan2 ();
8892 int
8893 main ()
8894 {
8895 atan2 ();
8896   ;
8897   return 0;
8898 }
8899 _ACEOF
8900 rm -f conftest.$ac_objext conftest$ac_exeext
8901 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8902   (eval $ac_link) 2>conftest.er1
8903   ac_status=$?
8904   grep -v '^ *+' conftest.er1 >conftest.err
8905   rm -f conftest.er1
8906   cat conftest.err >&5
8907   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8908   (exit $ac_status); } &&
8909          { ac_try='test -z "$ac_c_werror_flag"
8910                          || test ! -s conftest.err'
8911   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8912   (eval $ac_try) 2>&5
8913   ac_status=$?
8914   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8915   (exit $ac_status); }; } &&
8916          { ac_try='test -s conftest$ac_exeext'
8917   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8918   (eval $ac_try) 2>&5
8919   ac_status=$?
8920   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8921   (exit $ac_status); }; }; then
8922   ac_cv_lib_m_atan2=yes
8923 else
8924   echo "$as_me: failed program was:" >&5
8925 sed 's/^/| /' conftest.$ac_ext >&5
8926
8927 ac_cv_lib_m_atan2=no
8928 fi
8929 rm -f conftest.err conftest.$ac_objext \
8930       conftest$ac_exeext conftest.$ac_ext
8931 LIBS=$ac_check_lib_save_LIBS
8932 fi
8933 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2" >&5
8934 echo "${ECHO_T}$ac_cv_lib_m_atan2" >&6
8935 if test $ac_cv_lib_m_atan2 = yes; then
8936
8937 cat >>confdefs.h <<\_ACEOF
8938 #define HAVE_ATAN2 1
8939 _ACEOF
8940
8941 fi
8942
8943 echo "$as_me:$LINENO: checking for atan2l in -lm" >&5
8944 echo $ECHO_N "checking for atan2l in -lm... $ECHO_C" >&6
8945 if test "${ac_cv_lib_m_atan2l+set}" = set; then
8946   echo $ECHO_N "(cached) $ECHO_C" >&6
8947 else
8948   ac_check_lib_save_LIBS=$LIBS
8949 LIBS="-lm  $LIBS"
8950 if test x$gcc_no_link = xyes; then
8951   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8952 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8953    { (exit 1); exit 1; }; }
8954 fi
8955 cat >conftest.$ac_ext <<_ACEOF
8956 /* confdefs.h.  */
8957 _ACEOF
8958 cat confdefs.h >>conftest.$ac_ext
8959 cat >>conftest.$ac_ext <<_ACEOF
8960 /* end confdefs.h.  */
8961
8962 /* Override any gcc2 internal prototype to avoid an error.  */
8963 #ifdef __cplusplus
8964 extern "C"
8965 #endif
8966 /* We use char because int might match the return type of a gcc2
8967    builtin and then its argument prototype would still apply.  */
8968 char atan2l ();
8969 int
8970 main ()
8971 {
8972 atan2l ();
8973   ;
8974   return 0;
8975 }
8976 _ACEOF
8977 rm -f conftest.$ac_objext conftest$ac_exeext
8978 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8979   (eval $ac_link) 2>conftest.er1
8980   ac_status=$?
8981   grep -v '^ *+' conftest.er1 >conftest.err
8982   rm -f conftest.er1
8983   cat conftest.err >&5
8984   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8985   (exit $ac_status); } &&
8986          { ac_try='test -z "$ac_c_werror_flag"
8987                          || test ! -s conftest.err'
8988   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8989   (eval $ac_try) 2>&5
8990   ac_status=$?
8991   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8992   (exit $ac_status); }; } &&
8993          { ac_try='test -s conftest$ac_exeext'
8994   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8995   (eval $ac_try) 2>&5
8996   ac_status=$?
8997   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8998   (exit $ac_status); }; }; then
8999   ac_cv_lib_m_atan2l=yes
9000 else
9001   echo "$as_me: failed program was:" >&5
9002 sed 's/^/| /' conftest.$ac_ext >&5
9003
9004 ac_cv_lib_m_atan2l=no
9005 fi
9006 rm -f conftest.err conftest.$ac_objext \
9007       conftest$ac_exeext conftest.$ac_ext
9008 LIBS=$ac_check_lib_save_LIBS
9009 fi
9010 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2l" >&5
9011 echo "${ECHO_T}$ac_cv_lib_m_atan2l" >&6
9012 if test $ac_cv_lib_m_atan2l = yes; then
9013
9014 cat >>confdefs.h <<\_ACEOF
9015 #define HAVE_ATAN2L 1
9016 _ACEOF
9017
9018 fi
9019
9020 echo "$as_me:$LINENO: checking for atanf in -lm" >&5
9021 echo $ECHO_N "checking for atanf in -lm... $ECHO_C" >&6
9022 if test "${ac_cv_lib_m_atanf+set}" = set; then
9023   echo $ECHO_N "(cached) $ECHO_C" >&6
9024 else
9025   ac_check_lib_save_LIBS=$LIBS
9026 LIBS="-lm  $LIBS"
9027 if test x$gcc_no_link = xyes; then
9028   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9029 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9030    { (exit 1); exit 1; }; }
9031 fi
9032 cat >conftest.$ac_ext <<_ACEOF
9033 /* confdefs.h.  */
9034 _ACEOF
9035 cat confdefs.h >>conftest.$ac_ext
9036 cat >>conftest.$ac_ext <<_ACEOF
9037 /* end confdefs.h.  */
9038
9039 /* Override any gcc2 internal prototype to avoid an error.  */
9040 #ifdef __cplusplus
9041 extern "C"
9042 #endif
9043 /* We use char because int might match the return type of a gcc2
9044    builtin and then its argument prototype would still apply.  */
9045 char atanf ();
9046 int
9047 main ()
9048 {
9049 atanf ();
9050   ;
9051   return 0;
9052 }
9053 _ACEOF
9054 rm -f conftest.$ac_objext conftest$ac_exeext
9055 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9056   (eval $ac_link) 2>conftest.er1
9057   ac_status=$?
9058   grep -v '^ *+' conftest.er1 >conftest.err
9059   rm -f conftest.er1
9060   cat conftest.err >&5
9061   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9062   (exit $ac_status); } &&
9063          { ac_try='test -z "$ac_c_werror_flag"
9064                          || test ! -s conftest.err'
9065   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9066   (eval $ac_try) 2>&5
9067   ac_status=$?
9068   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9069   (exit $ac_status); }; } &&
9070          { ac_try='test -s conftest$ac_exeext'
9071   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9072   (eval $ac_try) 2>&5
9073   ac_status=$?
9074   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9075   (exit $ac_status); }; }; then
9076   ac_cv_lib_m_atanf=yes
9077 else
9078   echo "$as_me: failed program was:" >&5
9079 sed 's/^/| /' conftest.$ac_ext >&5
9080
9081 ac_cv_lib_m_atanf=no
9082 fi
9083 rm -f conftest.err conftest.$ac_objext \
9084       conftest$ac_exeext conftest.$ac_ext
9085 LIBS=$ac_check_lib_save_LIBS
9086 fi
9087 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanf" >&5
9088 echo "${ECHO_T}$ac_cv_lib_m_atanf" >&6
9089 if test $ac_cv_lib_m_atanf = yes; then
9090
9091 cat >>confdefs.h <<\_ACEOF
9092 #define HAVE_ATANF 1
9093 _ACEOF
9094
9095 fi
9096
9097 echo "$as_me:$LINENO: checking for atan in -lm" >&5
9098 echo $ECHO_N "checking for atan in -lm... $ECHO_C" >&6
9099 if test "${ac_cv_lib_m_atan+set}" = set; then
9100   echo $ECHO_N "(cached) $ECHO_C" >&6
9101 else
9102   ac_check_lib_save_LIBS=$LIBS
9103 LIBS="-lm  $LIBS"
9104 if test x$gcc_no_link = xyes; then
9105   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9106 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9107    { (exit 1); exit 1; }; }
9108 fi
9109 cat >conftest.$ac_ext <<_ACEOF
9110 /* confdefs.h.  */
9111 _ACEOF
9112 cat confdefs.h >>conftest.$ac_ext
9113 cat >>conftest.$ac_ext <<_ACEOF
9114 /* end confdefs.h.  */
9115
9116 /* Override any gcc2 internal prototype to avoid an error.  */
9117 #ifdef __cplusplus
9118 extern "C"
9119 #endif
9120 /* We use char because int might match the return type of a gcc2
9121    builtin and then its argument prototype would still apply.  */
9122 char atan ();
9123 int
9124 main ()
9125 {
9126 atan ();
9127   ;
9128   return 0;
9129 }
9130 _ACEOF
9131 rm -f conftest.$ac_objext conftest$ac_exeext
9132 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9133   (eval $ac_link) 2>conftest.er1
9134   ac_status=$?
9135   grep -v '^ *+' conftest.er1 >conftest.err
9136   rm -f conftest.er1
9137   cat conftest.err >&5
9138   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9139   (exit $ac_status); } &&
9140          { ac_try='test -z "$ac_c_werror_flag"
9141                          || test ! -s conftest.err'
9142   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9143   (eval $ac_try) 2>&5
9144   ac_status=$?
9145   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9146   (exit $ac_status); }; } &&
9147          { ac_try='test -s conftest$ac_exeext'
9148   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9149   (eval $ac_try) 2>&5
9150   ac_status=$?
9151   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9152   (exit $ac_status); }; }; then
9153   ac_cv_lib_m_atan=yes
9154 else
9155   echo "$as_me: failed program was:" >&5
9156 sed 's/^/| /' conftest.$ac_ext >&5
9157
9158 ac_cv_lib_m_atan=no
9159 fi
9160 rm -f conftest.err conftest.$ac_objext \
9161       conftest$ac_exeext conftest.$ac_ext
9162 LIBS=$ac_check_lib_save_LIBS
9163 fi
9164 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan" >&5
9165 echo "${ECHO_T}$ac_cv_lib_m_atan" >&6
9166 if test $ac_cv_lib_m_atan = yes; then
9167
9168 cat >>confdefs.h <<\_ACEOF
9169 #define HAVE_ATAN 1
9170 _ACEOF
9171
9172 fi
9173
9174 echo "$as_me:$LINENO: checking for atanl in -lm" >&5
9175 echo $ECHO_N "checking for atanl in -lm... $ECHO_C" >&6
9176 if test "${ac_cv_lib_m_atanl+set}" = set; then
9177   echo $ECHO_N "(cached) $ECHO_C" >&6
9178 else
9179   ac_check_lib_save_LIBS=$LIBS
9180 LIBS="-lm  $LIBS"
9181 if test x$gcc_no_link = xyes; then
9182   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9183 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9184    { (exit 1); exit 1; }; }
9185 fi
9186 cat >conftest.$ac_ext <<_ACEOF
9187 /* confdefs.h.  */
9188 _ACEOF
9189 cat confdefs.h >>conftest.$ac_ext
9190 cat >>conftest.$ac_ext <<_ACEOF
9191 /* end confdefs.h.  */
9192
9193 /* Override any gcc2 internal prototype to avoid an error.  */
9194 #ifdef __cplusplus
9195 extern "C"
9196 #endif
9197 /* We use char because int might match the return type of a gcc2
9198    builtin and then its argument prototype would still apply.  */
9199 char atanl ();
9200 int
9201 main ()
9202 {
9203 atanl ();
9204   ;
9205   return 0;
9206 }
9207 _ACEOF
9208 rm -f conftest.$ac_objext conftest$ac_exeext
9209 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9210   (eval $ac_link) 2>conftest.er1
9211   ac_status=$?
9212   grep -v '^ *+' conftest.er1 >conftest.err
9213   rm -f conftest.er1
9214   cat conftest.err >&5
9215   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9216   (exit $ac_status); } &&
9217          { ac_try='test -z "$ac_c_werror_flag"
9218                          || test ! -s conftest.err'
9219   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9220   (eval $ac_try) 2>&5
9221   ac_status=$?
9222   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9223   (exit $ac_status); }; } &&
9224          { ac_try='test -s conftest$ac_exeext'
9225   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9226   (eval $ac_try) 2>&5
9227   ac_status=$?
9228   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9229   (exit $ac_status); }; }; then
9230   ac_cv_lib_m_atanl=yes
9231 else
9232   echo "$as_me: failed program was:" >&5
9233 sed 's/^/| /' conftest.$ac_ext >&5
9234
9235 ac_cv_lib_m_atanl=no
9236 fi
9237 rm -f conftest.err conftest.$ac_objext \
9238       conftest$ac_exeext conftest.$ac_ext
9239 LIBS=$ac_check_lib_save_LIBS
9240 fi
9241 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanl" >&5
9242 echo "${ECHO_T}$ac_cv_lib_m_atanl" >&6
9243 if test $ac_cv_lib_m_atanl = yes; then
9244
9245 cat >>confdefs.h <<\_ACEOF
9246 #define HAVE_ATANL 1
9247 _ACEOF
9248
9249 fi
9250
9251 echo "$as_me:$LINENO: checking for atanhf in -lm" >&5
9252 echo $ECHO_N "checking for atanhf in -lm... $ECHO_C" >&6
9253 if test "${ac_cv_lib_m_atanhf+set}" = set; then
9254   echo $ECHO_N "(cached) $ECHO_C" >&6
9255 else
9256   ac_check_lib_save_LIBS=$LIBS
9257 LIBS="-lm  $LIBS"
9258 if test x$gcc_no_link = xyes; then
9259   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9260 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9261    { (exit 1); exit 1; }; }
9262 fi
9263 cat >conftest.$ac_ext <<_ACEOF
9264 /* confdefs.h.  */
9265 _ACEOF
9266 cat confdefs.h >>conftest.$ac_ext
9267 cat >>conftest.$ac_ext <<_ACEOF
9268 /* end confdefs.h.  */
9269
9270 /* Override any gcc2 internal prototype to avoid an error.  */
9271 #ifdef __cplusplus
9272 extern "C"
9273 #endif
9274 /* We use char because int might match the return type of a gcc2
9275    builtin and then its argument prototype would still apply.  */
9276 char atanhf ();
9277 int
9278 main ()
9279 {
9280 atanhf ();
9281   ;
9282   return 0;
9283 }
9284 _ACEOF
9285 rm -f conftest.$ac_objext conftest$ac_exeext
9286 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9287   (eval $ac_link) 2>conftest.er1
9288   ac_status=$?
9289   grep -v '^ *+' conftest.er1 >conftest.err
9290   rm -f conftest.er1
9291   cat conftest.err >&5
9292   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9293   (exit $ac_status); } &&
9294          { ac_try='test -z "$ac_c_werror_flag"
9295                          || test ! -s conftest.err'
9296   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9297   (eval $ac_try) 2>&5
9298   ac_status=$?
9299   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9300   (exit $ac_status); }; } &&
9301          { ac_try='test -s conftest$ac_exeext'
9302   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9303   (eval $ac_try) 2>&5
9304   ac_status=$?
9305   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9306   (exit $ac_status); }; }; then
9307   ac_cv_lib_m_atanhf=yes
9308 else
9309   echo "$as_me: failed program was:" >&5
9310 sed 's/^/| /' conftest.$ac_ext >&5
9311
9312 ac_cv_lib_m_atanhf=no
9313 fi
9314 rm -f conftest.err conftest.$ac_objext \
9315       conftest$ac_exeext conftest.$ac_ext
9316 LIBS=$ac_check_lib_save_LIBS
9317 fi
9318 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanhf" >&5
9319 echo "${ECHO_T}$ac_cv_lib_m_atanhf" >&6
9320 if test $ac_cv_lib_m_atanhf = yes; then
9321
9322 cat >>confdefs.h <<\_ACEOF
9323 #define HAVE_ATANHF 1
9324 _ACEOF
9325
9326 fi
9327
9328 echo "$as_me:$LINENO: checking for atanh in -lm" >&5
9329 echo $ECHO_N "checking for atanh in -lm... $ECHO_C" >&6
9330 if test "${ac_cv_lib_m_atanh+set}" = set; then
9331   echo $ECHO_N "(cached) $ECHO_C" >&6
9332 else
9333   ac_check_lib_save_LIBS=$LIBS
9334 LIBS="-lm  $LIBS"
9335 if test x$gcc_no_link = xyes; then
9336   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9337 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9338    { (exit 1); exit 1; }; }
9339 fi
9340 cat >conftest.$ac_ext <<_ACEOF
9341 /* confdefs.h.  */
9342 _ACEOF
9343 cat confdefs.h >>conftest.$ac_ext
9344 cat >>conftest.$ac_ext <<_ACEOF
9345 /* end confdefs.h.  */
9346
9347 /* Override any gcc2 internal prototype to avoid an error.  */
9348 #ifdef __cplusplus
9349 extern "C"
9350 #endif
9351 /* We use char because int might match the return type of a gcc2
9352    builtin and then its argument prototype would still apply.  */
9353 char atanh ();
9354 int
9355 main ()
9356 {
9357 atanh ();
9358   ;
9359   return 0;
9360 }
9361 _ACEOF
9362 rm -f conftest.$ac_objext conftest$ac_exeext
9363 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9364   (eval $ac_link) 2>conftest.er1
9365   ac_status=$?
9366   grep -v '^ *+' conftest.er1 >conftest.err
9367   rm -f conftest.er1
9368   cat conftest.err >&5
9369   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9370   (exit $ac_status); } &&
9371          { ac_try='test -z "$ac_c_werror_flag"
9372                          || test ! -s conftest.err'
9373   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9374   (eval $ac_try) 2>&5
9375   ac_status=$?
9376   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9377   (exit $ac_status); }; } &&
9378          { ac_try='test -s conftest$ac_exeext'
9379   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9380   (eval $ac_try) 2>&5
9381   ac_status=$?
9382   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9383   (exit $ac_status); }; }; then
9384   ac_cv_lib_m_atanh=yes
9385 else
9386   echo "$as_me: failed program was:" >&5
9387 sed 's/^/| /' conftest.$ac_ext >&5
9388
9389 ac_cv_lib_m_atanh=no
9390 fi
9391 rm -f conftest.err conftest.$ac_objext \
9392       conftest$ac_exeext conftest.$ac_ext
9393 LIBS=$ac_check_lib_save_LIBS
9394 fi
9395 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanh" >&5
9396 echo "${ECHO_T}$ac_cv_lib_m_atanh" >&6
9397 if test $ac_cv_lib_m_atanh = yes; then
9398
9399 cat >>confdefs.h <<\_ACEOF
9400 #define HAVE_ATANH 1
9401 _ACEOF
9402
9403 fi
9404
9405 echo "$as_me:$LINENO: checking for atanhl in -lm" >&5
9406 echo $ECHO_N "checking for atanhl in -lm... $ECHO_C" >&6
9407 if test "${ac_cv_lib_m_atanhl+set}" = set; then
9408   echo $ECHO_N "(cached) $ECHO_C" >&6
9409 else
9410   ac_check_lib_save_LIBS=$LIBS
9411 LIBS="-lm  $LIBS"
9412 if test x$gcc_no_link = xyes; then
9413   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9414 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9415    { (exit 1); exit 1; }; }
9416 fi
9417 cat >conftest.$ac_ext <<_ACEOF
9418 /* confdefs.h.  */
9419 _ACEOF
9420 cat confdefs.h >>conftest.$ac_ext
9421 cat >>conftest.$ac_ext <<_ACEOF
9422 /* end confdefs.h.  */
9423
9424 /* Override any gcc2 internal prototype to avoid an error.  */
9425 #ifdef __cplusplus
9426 extern "C"
9427 #endif
9428 /* We use char because int might match the return type of a gcc2
9429    builtin and then its argument prototype would still apply.  */
9430 char atanhl ();
9431 int
9432 main ()
9433 {
9434 atanhl ();
9435   ;
9436   return 0;
9437 }
9438 _ACEOF
9439 rm -f conftest.$ac_objext conftest$ac_exeext
9440 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9441   (eval $ac_link) 2>conftest.er1
9442   ac_status=$?
9443   grep -v '^ *+' conftest.er1 >conftest.err
9444   rm -f conftest.er1
9445   cat conftest.err >&5
9446   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9447   (exit $ac_status); } &&
9448          { ac_try='test -z "$ac_c_werror_flag"
9449                          || test ! -s conftest.err'
9450   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9451   (eval $ac_try) 2>&5
9452   ac_status=$?
9453   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9454   (exit $ac_status); }; } &&
9455          { ac_try='test -s conftest$ac_exeext'
9456   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9457   (eval $ac_try) 2>&5
9458   ac_status=$?
9459   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9460   (exit $ac_status); }; }; then
9461   ac_cv_lib_m_atanhl=yes
9462 else
9463   echo "$as_me: failed program was:" >&5
9464 sed 's/^/| /' conftest.$ac_ext >&5
9465
9466 ac_cv_lib_m_atanhl=no
9467 fi
9468 rm -f conftest.err conftest.$ac_objext \
9469       conftest$ac_exeext conftest.$ac_ext
9470 LIBS=$ac_check_lib_save_LIBS
9471 fi
9472 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanhl" >&5
9473 echo "${ECHO_T}$ac_cv_lib_m_atanhl" >&6
9474 if test $ac_cv_lib_m_atanhl = yes; then
9475
9476 cat >>confdefs.h <<\_ACEOF
9477 #define HAVE_ATANHL 1
9478 _ACEOF
9479
9480 fi
9481
9482 echo "$as_me:$LINENO: checking for cargf in -lm" >&5
9483 echo $ECHO_N "checking for cargf in -lm... $ECHO_C" >&6
9484 if test "${ac_cv_lib_m_cargf+set}" = set; then
9485   echo $ECHO_N "(cached) $ECHO_C" >&6
9486 else
9487   ac_check_lib_save_LIBS=$LIBS
9488 LIBS="-lm  $LIBS"
9489 if test x$gcc_no_link = xyes; then
9490   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9491 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9492    { (exit 1); exit 1; }; }
9493 fi
9494 cat >conftest.$ac_ext <<_ACEOF
9495 /* confdefs.h.  */
9496 _ACEOF
9497 cat confdefs.h >>conftest.$ac_ext
9498 cat >>conftest.$ac_ext <<_ACEOF
9499 /* end confdefs.h.  */
9500
9501 /* Override any gcc2 internal prototype to avoid an error.  */
9502 #ifdef __cplusplus
9503 extern "C"
9504 #endif
9505 /* We use char because int might match the return type of a gcc2
9506    builtin and then its argument prototype would still apply.  */
9507 char cargf ();
9508 int
9509 main ()
9510 {
9511 cargf ();
9512   ;
9513   return 0;
9514 }
9515 _ACEOF
9516 rm -f conftest.$ac_objext conftest$ac_exeext
9517 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9518   (eval $ac_link) 2>conftest.er1
9519   ac_status=$?
9520   grep -v '^ *+' conftest.er1 >conftest.err
9521   rm -f conftest.er1
9522   cat conftest.err >&5
9523   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9524   (exit $ac_status); } &&
9525          { ac_try='test -z "$ac_c_werror_flag"
9526                          || test ! -s conftest.err'
9527   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9528   (eval $ac_try) 2>&5
9529   ac_status=$?
9530   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9531   (exit $ac_status); }; } &&
9532          { ac_try='test -s conftest$ac_exeext'
9533   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9534   (eval $ac_try) 2>&5
9535   ac_status=$?
9536   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9537   (exit $ac_status); }; }; then
9538   ac_cv_lib_m_cargf=yes
9539 else
9540   echo "$as_me: failed program was:" >&5
9541 sed 's/^/| /' conftest.$ac_ext >&5
9542
9543 ac_cv_lib_m_cargf=no
9544 fi
9545 rm -f conftest.err conftest.$ac_objext \
9546       conftest$ac_exeext conftest.$ac_ext
9547 LIBS=$ac_check_lib_save_LIBS
9548 fi
9549 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cargf" >&5
9550 echo "${ECHO_T}$ac_cv_lib_m_cargf" >&6
9551 if test $ac_cv_lib_m_cargf = yes; then
9552
9553 cat >>confdefs.h <<\_ACEOF
9554 #define HAVE_CARGF 1
9555 _ACEOF
9556
9557 fi
9558
9559 echo "$as_me:$LINENO: checking for carg in -lm" >&5
9560 echo $ECHO_N "checking for carg in -lm... $ECHO_C" >&6
9561 if test "${ac_cv_lib_m_carg+set}" = set; then
9562   echo $ECHO_N "(cached) $ECHO_C" >&6
9563 else
9564   ac_check_lib_save_LIBS=$LIBS
9565 LIBS="-lm  $LIBS"
9566 if test x$gcc_no_link = xyes; then
9567   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9568 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9569    { (exit 1); exit 1; }; }
9570 fi
9571 cat >conftest.$ac_ext <<_ACEOF
9572 /* confdefs.h.  */
9573 _ACEOF
9574 cat confdefs.h >>conftest.$ac_ext
9575 cat >>conftest.$ac_ext <<_ACEOF
9576 /* end confdefs.h.  */
9577
9578 /* Override any gcc2 internal prototype to avoid an error.  */
9579 #ifdef __cplusplus
9580 extern "C"
9581 #endif
9582 /* We use char because int might match the return type of a gcc2
9583    builtin and then its argument prototype would still apply.  */
9584 char carg ();
9585 int
9586 main ()
9587 {
9588 carg ();
9589   ;
9590   return 0;
9591 }
9592 _ACEOF
9593 rm -f conftest.$ac_objext conftest$ac_exeext
9594 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9595   (eval $ac_link) 2>conftest.er1
9596   ac_status=$?
9597   grep -v '^ *+' conftest.er1 >conftest.err
9598   rm -f conftest.er1
9599   cat conftest.err >&5
9600   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9601   (exit $ac_status); } &&
9602          { ac_try='test -z "$ac_c_werror_flag"
9603                          || test ! -s conftest.err'
9604   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9605   (eval $ac_try) 2>&5
9606   ac_status=$?
9607   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9608   (exit $ac_status); }; } &&
9609          { ac_try='test -s conftest$ac_exeext'
9610   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9611   (eval $ac_try) 2>&5
9612   ac_status=$?
9613   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9614   (exit $ac_status); }; }; then
9615   ac_cv_lib_m_carg=yes
9616 else
9617   echo "$as_me: failed program was:" >&5
9618 sed 's/^/| /' conftest.$ac_ext >&5
9619
9620 ac_cv_lib_m_carg=no
9621 fi
9622 rm -f conftest.err conftest.$ac_objext \
9623       conftest$ac_exeext conftest.$ac_ext
9624 LIBS=$ac_check_lib_save_LIBS
9625 fi
9626 echo "$as_me:$LINENO: result: $ac_cv_lib_m_carg" >&5
9627 echo "${ECHO_T}$ac_cv_lib_m_carg" >&6
9628 if test $ac_cv_lib_m_carg = yes; then
9629
9630 cat >>confdefs.h <<\_ACEOF
9631 #define HAVE_CARG 1
9632 _ACEOF
9633
9634 fi
9635
9636 echo "$as_me:$LINENO: checking for cargl in -lm" >&5
9637 echo $ECHO_N "checking for cargl in -lm... $ECHO_C" >&6
9638 if test "${ac_cv_lib_m_cargl+set}" = set; then
9639   echo $ECHO_N "(cached) $ECHO_C" >&6
9640 else
9641   ac_check_lib_save_LIBS=$LIBS
9642 LIBS="-lm  $LIBS"
9643 if test x$gcc_no_link = xyes; then
9644   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9645 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9646    { (exit 1); exit 1; }; }
9647 fi
9648 cat >conftest.$ac_ext <<_ACEOF
9649 /* confdefs.h.  */
9650 _ACEOF
9651 cat confdefs.h >>conftest.$ac_ext
9652 cat >>conftest.$ac_ext <<_ACEOF
9653 /* end confdefs.h.  */
9654
9655 /* Override any gcc2 internal prototype to avoid an error.  */
9656 #ifdef __cplusplus
9657 extern "C"
9658 #endif
9659 /* We use char because int might match the return type of a gcc2
9660    builtin and then its argument prototype would still apply.  */
9661 char cargl ();
9662 int
9663 main ()
9664 {
9665 cargl ();
9666   ;
9667   return 0;
9668 }
9669 _ACEOF
9670 rm -f conftest.$ac_objext conftest$ac_exeext
9671 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9672   (eval $ac_link) 2>conftest.er1
9673   ac_status=$?
9674   grep -v '^ *+' conftest.er1 >conftest.err
9675   rm -f conftest.er1
9676   cat conftest.err >&5
9677   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9678   (exit $ac_status); } &&
9679          { ac_try='test -z "$ac_c_werror_flag"
9680                          || test ! -s conftest.err'
9681   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9682   (eval $ac_try) 2>&5
9683   ac_status=$?
9684   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9685   (exit $ac_status); }; } &&
9686          { ac_try='test -s conftest$ac_exeext'
9687   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9688   (eval $ac_try) 2>&5
9689   ac_status=$?
9690   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9691   (exit $ac_status); }; }; then
9692   ac_cv_lib_m_cargl=yes
9693 else
9694   echo "$as_me: failed program was:" >&5
9695 sed 's/^/| /' conftest.$ac_ext >&5
9696
9697 ac_cv_lib_m_cargl=no
9698 fi
9699 rm -f conftest.err conftest.$ac_objext \
9700       conftest$ac_exeext conftest.$ac_ext
9701 LIBS=$ac_check_lib_save_LIBS
9702 fi
9703 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cargl" >&5
9704 echo "${ECHO_T}$ac_cv_lib_m_cargl" >&6
9705 if test $ac_cv_lib_m_cargl = yes; then
9706
9707 cat >>confdefs.h <<\_ACEOF
9708 #define HAVE_CARGL 1
9709 _ACEOF
9710
9711 fi
9712
9713 echo "$as_me:$LINENO: checking for ceilf in -lm" >&5
9714 echo $ECHO_N "checking for ceilf in -lm... $ECHO_C" >&6
9715 if test "${ac_cv_lib_m_ceilf+set}" = set; then
9716   echo $ECHO_N "(cached) $ECHO_C" >&6
9717 else
9718   ac_check_lib_save_LIBS=$LIBS
9719 LIBS="-lm  $LIBS"
9720 if test x$gcc_no_link = xyes; then
9721   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9722 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9723    { (exit 1); exit 1; }; }
9724 fi
9725 cat >conftest.$ac_ext <<_ACEOF
9726 /* confdefs.h.  */
9727 _ACEOF
9728 cat confdefs.h >>conftest.$ac_ext
9729 cat >>conftest.$ac_ext <<_ACEOF
9730 /* end confdefs.h.  */
9731
9732 /* Override any gcc2 internal prototype to avoid an error.  */
9733 #ifdef __cplusplus
9734 extern "C"
9735 #endif
9736 /* We use char because int might match the return type of a gcc2
9737    builtin and then its argument prototype would still apply.  */
9738 char ceilf ();
9739 int
9740 main ()
9741 {
9742 ceilf ();
9743   ;
9744   return 0;
9745 }
9746 _ACEOF
9747 rm -f conftest.$ac_objext conftest$ac_exeext
9748 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9749   (eval $ac_link) 2>conftest.er1
9750   ac_status=$?
9751   grep -v '^ *+' conftest.er1 >conftest.err
9752   rm -f conftest.er1
9753   cat conftest.err >&5
9754   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9755   (exit $ac_status); } &&
9756          { ac_try='test -z "$ac_c_werror_flag"
9757                          || test ! -s conftest.err'
9758   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9759   (eval $ac_try) 2>&5
9760   ac_status=$?
9761   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9762   (exit $ac_status); }; } &&
9763          { ac_try='test -s conftest$ac_exeext'
9764   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9765   (eval $ac_try) 2>&5
9766   ac_status=$?
9767   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9768   (exit $ac_status); }; }; then
9769   ac_cv_lib_m_ceilf=yes
9770 else
9771   echo "$as_me: failed program was:" >&5
9772 sed 's/^/| /' conftest.$ac_ext >&5
9773
9774 ac_cv_lib_m_ceilf=no
9775 fi
9776 rm -f conftest.err conftest.$ac_objext \
9777       conftest$ac_exeext conftest.$ac_ext
9778 LIBS=$ac_check_lib_save_LIBS
9779 fi
9780 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceilf" >&5
9781 echo "${ECHO_T}$ac_cv_lib_m_ceilf" >&6
9782 if test $ac_cv_lib_m_ceilf = yes; then
9783
9784 cat >>confdefs.h <<\_ACEOF
9785 #define HAVE_CEILF 1
9786 _ACEOF
9787
9788 fi
9789
9790 echo "$as_me:$LINENO: checking for ceil in -lm" >&5
9791 echo $ECHO_N "checking for ceil in -lm... $ECHO_C" >&6
9792 if test "${ac_cv_lib_m_ceil+set}" = set; then
9793   echo $ECHO_N "(cached) $ECHO_C" >&6
9794 else
9795   ac_check_lib_save_LIBS=$LIBS
9796 LIBS="-lm  $LIBS"
9797 if test x$gcc_no_link = xyes; then
9798   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9799 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9800    { (exit 1); exit 1; }; }
9801 fi
9802 cat >conftest.$ac_ext <<_ACEOF
9803 /* confdefs.h.  */
9804 _ACEOF
9805 cat confdefs.h >>conftest.$ac_ext
9806 cat >>conftest.$ac_ext <<_ACEOF
9807 /* end confdefs.h.  */
9808
9809 /* Override any gcc2 internal prototype to avoid an error.  */
9810 #ifdef __cplusplus
9811 extern "C"
9812 #endif
9813 /* We use char because int might match the return type of a gcc2
9814    builtin and then its argument prototype would still apply.  */
9815 char ceil ();
9816 int
9817 main ()
9818 {
9819 ceil ();
9820   ;
9821   return 0;
9822 }
9823 _ACEOF
9824 rm -f conftest.$ac_objext conftest$ac_exeext
9825 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9826   (eval $ac_link) 2>conftest.er1
9827   ac_status=$?
9828   grep -v '^ *+' conftest.er1 >conftest.err
9829   rm -f conftest.er1
9830   cat conftest.err >&5
9831   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9832   (exit $ac_status); } &&
9833          { ac_try='test -z "$ac_c_werror_flag"
9834                          || test ! -s conftest.err'
9835   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9836   (eval $ac_try) 2>&5
9837   ac_status=$?
9838   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9839   (exit $ac_status); }; } &&
9840          { ac_try='test -s conftest$ac_exeext'
9841   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9842   (eval $ac_try) 2>&5
9843   ac_status=$?
9844   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9845   (exit $ac_status); }; }; then
9846   ac_cv_lib_m_ceil=yes
9847 else
9848   echo "$as_me: failed program was:" >&5
9849 sed 's/^/| /' conftest.$ac_ext >&5
9850
9851 ac_cv_lib_m_ceil=no
9852 fi
9853 rm -f conftest.err conftest.$ac_objext \
9854       conftest$ac_exeext conftest.$ac_ext
9855 LIBS=$ac_check_lib_save_LIBS
9856 fi
9857 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceil" >&5
9858 echo "${ECHO_T}$ac_cv_lib_m_ceil" >&6
9859 if test $ac_cv_lib_m_ceil = yes; then
9860
9861 cat >>confdefs.h <<\_ACEOF
9862 #define HAVE_CEIL 1
9863 _ACEOF
9864
9865 fi
9866
9867 echo "$as_me:$LINENO: checking for ceill in -lm" >&5
9868 echo $ECHO_N "checking for ceill in -lm... $ECHO_C" >&6
9869 if test "${ac_cv_lib_m_ceill+set}" = set; then
9870   echo $ECHO_N "(cached) $ECHO_C" >&6
9871 else
9872   ac_check_lib_save_LIBS=$LIBS
9873 LIBS="-lm  $LIBS"
9874 if test x$gcc_no_link = xyes; then
9875   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9876 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9877    { (exit 1); exit 1; }; }
9878 fi
9879 cat >conftest.$ac_ext <<_ACEOF
9880 /* confdefs.h.  */
9881 _ACEOF
9882 cat confdefs.h >>conftest.$ac_ext
9883 cat >>conftest.$ac_ext <<_ACEOF
9884 /* end confdefs.h.  */
9885
9886 /* Override any gcc2 internal prototype to avoid an error.  */
9887 #ifdef __cplusplus
9888 extern "C"
9889 #endif
9890 /* We use char because int might match the return type of a gcc2
9891    builtin and then its argument prototype would still apply.  */
9892 char ceill ();
9893 int
9894 main ()
9895 {
9896 ceill ();
9897   ;
9898   return 0;
9899 }
9900 _ACEOF
9901 rm -f conftest.$ac_objext conftest$ac_exeext
9902 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9903   (eval $ac_link) 2>conftest.er1
9904   ac_status=$?
9905   grep -v '^ *+' conftest.er1 >conftest.err
9906   rm -f conftest.er1
9907   cat conftest.err >&5
9908   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9909   (exit $ac_status); } &&
9910          { ac_try='test -z "$ac_c_werror_flag"
9911                          || test ! -s conftest.err'
9912   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9913   (eval $ac_try) 2>&5
9914   ac_status=$?
9915   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9916   (exit $ac_status); }; } &&
9917          { ac_try='test -s conftest$ac_exeext'
9918   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9919   (eval $ac_try) 2>&5
9920   ac_status=$?
9921   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9922   (exit $ac_status); }; }; then
9923   ac_cv_lib_m_ceill=yes
9924 else
9925   echo "$as_me: failed program was:" >&5
9926 sed 's/^/| /' conftest.$ac_ext >&5
9927
9928 ac_cv_lib_m_ceill=no
9929 fi
9930 rm -f conftest.err conftest.$ac_objext \
9931       conftest$ac_exeext conftest.$ac_ext
9932 LIBS=$ac_check_lib_save_LIBS
9933 fi
9934 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceill" >&5
9935 echo "${ECHO_T}$ac_cv_lib_m_ceill" >&6
9936 if test $ac_cv_lib_m_ceill = yes; then
9937
9938 cat >>confdefs.h <<\_ACEOF
9939 #define HAVE_CEILL 1
9940 _ACEOF
9941
9942 fi
9943
9944 echo "$as_me:$LINENO: checking for copysignf in -lm" >&5
9945 echo $ECHO_N "checking for copysignf in -lm... $ECHO_C" >&6
9946 if test "${ac_cv_lib_m_copysignf+set}" = set; then
9947   echo $ECHO_N "(cached) $ECHO_C" >&6
9948 else
9949   ac_check_lib_save_LIBS=$LIBS
9950 LIBS="-lm  $LIBS"
9951 if test x$gcc_no_link = xyes; then
9952   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9953 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9954    { (exit 1); exit 1; }; }
9955 fi
9956 cat >conftest.$ac_ext <<_ACEOF
9957 /* confdefs.h.  */
9958 _ACEOF
9959 cat confdefs.h >>conftest.$ac_ext
9960 cat >>conftest.$ac_ext <<_ACEOF
9961 /* end confdefs.h.  */
9962
9963 /* Override any gcc2 internal prototype to avoid an error.  */
9964 #ifdef __cplusplus
9965 extern "C"
9966 #endif
9967 /* We use char because int might match the return type of a gcc2
9968    builtin and then its argument prototype would still apply.  */
9969 char copysignf ();
9970 int
9971 main ()
9972 {
9973 copysignf ();
9974   ;
9975   return 0;
9976 }
9977 _ACEOF
9978 rm -f conftest.$ac_objext conftest$ac_exeext
9979 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9980   (eval $ac_link) 2>conftest.er1
9981   ac_status=$?
9982   grep -v '^ *+' conftest.er1 >conftest.err
9983   rm -f conftest.er1
9984   cat conftest.err >&5
9985   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9986   (exit $ac_status); } &&
9987          { ac_try='test -z "$ac_c_werror_flag"
9988                          || test ! -s conftest.err'
9989   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9990   (eval $ac_try) 2>&5
9991   ac_status=$?
9992   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9993   (exit $ac_status); }; } &&
9994          { ac_try='test -s conftest$ac_exeext'
9995   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9996   (eval $ac_try) 2>&5
9997   ac_status=$?
9998   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9999   (exit $ac_status); }; }; then
10000   ac_cv_lib_m_copysignf=yes
10001 else
10002   echo "$as_me: failed program was:" >&5
10003 sed 's/^/| /' conftest.$ac_ext >&5
10004
10005 ac_cv_lib_m_copysignf=no
10006 fi
10007 rm -f conftest.err conftest.$ac_objext \
10008       conftest$ac_exeext conftest.$ac_ext
10009 LIBS=$ac_check_lib_save_LIBS
10010 fi
10011 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysignf" >&5
10012 echo "${ECHO_T}$ac_cv_lib_m_copysignf" >&6
10013 if test $ac_cv_lib_m_copysignf = yes; then
10014
10015 cat >>confdefs.h <<\_ACEOF
10016 #define HAVE_COPYSIGNF 1
10017 _ACEOF
10018
10019 fi
10020
10021 echo "$as_me:$LINENO: checking for copysign in -lm" >&5
10022 echo $ECHO_N "checking for copysign in -lm... $ECHO_C" >&6
10023 if test "${ac_cv_lib_m_copysign+set}" = set; then
10024   echo $ECHO_N "(cached) $ECHO_C" >&6
10025 else
10026   ac_check_lib_save_LIBS=$LIBS
10027 LIBS="-lm  $LIBS"
10028 if test x$gcc_no_link = xyes; then
10029   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10030 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10031    { (exit 1); exit 1; }; }
10032 fi
10033 cat >conftest.$ac_ext <<_ACEOF
10034 /* confdefs.h.  */
10035 _ACEOF
10036 cat confdefs.h >>conftest.$ac_ext
10037 cat >>conftest.$ac_ext <<_ACEOF
10038 /* end confdefs.h.  */
10039
10040 /* Override any gcc2 internal prototype to avoid an error.  */
10041 #ifdef __cplusplus
10042 extern "C"
10043 #endif
10044 /* We use char because int might match the return type of a gcc2
10045    builtin and then its argument prototype would still apply.  */
10046 char copysign ();
10047 int
10048 main ()
10049 {
10050 copysign ();
10051   ;
10052   return 0;
10053 }
10054 _ACEOF
10055 rm -f conftest.$ac_objext conftest$ac_exeext
10056 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10057   (eval $ac_link) 2>conftest.er1
10058   ac_status=$?
10059   grep -v '^ *+' conftest.er1 >conftest.err
10060   rm -f conftest.er1
10061   cat conftest.err >&5
10062   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10063   (exit $ac_status); } &&
10064          { ac_try='test -z "$ac_c_werror_flag"
10065                          || test ! -s conftest.err'
10066   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10067   (eval $ac_try) 2>&5
10068   ac_status=$?
10069   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10070   (exit $ac_status); }; } &&
10071          { ac_try='test -s conftest$ac_exeext'
10072   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10073   (eval $ac_try) 2>&5
10074   ac_status=$?
10075   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10076   (exit $ac_status); }; }; then
10077   ac_cv_lib_m_copysign=yes
10078 else
10079   echo "$as_me: failed program was:" >&5
10080 sed 's/^/| /' conftest.$ac_ext >&5
10081
10082 ac_cv_lib_m_copysign=no
10083 fi
10084 rm -f conftest.err conftest.$ac_objext \
10085       conftest$ac_exeext conftest.$ac_ext
10086 LIBS=$ac_check_lib_save_LIBS
10087 fi
10088 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysign" >&5
10089 echo "${ECHO_T}$ac_cv_lib_m_copysign" >&6
10090 if test $ac_cv_lib_m_copysign = yes; then
10091
10092 cat >>confdefs.h <<\_ACEOF
10093 #define HAVE_COPYSIGN 1
10094 _ACEOF
10095
10096 fi
10097
10098 echo "$as_me:$LINENO: checking for copysignl in -lm" >&5
10099 echo $ECHO_N "checking for copysignl in -lm... $ECHO_C" >&6
10100 if test "${ac_cv_lib_m_copysignl+set}" = set; then
10101   echo $ECHO_N "(cached) $ECHO_C" >&6
10102 else
10103   ac_check_lib_save_LIBS=$LIBS
10104 LIBS="-lm  $LIBS"
10105 if test x$gcc_no_link = xyes; then
10106   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10107 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10108    { (exit 1); exit 1; }; }
10109 fi
10110 cat >conftest.$ac_ext <<_ACEOF
10111 /* confdefs.h.  */
10112 _ACEOF
10113 cat confdefs.h >>conftest.$ac_ext
10114 cat >>conftest.$ac_ext <<_ACEOF
10115 /* end confdefs.h.  */
10116
10117 /* Override any gcc2 internal prototype to avoid an error.  */
10118 #ifdef __cplusplus
10119 extern "C"
10120 #endif
10121 /* We use char because int might match the return type of a gcc2
10122    builtin and then its argument prototype would still apply.  */
10123 char copysignl ();
10124 int
10125 main ()
10126 {
10127 copysignl ();
10128   ;
10129   return 0;
10130 }
10131 _ACEOF
10132 rm -f conftest.$ac_objext conftest$ac_exeext
10133 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10134   (eval $ac_link) 2>conftest.er1
10135   ac_status=$?
10136   grep -v '^ *+' conftest.er1 >conftest.err
10137   rm -f conftest.er1
10138   cat conftest.err >&5
10139   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10140   (exit $ac_status); } &&
10141          { ac_try='test -z "$ac_c_werror_flag"
10142                          || test ! -s conftest.err'
10143   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10144   (eval $ac_try) 2>&5
10145   ac_status=$?
10146   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10147   (exit $ac_status); }; } &&
10148          { ac_try='test -s conftest$ac_exeext'
10149   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10150   (eval $ac_try) 2>&5
10151   ac_status=$?
10152   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10153   (exit $ac_status); }; }; then
10154   ac_cv_lib_m_copysignl=yes
10155 else
10156   echo "$as_me: failed program was:" >&5
10157 sed 's/^/| /' conftest.$ac_ext >&5
10158
10159 ac_cv_lib_m_copysignl=no
10160 fi
10161 rm -f conftest.err conftest.$ac_objext \
10162       conftest$ac_exeext conftest.$ac_ext
10163 LIBS=$ac_check_lib_save_LIBS
10164 fi
10165 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysignl" >&5
10166 echo "${ECHO_T}$ac_cv_lib_m_copysignl" >&6
10167 if test $ac_cv_lib_m_copysignl = yes; then
10168
10169 cat >>confdefs.h <<\_ACEOF
10170 #define HAVE_COPYSIGNL 1
10171 _ACEOF
10172
10173 fi
10174
10175 echo "$as_me:$LINENO: checking for cosf in -lm" >&5
10176 echo $ECHO_N "checking for cosf in -lm... $ECHO_C" >&6
10177 if test "${ac_cv_lib_m_cosf+set}" = set; then
10178   echo $ECHO_N "(cached) $ECHO_C" >&6
10179 else
10180   ac_check_lib_save_LIBS=$LIBS
10181 LIBS="-lm  $LIBS"
10182 if test x$gcc_no_link = xyes; then
10183   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10184 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10185    { (exit 1); exit 1; }; }
10186 fi
10187 cat >conftest.$ac_ext <<_ACEOF
10188 /* confdefs.h.  */
10189 _ACEOF
10190 cat confdefs.h >>conftest.$ac_ext
10191 cat >>conftest.$ac_ext <<_ACEOF
10192 /* end confdefs.h.  */
10193
10194 /* Override any gcc2 internal prototype to avoid an error.  */
10195 #ifdef __cplusplus
10196 extern "C"
10197 #endif
10198 /* We use char because int might match the return type of a gcc2
10199    builtin and then its argument prototype would still apply.  */
10200 char cosf ();
10201 int
10202 main ()
10203 {
10204 cosf ();
10205   ;
10206   return 0;
10207 }
10208 _ACEOF
10209 rm -f conftest.$ac_objext conftest$ac_exeext
10210 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10211   (eval $ac_link) 2>conftest.er1
10212   ac_status=$?
10213   grep -v '^ *+' conftest.er1 >conftest.err
10214   rm -f conftest.er1
10215   cat conftest.err >&5
10216   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10217   (exit $ac_status); } &&
10218          { ac_try='test -z "$ac_c_werror_flag"
10219                          || test ! -s conftest.err'
10220   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10221   (eval $ac_try) 2>&5
10222   ac_status=$?
10223   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10224   (exit $ac_status); }; } &&
10225          { ac_try='test -s conftest$ac_exeext'
10226   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10227   (eval $ac_try) 2>&5
10228   ac_status=$?
10229   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10230   (exit $ac_status); }; }; then
10231   ac_cv_lib_m_cosf=yes
10232 else
10233   echo "$as_me: failed program was:" >&5
10234 sed 's/^/| /' conftest.$ac_ext >&5
10235
10236 ac_cv_lib_m_cosf=no
10237 fi
10238 rm -f conftest.err conftest.$ac_objext \
10239       conftest$ac_exeext conftest.$ac_ext
10240 LIBS=$ac_check_lib_save_LIBS
10241 fi
10242 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosf" >&5
10243 echo "${ECHO_T}$ac_cv_lib_m_cosf" >&6
10244 if test $ac_cv_lib_m_cosf = yes; then
10245
10246 cat >>confdefs.h <<\_ACEOF
10247 #define HAVE_COSF 1
10248 _ACEOF
10249
10250 fi
10251
10252 echo "$as_me:$LINENO: checking for cos in -lm" >&5
10253 echo $ECHO_N "checking for cos in -lm... $ECHO_C" >&6
10254 if test "${ac_cv_lib_m_cos+set}" = set; then
10255   echo $ECHO_N "(cached) $ECHO_C" >&6
10256 else
10257   ac_check_lib_save_LIBS=$LIBS
10258 LIBS="-lm  $LIBS"
10259 if test x$gcc_no_link = xyes; then
10260   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10261 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10262    { (exit 1); exit 1; }; }
10263 fi
10264 cat >conftest.$ac_ext <<_ACEOF
10265 /* confdefs.h.  */
10266 _ACEOF
10267 cat confdefs.h >>conftest.$ac_ext
10268 cat >>conftest.$ac_ext <<_ACEOF
10269 /* end confdefs.h.  */
10270
10271 /* Override any gcc2 internal prototype to avoid an error.  */
10272 #ifdef __cplusplus
10273 extern "C"
10274 #endif
10275 /* We use char because int might match the return type of a gcc2
10276    builtin and then its argument prototype would still apply.  */
10277 char cos ();
10278 int
10279 main ()
10280 {
10281 cos ();
10282   ;
10283   return 0;
10284 }
10285 _ACEOF
10286 rm -f conftest.$ac_objext conftest$ac_exeext
10287 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10288   (eval $ac_link) 2>conftest.er1
10289   ac_status=$?
10290   grep -v '^ *+' conftest.er1 >conftest.err
10291   rm -f conftest.er1
10292   cat conftest.err >&5
10293   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10294   (exit $ac_status); } &&
10295          { ac_try='test -z "$ac_c_werror_flag"
10296                          || test ! -s conftest.err'
10297   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10298   (eval $ac_try) 2>&5
10299   ac_status=$?
10300   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10301   (exit $ac_status); }; } &&
10302          { ac_try='test -s conftest$ac_exeext'
10303   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10304   (eval $ac_try) 2>&5
10305   ac_status=$?
10306   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10307   (exit $ac_status); }; }; then
10308   ac_cv_lib_m_cos=yes
10309 else
10310   echo "$as_me: failed program was:" >&5
10311 sed 's/^/| /' conftest.$ac_ext >&5
10312
10313 ac_cv_lib_m_cos=no
10314 fi
10315 rm -f conftest.err conftest.$ac_objext \
10316       conftest$ac_exeext conftest.$ac_ext
10317 LIBS=$ac_check_lib_save_LIBS
10318 fi
10319 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cos" >&5
10320 echo "${ECHO_T}$ac_cv_lib_m_cos" >&6
10321 if test $ac_cv_lib_m_cos = yes; then
10322
10323 cat >>confdefs.h <<\_ACEOF
10324 #define HAVE_COS 1
10325 _ACEOF
10326
10327 fi
10328
10329 echo "$as_me:$LINENO: checking for cosl in -lm" >&5
10330 echo $ECHO_N "checking for cosl in -lm... $ECHO_C" >&6
10331 if test "${ac_cv_lib_m_cosl+set}" = set; then
10332   echo $ECHO_N "(cached) $ECHO_C" >&6
10333 else
10334   ac_check_lib_save_LIBS=$LIBS
10335 LIBS="-lm  $LIBS"
10336 if test x$gcc_no_link = xyes; then
10337   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10338 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10339    { (exit 1); exit 1; }; }
10340 fi
10341 cat >conftest.$ac_ext <<_ACEOF
10342 /* confdefs.h.  */
10343 _ACEOF
10344 cat confdefs.h >>conftest.$ac_ext
10345 cat >>conftest.$ac_ext <<_ACEOF
10346 /* end confdefs.h.  */
10347
10348 /* Override any gcc2 internal prototype to avoid an error.  */
10349 #ifdef __cplusplus
10350 extern "C"
10351 #endif
10352 /* We use char because int might match the return type of a gcc2
10353    builtin and then its argument prototype would still apply.  */
10354 char cosl ();
10355 int
10356 main ()
10357 {
10358 cosl ();
10359   ;
10360   return 0;
10361 }
10362 _ACEOF
10363 rm -f conftest.$ac_objext conftest$ac_exeext
10364 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10365   (eval $ac_link) 2>conftest.er1
10366   ac_status=$?
10367   grep -v '^ *+' conftest.er1 >conftest.err
10368   rm -f conftest.er1
10369   cat conftest.err >&5
10370   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10371   (exit $ac_status); } &&
10372          { ac_try='test -z "$ac_c_werror_flag"
10373                          || test ! -s conftest.err'
10374   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10375   (eval $ac_try) 2>&5
10376   ac_status=$?
10377   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10378   (exit $ac_status); }; } &&
10379          { ac_try='test -s conftest$ac_exeext'
10380   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10381   (eval $ac_try) 2>&5
10382   ac_status=$?
10383   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10384   (exit $ac_status); }; }; then
10385   ac_cv_lib_m_cosl=yes
10386 else
10387   echo "$as_me: failed program was:" >&5
10388 sed 's/^/| /' conftest.$ac_ext >&5
10389
10390 ac_cv_lib_m_cosl=no
10391 fi
10392 rm -f conftest.err conftest.$ac_objext \
10393       conftest$ac_exeext conftest.$ac_ext
10394 LIBS=$ac_check_lib_save_LIBS
10395 fi
10396 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosl" >&5
10397 echo "${ECHO_T}$ac_cv_lib_m_cosl" >&6
10398 if test $ac_cv_lib_m_cosl = yes; then
10399
10400 cat >>confdefs.h <<\_ACEOF
10401 #define HAVE_COSL 1
10402 _ACEOF
10403
10404 fi
10405
10406 echo "$as_me:$LINENO: checking for ccosf in -lm" >&5
10407 echo $ECHO_N "checking for ccosf in -lm... $ECHO_C" >&6
10408 if test "${ac_cv_lib_m_ccosf+set}" = set; then
10409   echo $ECHO_N "(cached) $ECHO_C" >&6
10410 else
10411   ac_check_lib_save_LIBS=$LIBS
10412 LIBS="-lm  $LIBS"
10413 if test x$gcc_no_link = xyes; then
10414   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10415 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10416    { (exit 1); exit 1; }; }
10417 fi
10418 cat >conftest.$ac_ext <<_ACEOF
10419 /* confdefs.h.  */
10420 _ACEOF
10421 cat confdefs.h >>conftest.$ac_ext
10422 cat >>conftest.$ac_ext <<_ACEOF
10423 /* end confdefs.h.  */
10424
10425 /* Override any gcc2 internal prototype to avoid an error.  */
10426 #ifdef __cplusplus
10427 extern "C"
10428 #endif
10429 /* We use char because int might match the return type of a gcc2
10430    builtin and then its argument prototype would still apply.  */
10431 char ccosf ();
10432 int
10433 main ()
10434 {
10435 ccosf ();
10436   ;
10437   return 0;
10438 }
10439 _ACEOF
10440 rm -f conftest.$ac_objext conftest$ac_exeext
10441 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10442   (eval $ac_link) 2>conftest.er1
10443   ac_status=$?
10444   grep -v '^ *+' conftest.er1 >conftest.err
10445   rm -f conftest.er1
10446   cat conftest.err >&5
10447   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10448   (exit $ac_status); } &&
10449          { ac_try='test -z "$ac_c_werror_flag"
10450                          || test ! -s conftest.err'
10451   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10452   (eval $ac_try) 2>&5
10453   ac_status=$?
10454   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10455   (exit $ac_status); }; } &&
10456          { ac_try='test -s conftest$ac_exeext'
10457   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10458   (eval $ac_try) 2>&5
10459   ac_status=$?
10460   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10461   (exit $ac_status); }; }; then
10462   ac_cv_lib_m_ccosf=yes
10463 else
10464   echo "$as_me: failed program was:" >&5
10465 sed 's/^/| /' conftest.$ac_ext >&5
10466
10467 ac_cv_lib_m_ccosf=no
10468 fi
10469 rm -f conftest.err conftest.$ac_objext \
10470       conftest$ac_exeext conftest.$ac_ext
10471 LIBS=$ac_check_lib_save_LIBS
10472 fi
10473 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosf" >&5
10474 echo "${ECHO_T}$ac_cv_lib_m_ccosf" >&6
10475 if test $ac_cv_lib_m_ccosf = yes; then
10476
10477 cat >>confdefs.h <<\_ACEOF
10478 #define HAVE_CCOSF 1
10479 _ACEOF
10480
10481 fi
10482
10483 echo "$as_me:$LINENO: checking for ccos in -lm" >&5
10484 echo $ECHO_N "checking for ccos in -lm... $ECHO_C" >&6
10485 if test "${ac_cv_lib_m_ccos+set}" = set; then
10486   echo $ECHO_N "(cached) $ECHO_C" >&6
10487 else
10488   ac_check_lib_save_LIBS=$LIBS
10489 LIBS="-lm  $LIBS"
10490 if test x$gcc_no_link = xyes; then
10491   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10492 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10493    { (exit 1); exit 1; }; }
10494 fi
10495 cat >conftest.$ac_ext <<_ACEOF
10496 /* confdefs.h.  */
10497 _ACEOF
10498 cat confdefs.h >>conftest.$ac_ext
10499 cat >>conftest.$ac_ext <<_ACEOF
10500 /* end confdefs.h.  */
10501
10502 /* Override any gcc2 internal prototype to avoid an error.  */
10503 #ifdef __cplusplus
10504 extern "C"
10505 #endif
10506 /* We use char because int might match the return type of a gcc2
10507    builtin and then its argument prototype would still apply.  */
10508 char ccos ();
10509 int
10510 main ()
10511 {
10512 ccos ();
10513   ;
10514   return 0;
10515 }
10516 _ACEOF
10517 rm -f conftest.$ac_objext conftest$ac_exeext
10518 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10519   (eval $ac_link) 2>conftest.er1
10520   ac_status=$?
10521   grep -v '^ *+' conftest.er1 >conftest.err
10522   rm -f conftest.er1
10523   cat conftest.err >&5
10524   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10525   (exit $ac_status); } &&
10526          { ac_try='test -z "$ac_c_werror_flag"
10527                          || test ! -s conftest.err'
10528   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10529   (eval $ac_try) 2>&5
10530   ac_status=$?
10531   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10532   (exit $ac_status); }; } &&
10533          { ac_try='test -s conftest$ac_exeext'
10534   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10535   (eval $ac_try) 2>&5
10536   ac_status=$?
10537   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10538   (exit $ac_status); }; }; then
10539   ac_cv_lib_m_ccos=yes
10540 else
10541   echo "$as_me: failed program was:" >&5
10542 sed 's/^/| /' conftest.$ac_ext >&5
10543
10544 ac_cv_lib_m_ccos=no
10545 fi
10546 rm -f conftest.err conftest.$ac_objext \
10547       conftest$ac_exeext conftest.$ac_ext
10548 LIBS=$ac_check_lib_save_LIBS
10549 fi
10550 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccos" >&5
10551 echo "${ECHO_T}$ac_cv_lib_m_ccos" >&6
10552 if test $ac_cv_lib_m_ccos = yes; then
10553
10554 cat >>confdefs.h <<\_ACEOF
10555 #define HAVE_CCOS 1
10556 _ACEOF
10557
10558 fi
10559
10560 echo "$as_me:$LINENO: checking for ccosl in -lm" >&5
10561 echo $ECHO_N "checking for ccosl in -lm... $ECHO_C" >&6
10562 if test "${ac_cv_lib_m_ccosl+set}" = set; then
10563   echo $ECHO_N "(cached) $ECHO_C" >&6
10564 else
10565   ac_check_lib_save_LIBS=$LIBS
10566 LIBS="-lm  $LIBS"
10567 if test x$gcc_no_link = xyes; then
10568   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10569 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10570    { (exit 1); exit 1; }; }
10571 fi
10572 cat >conftest.$ac_ext <<_ACEOF
10573 /* confdefs.h.  */
10574 _ACEOF
10575 cat confdefs.h >>conftest.$ac_ext
10576 cat >>conftest.$ac_ext <<_ACEOF
10577 /* end confdefs.h.  */
10578
10579 /* Override any gcc2 internal prototype to avoid an error.  */
10580 #ifdef __cplusplus
10581 extern "C"
10582 #endif
10583 /* We use char because int might match the return type of a gcc2
10584    builtin and then its argument prototype would still apply.  */
10585 char ccosl ();
10586 int
10587 main ()
10588 {
10589 ccosl ();
10590   ;
10591   return 0;
10592 }
10593 _ACEOF
10594 rm -f conftest.$ac_objext conftest$ac_exeext
10595 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10596   (eval $ac_link) 2>conftest.er1
10597   ac_status=$?
10598   grep -v '^ *+' conftest.er1 >conftest.err
10599   rm -f conftest.er1
10600   cat conftest.err >&5
10601   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10602   (exit $ac_status); } &&
10603          { ac_try='test -z "$ac_c_werror_flag"
10604                          || test ! -s conftest.err'
10605   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10606   (eval $ac_try) 2>&5
10607   ac_status=$?
10608   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10609   (exit $ac_status); }; } &&
10610          { ac_try='test -s conftest$ac_exeext'
10611   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10612   (eval $ac_try) 2>&5
10613   ac_status=$?
10614   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10615   (exit $ac_status); }; }; then
10616   ac_cv_lib_m_ccosl=yes
10617 else
10618   echo "$as_me: failed program was:" >&5
10619 sed 's/^/| /' conftest.$ac_ext >&5
10620
10621 ac_cv_lib_m_ccosl=no
10622 fi
10623 rm -f conftest.err conftest.$ac_objext \
10624       conftest$ac_exeext conftest.$ac_ext
10625 LIBS=$ac_check_lib_save_LIBS
10626 fi
10627 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosl" >&5
10628 echo "${ECHO_T}$ac_cv_lib_m_ccosl" >&6
10629 if test $ac_cv_lib_m_ccosl = yes; then
10630
10631 cat >>confdefs.h <<\_ACEOF
10632 #define HAVE_CCOSL 1
10633 _ACEOF
10634
10635 fi
10636
10637 echo "$as_me:$LINENO: checking for coshf in -lm" >&5
10638 echo $ECHO_N "checking for coshf in -lm... $ECHO_C" >&6
10639 if test "${ac_cv_lib_m_coshf+set}" = set; then
10640   echo $ECHO_N "(cached) $ECHO_C" >&6
10641 else
10642   ac_check_lib_save_LIBS=$LIBS
10643 LIBS="-lm  $LIBS"
10644 if test x$gcc_no_link = xyes; then
10645   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10646 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10647    { (exit 1); exit 1; }; }
10648 fi
10649 cat >conftest.$ac_ext <<_ACEOF
10650 /* confdefs.h.  */
10651 _ACEOF
10652 cat confdefs.h >>conftest.$ac_ext
10653 cat >>conftest.$ac_ext <<_ACEOF
10654 /* end confdefs.h.  */
10655
10656 /* Override any gcc2 internal prototype to avoid an error.  */
10657 #ifdef __cplusplus
10658 extern "C"
10659 #endif
10660 /* We use char because int might match the return type of a gcc2
10661    builtin and then its argument prototype would still apply.  */
10662 char coshf ();
10663 int
10664 main ()
10665 {
10666 coshf ();
10667   ;
10668   return 0;
10669 }
10670 _ACEOF
10671 rm -f conftest.$ac_objext conftest$ac_exeext
10672 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10673   (eval $ac_link) 2>conftest.er1
10674   ac_status=$?
10675   grep -v '^ *+' conftest.er1 >conftest.err
10676   rm -f conftest.er1
10677   cat conftest.err >&5
10678   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10679   (exit $ac_status); } &&
10680          { ac_try='test -z "$ac_c_werror_flag"
10681                          || test ! -s conftest.err'
10682   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10683   (eval $ac_try) 2>&5
10684   ac_status=$?
10685   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10686   (exit $ac_status); }; } &&
10687          { ac_try='test -s conftest$ac_exeext'
10688   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10689   (eval $ac_try) 2>&5
10690   ac_status=$?
10691   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10692   (exit $ac_status); }; }; then
10693   ac_cv_lib_m_coshf=yes
10694 else
10695   echo "$as_me: failed program was:" >&5
10696 sed 's/^/| /' conftest.$ac_ext >&5
10697
10698 ac_cv_lib_m_coshf=no
10699 fi
10700 rm -f conftest.err conftest.$ac_objext \
10701       conftest$ac_exeext conftest.$ac_ext
10702 LIBS=$ac_check_lib_save_LIBS
10703 fi
10704 echo "$as_me:$LINENO: result: $ac_cv_lib_m_coshf" >&5
10705 echo "${ECHO_T}$ac_cv_lib_m_coshf" >&6
10706 if test $ac_cv_lib_m_coshf = yes; then
10707
10708 cat >>confdefs.h <<\_ACEOF
10709 #define HAVE_COSHF 1
10710 _ACEOF
10711
10712 fi
10713
10714 echo "$as_me:$LINENO: checking for cosh in -lm" >&5
10715 echo $ECHO_N "checking for cosh in -lm... $ECHO_C" >&6
10716 if test "${ac_cv_lib_m_cosh+set}" = set; then
10717   echo $ECHO_N "(cached) $ECHO_C" >&6
10718 else
10719   ac_check_lib_save_LIBS=$LIBS
10720 LIBS="-lm  $LIBS"
10721 if test x$gcc_no_link = xyes; then
10722   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10723 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10724    { (exit 1); exit 1; }; }
10725 fi
10726 cat >conftest.$ac_ext <<_ACEOF
10727 /* confdefs.h.  */
10728 _ACEOF
10729 cat confdefs.h >>conftest.$ac_ext
10730 cat >>conftest.$ac_ext <<_ACEOF
10731 /* end confdefs.h.  */
10732
10733 /* Override any gcc2 internal prototype to avoid an error.  */
10734 #ifdef __cplusplus
10735 extern "C"
10736 #endif
10737 /* We use char because int might match the return type of a gcc2
10738    builtin and then its argument prototype would still apply.  */
10739 char cosh ();
10740 int
10741 main ()
10742 {
10743 cosh ();
10744   ;
10745   return 0;
10746 }
10747 _ACEOF
10748 rm -f conftest.$ac_objext conftest$ac_exeext
10749 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10750   (eval $ac_link) 2>conftest.er1
10751   ac_status=$?
10752   grep -v '^ *+' conftest.er1 >conftest.err
10753   rm -f conftest.er1
10754   cat conftest.err >&5
10755   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10756   (exit $ac_status); } &&
10757          { ac_try='test -z "$ac_c_werror_flag"
10758                          || test ! -s conftest.err'
10759   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10760   (eval $ac_try) 2>&5
10761   ac_status=$?
10762   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10763   (exit $ac_status); }; } &&
10764          { ac_try='test -s conftest$ac_exeext'
10765   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10766   (eval $ac_try) 2>&5
10767   ac_status=$?
10768   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10769   (exit $ac_status); }; }; then
10770   ac_cv_lib_m_cosh=yes
10771 else
10772   echo "$as_me: failed program was:" >&5
10773 sed 's/^/| /' conftest.$ac_ext >&5
10774
10775 ac_cv_lib_m_cosh=no
10776 fi
10777 rm -f conftest.err conftest.$ac_objext \
10778       conftest$ac_exeext conftest.$ac_ext
10779 LIBS=$ac_check_lib_save_LIBS
10780 fi
10781 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosh" >&5
10782 echo "${ECHO_T}$ac_cv_lib_m_cosh" >&6
10783 if test $ac_cv_lib_m_cosh = yes; then
10784
10785 cat >>confdefs.h <<\_ACEOF
10786 #define HAVE_COSH 1
10787 _ACEOF
10788
10789 fi
10790
10791 echo "$as_me:$LINENO: checking for coshl in -lm" >&5
10792 echo $ECHO_N "checking for coshl in -lm... $ECHO_C" >&6
10793 if test "${ac_cv_lib_m_coshl+set}" = set; then
10794   echo $ECHO_N "(cached) $ECHO_C" >&6
10795 else
10796   ac_check_lib_save_LIBS=$LIBS
10797 LIBS="-lm  $LIBS"
10798 if test x$gcc_no_link = xyes; then
10799   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10800 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10801    { (exit 1); exit 1; }; }
10802 fi
10803 cat >conftest.$ac_ext <<_ACEOF
10804 /* confdefs.h.  */
10805 _ACEOF
10806 cat confdefs.h >>conftest.$ac_ext
10807 cat >>conftest.$ac_ext <<_ACEOF
10808 /* end confdefs.h.  */
10809
10810 /* Override any gcc2 internal prototype to avoid an error.  */
10811 #ifdef __cplusplus
10812 extern "C"
10813 #endif
10814 /* We use char because int might match the return type of a gcc2
10815    builtin and then its argument prototype would still apply.  */
10816 char coshl ();
10817 int
10818 main ()
10819 {
10820 coshl ();
10821   ;
10822   return 0;
10823 }
10824 _ACEOF
10825 rm -f conftest.$ac_objext conftest$ac_exeext
10826 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10827   (eval $ac_link) 2>conftest.er1
10828   ac_status=$?
10829   grep -v '^ *+' conftest.er1 >conftest.err
10830   rm -f conftest.er1
10831   cat conftest.err >&5
10832   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10833   (exit $ac_status); } &&
10834          { ac_try='test -z "$ac_c_werror_flag"
10835                          || test ! -s conftest.err'
10836   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10837   (eval $ac_try) 2>&5
10838   ac_status=$?
10839   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10840   (exit $ac_status); }; } &&
10841          { ac_try='test -s conftest$ac_exeext'
10842   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10843   (eval $ac_try) 2>&5
10844   ac_status=$?
10845   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10846   (exit $ac_status); }; }; then
10847   ac_cv_lib_m_coshl=yes
10848 else
10849   echo "$as_me: failed program was:" >&5
10850 sed 's/^/| /' conftest.$ac_ext >&5
10851
10852 ac_cv_lib_m_coshl=no
10853 fi
10854 rm -f conftest.err conftest.$ac_objext \
10855       conftest$ac_exeext conftest.$ac_ext
10856 LIBS=$ac_check_lib_save_LIBS
10857 fi
10858 echo "$as_me:$LINENO: result: $ac_cv_lib_m_coshl" >&5
10859 echo "${ECHO_T}$ac_cv_lib_m_coshl" >&6
10860 if test $ac_cv_lib_m_coshl = yes; then
10861
10862 cat >>confdefs.h <<\_ACEOF
10863 #define HAVE_COSHL 1
10864 _ACEOF
10865
10866 fi
10867
10868 echo "$as_me:$LINENO: checking for ccoshf in -lm" >&5
10869 echo $ECHO_N "checking for ccoshf in -lm... $ECHO_C" >&6
10870 if test "${ac_cv_lib_m_ccoshf+set}" = set; then
10871   echo $ECHO_N "(cached) $ECHO_C" >&6
10872 else
10873   ac_check_lib_save_LIBS=$LIBS
10874 LIBS="-lm  $LIBS"
10875 if test x$gcc_no_link = xyes; then
10876   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10877 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10878    { (exit 1); exit 1; }; }
10879 fi
10880 cat >conftest.$ac_ext <<_ACEOF
10881 /* confdefs.h.  */
10882 _ACEOF
10883 cat confdefs.h >>conftest.$ac_ext
10884 cat >>conftest.$ac_ext <<_ACEOF
10885 /* end confdefs.h.  */
10886
10887 /* Override any gcc2 internal prototype to avoid an error.  */
10888 #ifdef __cplusplus
10889 extern "C"
10890 #endif
10891 /* We use char because int might match the return type of a gcc2
10892    builtin and then its argument prototype would still apply.  */
10893 char ccoshf ();
10894 int
10895 main ()
10896 {
10897 ccoshf ();
10898   ;
10899   return 0;
10900 }
10901 _ACEOF
10902 rm -f conftest.$ac_objext conftest$ac_exeext
10903 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10904   (eval $ac_link) 2>conftest.er1
10905   ac_status=$?
10906   grep -v '^ *+' conftest.er1 >conftest.err
10907   rm -f conftest.er1
10908   cat conftest.err >&5
10909   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10910   (exit $ac_status); } &&
10911          { ac_try='test -z "$ac_c_werror_flag"
10912                          || test ! -s conftest.err'
10913   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10914   (eval $ac_try) 2>&5
10915   ac_status=$?
10916   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10917   (exit $ac_status); }; } &&
10918          { ac_try='test -s conftest$ac_exeext'
10919   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10920   (eval $ac_try) 2>&5
10921   ac_status=$?
10922   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10923   (exit $ac_status); }; }; then
10924   ac_cv_lib_m_ccoshf=yes
10925 else
10926   echo "$as_me: failed program was:" >&5
10927 sed 's/^/| /' conftest.$ac_ext >&5
10928
10929 ac_cv_lib_m_ccoshf=no
10930 fi
10931 rm -f conftest.err conftest.$ac_objext \
10932       conftest$ac_exeext conftest.$ac_ext
10933 LIBS=$ac_check_lib_save_LIBS
10934 fi
10935 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccoshf" >&5
10936 echo "${ECHO_T}$ac_cv_lib_m_ccoshf" >&6
10937 if test $ac_cv_lib_m_ccoshf = yes; then
10938
10939 cat >>confdefs.h <<\_ACEOF
10940 #define HAVE_CCOSHF 1
10941 _ACEOF
10942
10943 fi
10944
10945 echo "$as_me:$LINENO: checking for ccosh in -lm" >&5
10946 echo $ECHO_N "checking for ccosh in -lm... $ECHO_C" >&6
10947 if test "${ac_cv_lib_m_ccosh+set}" = set; then
10948   echo $ECHO_N "(cached) $ECHO_C" >&6
10949 else
10950   ac_check_lib_save_LIBS=$LIBS
10951 LIBS="-lm  $LIBS"
10952 if test x$gcc_no_link = xyes; then
10953   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10954 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10955    { (exit 1); exit 1; }; }
10956 fi
10957 cat >conftest.$ac_ext <<_ACEOF
10958 /* confdefs.h.  */
10959 _ACEOF
10960 cat confdefs.h >>conftest.$ac_ext
10961 cat >>conftest.$ac_ext <<_ACEOF
10962 /* end confdefs.h.  */
10963
10964 /* Override any gcc2 internal prototype to avoid an error.  */
10965 #ifdef __cplusplus
10966 extern "C"
10967 #endif
10968 /* We use char because int might match the return type of a gcc2
10969    builtin and then its argument prototype would still apply.  */
10970 char ccosh ();
10971 int
10972 main ()
10973 {
10974 ccosh ();
10975   ;
10976   return 0;
10977 }
10978 _ACEOF
10979 rm -f conftest.$ac_objext conftest$ac_exeext
10980 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10981   (eval $ac_link) 2>conftest.er1
10982   ac_status=$?
10983   grep -v '^ *+' conftest.er1 >conftest.err
10984   rm -f conftest.er1
10985   cat conftest.err >&5
10986   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10987   (exit $ac_status); } &&
10988          { ac_try='test -z "$ac_c_werror_flag"
10989                          || test ! -s conftest.err'
10990   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10991   (eval $ac_try) 2>&5
10992   ac_status=$?
10993   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10994   (exit $ac_status); }; } &&
10995          { ac_try='test -s conftest$ac_exeext'
10996   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10997   (eval $ac_try) 2>&5
10998   ac_status=$?
10999   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11000   (exit $ac_status); }; }; then
11001   ac_cv_lib_m_ccosh=yes
11002 else
11003   echo "$as_me: failed program was:" >&5
11004 sed 's/^/| /' conftest.$ac_ext >&5
11005
11006 ac_cv_lib_m_ccosh=no
11007 fi
11008 rm -f conftest.err conftest.$ac_objext \
11009       conftest$ac_exeext conftest.$ac_ext
11010 LIBS=$ac_check_lib_save_LIBS
11011 fi
11012 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosh" >&5
11013 echo "${ECHO_T}$ac_cv_lib_m_ccosh" >&6
11014 if test $ac_cv_lib_m_ccosh = yes; then
11015
11016 cat >>confdefs.h <<\_ACEOF
11017 #define HAVE_CCOSH 1
11018 _ACEOF
11019
11020 fi
11021
11022 echo "$as_me:$LINENO: checking for ccoshl in -lm" >&5
11023 echo $ECHO_N "checking for ccoshl in -lm... $ECHO_C" >&6
11024 if test "${ac_cv_lib_m_ccoshl+set}" = set; then
11025   echo $ECHO_N "(cached) $ECHO_C" >&6
11026 else
11027   ac_check_lib_save_LIBS=$LIBS
11028 LIBS="-lm  $LIBS"
11029 if test x$gcc_no_link = xyes; then
11030   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11031 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11032    { (exit 1); exit 1; }; }
11033 fi
11034 cat >conftest.$ac_ext <<_ACEOF
11035 /* confdefs.h.  */
11036 _ACEOF
11037 cat confdefs.h >>conftest.$ac_ext
11038 cat >>conftest.$ac_ext <<_ACEOF
11039 /* end confdefs.h.  */
11040
11041 /* Override any gcc2 internal prototype to avoid an error.  */
11042 #ifdef __cplusplus
11043 extern "C"
11044 #endif
11045 /* We use char because int might match the return type of a gcc2
11046    builtin and then its argument prototype would still apply.  */
11047 char ccoshl ();
11048 int
11049 main ()
11050 {
11051 ccoshl ();
11052   ;
11053   return 0;
11054 }
11055 _ACEOF
11056 rm -f conftest.$ac_objext conftest$ac_exeext
11057 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11058   (eval $ac_link) 2>conftest.er1
11059   ac_status=$?
11060   grep -v '^ *+' conftest.er1 >conftest.err
11061   rm -f conftest.er1
11062   cat conftest.err >&5
11063   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11064   (exit $ac_status); } &&
11065          { ac_try='test -z "$ac_c_werror_flag"
11066                          || test ! -s conftest.err'
11067   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11068   (eval $ac_try) 2>&5
11069   ac_status=$?
11070   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11071   (exit $ac_status); }; } &&
11072          { ac_try='test -s conftest$ac_exeext'
11073   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11074   (eval $ac_try) 2>&5
11075   ac_status=$?
11076   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11077   (exit $ac_status); }; }; then
11078   ac_cv_lib_m_ccoshl=yes
11079 else
11080   echo "$as_me: failed program was:" >&5
11081 sed 's/^/| /' conftest.$ac_ext >&5
11082
11083 ac_cv_lib_m_ccoshl=no
11084 fi
11085 rm -f conftest.err conftest.$ac_objext \
11086       conftest$ac_exeext conftest.$ac_ext
11087 LIBS=$ac_check_lib_save_LIBS
11088 fi
11089 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccoshl" >&5
11090 echo "${ECHO_T}$ac_cv_lib_m_ccoshl" >&6
11091 if test $ac_cv_lib_m_ccoshl = yes; then
11092
11093 cat >>confdefs.h <<\_ACEOF
11094 #define HAVE_CCOSHL 1
11095 _ACEOF
11096
11097 fi
11098
11099 echo "$as_me:$LINENO: checking for expf in -lm" >&5
11100 echo $ECHO_N "checking for expf in -lm... $ECHO_C" >&6
11101 if test "${ac_cv_lib_m_expf+set}" = set; then
11102   echo $ECHO_N "(cached) $ECHO_C" >&6
11103 else
11104   ac_check_lib_save_LIBS=$LIBS
11105 LIBS="-lm  $LIBS"
11106 if test x$gcc_no_link = xyes; then
11107   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11108 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11109    { (exit 1); exit 1; }; }
11110 fi
11111 cat >conftest.$ac_ext <<_ACEOF
11112 /* confdefs.h.  */
11113 _ACEOF
11114 cat confdefs.h >>conftest.$ac_ext
11115 cat >>conftest.$ac_ext <<_ACEOF
11116 /* end confdefs.h.  */
11117
11118 /* Override any gcc2 internal prototype to avoid an error.  */
11119 #ifdef __cplusplus
11120 extern "C"
11121 #endif
11122 /* We use char because int might match the return type of a gcc2
11123    builtin and then its argument prototype would still apply.  */
11124 char expf ();
11125 int
11126 main ()
11127 {
11128 expf ();
11129   ;
11130   return 0;
11131 }
11132 _ACEOF
11133 rm -f conftest.$ac_objext conftest$ac_exeext
11134 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11135   (eval $ac_link) 2>conftest.er1
11136   ac_status=$?
11137   grep -v '^ *+' conftest.er1 >conftest.err
11138   rm -f conftest.er1
11139   cat conftest.err >&5
11140   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11141   (exit $ac_status); } &&
11142          { ac_try='test -z "$ac_c_werror_flag"
11143                          || test ! -s conftest.err'
11144   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11145   (eval $ac_try) 2>&5
11146   ac_status=$?
11147   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11148   (exit $ac_status); }; } &&
11149          { ac_try='test -s conftest$ac_exeext'
11150   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11151   (eval $ac_try) 2>&5
11152   ac_status=$?
11153   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11154   (exit $ac_status); }; }; then
11155   ac_cv_lib_m_expf=yes
11156 else
11157   echo "$as_me: failed program was:" >&5
11158 sed 's/^/| /' conftest.$ac_ext >&5
11159
11160 ac_cv_lib_m_expf=no
11161 fi
11162 rm -f conftest.err conftest.$ac_objext \
11163       conftest$ac_exeext conftest.$ac_ext
11164 LIBS=$ac_check_lib_save_LIBS
11165 fi
11166 echo "$as_me:$LINENO: result: $ac_cv_lib_m_expf" >&5
11167 echo "${ECHO_T}$ac_cv_lib_m_expf" >&6
11168 if test $ac_cv_lib_m_expf = yes; then
11169
11170 cat >>confdefs.h <<\_ACEOF
11171 #define HAVE_EXPF 1
11172 _ACEOF
11173
11174 fi
11175
11176 echo "$as_me:$LINENO: checking for exp in -lm" >&5
11177 echo $ECHO_N "checking for exp in -lm... $ECHO_C" >&6
11178 if test "${ac_cv_lib_m_exp+set}" = set; then
11179   echo $ECHO_N "(cached) $ECHO_C" >&6
11180 else
11181   ac_check_lib_save_LIBS=$LIBS
11182 LIBS="-lm  $LIBS"
11183 if test x$gcc_no_link = xyes; then
11184   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11185 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11186    { (exit 1); exit 1; }; }
11187 fi
11188 cat >conftest.$ac_ext <<_ACEOF
11189 /* confdefs.h.  */
11190 _ACEOF
11191 cat confdefs.h >>conftest.$ac_ext
11192 cat >>conftest.$ac_ext <<_ACEOF
11193 /* end confdefs.h.  */
11194
11195 /* Override any gcc2 internal prototype to avoid an error.  */
11196 #ifdef __cplusplus
11197 extern "C"
11198 #endif
11199 /* We use char because int might match the return type of a gcc2
11200    builtin and then its argument prototype would still apply.  */
11201 char exp ();
11202 int
11203 main ()
11204 {
11205 exp ();
11206   ;
11207   return 0;
11208 }
11209 _ACEOF
11210 rm -f conftest.$ac_objext conftest$ac_exeext
11211 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11212   (eval $ac_link) 2>conftest.er1
11213   ac_status=$?
11214   grep -v '^ *+' conftest.er1 >conftest.err
11215   rm -f conftest.er1
11216   cat conftest.err >&5
11217   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11218   (exit $ac_status); } &&
11219          { ac_try='test -z "$ac_c_werror_flag"
11220                          || test ! -s conftest.err'
11221   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11222   (eval $ac_try) 2>&5
11223   ac_status=$?
11224   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11225   (exit $ac_status); }; } &&
11226          { ac_try='test -s conftest$ac_exeext'
11227   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11228   (eval $ac_try) 2>&5
11229   ac_status=$?
11230   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11231   (exit $ac_status); }; }; then
11232   ac_cv_lib_m_exp=yes
11233 else
11234   echo "$as_me: failed program was:" >&5
11235 sed 's/^/| /' conftest.$ac_ext >&5
11236
11237 ac_cv_lib_m_exp=no
11238 fi
11239 rm -f conftest.err conftest.$ac_objext \
11240       conftest$ac_exeext conftest.$ac_ext
11241 LIBS=$ac_check_lib_save_LIBS
11242 fi
11243 echo "$as_me:$LINENO: result: $ac_cv_lib_m_exp" >&5
11244 echo "${ECHO_T}$ac_cv_lib_m_exp" >&6
11245 if test $ac_cv_lib_m_exp = yes; then
11246
11247 cat >>confdefs.h <<\_ACEOF
11248 #define HAVE_EXP 1
11249 _ACEOF
11250
11251 fi
11252
11253 echo "$as_me:$LINENO: checking for expl in -lm" >&5
11254 echo $ECHO_N "checking for expl in -lm... $ECHO_C" >&6
11255 if test "${ac_cv_lib_m_expl+set}" = set; then
11256   echo $ECHO_N "(cached) $ECHO_C" >&6
11257 else
11258   ac_check_lib_save_LIBS=$LIBS
11259 LIBS="-lm  $LIBS"
11260 if test x$gcc_no_link = xyes; then
11261   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11262 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11263    { (exit 1); exit 1; }; }
11264 fi
11265 cat >conftest.$ac_ext <<_ACEOF
11266 /* confdefs.h.  */
11267 _ACEOF
11268 cat confdefs.h >>conftest.$ac_ext
11269 cat >>conftest.$ac_ext <<_ACEOF
11270 /* end confdefs.h.  */
11271
11272 /* Override any gcc2 internal prototype to avoid an error.  */
11273 #ifdef __cplusplus
11274 extern "C"
11275 #endif
11276 /* We use char because int might match the return type of a gcc2
11277    builtin and then its argument prototype would still apply.  */
11278 char expl ();
11279 int
11280 main ()
11281 {
11282 expl ();
11283   ;
11284   return 0;
11285 }
11286 _ACEOF
11287 rm -f conftest.$ac_objext conftest$ac_exeext
11288 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11289   (eval $ac_link) 2>conftest.er1
11290   ac_status=$?
11291   grep -v '^ *+' conftest.er1 >conftest.err
11292   rm -f conftest.er1
11293   cat conftest.err >&5
11294   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11295   (exit $ac_status); } &&
11296          { ac_try='test -z "$ac_c_werror_flag"
11297                          || test ! -s conftest.err'
11298   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11299   (eval $ac_try) 2>&5
11300   ac_status=$?
11301   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11302   (exit $ac_status); }; } &&
11303          { ac_try='test -s conftest$ac_exeext'
11304   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11305   (eval $ac_try) 2>&5
11306   ac_status=$?
11307   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11308   (exit $ac_status); }; }; then
11309   ac_cv_lib_m_expl=yes
11310 else
11311   echo "$as_me: failed program was:" >&5
11312 sed 's/^/| /' conftest.$ac_ext >&5
11313
11314 ac_cv_lib_m_expl=no
11315 fi
11316 rm -f conftest.err conftest.$ac_objext \
11317       conftest$ac_exeext conftest.$ac_ext
11318 LIBS=$ac_check_lib_save_LIBS
11319 fi
11320 echo "$as_me:$LINENO: result: $ac_cv_lib_m_expl" >&5
11321 echo "${ECHO_T}$ac_cv_lib_m_expl" >&6
11322 if test $ac_cv_lib_m_expl = yes; then
11323
11324 cat >>confdefs.h <<\_ACEOF
11325 #define HAVE_EXPL 1
11326 _ACEOF
11327
11328 fi
11329
11330 echo "$as_me:$LINENO: checking for cexpf in -lm" >&5
11331 echo $ECHO_N "checking for cexpf in -lm... $ECHO_C" >&6
11332 if test "${ac_cv_lib_m_cexpf+set}" = set; then
11333   echo $ECHO_N "(cached) $ECHO_C" >&6
11334 else
11335   ac_check_lib_save_LIBS=$LIBS
11336 LIBS="-lm  $LIBS"
11337 if test x$gcc_no_link = xyes; then
11338   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11339 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11340    { (exit 1); exit 1; }; }
11341 fi
11342 cat >conftest.$ac_ext <<_ACEOF
11343 /* confdefs.h.  */
11344 _ACEOF
11345 cat confdefs.h >>conftest.$ac_ext
11346 cat >>conftest.$ac_ext <<_ACEOF
11347 /* end confdefs.h.  */
11348
11349 /* Override any gcc2 internal prototype to avoid an error.  */
11350 #ifdef __cplusplus
11351 extern "C"
11352 #endif
11353 /* We use char because int might match the return type of a gcc2
11354    builtin and then its argument prototype would still apply.  */
11355 char cexpf ();
11356 int
11357 main ()
11358 {
11359 cexpf ();
11360   ;
11361   return 0;
11362 }
11363 _ACEOF
11364 rm -f conftest.$ac_objext conftest$ac_exeext
11365 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11366   (eval $ac_link) 2>conftest.er1
11367   ac_status=$?
11368   grep -v '^ *+' conftest.er1 >conftest.err
11369   rm -f conftest.er1
11370   cat conftest.err >&5
11371   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11372   (exit $ac_status); } &&
11373          { ac_try='test -z "$ac_c_werror_flag"
11374                          || test ! -s conftest.err'
11375   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11376   (eval $ac_try) 2>&5
11377   ac_status=$?
11378   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11379   (exit $ac_status); }; } &&
11380          { ac_try='test -s conftest$ac_exeext'
11381   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11382   (eval $ac_try) 2>&5
11383   ac_status=$?
11384   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11385   (exit $ac_status); }; }; then
11386   ac_cv_lib_m_cexpf=yes
11387 else
11388   echo "$as_me: failed program was:" >&5
11389 sed 's/^/| /' conftest.$ac_ext >&5
11390
11391 ac_cv_lib_m_cexpf=no
11392 fi
11393 rm -f conftest.err conftest.$ac_objext \
11394       conftest$ac_exeext conftest.$ac_ext
11395 LIBS=$ac_check_lib_save_LIBS
11396 fi
11397 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexpf" >&5
11398 echo "${ECHO_T}$ac_cv_lib_m_cexpf" >&6
11399 if test $ac_cv_lib_m_cexpf = yes; then
11400
11401 cat >>confdefs.h <<\_ACEOF
11402 #define HAVE_CEXPF 1
11403 _ACEOF
11404
11405 fi
11406
11407 echo "$as_me:$LINENO: checking for cexp in -lm" >&5
11408 echo $ECHO_N "checking for cexp in -lm... $ECHO_C" >&6
11409 if test "${ac_cv_lib_m_cexp+set}" = set; then
11410   echo $ECHO_N "(cached) $ECHO_C" >&6
11411 else
11412   ac_check_lib_save_LIBS=$LIBS
11413 LIBS="-lm  $LIBS"
11414 if test x$gcc_no_link = xyes; then
11415   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11416 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11417    { (exit 1); exit 1; }; }
11418 fi
11419 cat >conftest.$ac_ext <<_ACEOF
11420 /* confdefs.h.  */
11421 _ACEOF
11422 cat confdefs.h >>conftest.$ac_ext
11423 cat >>conftest.$ac_ext <<_ACEOF
11424 /* end confdefs.h.  */
11425
11426 /* Override any gcc2 internal prototype to avoid an error.  */
11427 #ifdef __cplusplus
11428 extern "C"
11429 #endif
11430 /* We use char because int might match the return type of a gcc2
11431    builtin and then its argument prototype would still apply.  */
11432 char cexp ();
11433 int
11434 main ()
11435 {
11436 cexp ();
11437   ;
11438   return 0;
11439 }
11440 _ACEOF
11441 rm -f conftest.$ac_objext conftest$ac_exeext
11442 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11443   (eval $ac_link) 2>conftest.er1
11444   ac_status=$?
11445   grep -v '^ *+' conftest.er1 >conftest.err
11446   rm -f conftest.er1
11447   cat conftest.err >&5
11448   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11449   (exit $ac_status); } &&
11450          { ac_try='test -z "$ac_c_werror_flag"
11451                          || test ! -s conftest.err'
11452   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11453   (eval $ac_try) 2>&5
11454   ac_status=$?
11455   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11456   (exit $ac_status); }; } &&
11457          { ac_try='test -s conftest$ac_exeext'
11458   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11459   (eval $ac_try) 2>&5
11460   ac_status=$?
11461   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11462   (exit $ac_status); }; }; then
11463   ac_cv_lib_m_cexp=yes
11464 else
11465   echo "$as_me: failed program was:" >&5
11466 sed 's/^/| /' conftest.$ac_ext >&5
11467
11468 ac_cv_lib_m_cexp=no
11469 fi
11470 rm -f conftest.err conftest.$ac_objext \
11471       conftest$ac_exeext conftest.$ac_ext
11472 LIBS=$ac_check_lib_save_LIBS
11473 fi
11474 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexp" >&5
11475 echo "${ECHO_T}$ac_cv_lib_m_cexp" >&6
11476 if test $ac_cv_lib_m_cexp = yes; then
11477
11478 cat >>confdefs.h <<\_ACEOF
11479 #define HAVE_CEXP 1
11480 _ACEOF
11481
11482 fi
11483
11484 echo "$as_me:$LINENO: checking for cexpl in -lm" >&5
11485 echo $ECHO_N "checking for cexpl in -lm... $ECHO_C" >&6
11486 if test "${ac_cv_lib_m_cexpl+set}" = set; then
11487   echo $ECHO_N "(cached) $ECHO_C" >&6
11488 else
11489   ac_check_lib_save_LIBS=$LIBS
11490 LIBS="-lm  $LIBS"
11491 if test x$gcc_no_link = xyes; then
11492   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11493 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11494    { (exit 1); exit 1; }; }
11495 fi
11496 cat >conftest.$ac_ext <<_ACEOF
11497 /* confdefs.h.  */
11498 _ACEOF
11499 cat confdefs.h >>conftest.$ac_ext
11500 cat >>conftest.$ac_ext <<_ACEOF
11501 /* end confdefs.h.  */
11502
11503 /* Override any gcc2 internal prototype to avoid an error.  */
11504 #ifdef __cplusplus
11505 extern "C"
11506 #endif
11507 /* We use char because int might match the return type of a gcc2
11508    builtin and then its argument prototype would still apply.  */
11509 char cexpl ();
11510 int
11511 main ()
11512 {
11513 cexpl ();
11514   ;
11515   return 0;
11516 }
11517 _ACEOF
11518 rm -f conftest.$ac_objext conftest$ac_exeext
11519 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11520   (eval $ac_link) 2>conftest.er1
11521   ac_status=$?
11522   grep -v '^ *+' conftest.er1 >conftest.err
11523   rm -f conftest.er1
11524   cat conftest.err >&5
11525   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11526   (exit $ac_status); } &&
11527          { ac_try='test -z "$ac_c_werror_flag"
11528                          || test ! -s conftest.err'
11529   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11530   (eval $ac_try) 2>&5
11531   ac_status=$?
11532   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11533   (exit $ac_status); }; } &&
11534          { ac_try='test -s conftest$ac_exeext'
11535   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11536   (eval $ac_try) 2>&5
11537   ac_status=$?
11538   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11539   (exit $ac_status); }; }; then
11540   ac_cv_lib_m_cexpl=yes
11541 else
11542   echo "$as_me: failed program was:" >&5
11543 sed 's/^/| /' conftest.$ac_ext >&5
11544
11545 ac_cv_lib_m_cexpl=no
11546 fi
11547 rm -f conftest.err conftest.$ac_objext \
11548       conftest$ac_exeext conftest.$ac_ext
11549 LIBS=$ac_check_lib_save_LIBS
11550 fi
11551 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexpl" >&5
11552 echo "${ECHO_T}$ac_cv_lib_m_cexpl" >&6
11553 if test $ac_cv_lib_m_cexpl = yes; then
11554
11555 cat >>confdefs.h <<\_ACEOF
11556 #define HAVE_CEXPL 1
11557 _ACEOF
11558
11559 fi
11560
11561 echo "$as_me:$LINENO: checking for fabsf in -lm" >&5
11562 echo $ECHO_N "checking for fabsf in -lm... $ECHO_C" >&6
11563 if test "${ac_cv_lib_m_fabsf+set}" = set; then
11564   echo $ECHO_N "(cached) $ECHO_C" >&6
11565 else
11566   ac_check_lib_save_LIBS=$LIBS
11567 LIBS="-lm  $LIBS"
11568 if test x$gcc_no_link = xyes; then
11569   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11570 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11571    { (exit 1); exit 1; }; }
11572 fi
11573 cat >conftest.$ac_ext <<_ACEOF
11574 /* confdefs.h.  */
11575 _ACEOF
11576 cat confdefs.h >>conftest.$ac_ext
11577 cat >>conftest.$ac_ext <<_ACEOF
11578 /* end confdefs.h.  */
11579
11580 /* Override any gcc2 internal prototype to avoid an error.  */
11581 #ifdef __cplusplus
11582 extern "C"
11583 #endif
11584 /* We use char because int might match the return type of a gcc2
11585    builtin and then its argument prototype would still apply.  */
11586 char fabsf ();
11587 int
11588 main ()
11589 {
11590 fabsf ();
11591   ;
11592   return 0;
11593 }
11594 _ACEOF
11595 rm -f conftest.$ac_objext conftest$ac_exeext
11596 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11597   (eval $ac_link) 2>conftest.er1
11598   ac_status=$?
11599   grep -v '^ *+' conftest.er1 >conftest.err
11600   rm -f conftest.er1
11601   cat conftest.err >&5
11602   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11603   (exit $ac_status); } &&
11604          { ac_try='test -z "$ac_c_werror_flag"
11605                          || test ! -s conftest.err'
11606   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11607   (eval $ac_try) 2>&5
11608   ac_status=$?
11609   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11610   (exit $ac_status); }; } &&
11611          { ac_try='test -s conftest$ac_exeext'
11612   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11613   (eval $ac_try) 2>&5
11614   ac_status=$?
11615   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11616   (exit $ac_status); }; }; then
11617   ac_cv_lib_m_fabsf=yes
11618 else
11619   echo "$as_me: failed program was:" >&5
11620 sed 's/^/| /' conftest.$ac_ext >&5
11621
11622 ac_cv_lib_m_fabsf=no
11623 fi
11624 rm -f conftest.err conftest.$ac_objext \
11625       conftest$ac_exeext conftest.$ac_ext
11626 LIBS=$ac_check_lib_save_LIBS
11627 fi
11628 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabsf" >&5
11629 echo "${ECHO_T}$ac_cv_lib_m_fabsf" >&6
11630 if test $ac_cv_lib_m_fabsf = yes; then
11631
11632 cat >>confdefs.h <<\_ACEOF
11633 #define HAVE_FABSF 1
11634 _ACEOF
11635
11636 fi
11637
11638 echo "$as_me:$LINENO: checking for fabs in -lm" >&5
11639 echo $ECHO_N "checking for fabs in -lm... $ECHO_C" >&6
11640 if test "${ac_cv_lib_m_fabs+set}" = set; then
11641   echo $ECHO_N "(cached) $ECHO_C" >&6
11642 else
11643   ac_check_lib_save_LIBS=$LIBS
11644 LIBS="-lm  $LIBS"
11645 if test x$gcc_no_link = xyes; then
11646   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11647 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11648    { (exit 1); exit 1; }; }
11649 fi
11650 cat >conftest.$ac_ext <<_ACEOF
11651 /* confdefs.h.  */
11652 _ACEOF
11653 cat confdefs.h >>conftest.$ac_ext
11654 cat >>conftest.$ac_ext <<_ACEOF
11655 /* end confdefs.h.  */
11656
11657 /* Override any gcc2 internal prototype to avoid an error.  */
11658 #ifdef __cplusplus
11659 extern "C"
11660 #endif
11661 /* We use char because int might match the return type of a gcc2
11662    builtin and then its argument prototype would still apply.  */
11663 char fabs ();
11664 int
11665 main ()
11666 {
11667 fabs ();
11668   ;
11669   return 0;
11670 }
11671 _ACEOF
11672 rm -f conftest.$ac_objext conftest$ac_exeext
11673 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11674   (eval $ac_link) 2>conftest.er1
11675   ac_status=$?
11676   grep -v '^ *+' conftest.er1 >conftest.err
11677   rm -f conftest.er1
11678   cat conftest.err >&5
11679   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11680   (exit $ac_status); } &&
11681          { ac_try='test -z "$ac_c_werror_flag"
11682                          || test ! -s conftest.err'
11683   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11684   (eval $ac_try) 2>&5
11685   ac_status=$?
11686   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11687   (exit $ac_status); }; } &&
11688          { ac_try='test -s conftest$ac_exeext'
11689   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11690   (eval $ac_try) 2>&5
11691   ac_status=$?
11692   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11693   (exit $ac_status); }; }; then
11694   ac_cv_lib_m_fabs=yes
11695 else
11696   echo "$as_me: failed program was:" >&5
11697 sed 's/^/| /' conftest.$ac_ext >&5
11698
11699 ac_cv_lib_m_fabs=no
11700 fi
11701 rm -f conftest.err conftest.$ac_objext \
11702       conftest$ac_exeext conftest.$ac_ext
11703 LIBS=$ac_check_lib_save_LIBS
11704 fi
11705 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabs" >&5
11706 echo "${ECHO_T}$ac_cv_lib_m_fabs" >&6
11707 if test $ac_cv_lib_m_fabs = yes; then
11708
11709 cat >>confdefs.h <<\_ACEOF
11710 #define HAVE_FABS 1
11711 _ACEOF
11712
11713 fi
11714
11715 echo "$as_me:$LINENO: checking for fabsl in -lm" >&5
11716 echo $ECHO_N "checking for fabsl in -lm... $ECHO_C" >&6
11717 if test "${ac_cv_lib_m_fabsl+set}" = set; then
11718   echo $ECHO_N "(cached) $ECHO_C" >&6
11719 else
11720   ac_check_lib_save_LIBS=$LIBS
11721 LIBS="-lm  $LIBS"
11722 if test x$gcc_no_link = xyes; then
11723   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11724 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11725    { (exit 1); exit 1; }; }
11726 fi
11727 cat >conftest.$ac_ext <<_ACEOF
11728 /* confdefs.h.  */
11729 _ACEOF
11730 cat confdefs.h >>conftest.$ac_ext
11731 cat >>conftest.$ac_ext <<_ACEOF
11732 /* end confdefs.h.  */
11733
11734 /* Override any gcc2 internal prototype to avoid an error.  */
11735 #ifdef __cplusplus
11736 extern "C"
11737 #endif
11738 /* We use char because int might match the return type of a gcc2
11739    builtin and then its argument prototype would still apply.  */
11740 char fabsl ();
11741 int
11742 main ()
11743 {
11744 fabsl ();
11745   ;
11746   return 0;
11747 }
11748 _ACEOF
11749 rm -f conftest.$ac_objext conftest$ac_exeext
11750 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11751   (eval $ac_link) 2>conftest.er1
11752   ac_status=$?
11753   grep -v '^ *+' conftest.er1 >conftest.err
11754   rm -f conftest.er1
11755   cat conftest.err >&5
11756   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11757   (exit $ac_status); } &&
11758          { ac_try='test -z "$ac_c_werror_flag"
11759                          || test ! -s conftest.err'
11760   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11761   (eval $ac_try) 2>&5
11762   ac_status=$?
11763   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11764   (exit $ac_status); }; } &&
11765          { ac_try='test -s conftest$ac_exeext'
11766   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11767   (eval $ac_try) 2>&5
11768   ac_status=$?
11769   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11770   (exit $ac_status); }; }; then
11771   ac_cv_lib_m_fabsl=yes
11772 else
11773   echo "$as_me: failed program was:" >&5
11774 sed 's/^/| /' conftest.$ac_ext >&5
11775
11776 ac_cv_lib_m_fabsl=no
11777 fi
11778 rm -f conftest.err conftest.$ac_objext \
11779       conftest$ac_exeext conftest.$ac_ext
11780 LIBS=$ac_check_lib_save_LIBS
11781 fi
11782 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabsl" >&5
11783 echo "${ECHO_T}$ac_cv_lib_m_fabsl" >&6
11784 if test $ac_cv_lib_m_fabsl = yes; then
11785
11786 cat >>confdefs.h <<\_ACEOF
11787 #define HAVE_FABSL 1
11788 _ACEOF
11789
11790 fi
11791
11792 echo "$as_me:$LINENO: checking for cabsf in -lm" >&5
11793 echo $ECHO_N "checking for cabsf in -lm... $ECHO_C" >&6
11794 if test "${ac_cv_lib_m_cabsf+set}" = set; then
11795   echo $ECHO_N "(cached) $ECHO_C" >&6
11796 else
11797   ac_check_lib_save_LIBS=$LIBS
11798 LIBS="-lm  $LIBS"
11799 if test x$gcc_no_link = xyes; then
11800   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11801 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11802    { (exit 1); exit 1; }; }
11803 fi
11804 cat >conftest.$ac_ext <<_ACEOF
11805 /* confdefs.h.  */
11806 _ACEOF
11807 cat confdefs.h >>conftest.$ac_ext
11808 cat >>conftest.$ac_ext <<_ACEOF
11809 /* end confdefs.h.  */
11810
11811 /* Override any gcc2 internal prototype to avoid an error.  */
11812 #ifdef __cplusplus
11813 extern "C"
11814 #endif
11815 /* We use char because int might match the return type of a gcc2
11816    builtin and then its argument prototype would still apply.  */
11817 char cabsf ();
11818 int
11819 main ()
11820 {
11821 cabsf ();
11822   ;
11823   return 0;
11824 }
11825 _ACEOF
11826 rm -f conftest.$ac_objext conftest$ac_exeext
11827 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11828   (eval $ac_link) 2>conftest.er1
11829   ac_status=$?
11830   grep -v '^ *+' conftest.er1 >conftest.err
11831   rm -f conftest.er1
11832   cat conftest.err >&5
11833   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11834   (exit $ac_status); } &&
11835          { ac_try='test -z "$ac_c_werror_flag"
11836                          || test ! -s conftest.err'
11837   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11838   (eval $ac_try) 2>&5
11839   ac_status=$?
11840   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11841   (exit $ac_status); }; } &&
11842          { ac_try='test -s conftest$ac_exeext'
11843   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11844   (eval $ac_try) 2>&5
11845   ac_status=$?
11846   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11847   (exit $ac_status); }; }; then
11848   ac_cv_lib_m_cabsf=yes
11849 else
11850   echo "$as_me: failed program was:" >&5
11851 sed 's/^/| /' conftest.$ac_ext >&5
11852
11853 ac_cv_lib_m_cabsf=no
11854 fi
11855 rm -f conftest.err conftest.$ac_objext \
11856       conftest$ac_exeext conftest.$ac_ext
11857 LIBS=$ac_check_lib_save_LIBS
11858 fi
11859 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabsf" >&5
11860 echo "${ECHO_T}$ac_cv_lib_m_cabsf" >&6
11861 if test $ac_cv_lib_m_cabsf = yes; then
11862
11863 cat >>confdefs.h <<\_ACEOF
11864 #define HAVE_CABSF 1
11865 _ACEOF
11866
11867 fi
11868
11869 echo "$as_me:$LINENO: checking for cabs in -lm" >&5
11870 echo $ECHO_N "checking for cabs in -lm... $ECHO_C" >&6
11871 if test "${ac_cv_lib_m_cabs+set}" = set; then
11872   echo $ECHO_N "(cached) $ECHO_C" >&6
11873 else
11874   ac_check_lib_save_LIBS=$LIBS
11875 LIBS="-lm  $LIBS"
11876 if test x$gcc_no_link = xyes; then
11877   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11878 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11879    { (exit 1); exit 1; }; }
11880 fi
11881 cat >conftest.$ac_ext <<_ACEOF
11882 /* confdefs.h.  */
11883 _ACEOF
11884 cat confdefs.h >>conftest.$ac_ext
11885 cat >>conftest.$ac_ext <<_ACEOF
11886 /* end confdefs.h.  */
11887
11888 /* Override any gcc2 internal prototype to avoid an error.  */
11889 #ifdef __cplusplus
11890 extern "C"
11891 #endif
11892 /* We use char because int might match the return type of a gcc2
11893    builtin and then its argument prototype would still apply.  */
11894 char cabs ();
11895 int
11896 main ()
11897 {
11898 cabs ();
11899   ;
11900   return 0;
11901 }
11902 _ACEOF
11903 rm -f conftest.$ac_objext conftest$ac_exeext
11904 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11905   (eval $ac_link) 2>conftest.er1
11906   ac_status=$?
11907   grep -v '^ *+' conftest.er1 >conftest.err
11908   rm -f conftest.er1
11909   cat conftest.err >&5
11910   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11911   (exit $ac_status); } &&
11912          { ac_try='test -z "$ac_c_werror_flag"
11913                          || test ! -s conftest.err'
11914   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11915   (eval $ac_try) 2>&5
11916   ac_status=$?
11917   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11918   (exit $ac_status); }; } &&
11919          { ac_try='test -s conftest$ac_exeext'
11920   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11921   (eval $ac_try) 2>&5
11922   ac_status=$?
11923   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11924   (exit $ac_status); }; }; then
11925   ac_cv_lib_m_cabs=yes
11926 else
11927   echo "$as_me: failed program was:" >&5
11928 sed 's/^/| /' conftest.$ac_ext >&5
11929
11930 ac_cv_lib_m_cabs=no
11931 fi
11932 rm -f conftest.err conftest.$ac_objext \
11933       conftest$ac_exeext conftest.$ac_ext
11934 LIBS=$ac_check_lib_save_LIBS
11935 fi
11936 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabs" >&5
11937 echo "${ECHO_T}$ac_cv_lib_m_cabs" >&6
11938 if test $ac_cv_lib_m_cabs = yes; then
11939
11940 cat >>confdefs.h <<\_ACEOF
11941 #define HAVE_CABS 1
11942 _ACEOF
11943
11944 fi
11945
11946 echo "$as_me:$LINENO: checking for cabsl in -lm" >&5
11947 echo $ECHO_N "checking for cabsl in -lm... $ECHO_C" >&6
11948 if test "${ac_cv_lib_m_cabsl+set}" = set; then
11949   echo $ECHO_N "(cached) $ECHO_C" >&6
11950 else
11951   ac_check_lib_save_LIBS=$LIBS
11952 LIBS="-lm  $LIBS"
11953 if test x$gcc_no_link = xyes; then
11954   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11955 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11956    { (exit 1); exit 1; }; }
11957 fi
11958 cat >conftest.$ac_ext <<_ACEOF
11959 /* confdefs.h.  */
11960 _ACEOF
11961 cat confdefs.h >>conftest.$ac_ext
11962 cat >>conftest.$ac_ext <<_ACEOF
11963 /* end confdefs.h.  */
11964
11965 /* Override any gcc2 internal prototype to avoid an error.  */
11966 #ifdef __cplusplus
11967 extern "C"
11968 #endif
11969 /* We use char because int might match the return type of a gcc2
11970    builtin and then its argument prototype would still apply.  */
11971 char cabsl ();
11972 int
11973 main ()
11974 {
11975 cabsl ();
11976   ;
11977   return 0;
11978 }
11979 _ACEOF
11980 rm -f conftest.$ac_objext conftest$ac_exeext
11981 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11982   (eval $ac_link) 2>conftest.er1
11983   ac_status=$?
11984   grep -v '^ *+' conftest.er1 >conftest.err
11985   rm -f conftest.er1
11986   cat conftest.err >&5
11987   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11988   (exit $ac_status); } &&
11989          { ac_try='test -z "$ac_c_werror_flag"
11990                          || test ! -s conftest.err'
11991   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11992   (eval $ac_try) 2>&5
11993   ac_status=$?
11994   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11995   (exit $ac_status); }; } &&
11996          { ac_try='test -s conftest$ac_exeext'
11997   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11998   (eval $ac_try) 2>&5
11999   ac_status=$?
12000   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12001   (exit $ac_status); }; }; then
12002   ac_cv_lib_m_cabsl=yes
12003 else
12004   echo "$as_me: failed program was:" >&5
12005 sed 's/^/| /' conftest.$ac_ext >&5
12006
12007 ac_cv_lib_m_cabsl=no
12008 fi
12009 rm -f conftest.err conftest.$ac_objext \
12010       conftest$ac_exeext conftest.$ac_ext
12011 LIBS=$ac_check_lib_save_LIBS
12012 fi
12013 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabsl" >&5
12014 echo "${ECHO_T}$ac_cv_lib_m_cabsl" >&6
12015 if test $ac_cv_lib_m_cabsl = yes; then
12016
12017 cat >>confdefs.h <<\_ACEOF
12018 #define HAVE_CABSL 1
12019 _ACEOF
12020
12021 fi
12022
12023 echo "$as_me:$LINENO: checking for floorf in -lm" >&5
12024 echo $ECHO_N "checking for floorf in -lm... $ECHO_C" >&6
12025 if test "${ac_cv_lib_m_floorf+set}" = set; then
12026   echo $ECHO_N "(cached) $ECHO_C" >&6
12027 else
12028   ac_check_lib_save_LIBS=$LIBS
12029 LIBS="-lm  $LIBS"
12030 if test x$gcc_no_link = xyes; then
12031   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12032 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12033    { (exit 1); exit 1; }; }
12034 fi
12035 cat >conftest.$ac_ext <<_ACEOF
12036 /* confdefs.h.  */
12037 _ACEOF
12038 cat confdefs.h >>conftest.$ac_ext
12039 cat >>conftest.$ac_ext <<_ACEOF
12040 /* end confdefs.h.  */
12041
12042 /* Override any gcc2 internal prototype to avoid an error.  */
12043 #ifdef __cplusplus
12044 extern "C"
12045 #endif
12046 /* We use char because int might match the return type of a gcc2
12047    builtin and then its argument prototype would still apply.  */
12048 char floorf ();
12049 int
12050 main ()
12051 {
12052 floorf ();
12053   ;
12054   return 0;
12055 }
12056 _ACEOF
12057 rm -f conftest.$ac_objext conftest$ac_exeext
12058 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12059   (eval $ac_link) 2>conftest.er1
12060   ac_status=$?
12061   grep -v '^ *+' conftest.er1 >conftest.err
12062   rm -f conftest.er1
12063   cat conftest.err >&5
12064   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12065   (exit $ac_status); } &&
12066          { ac_try='test -z "$ac_c_werror_flag"
12067                          || test ! -s conftest.err'
12068   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12069   (eval $ac_try) 2>&5
12070   ac_status=$?
12071   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12072   (exit $ac_status); }; } &&
12073          { ac_try='test -s conftest$ac_exeext'
12074   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12075   (eval $ac_try) 2>&5
12076   ac_status=$?
12077   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12078   (exit $ac_status); }; }; then
12079   ac_cv_lib_m_floorf=yes
12080 else
12081   echo "$as_me: failed program was:" >&5
12082 sed 's/^/| /' conftest.$ac_ext >&5
12083
12084 ac_cv_lib_m_floorf=no
12085 fi
12086 rm -f conftest.err conftest.$ac_objext \
12087       conftest$ac_exeext conftest.$ac_ext
12088 LIBS=$ac_check_lib_save_LIBS
12089 fi
12090 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floorf" >&5
12091 echo "${ECHO_T}$ac_cv_lib_m_floorf" >&6
12092 if test $ac_cv_lib_m_floorf = yes; then
12093
12094 cat >>confdefs.h <<\_ACEOF
12095 #define HAVE_FLOORF 1
12096 _ACEOF
12097
12098 fi
12099
12100 echo "$as_me:$LINENO: checking for floor in -lm" >&5
12101 echo $ECHO_N "checking for floor in -lm... $ECHO_C" >&6
12102 if test "${ac_cv_lib_m_floor+set}" = set; then
12103   echo $ECHO_N "(cached) $ECHO_C" >&6
12104 else
12105   ac_check_lib_save_LIBS=$LIBS
12106 LIBS="-lm  $LIBS"
12107 if test x$gcc_no_link = xyes; then
12108   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12109 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12110    { (exit 1); exit 1; }; }
12111 fi
12112 cat >conftest.$ac_ext <<_ACEOF
12113 /* confdefs.h.  */
12114 _ACEOF
12115 cat confdefs.h >>conftest.$ac_ext
12116 cat >>conftest.$ac_ext <<_ACEOF
12117 /* end confdefs.h.  */
12118
12119 /* Override any gcc2 internal prototype to avoid an error.  */
12120 #ifdef __cplusplus
12121 extern "C"
12122 #endif
12123 /* We use char because int might match the return type of a gcc2
12124    builtin and then its argument prototype would still apply.  */
12125 char floor ();
12126 int
12127 main ()
12128 {
12129 floor ();
12130   ;
12131   return 0;
12132 }
12133 _ACEOF
12134 rm -f conftest.$ac_objext conftest$ac_exeext
12135 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12136   (eval $ac_link) 2>conftest.er1
12137   ac_status=$?
12138   grep -v '^ *+' conftest.er1 >conftest.err
12139   rm -f conftest.er1
12140   cat conftest.err >&5
12141   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12142   (exit $ac_status); } &&
12143          { ac_try='test -z "$ac_c_werror_flag"
12144                          || test ! -s conftest.err'
12145   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12146   (eval $ac_try) 2>&5
12147   ac_status=$?
12148   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12149   (exit $ac_status); }; } &&
12150          { ac_try='test -s conftest$ac_exeext'
12151   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12152   (eval $ac_try) 2>&5
12153   ac_status=$?
12154   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12155   (exit $ac_status); }; }; then
12156   ac_cv_lib_m_floor=yes
12157 else
12158   echo "$as_me: failed program was:" >&5
12159 sed 's/^/| /' conftest.$ac_ext >&5
12160
12161 ac_cv_lib_m_floor=no
12162 fi
12163 rm -f conftest.err conftest.$ac_objext \
12164       conftest$ac_exeext conftest.$ac_ext
12165 LIBS=$ac_check_lib_save_LIBS
12166 fi
12167 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floor" >&5
12168 echo "${ECHO_T}$ac_cv_lib_m_floor" >&6
12169 if test $ac_cv_lib_m_floor = yes; then
12170
12171 cat >>confdefs.h <<\_ACEOF
12172 #define HAVE_FLOOR 1
12173 _ACEOF
12174
12175 fi
12176
12177 echo "$as_me:$LINENO: checking for floorl in -lm" >&5
12178 echo $ECHO_N "checking for floorl in -lm... $ECHO_C" >&6
12179 if test "${ac_cv_lib_m_floorl+set}" = set; then
12180   echo $ECHO_N "(cached) $ECHO_C" >&6
12181 else
12182   ac_check_lib_save_LIBS=$LIBS
12183 LIBS="-lm  $LIBS"
12184 if test x$gcc_no_link = xyes; then
12185   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12186 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12187    { (exit 1); exit 1; }; }
12188 fi
12189 cat >conftest.$ac_ext <<_ACEOF
12190 /* confdefs.h.  */
12191 _ACEOF
12192 cat confdefs.h >>conftest.$ac_ext
12193 cat >>conftest.$ac_ext <<_ACEOF
12194 /* end confdefs.h.  */
12195
12196 /* Override any gcc2 internal prototype to avoid an error.  */
12197 #ifdef __cplusplus
12198 extern "C"
12199 #endif
12200 /* We use char because int might match the return type of a gcc2
12201    builtin and then its argument prototype would still apply.  */
12202 char floorl ();
12203 int
12204 main ()
12205 {
12206 floorl ();
12207   ;
12208   return 0;
12209 }
12210 _ACEOF
12211 rm -f conftest.$ac_objext conftest$ac_exeext
12212 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12213   (eval $ac_link) 2>conftest.er1
12214   ac_status=$?
12215   grep -v '^ *+' conftest.er1 >conftest.err
12216   rm -f conftest.er1
12217   cat conftest.err >&5
12218   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12219   (exit $ac_status); } &&
12220          { ac_try='test -z "$ac_c_werror_flag"
12221                          || test ! -s conftest.err'
12222   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12223   (eval $ac_try) 2>&5
12224   ac_status=$?
12225   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12226   (exit $ac_status); }; } &&
12227          { ac_try='test -s conftest$ac_exeext'
12228   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12229   (eval $ac_try) 2>&5
12230   ac_status=$?
12231   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12232   (exit $ac_status); }; }; then
12233   ac_cv_lib_m_floorl=yes
12234 else
12235   echo "$as_me: failed program was:" >&5
12236 sed 's/^/| /' conftest.$ac_ext >&5
12237
12238 ac_cv_lib_m_floorl=no
12239 fi
12240 rm -f conftest.err conftest.$ac_objext \
12241       conftest$ac_exeext conftest.$ac_ext
12242 LIBS=$ac_check_lib_save_LIBS
12243 fi
12244 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floorl" >&5
12245 echo "${ECHO_T}$ac_cv_lib_m_floorl" >&6
12246 if test $ac_cv_lib_m_floorl = yes; then
12247
12248 cat >>confdefs.h <<\_ACEOF
12249 #define HAVE_FLOORL 1
12250 _ACEOF
12251
12252 fi
12253
12254 echo "$as_me:$LINENO: checking for frexpf in -lm" >&5
12255 echo $ECHO_N "checking for frexpf in -lm... $ECHO_C" >&6
12256 if test "${ac_cv_lib_m_frexpf+set}" = set; then
12257   echo $ECHO_N "(cached) $ECHO_C" >&6
12258 else
12259   ac_check_lib_save_LIBS=$LIBS
12260 LIBS="-lm  $LIBS"
12261 if test x$gcc_no_link = xyes; then
12262   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12263 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12264    { (exit 1); exit 1; }; }
12265 fi
12266 cat >conftest.$ac_ext <<_ACEOF
12267 /* confdefs.h.  */
12268 _ACEOF
12269 cat confdefs.h >>conftest.$ac_ext
12270 cat >>conftest.$ac_ext <<_ACEOF
12271 /* end confdefs.h.  */
12272
12273 /* Override any gcc2 internal prototype to avoid an error.  */
12274 #ifdef __cplusplus
12275 extern "C"
12276 #endif
12277 /* We use char because int might match the return type of a gcc2
12278    builtin and then its argument prototype would still apply.  */
12279 char frexpf ();
12280 int
12281 main ()
12282 {
12283 frexpf ();
12284   ;
12285   return 0;
12286 }
12287 _ACEOF
12288 rm -f conftest.$ac_objext conftest$ac_exeext
12289 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12290   (eval $ac_link) 2>conftest.er1
12291   ac_status=$?
12292   grep -v '^ *+' conftest.er1 >conftest.err
12293   rm -f conftest.er1
12294   cat conftest.err >&5
12295   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12296   (exit $ac_status); } &&
12297          { ac_try='test -z "$ac_c_werror_flag"
12298                          || test ! -s conftest.err'
12299   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12300   (eval $ac_try) 2>&5
12301   ac_status=$?
12302   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12303   (exit $ac_status); }; } &&
12304          { ac_try='test -s conftest$ac_exeext'
12305   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12306   (eval $ac_try) 2>&5
12307   ac_status=$?
12308   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12309   (exit $ac_status); }; }; then
12310   ac_cv_lib_m_frexpf=yes
12311 else
12312   echo "$as_me: failed program was:" >&5
12313 sed 's/^/| /' conftest.$ac_ext >&5
12314
12315 ac_cv_lib_m_frexpf=no
12316 fi
12317 rm -f conftest.err conftest.$ac_objext \
12318       conftest$ac_exeext conftest.$ac_ext
12319 LIBS=$ac_check_lib_save_LIBS
12320 fi
12321 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexpf" >&5
12322 echo "${ECHO_T}$ac_cv_lib_m_frexpf" >&6
12323 if test $ac_cv_lib_m_frexpf = yes; then
12324
12325 cat >>confdefs.h <<\_ACEOF
12326 #define HAVE_FREXPF 1
12327 _ACEOF
12328
12329 fi
12330
12331 echo "$as_me:$LINENO: checking for frexp in -lm" >&5
12332 echo $ECHO_N "checking for frexp in -lm... $ECHO_C" >&6
12333 if test "${ac_cv_lib_m_frexp+set}" = set; then
12334   echo $ECHO_N "(cached) $ECHO_C" >&6
12335 else
12336   ac_check_lib_save_LIBS=$LIBS
12337 LIBS="-lm  $LIBS"
12338 if test x$gcc_no_link = xyes; then
12339   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12340 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12341    { (exit 1); exit 1; }; }
12342 fi
12343 cat >conftest.$ac_ext <<_ACEOF
12344 /* confdefs.h.  */
12345 _ACEOF
12346 cat confdefs.h >>conftest.$ac_ext
12347 cat >>conftest.$ac_ext <<_ACEOF
12348 /* end confdefs.h.  */
12349
12350 /* Override any gcc2 internal prototype to avoid an error.  */
12351 #ifdef __cplusplus
12352 extern "C"
12353 #endif
12354 /* We use char because int might match the return type of a gcc2
12355    builtin and then its argument prototype would still apply.  */
12356 char frexp ();
12357 int
12358 main ()
12359 {
12360 frexp ();
12361   ;
12362   return 0;
12363 }
12364 _ACEOF
12365 rm -f conftest.$ac_objext conftest$ac_exeext
12366 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12367   (eval $ac_link) 2>conftest.er1
12368   ac_status=$?
12369   grep -v '^ *+' conftest.er1 >conftest.err
12370   rm -f conftest.er1
12371   cat conftest.err >&5
12372   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12373   (exit $ac_status); } &&
12374          { ac_try='test -z "$ac_c_werror_flag"
12375                          || test ! -s conftest.err'
12376   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12377   (eval $ac_try) 2>&5
12378   ac_status=$?
12379   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12380   (exit $ac_status); }; } &&
12381          { ac_try='test -s conftest$ac_exeext'
12382   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12383   (eval $ac_try) 2>&5
12384   ac_status=$?
12385   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12386   (exit $ac_status); }; }; then
12387   ac_cv_lib_m_frexp=yes
12388 else
12389   echo "$as_me: failed program was:" >&5
12390 sed 's/^/| /' conftest.$ac_ext >&5
12391
12392 ac_cv_lib_m_frexp=no
12393 fi
12394 rm -f conftest.err conftest.$ac_objext \
12395       conftest$ac_exeext conftest.$ac_ext
12396 LIBS=$ac_check_lib_save_LIBS
12397 fi
12398 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexp" >&5
12399 echo "${ECHO_T}$ac_cv_lib_m_frexp" >&6
12400 if test $ac_cv_lib_m_frexp = yes; then
12401
12402 cat >>confdefs.h <<\_ACEOF
12403 #define HAVE_FREXP 1
12404 _ACEOF
12405
12406 fi
12407
12408 echo "$as_me:$LINENO: checking for frexpl in -lm" >&5
12409 echo $ECHO_N "checking for frexpl in -lm... $ECHO_C" >&6
12410 if test "${ac_cv_lib_m_frexpl+set}" = set; then
12411   echo $ECHO_N "(cached) $ECHO_C" >&6
12412 else
12413   ac_check_lib_save_LIBS=$LIBS
12414 LIBS="-lm  $LIBS"
12415 if test x$gcc_no_link = xyes; then
12416   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12417 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12418    { (exit 1); exit 1; }; }
12419 fi
12420 cat >conftest.$ac_ext <<_ACEOF
12421 /* confdefs.h.  */
12422 _ACEOF
12423 cat confdefs.h >>conftest.$ac_ext
12424 cat >>conftest.$ac_ext <<_ACEOF
12425 /* end confdefs.h.  */
12426
12427 /* Override any gcc2 internal prototype to avoid an error.  */
12428 #ifdef __cplusplus
12429 extern "C"
12430 #endif
12431 /* We use char because int might match the return type of a gcc2
12432    builtin and then its argument prototype would still apply.  */
12433 char frexpl ();
12434 int
12435 main ()
12436 {
12437 frexpl ();
12438   ;
12439   return 0;
12440 }
12441 _ACEOF
12442 rm -f conftest.$ac_objext conftest$ac_exeext
12443 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12444   (eval $ac_link) 2>conftest.er1
12445   ac_status=$?
12446   grep -v '^ *+' conftest.er1 >conftest.err
12447   rm -f conftest.er1
12448   cat conftest.err >&5
12449   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12450   (exit $ac_status); } &&
12451          { ac_try='test -z "$ac_c_werror_flag"
12452                          || test ! -s conftest.err'
12453   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12454   (eval $ac_try) 2>&5
12455   ac_status=$?
12456   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12457   (exit $ac_status); }; } &&
12458          { ac_try='test -s conftest$ac_exeext'
12459   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12460   (eval $ac_try) 2>&5
12461   ac_status=$?
12462   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12463   (exit $ac_status); }; }; then
12464   ac_cv_lib_m_frexpl=yes
12465 else
12466   echo "$as_me: failed program was:" >&5
12467 sed 's/^/| /' conftest.$ac_ext >&5
12468
12469 ac_cv_lib_m_frexpl=no
12470 fi
12471 rm -f conftest.err conftest.$ac_objext \
12472       conftest$ac_exeext conftest.$ac_ext
12473 LIBS=$ac_check_lib_save_LIBS
12474 fi
12475 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexpl" >&5
12476 echo "${ECHO_T}$ac_cv_lib_m_frexpl" >&6
12477 if test $ac_cv_lib_m_frexpl = yes; then
12478
12479 cat >>confdefs.h <<\_ACEOF
12480 #define HAVE_FREXPL 1
12481 _ACEOF
12482
12483 fi
12484
12485 echo "$as_me:$LINENO: checking for hypotf in -lm" >&5
12486 echo $ECHO_N "checking for hypotf in -lm... $ECHO_C" >&6
12487 if test "${ac_cv_lib_m_hypotf+set}" = set; then
12488   echo $ECHO_N "(cached) $ECHO_C" >&6
12489 else
12490   ac_check_lib_save_LIBS=$LIBS
12491 LIBS="-lm  $LIBS"
12492 if test x$gcc_no_link = xyes; then
12493   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12494 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12495    { (exit 1); exit 1; }; }
12496 fi
12497 cat >conftest.$ac_ext <<_ACEOF
12498 /* confdefs.h.  */
12499 _ACEOF
12500 cat confdefs.h >>conftest.$ac_ext
12501 cat >>conftest.$ac_ext <<_ACEOF
12502 /* end confdefs.h.  */
12503
12504 /* Override any gcc2 internal prototype to avoid an error.  */
12505 #ifdef __cplusplus
12506 extern "C"
12507 #endif
12508 /* We use char because int might match the return type of a gcc2
12509    builtin and then its argument prototype would still apply.  */
12510 char hypotf ();
12511 int
12512 main ()
12513 {
12514 hypotf ();
12515   ;
12516   return 0;
12517 }
12518 _ACEOF
12519 rm -f conftest.$ac_objext conftest$ac_exeext
12520 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12521   (eval $ac_link) 2>conftest.er1
12522   ac_status=$?
12523   grep -v '^ *+' conftest.er1 >conftest.err
12524   rm -f conftest.er1
12525   cat conftest.err >&5
12526   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12527   (exit $ac_status); } &&
12528          { ac_try='test -z "$ac_c_werror_flag"
12529                          || test ! -s conftest.err'
12530   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12531   (eval $ac_try) 2>&5
12532   ac_status=$?
12533   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12534   (exit $ac_status); }; } &&
12535          { ac_try='test -s conftest$ac_exeext'
12536   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12537   (eval $ac_try) 2>&5
12538   ac_status=$?
12539   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12540   (exit $ac_status); }; }; then
12541   ac_cv_lib_m_hypotf=yes
12542 else
12543   echo "$as_me: failed program was:" >&5
12544 sed 's/^/| /' conftest.$ac_ext >&5
12545
12546 ac_cv_lib_m_hypotf=no
12547 fi
12548 rm -f conftest.err conftest.$ac_objext \
12549       conftest$ac_exeext conftest.$ac_ext
12550 LIBS=$ac_check_lib_save_LIBS
12551 fi
12552 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypotf" >&5
12553 echo "${ECHO_T}$ac_cv_lib_m_hypotf" >&6
12554 if test $ac_cv_lib_m_hypotf = yes; then
12555
12556 cat >>confdefs.h <<\_ACEOF
12557 #define HAVE_HYPOTF 1
12558 _ACEOF
12559
12560 fi
12561
12562 echo "$as_me:$LINENO: checking for hypot in -lm" >&5
12563 echo $ECHO_N "checking for hypot in -lm... $ECHO_C" >&6
12564 if test "${ac_cv_lib_m_hypot+set}" = set; then
12565   echo $ECHO_N "(cached) $ECHO_C" >&6
12566 else
12567   ac_check_lib_save_LIBS=$LIBS
12568 LIBS="-lm  $LIBS"
12569 if test x$gcc_no_link = xyes; then
12570   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12571 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12572    { (exit 1); exit 1; }; }
12573 fi
12574 cat >conftest.$ac_ext <<_ACEOF
12575 /* confdefs.h.  */
12576 _ACEOF
12577 cat confdefs.h >>conftest.$ac_ext
12578 cat >>conftest.$ac_ext <<_ACEOF
12579 /* end confdefs.h.  */
12580
12581 /* Override any gcc2 internal prototype to avoid an error.  */
12582 #ifdef __cplusplus
12583 extern "C"
12584 #endif
12585 /* We use char because int might match the return type of a gcc2
12586    builtin and then its argument prototype would still apply.  */
12587 char hypot ();
12588 int
12589 main ()
12590 {
12591 hypot ();
12592   ;
12593   return 0;
12594 }
12595 _ACEOF
12596 rm -f conftest.$ac_objext conftest$ac_exeext
12597 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12598   (eval $ac_link) 2>conftest.er1
12599   ac_status=$?
12600   grep -v '^ *+' conftest.er1 >conftest.err
12601   rm -f conftest.er1
12602   cat conftest.err >&5
12603   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12604   (exit $ac_status); } &&
12605          { ac_try='test -z "$ac_c_werror_flag"
12606                          || test ! -s conftest.err'
12607   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12608   (eval $ac_try) 2>&5
12609   ac_status=$?
12610   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12611   (exit $ac_status); }; } &&
12612          { ac_try='test -s conftest$ac_exeext'
12613   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12614   (eval $ac_try) 2>&5
12615   ac_status=$?
12616   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12617   (exit $ac_status); }; }; then
12618   ac_cv_lib_m_hypot=yes
12619 else
12620   echo "$as_me: failed program was:" >&5
12621 sed 's/^/| /' conftest.$ac_ext >&5
12622
12623 ac_cv_lib_m_hypot=no
12624 fi
12625 rm -f conftest.err conftest.$ac_objext \
12626       conftest$ac_exeext conftest.$ac_ext
12627 LIBS=$ac_check_lib_save_LIBS
12628 fi
12629 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypot" >&5
12630 echo "${ECHO_T}$ac_cv_lib_m_hypot" >&6
12631 if test $ac_cv_lib_m_hypot = yes; then
12632
12633 cat >>confdefs.h <<\_ACEOF
12634 #define HAVE_HYPOT 1
12635 _ACEOF
12636
12637 fi
12638
12639 echo "$as_me:$LINENO: checking for hypotl in -lm" >&5
12640 echo $ECHO_N "checking for hypotl in -lm... $ECHO_C" >&6
12641 if test "${ac_cv_lib_m_hypotl+set}" = set; then
12642   echo $ECHO_N "(cached) $ECHO_C" >&6
12643 else
12644   ac_check_lib_save_LIBS=$LIBS
12645 LIBS="-lm  $LIBS"
12646 if test x$gcc_no_link = xyes; then
12647   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12648 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12649    { (exit 1); exit 1; }; }
12650 fi
12651 cat >conftest.$ac_ext <<_ACEOF
12652 /* confdefs.h.  */
12653 _ACEOF
12654 cat confdefs.h >>conftest.$ac_ext
12655 cat >>conftest.$ac_ext <<_ACEOF
12656 /* end confdefs.h.  */
12657
12658 /* Override any gcc2 internal prototype to avoid an error.  */
12659 #ifdef __cplusplus
12660 extern "C"
12661 #endif
12662 /* We use char because int might match the return type of a gcc2
12663    builtin and then its argument prototype would still apply.  */
12664 char hypotl ();
12665 int
12666 main ()
12667 {
12668 hypotl ();
12669   ;
12670   return 0;
12671 }
12672 _ACEOF
12673 rm -f conftest.$ac_objext conftest$ac_exeext
12674 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12675   (eval $ac_link) 2>conftest.er1
12676   ac_status=$?
12677   grep -v '^ *+' conftest.er1 >conftest.err
12678   rm -f conftest.er1
12679   cat conftest.err >&5
12680   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12681   (exit $ac_status); } &&
12682          { ac_try='test -z "$ac_c_werror_flag"
12683                          || test ! -s conftest.err'
12684   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12685   (eval $ac_try) 2>&5
12686   ac_status=$?
12687   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12688   (exit $ac_status); }; } &&
12689          { ac_try='test -s conftest$ac_exeext'
12690   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12691   (eval $ac_try) 2>&5
12692   ac_status=$?
12693   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12694   (exit $ac_status); }; }; then
12695   ac_cv_lib_m_hypotl=yes
12696 else
12697   echo "$as_me: failed program was:" >&5
12698 sed 's/^/| /' conftest.$ac_ext >&5
12699
12700 ac_cv_lib_m_hypotl=no
12701 fi
12702 rm -f conftest.err conftest.$ac_objext \
12703       conftest$ac_exeext conftest.$ac_ext
12704 LIBS=$ac_check_lib_save_LIBS
12705 fi
12706 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypotl" >&5
12707 echo "${ECHO_T}$ac_cv_lib_m_hypotl" >&6
12708 if test $ac_cv_lib_m_hypotl = yes; then
12709
12710 cat >>confdefs.h <<\_ACEOF
12711 #define HAVE_HYPOTL 1
12712 _ACEOF
12713
12714 fi
12715
12716 echo "$as_me:$LINENO: checking for logf in -lm" >&5
12717 echo $ECHO_N "checking for logf in -lm... $ECHO_C" >&6
12718 if test "${ac_cv_lib_m_logf+set}" = set; then
12719   echo $ECHO_N "(cached) $ECHO_C" >&6
12720 else
12721   ac_check_lib_save_LIBS=$LIBS
12722 LIBS="-lm  $LIBS"
12723 if test x$gcc_no_link = xyes; then
12724   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12725 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12726    { (exit 1); exit 1; }; }
12727 fi
12728 cat >conftest.$ac_ext <<_ACEOF
12729 /* confdefs.h.  */
12730 _ACEOF
12731 cat confdefs.h >>conftest.$ac_ext
12732 cat >>conftest.$ac_ext <<_ACEOF
12733 /* end confdefs.h.  */
12734
12735 /* Override any gcc2 internal prototype to avoid an error.  */
12736 #ifdef __cplusplus
12737 extern "C"
12738 #endif
12739 /* We use char because int might match the return type of a gcc2
12740    builtin and then its argument prototype would still apply.  */
12741 char logf ();
12742 int
12743 main ()
12744 {
12745 logf ();
12746   ;
12747   return 0;
12748 }
12749 _ACEOF
12750 rm -f conftest.$ac_objext conftest$ac_exeext
12751 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12752   (eval $ac_link) 2>conftest.er1
12753   ac_status=$?
12754   grep -v '^ *+' conftest.er1 >conftest.err
12755   rm -f conftest.er1
12756   cat conftest.err >&5
12757   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12758   (exit $ac_status); } &&
12759          { ac_try='test -z "$ac_c_werror_flag"
12760                          || test ! -s conftest.err'
12761   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12762   (eval $ac_try) 2>&5
12763   ac_status=$?
12764   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12765   (exit $ac_status); }; } &&
12766          { ac_try='test -s conftest$ac_exeext'
12767   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12768   (eval $ac_try) 2>&5
12769   ac_status=$?
12770   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12771   (exit $ac_status); }; }; then
12772   ac_cv_lib_m_logf=yes
12773 else
12774   echo "$as_me: failed program was:" >&5
12775 sed 's/^/| /' conftest.$ac_ext >&5
12776
12777 ac_cv_lib_m_logf=no
12778 fi
12779 rm -f conftest.err conftest.$ac_objext \
12780       conftest$ac_exeext conftest.$ac_ext
12781 LIBS=$ac_check_lib_save_LIBS
12782 fi
12783 echo "$as_me:$LINENO: result: $ac_cv_lib_m_logf" >&5
12784 echo "${ECHO_T}$ac_cv_lib_m_logf" >&6
12785 if test $ac_cv_lib_m_logf = yes; then
12786
12787 cat >>confdefs.h <<\_ACEOF
12788 #define HAVE_LOGF 1
12789 _ACEOF
12790
12791 fi
12792
12793 echo "$as_me:$LINENO: checking for log in -lm" >&5
12794 echo $ECHO_N "checking for log in -lm... $ECHO_C" >&6
12795 if test "${ac_cv_lib_m_log+set}" = set; then
12796   echo $ECHO_N "(cached) $ECHO_C" >&6
12797 else
12798   ac_check_lib_save_LIBS=$LIBS
12799 LIBS="-lm  $LIBS"
12800 if test x$gcc_no_link = xyes; then
12801   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12802 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12803    { (exit 1); exit 1; }; }
12804 fi
12805 cat >conftest.$ac_ext <<_ACEOF
12806 /* confdefs.h.  */
12807 _ACEOF
12808 cat confdefs.h >>conftest.$ac_ext
12809 cat >>conftest.$ac_ext <<_ACEOF
12810 /* end confdefs.h.  */
12811
12812 /* Override any gcc2 internal prototype to avoid an error.  */
12813 #ifdef __cplusplus
12814 extern "C"
12815 #endif
12816 /* We use char because int might match the return type of a gcc2
12817    builtin and then its argument prototype would still apply.  */
12818 char log ();
12819 int
12820 main ()
12821 {
12822 log ();
12823   ;
12824   return 0;
12825 }
12826 _ACEOF
12827 rm -f conftest.$ac_objext conftest$ac_exeext
12828 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12829   (eval $ac_link) 2>conftest.er1
12830   ac_status=$?
12831   grep -v '^ *+' conftest.er1 >conftest.err
12832   rm -f conftest.er1
12833   cat conftest.err >&5
12834   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12835   (exit $ac_status); } &&
12836          { ac_try='test -z "$ac_c_werror_flag"
12837                          || test ! -s conftest.err'
12838   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12839   (eval $ac_try) 2>&5
12840   ac_status=$?
12841   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12842   (exit $ac_status); }; } &&
12843          { ac_try='test -s conftest$ac_exeext'
12844   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12845   (eval $ac_try) 2>&5
12846   ac_status=$?
12847   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12848   (exit $ac_status); }; }; then
12849   ac_cv_lib_m_log=yes
12850 else
12851   echo "$as_me: failed program was:" >&5
12852 sed 's/^/| /' conftest.$ac_ext >&5
12853
12854 ac_cv_lib_m_log=no
12855 fi
12856 rm -f conftest.err conftest.$ac_objext \
12857       conftest$ac_exeext conftest.$ac_ext
12858 LIBS=$ac_check_lib_save_LIBS
12859 fi
12860 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log" >&5
12861 echo "${ECHO_T}$ac_cv_lib_m_log" >&6
12862 if test $ac_cv_lib_m_log = yes; then
12863
12864 cat >>confdefs.h <<\_ACEOF
12865 #define HAVE_LOG 1
12866 _ACEOF
12867
12868 fi
12869
12870 echo "$as_me:$LINENO: checking for logl in -lm" >&5
12871 echo $ECHO_N "checking for logl in -lm... $ECHO_C" >&6
12872 if test "${ac_cv_lib_m_logl+set}" = set; then
12873   echo $ECHO_N "(cached) $ECHO_C" >&6
12874 else
12875   ac_check_lib_save_LIBS=$LIBS
12876 LIBS="-lm  $LIBS"
12877 if test x$gcc_no_link = xyes; then
12878   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12879 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12880    { (exit 1); exit 1; }; }
12881 fi
12882 cat >conftest.$ac_ext <<_ACEOF
12883 /* confdefs.h.  */
12884 _ACEOF
12885 cat confdefs.h >>conftest.$ac_ext
12886 cat >>conftest.$ac_ext <<_ACEOF
12887 /* end confdefs.h.  */
12888
12889 /* Override any gcc2 internal prototype to avoid an error.  */
12890 #ifdef __cplusplus
12891 extern "C"
12892 #endif
12893 /* We use char because int might match the return type of a gcc2
12894    builtin and then its argument prototype would still apply.  */
12895 char logl ();
12896 int
12897 main ()
12898 {
12899 logl ();
12900   ;
12901   return 0;
12902 }
12903 _ACEOF
12904 rm -f conftest.$ac_objext conftest$ac_exeext
12905 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12906   (eval $ac_link) 2>conftest.er1
12907   ac_status=$?
12908   grep -v '^ *+' conftest.er1 >conftest.err
12909   rm -f conftest.er1
12910   cat conftest.err >&5
12911   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12912   (exit $ac_status); } &&
12913          { ac_try='test -z "$ac_c_werror_flag"
12914                          || test ! -s conftest.err'
12915   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12916   (eval $ac_try) 2>&5
12917   ac_status=$?
12918   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12919   (exit $ac_status); }; } &&
12920          { ac_try='test -s conftest$ac_exeext'
12921   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12922   (eval $ac_try) 2>&5
12923   ac_status=$?
12924   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12925   (exit $ac_status); }; }; then
12926   ac_cv_lib_m_logl=yes
12927 else
12928   echo "$as_me: failed program was:" >&5
12929 sed 's/^/| /' conftest.$ac_ext >&5
12930
12931 ac_cv_lib_m_logl=no
12932 fi
12933 rm -f conftest.err conftest.$ac_objext \
12934       conftest$ac_exeext conftest.$ac_ext
12935 LIBS=$ac_check_lib_save_LIBS
12936 fi
12937 echo "$as_me:$LINENO: result: $ac_cv_lib_m_logl" >&5
12938 echo "${ECHO_T}$ac_cv_lib_m_logl" >&6
12939 if test $ac_cv_lib_m_logl = yes; then
12940
12941 cat >>confdefs.h <<\_ACEOF
12942 #define HAVE_LOGL 1
12943 _ACEOF
12944
12945 fi
12946
12947 echo "$as_me:$LINENO: checking for clogf in -lm" >&5
12948 echo $ECHO_N "checking for clogf in -lm... $ECHO_C" >&6
12949 if test "${ac_cv_lib_m_clogf+set}" = set; then
12950   echo $ECHO_N "(cached) $ECHO_C" >&6
12951 else
12952   ac_check_lib_save_LIBS=$LIBS
12953 LIBS="-lm  $LIBS"
12954 if test x$gcc_no_link = xyes; then
12955   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12956 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12957    { (exit 1); exit 1; }; }
12958 fi
12959 cat >conftest.$ac_ext <<_ACEOF
12960 /* confdefs.h.  */
12961 _ACEOF
12962 cat confdefs.h >>conftest.$ac_ext
12963 cat >>conftest.$ac_ext <<_ACEOF
12964 /* end confdefs.h.  */
12965
12966 /* Override any gcc2 internal prototype to avoid an error.  */
12967 #ifdef __cplusplus
12968 extern "C"
12969 #endif
12970 /* We use char because int might match the return type of a gcc2
12971    builtin and then its argument prototype would still apply.  */
12972 char clogf ();
12973 int
12974 main ()
12975 {
12976 clogf ();
12977   ;
12978   return 0;
12979 }
12980 _ACEOF
12981 rm -f conftest.$ac_objext conftest$ac_exeext
12982 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12983   (eval $ac_link) 2>conftest.er1
12984   ac_status=$?
12985   grep -v '^ *+' conftest.er1 >conftest.err
12986   rm -f conftest.er1
12987   cat conftest.err >&5
12988   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12989   (exit $ac_status); } &&
12990          { ac_try='test -z "$ac_c_werror_flag"
12991                          || test ! -s conftest.err'
12992   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12993   (eval $ac_try) 2>&5
12994   ac_status=$?
12995   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12996   (exit $ac_status); }; } &&
12997          { ac_try='test -s conftest$ac_exeext'
12998   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12999   (eval $ac_try) 2>&5
13000   ac_status=$?
13001   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13002   (exit $ac_status); }; }; then
13003   ac_cv_lib_m_clogf=yes
13004 else
13005   echo "$as_me: failed program was:" >&5
13006 sed 's/^/| /' conftest.$ac_ext >&5
13007
13008 ac_cv_lib_m_clogf=no
13009 fi
13010 rm -f conftest.err conftest.$ac_objext \
13011       conftest$ac_exeext conftest.$ac_ext
13012 LIBS=$ac_check_lib_save_LIBS
13013 fi
13014 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clogf" >&5
13015 echo "${ECHO_T}$ac_cv_lib_m_clogf" >&6
13016 if test $ac_cv_lib_m_clogf = yes; then
13017
13018 cat >>confdefs.h <<\_ACEOF
13019 #define HAVE_CLOGF 1
13020 _ACEOF
13021
13022 fi
13023
13024 echo "$as_me:$LINENO: checking for clog in -lm" >&5
13025 echo $ECHO_N "checking for clog in -lm... $ECHO_C" >&6
13026 if test "${ac_cv_lib_m_clog+set}" = set; then
13027   echo $ECHO_N "(cached) $ECHO_C" >&6
13028 else
13029   ac_check_lib_save_LIBS=$LIBS
13030 LIBS="-lm  $LIBS"
13031 if test x$gcc_no_link = xyes; then
13032   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13033 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13034    { (exit 1); exit 1; }; }
13035 fi
13036 cat >conftest.$ac_ext <<_ACEOF
13037 /* confdefs.h.  */
13038 _ACEOF
13039 cat confdefs.h >>conftest.$ac_ext
13040 cat >>conftest.$ac_ext <<_ACEOF
13041 /* end confdefs.h.  */
13042
13043 /* Override any gcc2 internal prototype to avoid an error.  */
13044 #ifdef __cplusplus
13045 extern "C"
13046 #endif
13047 /* We use char because int might match the return type of a gcc2
13048    builtin and then its argument prototype would still apply.  */
13049 char clog ();
13050 int
13051 main ()
13052 {
13053 clog ();
13054   ;
13055   return 0;
13056 }
13057 _ACEOF
13058 rm -f conftest.$ac_objext conftest$ac_exeext
13059 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13060   (eval $ac_link) 2>conftest.er1
13061   ac_status=$?
13062   grep -v '^ *+' conftest.er1 >conftest.err
13063   rm -f conftest.er1
13064   cat conftest.err >&5
13065   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13066   (exit $ac_status); } &&
13067          { ac_try='test -z "$ac_c_werror_flag"
13068                          || test ! -s conftest.err'
13069   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13070   (eval $ac_try) 2>&5
13071   ac_status=$?
13072   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13073   (exit $ac_status); }; } &&
13074          { ac_try='test -s conftest$ac_exeext'
13075   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13076   (eval $ac_try) 2>&5
13077   ac_status=$?
13078   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13079   (exit $ac_status); }; }; then
13080   ac_cv_lib_m_clog=yes
13081 else
13082   echo "$as_me: failed program was:" >&5
13083 sed 's/^/| /' conftest.$ac_ext >&5
13084
13085 ac_cv_lib_m_clog=no
13086 fi
13087 rm -f conftest.err conftest.$ac_objext \
13088       conftest$ac_exeext conftest.$ac_ext
13089 LIBS=$ac_check_lib_save_LIBS
13090 fi
13091 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog" >&5
13092 echo "${ECHO_T}$ac_cv_lib_m_clog" >&6
13093 if test $ac_cv_lib_m_clog = yes; then
13094
13095 cat >>confdefs.h <<\_ACEOF
13096 #define HAVE_CLOG 1
13097 _ACEOF
13098
13099 fi
13100
13101 echo "$as_me:$LINENO: checking for clogl in -lm" >&5
13102 echo $ECHO_N "checking for clogl in -lm... $ECHO_C" >&6
13103 if test "${ac_cv_lib_m_clogl+set}" = set; then
13104   echo $ECHO_N "(cached) $ECHO_C" >&6
13105 else
13106   ac_check_lib_save_LIBS=$LIBS
13107 LIBS="-lm  $LIBS"
13108 if test x$gcc_no_link = xyes; then
13109   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13110 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13111    { (exit 1); exit 1; }; }
13112 fi
13113 cat >conftest.$ac_ext <<_ACEOF
13114 /* confdefs.h.  */
13115 _ACEOF
13116 cat confdefs.h >>conftest.$ac_ext
13117 cat >>conftest.$ac_ext <<_ACEOF
13118 /* end confdefs.h.  */
13119
13120 /* Override any gcc2 internal prototype to avoid an error.  */
13121 #ifdef __cplusplus
13122 extern "C"
13123 #endif
13124 /* We use char because int might match the return type of a gcc2
13125    builtin and then its argument prototype would still apply.  */
13126 char clogl ();
13127 int
13128 main ()
13129 {
13130 clogl ();
13131   ;
13132   return 0;
13133 }
13134 _ACEOF
13135 rm -f conftest.$ac_objext conftest$ac_exeext
13136 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13137   (eval $ac_link) 2>conftest.er1
13138   ac_status=$?
13139   grep -v '^ *+' conftest.er1 >conftest.err
13140   rm -f conftest.er1
13141   cat conftest.err >&5
13142   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13143   (exit $ac_status); } &&
13144          { ac_try='test -z "$ac_c_werror_flag"
13145                          || test ! -s conftest.err'
13146   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13147   (eval $ac_try) 2>&5
13148   ac_status=$?
13149   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13150   (exit $ac_status); }; } &&
13151          { ac_try='test -s conftest$ac_exeext'
13152   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13153   (eval $ac_try) 2>&5
13154   ac_status=$?
13155   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13156   (exit $ac_status); }; }; then
13157   ac_cv_lib_m_clogl=yes
13158 else
13159   echo "$as_me: failed program was:" >&5
13160 sed 's/^/| /' conftest.$ac_ext >&5
13161
13162 ac_cv_lib_m_clogl=no
13163 fi
13164 rm -f conftest.err conftest.$ac_objext \
13165       conftest$ac_exeext conftest.$ac_ext
13166 LIBS=$ac_check_lib_save_LIBS
13167 fi
13168 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clogl" >&5
13169 echo "${ECHO_T}$ac_cv_lib_m_clogl" >&6
13170 if test $ac_cv_lib_m_clogl = yes; then
13171
13172 cat >>confdefs.h <<\_ACEOF
13173 #define HAVE_CLOGL 1
13174 _ACEOF
13175
13176 fi
13177
13178 echo "$as_me:$LINENO: checking for log10f in -lm" >&5
13179 echo $ECHO_N "checking for log10f in -lm... $ECHO_C" >&6
13180 if test "${ac_cv_lib_m_log10f+set}" = set; then
13181   echo $ECHO_N "(cached) $ECHO_C" >&6
13182 else
13183   ac_check_lib_save_LIBS=$LIBS
13184 LIBS="-lm  $LIBS"
13185 if test x$gcc_no_link = xyes; then
13186   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13187 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13188    { (exit 1); exit 1; }; }
13189 fi
13190 cat >conftest.$ac_ext <<_ACEOF
13191 /* confdefs.h.  */
13192 _ACEOF
13193 cat confdefs.h >>conftest.$ac_ext
13194 cat >>conftest.$ac_ext <<_ACEOF
13195 /* end confdefs.h.  */
13196
13197 /* Override any gcc2 internal prototype to avoid an error.  */
13198 #ifdef __cplusplus
13199 extern "C"
13200 #endif
13201 /* We use char because int might match the return type of a gcc2
13202    builtin and then its argument prototype would still apply.  */
13203 char log10f ();
13204 int
13205 main ()
13206 {
13207 log10f ();
13208   ;
13209   return 0;
13210 }
13211 _ACEOF
13212 rm -f conftest.$ac_objext conftest$ac_exeext
13213 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13214   (eval $ac_link) 2>conftest.er1
13215   ac_status=$?
13216   grep -v '^ *+' conftest.er1 >conftest.err
13217   rm -f conftest.er1
13218   cat conftest.err >&5
13219   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13220   (exit $ac_status); } &&
13221          { ac_try='test -z "$ac_c_werror_flag"
13222                          || test ! -s conftest.err'
13223   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13224   (eval $ac_try) 2>&5
13225   ac_status=$?
13226   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13227   (exit $ac_status); }; } &&
13228          { ac_try='test -s conftest$ac_exeext'
13229   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13230   (eval $ac_try) 2>&5
13231   ac_status=$?
13232   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13233   (exit $ac_status); }; }; then
13234   ac_cv_lib_m_log10f=yes
13235 else
13236   echo "$as_me: failed program was:" >&5
13237 sed 's/^/| /' conftest.$ac_ext >&5
13238
13239 ac_cv_lib_m_log10f=no
13240 fi
13241 rm -f conftest.err conftest.$ac_objext \
13242       conftest$ac_exeext conftest.$ac_ext
13243 LIBS=$ac_check_lib_save_LIBS
13244 fi
13245 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10f" >&5
13246 echo "${ECHO_T}$ac_cv_lib_m_log10f" >&6
13247 if test $ac_cv_lib_m_log10f = yes; then
13248
13249 cat >>confdefs.h <<\_ACEOF
13250 #define HAVE_LOG10F 1
13251 _ACEOF
13252
13253 fi
13254
13255 echo "$as_me:$LINENO: checking for log10 in -lm" >&5
13256 echo $ECHO_N "checking for log10 in -lm... $ECHO_C" >&6
13257 if test "${ac_cv_lib_m_log10+set}" = set; then
13258   echo $ECHO_N "(cached) $ECHO_C" >&6
13259 else
13260   ac_check_lib_save_LIBS=$LIBS
13261 LIBS="-lm  $LIBS"
13262 if test x$gcc_no_link = xyes; then
13263   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13264 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13265    { (exit 1); exit 1; }; }
13266 fi
13267 cat >conftest.$ac_ext <<_ACEOF
13268 /* confdefs.h.  */
13269 _ACEOF
13270 cat confdefs.h >>conftest.$ac_ext
13271 cat >>conftest.$ac_ext <<_ACEOF
13272 /* end confdefs.h.  */
13273
13274 /* Override any gcc2 internal prototype to avoid an error.  */
13275 #ifdef __cplusplus
13276 extern "C"
13277 #endif
13278 /* We use char because int might match the return type of a gcc2
13279    builtin and then its argument prototype would still apply.  */
13280 char log10 ();
13281 int
13282 main ()
13283 {
13284 log10 ();
13285   ;
13286   return 0;
13287 }
13288 _ACEOF
13289 rm -f conftest.$ac_objext conftest$ac_exeext
13290 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13291   (eval $ac_link) 2>conftest.er1
13292   ac_status=$?
13293   grep -v '^ *+' conftest.er1 >conftest.err
13294   rm -f conftest.er1
13295   cat conftest.err >&5
13296   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13297   (exit $ac_status); } &&
13298          { ac_try='test -z "$ac_c_werror_flag"
13299                          || test ! -s conftest.err'
13300   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13301   (eval $ac_try) 2>&5
13302   ac_status=$?
13303   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13304   (exit $ac_status); }; } &&
13305          { ac_try='test -s conftest$ac_exeext'
13306   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13307   (eval $ac_try) 2>&5
13308   ac_status=$?
13309   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13310   (exit $ac_status); }; }; then
13311   ac_cv_lib_m_log10=yes
13312 else
13313   echo "$as_me: failed program was:" >&5
13314 sed 's/^/| /' conftest.$ac_ext >&5
13315
13316 ac_cv_lib_m_log10=no
13317 fi
13318 rm -f conftest.err conftest.$ac_objext \
13319       conftest$ac_exeext conftest.$ac_ext
13320 LIBS=$ac_check_lib_save_LIBS
13321 fi
13322 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10" >&5
13323 echo "${ECHO_T}$ac_cv_lib_m_log10" >&6
13324 if test $ac_cv_lib_m_log10 = yes; then
13325
13326 cat >>confdefs.h <<\_ACEOF
13327 #define HAVE_LOG10 1
13328 _ACEOF
13329
13330 fi
13331
13332 echo "$as_me:$LINENO: checking for log10l in -lm" >&5
13333 echo $ECHO_N "checking for log10l in -lm... $ECHO_C" >&6
13334 if test "${ac_cv_lib_m_log10l+set}" = set; then
13335   echo $ECHO_N "(cached) $ECHO_C" >&6
13336 else
13337   ac_check_lib_save_LIBS=$LIBS
13338 LIBS="-lm  $LIBS"
13339 if test x$gcc_no_link = xyes; then
13340   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13341 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13342    { (exit 1); exit 1; }; }
13343 fi
13344 cat >conftest.$ac_ext <<_ACEOF
13345 /* confdefs.h.  */
13346 _ACEOF
13347 cat confdefs.h >>conftest.$ac_ext
13348 cat >>conftest.$ac_ext <<_ACEOF
13349 /* end confdefs.h.  */
13350
13351 /* Override any gcc2 internal prototype to avoid an error.  */
13352 #ifdef __cplusplus
13353 extern "C"
13354 #endif
13355 /* We use char because int might match the return type of a gcc2
13356    builtin and then its argument prototype would still apply.  */
13357 char log10l ();
13358 int
13359 main ()
13360 {
13361 log10l ();
13362   ;
13363   return 0;
13364 }
13365 _ACEOF
13366 rm -f conftest.$ac_objext conftest$ac_exeext
13367 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13368   (eval $ac_link) 2>conftest.er1
13369   ac_status=$?
13370   grep -v '^ *+' conftest.er1 >conftest.err
13371   rm -f conftest.er1
13372   cat conftest.err >&5
13373   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13374   (exit $ac_status); } &&
13375          { ac_try='test -z "$ac_c_werror_flag"
13376                          || test ! -s conftest.err'
13377   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13378   (eval $ac_try) 2>&5
13379   ac_status=$?
13380   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13381   (exit $ac_status); }; } &&
13382          { ac_try='test -s conftest$ac_exeext'
13383   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13384   (eval $ac_try) 2>&5
13385   ac_status=$?
13386   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13387   (exit $ac_status); }; }; then
13388   ac_cv_lib_m_log10l=yes
13389 else
13390   echo "$as_me: failed program was:" >&5
13391 sed 's/^/| /' conftest.$ac_ext >&5
13392
13393 ac_cv_lib_m_log10l=no
13394 fi
13395 rm -f conftest.err conftest.$ac_objext \
13396       conftest$ac_exeext conftest.$ac_ext
13397 LIBS=$ac_check_lib_save_LIBS
13398 fi
13399 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10l" >&5
13400 echo "${ECHO_T}$ac_cv_lib_m_log10l" >&6
13401 if test $ac_cv_lib_m_log10l = yes; then
13402
13403 cat >>confdefs.h <<\_ACEOF
13404 #define HAVE_LOG10L 1
13405 _ACEOF
13406
13407 fi
13408
13409 echo "$as_me:$LINENO: checking for clog10f in -lm" >&5
13410 echo $ECHO_N "checking for clog10f in -lm... $ECHO_C" >&6
13411 if test "${ac_cv_lib_m_clog10f+set}" = set; then
13412   echo $ECHO_N "(cached) $ECHO_C" >&6
13413 else
13414   ac_check_lib_save_LIBS=$LIBS
13415 LIBS="-lm  $LIBS"
13416 if test x$gcc_no_link = xyes; then
13417   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13418 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13419    { (exit 1); exit 1; }; }
13420 fi
13421 cat >conftest.$ac_ext <<_ACEOF
13422 /* confdefs.h.  */
13423 _ACEOF
13424 cat confdefs.h >>conftest.$ac_ext
13425 cat >>conftest.$ac_ext <<_ACEOF
13426 /* end confdefs.h.  */
13427
13428 /* Override any gcc2 internal prototype to avoid an error.  */
13429 #ifdef __cplusplus
13430 extern "C"
13431 #endif
13432 /* We use char because int might match the return type of a gcc2
13433    builtin and then its argument prototype would still apply.  */
13434 char clog10f ();
13435 int
13436 main ()
13437 {
13438 clog10f ();
13439   ;
13440   return 0;
13441 }
13442 _ACEOF
13443 rm -f conftest.$ac_objext conftest$ac_exeext
13444 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13445   (eval $ac_link) 2>conftest.er1
13446   ac_status=$?
13447   grep -v '^ *+' conftest.er1 >conftest.err
13448   rm -f conftest.er1
13449   cat conftest.err >&5
13450   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13451   (exit $ac_status); } &&
13452          { ac_try='test -z "$ac_c_werror_flag"
13453                          || test ! -s conftest.err'
13454   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13455   (eval $ac_try) 2>&5
13456   ac_status=$?
13457   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13458   (exit $ac_status); }; } &&
13459          { ac_try='test -s conftest$ac_exeext'
13460   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13461   (eval $ac_try) 2>&5
13462   ac_status=$?
13463   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13464   (exit $ac_status); }; }; then
13465   ac_cv_lib_m_clog10f=yes
13466 else
13467   echo "$as_me: failed program was:" >&5
13468 sed 's/^/| /' conftest.$ac_ext >&5
13469
13470 ac_cv_lib_m_clog10f=no
13471 fi
13472 rm -f conftest.err conftest.$ac_objext \
13473       conftest$ac_exeext conftest.$ac_ext
13474 LIBS=$ac_check_lib_save_LIBS
13475 fi
13476 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10f" >&5
13477 echo "${ECHO_T}$ac_cv_lib_m_clog10f" >&6
13478 if test $ac_cv_lib_m_clog10f = yes; then
13479
13480 cat >>confdefs.h <<\_ACEOF
13481 #define HAVE_CLOG10F 1
13482 _ACEOF
13483
13484 fi
13485
13486 echo "$as_me:$LINENO: checking for clog10 in -lm" >&5
13487 echo $ECHO_N "checking for clog10 in -lm... $ECHO_C" >&6
13488 if test "${ac_cv_lib_m_clog10+set}" = set; then
13489   echo $ECHO_N "(cached) $ECHO_C" >&6
13490 else
13491   ac_check_lib_save_LIBS=$LIBS
13492 LIBS="-lm  $LIBS"
13493 if test x$gcc_no_link = xyes; then
13494   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13495 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13496    { (exit 1); exit 1; }; }
13497 fi
13498 cat >conftest.$ac_ext <<_ACEOF
13499 /* confdefs.h.  */
13500 _ACEOF
13501 cat confdefs.h >>conftest.$ac_ext
13502 cat >>conftest.$ac_ext <<_ACEOF
13503 /* end confdefs.h.  */
13504
13505 /* Override any gcc2 internal prototype to avoid an error.  */
13506 #ifdef __cplusplus
13507 extern "C"
13508 #endif
13509 /* We use char because int might match the return type of a gcc2
13510    builtin and then its argument prototype would still apply.  */
13511 char clog10 ();
13512 int
13513 main ()
13514 {
13515 clog10 ();
13516   ;
13517   return 0;
13518 }
13519 _ACEOF
13520 rm -f conftest.$ac_objext conftest$ac_exeext
13521 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13522   (eval $ac_link) 2>conftest.er1
13523   ac_status=$?
13524   grep -v '^ *+' conftest.er1 >conftest.err
13525   rm -f conftest.er1
13526   cat conftest.err >&5
13527   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13528   (exit $ac_status); } &&
13529          { ac_try='test -z "$ac_c_werror_flag"
13530                          || test ! -s conftest.err'
13531   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13532   (eval $ac_try) 2>&5
13533   ac_status=$?
13534   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13535   (exit $ac_status); }; } &&
13536          { ac_try='test -s conftest$ac_exeext'
13537   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13538   (eval $ac_try) 2>&5
13539   ac_status=$?
13540   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13541   (exit $ac_status); }; }; then
13542   ac_cv_lib_m_clog10=yes
13543 else
13544   echo "$as_me: failed program was:" >&5
13545 sed 's/^/| /' conftest.$ac_ext >&5
13546
13547 ac_cv_lib_m_clog10=no
13548 fi
13549 rm -f conftest.err conftest.$ac_objext \
13550       conftest$ac_exeext conftest.$ac_ext
13551 LIBS=$ac_check_lib_save_LIBS
13552 fi
13553 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10" >&5
13554 echo "${ECHO_T}$ac_cv_lib_m_clog10" >&6
13555 if test $ac_cv_lib_m_clog10 = yes; then
13556
13557 cat >>confdefs.h <<\_ACEOF
13558 #define HAVE_CLOG10 1
13559 _ACEOF
13560
13561 fi
13562
13563 echo "$as_me:$LINENO: checking for clog10l in -lm" >&5
13564 echo $ECHO_N "checking for clog10l in -lm... $ECHO_C" >&6
13565 if test "${ac_cv_lib_m_clog10l+set}" = set; then
13566   echo $ECHO_N "(cached) $ECHO_C" >&6
13567 else
13568   ac_check_lib_save_LIBS=$LIBS
13569 LIBS="-lm  $LIBS"
13570 if test x$gcc_no_link = xyes; then
13571   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13572 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13573    { (exit 1); exit 1; }; }
13574 fi
13575 cat >conftest.$ac_ext <<_ACEOF
13576 /* confdefs.h.  */
13577 _ACEOF
13578 cat confdefs.h >>conftest.$ac_ext
13579 cat >>conftest.$ac_ext <<_ACEOF
13580 /* end confdefs.h.  */
13581
13582 /* Override any gcc2 internal prototype to avoid an error.  */
13583 #ifdef __cplusplus
13584 extern "C"
13585 #endif
13586 /* We use char because int might match the return type of a gcc2
13587    builtin and then its argument prototype would still apply.  */
13588 char clog10l ();
13589 int
13590 main ()
13591 {
13592 clog10l ();
13593   ;
13594   return 0;
13595 }
13596 _ACEOF
13597 rm -f conftest.$ac_objext conftest$ac_exeext
13598 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13599   (eval $ac_link) 2>conftest.er1
13600   ac_status=$?
13601   grep -v '^ *+' conftest.er1 >conftest.err
13602   rm -f conftest.er1
13603   cat conftest.err >&5
13604   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13605   (exit $ac_status); } &&
13606          { ac_try='test -z "$ac_c_werror_flag"
13607                          || test ! -s conftest.err'
13608   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13609   (eval $ac_try) 2>&5
13610   ac_status=$?
13611   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13612   (exit $ac_status); }; } &&
13613          { ac_try='test -s conftest$ac_exeext'
13614   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13615   (eval $ac_try) 2>&5
13616   ac_status=$?
13617   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13618   (exit $ac_status); }; }; then
13619   ac_cv_lib_m_clog10l=yes
13620 else
13621   echo "$as_me: failed program was:" >&5
13622 sed 's/^/| /' conftest.$ac_ext >&5
13623
13624 ac_cv_lib_m_clog10l=no
13625 fi
13626 rm -f conftest.err conftest.$ac_objext \
13627       conftest$ac_exeext conftest.$ac_ext
13628 LIBS=$ac_check_lib_save_LIBS
13629 fi
13630 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10l" >&5
13631 echo "${ECHO_T}$ac_cv_lib_m_clog10l" >&6
13632 if test $ac_cv_lib_m_clog10l = yes; then
13633
13634 cat >>confdefs.h <<\_ACEOF
13635 #define HAVE_CLOG10L 1
13636 _ACEOF
13637
13638 fi
13639
13640 echo "$as_me:$LINENO: checking for nextafterf in -lm" >&5
13641 echo $ECHO_N "checking for nextafterf in -lm... $ECHO_C" >&6
13642 if test "${ac_cv_lib_m_nextafterf+set}" = set; then
13643   echo $ECHO_N "(cached) $ECHO_C" >&6
13644 else
13645   ac_check_lib_save_LIBS=$LIBS
13646 LIBS="-lm  $LIBS"
13647 if test x$gcc_no_link = xyes; then
13648   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13649 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13650    { (exit 1); exit 1; }; }
13651 fi
13652 cat >conftest.$ac_ext <<_ACEOF
13653 /* confdefs.h.  */
13654 _ACEOF
13655 cat confdefs.h >>conftest.$ac_ext
13656 cat >>conftest.$ac_ext <<_ACEOF
13657 /* end confdefs.h.  */
13658
13659 /* Override any gcc2 internal prototype to avoid an error.  */
13660 #ifdef __cplusplus
13661 extern "C"
13662 #endif
13663 /* We use char because int might match the return type of a gcc2
13664    builtin and then its argument prototype would still apply.  */
13665 char nextafterf ();
13666 int
13667 main ()
13668 {
13669 nextafterf ();
13670   ;
13671   return 0;
13672 }
13673 _ACEOF
13674 rm -f conftest.$ac_objext conftest$ac_exeext
13675 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13676   (eval $ac_link) 2>conftest.er1
13677   ac_status=$?
13678   grep -v '^ *+' conftest.er1 >conftest.err
13679   rm -f conftest.er1
13680   cat conftest.err >&5
13681   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13682   (exit $ac_status); } &&
13683          { ac_try='test -z "$ac_c_werror_flag"
13684                          || test ! -s conftest.err'
13685   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13686   (eval $ac_try) 2>&5
13687   ac_status=$?
13688   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13689   (exit $ac_status); }; } &&
13690          { ac_try='test -s conftest$ac_exeext'
13691   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13692   (eval $ac_try) 2>&5
13693   ac_status=$?
13694   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13695   (exit $ac_status); }; }; then
13696   ac_cv_lib_m_nextafterf=yes
13697 else
13698   echo "$as_me: failed program was:" >&5
13699 sed 's/^/| /' conftest.$ac_ext >&5
13700
13701 ac_cv_lib_m_nextafterf=no
13702 fi
13703 rm -f conftest.err conftest.$ac_objext \
13704       conftest$ac_exeext conftest.$ac_ext
13705 LIBS=$ac_check_lib_save_LIBS
13706 fi
13707 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafterf" >&5
13708 echo "${ECHO_T}$ac_cv_lib_m_nextafterf" >&6
13709 if test $ac_cv_lib_m_nextafterf = yes; then
13710
13711 cat >>confdefs.h <<\_ACEOF
13712 #define HAVE_NEXTAFTERF 1
13713 _ACEOF
13714
13715 fi
13716
13717 echo "$as_me:$LINENO: checking for nextafter in -lm" >&5
13718 echo $ECHO_N "checking for nextafter in -lm... $ECHO_C" >&6
13719 if test "${ac_cv_lib_m_nextafter+set}" = set; then
13720   echo $ECHO_N "(cached) $ECHO_C" >&6
13721 else
13722   ac_check_lib_save_LIBS=$LIBS
13723 LIBS="-lm  $LIBS"
13724 if test x$gcc_no_link = xyes; then
13725   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13726 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13727    { (exit 1); exit 1; }; }
13728 fi
13729 cat >conftest.$ac_ext <<_ACEOF
13730 /* confdefs.h.  */
13731 _ACEOF
13732 cat confdefs.h >>conftest.$ac_ext
13733 cat >>conftest.$ac_ext <<_ACEOF
13734 /* end confdefs.h.  */
13735
13736 /* Override any gcc2 internal prototype to avoid an error.  */
13737 #ifdef __cplusplus
13738 extern "C"
13739 #endif
13740 /* We use char because int might match the return type of a gcc2
13741    builtin and then its argument prototype would still apply.  */
13742 char nextafter ();
13743 int
13744 main ()
13745 {
13746 nextafter ();
13747   ;
13748   return 0;
13749 }
13750 _ACEOF
13751 rm -f conftest.$ac_objext conftest$ac_exeext
13752 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13753   (eval $ac_link) 2>conftest.er1
13754   ac_status=$?
13755   grep -v '^ *+' conftest.er1 >conftest.err
13756   rm -f conftest.er1
13757   cat conftest.err >&5
13758   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13759   (exit $ac_status); } &&
13760          { ac_try='test -z "$ac_c_werror_flag"
13761                          || test ! -s conftest.err'
13762   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13763   (eval $ac_try) 2>&5
13764   ac_status=$?
13765   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13766   (exit $ac_status); }; } &&
13767          { ac_try='test -s conftest$ac_exeext'
13768   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13769   (eval $ac_try) 2>&5
13770   ac_status=$?
13771   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13772   (exit $ac_status); }; }; then
13773   ac_cv_lib_m_nextafter=yes
13774 else
13775   echo "$as_me: failed program was:" >&5
13776 sed 's/^/| /' conftest.$ac_ext >&5
13777
13778 ac_cv_lib_m_nextafter=no
13779 fi
13780 rm -f conftest.err conftest.$ac_objext \
13781       conftest$ac_exeext conftest.$ac_ext
13782 LIBS=$ac_check_lib_save_LIBS
13783 fi
13784 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafter" >&5
13785 echo "${ECHO_T}$ac_cv_lib_m_nextafter" >&6
13786 if test $ac_cv_lib_m_nextafter = yes; then
13787
13788 cat >>confdefs.h <<\_ACEOF
13789 #define HAVE_NEXTAFTER 1
13790 _ACEOF
13791
13792 fi
13793
13794 echo "$as_me:$LINENO: checking for nextafterl in -lm" >&5
13795 echo $ECHO_N "checking for nextafterl in -lm... $ECHO_C" >&6
13796 if test "${ac_cv_lib_m_nextafterl+set}" = set; then
13797   echo $ECHO_N "(cached) $ECHO_C" >&6
13798 else
13799   ac_check_lib_save_LIBS=$LIBS
13800 LIBS="-lm  $LIBS"
13801 if test x$gcc_no_link = xyes; then
13802   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13803 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13804    { (exit 1); exit 1; }; }
13805 fi
13806 cat >conftest.$ac_ext <<_ACEOF
13807 /* confdefs.h.  */
13808 _ACEOF
13809 cat confdefs.h >>conftest.$ac_ext
13810 cat >>conftest.$ac_ext <<_ACEOF
13811 /* end confdefs.h.  */
13812
13813 /* Override any gcc2 internal prototype to avoid an error.  */
13814 #ifdef __cplusplus
13815 extern "C"
13816 #endif
13817 /* We use char because int might match the return type of a gcc2
13818    builtin and then its argument prototype would still apply.  */
13819 char nextafterl ();
13820 int
13821 main ()
13822 {
13823 nextafterl ();
13824   ;
13825   return 0;
13826 }
13827 _ACEOF
13828 rm -f conftest.$ac_objext conftest$ac_exeext
13829 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13830   (eval $ac_link) 2>conftest.er1
13831   ac_status=$?
13832   grep -v '^ *+' conftest.er1 >conftest.err
13833   rm -f conftest.er1
13834   cat conftest.err >&5
13835   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13836   (exit $ac_status); } &&
13837          { ac_try='test -z "$ac_c_werror_flag"
13838                          || test ! -s conftest.err'
13839   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13840   (eval $ac_try) 2>&5
13841   ac_status=$?
13842   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13843   (exit $ac_status); }; } &&
13844          { ac_try='test -s conftest$ac_exeext'
13845   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13846   (eval $ac_try) 2>&5
13847   ac_status=$?
13848   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13849   (exit $ac_status); }; }; then
13850   ac_cv_lib_m_nextafterl=yes
13851 else
13852   echo "$as_me: failed program was:" >&5
13853 sed 's/^/| /' conftest.$ac_ext >&5
13854
13855 ac_cv_lib_m_nextafterl=no
13856 fi
13857 rm -f conftest.err conftest.$ac_objext \
13858       conftest$ac_exeext conftest.$ac_ext
13859 LIBS=$ac_check_lib_save_LIBS
13860 fi
13861 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafterl" >&5
13862 echo "${ECHO_T}$ac_cv_lib_m_nextafterl" >&6
13863 if test $ac_cv_lib_m_nextafterl = yes; then
13864
13865 cat >>confdefs.h <<\_ACEOF
13866 #define HAVE_NEXTAFTERL 1
13867 _ACEOF
13868
13869 fi
13870
13871 echo "$as_me:$LINENO: checking for powf in -lm" >&5
13872 echo $ECHO_N "checking for powf in -lm... $ECHO_C" >&6
13873 if test "${ac_cv_lib_m_powf+set}" = set; then
13874   echo $ECHO_N "(cached) $ECHO_C" >&6
13875 else
13876   ac_check_lib_save_LIBS=$LIBS
13877 LIBS="-lm  $LIBS"
13878 if test x$gcc_no_link = xyes; then
13879   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13880 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13881    { (exit 1); exit 1; }; }
13882 fi
13883 cat >conftest.$ac_ext <<_ACEOF
13884 /* confdefs.h.  */
13885 _ACEOF
13886 cat confdefs.h >>conftest.$ac_ext
13887 cat >>conftest.$ac_ext <<_ACEOF
13888 /* end confdefs.h.  */
13889
13890 /* Override any gcc2 internal prototype to avoid an error.  */
13891 #ifdef __cplusplus
13892 extern "C"
13893 #endif
13894 /* We use char because int might match the return type of a gcc2
13895    builtin and then its argument prototype would still apply.  */
13896 char powf ();
13897 int
13898 main ()
13899 {
13900 powf ();
13901   ;
13902   return 0;
13903 }
13904 _ACEOF
13905 rm -f conftest.$ac_objext conftest$ac_exeext
13906 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13907   (eval $ac_link) 2>conftest.er1
13908   ac_status=$?
13909   grep -v '^ *+' conftest.er1 >conftest.err
13910   rm -f conftest.er1
13911   cat conftest.err >&5
13912   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13913   (exit $ac_status); } &&
13914          { ac_try='test -z "$ac_c_werror_flag"
13915                          || test ! -s conftest.err'
13916   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13917   (eval $ac_try) 2>&5
13918   ac_status=$?
13919   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13920   (exit $ac_status); }; } &&
13921          { ac_try='test -s conftest$ac_exeext'
13922   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13923   (eval $ac_try) 2>&5
13924   ac_status=$?
13925   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13926   (exit $ac_status); }; }; then
13927   ac_cv_lib_m_powf=yes
13928 else
13929   echo "$as_me: failed program was:" >&5
13930 sed 's/^/| /' conftest.$ac_ext >&5
13931
13932 ac_cv_lib_m_powf=no
13933 fi
13934 rm -f conftest.err conftest.$ac_objext \
13935       conftest$ac_exeext conftest.$ac_ext
13936 LIBS=$ac_check_lib_save_LIBS
13937 fi
13938 echo "$as_me:$LINENO: result: $ac_cv_lib_m_powf" >&5
13939 echo "${ECHO_T}$ac_cv_lib_m_powf" >&6
13940 if test $ac_cv_lib_m_powf = yes; then
13941
13942 cat >>confdefs.h <<\_ACEOF
13943 #define HAVE_POWF 1
13944 _ACEOF
13945
13946 fi
13947
13948 echo "$as_me:$LINENO: checking for pow in -lm" >&5
13949 echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
13950 if test "${ac_cv_lib_m_pow+set}" = set; then
13951   echo $ECHO_N "(cached) $ECHO_C" >&6
13952 else
13953   ac_check_lib_save_LIBS=$LIBS
13954 LIBS="-lm  $LIBS"
13955 if test x$gcc_no_link = xyes; then
13956   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13957 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13958    { (exit 1); exit 1; }; }
13959 fi
13960 cat >conftest.$ac_ext <<_ACEOF
13961 /* confdefs.h.  */
13962 _ACEOF
13963 cat confdefs.h >>conftest.$ac_ext
13964 cat >>conftest.$ac_ext <<_ACEOF
13965 /* end confdefs.h.  */
13966
13967 /* Override any gcc2 internal prototype to avoid an error.  */
13968 #ifdef __cplusplus
13969 extern "C"
13970 #endif
13971 /* We use char because int might match the return type of a gcc2
13972    builtin and then its argument prototype would still apply.  */
13973 char pow ();
13974 int
13975 main ()
13976 {
13977 pow ();
13978   ;
13979   return 0;
13980 }
13981 _ACEOF
13982 rm -f conftest.$ac_objext conftest$ac_exeext
13983 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13984   (eval $ac_link) 2>conftest.er1
13985   ac_status=$?
13986   grep -v '^ *+' conftest.er1 >conftest.err
13987   rm -f conftest.er1
13988   cat conftest.err >&5
13989   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13990   (exit $ac_status); } &&
13991          { ac_try='test -z "$ac_c_werror_flag"
13992                          || test ! -s conftest.err'
13993   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13994   (eval $ac_try) 2>&5
13995   ac_status=$?
13996   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13997   (exit $ac_status); }; } &&
13998          { ac_try='test -s conftest$ac_exeext'
13999   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14000   (eval $ac_try) 2>&5
14001   ac_status=$?
14002   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14003   (exit $ac_status); }; }; then
14004   ac_cv_lib_m_pow=yes
14005 else
14006   echo "$as_me: failed program was:" >&5
14007 sed 's/^/| /' conftest.$ac_ext >&5
14008
14009 ac_cv_lib_m_pow=no
14010 fi
14011 rm -f conftest.err conftest.$ac_objext \
14012       conftest$ac_exeext conftest.$ac_ext
14013 LIBS=$ac_check_lib_save_LIBS
14014 fi
14015 echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
14016 echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
14017 if test $ac_cv_lib_m_pow = yes; then
14018
14019 cat >>confdefs.h <<\_ACEOF
14020 #define HAVE_POW 1
14021 _ACEOF
14022
14023 fi
14024
14025 echo "$as_me:$LINENO: checking for powl in -lm" >&5
14026 echo $ECHO_N "checking for powl in -lm... $ECHO_C" >&6
14027 if test "${ac_cv_lib_m_powl+set}" = set; then
14028   echo $ECHO_N "(cached) $ECHO_C" >&6
14029 else
14030   ac_check_lib_save_LIBS=$LIBS
14031 LIBS="-lm  $LIBS"
14032 if test x$gcc_no_link = xyes; then
14033   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14034 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14035    { (exit 1); exit 1; }; }
14036 fi
14037 cat >conftest.$ac_ext <<_ACEOF
14038 /* confdefs.h.  */
14039 _ACEOF
14040 cat confdefs.h >>conftest.$ac_ext
14041 cat >>conftest.$ac_ext <<_ACEOF
14042 /* end confdefs.h.  */
14043
14044 /* Override any gcc2 internal prototype to avoid an error.  */
14045 #ifdef __cplusplus
14046 extern "C"
14047 #endif
14048 /* We use char because int might match the return type of a gcc2
14049    builtin and then its argument prototype would still apply.  */
14050 char powl ();
14051 int
14052 main ()
14053 {
14054 powl ();
14055   ;
14056   return 0;
14057 }
14058 _ACEOF
14059 rm -f conftest.$ac_objext conftest$ac_exeext
14060 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14061   (eval $ac_link) 2>conftest.er1
14062   ac_status=$?
14063   grep -v '^ *+' conftest.er1 >conftest.err
14064   rm -f conftest.er1
14065   cat conftest.err >&5
14066   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14067   (exit $ac_status); } &&
14068          { ac_try='test -z "$ac_c_werror_flag"
14069                          || test ! -s conftest.err'
14070   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14071   (eval $ac_try) 2>&5
14072   ac_status=$?
14073   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14074   (exit $ac_status); }; } &&
14075          { ac_try='test -s conftest$ac_exeext'
14076   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14077   (eval $ac_try) 2>&5
14078   ac_status=$?
14079   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14080   (exit $ac_status); }; }; then
14081   ac_cv_lib_m_powl=yes
14082 else
14083   echo "$as_me: failed program was:" >&5
14084 sed 's/^/| /' conftest.$ac_ext >&5
14085
14086 ac_cv_lib_m_powl=no
14087 fi
14088 rm -f conftest.err conftest.$ac_objext \
14089       conftest$ac_exeext conftest.$ac_ext
14090 LIBS=$ac_check_lib_save_LIBS
14091 fi
14092 echo "$as_me:$LINENO: result: $ac_cv_lib_m_powl" >&5
14093 echo "${ECHO_T}$ac_cv_lib_m_powl" >&6
14094 if test $ac_cv_lib_m_powl = yes; then
14095
14096 cat >>confdefs.h <<\_ACEOF
14097 #define HAVE_POWL 1
14098 _ACEOF
14099
14100 fi
14101
14102 echo "$as_me:$LINENO: checking for cpowf in -lm" >&5
14103 echo $ECHO_N "checking for cpowf in -lm... $ECHO_C" >&6
14104 if test "${ac_cv_lib_m_cpowf+set}" = set; then
14105   echo $ECHO_N "(cached) $ECHO_C" >&6
14106 else
14107   ac_check_lib_save_LIBS=$LIBS
14108 LIBS="-lm  $LIBS"
14109 if test x$gcc_no_link = xyes; then
14110   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14111 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14112    { (exit 1); exit 1; }; }
14113 fi
14114 cat >conftest.$ac_ext <<_ACEOF
14115 /* confdefs.h.  */
14116 _ACEOF
14117 cat confdefs.h >>conftest.$ac_ext
14118 cat >>conftest.$ac_ext <<_ACEOF
14119 /* end confdefs.h.  */
14120
14121 /* Override any gcc2 internal prototype to avoid an error.  */
14122 #ifdef __cplusplus
14123 extern "C"
14124 #endif
14125 /* We use char because int might match the return type of a gcc2
14126    builtin and then its argument prototype would still apply.  */
14127 char cpowf ();
14128 int
14129 main ()
14130 {
14131 cpowf ();
14132   ;
14133   return 0;
14134 }
14135 _ACEOF
14136 rm -f conftest.$ac_objext conftest$ac_exeext
14137 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14138   (eval $ac_link) 2>conftest.er1
14139   ac_status=$?
14140   grep -v '^ *+' conftest.er1 >conftest.err
14141   rm -f conftest.er1
14142   cat conftest.err >&5
14143   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14144   (exit $ac_status); } &&
14145          { ac_try='test -z "$ac_c_werror_flag"
14146                          || test ! -s conftest.err'
14147   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14148   (eval $ac_try) 2>&5
14149   ac_status=$?
14150   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14151   (exit $ac_status); }; } &&
14152          { ac_try='test -s conftest$ac_exeext'
14153   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14154   (eval $ac_try) 2>&5
14155   ac_status=$?
14156   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14157   (exit $ac_status); }; }; then
14158   ac_cv_lib_m_cpowf=yes
14159 else
14160   echo "$as_me: failed program was:" >&5
14161 sed 's/^/| /' conftest.$ac_ext >&5
14162
14163 ac_cv_lib_m_cpowf=no
14164 fi
14165 rm -f conftest.err conftest.$ac_objext \
14166       conftest$ac_exeext conftest.$ac_ext
14167 LIBS=$ac_check_lib_save_LIBS
14168 fi
14169 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpowf" >&5
14170 echo "${ECHO_T}$ac_cv_lib_m_cpowf" >&6
14171 if test $ac_cv_lib_m_cpowf = yes; then
14172
14173 cat >>confdefs.h <<\_ACEOF
14174 #define HAVE_CPOWF 1
14175 _ACEOF
14176
14177 fi
14178
14179 echo "$as_me:$LINENO: checking for cpow in -lm" >&5
14180 echo $ECHO_N "checking for cpow in -lm... $ECHO_C" >&6
14181 if test "${ac_cv_lib_m_cpow+set}" = set; then
14182   echo $ECHO_N "(cached) $ECHO_C" >&6
14183 else
14184   ac_check_lib_save_LIBS=$LIBS
14185 LIBS="-lm  $LIBS"
14186 if test x$gcc_no_link = xyes; then
14187   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14188 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14189    { (exit 1); exit 1; }; }
14190 fi
14191 cat >conftest.$ac_ext <<_ACEOF
14192 /* confdefs.h.  */
14193 _ACEOF
14194 cat confdefs.h >>conftest.$ac_ext
14195 cat >>conftest.$ac_ext <<_ACEOF
14196 /* end confdefs.h.  */
14197
14198 /* Override any gcc2 internal prototype to avoid an error.  */
14199 #ifdef __cplusplus
14200 extern "C"
14201 #endif
14202 /* We use char because int might match the return type of a gcc2
14203    builtin and then its argument prototype would still apply.  */
14204 char cpow ();
14205 int
14206 main ()
14207 {
14208 cpow ();
14209   ;
14210   return 0;
14211 }
14212 _ACEOF
14213 rm -f conftest.$ac_objext conftest$ac_exeext
14214 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14215   (eval $ac_link) 2>conftest.er1
14216   ac_status=$?
14217   grep -v '^ *+' conftest.er1 >conftest.err
14218   rm -f conftest.er1
14219   cat conftest.err >&5
14220   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14221   (exit $ac_status); } &&
14222          { ac_try='test -z "$ac_c_werror_flag"
14223                          || test ! -s conftest.err'
14224   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14225   (eval $ac_try) 2>&5
14226   ac_status=$?
14227   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14228   (exit $ac_status); }; } &&
14229          { ac_try='test -s conftest$ac_exeext'
14230   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14231   (eval $ac_try) 2>&5
14232   ac_status=$?
14233   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14234   (exit $ac_status); }; }; then
14235   ac_cv_lib_m_cpow=yes
14236 else
14237   echo "$as_me: failed program was:" >&5
14238 sed 's/^/| /' conftest.$ac_ext >&5
14239
14240 ac_cv_lib_m_cpow=no
14241 fi
14242 rm -f conftest.err conftest.$ac_objext \
14243       conftest$ac_exeext conftest.$ac_ext
14244 LIBS=$ac_check_lib_save_LIBS
14245 fi
14246 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpow" >&5
14247 echo "${ECHO_T}$ac_cv_lib_m_cpow" >&6
14248 if test $ac_cv_lib_m_cpow = yes; then
14249
14250 cat >>confdefs.h <<\_ACEOF
14251 #define HAVE_CPOW 1
14252 _ACEOF
14253
14254 fi
14255
14256 echo "$as_me:$LINENO: checking for cpowl in -lm" >&5
14257 echo $ECHO_N "checking for cpowl in -lm... $ECHO_C" >&6
14258 if test "${ac_cv_lib_m_cpowl+set}" = set; then
14259   echo $ECHO_N "(cached) $ECHO_C" >&6
14260 else
14261   ac_check_lib_save_LIBS=$LIBS
14262 LIBS="-lm  $LIBS"
14263 if test x$gcc_no_link = xyes; then
14264   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14265 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14266    { (exit 1); exit 1; }; }
14267 fi
14268 cat >conftest.$ac_ext <<_ACEOF
14269 /* confdefs.h.  */
14270 _ACEOF
14271 cat confdefs.h >>conftest.$ac_ext
14272 cat >>conftest.$ac_ext <<_ACEOF
14273 /* end confdefs.h.  */
14274
14275 /* Override any gcc2 internal prototype to avoid an error.  */
14276 #ifdef __cplusplus
14277 extern "C"
14278 #endif
14279 /* We use char because int might match the return type of a gcc2
14280    builtin and then its argument prototype would still apply.  */
14281 char cpowl ();
14282 int
14283 main ()
14284 {
14285 cpowl ();
14286   ;
14287   return 0;
14288 }
14289 _ACEOF
14290 rm -f conftest.$ac_objext conftest$ac_exeext
14291 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14292   (eval $ac_link) 2>conftest.er1
14293   ac_status=$?
14294   grep -v '^ *+' conftest.er1 >conftest.err
14295   rm -f conftest.er1
14296   cat conftest.err >&5
14297   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14298   (exit $ac_status); } &&
14299          { ac_try='test -z "$ac_c_werror_flag"
14300                          || test ! -s conftest.err'
14301   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14302   (eval $ac_try) 2>&5
14303   ac_status=$?
14304   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14305   (exit $ac_status); }; } &&
14306          { ac_try='test -s conftest$ac_exeext'
14307   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14308   (eval $ac_try) 2>&5
14309   ac_status=$?
14310   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14311   (exit $ac_status); }; }; then
14312   ac_cv_lib_m_cpowl=yes
14313 else
14314   echo "$as_me: failed program was:" >&5
14315 sed 's/^/| /' conftest.$ac_ext >&5
14316
14317 ac_cv_lib_m_cpowl=no
14318 fi
14319 rm -f conftest.err conftest.$ac_objext \
14320       conftest$ac_exeext conftest.$ac_ext
14321 LIBS=$ac_check_lib_save_LIBS
14322 fi
14323 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpowl" >&5
14324 echo "${ECHO_T}$ac_cv_lib_m_cpowl" >&6
14325 if test $ac_cv_lib_m_cpowl = yes; then
14326
14327 cat >>confdefs.h <<\_ACEOF
14328 #define HAVE_CPOWL 1
14329 _ACEOF
14330
14331 fi
14332
14333 echo "$as_me:$LINENO: checking for roundf in -lm" >&5
14334 echo $ECHO_N "checking for roundf in -lm... $ECHO_C" >&6
14335 if test "${ac_cv_lib_m_roundf+set}" = set; then
14336   echo $ECHO_N "(cached) $ECHO_C" >&6
14337 else
14338   ac_check_lib_save_LIBS=$LIBS
14339 LIBS="-lm  $LIBS"
14340 if test x$gcc_no_link = xyes; then
14341   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14342 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14343    { (exit 1); exit 1; }; }
14344 fi
14345 cat >conftest.$ac_ext <<_ACEOF
14346 /* confdefs.h.  */
14347 _ACEOF
14348 cat confdefs.h >>conftest.$ac_ext
14349 cat >>conftest.$ac_ext <<_ACEOF
14350 /* end confdefs.h.  */
14351
14352 /* Override any gcc2 internal prototype to avoid an error.  */
14353 #ifdef __cplusplus
14354 extern "C"
14355 #endif
14356 /* We use char because int might match the return type of a gcc2
14357    builtin and then its argument prototype would still apply.  */
14358 char roundf ();
14359 int
14360 main ()
14361 {
14362 roundf ();
14363   ;
14364   return 0;
14365 }
14366 _ACEOF
14367 rm -f conftest.$ac_objext conftest$ac_exeext
14368 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14369   (eval $ac_link) 2>conftest.er1
14370   ac_status=$?
14371   grep -v '^ *+' conftest.er1 >conftest.err
14372   rm -f conftest.er1
14373   cat conftest.err >&5
14374   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14375   (exit $ac_status); } &&
14376          { ac_try='test -z "$ac_c_werror_flag"
14377                          || test ! -s conftest.err'
14378   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14379   (eval $ac_try) 2>&5
14380   ac_status=$?
14381   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14382   (exit $ac_status); }; } &&
14383          { ac_try='test -s conftest$ac_exeext'
14384   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14385   (eval $ac_try) 2>&5
14386   ac_status=$?
14387   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14388   (exit $ac_status); }; }; then
14389   ac_cv_lib_m_roundf=yes
14390 else
14391   echo "$as_me: failed program was:" >&5
14392 sed 's/^/| /' conftest.$ac_ext >&5
14393
14394 ac_cv_lib_m_roundf=no
14395 fi
14396 rm -f conftest.err conftest.$ac_objext \
14397       conftest$ac_exeext conftest.$ac_ext
14398 LIBS=$ac_check_lib_save_LIBS
14399 fi
14400 echo "$as_me:$LINENO: result: $ac_cv_lib_m_roundf" >&5
14401 echo "${ECHO_T}$ac_cv_lib_m_roundf" >&6
14402 if test $ac_cv_lib_m_roundf = yes; then
14403
14404 cat >>confdefs.h <<\_ACEOF
14405 #define HAVE_ROUNDF 1
14406 _ACEOF
14407
14408 fi
14409
14410 echo "$as_me:$LINENO: checking for round in -lm" >&5
14411 echo $ECHO_N "checking for round in -lm... $ECHO_C" >&6
14412 if test "${ac_cv_lib_m_round+set}" = set; then
14413   echo $ECHO_N "(cached) $ECHO_C" >&6
14414 else
14415   ac_check_lib_save_LIBS=$LIBS
14416 LIBS="-lm  $LIBS"
14417 if test x$gcc_no_link = xyes; then
14418   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14419 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14420    { (exit 1); exit 1; }; }
14421 fi
14422 cat >conftest.$ac_ext <<_ACEOF
14423 /* confdefs.h.  */
14424 _ACEOF
14425 cat confdefs.h >>conftest.$ac_ext
14426 cat >>conftest.$ac_ext <<_ACEOF
14427 /* end confdefs.h.  */
14428
14429 /* Override any gcc2 internal prototype to avoid an error.  */
14430 #ifdef __cplusplus
14431 extern "C"
14432 #endif
14433 /* We use char because int might match the return type of a gcc2
14434    builtin and then its argument prototype would still apply.  */
14435 char round ();
14436 int
14437 main ()
14438 {
14439 round ();
14440   ;
14441   return 0;
14442 }
14443 _ACEOF
14444 rm -f conftest.$ac_objext conftest$ac_exeext
14445 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14446   (eval $ac_link) 2>conftest.er1
14447   ac_status=$?
14448   grep -v '^ *+' conftest.er1 >conftest.err
14449   rm -f conftest.er1
14450   cat conftest.err >&5
14451   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14452   (exit $ac_status); } &&
14453          { ac_try='test -z "$ac_c_werror_flag"
14454                          || test ! -s conftest.err'
14455   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14456   (eval $ac_try) 2>&5
14457   ac_status=$?
14458   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14459   (exit $ac_status); }; } &&
14460          { ac_try='test -s conftest$ac_exeext'
14461   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14462   (eval $ac_try) 2>&5
14463   ac_status=$?
14464   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14465   (exit $ac_status); }; }; then
14466   ac_cv_lib_m_round=yes
14467 else
14468   echo "$as_me: failed program was:" >&5
14469 sed 's/^/| /' conftest.$ac_ext >&5
14470
14471 ac_cv_lib_m_round=no
14472 fi
14473 rm -f conftest.err conftest.$ac_objext \
14474       conftest$ac_exeext conftest.$ac_ext
14475 LIBS=$ac_check_lib_save_LIBS
14476 fi
14477 echo "$as_me:$LINENO: result: $ac_cv_lib_m_round" >&5
14478 echo "${ECHO_T}$ac_cv_lib_m_round" >&6
14479 if test $ac_cv_lib_m_round = yes; then
14480
14481 cat >>confdefs.h <<\_ACEOF
14482 #define HAVE_ROUND 1
14483 _ACEOF
14484
14485 fi
14486
14487 echo "$as_me:$LINENO: checking for roundl in -lm" >&5
14488 echo $ECHO_N "checking for roundl in -lm... $ECHO_C" >&6
14489 if test "${ac_cv_lib_m_roundl+set}" = set; then
14490   echo $ECHO_N "(cached) $ECHO_C" >&6
14491 else
14492   ac_check_lib_save_LIBS=$LIBS
14493 LIBS="-lm  $LIBS"
14494 if test x$gcc_no_link = xyes; then
14495   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14496 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14497    { (exit 1); exit 1; }; }
14498 fi
14499 cat >conftest.$ac_ext <<_ACEOF
14500 /* confdefs.h.  */
14501 _ACEOF
14502 cat confdefs.h >>conftest.$ac_ext
14503 cat >>conftest.$ac_ext <<_ACEOF
14504 /* end confdefs.h.  */
14505
14506 /* Override any gcc2 internal prototype to avoid an error.  */
14507 #ifdef __cplusplus
14508 extern "C"
14509 #endif
14510 /* We use char because int might match the return type of a gcc2
14511    builtin and then its argument prototype would still apply.  */
14512 char roundl ();
14513 int
14514 main ()
14515 {
14516 roundl ();
14517   ;
14518   return 0;
14519 }
14520 _ACEOF
14521 rm -f conftest.$ac_objext conftest$ac_exeext
14522 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14523   (eval $ac_link) 2>conftest.er1
14524   ac_status=$?
14525   grep -v '^ *+' conftest.er1 >conftest.err
14526   rm -f conftest.er1
14527   cat conftest.err >&5
14528   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14529   (exit $ac_status); } &&
14530          { ac_try='test -z "$ac_c_werror_flag"
14531                          || test ! -s conftest.err'
14532   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14533   (eval $ac_try) 2>&5
14534   ac_status=$?
14535   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14536   (exit $ac_status); }; } &&
14537          { ac_try='test -s conftest$ac_exeext'
14538   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14539   (eval $ac_try) 2>&5
14540   ac_status=$?
14541   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14542   (exit $ac_status); }; }; then
14543   ac_cv_lib_m_roundl=yes
14544 else
14545   echo "$as_me: failed program was:" >&5
14546 sed 's/^/| /' conftest.$ac_ext >&5
14547
14548 ac_cv_lib_m_roundl=no
14549 fi
14550 rm -f conftest.err conftest.$ac_objext \
14551       conftest$ac_exeext conftest.$ac_ext
14552 LIBS=$ac_check_lib_save_LIBS
14553 fi
14554 echo "$as_me:$LINENO: result: $ac_cv_lib_m_roundl" >&5
14555 echo "${ECHO_T}$ac_cv_lib_m_roundl" >&6
14556 if test $ac_cv_lib_m_roundl = yes; then
14557
14558 cat >>confdefs.h <<\_ACEOF
14559 #define HAVE_ROUNDL 1
14560 _ACEOF
14561
14562 fi
14563
14564 echo "$as_me:$LINENO: checking for scalbnf in -lm" >&5
14565 echo $ECHO_N "checking for scalbnf in -lm... $ECHO_C" >&6
14566 if test "${ac_cv_lib_m_scalbnf+set}" = set; then
14567   echo $ECHO_N "(cached) $ECHO_C" >&6
14568 else
14569   ac_check_lib_save_LIBS=$LIBS
14570 LIBS="-lm  $LIBS"
14571 if test x$gcc_no_link = xyes; then
14572   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14573 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14574    { (exit 1); exit 1; }; }
14575 fi
14576 cat >conftest.$ac_ext <<_ACEOF
14577 /* confdefs.h.  */
14578 _ACEOF
14579 cat confdefs.h >>conftest.$ac_ext
14580 cat >>conftest.$ac_ext <<_ACEOF
14581 /* end confdefs.h.  */
14582
14583 /* Override any gcc2 internal prototype to avoid an error.  */
14584 #ifdef __cplusplus
14585 extern "C"
14586 #endif
14587 /* We use char because int might match the return type of a gcc2
14588    builtin and then its argument prototype would still apply.  */
14589 char scalbnf ();
14590 int
14591 main ()
14592 {
14593 scalbnf ();
14594   ;
14595   return 0;
14596 }
14597 _ACEOF
14598 rm -f conftest.$ac_objext conftest$ac_exeext
14599 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14600   (eval $ac_link) 2>conftest.er1
14601   ac_status=$?
14602   grep -v '^ *+' conftest.er1 >conftest.err
14603   rm -f conftest.er1
14604   cat conftest.err >&5
14605   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14606   (exit $ac_status); } &&
14607          { ac_try='test -z "$ac_c_werror_flag"
14608                          || test ! -s conftest.err'
14609   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14610   (eval $ac_try) 2>&5
14611   ac_status=$?
14612   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14613   (exit $ac_status); }; } &&
14614          { ac_try='test -s conftest$ac_exeext'
14615   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14616   (eval $ac_try) 2>&5
14617   ac_status=$?
14618   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14619   (exit $ac_status); }; }; then
14620   ac_cv_lib_m_scalbnf=yes
14621 else
14622   echo "$as_me: failed program was:" >&5
14623 sed 's/^/| /' conftest.$ac_ext >&5
14624
14625 ac_cv_lib_m_scalbnf=no
14626 fi
14627 rm -f conftest.err conftest.$ac_objext \
14628       conftest$ac_exeext conftest.$ac_ext
14629 LIBS=$ac_check_lib_save_LIBS
14630 fi
14631 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbnf" >&5
14632 echo "${ECHO_T}$ac_cv_lib_m_scalbnf" >&6
14633 if test $ac_cv_lib_m_scalbnf = yes; then
14634
14635 cat >>confdefs.h <<\_ACEOF
14636 #define HAVE_SCALBNF 1
14637 _ACEOF
14638
14639 fi
14640
14641 echo "$as_me:$LINENO: checking for scalbn in -lm" >&5
14642 echo $ECHO_N "checking for scalbn in -lm... $ECHO_C" >&6
14643 if test "${ac_cv_lib_m_scalbn+set}" = set; then
14644   echo $ECHO_N "(cached) $ECHO_C" >&6
14645 else
14646   ac_check_lib_save_LIBS=$LIBS
14647 LIBS="-lm  $LIBS"
14648 if test x$gcc_no_link = xyes; then
14649   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14650 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14651    { (exit 1); exit 1; }; }
14652 fi
14653 cat >conftest.$ac_ext <<_ACEOF
14654 /* confdefs.h.  */
14655 _ACEOF
14656 cat confdefs.h >>conftest.$ac_ext
14657 cat >>conftest.$ac_ext <<_ACEOF
14658 /* end confdefs.h.  */
14659
14660 /* Override any gcc2 internal prototype to avoid an error.  */
14661 #ifdef __cplusplus
14662 extern "C"
14663 #endif
14664 /* We use char because int might match the return type of a gcc2
14665    builtin and then its argument prototype would still apply.  */
14666 char scalbn ();
14667 int
14668 main ()
14669 {
14670 scalbn ();
14671   ;
14672   return 0;
14673 }
14674 _ACEOF
14675 rm -f conftest.$ac_objext conftest$ac_exeext
14676 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14677   (eval $ac_link) 2>conftest.er1
14678   ac_status=$?
14679   grep -v '^ *+' conftest.er1 >conftest.err
14680   rm -f conftest.er1
14681   cat conftest.err >&5
14682   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14683   (exit $ac_status); } &&
14684          { ac_try='test -z "$ac_c_werror_flag"
14685                          || test ! -s conftest.err'
14686   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14687   (eval $ac_try) 2>&5
14688   ac_status=$?
14689   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14690   (exit $ac_status); }; } &&
14691          { ac_try='test -s conftest$ac_exeext'
14692   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14693   (eval $ac_try) 2>&5
14694   ac_status=$?
14695   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14696   (exit $ac_status); }; }; then
14697   ac_cv_lib_m_scalbn=yes
14698 else
14699   echo "$as_me: failed program was:" >&5
14700 sed 's/^/| /' conftest.$ac_ext >&5
14701
14702 ac_cv_lib_m_scalbn=no
14703 fi
14704 rm -f conftest.err conftest.$ac_objext \
14705       conftest$ac_exeext conftest.$ac_ext
14706 LIBS=$ac_check_lib_save_LIBS
14707 fi
14708 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbn" >&5
14709 echo "${ECHO_T}$ac_cv_lib_m_scalbn" >&6
14710 if test $ac_cv_lib_m_scalbn = yes; then
14711
14712 cat >>confdefs.h <<\_ACEOF
14713 #define HAVE_SCALBN 1
14714 _ACEOF
14715
14716 fi
14717
14718 echo "$as_me:$LINENO: checking for scalbnl in -lm" >&5
14719 echo $ECHO_N "checking for scalbnl in -lm... $ECHO_C" >&6
14720 if test "${ac_cv_lib_m_scalbnl+set}" = set; then
14721   echo $ECHO_N "(cached) $ECHO_C" >&6
14722 else
14723   ac_check_lib_save_LIBS=$LIBS
14724 LIBS="-lm  $LIBS"
14725 if test x$gcc_no_link = xyes; then
14726   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14727 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14728    { (exit 1); exit 1; }; }
14729 fi
14730 cat >conftest.$ac_ext <<_ACEOF
14731 /* confdefs.h.  */
14732 _ACEOF
14733 cat confdefs.h >>conftest.$ac_ext
14734 cat >>conftest.$ac_ext <<_ACEOF
14735 /* end confdefs.h.  */
14736
14737 /* Override any gcc2 internal prototype to avoid an error.  */
14738 #ifdef __cplusplus
14739 extern "C"
14740 #endif
14741 /* We use char because int might match the return type of a gcc2
14742    builtin and then its argument prototype would still apply.  */
14743 char scalbnl ();
14744 int
14745 main ()
14746 {
14747 scalbnl ();
14748   ;
14749   return 0;
14750 }
14751 _ACEOF
14752 rm -f conftest.$ac_objext conftest$ac_exeext
14753 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14754   (eval $ac_link) 2>conftest.er1
14755   ac_status=$?
14756   grep -v '^ *+' conftest.er1 >conftest.err
14757   rm -f conftest.er1
14758   cat conftest.err >&5
14759   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14760   (exit $ac_status); } &&
14761          { ac_try='test -z "$ac_c_werror_flag"
14762                          || test ! -s conftest.err'
14763   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14764   (eval $ac_try) 2>&5
14765   ac_status=$?
14766   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14767   (exit $ac_status); }; } &&
14768          { ac_try='test -s conftest$ac_exeext'
14769   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14770   (eval $ac_try) 2>&5
14771   ac_status=$?
14772   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14773   (exit $ac_status); }; }; then
14774   ac_cv_lib_m_scalbnl=yes
14775 else
14776   echo "$as_me: failed program was:" >&5
14777 sed 's/^/| /' conftest.$ac_ext >&5
14778
14779 ac_cv_lib_m_scalbnl=no
14780 fi
14781 rm -f conftest.err conftest.$ac_objext \
14782       conftest$ac_exeext conftest.$ac_ext
14783 LIBS=$ac_check_lib_save_LIBS
14784 fi
14785 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbnl" >&5
14786 echo "${ECHO_T}$ac_cv_lib_m_scalbnl" >&6
14787 if test $ac_cv_lib_m_scalbnl = yes; then
14788
14789 cat >>confdefs.h <<\_ACEOF
14790 #define HAVE_SCALBNL 1
14791 _ACEOF
14792
14793 fi
14794
14795 echo "$as_me:$LINENO: checking for sinf in -lm" >&5
14796 echo $ECHO_N "checking for sinf in -lm... $ECHO_C" >&6
14797 if test "${ac_cv_lib_m_sinf+set}" = set; then
14798   echo $ECHO_N "(cached) $ECHO_C" >&6
14799 else
14800   ac_check_lib_save_LIBS=$LIBS
14801 LIBS="-lm  $LIBS"
14802 if test x$gcc_no_link = xyes; then
14803   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14804 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14805    { (exit 1); exit 1; }; }
14806 fi
14807 cat >conftest.$ac_ext <<_ACEOF
14808 /* confdefs.h.  */
14809 _ACEOF
14810 cat confdefs.h >>conftest.$ac_ext
14811 cat >>conftest.$ac_ext <<_ACEOF
14812 /* end confdefs.h.  */
14813
14814 /* Override any gcc2 internal prototype to avoid an error.  */
14815 #ifdef __cplusplus
14816 extern "C"
14817 #endif
14818 /* We use char because int might match the return type of a gcc2
14819    builtin and then its argument prototype would still apply.  */
14820 char sinf ();
14821 int
14822 main ()
14823 {
14824 sinf ();
14825   ;
14826   return 0;
14827 }
14828 _ACEOF
14829 rm -f conftest.$ac_objext conftest$ac_exeext
14830 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14831   (eval $ac_link) 2>conftest.er1
14832   ac_status=$?
14833   grep -v '^ *+' conftest.er1 >conftest.err
14834   rm -f conftest.er1
14835   cat conftest.err >&5
14836   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14837   (exit $ac_status); } &&
14838          { ac_try='test -z "$ac_c_werror_flag"
14839                          || test ! -s conftest.err'
14840   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14841   (eval $ac_try) 2>&5
14842   ac_status=$?
14843   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14844   (exit $ac_status); }; } &&
14845          { ac_try='test -s conftest$ac_exeext'
14846   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14847   (eval $ac_try) 2>&5
14848   ac_status=$?
14849   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14850   (exit $ac_status); }; }; then
14851   ac_cv_lib_m_sinf=yes
14852 else
14853   echo "$as_me: failed program was:" >&5
14854 sed 's/^/| /' conftest.$ac_ext >&5
14855
14856 ac_cv_lib_m_sinf=no
14857 fi
14858 rm -f conftest.err conftest.$ac_objext \
14859       conftest$ac_exeext conftest.$ac_ext
14860 LIBS=$ac_check_lib_save_LIBS
14861 fi
14862 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinf" >&5
14863 echo "${ECHO_T}$ac_cv_lib_m_sinf" >&6
14864 if test $ac_cv_lib_m_sinf = yes; then
14865
14866 cat >>confdefs.h <<\_ACEOF
14867 #define HAVE_SINF 1
14868 _ACEOF
14869
14870 fi
14871
14872 echo "$as_me:$LINENO: checking for sin in -lm" >&5
14873 echo $ECHO_N "checking for sin in -lm... $ECHO_C" >&6
14874 if test "${ac_cv_lib_m_sin+set}" = set; then
14875   echo $ECHO_N "(cached) $ECHO_C" >&6
14876 else
14877   ac_check_lib_save_LIBS=$LIBS
14878 LIBS="-lm  $LIBS"
14879 if test x$gcc_no_link = xyes; then
14880   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14881 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14882    { (exit 1); exit 1; }; }
14883 fi
14884 cat >conftest.$ac_ext <<_ACEOF
14885 /* confdefs.h.  */
14886 _ACEOF
14887 cat confdefs.h >>conftest.$ac_ext
14888 cat >>conftest.$ac_ext <<_ACEOF
14889 /* end confdefs.h.  */
14890
14891 /* Override any gcc2 internal prototype to avoid an error.  */
14892 #ifdef __cplusplus
14893 extern "C"
14894 #endif
14895 /* We use char because int might match the return type of a gcc2
14896    builtin and then its argument prototype would still apply.  */
14897 char sin ();
14898 int
14899 main ()
14900 {
14901 sin ();
14902   ;
14903   return 0;
14904 }
14905 _ACEOF
14906 rm -f conftest.$ac_objext conftest$ac_exeext
14907 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14908   (eval $ac_link) 2>conftest.er1
14909   ac_status=$?
14910   grep -v '^ *+' conftest.er1 >conftest.err
14911   rm -f conftest.er1
14912   cat conftest.err >&5
14913   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14914   (exit $ac_status); } &&
14915          { ac_try='test -z "$ac_c_werror_flag"
14916                          || test ! -s conftest.err'
14917   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14918   (eval $ac_try) 2>&5
14919   ac_status=$?
14920   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14921   (exit $ac_status); }; } &&
14922          { ac_try='test -s conftest$ac_exeext'
14923   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14924   (eval $ac_try) 2>&5
14925   ac_status=$?
14926   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14927   (exit $ac_status); }; }; then
14928   ac_cv_lib_m_sin=yes
14929 else
14930   echo "$as_me: failed program was:" >&5
14931 sed 's/^/| /' conftest.$ac_ext >&5
14932
14933 ac_cv_lib_m_sin=no
14934 fi
14935 rm -f conftest.err conftest.$ac_objext \
14936       conftest$ac_exeext conftest.$ac_ext
14937 LIBS=$ac_check_lib_save_LIBS
14938 fi
14939 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sin" >&5
14940 echo "${ECHO_T}$ac_cv_lib_m_sin" >&6
14941 if test $ac_cv_lib_m_sin = yes; then
14942
14943 cat >>confdefs.h <<\_ACEOF
14944 #define HAVE_SIN 1
14945 _ACEOF
14946
14947 fi
14948
14949 echo "$as_me:$LINENO: checking for sinl in -lm" >&5
14950 echo $ECHO_N "checking for sinl in -lm... $ECHO_C" >&6
14951 if test "${ac_cv_lib_m_sinl+set}" = set; then
14952   echo $ECHO_N "(cached) $ECHO_C" >&6
14953 else
14954   ac_check_lib_save_LIBS=$LIBS
14955 LIBS="-lm  $LIBS"
14956 if test x$gcc_no_link = xyes; then
14957   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14958 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14959    { (exit 1); exit 1; }; }
14960 fi
14961 cat >conftest.$ac_ext <<_ACEOF
14962 /* confdefs.h.  */
14963 _ACEOF
14964 cat confdefs.h >>conftest.$ac_ext
14965 cat >>conftest.$ac_ext <<_ACEOF
14966 /* end confdefs.h.  */
14967
14968 /* Override any gcc2 internal prototype to avoid an error.  */
14969 #ifdef __cplusplus
14970 extern "C"
14971 #endif
14972 /* We use char because int might match the return type of a gcc2
14973    builtin and then its argument prototype would still apply.  */
14974 char sinl ();
14975 int
14976 main ()
14977 {
14978 sinl ();
14979   ;
14980   return 0;
14981 }
14982 _ACEOF
14983 rm -f conftest.$ac_objext conftest$ac_exeext
14984 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14985   (eval $ac_link) 2>conftest.er1
14986   ac_status=$?
14987   grep -v '^ *+' conftest.er1 >conftest.err
14988   rm -f conftest.er1
14989   cat conftest.err >&5
14990   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14991   (exit $ac_status); } &&
14992          { ac_try='test -z "$ac_c_werror_flag"
14993                          || test ! -s conftest.err'
14994   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14995   (eval $ac_try) 2>&5
14996   ac_status=$?
14997   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14998   (exit $ac_status); }; } &&
14999          { ac_try='test -s conftest$ac_exeext'
15000   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15001   (eval $ac_try) 2>&5
15002   ac_status=$?
15003   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15004   (exit $ac_status); }; }; then
15005   ac_cv_lib_m_sinl=yes
15006 else
15007   echo "$as_me: failed program was:" >&5
15008 sed 's/^/| /' conftest.$ac_ext >&5
15009
15010 ac_cv_lib_m_sinl=no
15011 fi
15012 rm -f conftest.err conftest.$ac_objext \
15013       conftest$ac_exeext conftest.$ac_ext
15014 LIBS=$ac_check_lib_save_LIBS
15015 fi
15016 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinl" >&5
15017 echo "${ECHO_T}$ac_cv_lib_m_sinl" >&6
15018 if test $ac_cv_lib_m_sinl = yes; then
15019
15020 cat >>confdefs.h <<\_ACEOF
15021 #define HAVE_SINL 1
15022 _ACEOF
15023
15024 fi
15025
15026 echo "$as_me:$LINENO: checking for csinf in -lm" >&5
15027 echo $ECHO_N "checking for csinf in -lm... $ECHO_C" >&6
15028 if test "${ac_cv_lib_m_csinf+set}" = set; then
15029   echo $ECHO_N "(cached) $ECHO_C" >&6
15030 else
15031   ac_check_lib_save_LIBS=$LIBS
15032 LIBS="-lm  $LIBS"
15033 if test x$gcc_no_link = xyes; then
15034   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15035 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15036    { (exit 1); exit 1; }; }
15037 fi
15038 cat >conftest.$ac_ext <<_ACEOF
15039 /* confdefs.h.  */
15040 _ACEOF
15041 cat confdefs.h >>conftest.$ac_ext
15042 cat >>conftest.$ac_ext <<_ACEOF
15043 /* end confdefs.h.  */
15044
15045 /* Override any gcc2 internal prototype to avoid an error.  */
15046 #ifdef __cplusplus
15047 extern "C"
15048 #endif
15049 /* We use char because int might match the return type of a gcc2
15050    builtin and then its argument prototype would still apply.  */
15051 char csinf ();
15052 int
15053 main ()
15054 {
15055 csinf ();
15056   ;
15057   return 0;
15058 }
15059 _ACEOF
15060 rm -f conftest.$ac_objext conftest$ac_exeext
15061 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15062   (eval $ac_link) 2>conftest.er1
15063   ac_status=$?
15064   grep -v '^ *+' conftest.er1 >conftest.err
15065   rm -f conftest.er1
15066   cat conftest.err >&5
15067   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15068   (exit $ac_status); } &&
15069          { ac_try='test -z "$ac_c_werror_flag"
15070                          || test ! -s conftest.err'
15071   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15072   (eval $ac_try) 2>&5
15073   ac_status=$?
15074   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15075   (exit $ac_status); }; } &&
15076          { ac_try='test -s conftest$ac_exeext'
15077   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15078   (eval $ac_try) 2>&5
15079   ac_status=$?
15080   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15081   (exit $ac_status); }; }; then
15082   ac_cv_lib_m_csinf=yes
15083 else
15084   echo "$as_me: failed program was:" >&5
15085 sed 's/^/| /' conftest.$ac_ext >&5
15086
15087 ac_cv_lib_m_csinf=no
15088 fi
15089 rm -f conftest.err conftest.$ac_objext \
15090       conftest$ac_exeext conftest.$ac_ext
15091 LIBS=$ac_check_lib_save_LIBS
15092 fi
15093 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinf" >&5
15094 echo "${ECHO_T}$ac_cv_lib_m_csinf" >&6
15095 if test $ac_cv_lib_m_csinf = yes; then
15096
15097 cat >>confdefs.h <<\_ACEOF
15098 #define HAVE_CSINF 1
15099 _ACEOF
15100
15101 fi
15102
15103 echo "$as_me:$LINENO: checking for csin in -lm" >&5
15104 echo $ECHO_N "checking for csin in -lm... $ECHO_C" >&6
15105 if test "${ac_cv_lib_m_csin+set}" = set; then
15106   echo $ECHO_N "(cached) $ECHO_C" >&6
15107 else
15108   ac_check_lib_save_LIBS=$LIBS
15109 LIBS="-lm  $LIBS"
15110 if test x$gcc_no_link = xyes; then
15111   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15112 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15113    { (exit 1); exit 1; }; }
15114 fi
15115 cat >conftest.$ac_ext <<_ACEOF
15116 /* confdefs.h.  */
15117 _ACEOF
15118 cat confdefs.h >>conftest.$ac_ext
15119 cat >>conftest.$ac_ext <<_ACEOF
15120 /* end confdefs.h.  */
15121
15122 /* Override any gcc2 internal prototype to avoid an error.  */
15123 #ifdef __cplusplus
15124 extern "C"
15125 #endif
15126 /* We use char because int might match the return type of a gcc2
15127    builtin and then its argument prototype would still apply.  */
15128 char csin ();
15129 int
15130 main ()
15131 {
15132 csin ();
15133   ;
15134   return 0;
15135 }
15136 _ACEOF
15137 rm -f conftest.$ac_objext conftest$ac_exeext
15138 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15139   (eval $ac_link) 2>conftest.er1
15140   ac_status=$?
15141   grep -v '^ *+' conftest.er1 >conftest.err
15142   rm -f conftest.er1
15143   cat conftest.err >&5
15144   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15145   (exit $ac_status); } &&
15146          { ac_try='test -z "$ac_c_werror_flag"
15147                          || test ! -s conftest.err'
15148   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15149   (eval $ac_try) 2>&5
15150   ac_status=$?
15151   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15152   (exit $ac_status); }; } &&
15153          { ac_try='test -s conftest$ac_exeext'
15154   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15155   (eval $ac_try) 2>&5
15156   ac_status=$?
15157   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15158   (exit $ac_status); }; }; then
15159   ac_cv_lib_m_csin=yes
15160 else
15161   echo "$as_me: failed program was:" >&5
15162 sed 's/^/| /' conftest.$ac_ext >&5
15163
15164 ac_cv_lib_m_csin=no
15165 fi
15166 rm -f conftest.err conftest.$ac_objext \
15167       conftest$ac_exeext conftest.$ac_ext
15168 LIBS=$ac_check_lib_save_LIBS
15169 fi
15170 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csin" >&5
15171 echo "${ECHO_T}$ac_cv_lib_m_csin" >&6
15172 if test $ac_cv_lib_m_csin = yes; then
15173
15174 cat >>confdefs.h <<\_ACEOF
15175 #define HAVE_CSIN 1
15176 _ACEOF
15177
15178 fi
15179
15180 echo "$as_me:$LINENO: checking for csinl in -lm" >&5
15181 echo $ECHO_N "checking for csinl in -lm... $ECHO_C" >&6
15182 if test "${ac_cv_lib_m_csinl+set}" = set; then
15183   echo $ECHO_N "(cached) $ECHO_C" >&6
15184 else
15185   ac_check_lib_save_LIBS=$LIBS
15186 LIBS="-lm  $LIBS"
15187 if test x$gcc_no_link = xyes; then
15188   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15189 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15190    { (exit 1); exit 1; }; }
15191 fi
15192 cat >conftest.$ac_ext <<_ACEOF
15193 /* confdefs.h.  */
15194 _ACEOF
15195 cat confdefs.h >>conftest.$ac_ext
15196 cat >>conftest.$ac_ext <<_ACEOF
15197 /* end confdefs.h.  */
15198
15199 /* Override any gcc2 internal prototype to avoid an error.  */
15200 #ifdef __cplusplus
15201 extern "C"
15202 #endif
15203 /* We use char because int might match the return type of a gcc2
15204    builtin and then its argument prototype would still apply.  */
15205 char csinl ();
15206 int
15207 main ()
15208 {
15209 csinl ();
15210   ;
15211   return 0;
15212 }
15213 _ACEOF
15214 rm -f conftest.$ac_objext conftest$ac_exeext
15215 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15216   (eval $ac_link) 2>conftest.er1
15217   ac_status=$?
15218   grep -v '^ *+' conftest.er1 >conftest.err
15219   rm -f conftest.er1
15220   cat conftest.err >&5
15221   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15222   (exit $ac_status); } &&
15223          { ac_try='test -z "$ac_c_werror_flag"
15224                          || test ! -s conftest.err'
15225   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15226   (eval $ac_try) 2>&5
15227   ac_status=$?
15228   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15229   (exit $ac_status); }; } &&
15230          { ac_try='test -s conftest$ac_exeext'
15231   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15232   (eval $ac_try) 2>&5
15233   ac_status=$?
15234   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15235   (exit $ac_status); }; }; then
15236   ac_cv_lib_m_csinl=yes
15237 else
15238   echo "$as_me: failed program was:" >&5
15239 sed 's/^/| /' conftest.$ac_ext >&5
15240
15241 ac_cv_lib_m_csinl=no
15242 fi
15243 rm -f conftest.err conftest.$ac_objext \
15244       conftest$ac_exeext conftest.$ac_ext
15245 LIBS=$ac_check_lib_save_LIBS
15246 fi
15247 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinl" >&5
15248 echo "${ECHO_T}$ac_cv_lib_m_csinl" >&6
15249 if test $ac_cv_lib_m_csinl = yes; then
15250
15251 cat >>confdefs.h <<\_ACEOF
15252 #define HAVE_CSINL 1
15253 _ACEOF
15254
15255 fi
15256
15257 echo "$as_me:$LINENO: checking for sinhf in -lm" >&5
15258 echo $ECHO_N "checking for sinhf in -lm... $ECHO_C" >&6
15259 if test "${ac_cv_lib_m_sinhf+set}" = set; then
15260   echo $ECHO_N "(cached) $ECHO_C" >&6
15261 else
15262   ac_check_lib_save_LIBS=$LIBS
15263 LIBS="-lm  $LIBS"
15264 if test x$gcc_no_link = xyes; then
15265   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15266 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15267    { (exit 1); exit 1; }; }
15268 fi
15269 cat >conftest.$ac_ext <<_ACEOF
15270 /* confdefs.h.  */
15271 _ACEOF
15272 cat confdefs.h >>conftest.$ac_ext
15273 cat >>conftest.$ac_ext <<_ACEOF
15274 /* end confdefs.h.  */
15275
15276 /* Override any gcc2 internal prototype to avoid an error.  */
15277 #ifdef __cplusplus
15278 extern "C"
15279 #endif
15280 /* We use char because int might match the return type of a gcc2
15281    builtin and then its argument prototype would still apply.  */
15282 char sinhf ();
15283 int
15284 main ()
15285 {
15286 sinhf ();
15287   ;
15288   return 0;
15289 }
15290 _ACEOF
15291 rm -f conftest.$ac_objext conftest$ac_exeext
15292 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15293   (eval $ac_link) 2>conftest.er1
15294   ac_status=$?
15295   grep -v '^ *+' conftest.er1 >conftest.err
15296   rm -f conftest.er1
15297   cat conftest.err >&5
15298   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15299   (exit $ac_status); } &&
15300          { ac_try='test -z "$ac_c_werror_flag"
15301                          || test ! -s conftest.err'
15302   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15303   (eval $ac_try) 2>&5
15304   ac_status=$?
15305   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15306   (exit $ac_status); }; } &&
15307          { ac_try='test -s conftest$ac_exeext'
15308   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15309   (eval $ac_try) 2>&5
15310   ac_status=$?
15311   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15312   (exit $ac_status); }; }; then
15313   ac_cv_lib_m_sinhf=yes
15314 else
15315   echo "$as_me: failed program was:" >&5
15316 sed 's/^/| /' conftest.$ac_ext >&5
15317
15318 ac_cv_lib_m_sinhf=no
15319 fi
15320 rm -f conftest.err conftest.$ac_objext \
15321       conftest$ac_exeext conftest.$ac_ext
15322 LIBS=$ac_check_lib_save_LIBS
15323 fi
15324 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinhf" >&5
15325 echo "${ECHO_T}$ac_cv_lib_m_sinhf" >&6
15326 if test $ac_cv_lib_m_sinhf = yes; then
15327
15328 cat >>confdefs.h <<\_ACEOF
15329 #define HAVE_SINHF 1
15330 _ACEOF
15331
15332 fi
15333
15334 echo "$as_me:$LINENO: checking for sinh in -lm" >&5
15335 echo $ECHO_N "checking for sinh in -lm... $ECHO_C" >&6
15336 if test "${ac_cv_lib_m_sinh+set}" = set; then
15337   echo $ECHO_N "(cached) $ECHO_C" >&6
15338 else
15339   ac_check_lib_save_LIBS=$LIBS
15340 LIBS="-lm  $LIBS"
15341 if test x$gcc_no_link = xyes; then
15342   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15343 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15344    { (exit 1); exit 1; }; }
15345 fi
15346 cat >conftest.$ac_ext <<_ACEOF
15347 /* confdefs.h.  */
15348 _ACEOF
15349 cat confdefs.h >>conftest.$ac_ext
15350 cat >>conftest.$ac_ext <<_ACEOF
15351 /* end confdefs.h.  */
15352
15353 /* Override any gcc2 internal prototype to avoid an error.  */
15354 #ifdef __cplusplus
15355 extern "C"
15356 #endif
15357 /* We use char because int might match the return type of a gcc2
15358    builtin and then its argument prototype would still apply.  */
15359 char sinh ();
15360 int
15361 main ()
15362 {
15363 sinh ();
15364   ;
15365   return 0;
15366 }
15367 _ACEOF
15368 rm -f conftest.$ac_objext conftest$ac_exeext
15369 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15370   (eval $ac_link) 2>conftest.er1
15371   ac_status=$?
15372   grep -v '^ *+' conftest.er1 >conftest.err
15373   rm -f conftest.er1
15374   cat conftest.err >&5
15375   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15376   (exit $ac_status); } &&
15377          { ac_try='test -z "$ac_c_werror_flag"
15378                          || test ! -s conftest.err'
15379   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15380   (eval $ac_try) 2>&5
15381   ac_status=$?
15382   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15383   (exit $ac_status); }; } &&
15384          { ac_try='test -s conftest$ac_exeext'
15385   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15386   (eval $ac_try) 2>&5
15387   ac_status=$?
15388   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15389   (exit $ac_status); }; }; then
15390   ac_cv_lib_m_sinh=yes
15391 else
15392   echo "$as_me: failed program was:" >&5
15393 sed 's/^/| /' conftest.$ac_ext >&5
15394
15395 ac_cv_lib_m_sinh=no
15396 fi
15397 rm -f conftest.err conftest.$ac_objext \
15398       conftest$ac_exeext conftest.$ac_ext
15399 LIBS=$ac_check_lib_save_LIBS
15400 fi
15401 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinh" >&5
15402 echo "${ECHO_T}$ac_cv_lib_m_sinh" >&6
15403 if test $ac_cv_lib_m_sinh = yes; then
15404
15405 cat >>confdefs.h <<\_ACEOF
15406 #define HAVE_SINH 1
15407 _ACEOF
15408
15409 fi
15410
15411 echo "$as_me:$LINENO: checking for sinhl in -lm" >&5
15412 echo $ECHO_N "checking for sinhl in -lm... $ECHO_C" >&6
15413 if test "${ac_cv_lib_m_sinhl+set}" = set; then
15414   echo $ECHO_N "(cached) $ECHO_C" >&6
15415 else
15416   ac_check_lib_save_LIBS=$LIBS
15417 LIBS="-lm  $LIBS"
15418 if test x$gcc_no_link = xyes; then
15419   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15420 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15421    { (exit 1); exit 1; }; }
15422 fi
15423 cat >conftest.$ac_ext <<_ACEOF
15424 /* confdefs.h.  */
15425 _ACEOF
15426 cat confdefs.h >>conftest.$ac_ext
15427 cat >>conftest.$ac_ext <<_ACEOF
15428 /* end confdefs.h.  */
15429
15430 /* Override any gcc2 internal prototype to avoid an error.  */
15431 #ifdef __cplusplus
15432 extern "C"
15433 #endif
15434 /* We use char because int might match the return type of a gcc2
15435    builtin and then its argument prototype would still apply.  */
15436 char sinhl ();
15437 int
15438 main ()
15439 {
15440 sinhl ();
15441   ;
15442   return 0;
15443 }
15444 _ACEOF
15445 rm -f conftest.$ac_objext conftest$ac_exeext
15446 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15447   (eval $ac_link) 2>conftest.er1
15448   ac_status=$?
15449   grep -v '^ *+' conftest.er1 >conftest.err
15450   rm -f conftest.er1
15451   cat conftest.err >&5
15452   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15453   (exit $ac_status); } &&
15454          { ac_try='test -z "$ac_c_werror_flag"
15455                          || test ! -s conftest.err'
15456   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15457   (eval $ac_try) 2>&5
15458   ac_status=$?
15459   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15460   (exit $ac_status); }; } &&
15461          { ac_try='test -s conftest$ac_exeext'
15462   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15463   (eval $ac_try) 2>&5
15464   ac_status=$?
15465   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15466   (exit $ac_status); }; }; then
15467   ac_cv_lib_m_sinhl=yes
15468 else
15469   echo "$as_me: failed program was:" >&5
15470 sed 's/^/| /' conftest.$ac_ext >&5
15471
15472 ac_cv_lib_m_sinhl=no
15473 fi
15474 rm -f conftest.err conftest.$ac_objext \
15475       conftest$ac_exeext conftest.$ac_ext
15476 LIBS=$ac_check_lib_save_LIBS
15477 fi
15478 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinhl" >&5
15479 echo "${ECHO_T}$ac_cv_lib_m_sinhl" >&6
15480 if test $ac_cv_lib_m_sinhl = yes; then
15481
15482 cat >>confdefs.h <<\_ACEOF
15483 #define HAVE_SINHL 1
15484 _ACEOF
15485
15486 fi
15487
15488 echo "$as_me:$LINENO: checking for csinhf in -lm" >&5
15489 echo $ECHO_N "checking for csinhf in -lm... $ECHO_C" >&6
15490 if test "${ac_cv_lib_m_csinhf+set}" = set; then
15491   echo $ECHO_N "(cached) $ECHO_C" >&6
15492 else
15493   ac_check_lib_save_LIBS=$LIBS
15494 LIBS="-lm  $LIBS"
15495 if test x$gcc_no_link = xyes; then
15496   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15497 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15498    { (exit 1); exit 1; }; }
15499 fi
15500 cat >conftest.$ac_ext <<_ACEOF
15501 /* confdefs.h.  */
15502 _ACEOF
15503 cat confdefs.h >>conftest.$ac_ext
15504 cat >>conftest.$ac_ext <<_ACEOF
15505 /* end confdefs.h.  */
15506
15507 /* Override any gcc2 internal prototype to avoid an error.  */
15508 #ifdef __cplusplus
15509 extern "C"
15510 #endif
15511 /* We use char because int might match the return type of a gcc2
15512    builtin and then its argument prototype would still apply.  */
15513 char csinhf ();
15514 int
15515 main ()
15516 {
15517 csinhf ();
15518   ;
15519   return 0;
15520 }
15521 _ACEOF
15522 rm -f conftest.$ac_objext conftest$ac_exeext
15523 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15524   (eval $ac_link) 2>conftest.er1
15525   ac_status=$?
15526   grep -v '^ *+' conftest.er1 >conftest.err
15527   rm -f conftest.er1
15528   cat conftest.err >&5
15529   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15530   (exit $ac_status); } &&
15531          { ac_try='test -z "$ac_c_werror_flag"
15532                          || test ! -s conftest.err'
15533   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15534   (eval $ac_try) 2>&5
15535   ac_status=$?
15536   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15537   (exit $ac_status); }; } &&
15538          { ac_try='test -s conftest$ac_exeext'
15539   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15540   (eval $ac_try) 2>&5
15541   ac_status=$?
15542   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15543   (exit $ac_status); }; }; then
15544   ac_cv_lib_m_csinhf=yes
15545 else
15546   echo "$as_me: failed program was:" >&5
15547 sed 's/^/| /' conftest.$ac_ext >&5
15548
15549 ac_cv_lib_m_csinhf=no
15550 fi
15551 rm -f conftest.err conftest.$ac_objext \
15552       conftest$ac_exeext conftest.$ac_ext
15553 LIBS=$ac_check_lib_save_LIBS
15554 fi
15555 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinhf" >&5
15556 echo "${ECHO_T}$ac_cv_lib_m_csinhf" >&6
15557 if test $ac_cv_lib_m_csinhf = yes; then
15558
15559 cat >>confdefs.h <<\_ACEOF
15560 #define HAVE_CSINHF 1
15561 _ACEOF
15562
15563 fi
15564
15565 echo "$as_me:$LINENO: checking for csinh in -lm" >&5
15566 echo $ECHO_N "checking for csinh in -lm... $ECHO_C" >&6
15567 if test "${ac_cv_lib_m_csinh+set}" = set; then
15568   echo $ECHO_N "(cached) $ECHO_C" >&6
15569 else
15570   ac_check_lib_save_LIBS=$LIBS
15571 LIBS="-lm  $LIBS"
15572 if test x$gcc_no_link = xyes; then
15573   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15574 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15575    { (exit 1); exit 1; }; }
15576 fi
15577 cat >conftest.$ac_ext <<_ACEOF
15578 /* confdefs.h.  */
15579 _ACEOF
15580 cat confdefs.h >>conftest.$ac_ext
15581 cat >>conftest.$ac_ext <<_ACEOF
15582 /* end confdefs.h.  */
15583
15584 /* Override any gcc2 internal prototype to avoid an error.  */
15585 #ifdef __cplusplus
15586 extern "C"
15587 #endif
15588 /* We use char because int might match the return type of a gcc2
15589    builtin and then its argument prototype would still apply.  */
15590 char csinh ();
15591 int
15592 main ()
15593 {
15594 csinh ();
15595   ;
15596   return 0;
15597 }
15598 _ACEOF
15599 rm -f conftest.$ac_objext conftest$ac_exeext
15600 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15601   (eval $ac_link) 2>conftest.er1
15602   ac_status=$?
15603   grep -v '^ *+' conftest.er1 >conftest.err
15604   rm -f conftest.er1
15605   cat conftest.err >&5
15606   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15607   (exit $ac_status); } &&
15608          { ac_try='test -z "$ac_c_werror_flag"
15609                          || test ! -s conftest.err'
15610   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15611   (eval $ac_try) 2>&5
15612   ac_status=$?
15613   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15614   (exit $ac_status); }; } &&
15615          { ac_try='test -s conftest$ac_exeext'
15616   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15617   (eval $ac_try) 2>&5
15618   ac_status=$?
15619   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15620   (exit $ac_status); }; }; then
15621   ac_cv_lib_m_csinh=yes
15622 else
15623   echo "$as_me: failed program was:" >&5
15624 sed 's/^/| /' conftest.$ac_ext >&5
15625
15626 ac_cv_lib_m_csinh=no
15627 fi
15628 rm -f conftest.err conftest.$ac_objext \
15629       conftest$ac_exeext conftest.$ac_ext
15630 LIBS=$ac_check_lib_save_LIBS
15631 fi
15632 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinh" >&5
15633 echo "${ECHO_T}$ac_cv_lib_m_csinh" >&6
15634 if test $ac_cv_lib_m_csinh = yes; then
15635
15636 cat >>confdefs.h <<\_ACEOF
15637 #define HAVE_CSINH 1
15638 _ACEOF
15639
15640 fi
15641
15642 echo "$as_me:$LINENO: checking for csinhl in -lm" >&5
15643 echo $ECHO_N "checking for csinhl in -lm... $ECHO_C" >&6
15644 if test "${ac_cv_lib_m_csinhl+set}" = set; then
15645   echo $ECHO_N "(cached) $ECHO_C" >&6
15646 else
15647   ac_check_lib_save_LIBS=$LIBS
15648 LIBS="-lm  $LIBS"
15649 if test x$gcc_no_link = xyes; then
15650   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15651 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15652    { (exit 1); exit 1; }; }
15653 fi
15654 cat >conftest.$ac_ext <<_ACEOF
15655 /* confdefs.h.  */
15656 _ACEOF
15657 cat confdefs.h >>conftest.$ac_ext
15658 cat >>conftest.$ac_ext <<_ACEOF
15659 /* end confdefs.h.  */
15660
15661 /* Override any gcc2 internal prototype to avoid an error.  */
15662 #ifdef __cplusplus
15663 extern "C"
15664 #endif
15665 /* We use char because int might match the return type of a gcc2
15666    builtin and then its argument prototype would still apply.  */
15667 char csinhl ();
15668 int
15669 main ()
15670 {
15671 csinhl ();
15672   ;
15673   return 0;
15674 }
15675 _ACEOF
15676 rm -f conftest.$ac_objext conftest$ac_exeext
15677 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15678   (eval $ac_link) 2>conftest.er1
15679   ac_status=$?
15680   grep -v '^ *+' conftest.er1 >conftest.err
15681   rm -f conftest.er1
15682   cat conftest.err >&5
15683   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15684   (exit $ac_status); } &&
15685          { ac_try='test -z "$ac_c_werror_flag"
15686                          || test ! -s conftest.err'
15687   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15688   (eval $ac_try) 2>&5
15689   ac_status=$?
15690   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15691   (exit $ac_status); }; } &&
15692          { ac_try='test -s conftest$ac_exeext'
15693   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15694   (eval $ac_try) 2>&5
15695   ac_status=$?
15696   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15697   (exit $ac_status); }; }; then
15698   ac_cv_lib_m_csinhl=yes
15699 else
15700   echo "$as_me: failed program was:" >&5
15701 sed 's/^/| /' conftest.$ac_ext >&5
15702
15703 ac_cv_lib_m_csinhl=no
15704 fi
15705 rm -f conftest.err conftest.$ac_objext \
15706       conftest$ac_exeext conftest.$ac_ext
15707 LIBS=$ac_check_lib_save_LIBS
15708 fi
15709 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinhl" >&5
15710 echo "${ECHO_T}$ac_cv_lib_m_csinhl" >&6
15711 if test $ac_cv_lib_m_csinhl = yes; then
15712
15713 cat >>confdefs.h <<\_ACEOF
15714 #define HAVE_CSINHL 1
15715 _ACEOF
15716
15717 fi
15718
15719 echo "$as_me:$LINENO: checking for sqrtf in -lm" >&5
15720 echo $ECHO_N "checking for sqrtf in -lm... $ECHO_C" >&6
15721 if test "${ac_cv_lib_m_sqrtf+set}" = set; then
15722   echo $ECHO_N "(cached) $ECHO_C" >&6
15723 else
15724   ac_check_lib_save_LIBS=$LIBS
15725 LIBS="-lm  $LIBS"
15726 if test x$gcc_no_link = xyes; then
15727   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15728 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15729    { (exit 1); exit 1; }; }
15730 fi
15731 cat >conftest.$ac_ext <<_ACEOF
15732 /* confdefs.h.  */
15733 _ACEOF
15734 cat confdefs.h >>conftest.$ac_ext
15735 cat >>conftest.$ac_ext <<_ACEOF
15736 /* end confdefs.h.  */
15737
15738 /* Override any gcc2 internal prototype to avoid an error.  */
15739 #ifdef __cplusplus
15740 extern "C"
15741 #endif
15742 /* We use char because int might match the return type of a gcc2
15743    builtin and then its argument prototype would still apply.  */
15744 char sqrtf ();
15745 int
15746 main ()
15747 {
15748 sqrtf ();
15749   ;
15750   return 0;
15751 }
15752 _ACEOF
15753 rm -f conftest.$ac_objext conftest$ac_exeext
15754 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15755   (eval $ac_link) 2>conftest.er1
15756   ac_status=$?
15757   grep -v '^ *+' conftest.er1 >conftest.err
15758   rm -f conftest.er1
15759   cat conftest.err >&5
15760   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15761   (exit $ac_status); } &&
15762          { ac_try='test -z "$ac_c_werror_flag"
15763                          || test ! -s conftest.err'
15764   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15765   (eval $ac_try) 2>&5
15766   ac_status=$?
15767   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15768   (exit $ac_status); }; } &&
15769          { ac_try='test -s conftest$ac_exeext'
15770   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15771   (eval $ac_try) 2>&5
15772   ac_status=$?
15773   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15774   (exit $ac_status); }; }; then
15775   ac_cv_lib_m_sqrtf=yes
15776 else
15777   echo "$as_me: failed program was:" >&5
15778 sed 's/^/| /' conftest.$ac_ext >&5
15779
15780 ac_cv_lib_m_sqrtf=no
15781 fi
15782 rm -f conftest.err conftest.$ac_objext \
15783       conftest$ac_exeext conftest.$ac_ext
15784 LIBS=$ac_check_lib_save_LIBS
15785 fi
15786 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrtf" >&5
15787 echo "${ECHO_T}$ac_cv_lib_m_sqrtf" >&6
15788 if test $ac_cv_lib_m_sqrtf = yes; then
15789
15790 cat >>confdefs.h <<\_ACEOF
15791 #define HAVE_SQRTF 1
15792 _ACEOF
15793
15794 fi
15795
15796 echo "$as_me:$LINENO: checking for sqrt in -lm" >&5
15797 echo $ECHO_N "checking for sqrt in -lm... $ECHO_C" >&6
15798 if test "${ac_cv_lib_m_sqrt+set}" = set; then
15799   echo $ECHO_N "(cached) $ECHO_C" >&6
15800 else
15801   ac_check_lib_save_LIBS=$LIBS
15802 LIBS="-lm  $LIBS"
15803 if test x$gcc_no_link = xyes; then
15804   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15805 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15806    { (exit 1); exit 1; }; }
15807 fi
15808 cat >conftest.$ac_ext <<_ACEOF
15809 /* confdefs.h.  */
15810 _ACEOF
15811 cat confdefs.h >>conftest.$ac_ext
15812 cat >>conftest.$ac_ext <<_ACEOF
15813 /* end confdefs.h.  */
15814
15815 /* Override any gcc2 internal prototype to avoid an error.  */
15816 #ifdef __cplusplus
15817 extern "C"
15818 #endif
15819 /* We use char because int might match the return type of a gcc2
15820    builtin and then its argument prototype would still apply.  */
15821 char sqrt ();
15822 int
15823 main ()
15824 {
15825 sqrt ();
15826   ;
15827   return 0;
15828 }
15829 _ACEOF
15830 rm -f conftest.$ac_objext conftest$ac_exeext
15831 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15832   (eval $ac_link) 2>conftest.er1
15833   ac_status=$?
15834   grep -v '^ *+' conftest.er1 >conftest.err
15835   rm -f conftest.er1
15836   cat conftest.err >&5
15837   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15838   (exit $ac_status); } &&
15839          { ac_try='test -z "$ac_c_werror_flag"
15840                          || test ! -s conftest.err'
15841   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15842   (eval $ac_try) 2>&5
15843   ac_status=$?
15844   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15845   (exit $ac_status); }; } &&
15846          { ac_try='test -s conftest$ac_exeext'
15847   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15848   (eval $ac_try) 2>&5
15849   ac_status=$?
15850   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15851   (exit $ac_status); }; }; then
15852   ac_cv_lib_m_sqrt=yes
15853 else
15854   echo "$as_me: failed program was:" >&5
15855 sed 's/^/| /' conftest.$ac_ext >&5
15856
15857 ac_cv_lib_m_sqrt=no
15858 fi
15859 rm -f conftest.err conftest.$ac_objext \
15860       conftest$ac_exeext conftest.$ac_ext
15861 LIBS=$ac_check_lib_save_LIBS
15862 fi
15863 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrt" >&5
15864 echo "${ECHO_T}$ac_cv_lib_m_sqrt" >&6
15865 if test $ac_cv_lib_m_sqrt = yes; then
15866
15867 cat >>confdefs.h <<\_ACEOF
15868 #define HAVE_SQRT 1
15869 _ACEOF
15870
15871 fi
15872
15873 echo "$as_me:$LINENO: checking for sqrtl in -lm" >&5
15874 echo $ECHO_N "checking for sqrtl in -lm... $ECHO_C" >&6
15875 if test "${ac_cv_lib_m_sqrtl+set}" = set; then
15876   echo $ECHO_N "(cached) $ECHO_C" >&6
15877 else
15878   ac_check_lib_save_LIBS=$LIBS
15879 LIBS="-lm  $LIBS"
15880 if test x$gcc_no_link = xyes; then
15881   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15882 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15883    { (exit 1); exit 1; }; }
15884 fi
15885 cat >conftest.$ac_ext <<_ACEOF
15886 /* confdefs.h.  */
15887 _ACEOF
15888 cat confdefs.h >>conftest.$ac_ext
15889 cat >>conftest.$ac_ext <<_ACEOF
15890 /* end confdefs.h.  */
15891
15892 /* Override any gcc2 internal prototype to avoid an error.  */
15893 #ifdef __cplusplus
15894 extern "C"
15895 #endif
15896 /* We use char because int might match the return type of a gcc2
15897    builtin and then its argument prototype would still apply.  */
15898 char sqrtl ();
15899 int
15900 main ()
15901 {
15902 sqrtl ();
15903   ;
15904   return 0;
15905 }
15906 _ACEOF
15907 rm -f conftest.$ac_objext conftest$ac_exeext
15908 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15909   (eval $ac_link) 2>conftest.er1
15910   ac_status=$?
15911   grep -v '^ *+' conftest.er1 >conftest.err
15912   rm -f conftest.er1
15913   cat conftest.err >&5
15914   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15915   (exit $ac_status); } &&
15916          { ac_try='test -z "$ac_c_werror_flag"
15917                          || test ! -s conftest.err'
15918   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15919   (eval $ac_try) 2>&5
15920   ac_status=$?
15921   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15922   (exit $ac_status); }; } &&
15923          { ac_try='test -s conftest$ac_exeext'
15924   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15925   (eval $ac_try) 2>&5
15926   ac_status=$?
15927   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15928   (exit $ac_status); }; }; then
15929   ac_cv_lib_m_sqrtl=yes
15930 else
15931   echo "$as_me: failed program was:" >&5
15932 sed 's/^/| /' conftest.$ac_ext >&5
15933
15934 ac_cv_lib_m_sqrtl=no
15935 fi
15936 rm -f conftest.err conftest.$ac_objext \
15937       conftest$ac_exeext conftest.$ac_ext
15938 LIBS=$ac_check_lib_save_LIBS
15939 fi
15940 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrtl" >&5
15941 echo "${ECHO_T}$ac_cv_lib_m_sqrtl" >&6
15942 if test $ac_cv_lib_m_sqrtl = yes; then
15943
15944 cat >>confdefs.h <<\_ACEOF
15945 #define HAVE_SQRTL 1
15946 _ACEOF
15947
15948 fi
15949
15950 echo "$as_me:$LINENO: checking for csqrtf in -lm" >&5
15951 echo $ECHO_N "checking for csqrtf in -lm... $ECHO_C" >&6
15952 if test "${ac_cv_lib_m_csqrtf+set}" = set; then
15953   echo $ECHO_N "(cached) $ECHO_C" >&6
15954 else
15955   ac_check_lib_save_LIBS=$LIBS
15956 LIBS="-lm  $LIBS"
15957 if test x$gcc_no_link = xyes; then
15958   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15959 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15960    { (exit 1); exit 1; }; }
15961 fi
15962 cat >conftest.$ac_ext <<_ACEOF
15963 /* confdefs.h.  */
15964 _ACEOF
15965 cat confdefs.h >>conftest.$ac_ext
15966 cat >>conftest.$ac_ext <<_ACEOF
15967 /* end confdefs.h.  */
15968
15969 /* Override any gcc2 internal prototype to avoid an error.  */
15970 #ifdef __cplusplus
15971 extern "C"
15972 #endif
15973 /* We use char because int might match the return type of a gcc2
15974    builtin and then its argument prototype would still apply.  */
15975 char csqrtf ();
15976 int
15977 main ()
15978 {
15979 csqrtf ();
15980   ;
15981   return 0;
15982 }
15983 _ACEOF
15984 rm -f conftest.$ac_objext conftest$ac_exeext
15985 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15986   (eval $ac_link) 2>conftest.er1
15987   ac_status=$?
15988   grep -v '^ *+' conftest.er1 >conftest.err
15989   rm -f conftest.er1
15990   cat conftest.err >&5
15991   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15992   (exit $ac_status); } &&
15993          { ac_try='test -z "$ac_c_werror_flag"
15994                          || test ! -s conftest.err'
15995   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15996   (eval $ac_try) 2>&5
15997   ac_status=$?
15998   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15999   (exit $ac_status); }; } &&
16000          { ac_try='test -s conftest$ac_exeext'
16001   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16002   (eval $ac_try) 2>&5
16003   ac_status=$?
16004   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16005   (exit $ac_status); }; }; then
16006   ac_cv_lib_m_csqrtf=yes
16007 else
16008   echo "$as_me: failed program was:" >&5
16009 sed 's/^/| /' conftest.$ac_ext >&5
16010
16011 ac_cv_lib_m_csqrtf=no
16012 fi
16013 rm -f conftest.err conftest.$ac_objext \
16014       conftest$ac_exeext conftest.$ac_ext
16015 LIBS=$ac_check_lib_save_LIBS
16016 fi
16017 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrtf" >&5
16018 echo "${ECHO_T}$ac_cv_lib_m_csqrtf" >&6
16019 if test $ac_cv_lib_m_csqrtf = yes; then
16020
16021 cat >>confdefs.h <<\_ACEOF
16022 #define HAVE_CSQRTF 1
16023 _ACEOF
16024
16025 fi
16026
16027 echo "$as_me:$LINENO: checking for csqrt in -lm" >&5
16028 echo $ECHO_N "checking for csqrt in -lm... $ECHO_C" >&6
16029 if test "${ac_cv_lib_m_csqrt+set}" = set; then
16030   echo $ECHO_N "(cached) $ECHO_C" >&6
16031 else
16032   ac_check_lib_save_LIBS=$LIBS
16033 LIBS="-lm  $LIBS"
16034 if test x$gcc_no_link = xyes; then
16035   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16036 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16037    { (exit 1); exit 1; }; }
16038 fi
16039 cat >conftest.$ac_ext <<_ACEOF
16040 /* confdefs.h.  */
16041 _ACEOF
16042 cat confdefs.h >>conftest.$ac_ext
16043 cat >>conftest.$ac_ext <<_ACEOF
16044 /* end confdefs.h.  */
16045
16046 /* Override any gcc2 internal prototype to avoid an error.  */
16047 #ifdef __cplusplus
16048 extern "C"
16049 #endif
16050 /* We use char because int might match the return type of a gcc2
16051    builtin and then its argument prototype would still apply.  */
16052 char csqrt ();
16053 int
16054 main ()
16055 {
16056 csqrt ();
16057   ;
16058   return 0;
16059 }
16060 _ACEOF
16061 rm -f conftest.$ac_objext conftest$ac_exeext
16062 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16063   (eval $ac_link) 2>conftest.er1
16064   ac_status=$?
16065   grep -v '^ *+' conftest.er1 >conftest.err
16066   rm -f conftest.er1
16067   cat conftest.err >&5
16068   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16069   (exit $ac_status); } &&
16070          { ac_try='test -z "$ac_c_werror_flag"
16071                          || test ! -s conftest.err'
16072   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16073   (eval $ac_try) 2>&5
16074   ac_status=$?
16075   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16076   (exit $ac_status); }; } &&
16077          { ac_try='test -s conftest$ac_exeext'
16078   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16079   (eval $ac_try) 2>&5
16080   ac_status=$?
16081   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16082   (exit $ac_status); }; }; then
16083   ac_cv_lib_m_csqrt=yes
16084 else
16085   echo "$as_me: failed program was:" >&5
16086 sed 's/^/| /' conftest.$ac_ext >&5
16087
16088 ac_cv_lib_m_csqrt=no
16089 fi
16090 rm -f conftest.err conftest.$ac_objext \
16091       conftest$ac_exeext conftest.$ac_ext
16092 LIBS=$ac_check_lib_save_LIBS
16093 fi
16094 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrt" >&5
16095 echo "${ECHO_T}$ac_cv_lib_m_csqrt" >&6
16096 if test $ac_cv_lib_m_csqrt = yes; then
16097
16098 cat >>confdefs.h <<\_ACEOF
16099 #define HAVE_CSQRT 1
16100 _ACEOF
16101
16102 fi
16103
16104 echo "$as_me:$LINENO: checking for csqrtl in -lm" >&5
16105 echo $ECHO_N "checking for csqrtl in -lm... $ECHO_C" >&6
16106 if test "${ac_cv_lib_m_csqrtl+set}" = set; then
16107   echo $ECHO_N "(cached) $ECHO_C" >&6
16108 else
16109   ac_check_lib_save_LIBS=$LIBS
16110 LIBS="-lm  $LIBS"
16111 if test x$gcc_no_link = xyes; then
16112   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16113 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16114    { (exit 1); exit 1; }; }
16115 fi
16116 cat >conftest.$ac_ext <<_ACEOF
16117 /* confdefs.h.  */
16118 _ACEOF
16119 cat confdefs.h >>conftest.$ac_ext
16120 cat >>conftest.$ac_ext <<_ACEOF
16121 /* end confdefs.h.  */
16122
16123 /* Override any gcc2 internal prototype to avoid an error.  */
16124 #ifdef __cplusplus
16125 extern "C"
16126 #endif
16127 /* We use char because int might match the return type of a gcc2
16128    builtin and then its argument prototype would still apply.  */
16129 char csqrtl ();
16130 int
16131 main ()
16132 {
16133 csqrtl ();
16134   ;
16135   return 0;
16136 }
16137 _ACEOF
16138 rm -f conftest.$ac_objext conftest$ac_exeext
16139 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16140   (eval $ac_link) 2>conftest.er1
16141   ac_status=$?
16142   grep -v '^ *+' conftest.er1 >conftest.err
16143   rm -f conftest.er1
16144   cat conftest.err >&5
16145   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16146   (exit $ac_status); } &&
16147          { ac_try='test -z "$ac_c_werror_flag"
16148                          || test ! -s conftest.err'
16149   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16150   (eval $ac_try) 2>&5
16151   ac_status=$?
16152   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16153   (exit $ac_status); }; } &&
16154          { ac_try='test -s conftest$ac_exeext'
16155   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16156   (eval $ac_try) 2>&5
16157   ac_status=$?
16158   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16159   (exit $ac_status); }; }; then
16160   ac_cv_lib_m_csqrtl=yes
16161 else
16162   echo "$as_me: failed program was:" >&5
16163 sed 's/^/| /' conftest.$ac_ext >&5
16164
16165 ac_cv_lib_m_csqrtl=no
16166 fi
16167 rm -f conftest.err conftest.$ac_objext \
16168       conftest$ac_exeext conftest.$ac_ext
16169 LIBS=$ac_check_lib_save_LIBS
16170 fi
16171 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrtl" >&5
16172 echo "${ECHO_T}$ac_cv_lib_m_csqrtl" >&6
16173 if test $ac_cv_lib_m_csqrtl = yes; then
16174
16175 cat >>confdefs.h <<\_ACEOF
16176 #define HAVE_CSQRTL 1
16177 _ACEOF
16178
16179 fi
16180
16181 echo "$as_me:$LINENO: checking for tanf in -lm" >&5
16182 echo $ECHO_N "checking for tanf in -lm... $ECHO_C" >&6
16183 if test "${ac_cv_lib_m_tanf+set}" = set; then
16184   echo $ECHO_N "(cached) $ECHO_C" >&6
16185 else
16186   ac_check_lib_save_LIBS=$LIBS
16187 LIBS="-lm  $LIBS"
16188 if test x$gcc_no_link = xyes; then
16189   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16190 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16191    { (exit 1); exit 1; }; }
16192 fi
16193 cat >conftest.$ac_ext <<_ACEOF
16194 /* confdefs.h.  */
16195 _ACEOF
16196 cat confdefs.h >>conftest.$ac_ext
16197 cat >>conftest.$ac_ext <<_ACEOF
16198 /* end confdefs.h.  */
16199
16200 /* Override any gcc2 internal prototype to avoid an error.  */
16201 #ifdef __cplusplus
16202 extern "C"
16203 #endif
16204 /* We use char because int might match the return type of a gcc2
16205    builtin and then its argument prototype would still apply.  */
16206 char tanf ();
16207 int
16208 main ()
16209 {
16210 tanf ();
16211   ;
16212   return 0;
16213 }
16214 _ACEOF
16215 rm -f conftest.$ac_objext conftest$ac_exeext
16216 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16217   (eval $ac_link) 2>conftest.er1
16218   ac_status=$?
16219   grep -v '^ *+' conftest.er1 >conftest.err
16220   rm -f conftest.er1
16221   cat conftest.err >&5
16222   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16223   (exit $ac_status); } &&
16224          { ac_try='test -z "$ac_c_werror_flag"
16225                          || test ! -s conftest.err'
16226   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16227   (eval $ac_try) 2>&5
16228   ac_status=$?
16229   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16230   (exit $ac_status); }; } &&
16231          { ac_try='test -s conftest$ac_exeext'
16232   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16233   (eval $ac_try) 2>&5
16234   ac_status=$?
16235   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16236   (exit $ac_status); }; }; then
16237   ac_cv_lib_m_tanf=yes
16238 else
16239   echo "$as_me: failed program was:" >&5
16240 sed 's/^/| /' conftest.$ac_ext >&5
16241
16242 ac_cv_lib_m_tanf=no
16243 fi
16244 rm -f conftest.err conftest.$ac_objext \
16245       conftest$ac_exeext conftest.$ac_ext
16246 LIBS=$ac_check_lib_save_LIBS
16247 fi
16248 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanf" >&5
16249 echo "${ECHO_T}$ac_cv_lib_m_tanf" >&6
16250 if test $ac_cv_lib_m_tanf = yes; then
16251
16252 cat >>confdefs.h <<\_ACEOF
16253 #define HAVE_TANF 1
16254 _ACEOF
16255
16256 fi
16257
16258 echo "$as_me:$LINENO: checking for tan in -lm" >&5
16259 echo $ECHO_N "checking for tan in -lm... $ECHO_C" >&6
16260 if test "${ac_cv_lib_m_tan+set}" = set; then
16261   echo $ECHO_N "(cached) $ECHO_C" >&6
16262 else
16263   ac_check_lib_save_LIBS=$LIBS
16264 LIBS="-lm  $LIBS"
16265 if test x$gcc_no_link = xyes; then
16266   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16267 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16268    { (exit 1); exit 1; }; }
16269 fi
16270 cat >conftest.$ac_ext <<_ACEOF
16271 /* confdefs.h.  */
16272 _ACEOF
16273 cat confdefs.h >>conftest.$ac_ext
16274 cat >>conftest.$ac_ext <<_ACEOF
16275 /* end confdefs.h.  */
16276
16277 /* Override any gcc2 internal prototype to avoid an error.  */
16278 #ifdef __cplusplus
16279 extern "C"
16280 #endif
16281 /* We use char because int might match the return type of a gcc2
16282    builtin and then its argument prototype would still apply.  */
16283 char tan ();
16284 int
16285 main ()
16286 {
16287 tan ();
16288   ;
16289   return 0;
16290 }
16291 _ACEOF
16292 rm -f conftest.$ac_objext conftest$ac_exeext
16293 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16294   (eval $ac_link) 2>conftest.er1
16295   ac_status=$?
16296   grep -v '^ *+' conftest.er1 >conftest.err
16297   rm -f conftest.er1
16298   cat conftest.err >&5
16299   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16300   (exit $ac_status); } &&
16301          { ac_try='test -z "$ac_c_werror_flag"
16302                          || test ! -s conftest.err'
16303   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16304   (eval $ac_try) 2>&5
16305   ac_status=$?
16306   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16307   (exit $ac_status); }; } &&
16308          { ac_try='test -s conftest$ac_exeext'
16309   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16310   (eval $ac_try) 2>&5
16311   ac_status=$?
16312   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16313   (exit $ac_status); }; }; then
16314   ac_cv_lib_m_tan=yes
16315 else
16316   echo "$as_me: failed program was:" >&5
16317 sed 's/^/| /' conftest.$ac_ext >&5
16318
16319 ac_cv_lib_m_tan=no
16320 fi
16321 rm -f conftest.err conftest.$ac_objext \
16322       conftest$ac_exeext conftest.$ac_ext
16323 LIBS=$ac_check_lib_save_LIBS
16324 fi
16325 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tan" >&5
16326 echo "${ECHO_T}$ac_cv_lib_m_tan" >&6
16327 if test $ac_cv_lib_m_tan = yes; then
16328
16329 cat >>confdefs.h <<\_ACEOF
16330 #define HAVE_TAN 1
16331 _ACEOF
16332
16333 fi
16334
16335 echo "$as_me:$LINENO: checking for tanl in -lm" >&5
16336 echo $ECHO_N "checking for tanl in -lm... $ECHO_C" >&6
16337 if test "${ac_cv_lib_m_tanl+set}" = set; then
16338   echo $ECHO_N "(cached) $ECHO_C" >&6
16339 else
16340   ac_check_lib_save_LIBS=$LIBS
16341 LIBS="-lm  $LIBS"
16342 if test x$gcc_no_link = xyes; then
16343   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16344 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16345    { (exit 1); exit 1; }; }
16346 fi
16347 cat >conftest.$ac_ext <<_ACEOF
16348 /* confdefs.h.  */
16349 _ACEOF
16350 cat confdefs.h >>conftest.$ac_ext
16351 cat >>conftest.$ac_ext <<_ACEOF
16352 /* end confdefs.h.  */
16353
16354 /* Override any gcc2 internal prototype to avoid an error.  */
16355 #ifdef __cplusplus
16356 extern "C"
16357 #endif
16358 /* We use char because int might match the return type of a gcc2
16359    builtin and then its argument prototype would still apply.  */
16360 char tanl ();
16361 int
16362 main ()
16363 {
16364 tanl ();
16365   ;
16366   return 0;
16367 }
16368 _ACEOF
16369 rm -f conftest.$ac_objext conftest$ac_exeext
16370 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16371   (eval $ac_link) 2>conftest.er1
16372   ac_status=$?
16373   grep -v '^ *+' conftest.er1 >conftest.err
16374   rm -f conftest.er1
16375   cat conftest.err >&5
16376   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16377   (exit $ac_status); } &&
16378          { ac_try='test -z "$ac_c_werror_flag"
16379                          || test ! -s conftest.err'
16380   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16381   (eval $ac_try) 2>&5
16382   ac_status=$?
16383   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16384   (exit $ac_status); }; } &&
16385          { ac_try='test -s conftest$ac_exeext'
16386   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16387   (eval $ac_try) 2>&5
16388   ac_status=$?
16389   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16390   (exit $ac_status); }; }; then
16391   ac_cv_lib_m_tanl=yes
16392 else
16393   echo "$as_me: failed program was:" >&5
16394 sed 's/^/| /' conftest.$ac_ext >&5
16395
16396 ac_cv_lib_m_tanl=no
16397 fi
16398 rm -f conftest.err conftest.$ac_objext \
16399       conftest$ac_exeext conftest.$ac_ext
16400 LIBS=$ac_check_lib_save_LIBS
16401 fi
16402 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanl" >&5
16403 echo "${ECHO_T}$ac_cv_lib_m_tanl" >&6
16404 if test $ac_cv_lib_m_tanl = yes; then
16405
16406 cat >>confdefs.h <<\_ACEOF
16407 #define HAVE_TANL 1
16408 _ACEOF
16409
16410 fi
16411
16412 echo "$as_me:$LINENO: checking for ctanf in -lm" >&5
16413 echo $ECHO_N "checking for ctanf in -lm... $ECHO_C" >&6
16414 if test "${ac_cv_lib_m_ctanf+set}" = set; then
16415   echo $ECHO_N "(cached) $ECHO_C" >&6
16416 else
16417   ac_check_lib_save_LIBS=$LIBS
16418 LIBS="-lm  $LIBS"
16419 if test x$gcc_no_link = xyes; then
16420   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16421 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16422    { (exit 1); exit 1; }; }
16423 fi
16424 cat >conftest.$ac_ext <<_ACEOF
16425 /* confdefs.h.  */
16426 _ACEOF
16427 cat confdefs.h >>conftest.$ac_ext
16428 cat >>conftest.$ac_ext <<_ACEOF
16429 /* end confdefs.h.  */
16430
16431 /* Override any gcc2 internal prototype to avoid an error.  */
16432 #ifdef __cplusplus
16433 extern "C"
16434 #endif
16435 /* We use char because int might match the return type of a gcc2
16436    builtin and then its argument prototype would still apply.  */
16437 char ctanf ();
16438 int
16439 main ()
16440 {
16441 ctanf ();
16442   ;
16443   return 0;
16444 }
16445 _ACEOF
16446 rm -f conftest.$ac_objext conftest$ac_exeext
16447 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16448   (eval $ac_link) 2>conftest.er1
16449   ac_status=$?
16450   grep -v '^ *+' conftest.er1 >conftest.err
16451   rm -f conftest.er1
16452   cat conftest.err >&5
16453   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16454   (exit $ac_status); } &&
16455          { ac_try='test -z "$ac_c_werror_flag"
16456                          || test ! -s conftest.err'
16457   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16458   (eval $ac_try) 2>&5
16459   ac_status=$?
16460   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16461   (exit $ac_status); }; } &&
16462          { ac_try='test -s conftest$ac_exeext'
16463   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16464   (eval $ac_try) 2>&5
16465   ac_status=$?
16466   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16467   (exit $ac_status); }; }; then
16468   ac_cv_lib_m_ctanf=yes
16469 else
16470   echo "$as_me: failed program was:" >&5
16471 sed 's/^/| /' conftest.$ac_ext >&5
16472
16473 ac_cv_lib_m_ctanf=no
16474 fi
16475 rm -f conftest.err conftest.$ac_objext \
16476       conftest$ac_exeext conftest.$ac_ext
16477 LIBS=$ac_check_lib_save_LIBS
16478 fi
16479 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanf" >&5
16480 echo "${ECHO_T}$ac_cv_lib_m_ctanf" >&6
16481 if test $ac_cv_lib_m_ctanf = yes; then
16482
16483 cat >>confdefs.h <<\_ACEOF
16484 #define HAVE_CTANF 1
16485 _ACEOF
16486
16487 fi
16488
16489 echo "$as_me:$LINENO: checking for ctan in -lm" >&5
16490 echo $ECHO_N "checking for ctan in -lm... $ECHO_C" >&6
16491 if test "${ac_cv_lib_m_ctan+set}" = set; then
16492   echo $ECHO_N "(cached) $ECHO_C" >&6
16493 else
16494   ac_check_lib_save_LIBS=$LIBS
16495 LIBS="-lm  $LIBS"
16496 if test x$gcc_no_link = xyes; then
16497   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16498 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16499    { (exit 1); exit 1; }; }
16500 fi
16501 cat >conftest.$ac_ext <<_ACEOF
16502 /* confdefs.h.  */
16503 _ACEOF
16504 cat confdefs.h >>conftest.$ac_ext
16505 cat >>conftest.$ac_ext <<_ACEOF
16506 /* end confdefs.h.  */
16507
16508 /* Override any gcc2 internal prototype to avoid an error.  */
16509 #ifdef __cplusplus
16510 extern "C"
16511 #endif
16512 /* We use char because int might match the return type of a gcc2
16513    builtin and then its argument prototype would still apply.  */
16514 char ctan ();
16515 int
16516 main ()
16517 {
16518 ctan ();
16519   ;
16520   return 0;
16521 }
16522 _ACEOF
16523 rm -f conftest.$ac_objext conftest$ac_exeext
16524 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16525   (eval $ac_link) 2>conftest.er1
16526   ac_status=$?
16527   grep -v '^ *+' conftest.er1 >conftest.err
16528   rm -f conftest.er1
16529   cat conftest.err >&5
16530   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16531   (exit $ac_status); } &&
16532          { ac_try='test -z "$ac_c_werror_flag"
16533                          || test ! -s conftest.err'
16534   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16535   (eval $ac_try) 2>&5
16536   ac_status=$?
16537   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16538   (exit $ac_status); }; } &&
16539          { ac_try='test -s conftest$ac_exeext'
16540   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16541   (eval $ac_try) 2>&5
16542   ac_status=$?
16543   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16544   (exit $ac_status); }; }; then
16545   ac_cv_lib_m_ctan=yes
16546 else
16547   echo "$as_me: failed program was:" >&5
16548 sed 's/^/| /' conftest.$ac_ext >&5
16549
16550 ac_cv_lib_m_ctan=no
16551 fi
16552 rm -f conftest.err conftest.$ac_objext \
16553       conftest$ac_exeext conftest.$ac_ext
16554 LIBS=$ac_check_lib_save_LIBS
16555 fi
16556 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctan" >&5
16557 echo "${ECHO_T}$ac_cv_lib_m_ctan" >&6
16558 if test $ac_cv_lib_m_ctan = yes; then
16559
16560 cat >>confdefs.h <<\_ACEOF
16561 #define HAVE_CTAN 1
16562 _ACEOF
16563
16564 fi
16565
16566 echo "$as_me:$LINENO: checking for ctanl in -lm" >&5
16567 echo $ECHO_N "checking for ctanl in -lm... $ECHO_C" >&6
16568 if test "${ac_cv_lib_m_ctanl+set}" = set; then
16569   echo $ECHO_N "(cached) $ECHO_C" >&6
16570 else
16571   ac_check_lib_save_LIBS=$LIBS
16572 LIBS="-lm  $LIBS"
16573 if test x$gcc_no_link = xyes; then
16574   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16575 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16576    { (exit 1); exit 1; }; }
16577 fi
16578 cat >conftest.$ac_ext <<_ACEOF
16579 /* confdefs.h.  */
16580 _ACEOF
16581 cat confdefs.h >>conftest.$ac_ext
16582 cat >>conftest.$ac_ext <<_ACEOF
16583 /* end confdefs.h.  */
16584
16585 /* Override any gcc2 internal prototype to avoid an error.  */
16586 #ifdef __cplusplus
16587 extern "C"
16588 #endif
16589 /* We use char because int might match the return type of a gcc2
16590    builtin and then its argument prototype would still apply.  */
16591 char ctanl ();
16592 int
16593 main ()
16594 {
16595 ctanl ();
16596   ;
16597   return 0;
16598 }
16599 _ACEOF
16600 rm -f conftest.$ac_objext conftest$ac_exeext
16601 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16602   (eval $ac_link) 2>conftest.er1
16603   ac_status=$?
16604   grep -v '^ *+' conftest.er1 >conftest.err
16605   rm -f conftest.er1
16606   cat conftest.err >&5
16607   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16608   (exit $ac_status); } &&
16609          { ac_try='test -z "$ac_c_werror_flag"
16610                          || test ! -s conftest.err'
16611   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16612   (eval $ac_try) 2>&5
16613   ac_status=$?
16614   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16615   (exit $ac_status); }; } &&
16616          { ac_try='test -s conftest$ac_exeext'
16617   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16618   (eval $ac_try) 2>&5
16619   ac_status=$?
16620   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16621   (exit $ac_status); }; }; then
16622   ac_cv_lib_m_ctanl=yes
16623 else
16624   echo "$as_me: failed program was:" >&5
16625 sed 's/^/| /' conftest.$ac_ext >&5
16626
16627 ac_cv_lib_m_ctanl=no
16628 fi
16629 rm -f conftest.err conftest.$ac_objext \
16630       conftest$ac_exeext conftest.$ac_ext
16631 LIBS=$ac_check_lib_save_LIBS
16632 fi
16633 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanl" >&5
16634 echo "${ECHO_T}$ac_cv_lib_m_ctanl" >&6
16635 if test $ac_cv_lib_m_ctanl = yes; then
16636
16637 cat >>confdefs.h <<\_ACEOF
16638 #define HAVE_CTANL 1
16639 _ACEOF
16640
16641 fi
16642
16643 echo "$as_me:$LINENO: checking for tanhf in -lm" >&5
16644 echo $ECHO_N "checking for tanhf in -lm... $ECHO_C" >&6
16645 if test "${ac_cv_lib_m_tanhf+set}" = set; then
16646   echo $ECHO_N "(cached) $ECHO_C" >&6
16647 else
16648   ac_check_lib_save_LIBS=$LIBS
16649 LIBS="-lm  $LIBS"
16650 if test x$gcc_no_link = xyes; then
16651   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16652 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16653    { (exit 1); exit 1; }; }
16654 fi
16655 cat >conftest.$ac_ext <<_ACEOF
16656 /* confdefs.h.  */
16657 _ACEOF
16658 cat confdefs.h >>conftest.$ac_ext
16659 cat >>conftest.$ac_ext <<_ACEOF
16660 /* end confdefs.h.  */
16661
16662 /* Override any gcc2 internal prototype to avoid an error.  */
16663 #ifdef __cplusplus
16664 extern "C"
16665 #endif
16666 /* We use char because int might match the return type of a gcc2
16667    builtin and then its argument prototype would still apply.  */
16668 char tanhf ();
16669 int
16670 main ()
16671 {
16672 tanhf ();
16673   ;
16674   return 0;
16675 }
16676 _ACEOF
16677 rm -f conftest.$ac_objext conftest$ac_exeext
16678 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16679   (eval $ac_link) 2>conftest.er1
16680   ac_status=$?
16681   grep -v '^ *+' conftest.er1 >conftest.err
16682   rm -f conftest.er1
16683   cat conftest.err >&5
16684   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16685   (exit $ac_status); } &&
16686          { ac_try='test -z "$ac_c_werror_flag"
16687                          || test ! -s conftest.err'
16688   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16689   (eval $ac_try) 2>&5
16690   ac_status=$?
16691   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16692   (exit $ac_status); }; } &&
16693          { ac_try='test -s conftest$ac_exeext'
16694   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16695   (eval $ac_try) 2>&5
16696   ac_status=$?
16697   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16698   (exit $ac_status); }; }; then
16699   ac_cv_lib_m_tanhf=yes
16700 else
16701   echo "$as_me: failed program was:" >&5
16702 sed 's/^/| /' conftest.$ac_ext >&5
16703
16704 ac_cv_lib_m_tanhf=no
16705 fi
16706 rm -f conftest.err conftest.$ac_objext \
16707       conftest$ac_exeext conftest.$ac_ext
16708 LIBS=$ac_check_lib_save_LIBS
16709 fi
16710 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanhf" >&5
16711 echo "${ECHO_T}$ac_cv_lib_m_tanhf" >&6
16712 if test $ac_cv_lib_m_tanhf = yes; then
16713
16714 cat >>confdefs.h <<\_ACEOF
16715 #define HAVE_TANHF 1
16716 _ACEOF
16717
16718 fi
16719
16720 echo "$as_me:$LINENO: checking for tanh in -lm" >&5
16721 echo $ECHO_N "checking for tanh in -lm... $ECHO_C" >&6
16722 if test "${ac_cv_lib_m_tanh+set}" = set; then
16723   echo $ECHO_N "(cached) $ECHO_C" >&6
16724 else
16725   ac_check_lib_save_LIBS=$LIBS
16726 LIBS="-lm  $LIBS"
16727 if test x$gcc_no_link = xyes; then
16728   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16729 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16730    { (exit 1); exit 1; }; }
16731 fi
16732 cat >conftest.$ac_ext <<_ACEOF
16733 /* confdefs.h.  */
16734 _ACEOF
16735 cat confdefs.h >>conftest.$ac_ext
16736 cat >>conftest.$ac_ext <<_ACEOF
16737 /* end confdefs.h.  */
16738
16739 /* Override any gcc2 internal prototype to avoid an error.  */
16740 #ifdef __cplusplus
16741 extern "C"
16742 #endif
16743 /* We use char because int might match the return type of a gcc2
16744    builtin and then its argument prototype would still apply.  */
16745 char tanh ();
16746 int
16747 main ()
16748 {
16749 tanh ();
16750   ;
16751   return 0;
16752 }
16753 _ACEOF
16754 rm -f conftest.$ac_objext conftest$ac_exeext
16755 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16756   (eval $ac_link) 2>conftest.er1
16757   ac_status=$?
16758   grep -v '^ *+' conftest.er1 >conftest.err
16759   rm -f conftest.er1
16760   cat conftest.err >&5
16761   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16762   (exit $ac_status); } &&
16763          { ac_try='test -z "$ac_c_werror_flag"
16764                          || test ! -s conftest.err'
16765   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16766   (eval $ac_try) 2>&5
16767   ac_status=$?
16768   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16769   (exit $ac_status); }; } &&
16770          { ac_try='test -s conftest$ac_exeext'
16771   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16772   (eval $ac_try) 2>&5
16773   ac_status=$?
16774   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16775   (exit $ac_status); }; }; then
16776   ac_cv_lib_m_tanh=yes
16777 else
16778   echo "$as_me: failed program was:" >&5
16779 sed 's/^/| /' conftest.$ac_ext >&5
16780
16781 ac_cv_lib_m_tanh=no
16782 fi
16783 rm -f conftest.err conftest.$ac_objext \
16784       conftest$ac_exeext conftest.$ac_ext
16785 LIBS=$ac_check_lib_save_LIBS
16786 fi
16787 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanh" >&5
16788 echo "${ECHO_T}$ac_cv_lib_m_tanh" >&6
16789 if test $ac_cv_lib_m_tanh = yes; then
16790
16791 cat >>confdefs.h <<\_ACEOF
16792 #define HAVE_TANH 1
16793 _ACEOF
16794
16795 fi
16796
16797 echo "$as_me:$LINENO: checking for tanhl in -lm" >&5
16798 echo $ECHO_N "checking for tanhl in -lm... $ECHO_C" >&6
16799 if test "${ac_cv_lib_m_tanhl+set}" = set; then
16800   echo $ECHO_N "(cached) $ECHO_C" >&6
16801 else
16802   ac_check_lib_save_LIBS=$LIBS
16803 LIBS="-lm  $LIBS"
16804 if test x$gcc_no_link = xyes; then
16805   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16806 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16807    { (exit 1); exit 1; }; }
16808 fi
16809 cat >conftest.$ac_ext <<_ACEOF
16810 /* confdefs.h.  */
16811 _ACEOF
16812 cat confdefs.h >>conftest.$ac_ext
16813 cat >>conftest.$ac_ext <<_ACEOF
16814 /* end confdefs.h.  */
16815
16816 /* Override any gcc2 internal prototype to avoid an error.  */
16817 #ifdef __cplusplus
16818 extern "C"
16819 #endif
16820 /* We use char because int might match the return type of a gcc2
16821    builtin and then its argument prototype would still apply.  */
16822 char tanhl ();
16823 int
16824 main ()
16825 {
16826 tanhl ();
16827   ;
16828   return 0;
16829 }
16830 _ACEOF
16831 rm -f conftest.$ac_objext conftest$ac_exeext
16832 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16833   (eval $ac_link) 2>conftest.er1
16834   ac_status=$?
16835   grep -v '^ *+' conftest.er1 >conftest.err
16836   rm -f conftest.er1
16837   cat conftest.err >&5
16838   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16839   (exit $ac_status); } &&
16840          { ac_try='test -z "$ac_c_werror_flag"
16841                          || test ! -s conftest.err'
16842   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16843   (eval $ac_try) 2>&5
16844   ac_status=$?
16845   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16846   (exit $ac_status); }; } &&
16847          { ac_try='test -s conftest$ac_exeext'
16848   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16849   (eval $ac_try) 2>&5
16850   ac_status=$?
16851   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16852   (exit $ac_status); }; }; then
16853   ac_cv_lib_m_tanhl=yes
16854 else
16855   echo "$as_me: failed program was:" >&5
16856 sed 's/^/| /' conftest.$ac_ext >&5
16857
16858 ac_cv_lib_m_tanhl=no
16859 fi
16860 rm -f conftest.err conftest.$ac_objext \
16861       conftest$ac_exeext conftest.$ac_ext
16862 LIBS=$ac_check_lib_save_LIBS
16863 fi
16864 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanhl" >&5
16865 echo "${ECHO_T}$ac_cv_lib_m_tanhl" >&6
16866 if test $ac_cv_lib_m_tanhl = yes; then
16867
16868 cat >>confdefs.h <<\_ACEOF
16869 #define HAVE_TANHL 1
16870 _ACEOF
16871
16872 fi
16873
16874 echo "$as_me:$LINENO: checking for ctanhf in -lm" >&5
16875 echo $ECHO_N "checking for ctanhf in -lm... $ECHO_C" >&6
16876 if test "${ac_cv_lib_m_ctanhf+set}" = set; then
16877   echo $ECHO_N "(cached) $ECHO_C" >&6
16878 else
16879   ac_check_lib_save_LIBS=$LIBS
16880 LIBS="-lm  $LIBS"
16881 if test x$gcc_no_link = xyes; then
16882   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16883 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16884    { (exit 1); exit 1; }; }
16885 fi
16886 cat >conftest.$ac_ext <<_ACEOF
16887 /* confdefs.h.  */
16888 _ACEOF
16889 cat confdefs.h >>conftest.$ac_ext
16890 cat >>conftest.$ac_ext <<_ACEOF
16891 /* end confdefs.h.  */
16892
16893 /* Override any gcc2 internal prototype to avoid an error.  */
16894 #ifdef __cplusplus
16895 extern "C"
16896 #endif
16897 /* We use char because int might match the return type of a gcc2
16898    builtin and then its argument prototype would still apply.  */
16899 char ctanhf ();
16900 int
16901 main ()
16902 {
16903 ctanhf ();
16904   ;
16905   return 0;
16906 }
16907 _ACEOF
16908 rm -f conftest.$ac_objext conftest$ac_exeext
16909 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16910   (eval $ac_link) 2>conftest.er1
16911   ac_status=$?
16912   grep -v '^ *+' conftest.er1 >conftest.err
16913   rm -f conftest.er1
16914   cat conftest.err >&5
16915   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16916   (exit $ac_status); } &&
16917          { ac_try='test -z "$ac_c_werror_flag"
16918                          || test ! -s conftest.err'
16919   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16920   (eval $ac_try) 2>&5
16921   ac_status=$?
16922   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16923   (exit $ac_status); }; } &&
16924          { ac_try='test -s conftest$ac_exeext'
16925   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16926   (eval $ac_try) 2>&5
16927   ac_status=$?
16928   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16929   (exit $ac_status); }; }; then
16930   ac_cv_lib_m_ctanhf=yes
16931 else
16932   echo "$as_me: failed program was:" >&5
16933 sed 's/^/| /' conftest.$ac_ext >&5
16934
16935 ac_cv_lib_m_ctanhf=no
16936 fi
16937 rm -f conftest.err conftest.$ac_objext \
16938       conftest$ac_exeext conftest.$ac_ext
16939 LIBS=$ac_check_lib_save_LIBS
16940 fi
16941 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanhf" >&5
16942 echo "${ECHO_T}$ac_cv_lib_m_ctanhf" >&6
16943 if test $ac_cv_lib_m_ctanhf = yes; then
16944
16945 cat >>confdefs.h <<\_ACEOF
16946 #define HAVE_CTANHF 1
16947 _ACEOF
16948
16949 fi
16950
16951 echo "$as_me:$LINENO: checking for ctanh in -lm" >&5
16952 echo $ECHO_N "checking for ctanh in -lm... $ECHO_C" >&6
16953 if test "${ac_cv_lib_m_ctanh+set}" = set; then
16954   echo $ECHO_N "(cached) $ECHO_C" >&6
16955 else
16956   ac_check_lib_save_LIBS=$LIBS
16957 LIBS="-lm  $LIBS"
16958 if test x$gcc_no_link = xyes; then
16959   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16960 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16961    { (exit 1); exit 1; }; }
16962 fi
16963 cat >conftest.$ac_ext <<_ACEOF
16964 /* confdefs.h.  */
16965 _ACEOF
16966 cat confdefs.h >>conftest.$ac_ext
16967 cat >>conftest.$ac_ext <<_ACEOF
16968 /* end confdefs.h.  */
16969
16970 /* Override any gcc2 internal prototype to avoid an error.  */
16971 #ifdef __cplusplus
16972 extern "C"
16973 #endif
16974 /* We use char because int might match the return type of a gcc2
16975    builtin and then its argument prototype would still apply.  */
16976 char ctanh ();
16977 int
16978 main ()
16979 {
16980 ctanh ();
16981   ;
16982   return 0;
16983 }
16984 _ACEOF
16985 rm -f conftest.$ac_objext conftest$ac_exeext
16986 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16987   (eval $ac_link) 2>conftest.er1
16988   ac_status=$?
16989   grep -v '^ *+' conftest.er1 >conftest.err
16990   rm -f conftest.er1
16991   cat conftest.err >&5
16992   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16993   (exit $ac_status); } &&
16994          { ac_try='test -z "$ac_c_werror_flag"
16995                          || test ! -s conftest.err'
16996   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16997   (eval $ac_try) 2>&5
16998   ac_status=$?
16999   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17000   (exit $ac_status); }; } &&
17001          { ac_try='test -s conftest$ac_exeext'
17002   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17003   (eval $ac_try) 2>&5
17004   ac_status=$?
17005   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17006   (exit $ac_status); }; }; then
17007   ac_cv_lib_m_ctanh=yes
17008 else
17009   echo "$as_me: failed program was:" >&5
17010 sed 's/^/| /' conftest.$ac_ext >&5
17011
17012 ac_cv_lib_m_ctanh=no
17013 fi
17014 rm -f conftest.err conftest.$ac_objext \
17015       conftest$ac_exeext conftest.$ac_ext
17016 LIBS=$ac_check_lib_save_LIBS
17017 fi
17018 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanh" >&5
17019 echo "${ECHO_T}$ac_cv_lib_m_ctanh" >&6
17020 if test $ac_cv_lib_m_ctanh = yes; then
17021
17022 cat >>confdefs.h <<\_ACEOF
17023 #define HAVE_CTANH 1
17024 _ACEOF
17025
17026 fi
17027
17028 echo "$as_me:$LINENO: checking for ctanhl in -lm" >&5
17029 echo $ECHO_N "checking for ctanhl in -lm... $ECHO_C" >&6
17030 if test "${ac_cv_lib_m_ctanhl+set}" = set; then
17031   echo $ECHO_N "(cached) $ECHO_C" >&6
17032 else
17033   ac_check_lib_save_LIBS=$LIBS
17034 LIBS="-lm  $LIBS"
17035 if test x$gcc_no_link = xyes; then
17036   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17037 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17038    { (exit 1); exit 1; }; }
17039 fi
17040 cat >conftest.$ac_ext <<_ACEOF
17041 /* confdefs.h.  */
17042 _ACEOF
17043 cat confdefs.h >>conftest.$ac_ext
17044 cat >>conftest.$ac_ext <<_ACEOF
17045 /* end confdefs.h.  */
17046
17047 /* Override any gcc2 internal prototype to avoid an error.  */
17048 #ifdef __cplusplus
17049 extern "C"
17050 #endif
17051 /* We use char because int might match the return type of a gcc2
17052    builtin and then its argument prototype would still apply.  */
17053 char ctanhl ();
17054 int
17055 main ()
17056 {
17057 ctanhl ();
17058   ;
17059   return 0;
17060 }
17061 _ACEOF
17062 rm -f conftest.$ac_objext conftest$ac_exeext
17063 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17064   (eval $ac_link) 2>conftest.er1
17065   ac_status=$?
17066   grep -v '^ *+' conftest.er1 >conftest.err
17067   rm -f conftest.er1
17068   cat conftest.err >&5
17069   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17070   (exit $ac_status); } &&
17071          { ac_try='test -z "$ac_c_werror_flag"
17072                          || test ! -s conftest.err'
17073   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17074   (eval $ac_try) 2>&5
17075   ac_status=$?
17076   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17077   (exit $ac_status); }; } &&
17078          { ac_try='test -s conftest$ac_exeext'
17079   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17080   (eval $ac_try) 2>&5
17081   ac_status=$?
17082   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17083   (exit $ac_status); }; }; then
17084   ac_cv_lib_m_ctanhl=yes
17085 else
17086   echo "$as_me: failed program was:" >&5
17087 sed 's/^/| /' conftest.$ac_ext >&5
17088
17089 ac_cv_lib_m_ctanhl=no
17090 fi
17091 rm -f conftest.err conftest.$ac_objext \
17092       conftest$ac_exeext conftest.$ac_ext
17093 LIBS=$ac_check_lib_save_LIBS
17094 fi
17095 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanhl" >&5
17096 echo "${ECHO_T}$ac_cv_lib_m_ctanhl" >&6
17097 if test $ac_cv_lib_m_ctanhl = yes; then
17098
17099 cat >>confdefs.h <<\_ACEOF
17100 #define HAVE_CTANHL 1
17101 _ACEOF
17102
17103 fi
17104
17105 echo "$as_me:$LINENO: checking for truncf in -lm" >&5
17106 echo $ECHO_N "checking for truncf in -lm... $ECHO_C" >&6
17107 if test "${ac_cv_lib_m_truncf+set}" = set; then
17108   echo $ECHO_N "(cached) $ECHO_C" >&6
17109 else
17110   ac_check_lib_save_LIBS=$LIBS
17111 LIBS="-lm  $LIBS"
17112 if test x$gcc_no_link = xyes; then
17113   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17114 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17115    { (exit 1); exit 1; }; }
17116 fi
17117 cat >conftest.$ac_ext <<_ACEOF
17118 /* confdefs.h.  */
17119 _ACEOF
17120 cat confdefs.h >>conftest.$ac_ext
17121 cat >>conftest.$ac_ext <<_ACEOF
17122 /* end confdefs.h.  */
17123
17124 /* Override any gcc2 internal prototype to avoid an error.  */
17125 #ifdef __cplusplus
17126 extern "C"
17127 #endif
17128 /* We use char because int might match the return type of a gcc2
17129    builtin and then its argument prototype would still apply.  */
17130 char truncf ();
17131 int
17132 main ()
17133 {
17134 truncf ();
17135   ;
17136   return 0;
17137 }
17138 _ACEOF
17139 rm -f conftest.$ac_objext conftest$ac_exeext
17140 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17141   (eval $ac_link) 2>conftest.er1
17142   ac_status=$?
17143   grep -v '^ *+' conftest.er1 >conftest.err
17144   rm -f conftest.er1
17145   cat conftest.err >&5
17146   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17147   (exit $ac_status); } &&
17148          { ac_try='test -z "$ac_c_werror_flag"
17149                          || test ! -s conftest.err'
17150   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17151   (eval $ac_try) 2>&5
17152   ac_status=$?
17153   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17154   (exit $ac_status); }; } &&
17155          { ac_try='test -s conftest$ac_exeext'
17156   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17157   (eval $ac_try) 2>&5
17158   ac_status=$?
17159   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17160   (exit $ac_status); }; }; then
17161   ac_cv_lib_m_truncf=yes
17162 else
17163   echo "$as_me: failed program was:" >&5
17164 sed 's/^/| /' conftest.$ac_ext >&5
17165
17166 ac_cv_lib_m_truncf=no
17167 fi
17168 rm -f conftest.err conftest.$ac_objext \
17169       conftest$ac_exeext conftest.$ac_ext
17170 LIBS=$ac_check_lib_save_LIBS
17171 fi
17172 echo "$as_me:$LINENO: result: $ac_cv_lib_m_truncf" >&5
17173 echo "${ECHO_T}$ac_cv_lib_m_truncf" >&6
17174 if test $ac_cv_lib_m_truncf = yes; then
17175
17176 cat >>confdefs.h <<\_ACEOF
17177 #define HAVE_TRUNCF 1
17178 _ACEOF
17179
17180 fi
17181
17182 echo "$as_me:$LINENO: checking for trunc in -lm" >&5
17183 echo $ECHO_N "checking for trunc in -lm... $ECHO_C" >&6
17184 if test "${ac_cv_lib_m_trunc+set}" = set; then
17185   echo $ECHO_N "(cached) $ECHO_C" >&6
17186 else
17187   ac_check_lib_save_LIBS=$LIBS
17188 LIBS="-lm  $LIBS"
17189 if test x$gcc_no_link = xyes; then
17190   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17191 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17192    { (exit 1); exit 1; }; }
17193 fi
17194 cat >conftest.$ac_ext <<_ACEOF
17195 /* confdefs.h.  */
17196 _ACEOF
17197 cat confdefs.h >>conftest.$ac_ext
17198 cat >>conftest.$ac_ext <<_ACEOF
17199 /* end confdefs.h.  */
17200
17201 /* Override any gcc2 internal prototype to avoid an error.  */
17202 #ifdef __cplusplus
17203 extern "C"
17204 #endif
17205 /* We use char because int might match the return type of a gcc2
17206    builtin and then its argument prototype would still apply.  */
17207 char trunc ();
17208 int
17209 main ()
17210 {
17211 trunc ();
17212   ;
17213   return 0;
17214 }
17215 _ACEOF
17216 rm -f conftest.$ac_objext conftest$ac_exeext
17217 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17218   (eval $ac_link) 2>conftest.er1
17219   ac_status=$?
17220   grep -v '^ *+' conftest.er1 >conftest.err
17221   rm -f conftest.er1
17222   cat conftest.err >&5
17223   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17224   (exit $ac_status); } &&
17225          { ac_try='test -z "$ac_c_werror_flag"
17226                          || test ! -s conftest.err'
17227   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17228   (eval $ac_try) 2>&5
17229   ac_status=$?
17230   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17231   (exit $ac_status); }; } &&
17232          { ac_try='test -s conftest$ac_exeext'
17233   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17234   (eval $ac_try) 2>&5
17235   ac_status=$?
17236   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17237   (exit $ac_status); }; }; then
17238   ac_cv_lib_m_trunc=yes
17239 else
17240   echo "$as_me: failed program was:" >&5
17241 sed 's/^/| /' conftest.$ac_ext >&5
17242
17243 ac_cv_lib_m_trunc=no
17244 fi
17245 rm -f conftest.err conftest.$ac_objext \
17246       conftest$ac_exeext conftest.$ac_ext
17247 LIBS=$ac_check_lib_save_LIBS
17248 fi
17249 echo "$as_me:$LINENO: result: $ac_cv_lib_m_trunc" >&5
17250 echo "${ECHO_T}$ac_cv_lib_m_trunc" >&6
17251 if test $ac_cv_lib_m_trunc = yes; then
17252
17253 cat >>confdefs.h <<\_ACEOF
17254 #define HAVE_TRUNC 1
17255 _ACEOF
17256
17257 fi
17258
17259 echo "$as_me:$LINENO: checking for truncl in -lm" >&5
17260 echo $ECHO_N "checking for truncl in -lm... $ECHO_C" >&6
17261 if test "${ac_cv_lib_m_truncl+set}" = set; then
17262   echo $ECHO_N "(cached) $ECHO_C" >&6
17263 else
17264   ac_check_lib_save_LIBS=$LIBS
17265 LIBS="-lm  $LIBS"
17266 if test x$gcc_no_link = xyes; then
17267   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17268 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17269    { (exit 1); exit 1; }; }
17270 fi
17271 cat >conftest.$ac_ext <<_ACEOF
17272 /* confdefs.h.  */
17273 _ACEOF
17274 cat confdefs.h >>conftest.$ac_ext
17275 cat >>conftest.$ac_ext <<_ACEOF
17276 /* end confdefs.h.  */
17277
17278 /* Override any gcc2 internal prototype to avoid an error.  */
17279 #ifdef __cplusplus
17280 extern "C"
17281 #endif
17282 /* We use char because int might match the return type of a gcc2
17283    builtin and then its argument prototype would still apply.  */
17284 char truncl ();
17285 int
17286 main ()
17287 {
17288 truncl ();
17289   ;
17290   return 0;
17291 }
17292 _ACEOF
17293 rm -f conftest.$ac_objext conftest$ac_exeext
17294 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17295   (eval $ac_link) 2>conftest.er1
17296   ac_status=$?
17297   grep -v '^ *+' conftest.er1 >conftest.err
17298   rm -f conftest.er1
17299   cat conftest.err >&5
17300   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17301   (exit $ac_status); } &&
17302          { ac_try='test -z "$ac_c_werror_flag"
17303                          || test ! -s conftest.err'
17304   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17305   (eval $ac_try) 2>&5
17306   ac_status=$?
17307   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17308   (exit $ac_status); }; } &&
17309          { ac_try='test -s conftest$ac_exeext'
17310   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17311   (eval $ac_try) 2>&5
17312   ac_status=$?
17313   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17314   (exit $ac_status); }; }; then
17315   ac_cv_lib_m_truncl=yes
17316 else
17317   echo "$as_me: failed program was:" >&5
17318 sed 's/^/| /' conftest.$ac_ext >&5
17319
17320 ac_cv_lib_m_truncl=no
17321 fi
17322 rm -f conftest.err conftest.$ac_objext \
17323       conftest$ac_exeext conftest.$ac_ext
17324 LIBS=$ac_check_lib_save_LIBS
17325 fi
17326 echo "$as_me:$LINENO: result: $ac_cv_lib_m_truncl" >&5
17327 echo "${ECHO_T}$ac_cv_lib_m_truncl" >&6
17328 if test $ac_cv_lib_m_truncl = yes; then
17329
17330 cat >>confdefs.h <<\_ACEOF
17331 #define HAVE_TRUNCL 1
17332 _ACEOF
17333
17334 fi
17335
17336 echo "$as_me:$LINENO: checking for erff in -lm" >&5
17337 echo $ECHO_N "checking for erff in -lm... $ECHO_C" >&6
17338 if test "${ac_cv_lib_m_erff+set}" = set; then
17339   echo $ECHO_N "(cached) $ECHO_C" >&6
17340 else
17341   ac_check_lib_save_LIBS=$LIBS
17342 LIBS="-lm  $LIBS"
17343 if test x$gcc_no_link = xyes; then
17344   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17345 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17346    { (exit 1); exit 1; }; }
17347 fi
17348 cat >conftest.$ac_ext <<_ACEOF
17349 /* confdefs.h.  */
17350 _ACEOF
17351 cat confdefs.h >>conftest.$ac_ext
17352 cat >>conftest.$ac_ext <<_ACEOF
17353 /* end confdefs.h.  */
17354
17355 /* Override any gcc2 internal prototype to avoid an error.  */
17356 #ifdef __cplusplus
17357 extern "C"
17358 #endif
17359 /* We use char because int might match the return type of a gcc2
17360    builtin and then its argument prototype would still apply.  */
17361 char erff ();
17362 int
17363 main ()
17364 {
17365 erff ();
17366   ;
17367   return 0;
17368 }
17369 _ACEOF
17370 rm -f conftest.$ac_objext conftest$ac_exeext
17371 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17372   (eval $ac_link) 2>conftest.er1
17373   ac_status=$?
17374   grep -v '^ *+' conftest.er1 >conftest.err
17375   rm -f conftest.er1
17376   cat conftest.err >&5
17377   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17378   (exit $ac_status); } &&
17379          { ac_try='test -z "$ac_c_werror_flag"
17380                          || test ! -s conftest.err'
17381   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17382   (eval $ac_try) 2>&5
17383   ac_status=$?
17384   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17385   (exit $ac_status); }; } &&
17386          { ac_try='test -s conftest$ac_exeext'
17387   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17388   (eval $ac_try) 2>&5
17389   ac_status=$?
17390   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17391   (exit $ac_status); }; }; then
17392   ac_cv_lib_m_erff=yes
17393 else
17394   echo "$as_me: failed program was:" >&5
17395 sed 's/^/| /' conftest.$ac_ext >&5
17396
17397 ac_cv_lib_m_erff=no
17398 fi
17399 rm -f conftest.err conftest.$ac_objext \
17400       conftest$ac_exeext conftest.$ac_ext
17401 LIBS=$ac_check_lib_save_LIBS
17402 fi
17403 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erff" >&5
17404 echo "${ECHO_T}$ac_cv_lib_m_erff" >&6
17405 if test $ac_cv_lib_m_erff = yes; then
17406
17407 cat >>confdefs.h <<\_ACEOF
17408 #define HAVE_ERFF 1
17409 _ACEOF
17410
17411 fi
17412
17413 echo "$as_me:$LINENO: checking for erf in -lm" >&5
17414 echo $ECHO_N "checking for erf in -lm... $ECHO_C" >&6
17415 if test "${ac_cv_lib_m_erf+set}" = set; then
17416   echo $ECHO_N "(cached) $ECHO_C" >&6
17417 else
17418   ac_check_lib_save_LIBS=$LIBS
17419 LIBS="-lm  $LIBS"
17420 if test x$gcc_no_link = xyes; then
17421   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17422 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17423    { (exit 1); exit 1; }; }
17424 fi
17425 cat >conftest.$ac_ext <<_ACEOF
17426 /* confdefs.h.  */
17427 _ACEOF
17428 cat confdefs.h >>conftest.$ac_ext
17429 cat >>conftest.$ac_ext <<_ACEOF
17430 /* end confdefs.h.  */
17431
17432 /* Override any gcc2 internal prototype to avoid an error.  */
17433 #ifdef __cplusplus
17434 extern "C"
17435 #endif
17436 /* We use char because int might match the return type of a gcc2
17437    builtin and then its argument prototype would still apply.  */
17438 char erf ();
17439 int
17440 main ()
17441 {
17442 erf ();
17443   ;
17444   return 0;
17445 }
17446 _ACEOF
17447 rm -f conftest.$ac_objext conftest$ac_exeext
17448 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17449   (eval $ac_link) 2>conftest.er1
17450   ac_status=$?
17451   grep -v '^ *+' conftest.er1 >conftest.err
17452   rm -f conftest.er1
17453   cat conftest.err >&5
17454   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17455   (exit $ac_status); } &&
17456          { ac_try='test -z "$ac_c_werror_flag"
17457                          || test ! -s conftest.err'
17458   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17459   (eval $ac_try) 2>&5
17460   ac_status=$?
17461   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17462   (exit $ac_status); }; } &&
17463          { ac_try='test -s conftest$ac_exeext'
17464   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17465   (eval $ac_try) 2>&5
17466   ac_status=$?
17467   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17468   (exit $ac_status); }; }; then
17469   ac_cv_lib_m_erf=yes
17470 else
17471   echo "$as_me: failed program was:" >&5
17472 sed 's/^/| /' conftest.$ac_ext >&5
17473
17474 ac_cv_lib_m_erf=no
17475 fi
17476 rm -f conftest.err conftest.$ac_objext \
17477       conftest$ac_exeext conftest.$ac_ext
17478 LIBS=$ac_check_lib_save_LIBS
17479 fi
17480 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erf" >&5
17481 echo "${ECHO_T}$ac_cv_lib_m_erf" >&6
17482 if test $ac_cv_lib_m_erf = yes; then
17483
17484 cat >>confdefs.h <<\_ACEOF
17485 #define HAVE_ERF 1
17486 _ACEOF
17487
17488 fi
17489
17490 echo "$as_me:$LINENO: checking for erfl in -lm" >&5
17491 echo $ECHO_N "checking for erfl in -lm... $ECHO_C" >&6
17492 if test "${ac_cv_lib_m_erfl+set}" = set; then
17493   echo $ECHO_N "(cached) $ECHO_C" >&6
17494 else
17495   ac_check_lib_save_LIBS=$LIBS
17496 LIBS="-lm  $LIBS"
17497 if test x$gcc_no_link = xyes; then
17498   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17499 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17500    { (exit 1); exit 1; }; }
17501 fi
17502 cat >conftest.$ac_ext <<_ACEOF
17503 /* confdefs.h.  */
17504 _ACEOF
17505 cat confdefs.h >>conftest.$ac_ext
17506 cat >>conftest.$ac_ext <<_ACEOF
17507 /* end confdefs.h.  */
17508
17509 /* Override any gcc2 internal prototype to avoid an error.  */
17510 #ifdef __cplusplus
17511 extern "C"
17512 #endif
17513 /* We use char because int might match the return type of a gcc2
17514    builtin and then its argument prototype would still apply.  */
17515 char erfl ();
17516 int
17517 main ()
17518 {
17519 erfl ();
17520   ;
17521   return 0;
17522 }
17523 _ACEOF
17524 rm -f conftest.$ac_objext conftest$ac_exeext
17525 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17526   (eval $ac_link) 2>conftest.er1
17527   ac_status=$?
17528   grep -v '^ *+' conftest.er1 >conftest.err
17529   rm -f conftest.er1
17530   cat conftest.err >&5
17531   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17532   (exit $ac_status); } &&
17533          { ac_try='test -z "$ac_c_werror_flag"
17534                          || test ! -s conftest.err'
17535   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17536   (eval $ac_try) 2>&5
17537   ac_status=$?
17538   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17539   (exit $ac_status); }; } &&
17540          { ac_try='test -s conftest$ac_exeext'
17541   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17542   (eval $ac_try) 2>&5
17543   ac_status=$?
17544   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17545   (exit $ac_status); }; }; then
17546   ac_cv_lib_m_erfl=yes
17547 else
17548   echo "$as_me: failed program was:" >&5
17549 sed 's/^/| /' conftest.$ac_ext >&5
17550
17551 ac_cv_lib_m_erfl=no
17552 fi
17553 rm -f conftest.err conftest.$ac_objext \
17554       conftest$ac_exeext conftest.$ac_ext
17555 LIBS=$ac_check_lib_save_LIBS
17556 fi
17557 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfl" >&5
17558 echo "${ECHO_T}$ac_cv_lib_m_erfl" >&6
17559 if test $ac_cv_lib_m_erfl = yes; then
17560
17561 cat >>confdefs.h <<\_ACEOF
17562 #define HAVE_ERFL 1
17563 _ACEOF
17564
17565 fi
17566
17567 echo "$as_me:$LINENO: checking for erfcf in -lm" >&5
17568 echo $ECHO_N "checking for erfcf in -lm... $ECHO_C" >&6
17569 if test "${ac_cv_lib_m_erfcf+set}" = set; then
17570   echo $ECHO_N "(cached) $ECHO_C" >&6
17571 else
17572   ac_check_lib_save_LIBS=$LIBS
17573 LIBS="-lm  $LIBS"
17574 if test x$gcc_no_link = xyes; then
17575   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17576 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17577    { (exit 1); exit 1; }; }
17578 fi
17579 cat >conftest.$ac_ext <<_ACEOF
17580 /* confdefs.h.  */
17581 _ACEOF
17582 cat confdefs.h >>conftest.$ac_ext
17583 cat >>conftest.$ac_ext <<_ACEOF
17584 /* end confdefs.h.  */
17585
17586 /* Override any gcc2 internal prototype to avoid an error.  */
17587 #ifdef __cplusplus
17588 extern "C"
17589 #endif
17590 /* We use char because int might match the return type of a gcc2
17591    builtin and then its argument prototype would still apply.  */
17592 char erfcf ();
17593 int
17594 main ()
17595 {
17596 erfcf ();
17597   ;
17598   return 0;
17599 }
17600 _ACEOF
17601 rm -f conftest.$ac_objext conftest$ac_exeext
17602 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17603   (eval $ac_link) 2>conftest.er1
17604   ac_status=$?
17605   grep -v '^ *+' conftest.er1 >conftest.err
17606   rm -f conftest.er1
17607   cat conftest.err >&5
17608   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17609   (exit $ac_status); } &&
17610          { ac_try='test -z "$ac_c_werror_flag"
17611                          || test ! -s conftest.err'
17612   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17613   (eval $ac_try) 2>&5
17614   ac_status=$?
17615   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17616   (exit $ac_status); }; } &&
17617          { ac_try='test -s conftest$ac_exeext'
17618   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17619   (eval $ac_try) 2>&5
17620   ac_status=$?
17621   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17622   (exit $ac_status); }; }; then
17623   ac_cv_lib_m_erfcf=yes
17624 else
17625   echo "$as_me: failed program was:" >&5
17626 sed 's/^/| /' conftest.$ac_ext >&5
17627
17628 ac_cv_lib_m_erfcf=no
17629 fi
17630 rm -f conftest.err conftest.$ac_objext \
17631       conftest$ac_exeext conftest.$ac_ext
17632 LIBS=$ac_check_lib_save_LIBS
17633 fi
17634 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfcf" >&5
17635 echo "${ECHO_T}$ac_cv_lib_m_erfcf" >&6
17636 if test $ac_cv_lib_m_erfcf = yes; then
17637
17638 cat >>confdefs.h <<\_ACEOF
17639 #define HAVE_ERFCF 1
17640 _ACEOF
17641
17642 fi
17643
17644 echo "$as_me:$LINENO: checking for erfc in -lm" >&5
17645 echo $ECHO_N "checking for erfc in -lm... $ECHO_C" >&6
17646 if test "${ac_cv_lib_m_erfc+set}" = set; then
17647   echo $ECHO_N "(cached) $ECHO_C" >&6
17648 else
17649   ac_check_lib_save_LIBS=$LIBS
17650 LIBS="-lm  $LIBS"
17651 if test x$gcc_no_link = xyes; then
17652   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17653 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17654    { (exit 1); exit 1; }; }
17655 fi
17656 cat >conftest.$ac_ext <<_ACEOF
17657 /* confdefs.h.  */
17658 _ACEOF
17659 cat confdefs.h >>conftest.$ac_ext
17660 cat >>conftest.$ac_ext <<_ACEOF
17661 /* end confdefs.h.  */
17662
17663 /* Override any gcc2 internal prototype to avoid an error.  */
17664 #ifdef __cplusplus
17665 extern "C"
17666 #endif
17667 /* We use char because int might match the return type of a gcc2
17668    builtin and then its argument prototype would still apply.  */
17669 char erfc ();
17670 int
17671 main ()
17672 {
17673 erfc ();
17674   ;
17675   return 0;
17676 }
17677 _ACEOF
17678 rm -f conftest.$ac_objext conftest$ac_exeext
17679 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17680   (eval $ac_link) 2>conftest.er1
17681   ac_status=$?
17682   grep -v '^ *+' conftest.er1 >conftest.err
17683   rm -f conftest.er1
17684   cat conftest.err >&5
17685   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17686   (exit $ac_status); } &&
17687          { ac_try='test -z "$ac_c_werror_flag"
17688                          || test ! -s conftest.err'
17689   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17690   (eval $ac_try) 2>&5
17691   ac_status=$?
17692   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17693   (exit $ac_status); }; } &&
17694          { ac_try='test -s conftest$ac_exeext'
17695   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17696   (eval $ac_try) 2>&5
17697   ac_status=$?
17698   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17699   (exit $ac_status); }; }; then
17700   ac_cv_lib_m_erfc=yes
17701 else
17702   echo "$as_me: failed program was:" >&5
17703 sed 's/^/| /' conftest.$ac_ext >&5
17704
17705 ac_cv_lib_m_erfc=no
17706 fi
17707 rm -f conftest.err conftest.$ac_objext \
17708       conftest$ac_exeext conftest.$ac_ext
17709 LIBS=$ac_check_lib_save_LIBS
17710 fi
17711 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfc" >&5
17712 echo "${ECHO_T}$ac_cv_lib_m_erfc" >&6
17713 if test $ac_cv_lib_m_erfc = yes; then
17714
17715 cat >>confdefs.h <<\_ACEOF
17716 #define HAVE_ERFC 1
17717 _ACEOF
17718
17719 fi
17720
17721 echo "$as_me:$LINENO: checking for erfcl in -lm" >&5
17722 echo $ECHO_N "checking for erfcl in -lm... $ECHO_C" >&6
17723 if test "${ac_cv_lib_m_erfcl+set}" = set; then
17724   echo $ECHO_N "(cached) $ECHO_C" >&6
17725 else
17726   ac_check_lib_save_LIBS=$LIBS
17727 LIBS="-lm  $LIBS"
17728 if test x$gcc_no_link = xyes; then
17729   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17730 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17731    { (exit 1); exit 1; }; }
17732 fi
17733 cat >conftest.$ac_ext <<_ACEOF
17734 /* confdefs.h.  */
17735 _ACEOF
17736 cat confdefs.h >>conftest.$ac_ext
17737 cat >>conftest.$ac_ext <<_ACEOF
17738 /* end confdefs.h.  */
17739
17740 /* Override any gcc2 internal prototype to avoid an error.  */
17741 #ifdef __cplusplus
17742 extern "C"
17743 #endif
17744 /* We use char because int might match the return type of a gcc2
17745    builtin and then its argument prototype would still apply.  */
17746 char erfcl ();
17747 int
17748 main ()
17749 {
17750 erfcl ();
17751   ;
17752   return 0;
17753 }
17754 _ACEOF
17755 rm -f conftest.$ac_objext conftest$ac_exeext
17756 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17757   (eval $ac_link) 2>conftest.er1
17758   ac_status=$?
17759   grep -v '^ *+' conftest.er1 >conftest.err
17760   rm -f conftest.er1
17761   cat conftest.err >&5
17762   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17763   (exit $ac_status); } &&
17764          { ac_try='test -z "$ac_c_werror_flag"
17765                          || test ! -s conftest.err'
17766   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17767   (eval $ac_try) 2>&5
17768   ac_status=$?
17769   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17770   (exit $ac_status); }; } &&
17771          { ac_try='test -s conftest$ac_exeext'
17772   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17773   (eval $ac_try) 2>&5
17774   ac_status=$?
17775   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17776   (exit $ac_status); }; }; then
17777   ac_cv_lib_m_erfcl=yes
17778 else
17779   echo "$as_me: failed program was:" >&5
17780 sed 's/^/| /' conftest.$ac_ext >&5
17781
17782 ac_cv_lib_m_erfcl=no
17783 fi
17784 rm -f conftest.err conftest.$ac_objext \
17785       conftest$ac_exeext conftest.$ac_ext
17786 LIBS=$ac_check_lib_save_LIBS
17787 fi
17788 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfcl" >&5
17789 echo "${ECHO_T}$ac_cv_lib_m_erfcl" >&6
17790 if test $ac_cv_lib_m_erfcl = yes; then
17791
17792 cat >>confdefs.h <<\_ACEOF
17793 #define HAVE_ERFCL 1
17794 _ACEOF
17795
17796 fi
17797
17798 echo "$as_me:$LINENO: checking for j0f in -lm" >&5
17799 echo $ECHO_N "checking for j0f in -lm... $ECHO_C" >&6
17800 if test "${ac_cv_lib_m_j0f+set}" = set; then
17801   echo $ECHO_N "(cached) $ECHO_C" >&6
17802 else
17803   ac_check_lib_save_LIBS=$LIBS
17804 LIBS="-lm  $LIBS"
17805 if test x$gcc_no_link = xyes; then
17806   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17807 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17808    { (exit 1); exit 1; }; }
17809 fi
17810 cat >conftest.$ac_ext <<_ACEOF
17811 /* confdefs.h.  */
17812 _ACEOF
17813 cat confdefs.h >>conftest.$ac_ext
17814 cat >>conftest.$ac_ext <<_ACEOF
17815 /* end confdefs.h.  */
17816
17817 /* Override any gcc2 internal prototype to avoid an error.  */
17818 #ifdef __cplusplus
17819 extern "C"
17820 #endif
17821 /* We use char because int might match the return type of a gcc2
17822    builtin and then its argument prototype would still apply.  */
17823 char j0f ();
17824 int
17825 main ()
17826 {
17827 j0f ();
17828   ;
17829   return 0;
17830 }
17831 _ACEOF
17832 rm -f conftest.$ac_objext conftest$ac_exeext
17833 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17834   (eval $ac_link) 2>conftest.er1
17835   ac_status=$?
17836   grep -v '^ *+' conftest.er1 >conftest.err
17837   rm -f conftest.er1
17838   cat conftest.err >&5
17839   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17840   (exit $ac_status); } &&
17841          { ac_try='test -z "$ac_c_werror_flag"
17842                          || test ! -s conftest.err'
17843   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17844   (eval $ac_try) 2>&5
17845   ac_status=$?
17846   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17847   (exit $ac_status); }; } &&
17848          { ac_try='test -s conftest$ac_exeext'
17849   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17850   (eval $ac_try) 2>&5
17851   ac_status=$?
17852   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17853   (exit $ac_status); }; }; then
17854   ac_cv_lib_m_j0f=yes
17855 else
17856   echo "$as_me: failed program was:" >&5
17857 sed 's/^/| /' conftest.$ac_ext >&5
17858
17859 ac_cv_lib_m_j0f=no
17860 fi
17861 rm -f conftest.err conftest.$ac_objext \
17862       conftest$ac_exeext conftest.$ac_ext
17863 LIBS=$ac_check_lib_save_LIBS
17864 fi
17865 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0f" >&5
17866 echo "${ECHO_T}$ac_cv_lib_m_j0f" >&6
17867 if test $ac_cv_lib_m_j0f = yes; then
17868
17869 cat >>confdefs.h <<\_ACEOF
17870 #define HAVE_J0F 1
17871 _ACEOF
17872
17873 fi
17874
17875 echo "$as_me:$LINENO: checking for j0 in -lm" >&5
17876 echo $ECHO_N "checking for j0 in -lm... $ECHO_C" >&6
17877 if test "${ac_cv_lib_m_j0+set}" = set; then
17878   echo $ECHO_N "(cached) $ECHO_C" >&6
17879 else
17880   ac_check_lib_save_LIBS=$LIBS
17881 LIBS="-lm  $LIBS"
17882 if test x$gcc_no_link = xyes; then
17883   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17884 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17885    { (exit 1); exit 1; }; }
17886 fi
17887 cat >conftest.$ac_ext <<_ACEOF
17888 /* confdefs.h.  */
17889 _ACEOF
17890 cat confdefs.h >>conftest.$ac_ext
17891 cat >>conftest.$ac_ext <<_ACEOF
17892 /* end confdefs.h.  */
17893
17894 /* Override any gcc2 internal prototype to avoid an error.  */
17895 #ifdef __cplusplus
17896 extern "C"
17897 #endif
17898 /* We use char because int might match the return type of a gcc2
17899    builtin and then its argument prototype would still apply.  */
17900 char j0 ();
17901 int
17902 main ()
17903 {
17904 j0 ();
17905   ;
17906   return 0;
17907 }
17908 _ACEOF
17909 rm -f conftest.$ac_objext conftest$ac_exeext
17910 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17911   (eval $ac_link) 2>conftest.er1
17912   ac_status=$?
17913   grep -v '^ *+' conftest.er1 >conftest.err
17914   rm -f conftest.er1
17915   cat conftest.err >&5
17916   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17917   (exit $ac_status); } &&
17918          { ac_try='test -z "$ac_c_werror_flag"
17919                          || test ! -s conftest.err'
17920   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17921   (eval $ac_try) 2>&5
17922   ac_status=$?
17923   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17924   (exit $ac_status); }; } &&
17925          { ac_try='test -s conftest$ac_exeext'
17926   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17927   (eval $ac_try) 2>&5
17928   ac_status=$?
17929   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17930   (exit $ac_status); }; }; then
17931   ac_cv_lib_m_j0=yes
17932 else
17933   echo "$as_me: failed program was:" >&5
17934 sed 's/^/| /' conftest.$ac_ext >&5
17935
17936 ac_cv_lib_m_j0=no
17937 fi
17938 rm -f conftest.err conftest.$ac_objext \
17939       conftest$ac_exeext conftest.$ac_ext
17940 LIBS=$ac_check_lib_save_LIBS
17941 fi
17942 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0" >&5
17943 echo "${ECHO_T}$ac_cv_lib_m_j0" >&6
17944 if test $ac_cv_lib_m_j0 = yes; then
17945
17946 cat >>confdefs.h <<\_ACEOF
17947 #define HAVE_J0 1
17948 _ACEOF
17949
17950 fi
17951
17952 echo "$as_me:$LINENO: checking for j0l in -lm" >&5
17953 echo $ECHO_N "checking for j0l in -lm... $ECHO_C" >&6
17954 if test "${ac_cv_lib_m_j0l+set}" = set; then
17955   echo $ECHO_N "(cached) $ECHO_C" >&6
17956 else
17957   ac_check_lib_save_LIBS=$LIBS
17958 LIBS="-lm  $LIBS"
17959 if test x$gcc_no_link = xyes; then
17960   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17961 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17962    { (exit 1); exit 1; }; }
17963 fi
17964 cat >conftest.$ac_ext <<_ACEOF
17965 /* confdefs.h.  */
17966 _ACEOF
17967 cat confdefs.h >>conftest.$ac_ext
17968 cat >>conftest.$ac_ext <<_ACEOF
17969 /* end confdefs.h.  */
17970
17971 /* Override any gcc2 internal prototype to avoid an error.  */
17972 #ifdef __cplusplus
17973 extern "C"
17974 #endif
17975 /* We use char because int might match the return type of a gcc2
17976    builtin and then its argument prototype would still apply.  */
17977 char j0l ();
17978 int
17979 main ()
17980 {
17981 j0l ();
17982   ;
17983   return 0;
17984 }
17985 _ACEOF
17986 rm -f conftest.$ac_objext conftest$ac_exeext
17987 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17988   (eval $ac_link) 2>conftest.er1
17989   ac_status=$?
17990   grep -v '^ *+' conftest.er1 >conftest.err
17991   rm -f conftest.er1
17992   cat conftest.err >&5
17993   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17994   (exit $ac_status); } &&
17995          { ac_try='test -z "$ac_c_werror_flag"
17996                          || test ! -s conftest.err'
17997   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17998   (eval $ac_try) 2>&5
17999   ac_status=$?
18000   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18001   (exit $ac_status); }; } &&
18002          { ac_try='test -s conftest$ac_exeext'
18003   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18004   (eval $ac_try) 2>&5
18005   ac_status=$?
18006   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18007   (exit $ac_status); }; }; then
18008   ac_cv_lib_m_j0l=yes
18009 else
18010   echo "$as_me: failed program was:" >&5
18011 sed 's/^/| /' conftest.$ac_ext >&5
18012
18013 ac_cv_lib_m_j0l=no
18014 fi
18015 rm -f conftest.err conftest.$ac_objext \
18016       conftest$ac_exeext conftest.$ac_ext
18017 LIBS=$ac_check_lib_save_LIBS
18018 fi
18019 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0l" >&5
18020 echo "${ECHO_T}$ac_cv_lib_m_j0l" >&6
18021 if test $ac_cv_lib_m_j0l = yes; then
18022
18023 cat >>confdefs.h <<\_ACEOF
18024 #define HAVE_J0L 1
18025 _ACEOF
18026
18027 fi
18028
18029 echo "$as_me:$LINENO: checking for j1f in -lm" >&5
18030 echo $ECHO_N "checking for j1f in -lm... $ECHO_C" >&6
18031 if test "${ac_cv_lib_m_j1f+set}" = set; then
18032   echo $ECHO_N "(cached) $ECHO_C" >&6
18033 else
18034   ac_check_lib_save_LIBS=$LIBS
18035 LIBS="-lm  $LIBS"
18036 if test x$gcc_no_link = xyes; then
18037   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18038 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18039    { (exit 1); exit 1; }; }
18040 fi
18041 cat >conftest.$ac_ext <<_ACEOF
18042 /* confdefs.h.  */
18043 _ACEOF
18044 cat confdefs.h >>conftest.$ac_ext
18045 cat >>conftest.$ac_ext <<_ACEOF
18046 /* end confdefs.h.  */
18047
18048 /* Override any gcc2 internal prototype to avoid an error.  */
18049 #ifdef __cplusplus
18050 extern "C"
18051 #endif
18052 /* We use char because int might match the return type of a gcc2
18053    builtin and then its argument prototype would still apply.  */
18054 char j1f ();
18055 int
18056 main ()
18057 {
18058 j1f ();
18059   ;
18060   return 0;
18061 }
18062 _ACEOF
18063 rm -f conftest.$ac_objext conftest$ac_exeext
18064 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18065   (eval $ac_link) 2>conftest.er1
18066   ac_status=$?
18067   grep -v '^ *+' conftest.er1 >conftest.err
18068   rm -f conftest.er1
18069   cat conftest.err >&5
18070   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18071   (exit $ac_status); } &&
18072          { ac_try='test -z "$ac_c_werror_flag"
18073                          || test ! -s conftest.err'
18074   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18075   (eval $ac_try) 2>&5
18076   ac_status=$?
18077   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18078   (exit $ac_status); }; } &&
18079          { ac_try='test -s conftest$ac_exeext'
18080   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18081   (eval $ac_try) 2>&5
18082   ac_status=$?
18083   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18084   (exit $ac_status); }; }; then
18085   ac_cv_lib_m_j1f=yes
18086 else
18087   echo "$as_me: failed program was:" >&5
18088 sed 's/^/| /' conftest.$ac_ext >&5
18089
18090 ac_cv_lib_m_j1f=no
18091 fi
18092 rm -f conftest.err conftest.$ac_objext \
18093       conftest$ac_exeext conftest.$ac_ext
18094 LIBS=$ac_check_lib_save_LIBS
18095 fi
18096 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1f" >&5
18097 echo "${ECHO_T}$ac_cv_lib_m_j1f" >&6
18098 if test $ac_cv_lib_m_j1f = yes; then
18099
18100 cat >>confdefs.h <<\_ACEOF
18101 #define HAVE_J1F 1
18102 _ACEOF
18103
18104 fi
18105
18106 echo "$as_me:$LINENO: checking for j1 in -lm" >&5
18107 echo $ECHO_N "checking for j1 in -lm... $ECHO_C" >&6
18108 if test "${ac_cv_lib_m_j1+set}" = set; then
18109   echo $ECHO_N "(cached) $ECHO_C" >&6
18110 else
18111   ac_check_lib_save_LIBS=$LIBS
18112 LIBS="-lm  $LIBS"
18113 if test x$gcc_no_link = xyes; then
18114   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18115 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18116    { (exit 1); exit 1; }; }
18117 fi
18118 cat >conftest.$ac_ext <<_ACEOF
18119 /* confdefs.h.  */
18120 _ACEOF
18121 cat confdefs.h >>conftest.$ac_ext
18122 cat >>conftest.$ac_ext <<_ACEOF
18123 /* end confdefs.h.  */
18124
18125 /* Override any gcc2 internal prototype to avoid an error.  */
18126 #ifdef __cplusplus
18127 extern "C"
18128 #endif
18129 /* We use char because int might match the return type of a gcc2
18130    builtin and then its argument prototype would still apply.  */
18131 char j1 ();
18132 int
18133 main ()
18134 {
18135 j1 ();
18136   ;
18137   return 0;
18138 }
18139 _ACEOF
18140 rm -f conftest.$ac_objext conftest$ac_exeext
18141 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18142   (eval $ac_link) 2>conftest.er1
18143   ac_status=$?
18144   grep -v '^ *+' conftest.er1 >conftest.err
18145   rm -f conftest.er1
18146   cat conftest.err >&5
18147   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18148   (exit $ac_status); } &&
18149          { ac_try='test -z "$ac_c_werror_flag"
18150                          || test ! -s conftest.err'
18151   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18152   (eval $ac_try) 2>&5
18153   ac_status=$?
18154   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18155   (exit $ac_status); }; } &&
18156          { ac_try='test -s conftest$ac_exeext'
18157   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18158   (eval $ac_try) 2>&5
18159   ac_status=$?
18160   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18161   (exit $ac_status); }; }; then
18162   ac_cv_lib_m_j1=yes
18163 else
18164   echo "$as_me: failed program was:" >&5
18165 sed 's/^/| /' conftest.$ac_ext >&5
18166
18167 ac_cv_lib_m_j1=no
18168 fi
18169 rm -f conftest.err conftest.$ac_objext \
18170       conftest$ac_exeext conftest.$ac_ext
18171 LIBS=$ac_check_lib_save_LIBS
18172 fi
18173 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1" >&5
18174 echo "${ECHO_T}$ac_cv_lib_m_j1" >&6
18175 if test $ac_cv_lib_m_j1 = yes; then
18176
18177 cat >>confdefs.h <<\_ACEOF
18178 #define HAVE_J1 1
18179 _ACEOF
18180
18181 fi
18182
18183 echo "$as_me:$LINENO: checking for j1l in -lm" >&5
18184 echo $ECHO_N "checking for j1l in -lm... $ECHO_C" >&6
18185 if test "${ac_cv_lib_m_j1l+set}" = set; then
18186   echo $ECHO_N "(cached) $ECHO_C" >&6
18187 else
18188   ac_check_lib_save_LIBS=$LIBS
18189 LIBS="-lm  $LIBS"
18190 if test x$gcc_no_link = xyes; then
18191   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18192 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18193    { (exit 1); exit 1; }; }
18194 fi
18195 cat >conftest.$ac_ext <<_ACEOF
18196 /* confdefs.h.  */
18197 _ACEOF
18198 cat confdefs.h >>conftest.$ac_ext
18199 cat >>conftest.$ac_ext <<_ACEOF
18200 /* end confdefs.h.  */
18201
18202 /* Override any gcc2 internal prototype to avoid an error.  */
18203 #ifdef __cplusplus
18204 extern "C"
18205 #endif
18206 /* We use char because int might match the return type of a gcc2
18207    builtin and then its argument prototype would still apply.  */
18208 char j1l ();
18209 int
18210 main ()
18211 {
18212 j1l ();
18213   ;
18214   return 0;
18215 }
18216 _ACEOF
18217 rm -f conftest.$ac_objext conftest$ac_exeext
18218 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18219   (eval $ac_link) 2>conftest.er1
18220   ac_status=$?
18221   grep -v '^ *+' conftest.er1 >conftest.err
18222   rm -f conftest.er1
18223   cat conftest.err >&5
18224   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18225   (exit $ac_status); } &&
18226          { ac_try='test -z "$ac_c_werror_flag"
18227                          || test ! -s conftest.err'
18228   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18229   (eval $ac_try) 2>&5
18230   ac_status=$?
18231   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18232   (exit $ac_status); }; } &&
18233          { ac_try='test -s conftest$ac_exeext'
18234   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18235   (eval $ac_try) 2>&5
18236   ac_status=$?
18237   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18238   (exit $ac_status); }; }; then
18239   ac_cv_lib_m_j1l=yes
18240 else
18241   echo "$as_me: failed program was:" >&5
18242 sed 's/^/| /' conftest.$ac_ext >&5
18243
18244 ac_cv_lib_m_j1l=no
18245 fi
18246 rm -f conftest.err conftest.$ac_objext \
18247       conftest$ac_exeext conftest.$ac_ext
18248 LIBS=$ac_check_lib_save_LIBS
18249 fi
18250 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1l" >&5
18251 echo "${ECHO_T}$ac_cv_lib_m_j1l" >&6
18252 if test $ac_cv_lib_m_j1l = yes; then
18253
18254 cat >>confdefs.h <<\_ACEOF
18255 #define HAVE_J1L 1
18256 _ACEOF
18257
18258 fi
18259
18260 echo "$as_me:$LINENO: checking for jnf in -lm" >&5
18261 echo $ECHO_N "checking for jnf in -lm... $ECHO_C" >&6
18262 if test "${ac_cv_lib_m_jnf+set}" = set; then
18263   echo $ECHO_N "(cached) $ECHO_C" >&6
18264 else
18265   ac_check_lib_save_LIBS=$LIBS
18266 LIBS="-lm  $LIBS"
18267 if test x$gcc_no_link = xyes; then
18268   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18269 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18270    { (exit 1); exit 1; }; }
18271 fi
18272 cat >conftest.$ac_ext <<_ACEOF
18273 /* confdefs.h.  */
18274 _ACEOF
18275 cat confdefs.h >>conftest.$ac_ext
18276 cat >>conftest.$ac_ext <<_ACEOF
18277 /* end confdefs.h.  */
18278
18279 /* Override any gcc2 internal prototype to avoid an error.  */
18280 #ifdef __cplusplus
18281 extern "C"
18282 #endif
18283 /* We use char because int might match the return type of a gcc2
18284    builtin and then its argument prototype would still apply.  */
18285 char jnf ();
18286 int
18287 main ()
18288 {
18289 jnf ();
18290   ;
18291   return 0;
18292 }
18293 _ACEOF
18294 rm -f conftest.$ac_objext conftest$ac_exeext
18295 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18296   (eval $ac_link) 2>conftest.er1
18297   ac_status=$?
18298   grep -v '^ *+' conftest.er1 >conftest.err
18299   rm -f conftest.er1
18300   cat conftest.err >&5
18301   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18302   (exit $ac_status); } &&
18303          { ac_try='test -z "$ac_c_werror_flag"
18304                          || test ! -s conftest.err'
18305   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18306   (eval $ac_try) 2>&5
18307   ac_status=$?
18308   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18309   (exit $ac_status); }; } &&
18310          { ac_try='test -s conftest$ac_exeext'
18311   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18312   (eval $ac_try) 2>&5
18313   ac_status=$?
18314   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18315   (exit $ac_status); }; }; then
18316   ac_cv_lib_m_jnf=yes
18317 else
18318   echo "$as_me: failed program was:" >&5
18319 sed 's/^/| /' conftest.$ac_ext >&5
18320
18321 ac_cv_lib_m_jnf=no
18322 fi
18323 rm -f conftest.err conftest.$ac_objext \
18324       conftest$ac_exeext conftest.$ac_ext
18325 LIBS=$ac_check_lib_save_LIBS
18326 fi
18327 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jnf" >&5
18328 echo "${ECHO_T}$ac_cv_lib_m_jnf" >&6
18329 if test $ac_cv_lib_m_jnf = yes; then
18330
18331 cat >>confdefs.h <<\_ACEOF
18332 #define HAVE_JNF 1
18333 _ACEOF
18334
18335 fi
18336
18337 echo "$as_me:$LINENO: checking for jn in -lm" >&5
18338 echo $ECHO_N "checking for jn in -lm... $ECHO_C" >&6
18339 if test "${ac_cv_lib_m_jn+set}" = set; then
18340   echo $ECHO_N "(cached) $ECHO_C" >&6
18341 else
18342   ac_check_lib_save_LIBS=$LIBS
18343 LIBS="-lm  $LIBS"
18344 if test x$gcc_no_link = xyes; then
18345   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18346 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18347    { (exit 1); exit 1; }; }
18348 fi
18349 cat >conftest.$ac_ext <<_ACEOF
18350 /* confdefs.h.  */
18351 _ACEOF
18352 cat confdefs.h >>conftest.$ac_ext
18353 cat >>conftest.$ac_ext <<_ACEOF
18354 /* end confdefs.h.  */
18355
18356 /* Override any gcc2 internal prototype to avoid an error.  */
18357 #ifdef __cplusplus
18358 extern "C"
18359 #endif
18360 /* We use char because int might match the return type of a gcc2
18361    builtin and then its argument prototype would still apply.  */
18362 char jn ();
18363 int
18364 main ()
18365 {
18366 jn ();
18367   ;
18368   return 0;
18369 }
18370 _ACEOF
18371 rm -f conftest.$ac_objext conftest$ac_exeext
18372 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18373   (eval $ac_link) 2>conftest.er1
18374   ac_status=$?
18375   grep -v '^ *+' conftest.er1 >conftest.err
18376   rm -f conftest.er1
18377   cat conftest.err >&5
18378   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18379   (exit $ac_status); } &&
18380          { ac_try='test -z "$ac_c_werror_flag"
18381                          || test ! -s conftest.err'
18382   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18383   (eval $ac_try) 2>&5
18384   ac_status=$?
18385   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18386   (exit $ac_status); }; } &&
18387          { ac_try='test -s conftest$ac_exeext'
18388   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18389   (eval $ac_try) 2>&5
18390   ac_status=$?
18391   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18392   (exit $ac_status); }; }; then
18393   ac_cv_lib_m_jn=yes
18394 else
18395   echo "$as_me: failed program was:" >&5
18396 sed 's/^/| /' conftest.$ac_ext >&5
18397
18398 ac_cv_lib_m_jn=no
18399 fi
18400 rm -f conftest.err conftest.$ac_objext \
18401       conftest$ac_exeext conftest.$ac_ext
18402 LIBS=$ac_check_lib_save_LIBS
18403 fi
18404 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jn" >&5
18405 echo "${ECHO_T}$ac_cv_lib_m_jn" >&6
18406 if test $ac_cv_lib_m_jn = yes; then
18407
18408 cat >>confdefs.h <<\_ACEOF
18409 #define HAVE_JN 1
18410 _ACEOF
18411
18412 fi
18413
18414 echo "$as_me:$LINENO: checking for jnl in -lm" >&5
18415 echo $ECHO_N "checking for jnl in -lm... $ECHO_C" >&6
18416 if test "${ac_cv_lib_m_jnl+set}" = set; then
18417   echo $ECHO_N "(cached) $ECHO_C" >&6
18418 else
18419   ac_check_lib_save_LIBS=$LIBS
18420 LIBS="-lm  $LIBS"
18421 if test x$gcc_no_link = xyes; then
18422   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18423 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18424    { (exit 1); exit 1; }; }
18425 fi
18426 cat >conftest.$ac_ext <<_ACEOF
18427 /* confdefs.h.  */
18428 _ACEOF
18429 cat confdefs.h >>conftest.$ac_ext
18430 cat >>conftest.$ac_ext <<_ACEOF
18431 /* end confdefs.h.  */
18432
18433 /* Override any gcc2 internal prototype to avoid an error.  */
18434 #ifdef __cplusplus
18435 extern "C"
18436 #endif
18437 /* We use char because int might match the return type of a gcc2
18438    builtin and then its argument prototype would still apply.  */
18439 char jnl ();
18440 int
18441 main ()
18442 {
18443 jnl ();
18444   ;
18445   return 0;
18446 }
18447 _ACEOF
18448 rm -f conftest.$ac_objext conftest$ac_exeext
18449 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18450   (eval $ac_link) 2>conftest.er1
18451   ac_status=$?
18452   grep -v '^ *+' conftest.er1 >conftest.err
18453   rm -f conftest.er1
18454   cat conftest.err >&5
18455   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18456   (exit $ac_status); } &&
18457          { ac_try='test -z "$ac_c_werror_flag"
18458                          || test ! -s conftest.err'
18459   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18460   (eval $ac_try) 2>&5
18461   ac_status=$?
18462   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18463   (exit $ac_status); }; } &&
18464          { ac_try='test -s conftest$ac_exeext'
18465   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18466   (eval $ac_try) 2>&5
18467   ac_status=$?
18468   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18469   (exit $ac_status); }; }; then
18470   ac_cv_lib_m_jnl=yes
18471 else
18472   echo "$as_me: failed program was:" >&5
18473 sed 's/^/| /' conftest.$ac_ext >&5
18474
18475 ac_cv_lib_m_jnl=no
18476 fi
18477 rm -f conftest.err conftest.$ac_objext \
18478       conftest$ac_exeext conftest.$ac_ext
18479 LIBS=$ac_check_lib_save_LIBS
18480 fi
18481 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jnl" >&5
18482 echo "${ECHO_T}$ac_cv_lib_m_jnl" >&6
18483 if test $ac_cv_lib_m_jnl = yes; then
18484
18485 cat >>confdefs.h <<\_ACEOF
18486 #define HAVE_JNL 1
18487 _ACEOF
18488
18489 fi
18490
18491 echo "$as_me:$LINENO: checking for y0f in -lm" >&5
18492 echo $ECHO_N "checking for y0f in -lm... $ECHO_C" >&6
18493 if test "${ac_cv_lib_m_y0f+set}" = set; then
18494   echo $ECHO_N "(cached) $ECHO_C" >&6
18495 else
18496   ac_check_lib_save_LIBS=$LIBS
18497 LIBS="-lm  $LIBS"
18498 if test x$gcc_no_link = xyes; then
18499   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18500 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18501    { (exit 1); exit 1; }; }
18502 fi
18503 cat >conftest.$ac_ext <<_ACEOF
18504 /* confdefs.h.  */
18505 _ACEOF
18506 cat confdefs.h >>conftest.$ac_ext
18507 cat >>conftest.$ac_ext <<_ACEOF
18508 /* end confdefs.h.  */
18509
18510 /* Override any gcc2 internal prototype to avoid an error.  */
18511 #ifdef __cplusplus
18512 extern "C"
18513 #endif
18514 /* We use char because int might match the return type of a gcc2
18515    builtin and then its argument prototype would still apply.  */
18516 char y0f ();
18517 int
18518 main ()
18519 {
18520 y0f ();
18521   ;
18522   return 0;
18523 }
18524 _ACEOF
18525 rm -f conftest.$ac_objext conftest$ac_exeext
18526 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18527   (eval $ac_link) 2>conftest.er1
18528   ac_status=$?
18529   grep -v '^ *+' conftest.er1 >conftest.err
18530   rm -f conftest.er1
18531   cat conftest.err >&5
18532   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18533   (exit $ac_status); } &&
18534          { ac_try='test -z "$ac_c_werror_flag"
18535                          || test ! -s conftest.err'
18536   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18537   (eval $ac_try) 2>&5
18538   ac_status=$?
18539   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18540   (exit $ac_status); }; } &&
18541          { ac_try='test -s conftest$ac_exeext'
18542   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18543   (eval $ac_try) 2>&5
18544   ac_status=$?
18545   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18546   (exit $ac_status); }; }; then
18547   ac_cv_lib_m_y0f=yes
18548 else
18549   echo "$as_me: failed program was:" >&5
18550 sed 's/^/| /' conftest.$ac_ext >&5
18551
18552 ac_cv_lib_m_y0f=no
18553 fi
18554 rm -f conftest.err conftest.$ac_objext \
18555       conftest$ac_exeext conftest.$ac_ext
18556 LIBS=$ac_check_lib_save_LIBS
18557 fi
18558 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0f" >&5
18559 echo "${ECHO_T}$ac_cv_lib_m_y0f" >&6
18560 if test $ac_cv_lib_m_y0f = yes; then
18561
18562 cat >>confdefs.h <<\_ACEOF
18563 #define HAVE_Y0F 1
18564 _ACEOF
18565
18566 fi
18567
18568 echo "$as_me:$LINENO: checking for y0 in -lm" >&5
18569 echo $ECHO_N "checking for y0 in -lm... $ECHO_C" >&6
18570 if test "${ac_cv_lib_m_y0+set}" = set; then
18571   echo $ECHO_N "(cached) $ECHO_C" >&6
18572 else
18573   ac_check_lib_save_LIBS=$LIBS
18574 LIBS="-lm  $LIBS"
18575 if test x$gcc_no_link = xyes; then
18576   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18577 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18578    { (exit 1); exit 1; }; }
18579 fi
18580 cat >conftest.$ac_ext <<_ACEOF
18581 /* confdefs.h.  */
18582 _ACEOF
18583 cat confdefs.h >>conftest.$ac_ext
18584 cat >>conftest.$ac_ext <<_ACEOF
18585 /* end confdefs.h.  */
18586
18587 /* Override any gcc2 internal prototype to avoid an error.  */
18588 #ifdef __cplusplus
18589 extern "C"
18590 #endif
18591 /* We use char because int might match the return type of a gcc2
18592    builtin and then its argument prototype would still apply.  */
18593 char y0 ();
18594 int
18595 main ()
18596 {
18597 y0 ();
18598   ;
18599   return 0;
18600 }
18601 _ACEOF
18602 rm -f conftest.$ac_objext conftest$ac_exeext
18603 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18604   (eval $ac_link) 2>conftest.er1
18605   ac_status=$?
18606   grep -v '^ *+' conftest.er1 >conftest.err
18607   rm -f conftest.er1
18608   cat conftest.err >&5
18609   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18610   (exit $ac_status); } &&
18611          { ac_try='test -z "$ac_c_werror_flag"
18612                          || test ! -s conftest.err'
18613   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18614   (eval $ac_try) 2>&5
18615   ac_status=$?
18616   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18617   (exit $ac_status); }; } &&
18618          { ac_try='test -s conftest$ac_exeext'
18619   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18620   (eval $ac_try) 2>&5
18621   ac_status=$?
18622   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18623   (exit $ac_status); }; }; then
18624   ac_cv_lib_m_y0=yes
18625 else
18626   echo "$as_me: failed program was:" >&5
18627 sed 's/^/| /' conftest.$ac_ext >&5
18628
18629 ac_cv_lib_m_y0=no
18630 fi
18631 rm -f conftest.err conftest.$ac_objext \
18632       conftest$ac_exeext conftest.$ac_ext
18633 LIBS=$ac_check_lib_save_LIBS
18634 fi
18635 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0" >&5
18636 echo "${ECHO_T}$ac_cv_lib_m_y0" >&6
18637 if test $ac_cv_lib_m_y0 = yes; then
18638
18639 cat >>confdefs.h <<\_ACEOF
18640 #define HAVE_Y0 1
18641 _ACEOF
18642
18643 fi
18644
18645 echo "$as_me:$LINENO: checking for y0l in -lm" >&5
18646 echo $ECHO_N "checking for y0l in -lm... $ECHO_C" >&6
18647 if test "${ac_cv_lib_m_y0l+set}" = set; then
18648   echo $ECHO_N "(cached) $ECHO_C" >&6
18649 else
18650   ac_check_lib_save_LIBS=$LIBS
18651 LIBS="-lm  $LIBS"
18652 if test x$gcc_no_link = xyes; then
18653   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18654 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18655    { (exit 1); exit 1; }; }
18656 fi
18657 cat >conftest.$ac_ext <<_ACEOF
18658 /* confdefs.h.  */
18659 _ACEOF
18660 cat confdefs.h >>conftest.$ac_ext
18661 cat >>conftest.$ac_ext <<_ACEOF
18662 /* end confdefs.h.  */
18663
18664 /* Override any gcc2 internal prototype to avoid an error.  */
18665 #ifdef __cplusplus
18666 extern "C"
18667 #endif
18668 /* We use char because int might match the return type of a gcc2
18669    builtin and then its argument prototype would still apply.  */
18670 char y0l ();
18671 int
18672 main ()
18673 {
18674 y0l ();
18675   ;
18676   return 0;
18677 }
18678 _ACEOF
18679 rm -f conftest.$ac_objext conftest$ac_exeext
18680 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18681   (eval $ac_link) 2>conftest.er1
18682   ac_status=$?
18683   grep -v '^ *+' conftest.er1 >conftest.err
18684   rm -f conftest.er1
18685   cat conftest.err >&5
18686   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18687   (exit $ac_status); } &&
18688          { ac_try='test -z "$ac_c_werror_flag"
18689                          || test ! -s conftest.err'
18690   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18691   (eval $ac_try) 2>&5
18692   ac_status=$?
18693   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18694   (exit $ac_status); }; } &&
18695          { ac_try='test -s conftest$ac_exeext'
18696   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18697   (eval $ac_try) 2>&5
18698   ac_status=$?
18699   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18700   (exit $ac_status); }; }; then
18701   ac_cv_lib_m_y0l=yes
18702 else
18703   echo "$as_me: failed program was:" >&5
18704 sed 's/^/| /' conftest.$ac_ext >&5
18705
18706 ac_cv_lib_m_y0l=no
18707 fi
18708 rm -f conftest.err conftest.$ac_objext \
18709       conftest$ac_exeext conftest.$ac_ext
18710 LIBS=$ac_check_lib_save_LIBS
18711 fi
18712 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0l" >&5
18713 echo "${ECHO_T}$ac_cv_lib_m_y0l" >&6
18714 if test $ac_cv_lib_m_y0l = yes; then
18715
18716 cat >>confdefs.h <<\_ACEOF
18717 #define HAVE_Y0L 1
18718 _ACEOF
18719
18720 fi
18721
18722 echo "$as_me:$LINENO: checking for y1f in -lm" >&5
18723 echo $ECHO_N "checking for y1f in -lm... $ECHO_C" >&6
18724 if test "${ac_cv_lib_m_y1f+set}" = set; then
18725   echo $ECHO_N "(cached) $ECHO_C" >&6
18726 else
18727   ac_check_lib_save_LIBS=$LIBS
18728 LIBS="-lm  $LIBS"
18729 if test x$gcc_no_link = xyes; then
18730   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18731 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18732    { (exit 1); exit 1; }; }
18733 fi
18734 cat >conftest.$ac_ext <<_ACEOF
18735 /* confdefs.h.  */
18736 _ACEOF
18737 cat confdefs.h >>conftest.$ac_ext
18738 cat >>conftest.$ac_ext <<_ACEOF
18739 /* end confdefs.h.  */
18740
18741 /* Override any gcc2 internal prototype to avoid an error.  */
18742 #ifdef __cplusplus
18743 extern "C"
18744 #endif
18745 /* We use char because int might match the return type of a gcc2
18746    builtin and then its argument prototype would still apply.  */
18747 char y1f ();
18748 int
18749 main ()
18750 {
18751 y1f ();
18752   ;
18753   return 0;
18754 }
18755 _ACEOF
18756 rm -f conftest.$ac_objext conftest$ac_exeext
18757 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18758   (eval $ac_link) 2>conftest.er1
18759   ac_status=$?
18760   grep -v '^ *+' conftest.er1 >conftest.err
18761   rm -f conftest.er1
18762   cat conftest.err >&5
18763   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18764   (exit $ac_status); } &&
18765          { ac_try='test -z "$ac_c_werror_flag"
18766                          || test ! -s conftest.err'
18767   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18768   (eval $ac_try) 2>&5
18769   ac_status=$?
18770   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18771   (exit $ac_status); }; } &&
18772          { ac_try='test -s conftest$ac_exeext'
18773   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18774   (eval $ac_try) 2>&5
18775   ac_status=$?
18776   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18777   (exit $ac_status); }; }; then
18778   ac_cv_lib_m_y1f=yes
18779 else
18780   echo "$as_me: failed program was:" >&5
18781 sed 's/^/| /' conftest.$ac_ext >&5
18782
18783 ac_cv_lib_m_y1f=no
18784 fi
18785 rm -f conftest.err conftest.$ac_objext \
18786       conftest$ac_exeext conftest.$ac_ext
18787 LIBS=$ac_check_lib_save_LIBS
18788 fi
18789 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1f" >&5
18790 echo "${ECHO_T}$ac_cv_lib_m_y1f" >&6
18791 if test $ac_cv_lib_m_y1f = yes; then
18792
18793 cat >>confdefs.h <<\_ACEOF
18794 #define HAVE_Y1F 1
18795 _ACEOF
18796
18797 fi
18798
18799 echo "$as_me:$LINENO: checking for y1 in -lm" >&5
18800 echo $ECHO_N "checking for y1 in -lm... $ECHO_C" >&6
18801 if test "${ac_cv_lib_m_y1+set}" = set; then
18802   echo $ECHO_N "(cached) $ECHO_C" >&6
18803 else
18804   ac_check_lib_save_LIBS=$LIBS
18805 LIBS="-lm  $LIBS"
18806 if test x$gcc_no_link = xyes; then
18807   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18808 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18809    { (exit 1); exit 1; }; }
18810 fi
18811 cat >conftest.$ac_ext <<_ACEOF
18812 /* confdefs.h.  */
18813 _ACEOF
18814 cat confdefs.h >>conftest.$ac_ext
18815 cat >>conftest.$ac_ext <<_ACEOF
18816 /* end confdefs.h.  */
18817
18818 /* Override any gcc2 internal prototype to avoid an error.  */
18819 #ifdef __cplusplus
18820 extern "C"
18821 #endif
18822 /* We use char because int might match the return type of a gcc2
18823    builtin and then its argument prototype would still apply.  */
18824 char y1 ();
18825 int
18826 main ()
18827 {
18828 y1 ();
18829   ;
18830   return 0;
18831 }
18832 _ACEOF
18833 rm -f conftest.$ac_objext conftest$ac_exeext
18834 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18835   (eval $ac_link) 2>conftest.er1
18836   ac_status=$?
18837   grep -v '^ *+' conftest.er1 >conftest.err
18838   rm -f conftest.er1
18839   cat conftest.err >&5
18840   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18841   (exit $ac_status); } &&
18842          { ac_try='test -z "$ac_c_werror_flag"
18843                          || test ! -s conftest.err'
18844   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18845   (eval $ac_try) 2>&5
18846   ac_status=$?
18847   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18848   (exit $ac_status); }; } &&
18849          { ac_try='test -s conftest$ac_exeext'
18850   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18851   (eval $ac_try) 2>&5
18852   ac_status=$?
18853   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18854   (exit $ac_status); }; }; then
18855   ac_cv_lib_m_y1=yes
18856 else
18857   echo "$as_me: failed program was:" >&5
18858 sed 's/^/| /' conftest.$ac_ext >&5
18859
18860 ac_cv_lib_m_y1=no
18861 fi
18862 rm -f conftest.err conftest.$ac_objext \
18863       conftest$ac_exeext conftest.$ac_ext
18864 LIBS=$ac_check_lib_save_LIBS
18865 fi
18866 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1" >&5
18867 echo "${ECHO_T}$ac_cv_lib_m_y1" >&6
18868 if test $ac_cv_lib_m_y1 = yes; then
18869
18870 cat >>confdefs.h <<\_ACEOF
18871 #define HAVE_Y1 1
18872 _ACEOF
18873
18874 fi
18875
18876 echo "$as_me:$LINENO: checking for y1l in -lm" >&5
18877 echo $ECHO_N "checking for y1l in -lm... $ECHO_C" >&6
18878 if test "${ac_cv_lib_m_y1l+set}" = set; then
18879   echo $ECHO_N "(cached) $ECHO_C" >&6
18880 else
18881   ac_check_lib_save_LIBS=$LIBS
18882 LIBS="-lm  $LIBS"
18883 if test x$gcc_no_link = xyes; then
18884   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18885 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18886    { (exit 1); exit 1; }; }
18887 fi
18888 cat >conftest.$ac_ext <<_ACEOF
18889 /* confdefs.h.  */
18890 _ACEOF
18891 cat confdefs.h >>conftest.$ac_ext
18892 cat >>conftest.$ac_ext <<_ACEOF
18893 /* end confdefs.h.  */
18894
18895 /* Override any gcc2 internal prototype to avoid an error.  */
18896 #ifdef __cplusplus
18897 extern "C"
18898 #endif
18899 /* We use char because int might match the return type of a gcc2
18900    builtin and then its argument prototype would still apply.  */
18901 char y1l ();
18902 int
18903 main ()
18904 {
18905 y1l ();
18906   ;
18907   return 0;
18908 }
18909 _ACEOF
18910 rm -f conftest.$ac_objext conftest$ac_exeext
18911 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18912   (eval $ac_link) 2>conftest.er1
18913   ac_status=$?
18914   grep -v '^ *+' conftest.er1 >conftest.err
18915   rm -f conftest.er1
18916   cat conftest.err >&5
18917   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18918   (exit $ac_status); } &&
18919          { ac_try='test -z "$ac_c_werror_flag"
18920                          || test ! -s conftest.err'
18921   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18922   (eval $ac_try) 2>&5
18923   ac_status=$?
18924   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18925   (exit $ac_status); }; } &&
18926          { ac_try='test -s conftest$ac_exeext'
18927   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18928   (eval $ac_try) 2>&5
18929   ac_status=$?
18930   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18931   (exit $ac_status); }; }; then
18932   ac_cv_lib_m_y1l=yes
18933 else
18934   echo "$as_me: failed program was:" >&5
18935 sed 's/^/| /' conftest.$ac_ext >&5
18936
18937 ac_cv_lib_m_y1l=no
18938 fi
18939 rm -f conftest.err conftest.$ac_objext \
18940       conftest$ac_exeext conftest.$ac_ext
18941 LIBS=$ac_check_lib_save_LIBS
18942 fi
18943 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1l" >&5
18944 echo "${ECHO_T}$ac_cv_lib_m_y1l" >&6
18945 if test $ac_cv_lib_m_y1l = yes; then
18946
18947 cat >>confdefs.h <<\_ACEOF
18948 #define HAVE_Y1L 1
18949 _ACEOF
18950
18951 fi
18952
18953 echo "$as_me:$LINENO: checking for ynf in -lm" >&5
18954 echo $ECHO_N "checking for ynf in -lm... $ECHO_C" >&6
18955 if test "${ac_cv_lib_m_ynf+set}" = set; then
18956   echo $ECHO_N "(cached) $ECHO_C" >&6
18957 else
18958   ac_check_lib_save_LIBS=$LIBS
18959 LIBS="-lm  $LIBS"
18960 if test x$gcc_no_link = xyes; then
18961   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18962 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18963    { (exit 1); exit 1; }; }
18964 fi
18965 cat >conftest.$ac_ext <<_ACEOF
18966 /* confdefs.h.  */
18967 _ACEOF
18968 cat confdefs.h >>conftest.$ac_ext
18969 cat >>conftest.$ac_ext <<_ACEOF
18970 /* end confdefs.h.  */
18971
18972 /* Override any gcc2 internal prototype to avoid an error.  */
18973 #ifdef __cplusplus
18974 extern "C"
18975 #endif
18976 /* We use char because int might match the return type of a gcc2
18977    builtin and then its argument prototype would still apply.  */
18978 char ynf ();
18979 int
18980 main ()
18981 {
18982 ynf ();
18983   ;
18984   return 0;
18985 }
18986 _ACEOF
18987 rm -f conftest.$ac_objext conftest$ac_exeext
18988 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18989   (eval $ac_link) 2>conftest.er1
18990   ac_status=$?
18991   grep -v '^ *+' conftest.er1 >conftest.err
18992   rm -f conftest.er1
18993   cat conftest.err >&5
18994   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18995   (exit $ac_status); } &&
18996          { ac_try='test -z "$ac_c_werror_flag"
18997                          || test ! -s conftest.err'
18998   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18999   (eval $ac_try) 2>&5
19000   ac_status=$?
19001   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19002   (exit $ac_status); }; } &&
19003          { ac_try='test -s conftest$ac_exeext'
19004   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19005   (eval $ac_try) 2>&5
19006   ac_status=$?
19007   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19008   (exit $ac_status); }; }; then
19009   ac_cv_lib_m_ynf=yes
19010 else
19011   echo "$as_me: failed program was:" >&5
19012 sed 's/^/| /' conftest.$ac_ext >&5
19013
19014 ac_cv_lib_m_ynf=no
19015 fi
19016 rm -f conftest.err conftest.$ac_objext \
19017       conftest$ac_exeext conftest.$ac_ext
19018 LIBS=$ac_check_lib_save_LIBS
19019 fi
19020 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ynf" >&5
19021 echo "${ECHO_T}$ac_cv_lib_m_ynf" >&6
19022 if test $ac_cv_lib_m_ynf = yes; then
19023
19024 cat >>confdefs.h <<\_ACEOF
19025 #define HAVE_YNF 1
19026 _ACEOF
19027
19028 fi
19029
19030 echo "$as_me:$LINENO: checking for yn in -lm" >&5
19031 echo $ECHO_N "checking for yn in -lm... $ECHO_C" >&6
19032 if test "${ac_cv_lib_m_yn+set}" = set; then
19033   echo $ECHO_N "(cached) $ECHO_C" >&6
19034 else
19035   ac_check_lib_save_LIBS=$LIBS
19036 LIBS="-lm  $LIBS"
19037 if test x$gcc_no_link = xyes; then
19038   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19039 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19040    { (exit 1); exit 1; }; }
19041 fi
19042 cat >conftest.$ac_ext <<_ACEOF
19043 /* confdefs.h.  */
19044 _ACEOF
19045 cat confdefs.h >>conftest.$ac_ext
19046 cat >>conftest.$ac_ext <<_ACEOF
19047 /* end confdefs.h.  */
19048
19049 /* Override any gcc2 internal prototype to avoid an error.  */
19050 #ifdef __cplusplus
19051 extern "C"
19052 #endif
19053 /* We use char because int might match the return type of a gcc2
19054    builtin and then its argument prototype would still apply.  */
19055 char yn ();
19056 int
19057 main ()
19058 {
19059 yn ();
19060   ;
19061   return 0;
19062 }
19063 _ACEOF
19064 rm -f conftest.$ac_objext conftest$ac_exeext
19065 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19066   (eval $ac_link) 2>conftest.er1
19067   ac_status=$?
19068   grep -v '^ *+' conftest.er1 >conftest.err
19069   rm -f conftest.er1
19070   cat conftest.err >&5
19071   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19072   (exit $ac_status); } &&
19073          { ac_try='test -z "$ac_c_werror_flag"
19074                          || test ! -s conftest.err'
19075   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19076   (eval $ac_try) 2>&5
19077   ac_status=$?
19078   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19079   (exit $ac_status); }; } &&
19080          { ac_try='test -s conftest$ac_exeext'
19081   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19082   (eval $ac_try) 2>&5
19083   ac_status=$?
19084   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19085   (exit $ac_status); }; }; then
19086   ac_cv_lib_m_yn=yes
19087 else
19088   echo "$as_me: failed program was:" >&5
19089 sed 's/^/| /' conftest.$ac_ext >&5
19090
19091 ac_cv_lib_m_yn=no
19092 fi
19093 rm -f conftest.err conftest.$ac_objext \
19094       conftest$ac_exeext conftest.$ac_ext
19095 LIBS=$ac_check_lib_save_LIBS
19096 fi
19097 echo "$as_me:$LINENO: result: $ac_cv_lib_m_yn" >&5
19098 echo "${ECHO_T}$ac_cv_lib_m_yn" >&6
19099 if test $ac_cv_lib_m_yn = yes; then
19100
19101 cat >>confdefs.h <<\_ACEOF
19102 #define HAVE_YN 1
19103 _ACEOF
19104
19105 fi
19106
19107 echo "$as_me:$LINENO: checking for ynl in -lm" >&5
19108 echo $ECHO_N "checking for ynl in -lm... $ECHO_C" >&6
19109 if test "${ac_cv_lib_m_ynl+set}" = set; then
19110   echo $ECHO_N "(cached) $ECHO_C" >&6
19111 else
19112   ac_check_lib_save_LIBS=$LIBS
19113 LIBS="-lm  $LIBS"
19114 if test x$gcc_no_link = xyes; then
19115   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19116 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19117    { (exit 1); exit 1; }; }
19118 fi
19119 cat >conftest.$ac_ext <<_ACEOF
19120 /* confdefs.h.  */
19121 _ACEOF
19122 cat confdefs.h >>conftest.$ac_ext
19123 cat >>conftest.$ac_ext <<_ACEOF
19124 /* end confdefs.h.  */
19125
19126 /* Override any gcc2 internal prototype to avoid an error.  */
19127 #ifdef __cplusplus
19128 extern "C"
19129 #endif
19130 /* We use char because int might match the return type of a gcc2
19131    builtin and then its argument prototype would still apply.  */
19132 char ynl ();
19133 int
19134 main ()
19135 {
19136 ynl ();
19137   ;
19138   return 0;
19139 }
19140 _ACEOF
19141 rm -f conftest.$ac_objext conftest$ac_exeext
19142 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19143   (eval $ac_link) 2>conftest.er1
19144   ac_status=$?
19145   grep -v '^ *+' conftest.er1 >conftest.err
19146   rm -f conftest.er1
19147   cat conftest.err >&5
19148   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19149   (exit $ac_status); } &&
19150          { ac_try='test -z "$ac_c_werror_flag"
19151                          || test ! -s conftest.err'
19152   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19153   (eval $ac_try) 2>&5
19154   ac_status=$?
19155   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19156   (exit $ac_status); }; } &&
19157          { ac_try='test -s conftest$ac_exeext'
19158   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19159   (eval $ac_try) 2>&5
19160   ac_status=$?
19161   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19162   (exit $ac_status); }; }; then
19163   ac_cv_lib_m_ynl=yes
19164 else
19165   echo "$as_me: failed program was:" >&5
19166 sed 's/^/| /' conftest.$ac_ext >&5
19167
19168 ac_cv_lib_m_ynl=no
19169 fi
19170 rm -f conftest.err conftest.$ac_objext \
19171       conftest$ac_exeext conftest.$ac_ext
19172 LIBS=$ac_check_lib_save_LIBS
19173 fi
19174 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ynl" >&5
19175 echo "${ECHO_T}$ac_cv_lib_m_ynl" >&6
19176 if test $ac_cv_lib_m_ynl = yes; then
19177
19178 cat >>confdefs.h <<\_ACEOF
19179 #define HAVE_YNL 1
19180 _ACEOF
19181
19182 fi
19183
19184
19185 # On AIX, clog is present in libm as __clog
19186 echo "$as_me:$LINENO: checking for __clog in -lm" >&5
19187 echo $ECHO_N "checking for __clog in -lm... $ECHO_C" >&6
19188 if test "${ac_cv_lib_m___clog+set}" = set; then
19189   echo $ECHO_N "(cached) $ECHO_C" >&6
19190 else
19191   ac_check_lib_save_LIBS=$LIBS
19192 LIBS="-lm  $LIBS"
19193 if test x$gcc_no_link = xyes; then
19194   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19195 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19196    { (exit 1); exit 1; }; }
19197 fi
19198 cat >conftest.$ac_ext <<_ACEOF
19199 /* confdefs.h.  */
19200 _ACEOF
19201 cat confdefs.h >>conftest.$ac_ext
19202 cat >>conftest.$ac_ext <<_ACEOF
19203 /* end confdefs.h.  */
19204
19205 /* Override any gcc2 internal prototype to avoid an error.  */
19206 #ifdef __cplusplus
19207 extern "C"
19208 #endif
19209 /* We use char because int might match the return type of a gcc2
19210    builtin and then its argument prototype would still apply.  */
19211 char __clog ();
19212 int
19213 main ()
19214 {
19215 __clog ();
19216   ;
19217   return 0;
19218 }
19219 _ACEOF
19220 rm -f conftest.$ac_objext conftest$ac_exeext
19221 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19222   (eval $ac_link) 2>conftest.er1
19223   ac_status=$?
19224   grep -v '^ *+' conftest.er1 >conftest.err
19225   rm -f conftest.er1
19226   cat conftest.err >&5
19227   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19228   (exit $ac_status); } &&
19229          { ac_try='test -z "$ac_c_werror_flag"
19230                          || test ! -s conftest.err'
19231   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19232   (eval $ac_try) 2>&5
19233   ac_status=$?
19234   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19235   (exit $ac_status); }; } &&
19236          { ac_try='test -s conftest$ac_exeext'
19237   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19238   (eval $ac_try) 2>&5
19239   ac_status=$?
19240   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19241   (exit $ac_status); }; }; then
19242   ac_cv_lib_m___clog=yes
19243 else
19244   echo "$as_me: failed program was:" >&5
19245 sed 's/^/| /' conftest.$ac_ext >&5
19246
19247 ac_cv_lib_m___clog=no
19248 fi
19249 rm -f conftest.err conftest.$ac_objext \
19250       conftest$ac_exeext conftest.$ac_ext
19251 LIBS=$ac_check_lib_save_LIBS
19252 fi
19253 echo "$as_me:$LINENO: result: $ac_cv_lib_m___clog" >&5
19254 echo "${ECHO_T}$ac_cv_lib_m___clog" >&6
19255 if test $ac_cv_lib_m___clog = yes; then
19256
19257 cat >>confdefs.h <<\_ACEOF
19258 #define HAVE_CLOG 1
19259 _ACEOF
19260
19261 fi
19262
19263
19264 # Check for a isfinite macro that works on long doubles.
19265
19266   echo "$as_me:$LINENO: checking whether isfinite is broken" >&5
19267 echo $ECHO_N "checking whether isfinite is broken... $ECHO_C" >&6
19268 if test "${have_broken_isfinite+set}" = set; then
19269   echo $ECHO_N "(cached) $ECHO_C" >&6
19270 else
19271
19272   libgfor_check_for_broken_isfinite_save_LIBS=$LIBS
19273   LIBS="$LIBS -lm"
19274   if test "$cross_compiling" = yes; then
19275
19276 case "${target}" in
19277   hppa*-*-hpux*) have_broken_isfinite=yes ;;
19278   *) have_broken_isfinite=no ;;
19279 esac
19280 else
19281   cat >conftest.$ac_ext <<_ACEOF
19282 /* confdefs.h.  */
19283 _ACEOF
19284 cat confdefs.h >>conftest.$ac_ext
19285 cat >>conftest.$ac_ext <<_ACEOF
19286 /* end confdefs.h.  */
19287
19288 #ifdef HAVE_MATH_H
19289 #include <math.h>
19290 #endif
19291 #include <float.h>
19292 int main ()
19293 {
19294 #ifdef isfinite
19295 #ifdef LDBL_MAX
19296   if (!isfinite(LDBL_MAX)) return 1;
19297 #endif
19298 #ifdef DBL_MAX
19299   if (!isfinite(DBL_MAX)) return 1;
19300 #endif
19301 #endif
19302 return 0;
19303 }
19304 _ACEOF
19305 rm -f conftest$ac_exeext
19306 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19307   (eval $ac_link) 2>&5
19308   ac_status=$?
19309   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19310   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
19311   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19312   (eval $ac_try) 2>&5
19313   ac_status=$?
19314   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19315   (exit $ac_status); }; }; then
19316   have_broken_isfinite=no
19317 else
19318   echo "$as_me: program exited with status $ac_status" >&5
19319 echo "$as_me: failed program was:" >&5
19320 sed 's/^/| /' conftest.$ac_ext >&5
19321
19322 ( exit $ac_status )
19323 have_broken_isfinite=yes
19324 fi
19325 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
19326 fi
19327   LIBS=$libgfor_check_for_broken_isfinite_save_LIBS
19328 fi
19329 echo "$as_me:$LINENO: result: $have_broken_isfinite" >&5
19330 echo "${ECHO_T}$have_broken_isfinite" >&6
19331 if test x"$have_broken_isfinite" = xyes; then
19332
19333 cat >>confdefs.h <<\_ACEOF
19334 #define HAVE_BROKEN_ISFINITE 1
19335 _ACEOF
19336
19337 fi
19338
19339 # Check for a isnan macro that works on long doubles.
19340
19341   echo "$as_me:$LINENO: checking whether isnan is broken" >&5
19342 echo $ECHO_N "checking whether isnan is broken... $ECHO_C" >&6
19343 if test "${have_broken_isnan+set}" = set; then
19344   echo $ECHO_N "(cached) $ECHO_C" >&6
19345 else
19346
19347   libgfor_check_for_broken_isnan_save_LIBS=$LIBS
19348   LIBS="$LIBS -lm"
19349   if test "$cross_compiling" = yes; then
19350
19351 case "${target}" in
19352   hppa*-*-hpux*) have_broken_isnan=yes ;;
19353   *) have_broken_isnan=no ;;
19354 esac
19355 else
19356   cat >conftest.$ac_ext <<_ACEOF
19357 /* confdefs.h.  */
19358 _ACEOF
19359 cat confdefs.h >>conftest.$ac_ext
19360 cat >>conftest.$ac_ext <<_ACEOF
19361 /* end confdefs.h.  */
19362
19363 #ifdef HAVE_MATH_H
19364 #include <math.h>
19365 #endif
19366 #include <float.h>
19367 int main ()
19368 {
19369 #ifdef isnan
19370 #ifdef LDBL_MAX
19371   {
19372     long double x;
19373     x = __builtin_nanl ("");
19374     if (!isnan(x)) return 1;
19375     if (isnan(LDBL_MAX)) return 1;
19376 #ifdef NAN
19377     x = (long double) NAN;
19378     if (!isnan(x)) return 1;
19379 #endif
19380   }
19381 #endif
19382 #ifdef DBL_MAX
19383   {
19384     double y;
19385     y = __builtin_nan ("");
19386     if (!isnan(y)) return 1;
19387     if (isnan(DBL_MAX)) return 1;
19388 #ifdef NAN
19389     y = (double) NAN;
19390     if (!isnan(y)) return 1;
19391 #endif
19392   }
19393 #endif
19394 #endif
19395 return 0;
19396 }
19397 _ACEOF
19398 rm -f conftest$ac_exeext
19399 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19400   (eval $ac_link) 2>&5
19401   ac_status=$?
19402   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19403   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
19404   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19405   (eval $ac_try) 2>&5
19406   ac_status=$?
19407   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19408   (exit $ac_status); }; }; then
19409   have_broken_isnan=no
19410 else
19411   echo "$as_me: program exited with status $ac_status" >&5
19412 echo "$as_me: failed program was:" >&5
19413 sed 's/^/| /' conftest.$ac_ext >&5
19414
19415 ( exit $ac_status )
19416 have_broken_isnan=yes
19417 fi
19418 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
19419 fi
19420   LIBS=$libgfor_check_for_broken_isnan_save_LIBS
19421 fi
19422 echo "$as_me:$LINENO: result: $have_broken_isnan" >&5
19423 echo "${ECHO_T}$have_broken_isnan" >&6
19424 if test x"$have_broken_isnan" = xyes; then
19425
19426 cat >>confdefs.h <<\_ACEOF
19427 #define HAVE_BROKEN_ISNAN 1
19428 _ACEOF
19429
19430 fi
19431
19432 # Check for a fpclassify macro that works on long doubles.
19433
19434   echo "$as_me:$LINENO: checking whether fpclassify is broken" >&5
19435 echo $ECHO_N "checking whether fpclassify is broken... $ECHO_C" >&6
19436 if test "${have_broken_fpclassify+set}" = set; then
19437   echo $ECHO_N "(cached) $ECHO_C" >&6
19438 else
19439
19440   libgfor_check_for_broken_fpclassify_save_LIBS=$LIBS
19441   LIBS="$LIBS -lm"
19442   if test "$cross_compiling" = yes; then
19443
19444 case "${target}" in
19445   hppa*-*-hpux*) have_broken_fpclassify=yes ;;
19446   *) have_broken_fpclassify=no ;;
19447 esac
19448 else
19449   cat >conftest.$ac_ext <<_ACEOF
19450 /* confdefs.h.  */
19451 _ACEOF
19452 cat confdefs.h >>conftest.$ac_ext
19453 cat >>conftest.$ac_ext <<_ACEOF
19454 /* end confdefs.h.  */
19455
19456 #ifdef HAVE_MATH_H
19457 #include <math.h>
19458 #endif
19459 #include <float.h>
19460 int main ()
19461 {
19462 #ifdef fpclassify
19463 #ifdef LDBL_MAX
19464         if (fpclassify(LDBL_MAX) == FP_NAN
19465             || fpclassify(LDBL_MAX) == FP_INFINITE) return 1;
19466 #endif
19467 #ifdef DBL_MAX
19468         if (fpclassify(DBL_MAX) == FP_NAN
19469             || fpclassify(DBL_MAX) == FP_INFINITE) return 1;
19470 #endif
19471 #endif
19472 return 0;
19473 }
19474 _ACEOF
19475 rm -f conftest$ac_exeext
19476 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19477   (eval $ac_link) 2>&5
19478   ac_status=$?
19479   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19480   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
19481   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19482   (eval $ac_try) 2>&5
19483   ac_status=$?
19484   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19485   (exit $ac_status); }; }; then
19486   have_broken_fpclassify=no
19487 else
19488   echo "$as_me: program exited with status $ac_status" >&5
19489 echo "$as_me: failed program was:" >&5
19490 sed 's/^/| /' conftest.$ac_ext >&5
19491
19492 ( exit $ac_status )
19493 have_broken_fpclassify=yes
19494 fi
19495 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
19496 fi
19497   LIBS=$libgfor_check_for_broken_fpclassify_save_LIBS
19498 fi
19499 echo "$as_me:$LINENO: result: $have_broken_fpclassify" >&5
19500 echo "${ECHO_T}$have_broken_fpclassify" >&6
19501 if test x"$have_broken_fpclassify" = xyes; then
19502
19503 cat >>confdefs.h <<\_ACEOF
19504 #define HAVE_BROKEN_FPCLASSIFY 1
19505 _ACEOF
19506
19507 fi
19508
19509 # Check whether the system has a working stat()
19510
19511   echo "$as_me:$LINENO: checking whether the target stat is reliable" >&5
19512 echo $ECHO_N "checking whether the target stat is reliable... $ECHO_C" >&6
19513 if test "${have_working_stat+set}" = set; then
19514   echo $ECHO_N "(cached) $ECHO_C" >&6
19515 else
19516
19517   if test "$cross_compiling" = yes; then
19518
19519 case "${target}" in
19520   *mingw*) have_working_stat=no ;;
19521   *) have_working_stat=yes;;
19522 esac
19523 else
19524   cat >conftest.$ac_ext <<_ACEOF
19525 /* confdefs.h.  */
19526 _ACEOF
19527 cat confdefs.h >>conftest.$ac_ext
19528 cat >>conftest.$ac_ext <<_ACEOF
19529 /* end confdefs.h.  */
19530
19531 #include <stdio.h>
19532 #include <sys/types.h>
19533 #include <sys/stat.h>
19534 #include <unistd.h>
19535
19536 int main ()
19537 {
19538   FILE *f, *g;
19539   struct stat st1, st2;
19540
19541   f = fopen ("foo", "w");
19542   g = fopen ("bar", "w");
19543   if (stat ("foo", &st1) != 0 || stat ("bar", &st2))
19544     return 1;
19545   if (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino)
19546     return 1;
19547   fclose(f);
19548   fclose(g);
19549   return 0;
19550 }
19551 _ACEOF
19552 rm -f conftest$ac_exeext
19553 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19554   (eval $ac_link) 2>&5
19555   ac_status=$?
19556   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19557   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
19558   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19559   (eval $ac_try) 2>&5
19560   ac_status=$?
19561   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19562   (exit $ac_status); }; }; then
19563   have_working_stat=yes
19564 else
19565   echo "$as_me: program exited with status $ac_status" >&5
19566 echo "$as_me: failed program was:" >&5
19567 sed 's/^/| /' conftest.$ac_ext >&5
19568
19569 ( exit $ac_status )
19570 have_working_stat=no
19571 fi
19572 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
19573 fi
19574 fi
19575 echo "$as_me:$LINENO: result: $have_working_stat" >&5
19576 echo "${ECHO_T}$have_working_stat" >&6
19577 if test x"$have_working_stat" = xyes; then
19578
19579 cat >>confdefs.h <<\_ACEOF
19580 #define HAVE_WORKING_STAT 1
19581 _ACEOF
19582
19583 fi
19584
19585 # Fallback in case isfinite is not available.
19586 echo "$as_me:$LINENO: checking for finite in -lm" >&5
19587 echo $ECHO_N "checking for finite in -lm... $ECHO_C" >&6
19588 if test "${ac_cv_lib_m_finite+set}" = set; then
19589   echo $ECHO_N "(cached) $ECHO_C" >&6
19590 else
19591   ac_check_lib_save_LIBS=$LIBS
19592 LIBS="-lm  $LIBS"
19593 if test x$gcc_no_link = xyes; then
19594   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19595 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19596    { (exit 1); exit 1; }; }
19597 fi
19598 cat >conftest.$ac_ext <<_ACEOF
19599 /* confdefs.h.  */
19600 _ACEOF
19601 cat confdefs.h >>conftest.$ac_ext
19602 cat >>conftest.$ac_ext <<_ACEOF
19603 /* end confdefs.h.  */
19604
19605 /* Override any gcc2 internal prototype to avoid an error.  */
19606 #ifdef __cplusplus
19607 extern "C"
19608 #endif
19609 /* We use char because int might match the return type of a gcc2
19610    builtin and then its argument prototype would still apply.  */
19611 char finite ();
19612 int
19613 main ()
19614 {
19615 finite ();
19616   ;
19617   return 0;
19618 }
19619 _ACEOF
19620 rm -f conftest.$ac_objext conftest$ac_exeext
19621 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19622   (eval $ac_link) 2>conftest.er1
19623   ac_status=$?
19624   grep -v '^ *+' conftest.er1 >conftest.err
19625   rm -f conftest.er1
19626   cat conftest.err >&5
19627   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19628   (exit $ac_status); } &&
19629          { ac_try='test -z "$ac_c_werror_flag"
19630                          || test ! -s conftest.err'
19631   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19632   (eval $ac_try) 2>&5
19633   ac_status=$?
19634   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19635   (exit $ac_status); }; } &&
19636          { ac_try='test -s conftest$ac_exeext'
19637   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19638   (eval $ac_try) 2>&5
19639   ac_status=$?
19640   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19641   (exit $ac_status); }; }; then
19642   ac_cv_lib_m_finite=yes
19643 else
19644   echo "$as_me: failed program was:" >&5
19645 sed 's/^/| /' conftest.$ac_ext >&5
19646
19647 ac_cv_lib_m_finite=no
19648 fi
19649 rm -f conftest.err conftest.$ac_objext \
19650       conftest$ac_exeext conftest.$ac_ext
19651 LIBS=$ac_check_lib_save_LIBS
19652 fi
19653 echo "$as_me:$LINENO: result: $ac_cv_lib_m_finite" >&5
19654 echo "${ECHO_T}$ac_cv_lib_m_finite" >&6
19655 if test $ac_cv_lib_m_finite = yes; then
19656
19657 cat >>confdefs.h <<\_ACEOF
19658 #define HAVE_FINITE 1
19659 _ACEOF
19660
19661 fi
19662
19663
19664 # Check for GNU libc feenableexcept
19665 echo "$as_me:$LINENO: checking for feenableexcept in -lm" >&5
19666 echo $ECHO_N "checking for feenableexcept in -lm... $ECHO_C" >&6
19667 if test "${ac_cv_lib_m_feenableexcept+set}" = set; then
19668   echo $ECHO_N "(cached) $ECHO_C" >&6
19669 else
19670   ac_check_lib_save_LIBS=$LIBS
19671 LIBS="-lm  $LIBS"
19672 if test x$gcc_no_link = xyes; then
19673   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19674 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19675    { (exit 1); exit 1; }; }
19676 fi
19677 cat >conftest.$ac_ext <<_ACEOF
19678 /* confdefs.h.  */
19679 _ACEOF
19680 cat confdefs.h >>conftest.$ac_ext
19681 cat >>conftest.$ac_ext <<_ACEOF
19682 /* end confdefs.h.  */
19683
19684 /* Override any gcc2 internal prototype to avoid an error.  */
19685 #ifdef __cplusplus
19686 extern "C"
19687 #endif
19688 /* We use char because int might match the return type of a gcc2
19689    builtin and then its argument prototype would still apply.  */
19690 char feenableexcept ();
19691 int
19692 main ()
19693 {
19694 feenableexcept ();
19695   ;
19696   return 0;
19697 }
19698 _ACEOF
19699 rm -f conftest.$ac_objext conftest$ac_exeext
19700 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19701   (eval $ac_link) 2>conftest.er1
19702   ac_status=$?
19703   grep -v '^ *+' conftest.er1 >conftest.err
19704   rm -f conftest.er1
19705   cat conftest.err >&5
19706   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19707   (exit $ac_status); } &&
19708          { ac_try='test -z "$ac_c_werror_flag"
19709                          || test ! -s conftest.err'
19710   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19711   (eval $ac_try) 2>&5
19712   ac_status=$?
19713   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19714   (exit $ac_status); }; } &&
19715          { ac_try='test -s conftest$ac_exeext'
19716   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19717   (eval $ac_try) 2>&5
19718   ac_status=$?
19719   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19720   (exit $ac_status); }; }; then
19721   ac_cv_lib_m_feenableexcept=yes
19722 else
19723   echo "$as_me: failed program was:" >&5
19724 sed 's/^/| /' conftest.$ac_ext >&5
19725
19726 ac_cv_lib_m_feenableexcept=no
19727 fi
19728 rm -f conftest.err conftest.$ac_objext \
19729       conftest$ac_exeext conftest.$ac_ext
19730 LIBS=$ac_check_lib_save_LIBS
19731 fi
19732 echo "$as_me:$LINENO: result: $ac_cv_lib_m_feenableexcept" >&5
19733 echo "${ECHO_T}$ac_cv_lib_m_feenableexcept" >&6
19734 if test $ac_cv_lib_m_feenableexcept = yes; then
19735   have_feenableexcept=yes
19736 cat >>confdefs.h <<\_ACEOF
19737 #define HAVE_FEENABLEEXCEPT 1
19738 _ACEOF
19739
19740 fi
19741
19742
19743 # Check for SysV fpsetmask
19744
19745   echo "$as_me:$LINENO: checking whether fpsetmask is present" >&5
19746 echo $ECHO_N "checking whether fpsetmask is present... $ECHO_C" >&6
19747 if test "${have_fpsetmask+set}" = set; then
19748   echo $ECHO_N "(cached) $ECHO_C" >&6
19749 else
19750
19751     if test x$gcc_no_link = xyes; then
19752   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19753 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19754    { (exit 1); exit 1; }; }
19755 fi
19756 cat >conftest.$ac_ext <<_ACEOF
19757 /* confdefs.h.  */
19758 _ACEOF
19759 cat confdefs.h >>conftest.$ac_ext
19760 cat >>conftest.$ac_ext <<_ACEOF
19761 /* end confdefs.h.  */
19762
19763 #if HAVE_FLOATINGPOINT_H
19764 # include <floatingpoint.h>
19765 #endif /* HAVE_FLOATINGPOINT_H */
19766 #if HAVE_IEEEFP_H
19767 # include <ieeefp.h>
19768 #endif /* HAVE_IEEEFP_H */
19769 int
19770 main ()
19771 {
19772 fpsetmask(0);
19773   ;
19774   return 0;
19775 }
19776 _ACEOF
19777 rm -f conftest.$ac_objext conftest$ac_exeext
19778 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19779   (eval $ac_link) 2>conftest.er1
19780   ac_status=$?
19781   grep -v '^ *+' conftest.er1 >conftest.err
19782   rm -f conftest.er1
19783   cat conftest.err >&5
19784   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19785   (exit $ac_status); } &&
19786          { ac_try='test -z "$ac_c_werror_flag"
19787                          || test ! -s conftest.err'
19788   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19789   (eval $ac_try) 2>&5
19790   ac_status=$?
19791   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19792   (exit $ac_status); }; } &&
19793          { ac_try='test -s conftest$ac_exeext'
19794   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19795   (eval $ac_try) 2>&5
19796   ac_status=$?
19797   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19798   (exit $ac_status); }; }; then
19799   eval "have_fpsetmask=yes"
19800 else
19801   echo "$as_me: failed program was:" >&5
19802 sed 's/^/| /' conftest.$ac_ext >&5
19803
19804 eval "have_fpsetmask=no"
19805 fi
19806 rm -f conftest.err conftest.$ac_objext \
19807       conftest$ac_exeext conftest.$ac_ext
19808
19809 fi
19810 echo "$as_me:$LINENO: result: $have_fpsetmask" >&5
19811 echo "${ECHO_T}$have_fpsetmask" >&6
19812   if test x"$have_fpsetmask" = xyes; then
19813
19814 cat >>confdefs.h <<\_ACEOF
19815 #define HAVE_FPSETMASK 1
19816 _ACEOF
19817
19818   fi
19819
19820
19821 # Check for AIX fp_trap and fp_enable
19822 echo "$as_me:$LINENO: checking for fp_trap" >&5
19823 echo $ECHO_N "checking for fp_trap... $ECHO_C" >&6
19824 if test "${ac_cv_func_fp_trap+set}" = set; then
19825   echo $ECHO_N "(cached) $ECHO_C" >&6
19826 else
19827   if test x$gcc_no_link = xyes; then
19828   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19829 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19830    { (exit 1); exit 1; }; }
19831 fi
19832 cat >conftest.$ac_ext <<_ACEOF
19833 /* confdefs.h.  */
19834 _ACEOF
19835 cat confdefs.h >>conftest.$ac_ext
19836 cat >>conftest.$ac_ext <<_ACEOF
19837 /* end confdefs.h.  */
19838 /* Define fp_trap to an innocuous variant, in case <limits.h> declares fp_trap.
19839    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
19840 #define fp_trap innocuous_fp_trap
19841
19842 /* System header to define __stub macros and hopefully few prototypes,
19843     which can conflict with char fp_trap (); below.
19844     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
19845     <limits.h> exists even on freestanding compilers.  */
19846
19847 #ifdef __STDC__
19848 # include <limits.h>
19849 #else
19850 # include <assert.h>
19851 #endif
19852
19853 #undef fp_trap
19854
19855 /* Override any gcc2 internal prototype to avoid an error.  */
19856 #ifdef __cplusplus
19857 extern "C"
19858 {
19859 #endif
19860 /* We use char because int might match the return type of a gcc2
19861    builtin and then its argument prototype would still apply.  */
19862 char fp_trap ();
19863 /* The GNU C library defines this for functions which it implements
19864     to always fail with ENOSYS.  Some functions are actually named
19865     something starting with __ and the normal name is an alias.  */
19866 #if defined (__stub_fp_trap) || defined (__stub___fp_trap)
19867 choke me
19868 #else
19869 char (*f) () = fp_trap;
19870 #endif
19871 #ifdef __cplusplus
19872 }
19873 #endif
19874
19875 int
19876 main ()
19877 {
19878 return f != fp_trap;
19879   ;
19880   return 0;
19881 }
19882 _ACEOF
19883 rm -f conftest.$ac_objext conftest$ac_exeext
19884 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19885   (eval $ac_link) 2>conftest.er1
19886   ac_status=$?
19887   grep -v '^ *+' conftest.er1 >conftest.err
19888   rm -f conftest.er1
19889   cat conftest.err >&5
19890   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19891   (exit $ac_status); } &&
19892          { ac_try='test -z "$ac_c_werror_flag"
19893                          || test ! -s conftest.err'
19894   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19895   (eval $ac_try) 2>&5
19896   ac_status=$?
19897   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19898   (exit $ac_status); }; } &&
19899          { ac_try='test -s conftest$ac_exeext'
19900   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19901   (eval $ac_try) 2>&5
19902   ac_status=$?
19903   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19904   (exit $ac_status); }; }; then
19905   ac_cv_func_fp_trap=yes
19906 else
19907   echo "$as_me: failed program was:" >&5
19908 sed 's/^/| /' conftest.$ac_ext >&5
19909
19910 ac_cv_func_fp_trap=no
19911 fi
19912 rm -f conftest.err conftest.$ac_objext \
19913       conftest$ac_exeext conftest.$ac_ext
19914 fi
19915 echo "$as_me:$LINENO: result: $ac_cv_func_fp_trap" >&5
19916 echo "${ECHO_T}$ac_cv_func_fp_trap" >&6
19917 if test $ac_cv_func_fp_trap = yes; then
19918   have_fp_trap=yes
19919 cat >>confdefs.h <<\_ACEOF
19920 #define HAVE_FP_TRAP 1
19921 _ACEOF
19922
19923 fi
19924
19925 echo "$as_me:$LINENO: checking for fp_enable" >&5
19926 echo $ECHO_N "checking for fp_enable... $ECHO_C" >&6
19927 if test "${ac_cv_func_fp_enable+set}" = set; then
19928   echo $ECHO_N "(cached) $ECHO_C" >&6
19929 else
19930   if test x$gcc_no_link = xyes; then
19931   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19932 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19933    { (exit 1); exit 1; }; }
19934 fi
19935 cat >conftest.$ac_ext <<_ACEOF
19936 /* confdefs.h.  */
19937 _ACEOF
19938 cat confdefs.h >>conftest.$ac_ext
19939 cat >>conftest.$ac_ext <<_ACEOF
19940 /* end confdefs.h.  */
19941 /* Define fp_enable to an innocuous variant, in case <limits.h> declares fp_enable.
19942    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
19943 #define fp_enable innocuous_fp_enable
19944
19945 /* System header to define __stub macros and hopefully few prototypes,
19946     which can conflict with char fp_enable (); below.
19947     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
19948     <limits.h> exists even on freestanding compilers.  */
19949
19950 #ifdef __STDC__
19951 # include <limits.h>
19952 #else
19953 # include <assert.h>
19954 #endif
19955
19956 #undef fp_enable
19957
19958 /* Override any gcc2 internal prototype to avoid an error.  */
19959 #ifdef __cplusplus
19960 extern "C"
19961 {
19962 #endif
19963 /* We use char because int might match the return type of a gcc2
19964    builtin and then its argument prototype would still apply.  */
19965 char fp_enable ();
19966 /* The GNU C library defines this for functions which it implements
19967     to always fail with ENOSYS.  Some functions are actually named
19968     something starting with __ and the normal name is an alias.  */
19969 #if defined (__stub_fp_enable) || defined (__stub___fp_enable)
19970 choke me
19971 #else
19972 char (*f) () = fp_enable;
19973 #endif
19974 #ifdef __cplusplus
19975 }
19976 #endif
19977
19978 int
19979 main ()
19980 {
19981 return f != fp_enable;
19982   ;
19983   return 0;
19984 }
19985 _ACEOF
19986 rm -f conftest.$ac_objext conftest$ac_exeext
19987 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19988   (eval $ac_link) 2>conftest.er1
19989   ac_status=$?
19990   grep -v '^ *+' conftest.er1 >conftest.err
19991   rm -f conftest.er1
19992   cat conftest.err >&5
19993   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19994   (exit $ac_status); } &&
19995          { ac_try='test -z "$ac_c_werror_flag"
19996                          || test ! -s conftest.err'
19997   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19998   (eval $ac_try) 2>&5
19999   ac_status=$?
20000   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20001   (exit $ac_status); }; } &&
20002          { ac_try='test -s conftest$ac_exeext'
20003   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20004   (eval $ac_try) 2>&5
20005   ac_status=$?
20006   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20007   (exit $ac_status); }; }; then
20008   ac_cv_func_fp_enable=yes
20009 else
20010   echo "$as_me: failed program was:" >&5
20011 sed 's/^/| /' conftest.$ac_ext >&5
20012
20013 ac_cv_func_fp_enable=no
20014 fi
20015 rm -f conftest.err conftest.$ac_objext \
20016       conftest$ac_exeext conftest.$ac_ext
20017 fi
20018 echo "$as_me:$LINENO: result: $ac_cv_func_fp_enable" >&5
20019 echo "${ECHO_T}$ac_cv_func_fp_enable" >&6
20020 if test $ac_cv_func_fp_enable = yes; then
20021   have_fp_enable=yes
20022 cat >>confdefs.h <<\_ACEOF
20023 #define HAVE_FP_ENABLE 1
20024 _ACEOF
20025
20026 fi
20027
20028
20029 # Runs configure.host to set up necessary host-dependent shell variables.
20030 # We then display a message about it, and propagate them through the
20031 # build chain.
20032 . ${srcdir}/configure.host
20033 { echo "$as_me:$LINENO: FPU dependent file will be ${fpu_host}.h" >&5
20034 echo "$as_me: FPU dependent file will be ${fpu_host}.h" >&6;}
20035 FPU_HOST_HEADER=config/${fpu_host}.h
20036
20037
20038 # The standard autoconf HAVE_STRUCT_TIMEZONE doesn't actually check
20039 # for struct timezone, as you might think.  We also need to check how
20040 # to call gettimeofday if we have it.
20041 echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
20042 echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
20043 if test "${ac_cv_header_time+set}" = set; then
20044   echo $ECHO_N "(cached) $ECHO_C" >&6
20045 else
20046   cat >conftest.$ac_ext <<_ACEOF
20047 /* confdefs.h.  */
20048 _ACEOF
20049 cat confdefs.h >>conftest.$ac_ext
20050 cat >>conftest.$ac_ext <<_ACEOF
20051 /* end confdefs.h.  */
20052 #include <sys/types.h>
20053 #include <sys/time.h>
20054 #include <time.h>
20055
20056 int
20057 main ()
20058 {
20059 if ((struct tm *) 0)
20060 return 0;
20061   ;
20062   return 0;
20063 }
20064 _ACEOF
20065 rm -f conftest.$ac_objext
20066 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
20067   (eval $ac_compile) 2>conftest.er1
20068   ac_status=$?
20069   grep -v '^ *+' conftest.er1 >conftest.err
20070   rm -f conftest.er1
20071   cat conftest.err >&5
20072   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20073   (exit $ac_status); } &&
20074          { ac_try='test -z "$ac_c_werror_flag"
20075                          || test ! -s conftest.err'
20076   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20077   (eval $ac_try) 2>&5
20078   ac_status=$?
20079   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20080   (exit $ac_status); }; } &&
20081          { ac_try='test -s conftest.$ac_objext'
20082   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20083   (eval $ac_try) 2>&5
20084   ac_status=$?
20085   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20086   (exit $ac_status); }; }; then
20087   ac_cv_header_time=yes
20088 else
20089   echo "$as_me: failed program was:" >&5
20090 sed 's/^/| /' conftest.$ac_ext >&5
20091
20092 ac_cv_header_time=no
20093 fi
20094 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
20095 fi
20096 echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
20097 echo "${ECHO_T}$ac_cv_header_time" >&6
20098 if test $ac_cv_header_time = yes; then
20099
20100 cat >>confdefs.h <<\_ACEOF
20101 #define TIME_WITH_SYS_TIME 1
20102 _ACEOF
20103
20104 fi
20105
20106
20107
20108 for ac_func in gettimeofday
20109 do
20110 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
20111 echo "$as_me:$LINENO: checking for $ac_func" >&5
20112 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
20113 if eval "test \"\${$as_ac_var+set}\" = set"; then
20114   echo $ECHO_N "(cached) $ECHO_C" >&6
20115 else
20116   if test x$gcc_no_link = xyes; then
20117   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20118 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20119    { (exit 1); exit 1; }; }
20120 fi
20121 cat >conftest.$ac_ext <<_ACEOF
20122 /* confdefs.h.  */
20123 _ACEOF
20124 cat confdefs.h >>conftest.$ac_ext
20125 cat >>conftest.$ac_ext <<_ACEOF
20126 /* end confdefs.h.  */
20127 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
20128    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
20129 #define $ac_func innocuous_$ac_func
20130
20131 /* System header to define __stub macros and hopefully few prototypes,
20132     which can conflict with char $ac_func (); below.
20133     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
20134     <limits.h> exists even on freestanding compilers.  */
20135
20136 #ifdef __STDC__
20137 # include <limits.h>
20138 #else
20139 # include <assert.h>
20140 #endif
20141
20142 #undef $ac_func
20143
20144 /* Override any gcc2 internal prototype to avoid an error.  */
20145 #ifdef __cplusplus
20146 extern "C"
20147 {
20148 #endif
20149 /* We use char because int might match the return type of a gcc2
20150    builtin and then its argument prototype would still apply.  */
20151 char $ac_func ();
20152 /* The GNU C library defines this for functions which it implements
20153     to always fail with ENOSYS.  Some functions are actually named
20154     something starting with __ and the normal name is an alias.  */
20155 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
20156 choke me
20157 #else
20158 char (*f) () = $ac_func;
20159 #endif
20160 #ifdef __cplusplus
20161 }
20162 #endif
20163
20164 int
20165 main ()
20166 {
20167 return f != $ac_func;
20168   ;
20169   return 0;
20170 }
20171 _ACEOF
20172 rm -f conftest.$ac_objext conftest$ac_exeext
20173 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20174   (eval $ac_link) 2>conftest.er1
20175   ac_status=$?
20176   grep -v '^ *+' conftest.er1 >conftest.err
20177   rm -f conftest.er1
20178   cat conftest.err >&5
20179   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20180   (exit $ac_status); } &&
20181          { ac_try='test -z "$ac_c_werror_flag"
20182                          || test ! -s conftest.err'
20183   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20184   (eval $ac_try) 2>&5
20185   ac_status=$?
20186   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20187   (exit $ac_status); }; } &&
20188          { ac_try='test -s conftest$ac_exeext'
20189   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20190   (eval $ac_try) 2>&5
20191   ac_status=$?
20192   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20193   (exit $ac_status); }; }; then
20194   eval "$as_ac_var=yes"
20195 else
20196   echo "$as_me: failed program was:" >&5
20197 sed 's/^/| /' conftest.$ac_ext >&5
20198
20199 eval "$as_ac_var=no"
20200 fi
20201 rm -f conftest.err conftest.$ac_objext \
20202       conftest$ac_exeext conftest.$ac_ext
20203 fi
20204 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
20205 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
20206 if test `eval echo '${'$as_ac_var'}'` = yes; then
20207   cat >>confdefs.h <<_ACEOF
20208 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
20209 _ACEOF
20210
20211 fi
20212 done
20213
20214   if test "$ac_cv_func_gettimeofday" = yes; then
20215     echo "$as_me:$LINENO: checking for struct timezone" >&5
20216 echo $ECHO_N "checking for struct timezone... $ECHO_C" >&6
20217 if test "${gfor_cv_struct_timezone+set}" = set; then
20218   echo $ECHO_N "(cached) $ECHO_C" >&6
20219 else
20220   cat >conftest.$ac_ext <<_ACEOF
20221 /* confdefs.h.  */
20222 _ACEOF
20223 cat confdefs.h >>conftest.$ac_ext
20224 cat >>conftest.$ac_ext <<_ACEOF
20225 /* end confdefs.h.  */
20226 #include <sys/time.h>
20227 int
20228 main ()
20229 {
20230 struct timezone tz;
20231   ;
20232   return 0;
20233 }
20234 _ACEOF
20235 rm -f conftest.$ac_objext
20236 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
20237   (eval $ac_compile) 2>conftest.er1
20238   ac_status=$?
20239   grep -v '^ *+' conftest.er1 >conftest.err
20240   rm -f conftest.er1
20241   cat conftest.err >&5
20242   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20243   (exit $ac_status); } &&
20244          { ac_try='test -z "$ac_c_werror_flag"
20245                          || test ! -s conftest.err'
20246   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20247   (eval $ac_try) 2>&5
20248   ac_status=$?
20249   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20250   (exit $ac_status); }; } &&
20251          { ac_try='test -s conftest.$ac_objext'
20252   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20253   (eval $ac_try) 2>&5
20254   ac_status=$?
20255   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20256   (exit $ac_status); }; }; then
20257   gfor_cv_struct_timezone=yes
20258 else
20259   echo "$as_me: failed program was:" >&5
20260 sed 's/^/| /' conftest.$ac_ext >&5
20261
20262 gfor_cv_struct_timezone=no
20263 fi
20264 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
20265 fi
20266 echo "$as_me:$LINENO: result: $gfor_cv_struct_timezone" >&5
20267 echo "${ECHO_T}$gfor_cv_struct_timezone" >&6
20268     if test $gfor_cv_struct_timezone = yes; then
20269                   if test "$cross_compiling" = yes; then
20270   gfor_have_struct_timezone=yes
20271 else
20272   cat >conftest.$ac_ext <<_ACEOF
20273 /* confdefs.h.  */
20274 _ACEOF
20275 cat confdefs.h >>conftest.$ac_ext
20276 cat >>conftest.$ac_ext <<_ACEOF
20277 /* end confdefs.h.  */
20278
20279 #ifdef TIME_WITH_SYS_TIME
20280 #include <sys/time.h>
20281 #include <time.h>
20282 #else
20283 #ifdef HAVE_SYS_TIME_H
20284 #include <sys/time.h>
20285 #else
20286 #include <time.h>
20287 #endif
20288 #endif
20289 main ()
20290 {
20291   struct timeval time;
20292   struct timezone dummy;
20293   if (gettimeofday (&time, &dummy))
20294     exit (1);
20295   else
20296     exit (0);
20297 }
20298 _ACEOF
20299 rm -f conftest$ac_exeext
20300 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20301   (eval $ac_link) 2>&5
20302   ac_status=$?
20303   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20304   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
20305   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20306   (eval $ac_try) 2>&5
20307   ac_status=$?
20308   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20309   (exit $ac_status); }; }; then
20310   gfor_have_struct_timezone=yes
20311 else
20312   echo "$as_me: program exited with status $ac_status" >&5
20313 echo "$as_me: failed program was:" >&5
20314 sed 's/^/| /' conftest.$ac_ext >&5
20315
20316 ( exit $ac_status )
20317 gfor_have_struct_timezone=no
20318 fi
20319 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
20320 fi
20321       if test $gfor_have_struct_timezone = yes; then
20322
20323 cat >>confdefs.h <<\_ACEOF
20324 #define HAVE_TIMEZONE 1
20325 _ACEOF
20326
20327       fi
20328     fi
20329
20330     echo "$as_me:$LINENO: checking whether gettimeofday can accept two arguments" >&5
20331 echo $ECHO_N "checking whether gettimeofday can accept two arguments... $ECHO_C" >&6
20332 if test "${emacs_cv_gettimeofday_two_arguments+set}" = set; then
20333   echo $ECHO_N "(cached) $ECHO_C" >&6
20334 else
20335   if test x$gcc_no_link = xyes; then
20336   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20337 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20338    { (exit 1); exit 1; }; }
20339 fi
20340 cat >conftest.$ac_ext <<_ACEOF
20341 /* confdefs.h.  */
20342 _ACEOF
20343 cat confdefs.h >>conftest.$ac_ext
20344 cat >>conftest.$ac_ext <<_ACEOF
20345 /* end confdefs.h.  */
20346
20347 #ifdef TIME_WITH_SYS_TIME
20348 #include <sys/time.h>
20349 #include <time.h>
20350 #else
20351 #ifdef HAVE_SYS_TIME_H
20352 #include <sys/time.h>
20353 #else
20354 #include <time.h>
20355 #endif
20356 #endif
20357
20358 int
20359 main ()
20360 {
20361
20362       struct timeval time;
20363 #ifdef HAVE_TIMEZONE
20364       struct timezone dummy;
20365 #define DUMMY &dummy
20366 #else
20367 #define DUMMY NULL
20368 #endif
20369       gettimeofday (&time, DUMMY);
20370   ;
20371   return 0;
20372 }
20373 _ACEOF
20374 rm -f conftest.$ac_objext conftest$ac_exeext
20375 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20376   (eval $ac_link) 2>conftest.er1
20377   ac_status=$?
20378   grep -v '^ *+' conftest.er1 >conftest.err
20379   rm -f conftest.er1
20380   cat conftest.err >&5
20381   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20382   (exit $ac_status); } &&
20383          { ac_try='test -z "$ac_c_werror_flag"
20384                          || test ! -s conftest.err'
20385   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20386   (eval $ac_try) 2>&5
20387   ac_status=$?
20388   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20389   (exit $ac_status); }; } &&
20390          { ac_try='test -s conftest$ac_exeext'
20391   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20392   (eval $ac_try) 2>&5
20393   ac_status=$?
20394   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20395   (exit $ac_status); }; }; then
20396   emacs_cv_gettimeofday_two_arguments=yes
20397 else
20398   echo "$as_me: failed program was:" >&5
20399 sed 's/^/| /' conftest.$ac_ext >&5
20400
20401 emacs_cv_gettimeofday_two_arguments=no
20402 fi
20403 rm -f conftest.err conftest.$ac_objext \
20404       conftest$ac_exeext conftest.$ac_ext
20405 fi
20406 echo "$as_me:$LINENO: result: $emacs_cv_gettimeofday_two_arguments" >&5
20407 echo "${ECHO_T}$emacs_cv_gettimeofday_two_arguments" >&6
20408     if test $emacs_cv_gettimeofday_two_arguments = no; then
20409
20410 cat >>confdefs.h <<\_ACEOF
20411 #define GETTIMEOFDAY_ONE_ARGUMENT 1
20412 _ACEOF
20413
20414     fi
20415   fi
20416
20417 # Attempt to assert that the target is of common type in case we don't
20418 # have C99 integer types at all.
20419
20420   echo "$as_me:$LINENO: checking whether the target is ILP32" >&5
20421 echo $ECHO_N "checking whether the target is ILP32... $ECHO_C" >&6
20422 if test "${target_ilp32+set}" = set; then
20423   echo $ECHO_N "(cached) $ECHO_C" >&6
20424 else
20425
20426   save_CFLAGS="$CFLAGS"
20427   CFLAGS="-O2"
20428   if test x$gcc_no_link = xyes; then
20429   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20430 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20431    { (exit 1); exit 1; }; }
20432 fi
20433 cat >conftest.$ac_ext <<_ACEOF
20434 /* confdefs.h.  */
20435 _ACEOF
20436 cat confdefs.h >>conftest.$ac_ext
20437 cat >>conftest.$ac_ext <<_ACEOF
20438 /* end confdefs.h.  */
20439
20440 int
20441 main ()
20442 {
20443
20444 if (sizeof(int) == 4 && sizeof(long) == 4 && sizeof(void *) == 4)
20445   ;
20446 else
20447   undefined_function ();
20448
20449   ;
20450   return 0;
20451 }
20452 _ACEOF
20453 rm -f conftest.$ac_objext conftest$ac_exeext
20454 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20455   (eval $ac_link) 2>conftest.er1
20456   ac_status=$?
20457   grep -v '^ *+' conftest.er1 >conftest.err
20458   rm -f conftest.er1
20459   cat conftest.err >&5
20460   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20461   (exit $ac_status); } &&
20462          { ac_try='test -z "$ac_c_werror_flag"
20463                          || test ! -s conftest.err'
20464   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20465   (eval $ac_try) 2>&5
20466   ac_status=$?
20467   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20468   (exit $ac_status); }; } &&
20469          { ac_try='test -s conftest$ac_exeext'
20470   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20471   (eval $ac_try) 2>&5
20472   ac_status=$?
20473   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20474   (exit $ac_status); }; }; then
20475   target_ilp32=yes
20476 else
20477   echo "$as_me: failed program was:" >&5
20478 sed 's/^/| /' conftest.$ac_ext >&5
20479
20480 target_ilp32=no
20481 fi
20482 rm -f conftest.err conftest.$ac_objext \
20483       conftest$ac_exeext conftest.$ac_ext
20484   CFLAGS="$save_CFLAGS"
20485 fi
20486 echo "$as_me:$LINENO: result: $target_ilp32" >&5
20487 echo "${ECHO_T}$target_ilp32" >&6
20488   if test $target_ilp32 = yes; then
20489
20490 cat >>confdefs.h <<\_ACEOF
20491 #define TARGET_ILP32 1
20492 _ACEOF
20493
20494   fi
20495
20496
20497 # Check out attribute support.
20498
20499   echo "$as_me:$LINENO: checking whether the target supports hidden visibility" >&5
20500 echo $ECHO_N "checking whether the target supports hidden visibility... $ECHO_C" >&6
20501 if test "${have_attribute_visibility+set}" = set; then
20502   echo $ECHO_N "(cached) $ECHO_C" >&6
20503 else
20504
20505   save_CFLAGS="$CFLAGS"
20506   CFLAGS="$CFLAGS -Werror"
20507   cat >conftest.$ac_ext <<_ACEOF
20508 /* confdefs.h.  */
20509 _ACEOF
20510 cat confdefs.h >>conftest.$ac_ext
20511 cat >>conftest.$ac_ext <<_ACEOF
20512 /* end confdefs.h.  */
20513 void __attribute__((visibility("hidden"))) foo(void) { }
20514 int
20515 main ()
20516 {
20517
20518   ;
20519   return 0;
20520 }
20521 _ACEOF
20522 rm -f conftest.$ac_objext
20523 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
20524   (eval $ac_compile) 2>conftest.er1
20525   ac_status=$?
20526   grep -v '^ *+' conftest.er1 >conftest.err
20527   rm -f conftest.er1
20528   cat conftest.err >&5
20529   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20530   (exit $ac_status); } &&
20531          { ac_try='test -z "$ac_c_werror_flag"
20532                          || test ! -s conftest.err'
20533   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20534   (eval $ac_try) 2>&5
20535   ac_status=$?
20536   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20537   (exit $ac_status); }; } &&
20538          { ac_try='test -s conftest.$ac_objext'
20539   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20540   (eval $ac_try) 2>&5
20541   ac_status=$?
20542   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20543   (exit $ac_status); }; }; then
20544   have_attribute_visibility=yes
20545 else
20546   echo "$as_me: failed program was:" >&5
20547 sed 's/^/| /' conftest.$ac_ext >&5
20548
20549 have_attribute_visibility=no
20550 fi
20551 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
20552   CFLAGS="$save_CFLAGS"
20553 fi
20554 echo "$as_me:$LINENO: result: $have_attribute_visibility" >&5
20555 echo "${ECHO_T}$have_attribute_visibility" >&6
20556   if test $have_attribute_visibility = yes; then
20557
20558 cat >>confdefs.h <<\_ACEOF
20559 #define HAVE_ATTRIBUTE_VISIBILITY 1
20560 _ACEOF
20561
20562   fi
20563
20564   echo "$as_me:$LINENO: checking whether the target supports dllexport" >&5
20565 echo $ECHO_N "checking whether the target supports dllexport... $ECHO_C" >&6
20566 if test "${have_attribute_dllexport+set}" = set; then
20567   echo $ECHO_N "(cached) $ECHO_C" >&6
20568 else
20569
20570   save_CFLAGS="$CFLAGS"
20571   CFLAGS="$CFLAGS -Werror"
20572   cat >conftest.$ac_ext <<_ACEOF
20573 /* confdefs.h.  */
20574 _ACEOF
20575 cat confdefs.h >>conftest.$ac_ext
20576 cat >>conftest.$ac_ext <<_ACEOF
20577 /* end confdefs.h.  */
20578 void __attribute__((dllexport)) foo(void) { }
20579 int
20580 main ()
20581 {
20582
20583   ;
20584   return 0;
20585 }
20586 _ACEOF
20587 rm -f conftest.$ac_objext
20588 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
20589   (eval $ac_compile) 2>conftest.er1
20590   ac_status=$?
20591   grep -v '^ *+' conftest.er1 >conftest.err
20592   rm -f conftest.er1
20593   cat conftest.err >&5
20594   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20595   (exit $ac_status); } &&
20596          { ac_try='test -z "$ac_c_werror_flag"
20597                          || test ! -s conftest.err'
20598   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20599   (eval $ac_try) 2>&5
20600   ac_status=$?
20601   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20602   (exit $ac_status); }; } &&
20603          { ac_try='test -s conftest.$ac_objext'
20604   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20605   (eval $ac_try) 2>&5
20606   ac_status=$?
20607   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20608   (exit $ac_status); }; }; then
20609   have_attribute_dllexport=yes
20610 else
20611   echo "$as_me: failed program was:" >&5
20612 sed 's/^/| /' conftest.$ac_ext >&5
20613
20614 have_attribute_dllexport=no
20615 fi
20616 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
20617   CFLAGS="$save_CFLAGS"
20618 fi
20619 echo "$as_me:$LINENO: result: $have_attribute_dllexport" >&5
20620 echo "${ECHO_T}$have_attribute_dllexport" >&6
20621   if test $have_attribute_dllexport = yes; then
20622
20623 cat >>confdefs.h <<\_ACEOF
20624 #define HAVE_ATTRIBUTE_DLLEXPORT 1
20625 _ACEOF
20626
20627   fi
20628
20629   echo "$as_me:$LINENO: checking whether the target supports symbol aliases" >&5
20630 echo $ECHO_N "checking whether the target supports symbol aliases... $ECHO_C" >&6
20631 if test "${have_attribute_alias+set}" = set; then
20632   echo $ECHO_N "(cached) $ECHO_C" >&6
20633 else
20634
20635   if test x$gcc_no_link = xyes; then
20636   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20637 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20638    { (exit 1); exit 1; }; }
20639 fi
20640 cat >conftest.$ac_ext <<_ACEOF
20641 /* confdefs.h.  */
20642 _ACEOF
20643 cat confdefs.h >>conftest.$ac_ext
20644 cat >>conftest.$ac_ext <<_ACEOF
20645 /* end confdefs.h.  */
20646
20647 #define ULP     STR1(__USER_LABEL_PREFIX__)
20648 #define STR1(x) STR2(x)
20649 #define STR2(x) #x
20650 void foo(void) { }
20651 extern void bar(void) __attribute__((alias(ULP "foo")));
20652 int
20653 main ()
20654 {
20655 bar();
20656   ;
20657   return 0;
20658 }
20659 _ACEOF
20660 rm -f conftest.$ac_objext conftest$ac_exeext
20661 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20662   (eval $ac_link) 2>conftest.er1
20663   ac_status=$?
20664   grep -v '^ *+' conftest.er1 >conftest.err
20665   rm -f conftest.er1
20666   cat conftest.err >&5
20667   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20668   (exit $ac_status); } &&
20669          { ac_try='test -z "$ac_c_werror_flag"
20670                          || test ! -s conftest.err'
20671   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20672   (eval $ac_try) 2>&5
20673   ac_status=$?
20674   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20675   (exit $ac_status); }; } &&
20676          { ac_try='test -s conftest$ac_exeext'
20677   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20678   (eval $ac_try) 2>&5
20679   ac_status=$?
20680   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20681   (exit $ac_status); }; }; then
20682   have_attribute_alias=yes
20683 else
20684   echo "$as_me: failed program was:" >&5
20685 sed 's/^/| /' conftest.$ac_ext >&5
20686
20687 have_attribute_alias=no
20688 fi
20689 rm -f conftest.err conftest.$ac_objext \
20690       conftest$ac_exeext conftest.$ac_ext
20691 fi
20692 echo "$as_me:$LINENO: result: $have_attribute_alias" >&5
20693 echo "${ECHO_T}$have_attribute_alias" >&6
20694   if test $have_attribute_alias = yes; then
20695
20696 cat >>confdefs.h <<\_ACEOF
20697 #define HAVE_ATTRIBUTE_ALIAS 1
20698 _ACEOF
20699
20700   fi
20701
20702 # Check out sync builtins support.
20703
20704   echo "$as_me:$LINENO: checking whether the target supports __sync_fetch_and_add" >&5
20705 echo $ECHO_N "checking whether the target supports __sync_fetch_and_add... $ECHO_C" >&6
20706 if test "${have_sync_fetch_and_add+set}" = set; then
20707   echo $ECHO_N "(cached) $ECHO_C" >&6
20708 else
20709
20710   if test x$gcc_no_link = xyes; then
20711   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20712 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20713    { (exit 1); exit 1; }; }
20714 fi
20715 cat >conftest.$ac_ext <<_ACEOF
20716 /* confdefs.h.  */
20717 _ACEOF
20718 cat confdefs.h >>conftest.$ac_ext
20719 cat >>conftest.$ac_ext <<_ACEOF
20720 /* end confdefs.h.  */
20721 int foovar = 0;
20722 int
20723 main ()
20724 {
20725
20726 if (foovar <= 0) return __sync_fetch_and_add (&foovar, 1);
20727 if (foovar > 10) return __sync_add_and_fetch (&foovar, -1);
20728   ;
20729   return 0;
20730 }
20731 _ACEOF
20732 rm -f conftest.$ac_objext conftest$ac_exeext
20733 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20734   (eval $ac_link) 2>conftest.er1
20735   ac_status=$?
20736   grep -v '^ *+' conftest.er1 >conftest.err
20737   rm -f conftest.er1
20738   cat conftest.err >&5
20739   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20740   (exit $ac_status); } &&
20741          { ac_try='test -z "$ac_c_werror_flag"
20742                          || test ! -s conftest.err'
20743   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20744   (eval $ac_try) 2>&5
20745   ac_status=$?
20746   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20747   (exit $ac_status); }; } &&
20748          { ac_try='test -s conftest$ac_exeext'
20749   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20750   (eval $ac_try) 2>&5
20751   ac_status=$?
20752   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20753   (exit $ac_status); }; }; then
20754   have_sync_fetch_and_add=yes
20755 else
20756   echo "$as_me: failed program was:" >&5
20757 sed 's/^/| /' conftest.$ac_ext >&5
20758
20759 have_sync_fetch_and_add=no
20760 fi
20761 rm -f conftest.err conftest.$ac_objext \
20762       conftest$ac_exeext conftest.$ac_ext
20763 fi
20764 echo "$as_me:$LINENO: result: $have_sync_fetch_and_add" >&5
20765 echo "${ECHO_T}$have_sync_fetch_and_add" >&6
20766   if test $have_sync_fetch_and_add = yes; then
20767
20768 cat >>confdefs.h <<\_ACEOF
20769 #define HAVE_SYNC_FETCH_AND_ADD 1
20770 _ACEOF
20771
20772   fi
20773
20774 # Check out thread support.
20775
20776   echo "$as_me:$LINENO: checking configured target thread model" >&5
20777 echo $ECHO_N "checking configured target thread model... $ECHO_C" >&6
20778 if test "${target_thread_file+set}" = set; then
20779   echo $ECHO_N "(cached) $ECHO_C" >&6
20780 else
20781
20782 target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`
20783 fi
20784 echo "$as_me:$LINENO: result: $target_thread_file" >&5
20785 echo "${ECHO_T}$target_thread_file" >&6
20786
20787   if test $target_thread_file != single; then
20788
20789 cat >>confdefs.h <<\_ACEOF
20790 #define HAVE_GTHR_DEFAULT 1
20791 _ACEOF
20792
20793   fi
20794
20795 # Check out #pragma weak.
20796
20797   echo "$as_me:$LINENO: checking whether pragma weak works" >&5
20798 echo $ECHO_N "checking whether pragma weak works... $ECHO_C" >&6
20799 if test "${have_pragma_weak+set}" = set; then
20800   echo $ECHO_N "(cached) $ECHO_C" >&6
20801 else
20802
20803   gfor_save_CFLAGS="$CFLAGS"
20804   CFLAGS="$CFLAGS -Wunknown-pragmas"
20805   cat >conftest.$ac_ext <<_ACEOF
20806 /* confdefs.h.  */
20807 _ACEOF
20808 cat confdefs.h >>conftest.$ac_ext
20809 cat >>conftest.$ac_ext <<_ACEOF
20810 /* end confdefs.h.  */
20811 void foo (void);
20812 #pragma weak foo
20813 int
20814 main ()
20815 {
20816 if (foo) foo ();
20817   ;
20818   return 0;
20819 }
20820 _ACEOF
20821 rm -f conftest.$ac_objext
20822 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
20823   (eval $ac_compile) 2>conftest.er1
20824   ac_status=$?
20825   grep -v '^ *+' conftest.er1 >conftest.err
20826   rm -f conftest.er1
20827   cat conftest.err >&5
20828   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20829   (exit $ac_status); } &&
20830          { ac_try='test -z "$ac_c_werror_flag"
20831                          || test ! -s conftest.err'
20832   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20833   (eval $ac_try) 2>&5
20834   ac_status=$?
20835   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20836   (exit $ac_status); }; } &&
20837          { ac_try='test -s conftest.$ac_objext'
20838   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20839   (eval $ac_try) 2>&5
20840   ac_status=$?
20841   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20842   (exit $ac_status); }; }; then
20843   have_pragma_weak=yes
20844 else
20845   echo "$as_me: failed program was:" >&5
20846 sed 's/^/| /' conftest.$ac_ext >&5
20847
20848 have_pragma_weak=no
20849 fi
20850 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
20851 fi
20852 echo "$as_me:$LINENO: result: $have_pragma_weak" >&5
20853 echo "${ECHO_T}$have_pragma_weak" >&6
20854   if test $have_pragma_weak = yes; then
20855
20856 cat >>confdefs.h <<\_ACEOF
20857 #define SUPPORTS_WEAK 1
20858 _ACEOF
20859
20860   fi
20861   case "$host" in
20862     *-*-darwin* | *-*-hpux* | *-*-cygwin*)
20863
20864 cat >>confdefs.h <<\_ACEOF
20865 #define GTHREAD_USE_WEAK 0
20866 _ACEOF
20867
20868       ;;
20869   esac
20870
20871 # Various other checks on target
20872
20873   echo "$as_me:$LINENO: checking whether the target can unlink an open file" >&5
20874 echo $ECHO_N "checking whether the target can unlink an open file... $ECHO_C" >&6
20875 if test "${have_unlink_open_file+set}" = set; then
20876   echo $ECHO_N "(cached) $ECHO_C" >&6
20877 else
20878
20879   if test "$cross_compiling" = yes; then
20880
20881 case "${target}" in
20882   *mingw*) have_unlink_open_file=no ;;
20883   *) have_unlink_open_file=yes;;
20884 esac
20885 else
20886   cat >conftest.$ac_ext <<_ACEOF
20887 /* confdefs.h.  */
20888 _ACEOF
20889 cat confdefs.h >>conftest.$ac_ext
20890 cat >>conftest.$ac_ext <<_ACEOF
20891 /* end confdefs.h.  */
20892
20893 #include <errno.h>
20894 #include <fcntl.h>
20895 #include <unistd.h>
20896 #include <sys/stat.h>
20897
20898 int main ()
20899 {
20900   int fd;
20901
20902   fd = open ("testfile", O_RDWR | O_CREAT, S_IWRITE | S_IREAD);
20903   if (fd <= 0)
20904     return 0;
20905   if (unlink ("testfile") == -1)
20906     return 1;
20907   write (fd, "This is a test\n", 15);
20908   close (fd);
20909
20910   if (open ("testfile", O_RDONLY, S_IWRITE | S_IREAD) == -1 && errno == ENOENT)
20911     return 0;
20912   else
20913     return 1;
20914 }
20915 _ACEOF
20916 rm -f conftest$ac_exeext
20917 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20918   (eval $ac_link) 2>&5
20919   ac_status=$?
20920   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20921   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
20922   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20923   (eval $ac_try) 2>&5
20924   ac_status=$?
20925   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20926   (exit $ac_status); }; }; then
20927   have_unlink_open_file=yes
20928 else
20929   echo "$as_me: program exited with status $ac_status" >&5
20930 echo "$as_me: failed program was:" >&5
20931 sed 's/^/| /' conftest.$ac_ext >&5
20932
20933 ( exit $ac_status )
20934 have_unlink_open_file=no
20935 fi
20936 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
20937 fi
20938 fi
20939 echo "$as_me:$LINENO: result: $have_unlink_open_file" >&5
20940 echo "${ECHO_T}$have_unlink_open_file" >&6
20941 if test x"$have_unlink_open_file" = xyes; then
20942
20943 cat >>confdefs.h <<\_ACEOF
20944 #define HAVE_UNLINK_OPEN_FILE 1
20945 _ACEOF
20946
20947 fi
20948
20949 # Check whether line terminator is LF or CRLF
20950
20951   echo "$as_me:$LINENO: checking whether the target has CRLF as line terminator" >&5
20952 echo $ECHO_N "checking whether the target has CRLF as line terminator... $ECHO_C" >&6
20953 if test "${have_crlf+set}" = set; then
20954   echo $ECHO_N "(cached) $ECHO_C" >&6
20955 else
20956
20957   if test "$cross_compiling" = yes; then
20958
20959 case "${target}" in
20960   *mingw*) have_crlf=yes ;;
20961   *) have_crlf=no;;
20962 esac
20963 else
20964   cat >conftest.$ac_ext <<_ACEOF
20965 /* confdefs.h.  */
20966 _ACEOF
20967 cat confdefs.h >>conftest.$ac_ext
20968 cat >>conftest.$ac_ext <<_ACEOF
20969 /* end confdefs.h.  */
20970
20971 /* This test program should exit with status 0 if system uses a CRLF as
20972    line terminator, and status 1 otherwise.
20973    Since it is used to check for mingw systems, and should return 0 in any
20974    other case, in case of a failure we will not use CRLF.  */
20975 #include <sys/stat.h>
20976 #include <stdlib.h>
20977 #include <fcntl.h>
20978 #include <stdio.h>
20979
20980 int main ()
20981 {
20982 #ifndef O_BINARY
20983   exit(1);
20984 #else
20985   int fd, bytes;
20986   char buff[5];
20987
20988   fd = open ("foo", O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
20989   if (fd < 0)
20990     exit(1);
20991   if (write (fd, "\n", 1) < 0)
20992     perror ("write");
20993
20994   close (fd);
20995
20996   if ((fd = open ("foo", O_RDONLY | O_BINARY, S_IRWXU)) < 0)
20997     exit(1);
20998   bytes = read (fd, buff, 5);
20999   if (bytes == 2 && buff[0] == '\r' && buff[1] == '\n')
21000     exit(0);
21001   else
21002     exit(1);
21003 #endif
21004 }
21005 _ACEOF
21006 rm -f conftest$ac_exeext
21007 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
21008   (eval $ac_link) 2>&5
21009   ac_status=$?
21010   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21011   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
21012   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
21013   (eval $ac_try) 2>&5
21014   ac_status=$?
21015   echo "$as_me:$LINENO: \$? = $ac_status" >&5
21016   (exit $ac_status); }; }; then
21017   have_crlf=yes
21018 else
21019   echo "$as_me: program exited with status $ac_status" >&5
21020 echo "$as_me: failed program was:" >&5
21021 sed 's/^/| /' conftest.$ac_ext >&5
21022
21023 ( exit $ac_status )
21024 have_crlf=no
21025 fi
21026 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
21027 fi
21028 fi
21029 echo "$as_me:$LINENO: result: $have_crlf" >&5
21030 echo "${ECHO_T}$have_crlf" >&6
21031 if test x"$have_crlf" = xyes; then
21032
21033 cat >>confdefs.h <<\_ACEOF
21034 #define HAVE_CRLF 1
21035 _ACEOF
21036
21037 fi
21038
21039 cat >confcache <<\_ACEOF
21040 # This file is a shell script that caches the results of configure
21041 # tests run on this system so they can be shared between configure
21042 # scripts and configure runs, see configure's option --config-cache.
21043 # It is not useful on other systems.  If it contains results you don't
21044 # want to keep, you may remove or edit it.
21045 #
21046 # config.status only pays attention to the cache file if you give it
21047 # the --recheck option to rerun configure.
21048 #
21049 # `ac_cv_env_foo' variables (set or unset) will be overridden when
21050 # loading this file, other *unset* `ac_cv_foo' will be assigned the
21051 # following values.
21052
21053 _ACEOF
21054
21055 # The following way of writing the cache mishandles newlines in values,
21056 # but we know of no workaround that is simple, portable, and efficient.
21057 # So, don't put newlines in cache variables' values.
21058 # Ultrix sh set writes to stderr and can't be redirected directly,
21059 # and sets the high bit in the cache file unless we assign to the vars.
21060 {
21061   (set) 2>&1 |
21062     case `(ac_space=' '; set | grep ac_space) 2>&1` in
21063     *ac_space=\ *)
21064       # `set' does not quote correctly, so add quotes (double-quote
21065       # substitution turns \\\\ into \\, and sed turns \\ into \).
21066       sed -n \
21067         "s/'/'\\\\''/g;
21068           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
21069       ;;
21070     *)
21071       # `set' quotes correctly as required by POSIX, so do not add quotes.
21072       sed -n \
21073         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
21074       ;;
21075     esac;
21076 } |
21077   sed '
21078      t clear
21079      : clear
21080      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
21081      t end
21082      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
21083      : end' >>confcache
21084 if diff $cache_file confcache >/dev/null 2>&1; then :; else
21085   if test -w $cache_file; then
21086     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
21087     cat confcache >$cache_file
21088   else
21089     echo "not updating unwritable cache $cache_file"
21090   fi
21091 fi
21092 rm -f confcache
21093
21094 if test ${multilib} = yes; then
21095   multilib_arg="--enable-multilib"
21096 else
21097   multilib_arg=
21098 fi
21099
21100 # Write our Makefile.
21101           ac_config_files="$ac_config_files Makefile"
21102
21103 cat >confcache <<\_ACEOF
21104 # This file is a shell script that caches the results of configure
21105 # tests run on this system so they can be shared between configure
21106 # scripts and configure runs, see configure's option --config-cache.
21107 # It is not useful on other systems.  If it contains results you don't
21108 # want to keep, you may remove or edit it.
21109 #
21110 # config.status only pays attention to the cache file if you give it
21111 # the --recheck option to rerun configure.
21112 #
21113 # `ac_cv_env_foo' variables (set or unset) will be overridden when
21114 # loading this file, other *unset* `ac_cv_foo' will be assigned the
21115 # following values.
21116
21117 _ACEOF
21118
21119 # The following way of writing the cache mishandles newlines in values,
21120 # but we know of no workaround that is simple, portable, and efficient.
21121 # So, don't put newlines in cache variables' values.
21122 # Ultrix sh set writes to stderr and can't be redirected directly,
21123 # and sets the high bit in the cache file unless we assign to the vars.
21124 {
21125   (set) 2>&1 |
21126     case `(ac_space=' '; set | grep ac_space) 2>&1` in
21127     *ac_space=\ *)
21128       # `set' does not quote correctly, so add quotes (double-quote
21129       # substitution turns \\\\ into \\, and sed turns \\ into \).
21130       sed -n \
21131         "s/'/'\\\\''/g;
21132           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
21133       ;;
21134     *)
21135       # `set' quotes correctly as required by POSIX, so do not add quotes.
21136       sed -n \
21137         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
21138       ;;
21139     esac;
21140 } |
21141   sed '
21142      t clear
21143      : clear
21144      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
21145      t end
21146      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
21147      : end' >>confcache
21148 if diff $cache_file confcache >/dev/null 2>&1; then :; else
21149   if test -w $cache_file; then
21150     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
21151     cat confcache >$cache_file
21152   else
21153     echo "not updating unwritable cache $cache_file"
21154   fi
21155 fi
21156 rm -f confcache
21157
21158 test "x$prefix" = xNONE && prefix=$ac_default_prefix
21159 # Let make expand exec_prefix.
21160 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
21161
21162 # VPATH may cause trouble with some makes, so we remove $(srcdir),
21163 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
21164 # trailing colons and then remove the whole line if VPATH becomes empty
21165 # (actually we leave an empty line to preserve line numbers).
21166 if test "x$srcdir" = x.; then
21167   ac_vpsub='/^[  ]*VPATH[        ]*=/{
21168 s/:*\$(srcdir):*/:/;
21169 s/:*\${srcdir}:*/:/;
21170 s/:*@srcdir@:*/:/;
21171 s/^\([^=]*=[     ]*\):*/\1/;
21172 s/:*$//;
21173 s/^[^=]*=[       ]*$//;
21174 }'
21175 fi
21176
21177 DEFS=-DHAVE_CONFIG_H
21178
21179 ac_libobjs=
21180 ac_ltlibobjs=
21181 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
21182   # 1. Remove the extension, and $U if already installed.
21183   ac_i=`echo "$ac_i" |
21184          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
21185   # 2. Add them.
21186   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
21187   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
21188 done
21189 LIBOBJS=$ac_libobjs
21190
21191 LTLIBOBJS=$ac_ltlibobjs
21192
21193
21194 if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then
21195   { { echo "$as_me:$LINENO: error: conditional \"MAINTAINER_MODE\" was never defined.
21196 Usually this means the macro was only invoked conditionally." >&5
21197 echo "$as_me: error: conditional \"MAINTAINER_MODE\" was never defined.
21198 Usually this means the macro was only invoked conditionally." >&2;}
21199    { (exit 1); exit 1; }; }
21200 fi
21201
21202 : ${CONFIG_STATUS=./config.status}
21203 ac_clean_files_save=$ac_clean_files
21204 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
21205 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
21206 echo "$as_me: creating $CONFIG_STATUS" >&6;}
21207 cat >$CONFIG_STATUS <<_ACEOF
21208 #! $SHELL
21209 # Generated by $as_me.
21210 # Run this file to recreate the current configuration.
21211 # Compiler output produced by configure, useful for debugging
21212 # configure, is in config.log if it exists.
21213
21214 debug=false
21215 ac_cs_recheck=false
21216 ac_cs_silent=false
21217 SHELL=\${CONFIG_SHELL-$SHELL}
21218 _ACEOF
21219
21220 cat >>$CONFIG_STATUS <<\_ACEOF
21221 ## --------------------- ##
21222 ## M4sh Initialization.  ##
21223 ## --------------------- ##
21224
21225 # Be Bourne compatible
21226 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
21227   emulate sh
21228   NULLCMD=:
21229   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
21230   # is contrary to our usage.  Disable this feature.
21231   alias -g '${1+"$@"}'='"$@"'
21232 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
21233   set -o posix
21234 fi
21235 DUALCASE=1; export DUALCASE # for MKS sh
21236
21237 # Support unset when possible.
21238 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
21239   as_unset=unset
21240 else
21241   as_unset=false
21242 fi
21243
21244
21245 # Work around bugs in pre-3.0 UWIN ksh.
21246 $as_unset ENV MAIL MAILPATH
21247 PS1='$ '
21248 PS2='> '
21249 PS4='+ '
21250
21251 # NLS nuisances.
21252 for as_var in \
21253   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
21254   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
21255   LC_TELEPHONE LC_TIME
21256 do
21257   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
21258     eval $as_var=C; export $as_var
21259   else
21260     $as_unset $as_var
21261   fi
21262 done
21263
21264 # Required to use basename.
21265 if expr a : '\(a\)' >/dev/null 2>&1; then
21266   as_expr=expr
21267 else
21268   as_expr=false
21269 fi
21270
21271 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
21272   as_basename=basename
21273 else
21274   as_basename=false
21275 fi
21276
21277
21278 # Name of the executable.
21279 as_me=`$as_basename "$0" ||
21280 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
21281          X"$0" : 'X\(//\)$' \| \
21282          X"$0" : 'X\(/\)$' \| \
21283          .     : '\(.\)' 2>/dev/null ||
21284 echo X/"$0" |
21285     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
21286           /^X\/\(\/\/\)$/{ s//\1/; q; }
21287           /^X\/\(\/\).*/{ s//\1/; q; }
21288           s/.*/./; q'`
21289
21290
21291 # PATH needs CR, and LINENO needs CR and PATH.
21292 # Avoid depending upon Character Ranges.
21293 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
21294 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
21295 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
21296 as_cr_digits='0123456789'
21297 as_cr_alnum=$as_cr_Letters$as_cr_digits
21298
21299 # The user is always right.
21300 if test "${PATH_SEPARATOR+set}" != set; then
21301   echo "#! /bin/sh" >conf$$.sh
21302   echo  "exit 0"   >>conf$$.sh
21303   chmod +x conf$$.sh
21304   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
21305     PATH_SEPARATOR=';'
21306   else
21307     PATH_SEPARATOR=:
21308   fi
21309   rm -f conf$$.sh
21310 fi
21311
21312
21313   as_lineno_1=$LINENO
21314   as_lineno_2=$LINENO
21315   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
21316   test "x$as_lineno_1" != "x$as_lineno_2" &&
21317   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
21318   # Find who we are.  Look in the path if we contain no path at all
21319   # relative or not.
21320   case $0 in
21321     *[\\/]* ) as_myself=$0 ;;
21322     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21323 for as_dir in $PATH
21324 do
21325   IFS=$as_save_IFS
21326   test -z "$as_dir" && as_dir=.
21327   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
21328 done
21329
21330        ;;
21331   esac
21332   # We did not find ourselves, most probably we were run as `sh COMMAND'
21333   # in which case we are not to be found in the path.
21334   if test "x$as_myself" = x; then
21335     as_myself=$0
21336   fi
21337   if test ! -f "$as_myself"; then
21338     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
21339 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
21340    { (exit 1); exit 1; }; }
21341   fi
21342   case $CONFIG_SHELL in
21343   '')
21344     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
21345 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
21346 do
21347   IFS=$as_save_IFS
21348   test -z "$as_dir" && as_dir=.
21349   for as_base in sh bash ksh sh5; do
21350          case $as_dir in
21351          /*)
21352            if ("$as_dir/$as_base" -c '
21353   as_lineno_1=$LINENO
21354   as_lineno_2=$LINENO
21355   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
21356   test "x$as_lineno_1" != "x$as_lineno_2" &&
21357   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
21358              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
21359              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
21360              CONFIG_SHELL=$as_dir/$as_base
21361              export CONFIG_SHELL
21362              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
21363            fi;;
21364          esac
21365        done
21366 done
21367 ;;
21368   esac
21369
21370   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
21371   # uniformly replaced by the line number.  The first 'sed' inserts a
21372   # line-number line before each line; the second 'sed' does the real
21373   # work.  The second script uses 'N' to pair each line-number line
21374   # with the numbered line, and appends trailing '-' during
21375   # substitution so that $LINENO is not a special case at line end.
21376   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
21377   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
21378   sed '=' <$as_myself |
21379     sed '
21380       N
21381       s,$,-,
21382       : loop
21383       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
21384       t loop
21385       s,-$,,
21386       s,^['$as_cr_digits']*\n,,
21387     ' >$as_me.lineno &&
21388   chmod +x $as_me.lineno ||
21389     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
21390 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
21391    { (exit 1); exit 1; }; }
21392
21393   # Don't try to exec as it changes $[0], causing all sort of problems
21394   # (the dirname of $[0] is not the place where we might find the
21395   # original and so on.  Autoconf is especially sensible to this).
21396   . ./$as_me.lineno
21397   # Exit status is that of the last command.
21398   exit
21399 }
21400
21401
21402 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
21403   *c*,-n*) ECHO_N= ECHO_C='
21404 ' ECHO_T='      ' ;;
21405   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
21406   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
21407 esac
21408
21409 if expr a : '\(a\)' >/dev/null 2>&1; then
21410   as_expr=expr
21411 else
21412   as_expr=false
21413 fi
21414
21415 rm -f conf$$ conf$$.exe conf$$.file
21416 echo >conf$$.file
21417 if ln -s conf$$.file conf$$ 2>/dev/null; then
21418   # We could just check for DJGPP; but this test a) works b) is more generic
21419   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
21420   if test -f conf$$.exe; then
21421     # Don't use ln at all; we don't have any links
21422     as_ln_s='cp -p'
21423   else
21424     as_ln_s='ln -s'
21425   fi
21426 elif ln conf$$.file conf$$ 2>/dev/null; then
21427   as_ln_s=ln
21428 else
21429   as_ln_s='cp -p'
21430 fi
21431 rm -f conf$$ conf$$.exe conf$$.file
21432
21433 if mkdir -p . 2>/dev/null; then
21434   as_mkdir_p=:
21435 else
21436   test -d ./-p && rmdir ./-p
21437   as_mkdir_p=false
21438 fi
21439
21440 as_executable_p="test -f"
21441
21442 # Sed expression to map a string onto a valid CPP name.
21443 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
21444
21445 # Sed expression to map a string onto a valid variable name.
21446 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
21447
21448
21449 # IFS
21450 # We need space, tab and new line, in precisely that order.
21451 as_nl='
21452 '
21453 IFS="   $as_nl"
21454
21455 # CDPATH.
21456 $as_unset CDPATH
21457
21458 exec 6>&1
21459
21460 # Open the log real soon, to keep \$[0] and so on meaningful, and to
21461 # report actual input values of CONFIG_FILES etc. instead of their
21462 # values after options handling.  Logging --version etc. is OK.
21463 exec 5>>config.log
21464 {
21465   echo
21466   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
21467 ## Running $as_me. ##
21468 _ASBOX
21469 } >&5
21470 cat >&5 <<_CSEOF
21471
21472 This file was extended by GNU Fortran Runtime Library $as_me 0.2, which was
21473 generated by GNU Autoconf 2.59.  Invocation command line was
21474
21475   CONFIG_FILES    = $CONFIG_FILES
21476   CONFIG_HEADERS  = $CONFIG_HEADERS
21477   CONFIG_LINKS    = $CONFIG_LINKS
21478   CONFIG_COMMANDS = $CONFIG_COMMANDS
21479   $ $0 $@
21480
21481 _CSEOF
21482 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
21483 echo >&5
21484 _ACEOF
21485
21486 # Files that config.status was made for.
21487 if test -n "$ac_config_files"; then
21488   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
21489 fi
21490
21491 if test -n "$ac_config_headers"; then
21492   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
21493 fi
21494
21495 if test -n "$ac_config_links"; then
21496   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
21497 fi
21498
21499 if test -n "$ac_config_commands"; then
21500   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
21501 fi
21502
21503 cat >>$CONFIG_STATUS <<\_ACEOF
21504
21505 ac_cs_usage="\
21506 \`$as_me' instantiates files from templates according to the
21507 current configuration.
21508
21509 Usage: $0 [OPTIONS] [FILE]...
21510
21511   -h, --help       print this help, then exit
21512   -V, --version    print version number, then exit
21513   -q, --quiet      do not print progress messages
21514   -d, --debug      don't remove temporary files
21515       --recheck    update $as_me by reconfiguring in the same conditions
21516   --file=FILE[:TEMPLATE]
21517                    instantiate the configuration file FILE
21518   --header=FILE[:TEMPLATE]
21519                    instantiate the configuration header FILE
21520
21521 Configuration files:
21522 $config_files
21523
21524 Configuration headers:
21525 $config_headers
21526
21527 Configuration commands:
21528 $config_commands
21529
21530 Report bugs to <bug-autoconf@gnu.org>."
21531 _ACEOF
21532
21533 cat >>$CONFIG_STATUS <<_ACEOF
21534 ac_cs_version="\\
21535 GNU Fortran Runtime Library config.status 0.2
21536 configured by $0, generated by GNU Autoconf 2.59,
21537   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
21538
21539 Copyright (C) 2003 Free Software Foundation, Inc.
21540 This config.status script is free software; the Free Software Foundation
21541 gives unlimited permission to copy, distribute and modify it."
21542 srcdir=$srcdir
21543 INSTALL="$INSTALL"
21544 _ACEOF
21545
21546 cat >>$CONFIG_STATUS <<\_ACEOF
21547 # If no file are specified by the user, then we need to provide default
21548 # value.  By we need to know if files were specified by the user.
21549 ac_need_defaults=:
21550 while test $# != 0
21551 do
21552   case $1 in
21553   --*=*)
21554     ac_option=`expr "x$1" : 'x\([^=]*\)='`
21555     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
21556     ac_shift=:
21557     ;;
21558   -*)
21559     ac_option=$1
21560     ac_optarg=$2
21561     ac_shift=shift
21562     ;;
21563   *) # This is not an option, so the user has probably given explicit
21564      # arguments.
21565      ac_option=$1
21566      ac_need_defaults=false;;
21567   esac
21568
21569   case $ac_option in
21570   # Handling of the options.
21571 _ACEOF
21572 cat >>$CONFIG_STATUS <<\_ACEOF
21573   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
21574     ac_cs_recheck=: ;;
21575   --version | --vers* | -V )
21576     echo "$ac_cs_version"; exit 0 ;;
21577   --he | --h)
21578     # Conflict between --help and --header
21579     { { echo "$as_me:$LINENO: error: ambiguous option: $1
21580 Try \`$0 --help' for more information." >&5
21581 echo "$as_me: error: ambiguous option: $1
21582 Try \`$0 --help' for more information." >&2;}
21583    { (exit 1); exit 1; }; };;
21584   --help | --hel | -h )
21585     echo "$ac_cs_usage"; exit 0 ;;
21586   --debug | --d* | -d )
21587     debug=: ;;
21588   --file | --fil | --fi | --f )
21589     $ac_shift
21590     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
21591     ac_need_defaults=false;;
21592   --header | --heade | --head | --hea )
21593     $ac_shift
21594     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
21595     ac_need_defaults=false;;
21596   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
21597   | -silent | --silent | --silen | --sile | --sil | --si | --s)
21598     ac_cs_silent=: ;;
21599
21600   # This is an error.
21601   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
21602 Try \`$0 --help' for more information." >&5
21603 echo "$as_me: error: unrecognized option: $1
21604 Try \`$0 --help' for more information." >&2;}
21605    { (exit 1); exit 1; }; } ;;
21606
21607   *) ac_config_targets="$ac_config_targets $1" ;;
21608
21609   esac
21610   shift
21611 done
21612
21613 ac_configure_extra_args=
21614
21615 if $ac_cs_silent; then
21616   exec 6>/dev/null
21617   ac_configure_extra_args="$ac_configure_extra_args --silent"
21618 fi
21619
21620 _ACEOF
21621 cat >>$CONFIG_STATUS <<_ACEOF
21622 if \$ac_cs_recheck; then
21623   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
21624   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
21625 fi
21626
21627 _ACEOF
21628
21629 cat >>$CONFIG_STATUS <<_ACEOF
21630 #
21631 # INIT-COMMANDS section.
21632 #
21633
21634
21635 srcdir="$srcdir"
21636 host="$host"
21637 target="$target"
21638 with_multisubdir="$with_multisubdir"
21639 with_multisrctop="$with_multisrctop"
21640 with_target_subdir="$with_target_subdir"
21641 ac_configure_args="${multilib_arg} ${ac_configure_args}"
21642 multi_basedir="$multi_basedir"
21643 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
21644 CC="$CC"
21645
21646 _ACEOF
21647
21648
21649
21650 cat >>$CONFIG_STATUS <<\_ACEOF
21651 for ac_config_target in $ac_config_targets
21652 do
21653   case "$ac_config_target" in
21654   # Handling of arguments.
21655   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
21656   "default-1" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default-1" ;;
21657   "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
21658   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
21659 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
21660    { (exit 1); exit 1; }; };;
21661   esac
21662 done
21663
21664 # If the user did not use the arguments to specify the items to instantiate,
21665 # then the envvar interface is used.  Set only those that are not.
21666 # We use the long form for the default assignment because of an extremely
21667 # bizarre bug on SunOS 4.1.3.
21668 if $ac_need_defaults; then
21669   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
21670   test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
21671   test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
21672 fi
21673
21674 # Have a temporary directory for convenience.  Make it in the build tree
21675 # simply because there is no reason to put it here, and in addition,
21676 # creating and moving files from /tmp can sometimes cause problems.
21677 # Create a temporary directory, and hook for its removal unless debugging.
21678 $debug ||
21679 {
21680   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
21681   trap '{ (exit 1); exit 1; }' 1 2 13 15
21682 }
21683
21684 # Create a (secure) tmp directory for tmp files.
21685
21686 {
21687   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
21688   test -n "$tmp" && test -d "$tmp"
21689 }  ||
21690 {
21691   tmp=./confstat$$-$RANDOM
21692   (umask 077 && mkdir $tmp)
21693 } ||
21694 {
21695    echo "$me: cannot create a temporary directory in ." >&2
21696    { (exit 1); exit 1; }
21697 }
21698
21699 _ACEOF
21700
21701 cat >>$CONFIG_STATUS <<_ACEOF
21702
21703 #
21704 # CONFIG_FILES section.
21705 #
21706
21707 # No need to generate the scripts if there are no CONFIG_FILES.
21708 # This happens for instance when ./config.status config.h
21709 if test -n "\$CONFIG_FILES"; then
21710   # Protect against being on the right side of a sed subst in config.status.
21711   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
21712    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
21713 s,@SHELL@,$SHELL,;t t
21714 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
21715 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
21716 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
21717 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
21718 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
21719 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
21720 s,@exec_prefix@,$exec_prefix,;t t
21721 s,@prefix@,$prefix,;t t
21722 s,@program_transform_name@,$program_transform_name,;t t
21723 s,@bindir@,$bindir,;t t
21724 s,@sbindir@,$sbindir,;t t
21725 s,@libexecdir@,$libexecdir,;t t
21726 s,@datadir@,$datadir,;t t
21727 s,@sysconfdir@,$sysconfdir,;t t
21728 s,@sharedstatedir@,$sharedstatedir,;t t
21729 s,@localstatedir@,$localstatedir,;t t
21730 s,@libdir@,$libdir,;t t
21731 s,@includedir@,$includedir,;t t
21732 s,@oldincludedir@,$oldincludedir,;t t
21733 s,@infodir@,$infodir,;t t
21734 s,@mandir@,$mandir,;t t
21735 s,@build_alias@,$build_alias,;t t
21736 s,@host_alias@,$host_alias,;t t
21737 s,@target_alias@,$target_alias,;t t
21738 s,@DEFS@,$DEFS,;t t
21739 s,@ECHO_C@,$ECHO_C,;t t
21740 s,@ECHO_N@,$ECHO_N,;t t
21741 s,@ECHO_T@,$ECHO_T,;t t
21742 s,@LIBS@,$LIBS,;t t
21743 s,@build@,$build,;t t
21744 s,@build_cpu@,$build_cpu,;t t
21745 s,@build_vendor@,$build_vendor,;t t
21746 s,@build_os@,$build_os,;t t
21747 s,@host@,$host,;t t
21748 s,@host_cpu@,$host_cpu,;t t
21749 s,@host_vendor@,$host_vendor,;t t
21750 s,@host_os@,$host_os,;t t
21751 s,@target@,$target,;t t
21752 s,@target_cpu@,$target_cpu,;t t
21753 s,@target_vendor@,$target_vendor,;t t
21754 s,@target_os@,$target_os,;t t
21755 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
21756 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
21757 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
21758 s,@CYGPATH_W@,$CYGPATH_W,;t t
21759 s,@PACKAGE@,$PACKAGE,;t t
21760 s,@VERSION@,$VERSION,;t t
21761 s,@ACLOCAL@,$ACLOCAL,;t t
21762 s,@AUTOCONF@,$AUTOCONF,;t t
21763 s,@AUTOMAKE@,$AUTOMAKE,;t t
21764 s,@AUTOHEADER@,$AUTOHEADER,;t t
21765 s,@MAKEINFO@,$MAKEINFO,;t t
21766 s,@install_sh@,$install_sh,;t t
21767 s,@STRIP@,$STRIP,;t t
21768 s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t
21769 s,@INSTALL_STRIP_PROGRAM@,$INSTALL_STRIP_PROGRAM,;t t
21770 s,@mkdir_p@,$mkdir_p,;t t
21771 s,@AWK@,$AWK,;t t
21772 s,@SET_MAKE@,$SET_MAKE,;t t
21773 s,@am__leading_dot@,$am__leading_dot,;t t
21774 s,@AMTAR@,$AMTAR,;t t
21775 s,@am__tar@,$am__tar,;t t
21776 s,@am__untar@,$am__untar,;t t
21777 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
21778 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
21779 s,@MAINT@,$MAINT,;t t
21780 s,@multi_basedir@,$multi_basedir,;t t
21781 s,@toolexecdir@,$toolexecdir,;t t
21782 s,@toolexeclibdir@,$toolexeclibdir,;t t
21783 s,@CC@,$CC,;t t
21784 s,@ac_ct_CC@,$ac_ct_CC,;t t
21785 s,@EXEEXT@,$EXEEXT,;t t
21786 s,@OBJEXT@,$OBJEXT,;t t
21787 s,@AM_FCFLAGS@,$AM_FCFLAGS,;t t
21788 s,@AM_CFLAGS@,$AM_CFLAGS,;t t
21789 s,@AS@,$AS,;t t
21790 s,@ac_ct_AS@,$ac_ct_AS,;t t
21791 s,@AR@,$AR,;t t
21792 s,@ac_ct_AR@,$ac_ct_AR,;t t
21793 s,@RANLIB@,$RANLIB,;t t
21794 s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
21795 s,@LN_S@,$LN_S,;t t
21796 s,@LIBTOOL@,$LIBTOOL,;t t
21797 s,@enable_shared@,$enable_shared,;t t
21798 s,@enable_static@,$enable_static,;t t
21799 s,@FC@,$FC,;t t
21800 s,@FCFLAGS@,$FCFLAGS,;t t
21801 s,@LDFLAGS@,$LDFLAGS,;t t
21802 s,@ac_ct_FC@,$ac_ct_FC,;t t
21803 s,@extra_ldflags_libgfortran@,$extra_ldflags_libgfortran,;t t
21804 s,@CPP@,$CPP,;t t
21805 s,@CPPFLAGS@,$CPPFLAGS,;t t
21806 s,@EGREP@,$EGREP,;t t
21807 s,@FPU_HOST_HEADER@,$FPU_HOST_HEADER,;t t
21808 s,@LIBOBJS@,$LIBOBJS,;t t
21809 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
21810 CEOF
21811
21812 _ACEOF
21813
21814   cat >>$CONFIG_STATUS <<\_ACEOF
21815   # Split the substitutions into bite-sized pieces for seds with
21816   # small command number limits, like on Digital OSF/1 and HP-UX.
21817   ac_max_sed_lines=48
21818   ac_sed_frag=1 # Number of current file.
21819   ac_beg=1 # First line for current file.
21820   ac_end=$ac_max_sed_lines # Line after last line for current file.
21821   ac_more_lines=:
21822   ac_sed_cmds=
21823   while $ac_more_lines; do
21824     if test $ac_beg -gt 1; then
21825       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
21826     else
21827       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
21828     fi
21829     if test ! -s $tmp/subs.frag; then
21830       ac_more_lines=false
21831     else
21832       # The purpose of the label and of the branching condition is to
21833       # speed up the sed processing (if there are no `@' at all, there
21834       # is no need to browse any of the substitutions).
21835       # These are the two extra sed commands mentioned above.
21836       (echo ':t
21837   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
21838       if test -z "$ac_sed_cmds"; then
21839         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
21840       else
21841         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
21842       fi
21843       ac_sed_frag=`expr $ac_sed_frag + 1`
21844       ac_beg=$ac_end
21845       ac_end=`expr $ac_end + $ac_max_sed_lines`
21846     fi
21847   done
21848   if test -z "$ac_sed_cmds"; then
21849     ac_sed_cmds=cat
21850   fi
21851 fi # test -n "$CONFIG_FILES"
21852
21853 _ACEOF
21854 cat >>$CONFIG_STATUS <<\_ACEOF
21855 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
21856   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
21857   case $ac_file in
21858   - | *:- | *:-:* ) # input from stdin
21859         cat >$tmp/stdin
21860         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
21861         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
21862   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
21863         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
21864   * )   ac_file_in=$ac_file.in ;;
21865   esac
21866
21867   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
21868   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
21869 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
21870          X"$ac_file" : 'X\(//\)[^/]' \| \
21871          X"$ac_file" : 'X\(//\)$' \| \
21872          X"$ac_file" : 'X\(/\)' \| \
21873          .     : '\(.\)' 2>/dev/null ||
21874 echo X"$ac_file" |
21875     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
21876           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
21877           /^X\(\/\/\)$/{ s//\1/; q; }
21878           /^X\(\/\).*/{ s//\1/; q; }
21879           s/.*/./; q'`
21880   { if $as_mkdir_p; then
21881     mkdir -p "$ac_dir"
21882   else
21883     as_dir="$ac_dir"
21884     as_dirs=
21885     while test ! -d "$as_dir"; do
21886       as_dirs="$as_dir $as_dirs"
21887       as_dir=`(dirname "$as_dir") 2>/dev/null ||
21888 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
21889          X"$as_dir" : 'X\(//\)[^/]' \| \
21890          X"$as_dir" : 'X\(//\)$' \| \
21891          X"$as_dir" : 'X\(/\)' \| \
21892          .     : '\(.\)' 2>/dev/null ||
21893 echo X"$as_dir" |
21894     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
21895           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
21896           /^X\(\/\/\)$/{ s//\1/; q; }
21897           /^X\(\/\).*/{ s//\1/; q; }
21898           s/.*/./; q'`
21899     done
21900     test ! -n "$as_dirs" || mkdir $as_dirs
21901   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
21902 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
21903    { (exit 1); exit 1; }; }; }
21904
21905   ac_builddir=.
21906
21907 if test "$ac_dir" != .; then
21908   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
21909   # A "../" for each directory in $ac_dir_suffix.
21910   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
21911 else
21912   ac_dir_suffix= ac_top_builddir=
21913 fi
21914
21915 case $srcdir in
21916   .)  # No --srcdir option.  We are building in place.
21917     ac_srcdir=.
21918     if test -z "$ac_top_builddir"; then
21919        ac_top_srcdir=.
21920     else
21921        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
21922     fi ;;
21923   [\\/]* | ?:[\\/]* )  # Absolute path.
21924     ac_srcdir=$srcdir$ac_dir_suffix;
21925     ac_top_srcdir=$srcdir ;;
21926   *) # Relative path.
21927     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
21928     ac_top_srcdir=$ac_top_builddir$srcdir ;;
21929 esac
21930
21931 # Do not use `cd foo && pwd` to compute absolute paths, because
21932 # the directories may not exist.
21933 case `pwd` in
21934 .) ac_abs_builddir="$ac_dir";;
21935 *)
21936   case "$ac_dir" in
21937   .) ac_abs_builddir=`pwd`;;
21938   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
21939   *) ac_abs_builddir=`pwd`/"$ac_dir";;
21940   esac;;
21941 esac
21942 case $ac_abs_builddir in
21943 .) ac_abs_top_builddir=${ac_top_builddir}.;;
21944 *)
21945   case ${ac_top_builddir}. in
21946   .) ac_abs_top_builddir=$ac_abs_builddir;;
21947   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
21948   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
21949   esac;;
21950 esac
21951 case $ac_abs_builddir in
21952 .) ac_abs_srcdir=$ac_srcdir;;
21953 *)
21954   case $ac_srcdir in
21955   .) ac_abs_srcdir=$ac_abs_builddir;;
21956   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
21957   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
21958   esac;;
21959 esac
21960 case $ac_abs_builddir in
21961 .) ac_abs_top_srcdir=$ac_top_srcdir;;
21962 *)
21963   case $ac_top_srcdir in
21964   .) ac_abs_top_srcdir=$ac_abs_builddir;;
21965   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
21966   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
21967   esac;;
21968 esac
21969
21970
21971   case $INSTALL in
21972   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
21973   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
21974   esac
21975
21976   if test x"$ac_file" != x-; then
21977     { echo "$as_me:$LINENO: creating $ac_file" >&5
21978 echo "$as_me: creating $ac_file" >&6;}
21979     rm -f "$ac_file"
21980   fi
21981   # Let's still pretend it is `configure' which instantiates (i.e., don't
21982   # use $as_me), people would be surprised to read:
21983   #    /* config.h.  Generated by config.status.  */
21984   if test x"$ac_file" = x-; then
21985     configure_input=
21986   else
21987     configure_input="$ac_file.  "
21988   fi
21989   configure_input=$configure_input"Generated from `echo $ac_file_in |
21990                                      sed 's,.*/,,'` by configure."
21991
21992   # First look for the input files in the build tree, otherwise in the
21993   # src tree.
21994   ac_file_inputs=`IFS=:
21995     for f in $ac_file_in; do
21996       case $f in
21997       -) echo $tmp/stdin ;;
21998       [\\/$]*)
21999          # Absolute (can't be DOS-style, as IFS=:)
22000          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
22001 echo "$as_me: error: cannot find input file: $f" >&2;}
22002    { (exit 1); exit 1; }; }
22003          echo "$f";;
22004       *) # Relative
22005          if test -f "$f"; then
22006            # Build tree
22007            echo "$f"
22008          elif test -f "$srcdir/$f"; then
22009            # Source tree
22010            echo "$srcdir/$f"
22011          else
22012            # /dev/null tree
22013            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
22014 echo "$as_me: error: cannot find input file: $f" >&2;}
22015    { (exit 1); exit 1; }; }
22016          fi;;
22017       esac
22018     done` || { (exit 1); exit 1; }
22019 _ACEOF
22020 cat >>$CONFIG_STATUS <<_ACEOF
22021   sed "$ac_vpsub
22022 $extrasub
22023 _ACEOF
22024 cat >>$CONFIG_STATUS <<\_ACEOF
22025 :t
22026 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
22027 s,@configure_input@,$configure_input,;t t
22028 s,@srcdir@,$ac_srcdir,;t t
22029 s,@abs_srcdir@,$ac_abs_srcdir,;t t
22030 s,@top_srcdir@,$ac_top_srcdir,;t t
22031 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
22032 s,@builddir@,$ac_builddir,;t t
22033 s,@abs_builddir@,$ac_abs_builddir,;t t
22034 s,@top_builddir@,$ac_top_builddir,;t t
22035 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
22036 s,@INSTALL@,$ac_INSTALL,;t t
22037 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
22038   rm -f $tmp/stdin
22039   if test x"$ac_file" != x-; then
22040     mv $tmp/out $ac_file
22041   else
22042     cat $tmp/out
22043     rm -f $tmp/out
22044   fi
22045
22046 done
22047 _ACEOF
22048 cat >>$CONFIG_STATUS <<\_ACEOF
22049
22050 #
22051 # CONFIG_HEADER section.
22052 #
22053
22054 # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
22055 # NAME is the cpp macro being defined and VALUE is the value it is being given.
22056 #
22057 # ac_d sets the value in "#define NAME VALUE" lines.
22058 ac_dA='s,^\([    ]*\)#\([        ]*define[       ][      ]*\)'
22059 ac_dB='[         ].*$,\1#\2'
22060 ac_dC=' '
22061 ac_dD=',;t'
22062 # ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
22063 ac_uA='s,^\([    ]*\)#\([        ]*\)undef\([    ][      ]*\)'
22064 ac_uB='$,\1#\2define\3'
22065 ac_uC=' '
22066 ac_uD=',;t'
22067
22068 for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue
22069   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
22070   case $ac_file in
22071   - | *:- | *:-:* ) # input from stdin
22072         cat >$tmp/stdin
22073         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
22074         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
22075   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
22076         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
22077   * )   ac_file_in=$ac_file.in ;;
22078   esac
22079
22080   test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5
22081 echo "$as_me: creating $ac_file" >&6;}
22082
22083   # First look for the input files in the build tree, otherwise in the
22084   # src tree.
22085   ac_file_inputs=`IFS=:
22086     for f in $ac_file_in; do
22087       case $f in
22088       -) echo $tmp/stdin ;;
22089       [\\/$]*)
22090          # Absolute (can't be DOS-style, as IFS=:)
22091          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
22092 echo "$as_me: error: cannot find input file: $f" >&2;}
22093    { (exit 1); exit 1; }; }
22094          # Do quote $f, to prevent DOS paths from being IFS'd.
22095          echo "$f";;
22096       *) # Relative
22097          if test -f "$f"; then
22098            # Build tree
22099            echo "$f"
22100          elif test -f "$srcdir/$f"; then
22101            # Source tree
22102            echo "$srcdir/$f"
22103          else
22104            # /dev/null tree
22105            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
22106 echo "$as_me: error: cannot find input file: $f" >&2;}
22107    { (exit 1); exit 1; }; }
22108          fi;;
22109       esac
22110     done` || { (exit 1); exit 1; }
22111   # Remove the trailing spaces.
22112   sed 's/[       ]*$//' $ac_file_inputs >$tmp/in
22113
22114 _ACEOF
22115
22116 # Transform confdefs.h into two sed scripts, `conftest.defines' and
22117 # `conftest.undefs', that substitutes the proper values into
22118 # config.h.in to produce config.h.  The first handles `#define'
22119 # templates, and the second `#undef' templates.
22120 # And first: Protect against being on the right side of a sed subst in
22121 # config.status.  Protect against being in an unquoted here document
22122 # in config.status.
22123 rm -f conftest.defines conftest.undefs
22124 # Using a here document instead of a string reduces the quoting nightmare.
22125 # Putting comments in sed scripts is not portable.
22126 #
22127 # `end' is used to avoid that the second main sed command (meant for
22128 # 0-ary CPP macros) applies to n-ary macro definitions.
22129 # See the Autoconf documentation for `clear'.
22130 cat >confdef2sed.sed <<\_ACEOF
22131 s/[\\&,]/\\&/g
22132 s,[\\$`],\\&,g
22133 t clear
22134 : clear
22135 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
22136 t end
22137 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
22138 : end
22139 _ACEOF
22140 # If some macros were called several times there might be several times
22141 # the same #defines, which is useless.  Nevertheless, we may not want to
22142 # sort them, since we want the *last* AC-DEFINE to be honored.
22143 uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines
22144 sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs
22145 rm -f confdef2sed.sed
22146
22147 # This sed command replaces #undef with comments.  This is necessary, for
22148 # example, in the case of _POSIX_SOURCE, which is predefined and required
22149 # on some systems where configure will not decide to define it.
22150 cat >>conftest.undefs <<\_ACEOF
22151 s,^[     ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
22152 _ACEOF
22153
22154 # Break up conftest.defines because some shells have a limit on the size
22155 # of here documents, and old seds have small limits too (100 cmds).
22156 echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
22157 echo '  if grep "^[      ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
22158 echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
22159 echo '  :' >>$CONFIG_STATUS
22160 rm -f conftest.tail
22161 while grep . conftest.defines >/dev/null
22162 do
22163   # Write a limited-size here document to $tmp/defines.sed.
22164   echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
22165   # Speed up: don't consider the non `#define' lines.
22166   echo '/^[      ]*#[    ]*define/!b' >>$CONFIG_STATUS
22167   # Work around the forget-to-reset-the-flag bug.
22168   echo 't clr' >>$CONFIG_STATUS
22169   echo ': clr' >>$CONFIG_STATUS
22170   sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS
22171   echo 'CEOF
22172   sed -f $tmp/defines.sed $tmp/in >$tmp/out
22173   rm -f $tmp/in
22174   mv $tmp/out $tmp/in
22175 ' >>$CONFIG_STATUS
22176   sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail
22177   rm -f conftest.defines
22178   mv conftest.tail conftest.defines
22179 done
22180 rm -f conftest.defines
22181 echo '  fi # grep' >>$CONFIG_STATUS
22182 echo >>$CONFIG_STATUS
22183
22184 # Break up conftest.undefs because some shells have a limit on the size
22185 # of here documents, and old seds have small limits too (100 cmds).
22186 echo '  # Handle all the #undef templates' >>$CONFIG_STATUS
22187 rm -f conftest.tail
22188 while grep . conftest.undefs >/dev/null
22189 do
22190   # Write a limited-size here document to $tmp/undefs.sed.
22191   echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
22192   # Speed up: don't consider the non `#undef'
22193   echo '/^[      ]*#[    ]*undef/!b' >>$CONFIG_STATUS
22194   # Work around the forget-to-reset-the-flag bug.
22195   echo 't clr' >>$CONFIG_STATUS
22196   echo ': clr' >>$CONFIG_STATUS
22197   sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS
22198   echo 'CEOF
22199   sed -f $tmp/undefs.sed $tmp/in >$tmp/out
22200   rm -f $tmp/in
22201   mv $tmp/out $tmp/in
22202 ' >>$CONFIG_STATUS
22203   sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail
22204   rm -f conftest.undefs
22205   mv conftest.tail conftest.undefs
22206 done
22207 rm -f conftest.undefs
22208
22209 cat >>$CONFIG_STATUS <<\_ACEOF
22210   # Let's still pretend it is `configure' which instantiates (i.e., don't
22211   # use $as_me), people would be surprised to read:
22212   #    /* config.h.  Generated by config.status.  */
22213   if test x"$ac_file" = x-; then
22214     echo "/* Generated by configure.  */" >$tmp/config.h
22215   else
22216     echo "/* $ac_file.  Generated by configure.  */" >$tmp/config.h
22217   fi
22218   cat $tmp/in >>$tmp/config.h
22219   rm -f $tmp/in
22220   if test x"$ac_file" != x-; then
22221     if diff $ac_file $tmp/config.h >/dev/null 2>&1; then
22222       { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
22223 echo "$as_me: $ac_file is unchanged" >&6;}
22224     else
22225       ac_dir=`(dirname "$ac_file") 2>/dev/null ||
22226 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
22227          X"$ac_file" : 'X\(//\)[^/]' \| \
22228          X"$ac_file" : 'X\(//\)$' \| \
22229          X"$ac_file" : 'X\(/\)' \| \
22230          .     : '\(.\)' 2>/dev/null ||
22231 echo X"$ac_file" |
22232     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
22233           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
22234           /^X\(\/\/\)$/{ s//\1/; q; }
22235           /^X\(\/\).*/{ s//\1/; q; }
22236           s/.*/./; q'`
22237       { if $as_mkdir_p; then
22238     mkdir -p "$ac_dir"
22239   else
22240     as_dir="$ac_dir"
22241     as_dirs=
22242     while test ! -d "$as_dir"; do
22243       as_dirs="$as_dir $as_dirs"
22244       as_dir=`(dirname "$as_dir") 2>/dev/null ||
22245 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
22246          X"$as_dir" : 'X\(//\)[^/]' \| \
22247          X"$as_dir" : 'X\(//\)$' \| \
22248          X"$as_dir" : 'X\(/\)' \| \
22249          .     : '\(.\)' 2>/dev/null ||
22250 echo X"$as_dir" |
22251     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
22252           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
22253           /^X\(\/\/\)$/{ s//\1/; q; }
22254           /^X\(\/\).*/{ s//\1/; q; }
22255           s/.*/./; q'`
22256     done
22257     test ! -n "$as_dirs" || mkdir $as_dirs
22258   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
22259 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
22260    { (exit 1); exit 1; }; }; }
22261
22262       rm -f $ac_file
22263       mv $tmp/config.h $ac_file
22264     fi
22265   else
22266     cat $tmp/config.h
22267     rm -f $tmp/config.h
22268   fi
22269 # Compute $ac_file's index in $config_headers.
22270 _am_stamp_count=1
22271 for _am_header in $config_headers :; do
22272   case $_am_header in
22273     $ac_file | $ac_file:* )
22274       break ;;
22275     * )
22276       _am_stamp_count=`expr $_am_stamp_count + 1` ;;
22277   esac
22278 done
22279 echo "timestamp for $ac_file" >`(dirname $ac_file) 2>/dev/null ||
22280 $as_expr X$ac_file : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
22281          X$ac_file : 'X\(//\)[^/]' \| \
22282          X$ac_file : 'X\(//\)$' \| \
22283          X$ac_file : 'X\(/\)' \| \
22284          .     : '\(.\)' 2>/dev/null ||
22285 echo X$ac_file |
22286     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
22287           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
22288           /^X\(\/\/\)$/{ s//\1/; q; }
22289           /^X\(\/\).*/{ s//\1/; q; }
22290           s/.*/./; q'`/stamp-h$_am_stamp_count
22291 done
22292 _ACEOF
22293 cat >>$CONFIG_STATUS <<\_ACEOF
22294
22295 #
22296 # CONFIG_COMMANDS section.
22297 #
22298 for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue
22299   ac_dest=`echo "$ac_file" | sed 's,:.*,,'`
22300   ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`
22301   ac_dir=`(dirname "$ac_dest") 2>/dev/null ||
22302 $as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
22303          X"$ac_dest" : 'X\(//\)[^/]' \| \
22304          X"$ac_dest" : 'X\(//\)$' \| \
22305          X"$ac_dest" : 'X\(/\)' \| \
22306          .     : '\(.\)' 2>/dev/null ||
22307 echo X"$ac_dest" |
22308     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
22309           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
22310           /^X\(\/\/\)$/{ s//\1/; q; }
22311           /^X\(\/\).*/{ s//\1/; q; }
22312           s/.*/./; q'`
22313   { if $as_mkdir_p; then
22314     mkdir -p "$ac_dir"
22315   else
22316     as_dir="$ac_dir"
22317     as_dirs=
22318     while test ! -d "$as_dir"; do
22319       as_dirs="$as_dir $as_dirs"
22320       as_dir=`(dirname "$as_dir") 2>/dev/null ||
22321 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
22322          X"$as_dir" : 'X\(//\)[^/]' \| \
22323          X"$as_dir" : 'X\(//\)$' \| \
22324          X"$as_dir" : 'X\(/\)' \| \
22325          .     : '\(.\)' 2>/dev/null ||
22326 echo X"$as_dir" |
22327     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
22328           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
22329           /^X\(\/\/\)$/{ s//\1/; q; }
22330           /^X\(\/\).*/{ s//\1/; q; }
22331           s/.*/./; q'`
22332     done
22333     test ! -n "$as_dirs" || mkdir $as_dirs
22334   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
22335 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
22336    { (exit 1); exit 1; }; }; }
22337
22338   ac_builddir=.
22339
22340 if test "$ac_dir" != .; then
22341   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
22342   # A "../" for each directory in $ac_dir_suffix.
22343   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
22344 else
22345   ac_dir_suffix= ac_top_builddir=
22346 fi
22347
22348 case $srcdir in
22349   .)  # No --srcdir option.  We are building in place.
22350     ac_srcdir=.
22351     if test -z "$ac_top_builddir"; then
22352        ac_top_srcdir=.
22353     else
22354        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
22355     fi ;;
22356   [\\/]* | ?:[\\/]* )  # Absolute path.
22357     ac_srcdir=$srcdir$ac_dir_suffix;
22358     ac_top_srcdir=$srcdir ;;
22359   *) # Relative path.
22360     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
22361     ac_top_srcdir=$ac_top_builddir$srcdir ;;
22362 esac
22363
22364 # Do not use `cd foo && pwd` to compute absolute paths, because
22365 # the directories may not exist.
22366 case `pwd` in
22367 .) ac_abs_builddir="$ac_dir";;
22368 *)
22369   case "$ac_dir" in
22370   .) ac_abs_builddir=`pwd`;;
22371   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
22372   *) ac_abs_builddir=`pwd`/"$ac_dir";;
22373   esac;;
22374 esac
22375 case $ac_abs_builddir in
22376 .) ac_abs_top_builddir=${ac_top_builddir}.;;
22377 *)
22378   case ${ac_top_builddir}. in
22379   .) ac_abs_top_builddir=$ac_abs_builddir;;
22380   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
22381   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
22382   esac;;
22383 esac
22384 case $ac_abs_builddir in
22385 .) ac_abs_srcdir=$ac_srcdir;;
22386 *)
22387   case $ac_srcdir in
22388   .) ac_abs_srcdir=$ac_abs_builddir;;
22389   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
22390   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
22391   esac;;
22392 esac
22393 case $ac_abs_builddir in
22394 .) ac_abs_top_srcdir=$ac_top_srcdir;;
22395 *)
22396   case $ac_top_srcdir in
22397   .) ac_abs_top_srcdir=$ac_abs_builddir;;
22398   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
22399   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
22400   esac;;
22401 esac
22402
22403
22404   { echo "$as_me:$LINENO: executing $ac_dest commands" >&5
22405 echo "$as_me: executing $ac_dest commands" >&6;}
22406   case $ac_dest in
22407     default-1 )
22408 # Only add multilib support code if we just rebuilt the top-level
22409 # Makefile.
22410 case " $CONFIG_FILES " in
22411  *" Makefile "*)
22412    ac_file=Makefile . ${multi_basedir}/config-ml.in
22413    ;;
22414 esac ;;
22415   esac
22416 done
22417 _ACEOF
22418
22419 cat >>$CONFIG_STATUS <<\_ACEOF
22420
22421 { (exit 0); exit 0; }
22422 _ACEOF
22423 chmod +x $CONFIG_STATUS
22424 ac_clean_files=$ac_clean_files_save
22425
22426
22427 # configure is writing to config.log, and then calls config.status.
22428 # config.status does its own redirection, appending to config.log.
22429 # Unfortunately, on DOS this fails, as config.log is still kept open
22430 # by configure, so config.status won't be able to write to it; its
22431 # output is simply discarded.  So we exec the FD to /dev/null,
22432 # effectively closing config.log, so it can be properly (re)opened and
22433 # appended to by config.status.  When coming back to configure, we
22434 # need to make the FD available again.
22435 if test "$no_create" != yes; then
22436   ac_cs_success=:
22437   ac_config_status_args=
22438   test "$silent" = yes &&
22439     ac_config_status_args="$ac_config_status_args --quiet"
22440   exec 5>/dev/null
22441   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
22442   exec 5>>config.log
22443   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
22444   # would make configure fail if this is the last instruction.
22445   $ac_cs_success || { (exit 1); exit 1; }
22446 fi
22447