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"                   || test ! -s conftest.err'
2605   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2606   (eval $ac_try) 2>&5
2607   ac_status=$?
2608   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2609   (exit $ac_status); }; } &&
2610          { ac_try='test -s conftest.$ac_objext'
2611   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2612   (eval $ac_try) 2>&5
2613   ac_status=$?
2614   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2615   (exit $ac_status); }; }; then
2616   ac_compiler_gnu=yes
2617 else
2618   echo "$as_me: failed program was:" >&5
2619 sed 's/^/| /' conftest.$ac_ext >&5
2620
2621 ac_compiler_gnu=no
2622 fi
2623 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2624 ac_cv_c_compiler_gnu=$ac_compiler_gnu
2625
2626 fi
2627 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2628 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2629 GCC=`test $ac_compiler_gnu = yes && echo yes`
2630 ac_test_CFLAGS=${CFLAGS+set}
2631 ac_save_CFLAGS=$CFLAGS
2632 CFLAGS="-g"
2633 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2634 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2635 if test "${ac_cv_prog_cc_g+set}" = set; then
2636   echo $ECHO_N "(cached) $ECHO_C" >&6
2637 else
2638   cat >conftest.$ac_ext <<_ACEOF
2639 /* confdefs.h.  */
2640 _ACEOF
2641 cat confdefs.h >>conftest.$ac_ext
2642 cat >>conftest.$ac_ext <<_ACEOF
2643 /* end confdefs.h.  */
2644
2645 int
2646 main ()
2647 {
2648
2649   ;
2650   return 0;
2651 }
2652 _ACEOF
2653 rm -f conftest.$ac_objext
2654 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2655   (eval $ac_compile) 2>conftest.er1
2656   ac_status=$?
2657   grep -v '^ *+' conftest.er1 >conftest.err
2658   rm -f conftest.er1
2659   cat conftest.err >&5
2660   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2661   (exit $ac_status); } &&
2662          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
2663   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2664   (eval $ac_try) 2>&5
2665   ac_status=$?
2666   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2667   (exit $ac_status); }; } &&
2668          { ac_try='test -s conftest.$ac_objext'
2669   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2670   (eval $ac_try) 2>&5
2671   ac_status=$?
2672   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2673   (exit $ac_status); }; }; then
2674   ac_cv_prog_cc_g=yes
2675 else
2676   echo "$as_me: failed program was:" >&5
2677 sed 's/^/| /' conftest.$ac_ext >&5
2678
2679 ac_cv_prog_cc_g=no
2680 fi
2681 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2682 fi
2683 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2684 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2685 if test "$ac_test_CFLAGS" = set; then
2686   CFLAGS=$ac_save_CFLAGS
2687 elif test $ac_cv_prog_cc_g = yes; then
2688   if test "$GCC" = yes; then
2689     CFLAGS="-g -O2"
2690   else
2691     CFLAGS="-g"
2692   fi
2693 else
2694   if test "$GCC" = yes; then
2695     CFLAGS="-O2"
2696   else
2697     CFLAGS=
2698   fi
2699 fi
2700 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2701 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2702 if test "${ac_cv_prog_cc_stdc+set}" = set; then
2703   echo $ECHO_N "(cached) $ECHO_C" >&6
2704 else
2705   ac_cv_prog_cc_stdc=no
2706 ac_save_CC=$CC
2707 cat >conftest.$ac_ext <<_ACEOF
2708 /* confdefs.h.  */
2709 _ACEOF
2710 cat confdefs.h >>conftest.$ac_ext
2711 cat >>conftest.$ac_ext <<_ACEOF
2712 /* end confdefs.h.  */
2713 #include <stdarg.h>
2714 #include <stdio.h>
2715 #include <sys/types.h>
2716 #include <sys/stat.h>
2717 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2718 struct buf { int x; };
2719 FILE * (*rcsopen) (struct buf *, struct stat *, int);
2720 static char *e (p, i)
2721      char **p;
2722      int i;
2723 {
2724   return p[i];
2725 }
2726 static char *f (char * (*g) (char **, int), char **p, ...)
2727 {
2728   char *s;
2729   va_list v;
2730   va_start (v,p);
2731   s = g (p, va_arg (v,int));
2732   va_end (v);
2733   return s;
2734 }
2735
2736 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2737    function prototypes and stuff, but not '\xHH' hex character constants.
2738    These don't provoke an error unfortunately, instead are silently treated
2739    as 'x'.  The following induces an error, until -std1 is added to get
2740    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2741    array size at least.  It's necessary to write '\x00'==0 to get something
2742    that's true only with -std1.  */
2743 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2744
2745 int test (int i, double x);
2746 struct s1 {int (*f) (int a);};
2747 struct s2 {int (*f) (double a);};
2748 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2749 int argc;
2750 char **argv;
2751 int
2752 main ()
2753 {
2754 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2755   ;
2756   return 0;
2757 }
2758 _ACEOF
2759 # Don't try gcc -ansi; that turns off useful extensions and
2760 # breaks some systems' header files.
2761 # AIX                   -qlanglvl=ansi
2762 # Ultrix and OSF/1      -std1
2763 # HP-UX 10.20 and later -Ae
2764 # HP-UX older versions  -Aa -D_HPUX_SOURCE
2765 # SVR4                  -Xc -D__EXTENSIONS__
2766 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2767 do
2768   CC="$ac_save_CC $ac_arg"
2769   rm -f conftest.$ac_objext
2770 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2771   (eval $ac_compile) 2>conftest.er1
2772   ac_status=$?
2773   grep -v '^ *+' conftest.er1 >conftest.err
2774   rm -f conftest.er1
2775   cat conftest.err >&5
2776   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2777   (exit $ac_status); } &&
2778          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
2779   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2780   (eval $ac_try) 2>&5
2781   ac_status=$?
2782   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2783   (exit $ac_status); }; } &&
2784          { ac_try='test -s conftest.$ac_objext'
2785   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2786   (eval $ac_try) 2>&5
2787   ac_status=$?
2788   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2789   (exit $ac_status); }; }; then
2790   ac_cv_prog_cc_stdc=$ac_arg
2791 break
2792 else
2793   echo "$as_me: failed program was:" >&5
2794 sed 's/^/| /' conftest.$ac_ext >&5
2795
2796 fi
2797 rm -f conftest.err conftest.$ac_objext
2798 done
2799 rm -f conftest.$ac_ext conftest.$ac_objext
2800 CC=$ac_save_CC
2801
2802 fi
2803
2804 case "x$ac_cv_prog_cc_stdc" in
2805   x|xno)
2806     echo "$as_me:$LINENO: result: none needed" >&5
2807 echo "${ECHO_T}none needed" >&6 ;;
2808   *)
2809     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2810 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2811     CC="$CC $ac_cv_prog_cc_stdc" ;;
2812 esac
2813
2814 # Some people use a C++ compiler to compile C.  Since we use `exit',
2815 # in C++ we need to declare it.  In case someone uses the same compiler
2816 # for both compiling C and C++ we need to have the C++ compiler decide
2817 # the declaration of exit, since it's the most demanding environment.
2818 cat >conftest.$ac_ext <<_ACEOF
2819 #ifndef __cplusplus
2820   choke me
2821 #endif
2822 _ACEOF
2823 rm -f conftest.$ac_objext
2824 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2825   (eval $ac_compile) 2>conftest.er1
2826   ac_status=$?
2827   grep -v '^ *+' conftest.er1 >conftest.err
2828   rm -f conftest.er1
2829   cat conftest.err >&5
2830   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2831   (exit $ac_status); } &&
2832          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
2833   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2834   (eval $ac_try) 2>&5
2835   ac_status=$?
2836   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2837   (exit $ac_status); }; } &&
2838          { ac_try='test -s conftest.$ac_objext'
2839   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2840   (eval $ac_try) 2>&5
2841   ac_status=$?
2842   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2843   (exit $ac_status); }; }; then
2844   for ac_declaration in \
2845    '' \
2846    'extern "C" void std::exit (int) throw (); using std::exit;' \
2847    'extern "C" void std::exit (int); using std::exit;' \
2848    'extern "C" void exit (int) throw ();' \
2849    'extern "C" void exit (int);' \
2850    'void exit (int);'
2851 do
2852   cat >conftest.$ac_ext <<_ACEOF
2853 /* confdefs.h.  */
2854 _ACEOF
2855 cat confdefs.h >>conftest.$ac_ext
2856 cat >>conftest.$ac_ext <<_ACEOF
2857 /* end confdefs.h.  */
2858 $ac_declaration
2859 #include <stdlib.h>
2860 int
2861 main ()
2862 {
2863 exit (42);
2864   ;
2865   return 0;
2866 }
2867 _ACEOF
2868 rm -f conftest.$ac_objext
2869 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2870   (eval $ac_compile) 2>conftest.er1
2871   ac_status=$?
2872   grep -v '^ *+' conftest.er1 >conftest.err
2873   rm -f conftest.er1
2874   cat conftest.err >&5
2875   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2876   (exit $ac_status); } &&
2877          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
2878   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2879   (eval $ac_try) 2>&5
2880   ac_status=$?
2881   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2882   (exit $ac_status); }; } &&
2883          { ac_try='test -s conftest.$ac_objext'
2884   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2885   (eval $ac_try) 2>&5
2886   ac_status=$?
2887   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2888   (exit $ac_status); }; }; then
2889   :
2890 else
2891   echo "$as_me: failed program was:" >&5
2892 sed 's/^/| /' conftest.$ac_ext >&5
2893
2894 continue
2895 fi
2896 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2897   cat >conftest.$ac_ext <<_ACEOF
2898 /* confdefs.h.  */
2899 _ACEOF
2900 cat confdefs.h >>conftest.$ac_ext
2901 cat >>conftest.$ac_ext <<_ACEOF
2902 /* end confdefs.h.  */
2903 $ac_declaration
2904 int
2905 main ()
2906 {
2907 exit (42);
2908   ;
2909   return 0;
2910 }
2911 _ACEOF
2912 rm -f conftest.$ac_objext
2913 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2914   (eval $ac_compile) 2>conftest.er1
2915   ac_status=$?
2916   grep -v '^ *+' conftest.er1 >conftest.err
2917   rm -f conftest.er1
2918   cat conftest.err >&5
2919   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2920   (exit $ac_status); } &&
2921          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
2922   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2923   (eval $ac_try) 2>&5
2924   ac_status=$?
2925   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2926   (exit $ac_status); }; } &&
2927          { ac_try='test -s conftest.$ac_objext'
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); }; }; then
2933   break
2934 else
2935   echo "$as_me: failed program was:" >&5
2936 sed 's/^/| /' conftest.$ac_ext >&5
2937
2938 fi
2939 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2940 done
2941 rm -f conftest*
2942 if test -n "$ac_declaration"; then
2943   echo '#ifdef __cplusplus' >>confdefs.h
2944   echo $ac_declaration      >>confdefs.h
2945   echo '#endif'             >>confdefs.h
2946 fi
2947
2948 else
2949   echo "$as_me: failed program was:" >&5
2950 sed 's/^/| /' conftest.$ac_ext >&5
2951
2952 fi
2953 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2954 ac_ext=c
2955 ac_cpp='$CPP $CPPFLAGS'
2956 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2957 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2958 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2959
2960
2961
2962 # Add -Wall -fno-repack-arrays -fno-underscoring if we are using GCC.
2963 if test "x$GCC" = "xyes"; then
2964   AM_FCFLAGS="-Wall -fno-repack-arrays -fno-underscoring"
2965   ## We like to use C99 routines when available.  This makes sure that
2966   ## __STDC_VERSION__ is set such that libc includes make them available.
2967   AM_CFLAGS="-std=gnu99 -Wall -Wstrict-prototypes -Wmissing-prototypes -Wold-style-definition -Wextra -Wwrite-strings"
2968 fi
2969
2970
2971
2972 # Find other programs we need.
2973 if test -n "$ac_tool_prefix"; then
2974   # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
2975 set dummy ${ac_tool_prefix}as; ac_word=$2
2976 echo "$as_me:$LINENO: checking for $ac_word" >&5
2977 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2978 if test "${ac_cv_prog_AS+set}" = set; then
2979   echo $ECHO_N "(cached) $ECHO_C" >&6
2980 else
2981   if test -n "$AS"; then
2982   ac_cv_prog_AS="$AS" # Let the user override the test.
2983 else
2984 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2985 for as_dir in $PATH
2986 do
2987   IFS=$as_save_IFS
2988   test -z "$as_dir" && as_dir=.
2989   for ac_exec_ext in '' $ac_executable_extensions; do
2990   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2991     ac_cv_prog_AS="${ac_tool_prefix}as"
2992     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2993     break 2
2994   fi
2995 done
2996 done
2997
2998 fi
2999 fi
3000 AS=$ac_cv_prog_AS
3001 if test -n "$AS"; then
3002   echo "$as_me:$LINENO: result: $AS" >&5
3003 echo "${ECHO_T}$AS" >&6
3004 else
3005   echo "$as_me:$LINENO: result: no" >&5
3006 echo "${ECHO_T}no" >&6
3007 fi
3008
3009 fi
3010 if test -z "$ac_cv_prog_AS"; then
3011   ac_ct_AS=$AS
3012   # Extract the first word of "as", so it can be a program name with args.
3013 set dummy as; ac_word=$2
3014 echo "$as_me:$LINENO: checking for $ac_word" >&5
3015 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3016 if test "${ac_cv_prog_ac_ct_AS+set}" = set; then
3017   echo $ECHO_N "(cached) $ECHO_C" >&6
3018 else
3019   if test -n "$ac_ct_AS"; then
3020   ac_cv_prog_ac_ct_AS="$ac_ct_AS" # Let the user override the test.
3021 else
3022 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3023 for as_dir in $PATH
3024 do
3025   IFS=$as_save_IFS
3026   test -z "$as_dir" && as_dir=.
3027   for ac_exec_ext in '' $ac_executable_extensions; do
3028   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3029     ac_cv_prog_ac_ct_AS="as"
3030     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3031     break 2
3032   fi
3033 done
3034 done
3035
3036 fi
3037 fi
3038 ac_ct_AS=$ac_cv_prog_ac_ct_AS
3039 if test -n "$ac_ct_AS"; then
3040   echo "$as_me:$LINENO: result: $ac_ct_AS" >&5
3041 echo "${ECHO_T}$ac_ct_AS" >&6
3042 else
3043   echo "$as_me:$LINENO: result: no" >&5
3044 echo "${ECHO_T}no" >&6
3045 fi
3046
3047   AS=$ac_ct_AS
3048 else
3049   AS="$ac_cv_prog_AS"
3050 fi
3051
3052 if test -n "$ac_tool_prefix"; then
3053   # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
3054 set dummy ${ac_tool_prefix}ar; ac_word=$2
3055 echo "$as_me:$LINENO: checking for $ac_word" >&5
3056 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3057 if test "${ac_cv_prog_AR+set}" = set; then
3058   echo $ECHO_N "(cached) $ECHO_C" >&6
3059 else
3060   if test -n "$AR"; then
3061   ac_cv_prog_AR="$AR" # Let the user override the test.
3062 else
3063 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3064 for as_dir in $PATH
3065 do
3066   IFS=$as_save_IFS
3067   test -z "$as_dir" && as_dir=.
3068   for ac_exec_ext in '' $ac_executable_extensions; do
3069   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3070     ac_cv_prog_AR="${ac_tool_prefix}ar"
3071     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3072     break 2
3073   fi
3074 done
3075 done
3076
3077 fi
3078 fi
3079 AR=$ac_cv_prog_AR
3080 if test -n "$AR"; then
3081   echo "$as_me:$LINENO: result: $AR" >&5
3082 echo "${ECHO_T}$AR" >&6
3083 else
3084   echo "$as_me:$LINENO: result: no" >&5
3085 echo "${ECHO_T}no" >&6
3086 fi
3087
3088 fi
3089 if test -z "$ac_cv_prog_AR"; then
3090   ac_ct_AR=$AR
3091   # Extract the first word of "ar", so it can be a program name with args.
3092 set dummy ar; ac_word=$2
3093 echo "$as_me:$LINENO: checking for $ac_word" >&5
3094 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3095 if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
3096   echo $ECHO_N "(cached) $ECHO_C" >&6
3097 else
3098   if test -n "$ac_ct_AR"; then
3099   ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
3100 else
3101 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3102 for as_dir in $PATH
3103 do
3104   IFS=$as_save_IFS
3105   test -z "$as_dir" && as_dir=.
3106   for ac_exec_ext in '' $ac_executable_extensions; do
3107   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3108     ac_cv_prog_ac_ct_AR="ar"
3109     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3110     break 2
3111   fi
3112 done
3113 done
3114
3115 fi
3116 fi
3117 ac_ct_AR=$ac_cv_prog_ac_ct_AR
3118 if test -n "$ac_ct_AR"; then
3119   echo "$as_me:$LINENO: result: $ac_ct_AR" >&5
3120 echo "${ECHO_T}$ac_ct_AR" >&6
3121 else
3122   echo "$as_me:$LINENO: result: no" >&5
3123 echo "${ECHO_T}no" >&6
3124 fi
3125
3126   AR=$ac_ct_AR
3127 else
3128   AR="$ac_cv_prog_AR"
3129 fi
3130
3131 if test -n "$ac_tool_prefix"; then
3132   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3133 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3134 echo "$as_me:$LINENO: checking for $ac_word" >&5
3135 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3136 if test "${ac_cv_prog_RANLIB+set}" = set; then
3137   echo $ECHO_N "(cached) $ECHO_C" >&6
3138 else
3139   if test -n "$RANLIB"; then
3140   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3141 else
3142 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3143 for as_dir in $PATH
3144 do
3145   IFS=$as_save_IFS
3146   test -z "$as_dir" && as_dir=.
3147   for ac_exec_ext in '' $ac_executable_extensions; do
3148   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3149     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3150     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3151     break 2
3152   fi
3153 done
3154 done
3155
3156 fi
3157 fi
3158 RANLIB=$ac_cv_prog_RANLIB
3159 if test -n "$RANLIB"; then
3160   echo "$as_me:$LINENO: result: $RANLIB" >&5
3161 echo "${ECHO_T}$RANLIB" >&6
3162 else
3163   echo "$as_me:$LINENO: result: no" >&5
3164 echo "${ECHO_T}no" >&6
3165 fi
3166
3167 fi
3168 if test -z "$ac_cv_prog_RANLIB"; then
3169   ac_ct_RANLIB=$RANLIB
3170   # Extract the first word of "ranlib", so it can be a program name with args.
3171 set dummy ranlib; ac_word=$2
3172 echo "$as_me:$LINENO: checking for $ac_word" >&5
3173 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3174 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3175   echo $ECHO_N "(cached) $ECHO_C" >&6
3176 else
3177   if test -n "$ac_ct_RANLIB"; then
3178   ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3179 else
3180 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3181 for as_dir in $PATH
3182 do
3183   IFS=$as_save_IFS
3184   test -z "$as_dir" && as_dir=.
3185   for ac_exec_ext in '' $ac_executable_extensions; do
3186   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3187     ac_cv_prog_ac_ct_RANLIB="ranlib"
3188     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3189     break 2
3190   fi
3191 done
3192 done
3193
3194   test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB="ranlib-not-found-in-path-error"
3195 fi
3196 fi
3197 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3198 if test -n "$ac_ct_RANLIB"; then
3199   echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3200 echo "${ECHO_T}$ac_ct_RANLIB" >&6
3201 else
3202   echo "$as_me:$LINENO: result: no" >&5
3203 echo "${ECHO_T}no" >&6
3204 fi
3205
3206   RANLIB=$ac_ct_RANLIB
3207 else
3208   RANLIB="$ac_cv_prog_RANLIB"
3209 fi
3210
3211 echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3212 echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3213 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3214 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3215   echo $ECHO_N "(cached) $ECHO_C" >&6
3216 else
3217   cat >conftest.make <<\_ACEOF
3218 all:
3219         @echo 'ac_maketemp="$(MAKE)"'
3220 _ACEOF
3221 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3222 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3223 if test -n "$ac_maketemp"; then
3224   eval ac_cv_prog_make_${ac_make}_set=yes
3225 else
3226   eval ac_cv_prog_make_${ac_make}_set=no
3227 fi
3228 rm -f conftest.make
3229 fi
3230 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3231   echo "$as_me:$LINENO: result: yes" >&5
3232 echo "${ECHO_T}yes" >&6
3233   SET_MAKE=
3234 else
3235   echo "$as_me:$LINENO: result: no" >&5
3236 echo "${ECHO_T}no" >&6
3237   SET_MAKE="MAKE=${MAKE-make}"
3238 fi
3239
3240 # Find a good install program.  We prefer a C program (faster),
3241 # so one script is as good as another.  But avoid the broken or
3242 # incompatible versions:
3243 # SysV /etc/install, /usr/sbin/install
3244 # SunOS /usr/etc/install
3245 # IRIX /sbin/install
3246 # AIX /bin/install
3247 # AmigaOS /C/install, which installs bootblocks on floppy discs
3248 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3249 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3250 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3251 # OS/2's system install, which has a completely different semantic
3252 # ./install, which can be erroneously created by make from ./install.sh.
3253 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3254 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3255 if test -z "$INSTALL"; then
3256 if test "${ac_cv_path_install+set}" = set; then
3257   echo $ECHO_N "(cached) $ECHO_C" >&6
3258 else
3259   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3260 for as_dir in $PATH
3261 do
3262   IFS=$as_save_IFS
3263   test -z "$as_dir" && as_dir=.
3264   # Account for people who put trailing slashes in PATH elements.
3265 case $as_dir/ in
3266   ./ | .// | /cC/* | \
3267   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3268   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3269   /usr/ucb/* ) ;;
3270   *)
3271     # OSF1 and SCO ODT 3.0 have their own names for install.
3272     # Don't use installbsd from OSF since it installs stuff as root
3273     # by default.
3274     for ac_prog in ginstall scoinst install; do
3275       for ac_exec_ext in '' $ac_executable_extensions; do
3276         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3277           if test $ac_prog = install &&
3278             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3279             # AIX install.  It has an incompatible calling convention.
3280             :
3281           elif test $ac_prog = install &&
3282             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3283             # program-specific install script used by HP pwplus--don't use.
3284             :
3285           else
3286             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3287             break 3
3288           fi
3289         fi
3290       done
3291     done
3292     ;;
3293 esac
3294 done
3295
3296
3297 fi
3298   if test "${ac_cv_path_install+set}" = set; then
3299     INSTALL=$ac_cv_path_install
3300   else
3301     # As a last resort, use the slow shell script.  We don't cache a
3302     # path for INSTALL within a source directory, because that will
3303     # break other packages using the cache if that directory is
3304     # removed, or if the path is relative.
3305     INSTALL=$ac_install_sh
3306   fi
3307 fi
3308 echo "$as_me:$LINENO: result: $INSTALL" >&5
3309 echo "${ECHO_T}$INSTALL" >&6
3310
3311 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3312 # It thinks the first close brace ends the variable substitution.
3313 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3314
3315 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3316
3317 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3318
3319
3320 # Configure libtool
3321 #AC_MSG_NOTICE([====== Starting libtool configuration])
3322
3323 # Check whether --enable-shared or --disable-shared was given.
3324 if test "${enable_shared+set}" = set; then
3325   enableval="$enable_shared"
3326   p=${PACKAGE-default}
3327 case $enableval in
3328 yes) enable_shared=yes ;;
3329 no) enable_shared=no ;;
3330 *)
3331   enable_shared=no
3332   # Look at the argument we got.  We use all the common list separators.
3333   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3334   for pkg in $enableval; do
3335     if test "X$pkg" = "X$p"; then
3336       enable_shared=yes
3337     fi
3338   done
3339   IFS="$ac_save_ifs"
3340   ;;
3341 esac
3342 else
3343   enable_shared=yes
3344 fi;
3345 # Check whether --enable-static or --disable-static was given.
3346 if test "${enable_static+set}" = set; then
3347   enableval="$enable_static"
3348   p=${PACKAGE-default}
3349 case $enableval in
3350 yes) enable_static=yes ;;
3351 no) enable_static=no ;;
3352 *)
3353   enable_static=no
3354   # Look at the argument we got.  We use all the common list separators.
3355   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3356   for pkg in $enableval; do
3357     if test "X$pkg" = "X$p"; then
3358       enable_static=yes
3359     fi
3360   done
3361   IFS="$ac_save_ifs"
3362   ;;
3363 esac
3364 else
3365   enable_static=yes
3366 fi;
3367 # Check whether --enable-fast-install or --disable-fast-install was given.
3368 if test "${enable_fast_install+set}" = set; then
3369   enableval="$enable_fast_install"
3370   p=${PACKAGE-default}
3371 case $enableval in
3372 yes) enable_fast_install=yes ;;
3373 no) enable_fast_install=no ;;
3374 *)
3375   enable_fast_install=no
3376   # Look at the argument we got.  We use all the common list separators.
3377   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3378   for pkg in $enableval; do
3379     if test "X$pkg" = "X$p"; then
3380       enable_fast_install=yes
3381     fi
3382   done
3383   IFS="$ac_save_ifs"
3384   ;;
3385 esac
3386 else
3387   enable_fast_install=yes
3388 fi;
3389
3390 # Check whether --with-gnu-ld or --without-gnu-ld was given.
3391 if test "${with_gnu_ld+set}" = set; then
3392   withval="$with_gnu_ld"
3393   test "$withval" = no || with_gnu_ld=yes
3394 else
3395   with_gnu_ld=no
3396 fi;
3397 ac_prog=ld
3398 if test "$GCC" = yes; then
3399   # Check if gcc -print-prog-name=ld gives a path.
3400   echo "$as_me:$LINENO: checking for ld used by GCC" >&5
3401 echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6
3402   case $host in
3403   *-*-mingw*)
3404     # gcc leaves a trailing carriage return which upsets mingw
3405     ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
3406   *)
3407     ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
3408   esac
3409   case $ac_prog in
3410     # Accept absolute paths.
3411     [\\/]* | [A-Za-z]:[\\/]*)
3412       re_direlt='/[^/][^/]*/\.\./'
3413       # Canonicalize the path of ld
3414       ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
3415       while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
3416         ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
3417       done
3418       test -z "$LD" && LD="$ac_prog"
3419       ;;
3420   "")
3421     # If it fails, then pretend we aren't using GCC.
3422     ac_prog=ld
3423     ;;
3424   *)
3425     # If it is relative, then search for the first ld in PATH.
3426     with_gnu_ld=unknown
3427     ;;
3428   esac
3429 elif test "$with_gnu_ld" = yes; then
3430   echo "$as_me:$LINENO: checking for GNU ld" >&5
3431 echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6
3432 else
3433   echo "$as_me:$LINENO: checking for non-GNU ld" >&5
3434 echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6
3435 fi
3436 if test "${lt_cv_path_LD+set}" = set; then
3437   echo $ECHO_N "(cached) $ECHO_C" >&6
3438 else
3439   if test -z "$LD"; then
3440   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
3441   for ac_dir in $PATH; do
3442     test -z "$ac_dir" && ac_dir=.
3443     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
3444       lt_cv_path_LD="$ac_dir/$ac_prog"
3445       # Check to see if the program is GNU ld.  I'd rather use --version,
3446       # but apparently some GNU ld's only accept -v.
3447       # Break only if it was the GNU/non-GNU ld that we prefer.
3448       if "$lt_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
3449         test "$with_gnu_ld" != no && break
3450       else
3451         test "$with_gnu_ld" != yes && break
3452       fi
3453     fi
3454   done
3455   IFS="$ac_save_ifs"
3456 else
3457   lt_cv_path_LD="$LD" # Let the user override the test with a path.
3458 fi
3459 fi
3460
3461 LD="$lt_cv_path_LD"
3462 if test -n "$LD"; then
3463   echo "$as_me:$LINENO: result: $LD" >&5
3464 echo "${ECHO_T}$LD" >&6
3465 else
3466   echo "$as_me:$LINENO: result: no" >&5
3467 echo "${ECHO_T}no" >&6
3468 fi
3469 test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5
3470 echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}
3471    { (exit 1); exit 1; }; }
3472 echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
3473 echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6
3474 if test "${lt_cv_prog_gnu_ld+set}" = set; then
3475   echo $ECHO_N "(cached) $ECHO_C" >&6
3476 else
3477   # I'd rather use --version here, but apparently some GNU ld's only accept -v.
3478 if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
3479   lt_cv_prog_gnu_ld=yes
3480 else
3481   lt_cv_prog_gnu_ld=no
3482 fi
3483 fi
3484 echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
3485 echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6
3486 with_gnu_ld=$lt_cv_prog_gnu_ld
3487
3488
3489 echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
3490 echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6
3491 if test "${lt_cv_ld_reload_flag+set}" = set; then
3492   echo $ECHO_N "(cached) $ECHO_C" >&6
3493 else
3494   lt_cv_ld_reload_flag='-r'
3495 fi
3496 echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
3497 echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6
3498 reload_flag=$lt_cv_ld_reload_flag
3499 test -n "$reload_flag" && reload_flag=" $reload_flag"
3500
3501 echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
3502 echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6
3503 if test "${lt_cv_path_NM+set}" = set; then
3504   echo $ECHO_N "(cached) $ECHO_C" >&6
3505 else
3506   if test -n "$NM"; then
3507   # Let the user override the test.
3508   lt_cv_path_NM="$NM"
3509 else
3510   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
3511   for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
3512     test -z "$ac_dir" && ac_dir=.
3513     tmp_nm=$ac_dir/${ac_tool_prefix}nm
3514     if test -f $tmp_nm || test -f $tmp_nm$ac_exeext ; then
3515       # Check to see if the nm accepts a BSD-compat flag.
3516       # Adding the `sed 1q' prevents false positives on HP-UX, which says:
3517       #   nm: unknown option "B" ignored
3518       # Tru64's nm complains that /dev/null is an invalid object file
3519       if ($tmp_nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep '(/dev/null|Invalid file or object type)' >/dev/null; then
3520         lt_cv_path_NM="$tmp_nm -B"
3521         break
3522       elif ($tmp_nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
3523         lt_cv_path_NM="$tmp_nm -p"
3524         break
3525       else
3526         lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
3527         continue # so that we can try to find one that supports BSD flags
3528       fi
3529     fi
3530   done
3531   IFS="$ac_save_ifs"
3532   test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm
3533 fi
3534 fi
3535
3536 NM="$lt_cv_path_NM"
3537 echo "$as_me:$LINENO: result: $NM" >&5
3538 echo "${ECHO_T}$NM" >&6
3539
3540 echo "$as_me:$LINENO: checking whether ln -s works" >&5
3541 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3542 LN_S=$as_ln_s
3543 if test "$LN_S" = "ln -s"; then
3544   echo "$as_me:$LINENO: result: yes" >&5
3545 echo "${ECHO_T}yes" >&6
3546 else
3547   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3548 echo "${ECHO_T}no, using $LN_S" >&6
3549 fi
3550
3551 echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5
3552 echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6
3553 if test "${lt_cv_deplibs_check_method+set}" = set; then
3554   echo $ECHO_N "(cached) $ECHO_C" >&6
3555 else
3556   lt_cv_file_magic_cmd='$MAGIC_CMD'
3557 lt_cv_file_magic_test_file=
3558 lt_cv_deplibs_check_method='unknown'
3559 # Need to set the preceding variable on all platforms that support
3560 # interlibrary dependencies.
3561 # 'none' -- dependencies not supported.
3562 # `unknown' -- same as none, but documents that we really don't know.
3563 # 'pass_all' -- all dependencies passed with no checks.
3564 # 'test_compile' -- check by making test program.
3565 # 'file_magic [regex]' -- check by looking for files in library path
3566 # which responds to the $file_magic_cmd with a given egrep regex.
3567 # If you have `file' or equivalent on your system and you're not sure
3568 # whether `pass_all' will *always* work, you probably want this one.
3569
3570 case $host_os in
3571 aix*)
3572   lt_cv_deplibs_check_method=pass_all
3573   ;;
3574
3575 beos*)
3576   lt_cv_deplibs_check_method=pass_all
3577   ;;
3578
3579 bsdi4*)
3580   lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
3581   lt_cv_file_magic_cmd='/usr/bin/file -L'
3582   lt_cv_file_magic_test_file=/shlib/libc.so
3583   ;;
3584
3585 cygwin* | mingw* |pw32*)
3586   lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
3587   lt_cv_file_magic_cmd='$OBJDUMP -f'
3588   ;;
3589
3590 darwin* | rhapsody*)
3591   # this will be overwritten by pass_all, but leave it in just in case
3592   lt_cv_deplibs_check_method='file_magic Mach-O dynamically linked shared library'
3593   lt_cv_file_magic_cmd='/usr/bin/file -L'
3594   case "$host_os" in
3595   rhapsody* | darwin1.012)
3596     lt_cv_file_magic_test_file='/System/Library/Frameworks/System.framework/System'
3597     ;;
3598   *) # Darwin 1.3 on
3599     lt_cv_file_magic_test_file='/usr/lib/libSystem.dylib'
3600     ;;
3601   esac
3602   lt_cv_deplibs_check_method=pass_all
3603   ;;
3604
3605 freebsd* | kfreebsd*-gnu)
3606   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
3607     case $host_cpu in
3608     i*86 )
3609       # Not sure whether the presence of OpenBSD here was a mistake.
3610       # Let's accept both of them until this is cleared up.
3611       lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[3-9]86 (compact )?demand paged shared library'
3612       lt_cv_file_magic_cmd=/usr/bin/file
3613       lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
3614       ;;
3615     esac
3616   else
3617     lt_cv_deplibs_check_method=pass_all
3618   fi
3619   ;;
3620
3621 gnu*)
3622   lt_cv_deplibs_check_method=pass_all
3623   ;;
3624
3625 hpux10.20*|hpux11*)
3626   case $host_cpu in
3627   hppa*)
3628     lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library'
3629     lt_cv_file_magic_cmd=/usr/bin/file
3630     lt_cv_file_magic_test_file=/usr/lib/libc.sl
3631     ;;
3632   ia64*)
3633     lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
3634     lt_cv_file_magic_cmd=/usr/bin/file
3635     lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
3636     ;;
3637   esac
3638   ;;
3639
3640 irix5* | irix6*)
3641   case $host_os in
3642   irix5*)
3643     # this will be overridden with pass_all, but let us keep it just in case
3644     lt_cv_deplibs_check_method="file_magic ELF 32-bit MSB dynamic lib MIPS - version 1"
3645     ;;
3646   *)
3647     case $LD in
3648     *-32|*"-32 ") libmagic=32-bit;;
3649     *-n32|*"-n32 ") libmagic=N32;;
3650     *-64|*"-64 ") libmagic=64-bit;;
3651     *) libmagic=never-match;;
3652     esac
3653     # this will be overridden with pass_all, but let us keep it just in case
3654     lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[1234] dynamic lib MIPS - version 1"
3655     ;;
3656   esac
3657   lt_cv_file_magic_test_file=`echo /lib${libsuff}/libc.so*`
3658   lt_cv_deplibs_check_method=pass_all
3659   ;;
3660
3661 # This must be Linux ELF.
3662 linux-gnu*)
3663   lt_cv_deplibs_check_method=pass_all
3664   ;;
3665
3666 netbsd* | knetbsd*-gnu)
3667   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
3668     lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so\.[0-9]+\.[0-9]+$'
3669   else
3670     lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so$'
3671   fi
3672   ;;
3673
3674 newsos6)
3675   lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'
3676   lt_cv_file_magic_cmd=/usr/bin/file
3677   lt_cv_file_magic_test_file=/usr/lib/libnls.so
3678   ;;
3679
3680 osf3* | osf4* | osf5*)
3681   # this will be overridden with pass_all, but let us keep it just in case
3682   lt_cv_deplibs_check_method='file_magic COFF format alpha shared library'
3683   lt_cv_file_magic_test_file=/shlib/libc.so
3684   lt_cv_deplibs_check_method=pass_all
3685   ;;
3686
3687 sco3.2v5*)
3688   lt_cv_deplibs_check_method=pass_all
3689   ;;
3690
3691 solaris*)
3692   lt_cv_deplibs_check_method=pass_all
3693   lt_cv_file_magic_test_file=/lib/libc.so
3694   ;;
3695
3696 sysv5uw[78]* | sysv4*uw2*)
3697   lt_cv_deplibs_check_method=pass_all
3698   ;;
3699
3700 sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
3701   case $host_vendor in
3702   ncr)
3703     lt_cv_deplibs_check_method=pass_all
3704     ;;
3705   motorola)
3706     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]'
3707     lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
3708     ;;
3709   esac
3710   ;;
3711 esac
3712
3713 fi
3714 echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
3715 echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6
3716 file_magic_cmd=$lt_cv_file_magic_cmd
3717 deplibs_check_method=$lt_cv_deplibs_check_method
3718
3719
3720
3721
3722
3723 # Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
3724
3725 # find the maximum length of command line arguments
3726 echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
3727 echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6
3728 if test "${lt_cv_sys_max_cmd_len+set}" = set; then
3729   echo $ECHO_N "(cached) $ECHO_C" >&6
3730 else
3731     i=0
3732   teststring="ABCD"
3733
3734   case $build_os in
3735   msdosdjgpp*)
3736     # On DJGPP, this test can blow up pretty badly due to problems in libc
3737     # (any single argument exceeding 2000 bytes causes a buffer overrun
3738     # during glob expansion).  Even if it were fixed, the result of this
3739     # check would be larger than it should be.
3740     lt_cv_sys_max_cmd_len=12288;    # 12K is about right
3741     ;;
3742
3743   cygwin* | mingw*)
3744     # On Win9x/ME, this test blows up -- it succeeds, but takes
3745     # about 5 minutes as the teststring grows exponentially.
3746     # Worse, since 9x/ME are not pre-emptively multitasking,
3747     # you end up with a "frozen" computer, even though with patience
3748     # the test eventually succeeds (with a max line length of 256k).
3749     # Instead, let's just punt: use the minimum linelength reported by
3750     # all of the supported platforms: 8192 (on NT/2K/XP).
3751     lt_cv_sys_max_cmd_len=8192;
3752     ;;
3753
3754   amigaos*)
3755     # On AmigaOS with pdksh, this test takes hours, literally.
3756     # So we just punt and use a minimum line length of 8192.
3757     lt_cv_sys_max_cmd_len=8192;
3758     ;;
3759
3760   netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
3761     # This has been around since 386BSD, at least.  Likely further.
3762     if test -x /sbin/sysctl; then
3763       lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
3764     elif test -x /usr/sbin/sysctl; then
3765       lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
3766     else
3767       lt_cv_sys_max_cmd_len=65536 # usable default for *BSD
3768     fi
3769     # And add a safety zone
3770     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
3771     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
3772     ;;
3773   esac
3774
3775 fi
3776
3777 if test -n "$lt_cv_sys_max_cmd_len" ; then
3778   echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
3779 echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6
3780 else
3781   echo "$as_me:$LINENO: result: none" >&5
3782 echo "${ECHO_T}none" >&6
3783 fi
3784
3785
3786 # Only perform the check for file, if the check method requires it
3787 case $deplibs_check_method in
3788 file_magic*)
3789   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
3790     echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
3791 echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6
3792 if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
3793   echo $ECHO_N "(cached) $ECHO_C" >&6
3794 else
3795   case $MAGIC_CMD in
3796   /*)
3797   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
3798   ;;
3799   ?:/*)
3800   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
3801   ;;
3802   *)
3803   ac_save_MAGIC_CMD="$MAGIC_CMD"
3804   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3805   ac_dummy="/usr/bin:$PATH"
3806   for ac_dir in $ac_dummy; do
3807     test -z "$ac_dir" && ac_dir=.
3808     if test -f $ac_dir/${ac_tool_prefix}file; then
3809       lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
3810       if test -n "$file_magic_test_file"; then
3811         case $deplibs_check_method in
3812         "file_magic "*)
3813           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
3814           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
3815           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
3816             egrep "$file_magic_regex" > /dev/null; then
3817             :
3818           else
3819             cat <<EOF 1>&2
3820
3821 *** Warning: the command libtool uses to detect shared libraries,
3822 *** $file_magic_cmd, produces output that libtool cannot recognize.
3823 *** The result is that libtool may fail to recognize shared libraries
3824 *** as such.  This will affect the creation of libtool libraries that
3825 *** depend on shared libraries, but programs linked with such libtool
3826 *** libraries will work regardless of this problem.  Nevertheless, you
3827 *** may want to report the problem to your system manager and/or to
3828 *** bug-libtool@gnu.org
3829
3830 EOF
3831           fi ;;
3832         esac
3833       fi
3834       break
3835     fi
3836   done
3837   IFS="$ac_save_ifs"
3838   MAGIC_CMD="$ac_save_MAGIC_CMD"
3839   ;;
3840 esac
3841 fi
3842
3843 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
3844 if test -n "$MAGIC_CMD"; then
3845   echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
3846 echo "${ECHO_T}$MAGIC_CMD" >&6
3847 else
3848   echo "$as_me:$LINENO: result: no" >&5
3849 echo "${ECHO_T}no" >&6
3850 fi
3851
3852 if test -z "$lt_cv_path_MAGIC_CMD"; then
3853   if test -n "$ac_tool_prefix"; then
3854     echo "$as_me:$LINENO: checking for file" >&5
3855 echo $ECHO_N "checking for file... $ECHO_C" >&6
3856 if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
3857   echo $ECHO_N "(cached) $ECHO_C" >&6
3858 else
3859   case $MAGIC_CMD in
3860   /*)
3861   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
3862   ;;
3863   ?:/*)
3864   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
3865   ;;
3866   *)
3867   ac_save_MAGIC_CMD="$MAGIC_CMD"
3868   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3869   ac_dummy="/usr/bin:$PATH"
3870   for ac_dir in $ac_dummy; do
3871     test -z "$ac_dir" && ac_dir=.
3872     if test -f $ac_dir/file; then
3873       lt_cv_path_MAGIC_CMD="$ac_dir/file"
3874       if test -n "$file_magic_test_file"; then
3875         case $deplibs_check_method in
3876         "file_magic "*)
3877           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
3878           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
3879           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
3880             egrep "$file_magic_regex" > /dev/null; then
3881             :
3882           else
3883             cat <<EOF 1>&2
3884
3885 *** Warning: the command libtool uses to detect shared libraries,
3886 *** $file_magic_cmd, produces output that libtool cannot recognize.
3887 *** The result is that libtool may fail to recognize shared libraries
3888 *** as such.  This will affect the creation of libtool libraries that
3889 *** depend on shared libraries, but programs linked with such libtool
3890 *** libraries will work regardless of this problem.  Nevertheless, you
3891 *** may want to report the problem to your system manager and/or to
3892 *** bug-libtool@gnu.org
3893
3894 EOF
3895           fi ;;
3896         esac
3897       fi
3898       break
3899     fi
3900   done
3901   IFS="$ac_save_ifs"
3902   MAGIC_CMD="$ac_save_MAGIC_CMD"
3903   ;;
3904 esac
3905 fi
3906
3907 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
3908 if test -n "$MAGIC_CMD"; then
3909   echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
3910 echo "${ECHO_T}$MAGIC_CMD" >&6
3911 else
3912   echo "$as_me:$LINENO: result: no" >&5
3913 echo "${ECHO_T}no" >&6
3914 fi
3915
3916   else
3917     MAGIC_CMD=:
3918   fi
3919 fi
3920
3921   fi
3922   ;;
3923 esac
3924
3925 if test -n "$ac_tool_prefix"; then
3926   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3927 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3928 echo "$as_me:$LINENO: checking for $ac_word" >&5
3929 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3930 if test "${ac_cv_prog_RANLIB+set}" = set; then
3931   echo $ECHO_N "(cached) $ECHO_C" >&6
3932 else
3933   if test -n "$RANLIB"; then
3934   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3935 else
3936 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3937 for as_dir in $PATH
3938 do
3939   IFS=$as_save_IFS
3940   test -z "$as_dir" && as_dir=.
3941   for ac_exec_ext in '' $ac_executable_extensions; do
3942   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3943     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3944     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3945     break 2
3946   fi
3947 done
3948 done
3949
3950 fi
3951 fi
3952 RANLIB=$ac_cv_prog_RANLIB
3953 if test -n "$RANLIB"; then
3954   echo "$as_me:$LINENO: result: $RANLIB" >&5
3955 echo "${ECHO_T}$RANLIB" >&6
3956 else
3957   echo "$as_me:$LINENO: result: no" >&5
3958 echo "${ECHO_T}no" >&6
3959 fi
3960
3961 fi
3962 if test -z "$ac_cv_prog_RANLIB"; then
3963   ac_ct_RANLIB=$RANLIB
3964   # Extract the first word of "ranlib", so it can be a program name with args.
3965 set dummy ranlib; ac_word=$2
3966 echo "$as_me:$LINENO: checking for $ac_word" >&5
3967 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3968 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3969   echo $ECHO_N "(cached) $ECHO_C" >&6
3970 else
3971   if test -n "$ac_ct_RANLIB"; then
3972   ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3973 else
3974 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3975 for as_dir in $PATH
3976 do
3977   IFS=$as_save_IFS
3978   test -z "$as_dir" && as_dir=.
3979   for ac_exec_ext in '' $ac_executable_extensions; do
3980   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3981     ac_cv_prog_ac_ct_RANLIB="ranlib"
3982     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3983     break 2
3984   fi
3985 done
3986 done
3987
3988   test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3989 fi
3990 fi
3991 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3992 if test -n "$ac_ct_RANLIB"; then
3993   echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3994 echo "${ECHO_T}$ac_ct_RANLIB" >&6
3995 else
3996   echo "$as_me:$LINENO: result: no" >&5
3997 echo "${ECHO_T}no" >&6
3998 fi
3999
4000   RANLIB=$ac_ct_RANLIB
4001 else
4002   RANLIB="$ac_cv_prog_RANLIB"
4003 fi
4004
4005 if test -n "$ac_tool_prefix"; then
4006   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
4007 set dummy ${ac_tool_prefix}strip; ac_word=$2
4008 echo "$as_me:$LINENO: checking for $ac_word" >&5
4009 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4010 if test "${ac_cv_prog_STRIP+set}" = set; then
4011   echo $ECHO_N "(cached) $ECHO_C" >&6
4012 else
4013   if test -n "$STRIP"; then
4014   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
4015 else
4016 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4017 for as_dir in $PATH
4018 do
4019   IFS=$as_save_IFS
4020   test -z "$as_dir" && as_dir=.
4021   for ac_exec_ext in '' $ac_executable_extensions; do
4022   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4023     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
4024     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4025     break 2
4026   fi
4027 done
4028 done
4029
4030 fi
4031 fi
4032 STRIP=$ac_cv_prog_STRIP
4033 if test -n "$STRIP"; then
4034   echo "$as_me:$LINENO: result: $STRIP" >&5
4035 echo "${ECHO_T}$STRIP" >&6
4036 else
4037   echo "$as_me:$LINENO: result: no" >&5
4038 echo "${ECHO_T}no" >&6
4039 fi
4040
4041 fi
4042 if test -z "$ac_cv_prog_STRIP"; then
4043   ac_ct_STRIP=$STRIP
4044   # Extract the first word of "strip", so it can be a program name with args.
4045 set dummy strip; ac_word=$2
4046 echo "$as_me:$LINENO: checking for $ac_word" >&5
4047 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4048 if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
4049   echo $ECHO_N "(cached) $ECHO_C" >&6
4050 else
4051   if test -n "$ac_ct_STRIP"; then
4052   ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
4053 else
4054 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4055 for as_dir in $PATH
4056 do
4057   IFS=$as_save_IFS
4058   test -z "$as_dir" && as_dir=.
4059   for ac_exec_ext in '' $ac_executable_extensions; do
4060   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4061     ac_cv_prog_ac_ct_STRIP="strip"
4062     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4063     break 2
4064   fi
4065 done
4066 done
4067
4068   test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
4069 fi
4070 fi
4071 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
4072 if test -n "$ac_ct_STRIP"; then
4073   echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
4074 echo "${ECHO_T}$ac_ct_STRIP" >&6
4075 else
4076   echo "$as_me:$LINENO: result: no" >&5
4077 echo "${ECHO_T}no" >&6
4078 fi
4079
4080   STRIP=$ac_ct_STRIP
4081 else
4082   STRIP="$ac_cv_prog_STRIP"
4083 fi
4084
4085
4086 # Check for any special flags to pass to ltconfig.
4087 libtool_flags="--cache-file=$cache_file"
4088 test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
4089 test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
4090 test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
4091 test "$GCC" = yes && libtool_flags="$libtool_flags --with-gcc"
4092 test "$lt_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
4093
4094
4095 # Check whether --enable-libtool-lock or --disable-libtool-lock was given.
4096 if test "${enable_libtool_lock+set}" = set; then
4097   enableval="$enable_libtool_lock"
4098
4099 fi;
4100 test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
4101 test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
4102
4103
4104 # Check whether --with-pic or --without-pic was given.
4105 if test "${with_pic+set}" = set; then
4106   withval="$with_pic"
4107   pic_mode="$withval"
4108 else
4109   pic_mode=default
4110 fi;
4111 test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic"
4112 test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
4113
4114 # Some flags need to be propagated to the compiler or linker for good
4115 # libtool support.
4116 case $host in
4117 *-*-irix6*)
4118   # Find out which ABI we are using.
4119   echo '#line 4119 "configure"' > conftest.$ac_ext
4120   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4121   (eval $ac_compile) 2>&5
4122   ac_status=$?
4123   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4124   (exit $ac_status); }; then
4125    if test "$lt_cv_prog_gnu_ld" = yes; then
4126     case `/usr/bin/file conftest.$ac_objext` in
4127     *32-bit*)
4128       LD="${LD-ld} -melf32bsmip"
4129       ;;
4130     *N32*)
4131       LD="${LD-ld} -melf32bmipn32"
4132       ;;
4133     *64-bit*)
4134       LD="${LD-ld} -melf64bmip"
4135       ;;
4136     esac
4137    else
4138     case `/usr/bin/file conftest.$ac_objext` in
4139     *32-bit*)
4140       LD="${LD-ld} -32"
4141       ;;
4142     *N32*)
4143       LD="${LD-ld} -n32"
4144       ;;
4145     *64-bit*)
4146       LD="${LD-ld} -64"
4147       ;;
4148     esac
4149    fi
4150   fi
4151   rm -rf conftest*
4152   ;;
4153
4154 ia64-*-hpux*)
4155   # Find out which ABI we are using.
4156   echo 'int i;' > conftest.$ac_ext
4157   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4158   (eval $ac_compile) 2>&5
4159   ac_status=$?
4160   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4161   (exit $ac_status); }; then
4162     case "`/usr/bin/file conftest.o`" in
4163     *ELF-32*)
4164       HPUX_IA64_MODE="32"
4165       ;;
4166     *ELF-64*)
4167       HPUX_IA64_MODE="64"
4168       ;;
4169     esac
4170   fi
4171   rm -rf conftest*
4172   ;;
4173
4174 x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*)
4175   # Find out which ABI we are using.
4176   echo 'int i;' > conftest.$ac_ext
4177   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4178   (eval $ac_compile) 2>&5
4179   ac_status=$?
4180   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4181   (exit $ac_status); }; then
4182     case "`/usr/bin/file conftest.o`" in
4183     *32-bit*)
4184       case $host in
4185         x86_64-*linux*)
4186           LD="${LD-ld} -m elf_i386"
4187           ;;
4188         ppc64-*linux*|powerpc64-*linux*)
4189           LD="${LD-ld} -m elf32ppclinux"
4190           ;;
4191         s390x-*linux*)
4192           LD="${LD-ld} -m elf_s390"
4193           ;;
4194         sparc64-*linux*)
4195           LD="${LD-ld} -m elf32_sparc"
4196           ;;
4197       esac
4198       ;;
4199     *64-bit*)
4200       case $host in
4201         x86_64-*linux*)
4202           LD="${LD-ld} -m elf_x86_64"
4203           ;;
4204         ppc*-*linux*|powerpc*-*linux*)
4205           LD="${LD-ld} -m elf64ppc"
4206           ;;
4207         s390*-*linux*)
4208           LD="${LD-ld} -m elf64_s390"
4209           ;;
4210         sparc*-*linux*)
4211           LD="${LD-ld} -m elf64_sparc"
4212           ;;
4213       esac
4214       ;;
4215     esac
4216   fi
4217   rm -rf conftest*
4218   ;;
4219
4220 *-*-sco3.2v5*)
4221   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
4222   SAVE_CFLAGS="$CFLAGS"
4223   CFLAGS="$CFLAGS -belf"
4224   echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
4225 echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6
4226 if test "${lt_cv_cc_needs_belf+set}" = set; then
4227   echo $ECHO_N "(cached) $ECHO_C" >&6
4228 else
4229
4230
4231      ac_ext=c
4232 ac_cpp='$CPP $CPPFLAGS'
4233 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4234 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4235 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4236
4237      if test x$gcc_no_link = xyes; then
4238   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
4239 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
4240    { (exit 1); exit 1; }; }
4241 fi
4242 cat >conftest.$ac_ext <<_ACEOF
4243 /* confdefs.h.  */
4244 _ACEOF
4245 cat confdefs.h >>conftest.$ac_ext
4246 cat >>conftest.$ac_ext <<_ACEOF
4247 /* end confdefs.h.  */
4248
4249 int
4250 main ()
4251 {
4252
4253   ;
4254   return 0;
4255 }
4256 _ACEOF
4257 rm -f conftest.$ac_objext conftest$ac_exeext
4258 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4259   (eval $ac_link) 2>conftest.er1
4260   ac_status=$?
4261   grep -v '^ *+' conftest.er1 >conftest.err
4262   rm -f conftest.er1
4263   cat conftest.err >&5
4264   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4265   (exit $ac_status); } &&
4266          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
4267   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4268   (eval $ac_try) 2>&5
4269   ac_status=$?
4270   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4271   (exit $ac_status); }; } &&
4272          { ac_try='test -s conftest$ac_exeext'
4273   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4274   (eval $ac_try) 2>&5
4275   ac_status=$?
4276   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4277   (exit $ac_status); }; }; then
4278   lt_cv_cc_needs_belf=yes
4279 else
4280   echo "$as_me: failed program was:" >&5
4281 sed 's/^/| /' conftest.$ac_ext >&5
4282
4283 lt_cv_cc_needs_belf=no
4284 fi
4285 rm -f conftest.err conftest.$ac_objext \
4286       conftest$ac_exeext conftest.$ac_ext
4287      ac_ext=c
4288 ac_cpp='$CPP $CPPFLAGS'
4289 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4290 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4291 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4292
4293 fi
4294 echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
4295 echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6
4296   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
4297     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
4298     CFLAGS="$SAVE_CFLAGS"
4299   fi
4300   ;;
4301
4302
4303 esac
4304
4305
4306 # Save cache, so that ltconfig can load it
4307 cat >confcache <<\_ACEOF
4308 # This file is a shell script that caches the results of configure
4309 # tests run on this system so they can be shared between configure
4310 # scripts and configure runs, see configure's option --config-cache.
4311 # It is not useful on other systems.  If it contains results you don't
4312 # want to keep, you may remove or edit it.
4313 #
4314 # config.status only pays attention to the cache file if you give it
4315 # the --recheck option to rerun configure.
4316 #
4317 # `ac_cv_env_foo' variables (set or unset) will be overridden when
4318 # loading this file, other *unset* `ac_cv_foo' will be assigned the
4319 # following values.
4320
4321 _ACEOF
4322
4323 # The following way of writing the cache mishandles newlines in values,
4324 # but we know of no workaround that is simple, portable, and efficient.
4325 # So, don't put newlines in cache variables' values.
4326 # Ultrix sh set writes to stderr and can't be redirected directly,
4327 # and sets the high bit in the cache file unless we assign to the vars.
4328 {
4329   (set) 2>&1 |
4330     case `(ac_space=' '; set | grep ac_space) 2>&1` in
4331     *ac_space=\ *)
4332       # `set' does not quote correctly, so add quotes (double-quote
4333       # substitution turns \\\\ into \\, and sed turns \\ into \).
4334       sed -n \
4335         "s/'/'\\\\''/g;
4336           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
4337       ;;
4338     *)
4339       # `set' quotes correctly as required by POSIX, so do not add quotes.
4340       sed -n \
4341         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
4342       ;;
4343     esac;
4344 } |
4345   sed '
4346      t clear
4347      : clear
4348      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
4349      t end
4350      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
4351      : end' >>confcache
4352 if diff $cache_file confcache >/dev/null 2>&1; then :; else
4353   if test -w $cache_file; then
4354     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
4355     cat confcache >$cache_file
4356   else
4357     echo "not updating unwritable cache $cache_file"
4358   fi
4359 fi
4360 rm -f confcache
4361
4362 # Actually configure libtool.  ac_aux_dir is where install-sh is found.
4363 AR="$AR" LTCC="$CC" CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
4364 MAGIC_CMD="$MAGIC_CMD" LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
4365 LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \
4366 AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \
4367 objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \
4368 deplibs_check_method="$deplibs_check_method" file_magic_cmd="$file_magic_cmd" \
4369 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
4370 $libtool_flags --no-verify --build="$build" $ac_aux_dir/ltmain.sh $host \
4371 || { { echo "$as_me:$LINENO: error: libtool configure failed" >&5
4372 echo "$as_me: error: libtool configure failed" >&2;}
4373    { (exit 1); exit 1; }; }
4374
4375 # Reload cache, that may have been modified by ltconfig
4376 if test -r "$cache_file"; then
4377   # Some versions of bash will fail to source /dev/null (special
4378   # files actually), so we avoid doing that.
4379   if test -f "$cache_file"; then
4380     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
4381 echo "$as_me: loading cache $cache_file" >&6;}
4382     case $cache_file in
4383       [\\/]* | ?:[\\/]* ) . $cache_file;;
4384       *)                      . ./$cache_file;;
4385     esac
4386   fi
4387 else
4388   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
4389 echo "$as_me: creating cache $cache_file" >&6;}
4390   >$cache_file
4391 fi
4392
4393
4394 # This can be used to rebuild libtool when needed
4395 LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh $ac_aux_dir/ltcf-c.sh"
4396
4397 # Always use our own libtool.
4398 LIBTOOL='$(SHELL) $(top_builddir)/libtool'
4399
4400 # Redirect the config.log output again, so that the ltconfig log is not
4401 # clobbered by the next message.
4402 exec 5>>./config.log
4403
4404
4405
4406
4407
4408
4409
4410
4411 #AC_MSG_NOTICE([====== Finished libtool configuration]) ; sleep 10
4412
4413 # We need gfortran to compile parts of the library
4414 #AC_PROG_FC(gfortran)
4415 FC="$GFORTRAN"
4416 ac_ext=${FC_SRCEXT-f}
4417 ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4418 ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4419 ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4420 if test -n "$ac_tool_prefix"; then
4421   for ac_prog in gfortran
4422   do
4423     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4424 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4425 echo "$as_me:$LINENO: checking for $ac_word" >&5
4426 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4427 if test "${ac_cv_prog_FC+set}" = set; then
4428   echo $ECHO_N "(cached) $ECHO_C" >&6
4429 else
4430   if test -n "$FC"; then
4431   ac_cv_prog_FC="$FC" # Let the user override the test.
4432 else
4433 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4434 for as_dir in $PATH
4435 do
4436   IFS=$as_save_IFS
4437   test -z "$as_dir" && as_dir=.
4438   for ac_exec_ext in '' $ac_executable_extensions; do
4439   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4440     ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
4441     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4442     break 2
4443   fi
4444 done
4445 done
4446
4447 fi
4448 fi
4449 FC=$ac_cv_prog_FC
4450 if test -n "$FC"; then
4451   echo "$as_me:$LINENO: result: $FC" >&5
4452 echo "${ECHO_T}$FC" >&6
4453 else
4454   echo "$as_me:$LINENO: result: no" >&5
4455 echo "${ECHO_T}no" >&6
4456 fi
4457
4458     test -n "$FC" && break
4459   done
4460 fi
4461 if test -z "$FC"; then
4462   ac_ct_FC=$FC
4463   for ac_prog in gfortran
4464 do
4465   # Extract the first word of "$ac_prog", so it can be a program name with args.
4466 set dummy $ac_prog; ac_word=$2
4467 echo "$as_me:$LINENO: checking for $ac_word" >&5
4468 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4469 if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
4470   echo $ECHO_N "(cached) $ECHO_C" >&6
4471 else
4472   if test -n "$ac_ct_FC"; then
4473   ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
4474 else
4475 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4476 for as_dir in $PATH
4477 do
4478   IFS=$as_save_IFS
4479   test -z "$as_dir" && as_dir=.
4480   for ac_exec_ext in '' $ac_executable_extensions; do
4481   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4482     ac_cv_prog_ac_ct_FC="$ac_prog"
4483     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4484     break 2
4485   fi
4486 done
4487 done
4488
4489 fi
4490 fi
4491 ac_ct_FC=$ac_cv_prog_ac_ct_FC
4492 if test -n "$ac_ct_FC"; then
4493   echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
4494 echo "${ECHO_T}$ac_ct_FC" >&6
4495 else
4496   echo "$as_me:$LINENO: result: no" >&5
4497 echo "${ECHO_T}no" >&6
4498 fi
4499
4500   test -n "$ac_ct_FC" && break
4501 done
4502
4503   FC=$ac_ct_FC
4504 fi
4505
4506
4507 # Provide some information about the compiler.
4508 echo "$as_me:4508:" \
4509      "checking for Fortran compiler version" >&5
4510 ac_compiler=`set X $ac_compile; echo $2`
4511 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
4512   (eval $ac_compiler --version </dev/null >&5) 2>&5
4513   ac_status=$?
4514   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4515   (exit $ac_status); }
4516 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
4517   (eval $ac_compiler -v </dev/null >&5) 2>&5
4518   ac_status=$?
4519   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4520   (exit $ac_status); }
4521 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
4522   (eval $ac_compiler -V </dev/null >&5) 2>&5
4523   ac_status=$?
4524   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4525   (exit $ac_status); }
4526 rm -f a.out
4527
4528 # If we don't use `.F' as extension, the preprocessor is not run on the
4529 # input file.  (Note that this only needs to work for GNU compilers.)
4530 ac_save_ext=$ac_ext
4531 ac_ext=F
4532 echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
4533 echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
4534 if test "${ac_cv_fc_compiler_gnu+set}" = set; then
4535   echo $ECHO_N "(cached) $ECHO_C" >&6
4536 else
4537   cat >conftest.$ac_ext <<_ACEOF
4538       program main
4539 #ifndef __GNUC__
4540        choke me
4541 #endif
4542
4543       end
4544 _ACEOF
4545 rm -f conftest.$ac_objext
4546 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4547   (eval $ac_compile) 2>conftest.er1
4548   ac_status=$?
4549   grep -v '^ *+' conftest.er1 >conftest.err
4550   rm -f conftest.er1
4551   cat conftest.err >&5
4552   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4553   (exit $ac_status); } &&
4554          { ac_try='test -z "$ac_fc_werror_flag"                  || test ! -s conftest.err'
4555   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4556   (eval $ac_try) 2>&5
4557   ac_status=$?
4558   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4559   (exit $ac_status); }; } &&
4560          { ac_try='test -s conftest.$ac_objext'
4561   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4562   (eval $ac_try) 2>&5
4563   ac_status=$?
4564   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4565   (exit $ac_status); }; }; then
4566   ac_compiler_gnu=yes
4567 else
4568   echo "$as_me: failed program was:" >&5
4569 sed 's/^/| /' conftest.$ac_ext >&5
4570
4571 ac_compiler_gnu=no
4572 fi
4573 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4574 ac_cv_fc_compiler_gnu=$ac_compiler_gnu
4575
4576 fi
4577 echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
4578 echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
4579 ac_ext=$ac_save_ext
4580 ac_test_FFLAGS=${FCFLAGS+set}
4581 ac_save_FFLAGS=$FCFLAGS
4582 FCFLAGS=
4583 echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
4584 echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
4585 if test "${ac_cv_prog_fc_g+set}" = set; then
4586   echo $ECHO_N "(cached) $ECHO_C" >&6
4587 else
4588   FCFLAGS=-g
4589 cat >conftest.$ac_ext <<_ACEOF
4590       program main
4591
4592       end
4593 _ACEOF
4594 rm -f conftest.$ac_objext
4595 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4596   (eval $ac_compile) 2>conftest.er1
4597   ac_status=$?
4598   grep -v '^ *+' conftest.er1 >conftest.err
4599   rm -f conftest.er1
4600   cat conftest.err >&5
4601   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4602   (exit $ac_status); } &&
4603          { ac_try='test -z "$ac_fc_werror_flag"                  || test ! -s conftest.err'
4604   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4605   (eval $ac_try) 2>&5
4606   ac_status=$?
4607   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4608   (exit $ac_status); }; } &&
4609          { ac_try='test -s conftest.$ac_objext'
4610   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4611   (eval $ac_try) 2>&5
4612   ac_status=$?
4613   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4614   (exit $ac_status); }; }; then
4615   ac_cv_prog_fc_g=yes
4616 else
4617   echo "$as_me: failed program was:" >&5
4618 sed 's/^/| /' conftest.$ac_ext >&5
4619
4620 ac_cv_prog_fc_g=no
4621 fi
4622 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4623
4624 fi
4625 echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
4626 echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
4627 if test "$ac_test_FFLAGS" = set; then
4628   FCFLAGS=$ac_save_FFLAGS
4629 elif test $ac_cv_prog_fc_g = yes; then
4630   if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4631     FCFLAGS="-g -O2"
4632   else
4633     FCFLAGS="-g"
4634   fi
4635 else
4636   if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4637     FCFLAGS="-O2"
4638   else
4639     FCFLAGS=
4640   fi
4641 fi
4642
4643 ac_ext=c
4644 ac_cpp='$CPP $CPPFLAGS'
4645 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4646 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4647 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4648
4649
4650 # extra LD Flags which are required for targets
4651 case "${host}" in
4652   *-darwin*)
4653     # Darwin needs -single_module when linking libgfortran
4654     extra_ldflags_libgfortran=-Wl,-single_module
4655     ;;
4656 esac
4657
4658
4659 # Check whether --enable-largefile or --disable-largefile was given.
4660 if test "${enable_largefile+set}" = set; then
4661   enableval="$enable_largefile"
4662
4663 fi;
4664 if test "$enable_largefile" != no; then
4665
4666   echo "$as_me:$LINENO: checking for special C compiler options needed for large files" >&5
4667 echo $ECHO_N "checking for special C compiler options needed for large files... $ECHO_C" >&6
4668 if test "${ac_cv_sys_largefile_CC+set}" = set; then
4669   echo $ECHO_N "(cached) $ECHO_C" >&6
4670 else
4671   ac_cv_sys_largefile_CC=no
4672      if test "$GCC" != yes; then
4673        ac_save_CC=$CC
4674        while :; do
4675          # IRIX 6.2 and later do not support large files by default,
4676          # so use the C compiler's -n32 option if that helps.
4677          cat >conftest.$ac_ext <<_ACEOF
4678 /* confdefs.h.  */
4679 _ACEOF
4680 cat confdefs.h >>conftest.$ac_ext
4681 cat >>conftest.$ac_ext <<_ACEOF
4682 /* end confdefs.h.  */
4683 #include <sys/types.h>
4684  /* Check that off_t can represent 2**63 - 1 correctly.
4685     We can't simply define LARGE_OFF_T to be 9223372036854775807,
4686     since some C++ compilers masquerading as C compilers
4687     incorrectly reject 9223372036854775807.  */
4688 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4689   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4690                        && LARGE_OFF_T % 2147483647 == 1)
4691                       ? 1 : -1];
4692 int
4693 main ()
4694 {
4695
4696   ;
4697   return 0;
4698 }
4699 _ACEOF
4700          rm -f conftest.$ac_objext
4701 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4702   (eval $ac_compile) 2>conftest.er1
4703   ac_status=$?
4704   grep -v '^ *+' conftest.er1 >conftest.err
4705   rm -f conftest.er1
4706   cat conftest.err >&5
4707   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4708   (exit $ac_status); } &&
4709          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
4710   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4711   (eval $ac_try) 2>&5
4712   ac_status=$?
4713   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4714   (exit $ac_status); }; } &&
4715          { ac_try='test -s conftest.$ac_objext'
4716   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4717   (eval $ac_try) 2>&5
4718   ac_status=$?
4719   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4720   (exit $ac_status); }; }; then
4721   break
4722 else
4723   echo "$as_me: failed program was:" >&5
4724 sed 's/^/| /' conftest.$ac_ext >&5
4725
4726 fi
4727 rm -f conftest.err conftest.$ac_objext
4728          CC="$CC -n32"
4729          rm -f conftest.$ac_objext
4730 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4731   (eval $ac_compile) 2>conftest.er1
4732   ac_status=$?
4733   grep -v '^ *+' conftest.er1 >conftest.err
4734   rm -f conftest.er1
4735   cat conftest.err >&5
4736   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4737   (exit $ac_status); } &&
4738          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
4739   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4740   (eval $ac_try) 2>&5
4741   ac_status=$?
4742   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4743   (exit $ac_status); }; } &&
4744          { ac_try='test -s conftest.$ac_objext'
4745   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4746   (eval $ac_try) 2>&5
4747   ac_status=$?
4748   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4749   (exit $ac_status); }; }; then
4750   ac_cv_sys_largefile_CC=' -n32'; break
4751 else
4752   echo "$as_me: failed program was:" >&5
4753 sed 's/^/| /' conftest.$ac_ext >&5
4754
4755 fi
4756 rm -f conftest.err conftest.$ac_objext
4757          break
4758        done
4759        CC=$ac_save_CC
4760        rm -f conftest.$ac_ext
4761     fi
4762 fi
4763 echo "$as_me:$LINENO: result: $ac_cv_sys_largefile_CC" >&5
4764 echo "${ECHO_T}$ac_cv_sys_largefile_CC" >&6
4765   if test "$ac_cv_sys_largefile_CC" != no; then
4766     CC=$CC$ac_cv_sys_largefile_CC
4767   fi
4768
4769   echo "$as_me:$LINENO: checking for _FILE_OFFSET_BITS value needed for large files" >&5
4770 echo $ECHO_N "checking for _FILE_OFFSET_BITS value needed for large files... $ECHO_C" >&6
4771 if test "${ac_cv_sys_file_offset_bits+set}" = set; then
4772   echo $ECHO_N "(cached) $ECHO_C" >&6
4773 else
4774   while :; do
4775   ac_cv_sys_file_offset_bits=no
4776   cat >conftest.$ac_ext <<_ACEOF
4777 /* confdefs.h.  */
4778 _ACEOF
4779 cat confdefs.h >>conftest.$ac_ext
4780 cat >>conftest.$ac_ext <<_ACEOF
4781 /* end confdefs.h.  */
4782 #include <sys/types.h>
4783  /* Check that off_t can represent 2**63 - 1 correctly.
4784     We can't simply define LARGE_OFF_T to be 9223372036854775807,
4785     since some C++ compilers masquerading as C compilers
4786     incorrectly reject 9223372036854775807.  */
4787 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4788   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4789                        && LARGE_OFF_T % 2147483647 == 1)
4790                       ? 1 : -1];
4791 int
4792 main ()
4793 {
4794
4795   ;
4796   return 0;
4797 }
4798 _ACEOF
4799 rm -f conftest.$ac_objext
4800 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4801   (eval $ac_compile) 2>conftest.er1
4802   ac_status=$?
4803   grep -v '^ *+' conftest.er1 >conftest.err
4804   rm -f conftest.er1
4805   cat conftest.err >&5
4806   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4807   (exit $ac_status); } &&
4808          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
4809   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4810   (eval $ac_try) 2>&5
4811   ac_status=$?
4812   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4813   (exit $ac_status); }; } &&
4814          { ac_try='test -s conftest.$ac_objext'
4815   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4816   (eval $ac_try) 2>&5
4817   ac_status=$?
4818   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4819   (exit $ac_status); }; }; then
4820   break
4821 else
4822   echo "$as_me: failed program was:" >&5
4823 sed 's/^/| /' conftest.$ac_ext >&5
4824
4825 fi
4826 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4827   cat >conftest.$ac_ext <<_ACEOF
4828 /* confdefs.h.  */
4829 _ACEOF
4830 cat confdefs.h >>conftest.$ac_ext
4831 cat >>conftest.$ac_ext <<_ACEOF
4832 /* end confdefs.h.  */
4833 #define _FILE_OFFSET_BITS 64
4834 #include <sys/types.h>
4835  /* Check that off_t can represent 2**63 - 1 correctly.
4836     We can't simply define LARGE_OFF_T to be 9223372036854775807,
4837     since some C++ compilers masquerading as C compilers
4838     incorrectly reject 9223372036854775807.  */
4839 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4840   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4841                        && LARGE_OFF_T % 2147483647 == 1)
4842                       ? 1 : -1];
4843 int
4844 main ()
4845 {
4846
4847   ;
4848   return 0;
4849 }
4850 _ACEOF
4851 rm -f conftest.$ac_objext
4852 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4853   (eval $ac_compile) 2>conftest.er1
4854   ac_status=$?
4855   grep -v '^ *+' conftest.er1 >conftest.err
4856   rm -f conftest.er1
4857   cat conftest.err >&5
4858   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4859   (exit $ac_status); } &&
4860          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
4861   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4862   (eval $ac_try) 2>&5
4863   ac_status=$?
4864   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4865   (exit $ac_status); }; } &&
4866          { ac_try='test -s conftest.$ac_objext'
4867   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4868   (eval $ac_try) 2>&5
4869   ac_status=$?
4870   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4871   (exit $ac_status); }; }; then
4872   ac_cv_sys_file_offset_bits=64; break
4873 else
4874   echo "$as_me: failed program was:" >&5
4875 sed 's/^/| /' conftest.$ac_ext >&5
4876
4877 fi
4878 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4879   break
4880 done
4881 fi
4882 echo "$as_me:$LINENO: result: $ac_cv_sys_file_offset_bits" >&5
4883 echo "${ECHO_T}$ac_cv_sys_file_offset_bits" >&6
4884 if test "$ac_cv_sys_file_offset_bits" != no; then
4885
4886 cat >>confdefs.h <<_ACEOF
4887 #define _FILE_OFFSET_BITS $ac_cv_sys_file_offset_bits
4888 _ACEOF
4889
4890 fi
4891 rm -f conftest*
4892   echo "$as_me:$LINENO: checking for _LARGE_FILES value needed for large files" >&5
4893 echo $ECHO_N "checking for _LARGE_FILES value needed for large files... $ECHO_C" >&6
4894 if test "${ac_cv_sys_large_files+set}" = set; then
4895   echo $ECHO_N "(cached) $ECHO_C" >&6
4896 else
4897   while :; do
4898   ac_cv_sys_large_files=no
4899   cat >conftest.$ac_ext <<_ACEOF
4900 /* confdefs.h.  */
4901 _ACEOF
4902 cat confdefs.h >>conftest.$ac_ext
4903 cat >>conftest.$ac_ext <<_ACEOF
4904 /* end confdefs.h.  */
4905 #include <sys/types.h>
4906  /* Check that off_t can represent 2**63 - 1 correctly.
4907     We can't simply define LARGE_OFF_T to be 9223372036854775807,
4908     since some C++ compilers masquerading as C compilers
4909     incorrectly reject 9223372036854775807.  */
4910 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4911   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4912                        && LARGE_OFF_T % 2147483647 == 1)
4913                       ? 1 : -1];
4914 int
4915 main ()
4916 {
4917
4918   ;
4919   return 0;
4920 }
4921 _ACEOF
4922 rm -f conftest.$ac_objext
4923 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4924   (eval $ac_compile) 2>conftest.er1
4925   ac_status=$?
4926   grep -v '^ *+' conftest.er1 >conftest.err
4927   rm -f conftest.er1
4928   cat conftest.err >&5
4929   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4930   (exit $ac_status); } &&
4931          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
4932   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4933   (eval $ac_try) 2>&5
4934   ac_status=$?
4935   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4936   (exit $ac_status); }; } &&
4937          { ac_try='test -s conftest.$ac_objext'
4938   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4939   (eval $ac_try) 2>&5
4940   ac_status=$?
4941   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4942   (exit $ac_status); }; }; then
4943   break
4944 else
4945   echo "$as_me: failed program was:" >&5
4946 sed 's/^/| /' conftest.$ac_ext >&5
4947
4948 fi
4949 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4950   cat >conftest.$ac_ext <<_ACEOF
4951 /* confdefs.h.  */
4952 _ACEOF
4953 cat confdefs.h >>conftest.$ac_ext
4954 cat >>conftest.$ac_ext <<_ACEOF
4955 /* end confdefs.h.  */
4956 #define _LARGE_FILES 1
4957 #include <sys/types.h>
4958  /* Check that off_t can represent 2**63 - 1 correctly.
4959     We can't simply define LARGE_OFF_T to be 9223372036854775807,
4960     since some C++ compilers masquerading as C compilers
4961     incorrectly reject 9223372036854775807.  */
4962 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4963   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4964                        && LARGE_OFF_T % 2147483647 == 1)
4965                       ? 1 : -1];
4966 int
4967 main ()
4968 {
4969
4970   ;
4971   return 0;
4972 }
4973 _ACEOF
4974 rm -f conftest.$ac_objext
4975 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4976   (eval $ac_compile) 2>conftest.er1
4977   ac_status=$?
4978   grep -v '^ *+' conftest.er1 >conftest.err
4979   rm -f conftest.er1
4980   cat conftest.err >&5
4981   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4982   (exit $ac_status); } &&
4983          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
4984   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4985   (eval $ac_try) 2>&5
4986   ac_status=$?
4987   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4988   (exit $ac_status); }; } &&
4989          { ac_try='test -s conftest.$ac_objext'
4990   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4991   (eval $ac_try) 2>&5
4992   ac_status=$?
4993   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4994   (exit $ac_status); }; }; then
4995   ac_cv_sys_large_files=1; break
4996 else
4997   echo "$as_me: failed program was:" >&5
4998 sed 's/^/| /' conftest.$ac_ext >&5
4999
5000 fi
5001 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5002   break
5003 done
5004 fi
5005 echo "$as_me:$LINENO: result: $ac_cv_sys_large_files" >&5
5006 echo "${ECHO_T}$ac_cv_sys_large_files" >&6
5007 if test "$ac_cv_sys_large_files" != no; then
5008
5009 cat >>confdefs.h <<_ACEOF
5010 #define _LARGE_FILES $ac_cv_sys_large_files
5011 _ACEOF
5012
5013 fi
5014 rm -f conftest*
5015 fi
5016
5017 if test x$gcc_no_link = xyes; then
5018   if test "x${ac_cv_func_mmap_fixed_mapped+set}" != xset; then
5019     ac_cv_func_mmap_fixed_mapped=no
5020   fi
5021 fi
5022 if test "x${ac_cv_func_mmap_fixed_mapped}" != xno; then
5023   ac_ext=c
5024 ac_cpp='$CPP $CPPFLAGS'
5025 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5026 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5027 ac_compiler_gnu=$ac_cv_c_compiler_gnu
5028 echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
5029 echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
5030 # On Suns, sometimes $CPP names a directory.
5031 if test -n "$CPP" && test -d "$CPP"; then
5032   CPP=
5033 fi
5034 if test -z "$CPP"; then
5035   if test "${ac_cv_prog_CPP+set}" = set; then
5036   echo $ECHO_N "(cached) $ECHO_C" >&6
5037 else
5038       # Double quotes because CPP needs to be expanded
5039     for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
5040     do
5041       ac_preproc_ok=false
5042 for ac_c_preproc_warn_flag in '' yes
5043 do
5044   # Use a header file that comes with gcc, so configuring glibc
5045   # with a fresh cross-compiler works.
5046   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5047   # <limits.h> exists even on freestanding compilers.
5048   # On the NeXT, cc -E runs the code through the compiler's parser,
5049   # not just through cpp. "Syntax error" is here to catch this case.
5050   cat >conftest.$ac_ext <<_ACEOF
5051 /* confdefs.h.  */
5052 _ACEOF
5053 cat confdefs.h >>conftest.$ac_ext
5054 cat >>conftest.$ac_ext <<_ACEOF
5055 /* end confdefs.h.  */
5056 #ifdef __STDC__
5057 # include <limits.h>
5058 #else
5059 # include <assert.h>
5060 #endif
5061                      Syntax error
5062 _ACEOF
5063 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5064   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5065   ac_status=$?
5066   grep -v '^ *+' conftest.er1 >conftest.err
5067   rm -f conftest.er1
5068   cat conftest.err >&5
5069   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5070   (exit $ac_status); } >/dev/null; then
5071   if test -s conftest.err; then
5072     ac_cpp_err=$ac_c_preproc_warn_flag
5073     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5074   else
5075     ac_cpp_err=
5076   fi
5077 else
5078   ac_cpp_err=yes
5079 fi
5080 if test -z "$ac_cpp_err"; then
5081   :
5082 else
5083   echo "$as_me: failed program was:" >&5
5084 sed 's/^/| /' conftest.$ac_ext >&5
5085
5086   # Broken: fails on valid input.
5087 continue
5088 fi
5089 rm -f conftest.err conftest.$ac_ext
5090
5091   # OK, works on sane cases.  Now check whether non-existent headers
5092   # can be detected and how.
5093   cat >conftest.$ac_ext <<_ACEOF
5094 /* confdefs.h.  */
5095 _ACEOF
5096 cat confdefs.h >>conftest.$ac_ext
5097 cat >>conftest.$ac_ext <<_ACEOF
5098 /* end confdefs.h.  */
5099 #include <ac_nonexistent.h>
5100 _ACEOF
5101 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5102   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5103   ac_status=$?
5104   grep -v '^ *+' conftest.er1 >conftest.err
5105   rm -f conftest.er1
5106   cat conftest.err >&5
5107   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5108   (exit $ac_status); } >/dev/null; then
5109   if test -s conftest.err; then
5110     ac_cpp_err=$ac_c_preproc_warn_flag
5111     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5112   else
5113     ac_cpp_err=
5114   fi
5115 else
5116   ac_cpp_err=yes
5117 fi
5118 if test -z "$ac_cpp_err"; then
5119   # Broken: success on invalid input.
5120 continue
5121 else
5122   echo "$as_me: failed program was:" >&5
5123 sed 's/^/| /' conftest.$ac_ext >&5
5124
5125   # Passes both tests.
5126 ac_preproc_ok=:
5127 break
5128 fi
5129 rm -f conftest.err conftest.$ac_ext
5130
5131 done
5132 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5133 rm -f conftest.err conftest.$ac_ext
5134 if $ac_preproc_ok; then
5135   break
5136 fi
5137
5138     done
5139     ac_cv_prog_CPP=$CPP
5140
5141 fi
5142   CPP=$ac_cv_prog_CPP
5143 else
5144   ac_cv_prog_CPP=$CPP
5145 fi
5146 echo "$as_me:$LINENO: result: $CPP" >&5
5147 echo "${ECHO_T}$CPP" >&6
5148 ac_preproc_ok=false
5149 for ac_c_preproc_warn_flag in '' yes
5150 do
5151   # Use a header file that comes with gcc, so configuring glibc
5152   # with a fresh cross-compiler works.
5153   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5154   # <limits.h> exists even on freestanding compilers.
5155   # On the NeXT, cc -E runs the code through the compiler's parser,
5156   # not just through cpp. "Syntax error" is here to catch this case.
5157   cat >conftest.$ac_ext <<_ACEOF
5158 /* confdefs.h.  */
5159 _ACEOF
5160 cat confdefs.h >>conftest.$ac_ext
5161 cat >>conftest.$ac_ext <<_ACEOF
5162 /* end confdefs.h.  */
5163 #ifdef __STDC__
5164 # include <limits.h>
5165 #else
5166 # include <assert.h>
5167 #endif
5168                      Syntax error
5169 _ACEOF
5170 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5171   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5172   ac_status=$?
5173   grep -v '^ *+' conftest.er1 >conftest.err
5174   rm -f conftest.er1
5175   cat conftest.err >&5
5176   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5177   (exit $ac_status); } >/dev/null; then
5178   if test -s conftest.err; then
5179     ac_cpp_err=$ac_c_preproc_warn_flag
5180     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5181   else
5182     ac_cpp_err=
5183   fi
5184 else
5185   ac_cpp_err=yes
5186 fi
5187 if test -z "$ac_cpp_err"; then
5188   :
5189 else
5190   echo "$as_me: failed program was:" >&5
5191 sed 's/^/| /' conftest.$ac_ext >&5
5192
5193   # Broken: fails on valid input.
5194 continue
5195 fi
5196 rm -f conftest.err conftest.$ac_ext
5197
5198   # OK, works on sane cases.  Now check whether non-existent headers
5199   # can be detected and how.
5200   cat >conftest.$ac_ext <<_ACEOF
5201 /* confdefs.h.  */
5202 _ACEOF
5203 cat confdefs.h >>conftest.$ac_ext
5204 cat >>conftest.$ac_ext <<_ACEOF
5205 /* end confdefs.h.  */
5206 #include <ac_nonexistent.h>
5207 _ACEOF
5208 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5209   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5210   ac_status=$?
5211   grep -v '^ *+' conftest.er1 >conftest.err
5212   rm -f conftest.er1
5213   cat conftest.err >&5
5214   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5215   (exit $ac_status); } >/dev/null; then
5216   if test -s conftest.err; then
5217     ac_cpp_err=$ac_c_preproc_warn_flag
5218     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5219   else
5220     ac_cpp_err=
5221   fi
5222 else
5223   ac_cpp_err=yes
5224 fi
5225 if test -z "$ac_cpp_err"; then
5226   # Broken: success on invalid input.
5227 continue
5228 else
5229   echo "$as_me: failed program was:" >&5
5230 sed 's/^/| /' conftest.$ac_ext >&5
5231
5232   # Passes both tests.
5233 ac_preproc_ok=:
5234 break
5235 fi
5236 rm -f conftest.err conftest.$ac_ext
5237
5238 done
5239 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5240 rm -f conftest.err conftest.$ac_ext
5241 if $ac_preproc_ok; then
5242   :
5243 else
5244   { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
5245 See \`config.log' for more details." >&5
5246 echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
5247 See \`config.log' for more details." >&2;}
5248    { (exit 1); exit 1; }; }
5249 fi
5250
5251 ac_ext=c
5252 ac_cpp='$CPP $CPPFLAGS'
5253 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5254 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5255 ac_compiler_gnu=$ac_cv_c_compiler_gnu
5256
5257
5258 echo "$as_me:$LINENO: checking for egrep" >&5
5259 echo $ECHO_N "checking for egrep... $ECHO_C" >&6
5260 if test "${ac_cv_prog_egrep+set}" = set; then
5261   echo $ECHO_N "(cached) $ECHO_C" >&6
5262 else
5263   if echo a | (grep -E '(a|b)') >/dev/null 2>&1
5264     then ac_cv_prog_egrep='grep -E'
5265     else ac_cv_prog_egrep='egrep'
5266     fi
5267 fi
5268 echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
5269 echo "${ECHO_T}$ac_cv_prog_egrep" >&6
5270  EGREP=$ac_cv_prog_egrep
5271
5272
5273 echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5274 echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5275 if test "${ac_cv_header_stdc+set}" = set; then
5276   echo $ECHO_N "(cached) $ECHO_C" >&6
5277 else
5278   cat >conftest.$ac_ext <<_ACEOF
5279 /* confdefs.h.  */
5280 _ACEOF
5281 cat confdefs.h >>conftest.$ac_ext
5282 cat >>conftest.$ac_ext <<_ACEOF
5283 /* end confdefs.h.  */
5284 #include <stdlib.h>
5285 #include <stdarg.h>
5286 #include <string.h>
5287 #include <float.h>
5288
5289 int
5290 main ()
5291 {
5292
5293   ;
5294   return 0;
5295 }
5296 _ACEOF
5297 rm -f conftest.$ac_objext
5298 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5299   (eval $ac_compile) 2>conftest.er1
5300   ac_status=$?
5301   grep -v '^ *+' conftest.er1 >conftest.err
5302   rm -f conftest.er1
5303   cat conftest.err >&5
5304   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5305   (exit $ac_status); } &&
5306          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
5307   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5308   (eval $ac_try) 2>&5
5309   ac_status=$?
5310   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5311   (exit $ac_status); }; } &&
5312          { ac_try='test -s conftest.$ac_objext'
5313   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5314   (eval $ac_try) 2>&5
5315   ac_status=$?
5316   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5317   (exit $ac_status); }; }; then
5318   ac_cv_header_stdc=yes
5319 else
5320   echo "$as_me: failed program was:" >&5
5321 sed 's/^/| /' conftest.$ac_ext >&5
5322
5323 ac_cv_header_stdc=no
5324 fi
5325 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5326
5327 if test $ac_cv_header_stdc = yes; then
5328   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5329   cat >conftest.$ac_ext <<_ACEOF
5330 /* confdefs.h.  */
5331 _ACEOF
5332 cat confdefs.h >>conftest.$ac_ext
5333 cat >>conftest.$ac_ext <<_ACEOF
5334 /* end confdefs.h.  */
5335 #include <string.h>
5336
5337 _ACEOF
5338 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5339   $EGREP "memchr" >/dev/null 2>&1; then
5340   :
5341 else
5342   ac_cv_header_stdc=no
5343 fi
5344 rm -f conftest*
5345
5346 fi
5347
5348 if test $ac_cv_header_stdc = yes; then
5349   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5350   cat >conftest.$ac_ext <<_ACEOF
5351 /* confdefs.h.  */
5352 _ACEOF
5353 cat confdefs.h >>conftest.$ac_ext
5354 cat >>conftest.$ac_ext <<_ACEOF
5355 /* end confdefs.h.  */
5356 #include <stdlib.h>
5357
5358 _ACEOF
5359 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5360   $EGREP "free" >/dev/null 2>&1; then
5361   :
5362 else
5363   ac_cv_header_stdc=no
5364 fi
5365 rm -f conftest*
5366
5367 fi
5368
5369 if test $ac_cv_header_stdc = yes; then
5370   # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5371   if test "$cross_compiling" = yes; then
5372   :
5373 else
5374   cat >conftest.$ac_ext <<_ACEOF
5375 /* confdefs.h.  */
5376 _ACEOF
5377 cat confdefs.h >>conftest.$ac_ext
5378 cat >>conftest.$ac_ext <<_ACEOF
5379 /* end confdefs.h.  */
5380 #include <ctype.h>
5381 #if ((' ' & 0x0FF) == 0x020)
5382 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5383 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5384 #else
5385 # define ISLOWER(c) \
5386                    (('a' <= (c) && (c) <= 'i') \
5387                      || ('j' <= (c) && (c) <= 'r') \
5388                      || ('s' <= (c) && (c) <= 'z'))
5389 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5390 #endif
5391
5392 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5393 int
5394 main ()
5395 {
5396   int i;
5397   for (i = 0; i < 256; i++)
5398     if (XOR (islower (i), ISLOWER (i))
5399         || toupper (i) != TOUPPER (i))
5400       exit(2);
5401   exit (0);
5402 }
5403 _ACEOF
5404 rm -f conftest$ac_exeext
5405 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5406   (eval $ac_link) 2>&5
5407   ac_status=$?
5408   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5409   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5410   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5411   (eval $ac_try) 2>&5
5412   ac_status=$?
5413   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5414   (exit $ac_status); }; }; then
5415   :
5416 else
5417   echo "$as_me: program exited with status $ac_status" >&5
5418 echo "$as_me: failed program was:" >&5
5419 sed 's/^/| /' conftest.$ac_ext >&5
5420
5421 ( exit $ac_status )
5422 ac_cv_header_stdc=no
5423 fi
5424 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5425 fi
5426 fi
5427 fi
5428 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5429 echo "${ECHO_T}$ac_cv_header_stdc" >&6
5430 if test $ac_cv_header_stdc = yes; then
5431
5432 cat >>confdefs.h <<\_ACEOF
5433 #define STDC_HEADERS 1
5434 _ACEOF
5435
5436 fi
5437
5438 # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5439
5440
5441
5442
5443
5444
5445
5446
5447
5448 for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5449                   inttypes.h stdint.h unistd.h
5450 do
5451 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5452 echo "$as_me:$LINENO: checking for $ac_header" >&5
5453 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5454 if eval "test \"\${$as_ac_Header+set}\" = set"; then
5455   echo $ECHO_N "(cached) $ECHO_C" >&6
5456 else
5457   cat >conftest.$ac_ext <<_ACEOF
5458 /* confdefs.h.  */
5459 _ACEOF
5460 cat confdefs.h >>conftest.$ac_ext
5461 cat >>conftest.$ac_ext <<_ACEOF
5462 /* end confdefs.h.  */
5463 $ac_includes_default
5464
5465 #include <$ac_header>
5466 _ACEOF
5467 rm -f conftest.$ac_objext
5468 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5469   (eval $ac_compile) 2>conftest.er1
5470   ac_status=$?
5471   grep -v '^ *+' conftest.er1 >conftest.err
5472   rm -f conftest.er1
5473   cat conftest.err >&5
5474   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5475   (exit $ac_status); } &&
5476          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
5477   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5478   (eval $ac_try) 2>&5
5479   ac_status=$?
5480   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5481   (exit $ac_status); }; } &&
5482          { ac_try='test -s conftest.$ac_objext'
5483   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5484   (eval $ac_try) 2>&5
5485   ac_status=$?
5486   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5487   (exit $ac_status); }; }; then
5488   eval "$as_ac_Header=yes"
5489 else
5490   echo "$as_me: failed program was:" >&5
5491 sed 's/^/| /' conftest.$ac_ext >&5
5492
5493 eval "$as_ac_Header=no"
5494 fi
5495 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5496 fi
5497 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5498 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5499 if test `eval echo '${'$as_ac_Header'}'` = yes; then
5500   cat >>confdefs.h <<_ACEOF
5501 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5502 _ACEOF
5503
5504 fi
5505
5506 done
5507
5508
5509
5510
5511 for ac_header in stdlib.h unistd.h
5512 do
5513 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5514 if eval "test \"\${$as_ac_Header+set}\" = set"; then
5515   echo "$as_me:$LINENO: checking for $ac_header" >&5
5516 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5517 if eval "test \"\${$as_ac_Header+set}\" = set"; then
5518   echo $ECHO_N "(cached) $ECHO_C" >&6
5519 fi
5520 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5521 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5522 else
5523   # Is the header compilable?
5524 echo "$as_me:$LINENO: checking $ac_header usability" >&5
5525 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
5526 cat >conftest.$ac_ext <<_ACEOF
5527 /* confdefs.h.  */
5528 _ACEOF
5529 cat confdefs.h >>conftest.$ac_ext
5530 cat >>conftest.$ac_ext <<_ACEOF
5531 /* end confdefs.h.  */
5532 $ac_includes_default
5533 #include <$ac_header>
5534 _ACEOF
5535 rm -f conftest.$ac_objext
5536 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5537   (eval $ac_compile) 2>conftest.er1
5538   ac_status=$?
5539   grep -v '^ *+' conftest.er1 >conftest.err
5540   rm -f conftest.er1
5541   cat conftest.err >&5
5542   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5543   (exit $ac_status); } &&
5544          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
5545   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5546   (eval $ac_try) 2>&5
5547   ac_status=$?
5548   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5549   (exit $ac_status); }; } &&
5550          { ac_try='test -s conftest.$ac_objext'
5551   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5552   (eval $ac_try) 2>&5
5553   ac_status=$?
5554   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5555   (exit $ac_status); }; }; then
5556   ac_header_compiler=yes
5557 else
5558   echo "$as_me: failed program was:" >&5
5559 sed 's/^/| /' conftest.$ac_ext >&5
5560
5561 ac_header_compiler=no
5562 fi
5563 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5564 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5565 echo "${ECHO_T}$ac_header_compiler" >&6
5566
5567 # Is the header present?
5568 echo "$as_me:$LINENO: checking $ac_header presence" >&5
5569 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
5570 cat >conftest.$ac_ext <<_ACEOF
5571 /* confdefs.h.  */
5572 _ACEOF
5573 cat confdefs.h >>conftest.$ac_ext
5574 cat >>conftest.$ac_ext <<_ACEOF
5575 /* end confdefs.h.  */
5576 #include <$ac_header>
5577 _ACEOF
5578 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5579   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5580   ac_status=$?
5581   grep -v '^ *+' conftest.er1 >conftest.err
5582   rm -f conftest.er1
5583   cat conftest.err >&5
5584   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5585   (exit $ac_status); } >/dev/null; then
5586   if test -s conftest.err; then
5587     ac_cpp_err=$ac_c_preproc_warn_flag
5588     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5589   else
5590     ac_cpp_err=
5591   fi
5592 else
5593   ac_cpp_err=yes
5594 fi
5595 if test -z "$ac_cpp_err"; then
5596   ac_header_preproc=yes
5597 else
5598   echo "$as_me: failed program was:" >&5
5599 sed 's/^/| /' conftest.$ac_ext >&5
5600
5601   ac_header_preproc=no
5602 fi
5603 rm -f conftest.err conftest.$ac_ext
5604 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5605 echo "${ECHO_T}$ac_header_preproc" >&6
5606
5607 # So?  What about this header?
5608 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5609   yes:no: )
5610     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
5611 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
5612     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
5613 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
5614     ac_header_preproc=yes
5615     ;;
5616   no:yes:* )
5617     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
5618 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
5619     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
5620 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
5621     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
5622 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
5623     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
5624 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
5625     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
5626 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
5627     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
5628 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
5629     (
5630       cat <<\_ASBOX
5631 ## ------------------------------------------------------ ##
5632 ## Report this to the GNU Fortran Runtime Library lists.  ##
5633 ## ------------------------------------------------------ ##
5634 _ASBOX
5635     ) |
5636       sed "s/^/$as_me: WARNING:     /" >&2
5637     ;;
5638 esac
5639 echo "$as_me:$LINENO: checking for $ac_header" >&5
5640 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5641 if eval "test \"\${$as_ac_Header+set}\" = set"; then
5642   echo $ECHO_N "(cached) $ECHO_C" >&6
5643 else
5644   eval "$as_ac_Header=\$ac_header_preproc"
5645 fi
5646 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5647 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5648
5649 fi
5650 if test `eval echo '${'$as_ac_Header'}'` = yes; then
5651   cat >>confdefs.h <<_ACEOF
5652 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5653 _ACEOF
5654
5655 fi
5656
5657 done
5658
5659
5660 for ac_func in getpagesize
5661 do
5662 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
5663 echo "$as_me:$LINENO: checking for $ac_func" >&5
5664 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
5665 if eval "test \"\${$as_ac_var+set}\" = set"; then
5666   echo $ECHO_N "(cached) $ECHO_C" >&6
5667 else
5668   if test x$gcc_no_link = xyes; then
5669   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
5670 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
5671    { (exit 1); exit 1; }; }
5672 fi
5673 cat >conftest.$ac_ext <<_ACEOF
5674 /* confdefs.h.  */
5675 _ACEOF
5676 cat confdefs.h >>conftest.$ac_ext
5677 cat >>conftest.$ac_ext <<_ACEOF
5678 /* end confdefs.h.  */
5679 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
5680    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
5681 #define $ac_func innocuous_$ac_func
5682
5683 /* System header to define __stub macros and hopefully few prototypes,
5684     which can conflict with char $ac_func (); below.
5685     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5686     <limits.h> exists even on freestanding compilers.  */
5687
5688 #ifdef __STDC__
5689 # include <limits.h>
5690 #else
5691 # include <assert.h>
5692 #endif
5693
5694 #undef $ac_func
5695
5696 /* Override any gcc2 internal prototype to avoid an error.  */
5697 #ifdef __cplusplus
5698 extern "C"
5699 {
5700 #endif
5701 /* We use char because int might match the return type of a gcc2
5702    builtin and then its argument prototype would still apply.  */
5703 char $ac_func ();
5704 /* The GNU C library defines this for functions which it implements
5705     to always fail with ENOSYS.  Some functions are actually named
5706     something starting with __ and the normal name is an alias.  */
5707 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5708 choke me
5709 #else
5710 char (*f) () = $ac_func;
5711 #endif
5712 #ifdef __cplusplus
5713 }
5714 #endif
5715
5716 int
5717 main ()
5718 {
5719 return f != $ac_func;
5720   ;
5721   return 0;
5722 }
5723 _ACEOF
5724 rm -f conftest.$ac_objext conftest$ac_exeext
5725 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5726   (eval $ac_link) 2>conftest.er1
5727   ac_status=$?
5728   grep -v '^ *+' conftest.er1 >conftest.err
5729   rm -f conftest.er1
5730   cat conftest.err >&5
5731   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5732   (exit $ac_status); } &&
5733          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
5734   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5735   (eval $ac_try) 2>&5
5736   ac_status=$?
5737   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5738   (exit $ac_status); }; } &&
5739          { ac_try='test -s conftest$ac_exeext'
5740   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5741   (eval $ac_try) 2>&5
5742   ac_status=$?
5743   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5744   (exit $ac_status); }; }; then
5745   eval "$as_ac_var=yes"
5746 else
5747   echo "$as_me: failed program was:" >&5
5748 sed 's/^/| /' conftest.$ac_ext >&5
5749
5750 eval "$as_ac_var=no"
5751 fi
5752 rm -f conftest.err conftest.$ac_objext \
5753       conftest$ac_exeext conftest.$ac_ext
5754 fi
5755 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
5756 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
5757 if test `eval echo '${'$as_ac_var'}'` = yes; then
5758   cat >>confdefs.h <<_ACEOF
5759 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
5760 _ACEOF
5761
5762 fi
5763 done
5764
5765 echo "$as_me:$LINENO: checking for working mmap" >&5
5766 echo $ECHO_N "checking for working mmap... $ECHO_C" >&6
5767 if test "${ac_cv_func_mmap_fixed_mapped+set}" = set; then
5768   echo $ECHO_N "(cached) $ECHO_C" >&6
5769 else
5770   if test "$cross_compiling" = yes; then
5771   ac_cv_func_mmap_fixed_mapped=no
5772 else
5773   cat >conftest.$ac_ext <<_ACEOF
5774 /* confdefs.h.  */
5775 _ACEOF
5776 cat confdefs.h >>conftest.$ac_ext
5777 cat >>conftest.$ac_ext <<_ACEOF
5778 /* end confdefs.h.  */
5779 $ac_includes_default
5780 /* malloc might have been renamed as rpl_malloc. */
5781 #undef malloc
5782
5783 /* Thanks to Mike Haertel and Jim Avera for this test.
5784    Here is a matrix of mmap possibilities:
5785         mmap private not fixed
5786         mmap private fixed at somewhere currently unmapped
5787         mmap private fixed at somewhere already mapped
5788         mmap shared not fixed
5789         mmap shared fixed at somewhere currently unmapped
5790         mmap shared fixed at somewhere already mapped
5791    For private mappings, we should verify that changes cannot be read()
5792    back from the file, nor mmap's back from the file at a different
5793    address.  (There have been systems where private was not correctly
5794    implemented like the infamous i386 svr4.0, and systems where the
5795    VM page cache was not coherent with the file system buffer cache
5796    like early versions of FreeBSD and possibly contemporary NetBSD.)
5797    For shared mappings, we should conversely verify that changes get
5798    propagated back to all the places they're supposed to be.
5799
5800    Grep wants private fixed already mapped.
5801    The main things grep needs to know about mmap are:
5802    * does it exist and is it safe to write into the mmap'd area
5803    * how to use it (BSD variants)  */
5804
5805 #include <fcntl.h>
5806 #include <sys/mman.h>
5807
5808 #if !STDC_HEADERS && !HAVE_STDLIB_H
5809 char *malloc ();
5810 #endif
5811
5812 /* This mess was copied from the GNU getpagesize.h.  */
5813 #if !HAVE_GETPAGESIZE
5814 /* Assume that all systems that can run configure have sys/param.h.  */
5815 # if !HAVE_SYS_PARAM_H
5816 #  define HAVE_SYS_PARAM_H 1
5817 # endif
5818
5819 # ifdef _SC_PAGESIZE
5820 #  define getpagesize() sysconf(_SC_PAGESIZE)
5821 # else /* no _SC_PAGESIZE */
5822 #  if HAVE_SYS_PARAM_H
5823 #   include <sys/param.h>
5824 #   ifdef EXEC_PAGESIZE
5825 #    define getpagesize() EXEC_PAGESIZE
5826 #   else /* no EXEC_PAGESIZE */
5827 #    ifdef NBPG
5828 #     define getpagesize() NBPG * CLSIZE
5829 #     ifndef CLSIZE
5830 #      define CLSIZE 1
5831 #     endif /* no CLSIZE */
5832 #    else /* no NBPG */
5833 #     ifdef NBPC
5834 #      define getpagesize() NBPC
5835 #     else /* no NBPC */
5836 #      ifdef PAGESIZE
5837 #       define getpagesize() PAGESIZE
5838 #      endif /* PAGESIZE */
5839 #     endif /* no NBPC */
5840 #    endif /* no NBPG */
5841 #   endif /* no EXEC_PAGESIZE */
5842 #  else /* no HAVE_SYS_PARAM_H */
5843 #   define getpagesize() 8192   /* punt totally */
5844 #  endif /* no HAVE_SYS_PARAM_H */
5845 # endif /* no _SC_PAGESIZE */
5846
5847 #endif /* no HAVE_GETPAGESIZE */
5848
5849 int
5850 main ()
5851 {
5852   char *data, *data2, *data3;
5853   int i, pagesize;
5854   int fd;
5855
5856   pagesize = getpagesize ();
5857
5858   /* First, make a file with some known garbage in it. */
5859   data = (char *) malloc (pagesize);
5860   if (!data)
5861     exit (1);
5862   for (i = 0; i < pagesize; ++i)
5863     *(data + i) = rand ();
5864   umask (0);
5865   fd = creat ("conftest.mmap", 0600);
5866   if (fd < 0)
5867     exit (1);
5868   if (write (fd, data, pagesize) != pagesize)
5869     exit (1);
5870   close (fd);
5871
5872   /* Next, try to mmap the file at a fixed address which already has
5873      something else allocated at it.  If we can, also make sure that
5874      we see the same garbage.  */
5875   fd = open ("conftest.mmap", O_RDWR);
5876   if (fd < 0)
5877     exit (1);
5878   data2 = (char *) malloc (2 * pagesize);
5879   if (!data2)
5880     exit (1);
5881   data2 += (pagesize - ((long) data2 & (pagesize - 1))) & (pagesize - 1);
5882   if (data2 != mmap (data2, pagesize, PROT_READ | PROT_WRITE,
5883                      MAP_PRIVATE | MAP_FIXED, fd, 0L))
5884     exit (1);
5885   for (i = 0; i < pagesize; ++i)
5886     if (*(data + i) != *(data2 + i))
5887       exit (1);
5888
5889   /* Finally, make sure that changes to the mapped area do not
5890      percolate back to the file as seen by read().  (This is a bug on
5891      some variants of i386 svr4.0.)  */
5892   for (i = 0; i < pagesize; ++i)
5893     *(data2 + i) = *(data2 + i) + 1;
5894   data3 = (char *) malloc (pagesize);
5895   if (!data3)
5896     exit (1);
5897   if (read (fd, data3, pagesize) != pagesize)
5898     exit (1);
5899   for (i = 0; i < pagesize; ++i)
5900     if (*(data + i) != *(data3 + i))
5901       exit (1);
5902   close (fd);
5903   exit (0);
5904 }
5905 _ACEOF
5906 rm -f conftest$ac_exeext
5907 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5908   (eval $ac_link) 2>&5
5909   ac_status=$?
5910   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5911   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5912   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5913   (eval $ac_try) 2>&5
5914   ac_status=$?
5915   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5916   (exit $ac_status); }; }; then
5917   ac_cv_func_mmap_fixed_mapped=yes
5918 else
5919   echo "$as_me: program exited with status $ac_status" >&5
5920 echo "$as_me: failed program was:" >&5
5921 sed 's/^/| /' conftest.$ac_ext >&5
5922
5923 ( exit $ac_status )
5924 ac_cv_func_mmap_fixed_mapped=no
5925 fi
5926 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5927 fi
5928 fi
5929 echo "$as_me:$LINENO: result: $ac_cv_func_mmap_fixed_mapped" >&5
5930 echo "${ECHO_T}$ac_cv_func_mmap_fixed_mapped" >&6
5931 if test $ac_cv_func_mmap_fixed_mapped = yes; then
5932
5933 cat >>confdefs.h <<\_ACEOF
5934 #define HAVE_MMAP 1
5935 _ACEOF
5936
5937 fi
5938 rm -f conftest.mmap
5939
5940 fi
5941 echo "$as_me:$LINENO: checking for off_t" >&5
5942 echo $ECHO_N "checking for off_t... $ECHO_C" >&6
5943 if test "${ac_cv_type_off_t+set}" = set; then
5944   echo $ECHO_N "(cached) $ECHO_C" >&6
5945 else
5946   cat >conftest.$ac_ext <<_ACEOF
5947 /* confdefs.h.  */
5948 _ACEOF
5949 cat confdefs.h >>conftest.$ac_ext
5950 cat >>conftest.$ac_ext <<_ACEOF
5951 /* end confdefs.h.  */
5952 $ac_includes_default
5953 int
5954 main ()
5955 {
5956 if ((off_t *) 0)
5957   return 0;
5958 if (sizeof (off_t))
5959   return 0;
5960   ;
5961   return 0;
5962 }
5963 _ACEOF
5964 rm -f conftest.$ac_objext
5965 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5966   (eval $ac_compile) 2>conftest.er1
5967   ac_status=$?
5968   grep -v '^ *+' conftest.er1 >conftest.err
5969   rm -f conftest.er1
5970   cat conftest.err >&5
5971   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5972   (exit $ac_status); } &&
5973          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
5974   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5975   (eval $ac_try) 2>&5
5976   ac_status=$?
5977   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5978   (exit $ac_status); }; } &&
5979          { ac_try='test -s conftest.$ac_objext'
5980   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5981   (eval $ac_try) 2>&5
5982   ac_status=$?
5983   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5984   (exit $ac_status); }; }; then
5985   ac_cv_type_off_t=yes
5986 else
5987   echo "$as_me: failed program was:" >&5
5988 sed 's/^/| /' conftest.$ac_ext >&5
5989
5990 ac_cv_type_off_t=no
5991 fi
5992 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5993 fi
5994 echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5
5995 echo "${ECHO_T}$ac_cv_type_off_t" >&6
5996 if test $ac_cv_type_off_t = yes; then
5997   :
5998 else
5999
6000 cat >>confdefs.h <<_ACEOF
6001 #define off_t long
6002 _ACEOF
6003
6004 fi
6005
6006
6007 # check header files
6008 echo "$as_me:$LINENO: checking for ANSI C header files" >&5
6009 echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
6010 if test "${ac_cv_header_stdc+set}" = set; then
6011   echo $ECHO_N "(cached) $ECHO_C" >&6
6012 else
6013   cat >conftest.$ac_ext <<_ACEOF
6014 /* confdefs.h.  */
6015 _ACEOF
6016 cat confdefs.h >>conftest.$ac_ext
6017 cat >>conftest.$ac_ext <<_ACEOF
6018 /* end confdefs.h.  */
6019 #include <stdlib.h>
6020 #include <stdarg.h>
6021 #include <string.h>
6022 #include <float.h>
6023
6024 int
6025 main ()
6026 {
6027
6028   ;
6029   return 0;
6030 }
6031 _ACEOF
6032 rm -f conftest.$ac_objext
6033 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6034   (eval $ac_compile) 2>conftest.er1
6035   ac_status=$?
6036   grep -v '^ *+' conftest.er1 >conftest.err
6037   rm -f conftest.er1
6038   cat conftest.err >&5
6039   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6040   (exit $ac_status); } &&
6041          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
6042   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6043   (eval $ac_try) 2>&5
6044   ac_status=$?
6045   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6046   (exit $ac_status); }; } &&
6047          { ac_try='test -s conftest.$ac_objext'
6048   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6049   (eval $ac_try) 2>&5
6050   ac_status=$?
6051   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6052   (exit $ac_status); }; }; then
6053   ac_cv_header_stdc=yes
6054 else
6055   echo "$as_me: failed program was:" >&5
6056 sed 's/^/| /' conftest.$ac_ext >&5
6057
6058 ac_cv_header_stdc=no
6059 fi
6060 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6061
6062 if test $ac_cv_header_stdc = yes; then
6063   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
6064   cat >conftest.$ac_ext <<_ACEOF
6065 /* confdefs.h.  */
6066 _ACEOF
6067 cat confdefs.h >>conftest.$ac_ext
6068 cat >>conftest.$ac_ext <<_ACEOF
6069 /* end confdefs.h.  */
6070 #include <string.h>
6071
6072 _ACEOF
6073 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6074   $EGREP "memchr" >/dev/null 2>&1; then
6075   :
6076 else
6077   ac_cv_header_stdc=no
6078 fi
6079 rm -f conftest*
6080
6081 fi
6082
6083 if test $ac_cv_header_stdc = yes; then
6084   # ISC 2.0.2 stdlib.h does not declare free, 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 <stdlib.h>
6092
6093 _ACEOF
6094 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6095   $EGREP "free" >/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   # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
6106   if test "$cross_compiling" = yes; then
6107   :
6108 else
6109   cat >conftest.$ac_ext <<_ACEOF
6110 /* confdefs.h.  */
6111 _ACEOF
6112 cat confdefs.h >>conftest.$ac_ext
6113 cat >>conftest.$ac_ext <<_ACEOF
6114 /* end confdefs.h.  */
6115 #include <ctype.h>
6116 #if ((' ' & 0x0FF) == 0x020)
6117 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
6118 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
6119 #else
6120 # define ISLOWER(c) \
6121                    (('a' <= (c) && (c) <= 'i') \
6122                      || ('j' <= (c) && (c) <= 'r') \
6123                      || ('s' <= (c) && (c) <= 'z'))
6124 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
6125 #endif
6126
6127 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
6128 int
6129 main ()
6130 {
6131   int i;
6132   for (i = 0; i < 256; i++)
6133     if (XOR (islower (i), ISLOWER (i))
6134         || toupper (i) != TOUPPER (i))
6135       exit(2);
6136   exit (0);
6137 }
6138 _ACEOF
6139 rm -f conftest$ac_exeext
6140 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6141   (eval $ac_link) 2>&5
6142   ac_status=$?
6143   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6144   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
6145   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6146   (eval $ac_try) 2>&5
6147   ac_status=$?
6148   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6149   (exit $ac_status); }; }; then
6150   :
6151 else
6152   echo "$as_me: program exited with status $ac_status" >&5
6153 echo "$as_me: failed program was:" >&5
6154 sed 's/^/| /' conftest.$ac_ext >&5
6155
6156 ( exit $ac_status )
6157 ac_cv_header_stdc=no
6158 fi
6159 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
6160 fi
6161 fi
6162 fi
6163 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
6164 echo "${ECHO_T}$ac_cv_header_stdc" >&6
6165 if test $ac_cv_header_stdc = yes; then
6166
6167 cat >>confdefs.h <<\_ACEOF
6168 #define STDC_HEADERS 1
6169 _ACEOF
6170
6171 fi
6172
6173
6174
6175
6176
6177
6178
6179
6180 for ac_header in stdlib.h stdio.h string.h stddef.h math.h unistd.h signal.h
6181 do
6182 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6183 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6184   echo "$as_me:$LINENO: checking for $ac_header" >&5
6185 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6186 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6187   echo $ECHO_N "(cached) $ECHO_C" >&6
6188 fi
6189 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6190 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6191 else
6192   # Is the header compilable?
6193 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6194 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6195 cat >conftest.$ac_ext <<_ACEOF
6196 /* confdefs.h.  */
6197 _ACEOF
6198 cat confdefs.h >>conftest.$ac_ext
6199 cat >>conftest.$ac_ext <<_ACEOF
6200 /* end confdefs.h.  */
6201 $ac_includes_default
6202 #include <$ac_header>
6203 _ACEOF
6204 rm -f conftest.$ac_objext
6205 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6206   (eval $ac_compile) 2>conftest.er1
6207   ac_status=$?
6208   grep -v '^ *+' conftest.er1 >conftest.err
6209   rm -f conftest.er1
6210   cat conftest.err >&5
6211   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6212   (exit $ac_status); } &&
6213          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
6214   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6215   (eval $ac_try) 2>&5
6216   ac_status=$?
6217   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6218   (exit $ac_status); }; } &&
6219          { ac_try='test -s conftest.$ac_objext'
6220   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6221   (eval $ac_try) 2>&5
6222   ac_status=$?
6223   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6224   (exit $ac_status); }; }; then
6225   ac_header_compiler=yes
6226 else
6227   echo "$as_me: failed program was:" >&5
6228 sed 's/^/| /' conftest.$ac_ext >&5
6229
6230 ac_header_compiler=no
6231 fi
6232 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6233 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6234 echo "${ECHO_T}$ac_header_compiler" >&6
6235
6236 # Is the header present?
6237 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6238 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6239 cat >conftest.$ac_ext <<_ACEOF
6240 /* confdefs.h.  */
6241 _ACEOF
6242 cat confdefs.h >>conftest.$ac_ext
6243 cat >>conftest.$ac_ext <<_ACEOF
6244 /* end confdefs.h.  */
6245 #include <$ac_header>
6246 _ACEOF
6247 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6248   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6249   ac_status=$?
6250   grep -v '^ *+' conftest.er1 >conftest.err
6251   rm -f conftest.er1
6252   cat conftest.err >&5
6253   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6254   (exit $ac_status); } >/dev/null; then
6255   if test -s conftest.err; then
6256     ac_cpp_err=$ac_c_preproc_warn_flag
6257     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6258   else
6259     ac_cpp_err=
6260   fi
6261 else
6262   ac_cpp_err=yes
6263 fi
6264 if test -z "$ac_cpp_err"; then
6265   ac_header_preproc=yes
6266 else
6267   echo "$as_me: failed program was:" >&5
6268 sed 's/^/| /' conftest.$ac_ext >&5
6269
6270   ac_header_preproc=no
6271 fi
6272 rm -f conftest.err conftest.$ac_ext
6273 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6274 echo "${ECHO_T}$ac_header_preproc" >&6
6275
6276 # So?  What about this header?
6277 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6278   yes:no: )
6279     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6280 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6281     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6282 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6283     ac_header_preproc=yes
6284     ;;
6285   no:yes:* )
6286     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6287 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6288     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6289 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6290     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6291 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6292     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6293 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6294     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6295 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6296     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6297 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6298     (
6299       cat <<\_ASBOX
6300 ## ------------------------------------------------------ ##
6301 ## Report this to the GNU Fortran Runtime Library lists.  ##
6302 ## ------------------------------------------------------ ##
6303 _ASBOX
6304     ) |
6305       sed "s/^/$as_me: WARNING:     /" >&2
6306     ;;
6307 esac
6308 echo "$as_me:$LINENO: checking for $ac_header" >&5
6309 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6310 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6311   echo $ECHO_N "(cached) $ECHO_C" >&6
6312 else
6313   eval "$as_ac_Header=\$ac_header_preproc"
6314 fi
6315 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6316 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6317
6318 fi
6319 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6320   cat >>confdefs.h <<_ACEOF
6321 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6322 _ACEOF
6323
6324 fi
6325
6326 done
6327
6328
6329
6330
6331
6332
6333 for ac_header in time.h sys/params.h sys/time.h sys/times.h sys/resource.h
6334 do
6335 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6336 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6337   echo "$as_me:$LINENO: checking for $ac_header" >&5
6338 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6339 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6340   echo $ECHO_N "(cached) $ECHO_C" >&6
6341 fi
6342 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6343 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6344 else
6345   # Is the header compilable?
6346 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6347 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6348 cat >conftest.$ac_ext <<_ACEOF
6349 /* confdefs.h.  */
6350 _ACEOF
6351 cat confdefs.h >>conftest.$ac_ext
6352 cat >>conftest.$ac_ext <<_ACEOF
6353 /* end confdefs.h.  */
6354 $ac_includes_default
6355 #include <$ac_header>
6356 _ACEOF
6357 rm -f conftest.$ac_objext
6358 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6359   (eval $ac_compile) 2>conftest.er1
6360   ac_status=$?
6361   grep -v '^ *+' conftest.er1 >conftest.err
6362   rm -f conftest.er1
6363   cat conftest.err >&5
6364   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6365   (exit $ac_status); } &&
6366          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
6367   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6368   (eval $ac_try) 2>&5
6369   ac_status=$?
6370   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6371   (exit $ac_status); }; } &&
6372          { ac_try='test -s conftest.$ac_objext'
6373   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6374   (eval $ac_try) 2>&5
6375   ac_status=$?
6376   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6377   (exit $ac_status); }; }; then
6378   ac_header_compiler=yes
6379 else
6380   echo "$as_me: failed program was:" >&5
6381 sed 's/^/| /' conftest.$ac_ext >&5
6382
6383 ac_header_compiler=no
6384 fi
6385 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6386 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6387 echo "${ECHO_T}$ac_header_compiler" >&6
6388
6389 # Is the header present?
6390 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6391 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6392 cat >conftest.$ac_ext <<_ACEOF
6393 /* confdefs.h.  */
6394 _ACEOF
6395 cat confdefs.h >>conftest.$ac_ext
6396 cat >>conftest.$ac_ext <<_ACEOF
6397 /* end confdefs.h.  */
6398 #include <$ac_header>
6399 _ACEOF
6400 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6401   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6402   ac_status=$?
6403   grep -v '^ *+' conftest.er1 >conftest.err
6404   rm -f conftest.er1
6405   cat conftest.err >&5
6406   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6407   (exit $ac_status); } >/dev/null; then
6408   if test -s conftest.err; then
6409     ac_cpp_err=$ac_c_preproc_warn_flag
6410     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6411   else
6412     ac_cpp_err=
6413   fi
6414 else
6415   ac_cpp_err=yes
6416 fi
6417 if test -z "$ac_cpp_err"; then
6418   ac_header_preproc=yes
6419 else
6420   echo "$as_me: failed program was:" >&5
6421 sed 's/^/| /' conftest.$ac_ext >&5
6422
6423   ac_header_preproc=no
6424 fi
6425 rm -f conftest.err conftest.$ac_ext
6426 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6427 echo "${ECHO_T}$ac_header_preproc" >&6
6428
6429 # So?  What about this header?
6430 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6431   yes:no: )
6432     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6433 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6434     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6435 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6436     ac_header_preproc=yes
6437     ;;
6438   no:yes:* )
6439     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6440 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6441     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6442 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6443     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6444 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6445     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6446 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6447     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6448 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6449     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6450 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6451     (
6452       cat <<\_ASBOX
6453 ## ------------------------------------------------------ ##
6454 ## Report this to the GNU Fortran Runtime Library lists.  ##
6455 ## ------------------------------------------------------ ##
6456 _ASBOX
6457     ) |
6458       sed "s/^/$as_me: WARNING:     /" >&2
6459     ;;
6460 esac
6461 echo "$as_me:$LINENO: checking for $ac_header" >&5
6462 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6463 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6464   echo $ECHO_N "(cached) $ECHO_C" >&6
6465 else
6466   eval "$as_ac_Header=\$ac_header_preproc"
6467 fi
6468 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6469 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6470
6471 fi
6472 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6473   cat >>confdefs.h <<_ACEOF
6474 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6475 _ACEOF
6476
6477 fi
6478
6479 done
6480
6481
6482
6483
6484
6485
6486 for ac_header in sys/mman.h sys/types.h sys/stat.h floatingpoint.h ieeefp.h
6487 do
6488 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6489 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6490   echo "$as_me:$LINENO: checking for $ac_header" >&5
6491 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6492 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6493   echo $ECHO_N "(cached) $ECHO_C" >&6
6494 fi
6495 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6496 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6497 else
6498   # Is the header compilable?
6499 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6500 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6501 cat >conftest.$ac_ext <<_ACEOF
6502 /* confdefs.h.  */
6503 _ACEOF
6504 cat confdefs.h >>conftest.$ac_ext
6505 cat >>conftest.$ac_ext <<_ACEOF
6506 /* end confdefs.h.  */
6507 $ac_includes_default
6508 #include <$ac_header>
6509 _ACEOF
6510 rm -f conftest.$ac_objext
6511 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6512   (eval $ac_compile) 2>conftest.er1
6513   ac_status=$?
6514   grep -v '^ *+' conftest.er1 >conftest.err
6515   rm -f conftest.er1
6516   cat conftest.err >&5
6517   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6518   (exit $ac_status); } &&
6519          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
6520   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6521   (eval $ac_try) 2>&5
6522   ac_status=$?
6523   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6524   (exit $ac_status); }; } &&
6525          { ac_try='test -s conftest.$ac_objext'
6526   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6527   (eval $ac_try) 2>&5
6528   ac_status=$?
6529   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6530   (exit $ac_status); }; }; then
6531   ac_header_compiler=yes
6532 else
6533   echo "$as_me: failed program was:" >&5
6534 sed 's/^/| /' conftest.$ac_ext >&5
6535
6536 ac_header_compiler=no
6537 fi
6538 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6539 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6540 echo "${ECHO_T}$ac_header_compiler" >&6
6541
6542 # Is the header present?
6543 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6544 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6545 cat >conftest.$ac_ext <<_ACEOF
6546 /* confdefs.h.  */
6547 _ACEOF
6548 cat confdefs.h >>conftest.$ac_ext
6549 cat >>conftest.$ac_ext <<_ACEOF
6550 /* end confdefs.h.  */
6551 #include <$ac_header>
6552 _ACEOF
6553 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6554   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6555   ac_status=$?
6556   grep -v '^ *+' conftest.er1 >conftest.err
6557   rm -f conftest.er1
6558   cat conftest.err >&5
6559   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6560   (exit $ac_status); } >/dev/null; then
6561   if test -s conftest.err; then
6562     ac_cpp_err=$ac_c_preproc_warn_flag
6563     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6564   else
6565     ac_cpp_err=
6566   fi
6567 else
6568   ac_cpp_err=yes
6569 fi
6570 if test -z "$ac_cpp_err"; then
6571   ac_header_preproc=yes
6572 else
6573   echo "$as_me: failed program was:" >&5
6574 sed 's/^/| /' conftest.$ac_ext >&5
6575
6576   ac_header_preproc=no
6577 fi
6578 rm -f conftest.err conftest.$ac_ext
6579 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6580 echo "${ECHO_T}$ac_header_preproc" >&6
6581
6582 # So?  What about this header?
6583 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6584   yes:no: )
6585     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6586 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6587     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6588 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6589     ac_header_preproc=yes
6590     ;;
6591   no:yes:* )
6592     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6593 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6594     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6595 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6596     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6597 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6598     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6599 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6600     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6601 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6602     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6603 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6604     (
6605       cat <<\_ASBOX
6606 ## ------------------------------------------------------ ##
6607 ## Report this to the GNU Fortran Runtime Library lists.  ##
6608 ## ------------------------------------------------------ ##
6609 _ASBOX
6610     ) |
6611       sed "s/^/$as_me: WARNING:     /" >&2
6612     ;;
6613 esac
6614 echo "$as_me:$LINENO: checking for $ac_header" >&5
6615 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6616 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6617   echo $ECHO_N "(cached) $ECHO_C" >&6
6618 else
6619   eval "$as_ac_Header=\$ac_header_preproc"
6620 fi
6621 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6622 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6623
6624 fi
6625 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6626   cat >>confdefs.h <<_ACEOF
6627 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6628 _ACEOF
6629
6630 fi
6631
6632 done
6633
6634
6635
6636
6637 for ac_header in fenv.h fptrap.h float.h
6638 do
6639 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6640 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6641   echo "$as_me:$LINENO: checking for $ac_header" >&5
6642 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6643 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6644   echo $ECHO_N "(cached) $ECHO_C" >&6
6645 fi
6646 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6647 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6648 else
6649   # Is the header compilable?
6650 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6651 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6652 cat >conftest.$ac_ext <<_ACEOF
6653 /* confdefs.h.  */
6654 _ACEOF
6655 cat confdefs.h >>conftest.$ac_ext
6656 cat >>conftest.$ac_ext <<_ACEOF
6657 /* end confdefs.h.  */
6658 $ac_includes_default
6659 #include <$ac_header>
6660 _ACEOF
6661 rm -f conftest.$ac_objext
6662 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6663   (eval $ac_compile) 2>conftest.er1
6664   ac_status=$?
6665   grep -v '^ *+' conftest.er1 >conftest.err
6666   rm -f conftest.er1
6667   cat conftest.err >&5
6668   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6669   (exit $ac_status); } &&
6670          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
6671   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6672   (eval $ac_try) 2>&5
6673   ac_status=$?
6674   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6675   (exit $ac_status); }; } &&
6676          { ac_try='test -s conftest.$ac_objext'
6677   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6678   (eval $ac_try) 2>&5
6679   ac_status=$?
6680   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6681   (exit $ac_status); }; }; then
6682   ac_header_compiler=yes
6683 else
6684   echo "$as_me: failed program was:" >&5
6685 sed 's/^/| /' conftest.$ac_ext >&5
6686
6687 ac_header_compiler=no
6688 fi
6689 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6690 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6691 echo "${ECHO_T}$ac_header_compiler" >&6
6692
6693 # Is the header present?
6694 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6695 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6696 cat >conftest.$ac_ext <<_ACEOF
6697 /* confdefs.h.  */
6698 _ACEOF
6699 cat confdefs.h >>conftest.$ac_ext
6700 cat >>conftest.$ac_ext <<_ACEOF
6701 /* end confdefs.h.  */
6702 #include <$ac_header>
6703 _ACEOF
6704 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6705   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6706   ac_status=$?
6707   grep -v '^ *+' conftest.er1 >conftest.err
6708   rm -f conftest.er1
6709   cat conftest.err >&5
6710   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6711   (exit $ac_status); } >/dev/null; then
6712   if test -s conftest.err; then
6713     ac_cpp_err=$ac_c_preproc_warn_flag
6714     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6715   else
6716     ac_cpp_err=
6717   fi
6718 else
6719   ac_cpp_err=yes
6720 fi
6721 if test -z "$ac_cpp_err"; then
6722   ac_header_preproc=yes
6723 else
6724   echo "$as_me: failed program was:" >&5
6725 sed 's/^/| /' conftest.$ac_ext >&5
6726
6727   ac_header_preproc=no
6728 fi
6729 rm -f conftest.err conftest.$ac_ext
6730 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6731 echo "${ECHO_T}$ac_header_preproc" >&6
6732
6733 # So?  What about this header?
6734 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6735   yes:no: )
6736     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6737 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6738     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6739 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6740     ac_header_preproc=yes
6741     ;;
6742   no:yes:* )
6743     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6744 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6745     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6746 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6747     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6748 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6749     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6750 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6751     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6752 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6753     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6754 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6755     (
6756       cat <<\_ASBOX
6757 ## ------------------------------------------------------ ##
6758 ## Report this to the GNU Fortran Runtime Library lists.  ##
6759 ## ------------------------------------------------------ ##
6760 _ASBOX
6761     ) |
6762       sed "s/^/$as_me: WARNING:     /" >&2
6763     ;;
6764 esac
6765 echo "$as_me:$LINENO: checking for $ac_header" >&5
6766 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6767 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6768   echo $ECHO_N "(cached) $ECHO_C" >&6
6769 else
6770   eval "$as_ac_Header=\$ac_header_preproc"
6771 fi
6772 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6773 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6774
6775 fi
6776 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6777   cat >>confdefs.h <<_ACEOF
6778 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6779 _ACEOF
6780
6781 fi
6782
6783 done
6784
6785 if test "${ac_cv_header_complex_h+set}" = set; then
6786   echo "$as_me:$LINENO: checking for complex.h" >&5
6787 echo $ECHO_N "checking for complex.h... $ECHO_C" >&6
6788 if test "${ac_cv_header_complex_h+set}" = set; then
6789   echo $ECHO_N "(cached) $ECHO_C" >&6
6790 fi
6791 echo "$as_me:$LINENO: result: $ac_cv_header_complex_h" >&5
6792 echo "${ECHO_T}$ac_cv_header_complex_h" >&6
6793 else
6794   # Is the header compilable?
6795 echo "$as_me:$LINENO: checking complex.h usability" >&5
6796 echo $ECHO_N "checking complex.h usability... $ECHO_C" >&6
6797 cat >conftest.$ac_ext <<_ACEOF
6798 /* confdefs.h.  */
6799 _ACEOF
6800 cat confdefs.h >>conftest.$ac_ext
6801 cat >>conftest.$ac_ext <<_ACEOF
6802 /* end confdefs.h.  */
6803 $ac_includes_default
6804 #include <complex.h>
6805 _ACEOF
6806 rm -f conftest.$ac_objext
6807 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6808   (eval $ac_compile) 2>conftest.er1
6809   ac_status=$?
6810   grep -v '^ *+' conftest.er1 >conftest.err
6811   rm -f conftest.er1
6812   cat conftest.err >&5
6813   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6814   (exit $ac_status); } &&
6815          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
6816   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6817   (eval $ac_try) 2>&5
6818   ac_status=$?
6819   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6820   (exit $ac_status); }; } &&
6821          { ac_try='test -s conftest.$ac_objext'
6822   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6823   (eval $ac_try) 2>&5
6824   ac_status=$?
6825   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6826   (exit $ac_status); }; }; then
6827   ac_header_compiler=yes
6828 else
6829   echo "$as_me: failed program was:" >&5
6830 sed 's/^/| /' conftest.$ac_ext >&5
6831
6832 ac_header_compiler=no
6833 fi
6834 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6835 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6836 echo "${ECHO_T}$ac_header_compiler" >&6
6837
6838 # Is the header present?
6839 echo "$as_me:$LINENO: checking complex.h presence" >&5
6840 echo $ECHO_N "checking complex.h presence... $ECHO_C" >&6
6841 cat >conftest.$ac_ext <<_ACEOF
6842 /* confdefs.h.  */
6843 _ACEOF
6844 cat confdefs.h >>conftest.$ac_ext
6845 cat >>conftest.$ac_ext <<_ACEOF
6846 /* end confdefs.h.  */
6847 #include <complex.h>
6848 _ACEOF
6849 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6850   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6851   ac_status=$?
6852   grep -v '^ *+' conftest.er1 >conftest.err
6853   rm -f conftest.er1
6854   cat conftest.err >&5
6855   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6856   (exit $ac_status); } >/dev/null; then
6857   if test -s conftest.err; then
6858     ac_cpp_err=$ac_c_preproc_warn_flag
6859     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6860   else
6861     ac_cpp_err=
6862   fi
6863 else
6864   ac_cpp_err=yes
6865 fi
6866 if test -z "$ac_cpp_err"; then
6867   ac_header_preproc=yes
6868 else
6869   echo "$as_me: failed program was:" >&5
6870 sed 's/^/| /' conftest.$ac_ext >&5
6871
6872   ac_header_preproc=no
6873 fi
6874 rm -f conftest.err conftest.$ac_ext
6875 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6876 echo "${ECHO_T}$ac_header_preproc" >&6
6877
6878 # So?  What about this header?
6879 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6880   yes:no: )
6881     { echo "$as_me:$LINENO: WARNING: complex.h: accepted by the compiler, rejected by the preprocessor!" >&5
6882 echo "$as_me: WARNING: complex.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6883     { echo "$as_me:$LINENO: WARNING: complex.h: proceeding with the compiler's result" >&5
6884 echo "$as_me: WARNING: complex.h: proceeding with the compiler's result" >&2;}
6885     ac_header_preproc=yes
6886     ;;
6887   no:yes:* )
6888     { echo "$as_me:$LINENO: WARNING: complex.h: present but cannot be compiled" >&5
6889 echo "$as_me: WARNING: complex.h: present but cannot be compiled" >&2;}
6890     { echo "$as_me:$LINENO: WARNING: complex.h:     check for missing prerequisite headers?" >&5
6891 echo "$as_me: WARNING: complex.h:     check for missing prerequisite headers?" >&2;}
6892     { echo "$as_me:$LINENO: WARNING: complex.h: see the Autoconf documentation" >&5
6893 echo "$as_me: WARNING: complex.h: see the Autoconf documentation" >&2;}
6894     { echo "$as_me:$LINENO: WARNING: complex.h:     section \"Present But Cannot Be Compiled\"" >&5
6895 echo "$as_me: WARNING: complex.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6896     { echo "$as_me:$LINENO: WARNING: complex.h: proceeding with the preprocessor's result" >&5
6897 echo "$as_me: WARNING: complex.h: proceeding with the preprocessor's result" >&2;}
6898     { echo "$as_me:$LINENO: WARNING: complex.h: in the future, the compiler will take precedence" >&5
6899 echo "$as_me: WARNING: complex.h: in the future, the compiler will take precedence" >&2;}
6900     (
6901       cat <<\_ASBOX
6902 ## ------------------------------------------------------ ##
6903 ## Report this to the GNU Fortran Runtime Library lists.  ##
6904 ## ------------------------------------------------------ ##
6905 _ASBOX
6906     ) |
6907       sed "s/^/$as_me: WARNING:     /" >&2
6908     ;;
6909 esac
6910 echo "$as_me:$LINENO: checking for complex.h" >&5
6911 echo $ECHO_N "checking for complex.h... $ECHO_C" >&6
6912 if test "${ac_cv_header_complex_h+set}" = set; then
6913   echo $ECHO_N "(cached) $ECHO_C" >&6
6914 else
6915   ac_cv_header_complex_h=$ac_header_preproc
6916 fi
6917 echo "$as_me:$LINENO: result: $ac_cv_header_complex_h" >&5
6918 echo "${ECHO_T}$ac_cv_header_complex_h" >&6
6919
6920 fi
6921 if test $ac_cv_header_complex_h = yes; then
6922
6923 cat >>confdefs.h <<\_ACEOF
6924 #define HAVE_COMPLEX_H 1
6925 _ACEOF
6926
6927 fi
6928
6929
6930
6931 echo "$as_me:$LINENO: checking for struct stat.st_blksize" >&5
6932 echo $ECHO_N "checking for struct stat.st_blksize... $ECHO_C" >&6
6933 if test "${ac_cv_member_struct_stat_st_blksize+set}" = set; then
6934   echo $ECHO_N "(cached) $ECHO_C" >&6
6935 else
6936   cat >conftest.$ac_ext <<_ACEOF
6937 /* confdefs.h.  */
6938 _ACEOF
6939 cat confdefs.h >>conftest.$ac_ext
6940 cat >>conftest.$ac_ext <<_ACEOF
6941 /* end confdefs.h.  */
6942 $ac_includes_default
6943 int
6944 main ()
6945 {
6946 static struct stat ac_aggr;
6947 if (ac_aggr.st_blksize)
6948 return 0;
6949   ;
6950   return 0;
6951 }
6952 _ACEOF
6953 rm -f conftest.$ac_objext
6954 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6955   (eval $ac_compile) 2>conftest.er1
6956   ac_status=$?
6957   grep -v '^ *+' conftest.er1 >conftest.err
6958   rm -f conftest.er1
6959   cat conftest.err >&5
6960   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6961   (exit $ac_status); } &&
6962          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
6963   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6964   (eval $ac_try) 2>&5
6965   ac_status=$?
6966   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6967   (exit $ac_status); }; } &&
6968          { ac_try='test -s conftest.$ac_objext'
6969   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6970   (eval $ac_try) 2>&5
6971   ac_status=$?
6972   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6973   (exit $ac_status); }; }; then
6974   ac_cv_member_struct_stat_st_blksize=yes
6975 else
6976   echo "$as_me: failed program was:" >&5
6977 sed 's/^/| /' conftest.$ac_ext >&5
6978
6979 cat >conftest.$ac_ext <<_ACEOF
6980 /* confdefs.h.  */
6981 _ACEOF
6982 cat confdefs.h >>conftest.$ac_ext
6983 cat >>conftest.$ac_ext <<_ACEOF
6984 /* end confdefs.h.  */
6985 $ac_includes_default
6986 int
6987 main ()
6988 {
6989 static struct stat ac_aggr;
6990 if (sizeof ac_aggr.st_blksize)
6991 return 0;
6992   ;
6993   return 0;
6994 }
6995 _ACEOF
6996 rm -f conftest.$ac_objext
6997 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6998   (eval $ac_compile) 2>conftest.er1
6999   ac_status=$?
7000   grep -v '^ *+' conftest.er1 >conftest.err
7001   rm -f conftest.er1
7002   cat conftest.err >&5
7003   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7004   (exit $ac_status); } &&
7005          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
7006   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7007   (eval $ac_try) 2>&5
7008   ac_status=$?
7009   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7010   (exit $ac_status); }; } &&
7011          { ac_try='test -s conftest.$ac_objext'
7012   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7013   (eval $ac_try) 2>&5
7014   ac_status=$?
7015   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7016   (exit $ac_status); }; }; then
7017   ac_cv_member_struct_stat_st_blksize=yes
7018 else
7019   echo "$as_me: failed program was:" >&5
7020 sed 's/^/| /' conftest.$ac_ext >&5
7021
7022 ac_cv_member_struct_stat_st_blksize=no
7023 fi
7024 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7025 fi
7026 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7027 fi
7028 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blksize" >&5
7029 echo "${ECHO_T}$ac_cv_member_struct_stat_st_blksize" >&6
7030 if test $ac_cv_member_struct_stat_st_blksize = yes; then
7031
7032 cat >>confdefs.h <<_ACEOF
7033 #define HAVE_STRUCT_STAT_ST_BLKSIZE 1
7034 _ACEOF
7035
7036
7037 fi
7038
7039 echo "$as_me:$LINENO: checking for struct stat.st_blocks" >&5
7040 echo $ECHO_N "checking for struct stat.st_blocks... $ECHO_C" >&6
7041 if test "${ac_cv_member_struct_stat_st_blocks+set}" = set; then
7042   echo $ECHO_N "(cached) $ECHO_C" >&6
7043 else
7044   cat >conftest.$ac_ext <<_ACEOF
7045 /* confdefs.h.  */
7046 _ACEOF
7047 cat confdefs.h >>conftest.$ac_ext
7048 cat >>conftest.$ac_ext <<_ACEOF
7049 /* end confdefs.h.  */
7050 $ac_includes_default
7051 int
7052 main ()
7053 {
7054 static struct stat ac_aggr;
7055 if (ac_aggr.st_blocks)
7056 return 0;
7057   ;
7058   return 0;
7059 }
7060 _ACEOF
7061 rm -f conftest.$ac_objext
7062 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7063   (eval $ac_compile) 2>conftest.er1
7064   ac_status=$?
7065   grep -v '^ *+' conftest.er1 >conftest.err
7066   rm -f conftest.er1
7067   cat conftest.err >&5
7068   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7069   (exit $ac_status); } &&
7070          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
7071   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7072   (eval $ac_try) 2>&5
7073   ac_status=$?
7074   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7075   (exit $ac_status); }; } &&
7076          { ac_try='test -s conftest.$ac_objext'
7077   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7078   (eval $ac_try) 2>&5
7079   ac_status=$?
7080   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7081   (exit $ac_status); }; }; then
7082   ac_cv_member_struct_stat_st_blocks=yes
7083 else
7084   echo "$as_me: failed program was:" >&5
7085 sed 's/^/| /' conftest.$ac_ext >&5
7086
7087 cat >conftest.$ac_ext <<_ACEOF
7088 /* confdefs.h.  */
7089 _ACEOF
7090 cat confdefs.h >>conftest.$ac_ext
7091 cat >>conftest.$ac_ext <<_ACEOF
7092 /* end confdefs.h.  */
7093 $ac_includes_default
7094 int
7095 main ()
7096 {
7097 static struct stat ac_aggr;
7098 if (sizeof ac_aggr.st_blocks)
7099 return 0;
7100   ;
7101   return 0;
7102 }
7103 _ACEOF
7104 rm -f conftest.$ac_objext
7105 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7106   (eval $ac_compile) 2>conftest.er1
7107   ac_status=$?
7108   grep -v '^ *+' conftest.er1 >conftest.err
7109   rm -f conftest.er1
7110   cat conftest.err >&5
7111   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7112   (exit $ac_status); } &&
7113          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
7114   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7115   (eval $ac_try) 2>&5
7116   ac_status=$?
7117   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7118   (exit $ac_status); }; } &&
7119          { ac_try='test -s conftest.$ac_objext'
7120   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7121   (eval $ac_try) 2>&5
7122   ac_status=$?
7123   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7124   (exit $ac_status); }; }; then
7125   ac_cv_member_struct_stat_st_blocks=yes
7126 else
7127   echo "$as_me: failed program was:" >&5
7128 sed 's/^/| /' conftest.$ac_ext >&5
7129
7130 ac_cv_member_struct_stat_st_blocks=no
7131 fi
7132 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7133 fi
7134 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7135 fi
7136 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blocks" >&5
7137 echo "${ECHO_T}$ac_cv_member_struct_stat_st_blocks" >&6
7138 if test $ac_cv_member_struct_stat_st_blocks = yes; then
7139
7140 cat >>confdefs.h <<_ACEOF
7141 #define HAVE_STRUCT_STAT_ST_BLOCKS 1
7142 _ACEOF
7143
7144
7145 fi
7146
7147 echo "$as_me:$LINENO: checking for struct stat.st_rdev" >&5
7148 echo $ECHO_N "checking for struct stat.st_rdev... $ECHO_C" >&6
7149 if test "${ac_cv_member_struct_stat_st_rdev+set}" = set; then
7150   echo $ECHO_N "(cached) $ECHO_C" >&6
7151 else
7152   cat >conftest.$ac_ext <<_ACEOF
7153 /* confdefs.h.  */
7154 _ACEOF
7155 cat confdefs.h >>conftest.$ac_ext
7156 cat >>conftest.$ac_ext <<_ACEOF
7157 /* end confdefs.h.  */
7158 $ac_includes_default
7159 int
7160 main ()
7161 {
7162 static struct stat ac_aggr;
7163 if (ac_aggr.st_rdev)
7164 return 0;
7165   ;
7166   return 0;
7167 }
7168 _ACEOF
7169 rm -f conftest.$ac_objext
7170 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7171   (eval $ac_compile) 2>conftest.er1
7172   ac_status=$?
7173   grep -v '^ *+' conftest.er1 >conftest.err
7174   rm -f conftest.er1
7175   cat conftest.err >&5
7176   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7177   (exit $ac_status); } &&
7178          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
7179   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7180   (eval $ac_try) 2>&5
7181   ac_status=$?
7182   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7183   (exit $ac_status); }; } &&
7184          { ac_try='test -s conftest.$ac_objext'
7185   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7186   (eval $ac_try) 2>&5
7187   ac_status=$?
7188   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7189   (exit $ac_status); }; }; then
7190   ac_cv_member_struct_stat_st_rdev=yes
7191 else
7192   echo "$as_me: failed program was:" >&5
7193 sed 's/^/| /' conftest.$ac_ext >&5
7194
7195 cat >conftest.$ac_ext <<_ACEOF
7196 /* confdefs.h.  */
7197 _ACEOF
7198 cat confdefs.h >>conftest.$ac_ext
7199 cat >>conftest.$ac_ext <<_ACEOF
7200 /* end confdefs.h.  */
7201 $ac_includes_default
7202 int
7203 main ()
7204 {
7205 static struct stat ac_aggr;
7206 if (sizeof ac_aggr.st_rdev)
7207 return 0;
7208   ;
7209   return 0;
7210 }
7211 _ACEOF
7212 rm -f conftest.$ac_objext
7213 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7214   (eval $ac_compile) 2>conftest.er1
7215   ac_status=$?
7216   grep -v '^ *+' conftest.er1 >conftest.err
7217   rm -f conftest.er1
7218   cat conftest.err >&5
7219   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7220   (exit $ac_status); } &&
7221          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
7222   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7223   (eval $ac_try) 2>&5
7224   ac_status=$?
7225   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7226   (exit $ac_status); }; } &&
7227          { ac_try='test -s conftest.$ac_objext'
7228   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7229   (eval $ac_try) 2>&5
7230   ac_status=$?
7231   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7232   (exit $ac_status); }; }; then
7233   ac_cv_member_struct_stat_st_rdev=yes
7234 else
7235   echo "$as_me: failed program was:" >&5
7236 sed 's/^/| /' conftest.$ac_ext >&5
7237
7238 ac_cv_member_struct_stat_st_rdev=no
7239 fi
7240 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7241 fi
7242 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7243 fi
7244 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_rdev" >&5
7245 echo "${ECHO_T}$ac_cv_member_struct_stat_st_rdev" >&6
7246 if test $ac_cv_member_struct_stat_st_rdev = yes; then
7247
7248 cat >>confdefs.h <<_ACEOF
7249 #define HAVE_STRUCT_STAT_ST_RDEV 1
7250 _ACEOF
7251
7252
7253 fi
7254
7255
7256 # Check for library functions.
7257
7258
7259
7260
7261
7262
7263
7264
7265 for ac_func in getrusage times mkstemp strtof strtold snprintf ftruncate chsize
7266 do
7267 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7268 echo "$as_me:$LINENO: checking for $ac_func" >&5
7269 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7270 if eval "test \"\${$as_ac_var+set}\" = set"; then
7271   echo $ECHO_N "(cached) $ECHO_C" >&6
7272 else
7273   if test x$gcc_no_link = xyes; then
7274   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7275 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7276    { (exit 1); exit 1; }; }
7277 fi
7278 cat >conftest.$ac_ext <<_ACEOF
7279 /* confdefs.h.  */
7280 _ACEOF
7281 cat confdefs.h >>conftest.$ac_ext
7282 cat >>conftest.$ac_ext <<_ACEOF
7283 /* end confdefs.h.  */
7284 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7285    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7286 #define $ac_func innocuous_$ac_func
7287
7288 /* System header to define __stub macros and hopefully few prototypes,
7289     which can conflict with char $ac_func (); below.
7290     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7291     <limits.h> exists even on freestanding compilers.  */
7292
7293 #ifdef __STDC__
7294 # include <limits.h>
7295 #else
7296 # include <assert.h>
7297 #endif
7298
7299 #undef $ac_func
7300
7301 /* Override any gcc2 internal prototype to avoid an error.  */
7302 #ifdef __cplusplus
7303 extern "C"
7304 {
7305 #endif
7306 /* We use char because int might match the return type of a gcc2
7307    builtin and then its argument prototype would still apply.  */
7308 char $ac_func ();
7309 /* The GNU C library defines this for functions which it implements
7310     to always fail with ENOSYS.  Some functions are actually named
7311     something starting with __ and the normal name is an alias.  */
7312 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7313 choke me
7314 #else
7315 char (*f) () = $ac_func;
7316 #endif
7317 #ifdef __cplusplus
7318 }
7319 #endif
7320
7321 int
7322 main ()
7323 {
7324 return f != $ac_func;
7325   ;
7326   return 0;
7327 }
7328 _ACEOF
7329 rm -f conftest.$ac_objext conftest$ac_exeext
7330 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7331   (eval $ac_link) 2>conftest.er1
7332   ac_status=$?
7333   grep -v '^ *+' conftest.er1 >conftest.err
7334   rm -f conftest.er1
7335   cat conftest.err >&5
7336   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7337   (exit $ac_status); } &&
7338          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
7339   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7340   (eval $ac_try) 2>&5
7341   ac_status=$?
7342   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7343   (exit $ac_status); }; } &&
7344          { ac_try='test -s conftest$ac_exeext'
7345   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7346   (eval $ac_try) 2>&5
7347   ac_status=$?
7348   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7349   (exit $ac_status); }; }; then
7350   eval "$as_ac_var=yes"
7351 else
7352   echo "$as_me: failed program was:" >&5
7353 sed 's/^/| /' conftest.$ac_ext >&5
7354
7355 eval "$as_ac_var=no"
7356 fi
7357 rm -f conftest.err conftest.$ac_objext \
7358       conftest$ac_exeext conftest.$ac_ext
7359 fi
7360 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7361 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7362 if test `eval echo '${'$as_ac_var'}'` = yes; then
7363   cat >>confdefs.h <<_ACEOF
7364 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7365 _ACEOF
7366
7367 fi
7368 done
7369
7370
7371
7372
7373
7374
7375
7376
7377
7378 for ac_func in chdir strerror getlogin gethostname kill link symlink perror
7379 do
7380 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7381 echo "$as_me:$LINENO: checking for $ac_func" >&5
7382 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7383 if eval "test \"\${$as_ac_var+set}\" = set"; then
7384   echo $ECHO_N "(cached) $ECHO_C" >&6
7385 else
7386   if test x$gcc_no_link = xyes; then
7387   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7388 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7389    { (exit 1); exit 1; }; }
7390 fi
7391 cat >conftest.$ac_ext <<_ACEOF
7392 /* confdefs.h.  */
7393 _ACEOF
7394 cat confdefs.h >>conftest.$ac_ext
7395 cat >>conftest.$ac_ext <<_ACEOF
7396 /* end confdefs.h.  */
7397 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7398    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7399 #define $ac_func innocuous_$ac_func
7400
7401 /* System header to define __stub macros and hopefully few prototypes,
7402     which can conflict with char $ac_func (); below.
7403     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7404     <limits.h> exists even on freestanding compilers.  */
7405
7406 #ifdef __STDC__
7407 # include <limits.h>
7408 #else
7409 # include <assert.h>
7410 #endif
7411
7412 #undef $ac_func
7413
7414 /* Override any gcc2 internal prototype to avoid an error.  */
7415 #ifdef __cplusplus
7416 extern "C"
7417 {
7418 #endif
7419 /* We use char because int might match the return type of a gcc2
7420    builtin and then its argument prototype would still apply.  */
7421 char $ac_func ();
7422 /* The GNU C library defines this for functions which it implements
7423     to always fail with ENOSYS.  Some functions are actually named
7424     something starting with __ and the normal name is an alias.  */
7425 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7426 choke me
7427 #else
7428 char (*f) () = $ac_func;
7429 #endif
7430 #ifdef __cplusplus
7431 }
7432 #endif
7433
7434 int
7435 main ()
7436 {
7437 return f != $ac_func;
7438   ;
7439   return 0;
7440 }
7441 _ACEOF
7442 rm -f conftest.$ac_objext conftest$ac_exeext
7443 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7444   (eval $ac_link) 2>conftest.er1
7445   ac_status=$?
7446   grep -v '^ *+' conftest.er1 >conftest.err
7447   rm -f conftest.er1
7448   cat conftest.err >&5
7449   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7450   (exit $ac_status); } &&
7451          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
7452   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7453   (eval $ac_try) 2>&5
7454   ac_status=$?
7455   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7456   (exit $ac_status); }; } &&
7457          { ac_try='test -s conftest$ac_exeext'
7458   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7459   (eval $ac_try) 2>&5
7460   ac_status=$?
7461   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7462   (exit $ac_status); }; }; then
7463   eval "$as_ac_var=yes"
7464 else
7465   echo "$as_me: failed program was:" >&5
7466 sed 's/^/| /' conftest.$ac_ext >&5
7467
7468 eval "$as_ac_var=no"
7469 fi
7470 rm -f conftest.err conftest.$ac_objext \
7471       conftest$ac_exeext conftest.$ac_ext
7472 fi
7473 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7474 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7475 if test `eval echo '${'$as_ac_var'}'` = yes; then
7476   cat >>confdefs.h <<_ACEOF
7477 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7478 _ACEOF
7479
7480 fi
7481 done
7482
7483
7484
7485
7486
7487
7488
7489 for ac_func in sleep time ttyname signal alarm ctime
7490 do
7491 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7492 echo "$as_me:$LINENO: checking for $ac_func" >&5
7493 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7494 if eval "test \"\${$as_ac_var+set}\" = set"; then
7495   echo $ECHO_N "(cached) $ECHO_C" >&6
7496 else
7497   if test x$gcc_no_link = xyes; then
7498   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7499 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7500    { (exit 1); exit 1; }; }
7501 fi
7502 cat >conftest.$ac_ext <<_ACEOF
7503 /* confdefs.h.  */
7504 _ACEOF
7505 cat confdefs.h >>conftest.$ac_ext
7506 cat >>conftest.$ac_ext <<_ACEOF
7507 /* end confdefs.h.  */
7508 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7509    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7510 #define $ac_func innocuous_$ac_func
7511
7512 /* System header to define __stub macros and hopefully few prototypes,
7513     which can conflict with char $ac_func (); below.
7514     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7515     <limits.h> exists even on freestanding compilers.  */
7516
7517 #ifdef __STDC__
7518 # include <limits.h>
7519 #else
7520 # include <assert.h>
7521 #endif
7522
7523 #undef $ac_func
7524
7525 /* Override any gcc2 internal prototype to avoid an error.  */
7526 #ifdef __cplusplus
7527 extern "C"
7528 {
7529 #endif
7530 /* We use char because int might match the return type of a gcc2
7531    builtin and then its argument prototype would still apply.  */
7532 char $ac_func ();
7533 /* The GNU C library defines this for functions which it implements
7534     to always fail with ENOSYS.  Some functions are actually named
7535     something starting with __ and the normal name is an alias.  */
7536 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7537 choke me
7538 #else
7539 char (*f) () = $ac_func;
7540 #endif
7541 #ifdef __cplusplus
7542 }
7543 #endif
7544
7545 int
7546 main ()
7547 {
7548 return f != $ac_func;
7549   ;
7550   return 0;
7551 }
7552 _ACEOF
7553 rm -f conftest.$ac_objext conftest$ac_exeext
7554 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7555   (eval $ac_link) 2>conftest.er1
7556   ac_status=$?
7557   grep -v '^ *+' conftest.er1 >conftest.err
7558   rm -f conftest.er1
7559   cat conftest.err >&5
7560   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7561   (exit $ac_status); } &&
7562          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
7563   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7564   (eval $ac_try) 2>&5
7565   ac_status=$?
7566   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7567   (exit $ac_status); }; } &&
7568          { ac_try='test -s conftest$ac_exeext'
7569   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7570   (eval $ac_try) 2>&5
7571   ac_status=$?
7572   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7573   (exit $ac_status); }; }; then
7574   eval "$as_ac_var=yes"
7575 else
7576   echo "$as_me: failed program was:" >&5
7577 sed 's/^/| /' conftest.$ac_ext >&5
7578
7579 eval "$as_ac_var=no"
7580 fi
7581 rm -f conftest.err conftest.$ac_objext \
7582       conftest$ac_exeext conftest.$ac_ext
7583 fi
7584 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7585 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7586 if test `eval echo '${'$as_ac_var'}'` = yes; then
7587   cat >>confdefs.h <<_ACEOF
7588 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7589 _ACEOF
7590
7591 fi
7592 done
7593
7594
7595 # Check libc for getgid, getpid, getuid
7596 echo "$as_me:$LINENO: checking for getgid in -lc" >&5
7597 echo $ECHO_N "checking for getgid in -lc... $ECHO_C" >&6
7598 if test "${ac_cv_lib_c_getgid+set}" = set; then
7599   echo $ECHO_N "(cached) $ECHO_C" >&6
7600 else
7601   ac_check_lib_save_LIBS=$LIBS
7602 LIBS="-lc  $LIBS"
7603 if test x$gcc_no_link = xyes; then
7604   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7605 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7606    { (exit 1); exit 1; }; }
7607 fi
7608 cat >conftest.$ac_ext <<_ACEOF
7609 /* confdefs.h.  */
7610 _ACEOF
7611 cat confdefs.h >>conftest.$ac_ext
7612 cat >>conftest.$ac_ext <<_ACEOF
7613 /* end confdefs.h.  */
7614
7615 /* Override any gcc2 internal prototype to avoid an error.  */
7616 #ifdef __cplusplus
7617 extern "C"
7618 #endif
7619 /* We use char because int might match the return type of a gcc2
7620    builtin and then its argument prototype would still apply.  */
7621 char getgid ();
7622 int
7623 main ()
7624 {
7625 getgid ();
7626   ;
7627   return 0;
7628 }
7629 _ACEOF
7630 rm -f conftest.$ac_objext conftest$ac_exeext
7631 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7632   (eval $ac_link) 2>conftest.er1
7633   ac_status=$?
7634   grep -v '^ *+' conftest.er1 >conftest.err
7635   rm -f conftest.er1
7636   cat conftest.err >&5
7637   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7638   (exit $ac_status); } &&
7639          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
7640   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7641   (eval $ac_try) 2>&5
7642   ac_status=$?
7643   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7644   (exit $ac_status); }; } &&
7645          { ac_try='test -s conftest$ac_exeext'
7646   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7647   (eval $ac_try) 2>&5
7648   ac_status=$?
7649   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7650   (exit $ac_status); }; }; then
7651   ac_cv_lib_c_getgid=yes
7652 else
7653   echo "$as_me: failed program was:" >&5
7654 sed 's/^/| /' conftest.$ac_ext >&5
7655
7656 ac_cv_lib_c_getgid=no
7657 fi
7658 rm -f conftest.err conftest.$ac_objext \
7659       conftest$ac_exeext conftest.$ac_ext
7660 LIBS=$ac_check_lib_save_LIBS
7661 fi
7662 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getgid" >&5
7663 echo "${ECHO_T}$ac_cv_lib_c_getgid" >&6
7664 if test $ac_cv_lib_c_getgid = yes; then
7665
7666 cat >>confdefs.h <<\_ACEOF
7667 #define HAVE_GETGID 1
7668 _ACEOF
7669
7670 fi
7671
7672 echo "$as_me:$LINENO: checking for getpid in -lc" >&5
7673 echo $ECHO_N "checking for getpid in -lc... $ECHO_C" >&6
7674 if test "${ac_cv_lib_c_getpid+set}" = set; then
7675   echo $ECHO_N "(cached) $ECHO_C" >&6
7676 else
7677   ac_check_lib_save_LIBS=$LIBS
7678 LIBS="-lc  $LIBS"
7679 if test x$gcc_no_link = xyes; then
7680   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7681 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7682    { (exit 1); exit 1; }; }
7683 fi
7684 cat >conftest.$ac_ext <<_ACEOF
7685 /* confdefs.h.  */
7686 _ACEOF
7687 cat confdefs.h >>conftest.$ac_ext
7688 cat >>conftest.$ac_ext <<_ACEOF
7689 /* end confdefs.h.  */
7690
7691 /* Override any gcc2 internal prototype to avoid an error.  */
7692 #ifdef __cplusplus
7693 extern "C"
7694 #endif
7695 /* We use char because int might match the return type of a gcc2
7696    builtin and then its argument prototype would still apply.  */
7697 char getpid ();
7698 int
7699 main ()
7700 {
7701 getpid ();
7702   ;
7703   return 0;
7704 }
7705 _ACEOF
7706 rm -f conftest.$ac_objext conftest$ac_exeext
7707 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7708   (eval $ac_link) 2>conftest.er1
7709   ac_status=$?
7710   grep -v '^ *+' conftest.er1 >conftest.err
7711   rm -f conftest.er1
7712   cat conftest.err >&5
7713   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7714   (exit $ac_status); } &&
7715          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
7716   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7717   (eval $ac_try) 2>&5
7718   ac_status=$?
7719   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7720   (exit $ac_status); }; } &&
7721          { ac_try='test -s conftest$ac_exeext'
7722   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7723   (eval $ac_try) 2>&5
7724   ac_status=$?
7725   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7726   (exit $ac_status); }; }; then
7727   ac_cv_lib_c_getpid=yes
7728 else
7729   echo "$as_me: failed program was:" >&5
7730 sed 's/^/| /' conftest.$ac_ext >&5
7731
7732 ac_cv_lib_c_getpid=no
7733 fi
7734 rm -f conftest.err conftest.$ac_objext \
7735       conftest$ac_exeext conftest.$ac_ext
7736 LIBS=$ac_check_lib_save_LIBS
7737 fi
7738 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getpid" >&5
7739 echo "${ECHO_T}$ac_cv_lib_c_getpid" >&6
7740 if test $ac_cv_lib_c_getpid = yes; then
7741
7742 cat >>confdefs.h <<\_ACEOF
7743 #define HAVE_GETPID 1
7744 _ACEOF
7745
7746 fi
7747
7748 echo "$as_me:$LINENO: checking for getuid in -lc" >&5
7749 echo $ECHO_N "checking for getuid in -lc... $ECHO_C" >&6
7750 if test "${ac_cv_lib_c_getuid+set}" = set; then
7751   echo $ECHO_N "(cached) $ECHO_C" >&6
7752 else
7753   ac_check_lib_save_LIBS=$LIBS
7754 LIBS="-lc  $LIBS"
7755 if test x$gcc_no_link = xyes; then
7756   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7757 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7758    { (exit 1); exit 1; }; }
7759 fi
7760 cat >conftest.$ac_ext <<_ACEOF
7761 /* confdefs.h.  */
7762 _ACEOF
7763 cat confdefs.h >>conftest.$ac_ext
7764 cat >>conftest.$ac_ext <<_ACEOF
7765 /* end confdefs.h.  */
7766
7767 /* Override any gcc2 internal prototype to avoid an error.  */
7768 #ifdef __cplusplus
7769 extern "C"
7770 #endif
7771 /* We use char because int might match the return type of a gcc2
7772    builtin and then its argument prototype would still apply.  */
7773 char getuid ();
7774 int
7775 main ()
7776 {
7777 getuid ();
7778   ;
7779   return 0;
7780 }
7781 _ACEOF
7782 rm -f conftest.$ac_objext conftest$ac_exeext
7783 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7784   (eval $ac_link) 2>conftest.er1
7785   ac_status=$?
7786   grep -v '^ *+' conftest.er1 >conftest.err
7787   rm -f conftest.er1
7788   cat conftest.err >&5
7789   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7790   (exit $ac_status); } &&
7791          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
7792   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7793   (eval $ac_try) 2>&5
7794   ac_status=$?
7795   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7796   (exit $ac_status); }; } &&
7797          { ac_try='test -s conftest$ac_exeext'
7798   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7799   (eval $ac_try) 2>&5
7800   ac_status=$?
7801   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7802   (exit $ac_status); }; }; then
7803   ac_cv_lib_c_getuid=yes
7804 else
7805   echo "$as_me: failed program was:" >&5
7806 sed 's/^/| /' conftest.$ac_ext >&5
7807
7808 ac_cv_lib_c_getuid=no
7809 fi
7810 rm -f conftest.err conftest.$ac_objext \
7811       conftest$ac_exeext conftest.$ac_ext
7812 LIBS=$ac_check_lib_save_LIBS
7813 fi
7814 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getuid" >&5
7815 echo "${ECHO_T}$ac_cv_lib_c_getuid" >&6
7816 if test $ac_cv_lib_c_getuid = yes; then
7817
7818 cat >>confdefs.h <<\_ACEOF
7819 #define HAVE_GETUID 1
7820 _ACEOF
7821
7822 fi
7823
7824
7825 # Check for C99 (and other IEEE) math functions
7826 # ??? This list seems awful long. Is there a better way to test for these?
7827 echo "$as_me:$LINENO: checking for acosf in -lm" >&5
7828 echo $ECHO_N "checking for acosf in -lm... $ECHO_C" >&6
7829 if test "${ac_cv_lib_m_acosf+set}" = set; then
7830   echo $ECHO_N "(cached) $ECHO_C" >&6
7831 else
7832   ac_check_lib_save_LIBS=$LIBS
7833 LIBS="-lm  $LIBS"
7834 if test x$gcc_no_link = xyes; then
7835   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7836 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7837    { (exit 1); exit 1; }; }
7838 fi
7839 cat >conftest.$ac_ext <<_ACEOF
7840 /* confdefs.h.  */
7841 _ACEOF
7842 cat confdefs.h >>conftest.$ac_ext
7843 cat >>conftest.$ac_ext <<_ACEOF
7844 /* end confdefs.h.  */
7845
7846 /* Override any gcc2 internal prototype to avoid an error.  */
7847 #ifdef __cplusplus
7848 extern "C"
7849 #endif
7850 /* We use char because int might match the return type of a gcc2
7851    builtin and then its argument prototype would still apply.  */
7852 char acosf ();
7853 int
7854 main ()
7855 {
7856 acosf ();
7857   ;
7858   return 0;
7859 }
7860 _ACEOF
7861 rm -f conftest.$ac_objext conftest$ac_exeext
7862 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7863   (eval $ac_link) 2>conftest.er1
7864   ac_status=$?
7865   grep -v '^ *+' conftest.er1 >conftest.err
7866   rm -f conftest.er1
7867   cat conftest.err >&5
7868   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7869   (exit $ac_status); } &&
7870          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
7871   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7872   (eval $ac_try) 2>&5
7873   ac_status=$?
7874   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7875   (exit $ac_status); }; } &&
7876          { ac_try='test -s conftest$ac_exeext'
7877   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7878   (eval $ac_try) 2>&5
7879   ac_status=$?
7880   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7881   (exit $ac_status); }; }; then
7882   ac_cv_lib_m_acosf=yes
7883 else
7884   echo "$as_me: failed program was:" >&5
7885 sed 's/^/| /' conftest.$ac_ext >&5
7886
7887 ac_cv_lib_m_acosf=no
7888 fi
7889 rm -f conftest.err conftest.$ac_objext \
7890       conftest$ac_exeext conftest.$ac_ext
7891 LIBS=$ac_check_lib_save_LIBS
7892 fi
7893 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosf" >&5
7894 echo "${ECHO_T}$ac_cv_lib_m_acosf" >&6
7895 if test $ac_cv_lib_m_acosf = yes; then
7896
7897 cat >>confdefs.h <<\_ACEOF
7898 #define HAVE_ACOSF 1
7899 _ACEOF
7900
7901 fi
7902
7903 echo "$as_me:$LINENO: checking for acos in -lm" >&5
7904 echo $ECHO_N "checking for acos in -lm... $ECHO_C" >&6
7905 if test "${ac_cv_lib_m_acos+set}" = set; then
7906   echo $ECHO_N "(cached) $ECHO_C" >&6
7907 else
7908   ac_check_lib_save_LIBS=$LIBS
7909 LIBS="-lm  $LIBS"
7910 if test x$gcc_no_link = xyes; then
7911   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7912 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7913    { (exit 1); exit 1; }; }
7914 fi
7915 cat >conftest.$ac_ext <<_ACEOF
7916 /* confdefs.h.  */
7917 _ACEOF
7918 cat confdefs.h >>conftest.$ac_ext
7919 cat >>conftest.$ac_ext <<_ACEOF
7920 /* end confdefs.h.  */
7921
7922 /* Override any gcc2 internal prototype to avoid an error.  */
7923 #ifdef __cplusplus
7924 extern "C"
7925 #endif
7926 /* We use char because int might match the return type of a gcc2
7927    builtin and then its argument prototype would still apply.  */
7928 char acos ();
7929 int
7930 main ()
7931 {
7932 acos ();
7933   ;
7934   return 0;
7935 }
7936 _ACEOF
7937 rm -f conftest.$ac_objext conftest$ac_exeext
7938 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7939   (eval $ac_link) 2>conftest.er1
7940   ac_status=$?
7941   grep -v '^ *+' conftest.er1 >conftest.err
7942   rm -f conftest.er1
7943   cat conftest.err >&5
7944   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7945   (exit $ac_status); } &&
7946          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
7947   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7948   (eval $ac_try) 2>&5
7949   ac_status=$?
7950   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7951   (exit $ac_status); }; } &&
7952          { ac_try='test -s conftest$ac_exeext'
7953   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7954   (eval $ac_try) 2>&5
7955   ac_status=$?
7956   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7957   (exit $ac_status); }; }; then
7958   ac_cv_lib_m_acos=yes
7959 else
7960   echo "$as_me: failed program was:" >&5
7961 sed 's/^/| /' conftest.$ac_ext >&5
7962
7963 ac_cv_lib_m_acos=no
7964 fi
7965 rm -f conftest.err conftest.$ac_objext \
7966       conftest$ac_exeext conftest.$ac_ext
7967 LIBS=$ac_check_lib_save_LIBS
7968 fi
7969 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acos" >&5
7970 echo "${ECHO_T}$ac_cv_lib_m_acos" >&6
7971 if test $ac_cv_lib_m_acos = yes; then
7972
7973 cat >>confdefs.h <<\_ACEOF
7974 #define HAVE_ACOS 1
7975 _ACEOF
7976
7977 fi
7978
7979 echo "$as_me:$LINENO: checking for acosl in -lm" >&5
7980 echo $ECHO_N "checking for acosl in -lm... $ECHO_C" >&6
7981 if test "${ac_cv_lib_m_acosl+set}" = set; then
7982   echo $ECHO_N "(cached) $ECHO_C" >&6
7983 else
7984   ac_check_lib_save_LIBS=$LIBS
7985 LIBS="-lm  $LIBS"
7986 if test x$gcc_no_link = xyes; then
7987   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7988 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7989    { (exit 1); exit 1; }; }
7990 fi
7991 cat >conftest.$ac_ext <<_ACEOF
7992 /* confdefs.h.  */
7993 _ACEOF
7994 cat confdefs.h >>conftest.$ac_ext
7995 cat >>conftest.$ac_ext <<_ACEOF
7996 /* end confdefs.h.  */
7997
7998 /* Override any gcc2 internal prototype to avoid an error.  */
7999 #ifdef __cplusplus
8000 extern "C"
8001 #endif
8002 /* We use char because int might match the return type of a gcc2
8003    builtin and then its argument prototype would still apply.  */
8004 char acosl ();
8005 int
8006 main ()
8007 {
8008 acosl ();
8009   ;
8010   return 0;
8011 }
8012 _ACEOF
8013 rm -f conftest.$ac_objext conftest$ac_exeext
8014 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8015   (eval $ac_link) 2>conftest.er1
8016   ac_status=$?
8017   grep -v '^ *+' conftest.er1 >conftest.err
8018   rm -f conftest.er1
8019   cat conftest.err >&5
8020   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8021   (exit $ac_status); } &&
8022          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
8023   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8024   (eval $ac_try) 2>&5
8025   ac_status=$?
8026   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8027   (exit $ac_status); }; } &&
8028          { ac_try='test -s conftest$ac_exeext'
8029   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8030   (eval $ac_try) 2>&5
8031   ac_status=$?
8032   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8033   (exit $ac_status); }; }; then
8034   ac_cv_lib_m_acosl=yes
8035 else
8036   echo "$as_me: failed program was:" >&5
8037 sed 's/^/| /' conftest.$ac_ext >&5
8038
8039 ac_cv_lib_m_acosl=no
8040 fi
8041 rm -f conftest.err conftest.$ac_objext \
8042       conftest$ac_exeext conftest.$ac_ext
8043 LIBS=$ac_check_lib_save_LIBS
8044 fi
8045 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosl" >&5
8046 echo "${ECHO_T}$ac_cv_lib_m_acosl" >&6
8047 if test $ac_cv_lib_m_acosl = yes; then
8048
8049 cat >>confdefs.h <<\_ACEOF
8050 #define HAVE_ACOSL 1
8051 _ACEOF
8052
8053 fi
8054
8055 echo "$as_me:$LINENO: checking for acoshf in -lm" >&5
8056 echo $ECHO_N "checking for acoshf in -lm... $ECHO_C" >&6
8057 if test "${ac_cv_lib_m_acoshf+set}" = set; then
8058   echo $ECHO_N "(cached) $ECHO_C" >&6
8059 else
8060   ac_check_lib_save_LIBS=$LIBS
8061 LIBS="-lm  $LIBS"
8062 if test x$gcc_no_link = xyes; then
8063   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8064 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8065    { (exit 1); exit 1; }; }
8066 fi
8067 cat >conftest.$ac_ext <<_ACEOF
8068 /* confdefs.h.  */
8069 _ACEOF
8070 cat confdefs.h >>conftest.$ac_ext
8071 cat >>conftest.$ac_ext <<_ACEOF
8072 /* end confdefs.h.  */
8073
8074 /* Override any gcc2 internal prototype to avoid an error.  */
8075 #ifdef __cplusplus
8076 extern "C"
8077 #endif
8078 /* We use char because int might match the return type of a gcc2
8079    builtin and then its argument prototype would still apply.  */
8080 char acoshf ();
8081 int
8082 main ()
8083 {
8084 acoshf ();
8085   ;
8086   return 0;
8087 }
8088 _ACEOF
8089 rm -f conftest.$ac_objext conftest$ac_exeext
8090 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8091   (eval $ac_link) 2>conftest.er1
8092   ac_status=$?
8093   grep -v '^ *+' conftest.er1 >conftest.err
8094   rm -f conftest.er1
8095   cat conftest.err >&5
8096   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8097   (exit $ac_status); } &&
8098          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
8099   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8100   (eval $ac_try) 2>&5
8101   ac_status=$?
8102   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8103   (exit $ac_status); }; } &&
8104          { ac_try='test -s conftest$ac_exeext'
8105   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8106   (eval $ac_try) 2>&5
8107   ac_status=$?
8108   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8109   (exit $ac_status); }; }; then
8110   ac_cv_lib_m_acoshf=yes
8111 else
8112   echo "$as_me: failed program was:" >&5
8113 sed 's/^/| /' conftest.$ac_ext >&5
8114
8115 ac_cv_lib_m_acoshf=no
8116 fi
8117 rm -f conftest.err conftest.$ac_objext \
8118       conftest$ac_exeext conftest.$ac_ext
8119 LIBS=$ac_check_lib_save_LIBS
8120 fi
8121 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acoshf" >&5
8122 echo "${ECHO_T}$ac_cv_lib_m_acoshf" >&6
8123 if test $ac_cv_lib_m_acoshf = yes; then
8124
8125 cat >>confdefs.h <<\_ACEOF
8126 #define HAVE_ACOSHF 1
8127 _ACEOF
8128
8129 fi
8130
8131 echo "$as_me:$LINENO: checking for acosh in -lm" >&5
8132 echo $ECHO_N "checking for acosh in -lm... $ECHO_C" >&6
8133 if test "${ac_cv_lib_m_acosh+set}" = set; then
8134   echo $ECHO_N "(cached) $ECHO_C" >&6
8135 else
8136   ac_check_lib_save_LIBS=$LIBS
8137 LIBS="-lm  $LIBS"
8138 if test x$gcc_no_link = xyes; then
8139   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8140 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8141    { (exit 1); exit 1; }; }
8142 fi
8143 cat >conftest.$ac_ext <<_ACEOF
8144 /* confdefs.h.  */
8145 _ACEOF
8146 cat confdefs.h >>conftest.$ac_ext
8147 cat >>conftest.$ac_ext <<_ACEOF
8148 /* end confdefs.h.  */
8149
8150 /* Override any gcc2 internal prototype to avoid an error.  */
8151 #ifdef __cplusplus
8152 extern "C"
8153 #endif
8154 /* We use char because int might match the return type of a gcc2
8155    builtin and then its argument prototype would still apply.  */
8156 char acosh ();
8157 int
8158 main ()
8159 {
8160 acosh ();
8161   ;
8162   return 0;
8163 }
8164 _ACEOF
8165 rm -f conftest.$ac_objext conftest$ac_exeext
8166 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8167   (eval $ac_link) 2>conftest.er1
8168   ac_status=$?
8169   grep -v '^ *+' conftest.er1 >conftest.err
8170   rm -f conftest.er1
8171   cat conftest.err >&5
8172   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8173   (exit $ac_status); } &&
8174          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
8175   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8176   (eval $ac_try) 2>&5
8177   ac_status=$?
8178   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8179   (exit $ac_status); }; } &&
8180          { ac_try='test -s conftest$ac_exeext'
8181   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8182   (eval $ac_try) 2>&5
8183   ac_status=$?
8184   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8185   (exit $ac_status); }; }; then
8186   ac_cv_lib_m_acosh=yes
8187 else
8188   echo "$as_me: failed program was:" >&5
8189 sed 's/^/| /' conftest.$ac_ext >&5
8190
8191 ac_cv_lib_m_acosh=no
8192 fi
8193 rm -f conftest.err conftest.$ac_objext \
8194       conftest$ac_exeext conftest.$ac_ext
8195 LIBS=$ac_check_lib_save_LIBS
8196 fi
8197 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosh" >&5
8198 echo "${ECHO_T}$ac_cv_lib_m_acosh" >&6
8199 if test $ac_cv_lib_m_acosh = yes; then
8200
8201 cat >>confdefs.h <<\_ACEOF
8202 #define HAVE_ACOSH 1
8203 _ACEOF
8204
8205 fi
8206
8207 echo "$as_me:$LINENO: checking for acoshl in -lm" >&5
8208 echo $ECHO_N "checking for acoshl in -lm... $ECHO_C" >&6
8209 if test "${ac_cv_lib_m_acoshl+set}" = set; then
8210   echo $ECHO_N "(cached) $ECHO_C" >&6
8211 else
8212   ac_check_lib_save_LIBS=$LIBS
8213 LIBS="-lm  $LIBS"
8214 if test x$gcc_no_link = xyes; then
8215   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8216 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8217    { (exit 1); exit 1; }; }
8218 fi
8219 cat >conftest.$ac_ext <<_ACEOF
8220 /* confdefs.h.  */
8221 _ACEOF
8222 cat confdefs.h >>conftest.$ac_ext
8223 cat >>conftest.$ac_ext <<_ACEOF
8224 /* end confdefs.h.  */
8225
8226 /* Override any gcc2 internal prototype to avoid an error.  */
8227 #ifdef __cplusplus
8228 extern "C"
8229 #endif
8230 /* We use char because int might match the return type of a gcc2
8231    builtin and then its argument prototype would still apply.  */
8232 char acoshl ();
8233 int
8234 main ()
8235 {
8236 acoshl ();
8237   ;
8238   return 0;
8239 }
8240 _ACEOF
8241 rm -f conftest.$ac_objext conftest$ac_exeext
8242 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8243   (eval $ac_link) 2>conftest.er1
8244   ac_status=$?
8245   grep -v '^ *+' conftest.er1 >conftest.err
8246   rm -f conftest.er1
8247   cat conftest.err >&5
8248   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8249   (exit $ac_status); } &&
8250          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
8251   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8252   (eval $ac_try) 2>&5
8253   ac_status=$?
8254   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8255   (exit $ac_status); }; } &&
8256          { ac_try='test -s conftest$ac_exeext'
8257   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8258   (eval $ac_try) 2>&5
8259   ac_status=$?
8260   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8261   (exit $ac_status); }; }; then
8262   ac_cv_lib_m_acoshl=yes
8263 else
8264   echo "$as_me: failed program was:" >&5
8265 sed 's/^/| /' conftest.$ac_ext >&5
8266
8267 ac_cv_lib_m_acoshl=no
8268 fi
8269 rm -f conftest.err conftest.$ac_objext \
8270       conftest$ac_exeext conftest.$ac_ext
8271 LIBS=$ac_check_lib_save_LIBS
8272 fi
8273 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acoshl" >&5
8274 echo "${ECHO_T}$ac_cv_lib_m_acoshl" >&6
8275 if test $ac_cv_lib_m_acoshl = yes; then
8276
8277 cat >>confdefs.h <<\_ACEOF
8278 #define HAVE_ACOSHL 1
8279 _ACEOF
8280
8281 fi
8282
8283 echo "$as_me:$LINENO: checking for asinf in -lm" >&5
8284 echo $ECHO_N "checking for asinf in -lm... $ECHO_C" >&6
8285 if test "${ac_cv_lib_m_asinf+set}" = set; then
8286   echo $ECHO_N "(cached) $ECHO_C" >&6
8287 else
8288   ac_check_lib_save_LIBS=$LIBS
8289 LIBS="-lm  $LIBS"
8290 if test x$gcc_no_link = xyes; then
8291   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8292 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8293    { (exit 1); exit 1; }; }
8294 fi
8295 cat >conftest.$ac_ext <<_ACEOF
8296 /* confdefs.h.  */
8297 _ACEOF
8298 cat confdefs.h >>conftest.$ac_ext
8299 cat >>conftest.$ac_ext <<_ACEOF
8300 /* end confdefs.h.  */
8301
8302 /* Override any gcc2 internal prototype to avoid an error.  */
8303 #ifdef __cplusplus
8304 extern "C"
8305 #endif
8306 /* We use char because int might match the return type of a gcc2
8307    builtin and then its argument prototype would still apply.  */
8308 char asinf ();
8309 int
8310 main ()
8311 {
8312 asinf ();
8313   ;
8314   return 0;
8315 }
8316 _ACEOF
8317 rm -f conftest.$ac_objext conftest$ac_exeext
8318 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8319   (eval $ac_link) 2>conftest.er1
8320   ac_status=$?
8321   grep -v '^ *+' conftest.er1 >conftest.err
8322   rm -f conftest.er1
8323   cat conftest.err >&5
8324   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8325   (exit $ac_status); } &&
8326          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
8327   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8328   (eval $ac_try) 2>&5
8329   ac_status=$?
8330   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8331   (exit $ac_status); }; } &&
8332          { ac_try='test -s conftest$ac_exeext'
8333   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8334   (eval $ac_try) 2>&5
8335   ac_status=$?
8336   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8337   (exit $ac_status); }; }; then
8338   ac_cv_lib_m_asinf=yes
8339 else
8340   echo "$as_me: failed program was:" >&5
8341 sed 's/^/| /' conftest.$ac_ext >&5
8342
8343 ac_cv_lib_m_asinf=no
8344 fi
8345 rm -f conftest.err conftest.$ac_objext \
8346       conftest$ac_exeext conftest.$ac_ext
8347 LIBS=$ac_check_lib_save_LIBS
8348 fi
8349 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinf" >&5
8350 echo "${ECHO_T}$ac_cv_lib_m_asinf" >&6
8351 if test $ac_cv_lib_m_asinf = yes; then
8352
8353 cat >>confdefs.h <<\_ACEOF
8354 #define HAVE_ASINF 1
8355 _ACEOF
8356
8357 fi
8358
8359 echo "$as_me:$LINENO: checking for asin in -lm" >&5
8360 echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
8361 if test "${ac_cv_lib_m_asin+set}" = set; then
8362   echo $ECHO_N "(cached) $ECHO_C" >&6
8363 else
8364   ac_check_lib_save_LIBS=$LIBS
8365 LIBS="-lm  $LIBS"
8366 if test x$gcc_no_link = xyes; then
8367   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8368 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8369    { (exit 1); exit 1; }; }
8370 fi
8371 cat >conftest.$ac_ext <<_ACEOF
8372 /* confdefs.h.  */
8373 _ACEOF
8374 cat confdefs.h >>conftest.$ac_ext
8375 cat >>conftest.$ac_ext <<_ACEOF
8376 /* end confdefs.h.  */
8377
8378 /* Override any gcc2 internal prototype to avoid an error.  */
8379 #ifdef __cplusplus
8380 extern "C"
8381 #endif
8382 /* We use char because int might match the return type of a gcc2
8383    builtin and then its argument prototype would still apply.  */
8384 char asin ();
8385 int
8386 main ()
8387 {
8388 asin ();
8389   ;
8390   return 0;
8391 }
8392 _ACEOF
8393 rm -f conftest.$ac_objext conftest$ac_exeext
8394 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8395   (eval $ac_link) 2>conftest.er1
8396   ac_status=$?
8397   grep -v '^ *+' conftest.er1 >conftest.err
8398   rm -f conftest.er1
8399   cat conftest.err >&5
8400   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8401   (exit $ac_status); } &&
8402          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
8403   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8404   (eval $ac_try) 2>&5
8405   ac_status=$?
8406   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8407   (exit $ac_status); }; } &&
8408          { ac_try='test -s conftest$ac_exeext'
8409   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8410   (eval $ac_try) 2>&5
8411   ac_status=$?
8412   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8413   (exit $ac_status); }; }; then
8414   ac_cv_lib_m_asin=yes
8415 else
8416   echo "$as_me: failed program was:" >&5
8417 sed 's/^/| /' conftest.$ac_ext >&5
8418
8419 ac_cv_lib_m_asin=no
8420 fi
8421 rm -f conftest.err conftest.$ac_objext \
8422       conftest$ac_exeext conftest.$ac_ext
8423 LIBS=$ac_check_lib_save_LIBS
8424 fi
8425 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
8426 echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
8427 if test $ac_cv_lib_m_asin = yes; then
8428
8429 cat >>confdefs.h <<\_ACEOF
8430 #define HAVE_ASIN 1
8431 _ACEOF
8432
8433 fi
8434
8435 echo "$as_me:$LINENO: checking for asinl in -lm" >&5
8436 echo $ECHO_N "checking for asinl in -lm... $ECHO_C" >&6
8437 if test "${ac_cv_lib_m_asinl+set}" = set; then
8438   echo $ECHO_N "(cached) $ECHO_C" >&6
8439 else
8440   ac_check_lib_save_LIBS=$LIBS
8441 LIBS="-lm  $LIBS"
8442 if test x$gcc_no_link = xyes; then
8443   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8444 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8445    { (exit 1); exit 1; }; }
8446 fi
8447 cat >conftest.$ac_ext <<_ACEOF
8448 /* confdefs.h.  */
8449 _ACEOF
8450 cat confdefs.h >>conftest.$ac_ext
8451 cat >>conftest.$ac_ext <<_ACEOF
8452 /* end confdefs.h.  */
8453
8454 /* Override any gcc2 internal prototype to avoid an error.  */
8455 #ifdef __cplusplus
8456 extern "C"
8457 #endif
8458 /* We use char because int might match the return type of a gcc2
8459    builtin and then its argument prototype would still apply.  */
8460 char asinl ();
8461 int
8462 main ()
8463 {
8464 asinl ();
8465   ;
8466   return 0;
8467 }
8468 _ACEOF
8469 rm -f conftest.$ac_objext conftest$ac_exeext
8470 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8471   (eval $ac_link) 2>conftest.er1
8472   ac_status=$?
8473   grep -v '^ *+' conftest.er1 >conftest.err
8474   rm -f conftest.er1
8475   cat conftest.err >&5
8476   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8477   (exit $ac_status); } &&
8478          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
8479   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8480   (eval $ac_try) 2>&5
8481   ac_status=$?
8482   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8483   (exit $ac_status); }; } &&
8484          { ac_try='test -s conftest$ac_exeext'
8485   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8486   (eval $ac_try) 2>&5
8487   ac_status=$?
8488   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8489   (exit $ac_status); }; }; then
8490   ac_cv_lib_m_asinl=yes
8491 else
8492   echo "$as_me: failed program was:" >&5
8493 sed 's/^/| /' conftest.$ac_ext >&5
8494
8495 ac_cv_lib_m_asinl=no
8496 fi
8497 rm -f conftest.err conftest.$ac_objext \
8498       conftest$ac_exeext conftest.$ac_ext
8499 LIBS=$ac_check_lib_save_LIBS
8500 fi
8501 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinl" >&5
8502 echo "${ECHO_T}$ac_cv_lib_m_asinl" >&6
8503 if test $ac_cv_lib_m_asinl = yes; then
8504
8505 cat >>confdefs.h <<\_ACEOF
8506 #define HAVE_ASINL 1
8507 _ACEOF
8508
8509 fi
8510
8511 echo "$as_me:$LINENO: checking for asinhf in -lm" >&5
8512 echo $ECHO_N "checking for asinhf in -lm... $ECHO_C" >&6
8513 if test "${ac_cv_lib_m_asinhf+set}" = set; then
8514   echo $ECHO_N "(cached) $ECHO_C" >&6
8515 else
8516   ac_check_lib_save_LIBS=$LIBS
8517 LIBS="-lm  $LIBS"
8518 if test x$gcc_no_link = xyes; then
8519   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8520 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8521    { (exit 1); exit 1; }; }
8522 fi
8523 cat >conftest.$ac_ext <<_ACEOF
8524 /* confdefs.h.  */
8525 _ACEOF
8526 cat confdefs.h >>conftest.$ac_ext
8527 cat >>conftest.$ac_ext <<_ACEOF
8528 /* end confdefs.h.  */
8529
8530 /* Override any gcc2 internal prototype to avoid an error.  */
8531 #ifdef __cplusplus
8532 extern "C"
8533 #endif
8534 /* We use char because int might match the return type of a gcc2
8535    builtin and then its argument prototype would still apply.  */
8536 char asinhf ();
8537 int
8538 main ()
8539 {
8540 asinhf ();
8541   ;
8542   return 0;
8543 }
8544 _ACEOF
8545 rm -f conftest.$ac_objext conftest$ac_exeext
8546 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8547   (eval $ac_link) 2>conftest.er1
8548   ac_status=$?
8549   grep -v '^ *+' conftest.er1 >conftest.err
8550   rm -f conftest.er1
8551   cat conftest.err >&5
8552   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8553   (exit $ac_status); } &&
8554          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
8555   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8556   (eval $ac_try) 2>&5
8557   ac_status=$?
8558   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8559   (exit $ac_status); }; } &&
8560          { ac_try='test -s conftest$ac_exeext'
8561   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8562   (eval $ac_try) 2>&5
8563   ac_status=$?
8564   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8565   (exit $ac_status); }; }; then
8566   ac_cv_lib_m_asinhf=yes
8567 else
8568   echo "$as_me: failed program was:" >&5
8569 sed 's/^/| /' conftest.$ac_ext >&5
8570
8571 ac_cv_lib_m_asinhf=no
8572 fi
8573 rm -f conftest.err conftest.$ac_objext \
8574       conftest$ac_exeext conftest.$ac_ext
8575 LIBS=$ac_check_lib_save_LIBS
8576 fi
8577 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinhf" >&5
8578 echo "${ECHO_T}$ac_cv_lib_m_asinhf" >&6
8579 if test $ac_cv_lib_m_asinhf = yes; then
8580
8581 cat >>confdefs.h <<\_ACEOF
8582 #define HAVE_ASINHF 1
8583 _ACEOF
8584
8585 fi
8586
8587 echo "$as_me:$LINENO: checking for asinh in -lm" >&5
8588 echo $ECHO_N "checking for asinh in -lm... $ECHO_C" >&6
8589 if test "${ac_cv_lib_m_asinh+set}" = set; then
8590   echo $ECHO_N "(cached) $ECHO_C" >&6
8591 else
8592   ac_check_lib_save_LIBS=$LIBS
8593 LIBS="-lm  $LIBS"
8594 if test x$gcc_no_link = xyes; then
8595   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8596 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8597    { (exit 1); exit 1; }; }
8598 fi
8599 cat >conftest.$ac_ext <<_ACEOF
8600 /* confdefs.h.  */
8601 _ACEOF
8602 cat confdefs.h >>conftest.$ac_ext
8603 cat >>conftest.$ac_ext <<_ACEOF
8604 /* end confdefs.h.  */
8605
8606 /* Override any gcc2 internal prototype to avoid an error.  */
8607 #ifdef __cplusplus
8608 extern "C"
8609 #endif
8610 /* We use char because int might match the return type of a gcc2
8611    builtin and then its argument prototype would still apply.  */
8612 char asinh ();
8613 int
8614 main ()
8615 {
8616 asinh ();
8617   ;
8618   return 0;
8619 }
8620 _ACEOF
8621 rm -f conftest.$ac_objext conftest$ac_exeext
8622 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8623   (eval $ac_link) 2>conftest.er1
8624   ac_status=$?
8625   grep -v '^ *+' conftest.er1 >conftest.err
8626   rm -f conftest.er1
8627   cat conftest.err >&5
8628   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8629   (exit $ac_status); } &&
8630          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
8631   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8632   (eval $ac_try) 2>&5
8633   ac_status=$?
8634   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8635   (exit $ac_status); }; } &&
8636          { ac_try='test -s conftest$ac_exeext'
8637   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8638   (eval $ac_try) 2>&5
8639   ac_status=$?
8640   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8641   (exit $ac_status); }; }; then
8642   ac_cv_lib_m_asinh=yes
8643 else
8644   echo "$as_me: failed program was:" >&5
8645 sed 's/^/| /' conftest.$ac_ext >&5
8646
8647 ac_cv_lib_m_asinh=no
8648 fi
8649 rm -f conftest.err conftest.$ac_objext \
8650       conftest$ac_exeext conftest.$ac_ext
8651 LIBS=$ac_check_lib_save_LIBS
8652 fi
8653 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinh" >&5
8654 echo "${ECHO_T}$ac_cv_lib_m_asinh" >&6
8655 if test $ac_cv_lib_m_asinh = yes; then
8656
8657 cat >>confdefs.h <<\_ACEOF
8658 #define HAVE_ASINH 1
8659 _ACEOF
8660
8661 fi
8662
8663 echo "$as_me:$LINENO: checking for asinhl in -lm" >&5
8664 echo $ECHO_N "checking for asinhl in -lm... $ECHO_C" >&6
8665 if test "${ac_cv_lib_m_asinhl+set}" = set; then
8666   echo $ECHO_N "(cached) $ECHO_C" >&6
8667 else
8668   ac_check_lib_save_LIBS=$LIBS
8669 LIBS="-lm  $LIBS"
8670 if test x$gcc_no_link = xyes; then
8671   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8672 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8673    { (exit 1); exit 1; }; }
8674 fi
8675 cat >conftest.$ac_ext <<_ACEOF
8676 /* confdefs.h.  */
8677 _ACEOF
8678 cat confdefs.h >>conftest.$ac_ext
8679 cat >>conftest.$ac_ext <<_ACEOF
8680 /* end confdefs.h.  */
8681
8682 /* Override any gcc2 internal prototype to avoid an error.  */
8683 #ifdef __cplusplus
8684 extern "C"
8685 #endif
8686 /* We use char because int might match the return type of a gcc2
8687    builtin and then its argument prototype would still apply.  */
8688 char asinhl ();
8689 int
8690 main ()
8691 {
8692 asinhl ();
8693   ;
8694   return 0;
8695 }
8696 _ACEOF
8697 rm -f conftest.$ac_objext conftest$ac_exeext
8698 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8699   (eval $ac_link) 2>conftest.er1
8700   ac_status=$?
8701   grep -v '^ *+' conftest.er1 >conftest.err
8702   rm -f conftest.er1
8703   cat conftest.err >&5
8704   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8705   (exit $ac_status); } &&
8706          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
8707   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8708   (eval $ac_try) 2>&5
8709   ac_status=$?
8710   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8711   (exit $ac_status); }; } &&
8712          { ac_try='test -s conftest$ac_exeext'
8713   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8714   (eval $ac_try) 2>&5
8715   ac_status=$?
8716   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8717   (exit $ac_status); }; }; then
8718   ac_cv_lib_m_asinhl=yes
8719 else
8720   echo "$as_me: failed program was:" >&5
8721 sed 's/^/| /' conftest.$ac_ext >&5
8722
8723 ac_cv_lib_m_asinhl=no
8724 fi
8725 rm -f conftest.err conftest.$ac_objext \
8726       conftest$ac_exeext conftest.$ac_ext
8727 LIBS=$ac_check_lib_save_LIBS
8728 fi
8729 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinhl" >&5
8730 echo "${ECHO_T}$ac_cv_lib_m_asinhl" >&6
8731 if test $ac_cv_lib_m_asinhl = yes; then
8732
8733 cat >>confdefs.h <<\_ACEOF
8734 #define HAVE_ASINHL 1
8735 _ACEOF
8736
8737 fi
8738
8739 echo "$as_me:$LINENO: checking for atan2f in -lm" >&5
8740 echo $ECHO_N "checking for atan2f in -lm... $ECHO_C" >&6
8741 if test "${ac_cv_lib_m_atan2f+set}" = set; then
8742   echo $ECHO_N "(cached) $ECHO_C" >&6
8743 else
8744   ac_check_lib_save_LIBS=$LIBS
8745 LIBS="-lm  $LIBS"
8746 if test x$gcc_no_link = xyes; then
8747   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8748 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8749    { (exit 1); exit 1; }; }
8750 fi
8751 cat >conftest.$ac_ext <<_ACEOF
8752 /* confdefs.h.  */
8753 _ACEOF
8754 cat confdefs.h >>conftest.$ac_ext
8755 cat >>conftest.$ac_ext <<_ACEOF
8756 /* end confdefs.h.  */
8757
8758 /* Override any gcc2 internal prototype to avoid an error.  */
8759 #ifdef __cplusplus
8760 extern "C"
8761 #endif
8762 /* We use char because int might match the return type of a gcc2
8763    builtin and then its argument prototype would still apply.  */
8764 char atan2f ();
8765 int
8766 main ()
8767 {
8768 atan2f ();
8769   ;
8770   return 0;
8771 }
8772 _ACEOF
8773 rm -f conftest.$ac_objext conftest$ac_exeext
8774 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8775   (eval $ac_link) 2>conftest.er1
8776   ac_status=$?
8777   grep -v '^ *+' conftest.er1 >conftest.err
8778   rm -f conftest.er1
8779   cat conftest.err >&5
8780   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8781   (exit $ac_status); } &&
8782          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
8783   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8784   (eval $ac_try) 2>&5
8785   ac_status=$?
8786   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8787   (exit $ac_status); }; } &&
8788          { ac_try='test -s conftest$ac_exeext'
8789   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8790   (eval $ac_try) 2>&5
8791   ac_status=$?
8792   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8793   (exit $ac_status); }; }; then
8794   ac_cv_lib_m_atan2f=yes
8795 else
8796   echo "$as_me: failed program was:" >&5
8797 sed 's/^/| /' conftest.$ac_ext >&5
8798
8799 ac_cv_lib_m_atan2f=no
8800 fi
8801 rm -f conftest.err conftest.$ac_objext \
8802       conftest$ac_exeext conftest.$ac_ext
8803 LIBS=$ac_check_lib_save_LIBS
8804 fi
8805 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2f" >&5
8806 echo "${ECHO_T}$ac_cv_lib_m_atan2f" >&6
8807 if test $ac_cv_lib_m_atan2f = yes; then
8808
8809 cat >>confdefs.h <<\_ACEOF
8810 #define HAVE_ATAN2F 1
8811 _ACEOF
8812
8813 fi
8814
8815 echo "$as_me:$LINENO: checking for atan2 in -lm" >&5
8816 echo $ECHO_N "checking for atan2 in -lm... $ECHO_C" >&6
8817 if test "${ac_cv_lib_m_atan2+set}" = set; then
8818   echo $ECHO_N "(cached) $ECHO_C" >&6
8819 else
8820   ac_check_lib_save_LIBS=$LIBS
8821 LIBS="-lm  $LIBS"
8822 if test x$gcc_no_link = xyes; then
8823   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8824 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8825    { (exit 1); exit 1; }; }
8826 fi
8827 cat >conftest.$ac_ext <<_ACEOF
8828 /* confdefs.h.  */
8829 _ACEOF
8830 cat confdefs.h >>conftest.$ac_ext
8831 cat >>conftest.$ac_ext <<_ACEOF
8832 /* end confdefs.h.  */
8833
8834 /* Override any gcc2 internal prototype to avoid an error.  */
8835 #ifdef __cplusplus
8836 extern "C"
8837 #endif
8838 /* We use char because int might match the return type of a gcc2
8839    builtin and then its argument prototype would still apply.  */
8840 char atan2 ();
8841 int
8842 main ()
8843 {
8844 atan2 ();
8845   ;
8846   return 0;
8847 }
8848 _ACEOF
8849 rm -f conftest.$ac_objext conftest$ac_exeext
8850 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8851   (eval $ac_link) 2>conftest.er1
8852   ac_status=$?
8853   grep -v '^ *+' conftest.er1 >conftest.err
8854   rm -f conftest.er1
8855   cat conftest.err >&5
8856   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8857   (exit $ac_status); } &&
8858          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
8859   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8860   (eval $ac_try) 2>&5
8861   ac_status=$?
8862   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8863   (exit $ac_status); }; } &&
8864          { ac_try='test -s conftest$ac_exeext'
8865   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8866   (eval $ac_try) 2>&5
8867   ac_status=$?
8868   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8869   (exit $ac_status); }; }; then
8870   ac_cv_lib_m_atan2=yes
8871 else
8872   echo "$as_me: failed program was:" >&5
8873 sed 's/^/| /' conftest.$ac_ext >&5
8874
8875 ac_cv_lib_m_atan2=no
8876 fi
8877 rm -f conftest.err conftest.$ac_objext \
8878       conftest$ac_exeext conftest.$ac_ext
8879 LIBS=$ac_check_lib_save_LIBS
8880 fi
8881 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2" >&5
8882 echo "${ECHO_T}$ac_cv_lib_m_atan2" >&6
8883 if test $ac_cv_lib_m_atan2 = yes; then
8884
8885 cat >>confdefs.h <<\_ACEOF
8886 #define HAVE_ATAN2 1
8887 _ACEOF
8888
8889 fi
8890
8891 echo "$as_me:$LINENO: checking for atan2l in -lm" >&5
8892 echo $ECHO_N "checking for atan2l in -lm... $ECHO_C" >&6
8893 if test "${ac_cv_lib_m_atan2l+set}" = set; then
8894   echo $ECHO_N "(cached) $ECHO_C" >&6
8895 else
8896   ac_check_lib_save_LIBS=$LIBS
8897 LIBS="-lm  $LIBS"
8898 if test x$gcc_no_link = xyes; then
8899   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8900 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8901    { (exit 1); exit 1; }; }
8902 fi
8903 cat >conftest.$ac_ext <<_ACEOF
8904 /* confdefs.h.  */
8905 _ACEOF
8906 cat confdefs.h >>conftest.$ac_ext
8907 cat >>conftest.$ac_ext <<_ACEOF
8908 /* end confdefs.h.  */
8909
8910 /* Override any gcc2 internal prototype to avoid an error.  */
8911 #ifdef __cplusplus
8912 extern "C"
8913 #endif
8914 /* We use char because int might match the return type of a gcc2
8915    builtin and then its argument prototype would still apply.  */
8916 char atan2l ();
8917 int
8918 main ()
8919 {
8920 atan2l ();
8921   ;
8922   return 0;
8923 }
8924 _ACEOF
8925 rm -f conftest.$ac_objext conftest$ac_exeext
8926 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8927   (eval $ac_link) 2>conftest.er1
8928   ac_status=$?
8929   grep -v '^ *+' conftest.er1 >conftest.err
8930   rm -f conftest.er1
8931   cat conftest.err >&5
8932   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8933   (exit $ac_status); } &&
8934          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
8935   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8936   (eval $ac_try) 2>&5
8937   ac_status=$?
8938   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8939   (exit $ac_status); }; } &&
8940          { ac_try='test -s conftest$ac_exeext'
8941   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8942   (eval $ac_try) 2>&5
8943   ac_status=$?
8944   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8945   (exit $ac_status); }; }; then
8946   ac_cv_lib_m_atan2l=yes
8947 else
8948   echo "$as_me: failed program was:" >&5
8949 sed 's/^/| /' conftest.$ac_ext >&5
8950
8951 ac_cv_lib_m_atan2l=no
8952 fi
8953 rm -f conftest.err conftest.$ac_objext \
8954       conftest$ac_exeext conftest.$ac_ext
8955 LIBS=$ac_check_lib_save_LIBS
8956 fi
8957 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2l" >&5
8958 echo "${ECHO_T}$ac_cv_lib_m_atan2l" >&6
8959 if test $ac_cv_lib_m_atan2l = yes; then
8960
8961 cat >>confdefs.h <<\_ACEOF
8962 #define HAVE_ATAN2L 1
8963 _ACEOF
8964
8965 fi
8966
8967 echo "$as_me:$LINENO: checking for atanf in -lm" >&5
8968 echo $ECHO_N "checking for atanf in -lm... $ECHO_C" >&6
8969 if test "${ac_cv_lib_m_atanf+set}" = set; then
8970   echo $ECHO_N "(cached) $ECHO_C" >&6
8971 else
8972   ac_check_lib_save_LIBS=$LIBS
8973 LIBS="-lm  $LIBS"
8974 if test x$gcc_no_link = xyes; then
8975   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8976 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8977    { (exit 1); exit 1; }; }
8978 fi
8979 cat >conftest.$ac_ext <<_ACEOF
8980 /* confdefs.h.  */
8981 _ACEOF
8982 cat confdefs.h >>conftest.$ac_ext
8983 cat >>conftest.$ac_ext <<_ACEOF
8984 /* end confdefs.h.  */
8985
8986 /* Override any gcc2 internal prototype to avoid an error.  */
8987 #ifdef __cplusplus
8988 extern "C"
8989 #endif
8990 /* We use char because int might match the return type of a gcc2
8991    builtin and then its argument prototype would still apply.  */
8992 char atanf ();
8993 int
8994 main ()
8995 {
8996 atanf ();
8997   ;
8998   return 0;
8999 }
9000 _ACEOF
9001 rm -f conftest.$ac_objext conftest$ac_exeext
9002 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9003   (eval $ac_link) 2>conftest.er1
9004   ac_status=$?
9005   grep -v '^ *+' conftest.er1 >conftest.err
9006   rm -f conftest.er1
9007   cat conftest.err >&5
9008   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9009   (exit $ac_status); } &&
9010          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9011   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9012   (eval $ac_try) 2>&5
9013   ac_status=$?
9014   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9015   (exit $ac_status); }; } &&
9016          { ac_try='test -s conftest$ac_exeext'
9017   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9018   (eval $ac_try) 2>&5
9019   ac_status=$?
9020   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9021   (exit $ac_status); }; }; then
9022   ac_cv_lib_m_atanf=yes
9023 else
9024   echo "$as_me: failed program was:" >&5
9025 sed 's/^/| /' conftest.$ac_ext >&5
9026
9027 ac_cv_lib_m_atanf=no
9028 fi
9029 rm -f conftest.err conftest.$ac_objext \
9030       conftest$ac_exeext conftest.$ac_ext
9031 LIBS=$ac_check_lib_save_LIBS
9032 fi
9033 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanf" >&5
9034 echo "${ECHO_T}$ac_cv_lib_m_atanf" >&6
9035 if test $ac_cv_lib_m_atanf = yes; then
9036
9037 cat >>confdefs.h <<\_ACEOF
9038 #define HAVE_ATANF 1
9039 _ACEOF
9040
9041 fi
9042
9043 echo "$as_me:$LINENO: checking for atan in -lm" >&5
9044 echo $ECHO_N "checking for atan in -lm... $ECHO_C" >&6
9045 if test "${ac_cv_lib_m_atan+set}" = set; then
9046   echo $ECHO_N "(cached) $ECHO_C" >&6
9047 else
9048   ac_check_lib_save_LIBS=$LIBS
9049 LIBS="-lm  $LIBS"
9050 if test x$gcc_no_link = xyes; then
9051   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9052 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9053    { (exit 1); exit 1; }; }
9054 fi
9055 cat >conftest.$ac_ext <<_ACEOF
9056 /* confdefs.h.  */
9057 _ACEOF
9058 cat confdefs.h >>conftest.$ac_ext
9059 cat >>conftest.$ac_ext <<_ACEOF
9060 /* end confdefs.h.  */
9061
9062 /* Override any gcc2 internal prototype to avoid an error.  */
9063 #ifdef __cplusplus
9064 extern "C"
9065 #endif
9066 /* We use char because int might match the return type of a gcc2
9067    builtin and then its argument prototype would still apply.  */
9068 char atan ();
9069 int
9070 main ()
9071 {
9072 atan ();
9073   ;
9074   return 0;
9075 }
9076 _ACEOF
9077 rm -f conftest.$ac_objext conftest$ac_exeext
9078 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9079   (eval $ac_link) 2>conftest.er1
9080   ac_status=$?
9081   grep -v '^ *+' conftest.er1 >conftest.err
9082   rm -f conftest.er1
9083   cat conftest.err >&5
9084   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9085   (exit $ac_status); } &&
9086          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9087   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9088   (eval $ac_try) 2>&5
9089   ac_status=$?
9090   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9091   (exit $ac_status); }; } &&
9092          { ac_try='test -s conftest$ac_exeext'
9093   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9094   (eval $ac_try) 2>&5
9095   ac_status=$?
9096   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9097   (exit $ac_status); }; }; then
9098   ac_cv_lib_m_atan=yes
9099 else
9100   echo "$as_me: failed program was:" >&5
9101 sed 's/^/| /' conftest.$ac_ext >&5
9102
9103 ac_cv_lib_m_atan=no
9104 fi
9105 rm -f conftest.err conftest.$ac_objext \
9106       conftest$ac_exeext conftest.$ac_ext
9107 LIBS=$ac_check_lib_save_LIBS
9108 fi
9109 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan" >&5
9110 echo "${ECHO_T}$ac_cv_lib_m_atan" >&6
9111 if test $ac_cv_lib_m_atan = yes; then
9112
9113 cat >>confdefs.h <<\_ACEOF
9114 #define HAVE_ATAN 1
9115 _ACEOF
9116
9117 fi
9118
9119 echo "$as_me:$LINENO: checking for atanl in -lm" >&5
9120 echo $ECHO_N "checking for atanl in -lm... $ECHO_C" >&6
9121 if test "${ac_cv_lib_m_atanl+set}" = set; then
9122   echo $ECHO_N "(cached) $ECHO_C" >&6
9123 else
9124   ac_check_lib_save_LIBS=$LIBS
9125 LIBS="-lm  $LIBS"
9126 if test x$gcc_no_link = xyes; then
9127   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9128 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9129    { (exit 1); exit 1; }; }
9130 fi
9131 cat >conftest.$ac_ext <<_ACEOF
9132 /* confdefs.h.  */
9133 _ACEOF
9134 cat confdefs.h >>conftest.$ac_ext
9135 cat >>conftest.$ac_ext <<_ACEOF
9136 /* end confdefs.h.  */
9137
9138 /* Override any gcc2 internal prototype to avoid an error.  */
9139 #ifdef __cplusplus
9140 extern "C"
9141 #endif
9142 /* We use char because int might match the return type of a gcc2
9143    builtin and then its argument prototype would still apply.  */
9144 char atanl ();
9145 int
9146 main ()
9147 {
9148 atanl ();
9149   ;
9150   return 0;
9151 }
9152 _ACEOF
9153 rm -f conftest.$ac_objext conftest$ac_exeext
9154 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9155   (eval $ac_link) 2>conftest.er1
9156   ac_status=$?
9157   grep -v '^ *+' conftest.er1 >conftest.err
9158   rm -f conftest.er1
9159   cat conftest.err >&5
9160   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9161   (exit $ac_status); } &&
9162          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9163   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9164   (eval $ac_try) 2>&5
9165   ac_status=$?
9166   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9167   (exit $ac_status); }; } &&
9168          { ac_try='test -s conftest$ac_exeext'
9169   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9170   (eval $ac_try) 2>&5
9171   ac_status=$?
9172   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9173   (exit $ac_status); }; }; then
9174   ac_cv_lib_m_atanl=yes
9175 else
9176   echo "$as_me: failed program was:" >&5
9177 sed 's/^/| /' conftest.$ac_ext >&5
9178
9179 ac_cv_lib_m_atanl=no
9180 fi
9181 rm -f conftest.err conftest.$ac_objext \
9182       conftest$ac_exeext conftest.$ac_ext
9183 LIBS=$ac_check_lib_save_LIBS
9184 fi
9185 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanl" >&5
9186 echo "${ECHO_T}$ac_cv_lib_m_atanl" >&6
9187 if test $ac_cv_lib_m_atanl = yes; then
9188
9189 cat >>confdefs.h <<\_ACEOF
9190 #define HAVE_ATANL 1
9191 _ACEOF
9192
9193 fi
9194
9195 echo "$as_me:$LINENO: checking for atanhf in -lm" >&5
9196 echo $ECHO_N "checking for atanhf in -lm... $ECHO_C" >&6
9197 if test "${ac_cv_lib_m_atanhf+set}" = set; then
9198   echo $ECHO_N "(cached) $ECHO_C" >&6
9199 else
9200   ac_check_lib_save_LIBS=$LIBS
9201 LIBS="-lm  $LIBS"
9202 if test x$gcc_no_link = xyes; then
9203   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9204 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9205    { (exit 1); exit 1; }; }
9206 fi
9207 cat >conftest.$ac_ext <<_ACEOF
9208 /* confdefs.h.  */
9209 _ACEOF
9210 cat confdefs.h >>conftest.$ac_ext
9211 cat >>conftest.$ac_ext <<_ACEOF
9212 /* end confdefs.h.  */
9213
9214 /* Override any gcc2 internal prototype to avoid an error.  */
9215 #ifdef __cplusplus
9216 extern "C"
9217 #endif
9218 /* We use char because int might match the return type of a gcc2
9219    builtin and then its argument prototype would still apply.  */
9220 char atanhf ();
9221 int
9222 main ()
9223 {
9224 atanhf ();
9225   ;
9226   return 0;
9227 }
9228 _ACEOF
9229 rm -f conftest.$ac_objext conftest$ac_exeext
9230 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9231   (eval $ac_link) 2>conftest.er1
9232   ac_status=$?
9233   grep -v '^ *+' conftest.er1 >conftest.err
9234   rm -f conftest.er1
9235   cat conftest.err >&5
9236   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9237   (exit $ac_status); } &&
9238          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9239   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9240   (eval $ac_try) 2>&5
9241   ac_status=$?
9242   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9243   (exit $ac_status); }; } &&
9244          { ac_try='test -s conftest$ac_exeext'
9245   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9246   (eval $ac_try) 2>&5
9247   ac_status=$?
9248   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9249   (exit $ac_status); }; }; then
9250   ac_cv_lib_m_atanhf=yes
9251 else
9252   echo "$as_me: failed program was:" >&5
9253 sed 's/^/| /' conftest.$ac_ext >&5
9254
9255 ac_cv_lib_m_atanhf=no
9256 fi
9257 rm -f conftest.err conftest.$ac_objext \
9258       conftest$ac_exeext conftest.$ac_ext
9259 LIBS=$ac_check_lib_save_LIBS
9260 fi
9261 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanhf" >&5
9262 echo "${ECHO_T}$ac_cv_lib_m_atanhf" >&6
9263 if test $ac_cv_lib_m_atanhf = yes; then
9264
9265 cat >>confdefs.h <<\_ACEOF
9266 #define HAVE_ATANHF 1
9267 _ACEOF
9268
9269 fi
9270
9271 echo "$as_me:$LINENO: checking for atanh in -lm" >&5
9272 echo $ECHO_N "checking for atanh in -lm... $ECHO_C" >&6
9273 if test "${ac_cv_lib_m_atanh+set}" = set; then
9274   echo $ECHO_N "(cached) $ECHO_C" >&6
9275 else
9276   ac_check_lib_save_LIBS=$LIBS
9277 LIBS="-lm  $LIBS"
9278 if test x$gcc_no_link = xyes; then
9279   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9280 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9281    { (exit 1); exit 1; }; }
9282 fi
9283 cat >conftest.$ac_ext <<_ACEOF
9284 /* confdefs.h.  */
9285 _ACEOF
9286 cat confdefs.h >>conftest.$ac_ext
9287 cat >>conftest.$ac_ext <<_ACEOF
9288 /* end confdefs.h.  */
9289
9290 /* Override any gcc2 internal prototype to avoid an error.  */
9291 #ifdef __cplusplus
9292 extern "C"
9293 #endif
9294 /* We use char because int might match the return type of a gcc2
9295    builtin and then its argument prototype would still apply.  */
9296 char atanh ();
9297 int
9298 main ()
9299 {
9300 atanh ();
9301   ;
9302   return 0;
9303 }
9304 _ACEOF
9305 rm -f conftest.$ac_objext conftest$ac_exeext
9306 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9307   (eval $ac_link) 2>conftest.er1
9308   ac_status=$?
9309   grep -v '^ *+' conftest.er1 >conftest.err
9310   rm -f conftest.er1
9311   cat conftest.err >&5
9312   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9313   (exit $ac_status); } &&
9314          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9315   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9316   (eval $ac_try) 2>&5
9317   ac_status=$?
9318   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9319   (exit $ac_status); }; } &&
9320          { ac_try='test -s conftest$ac_exeext'
9321   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9322   (eval $ac_try) 2>&5
9323   ac_status=$?
9324   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9325   (exit $ac_status); }; }; then
9326   ac_cv_lib_m_atanh=yes
9327 else
9328   echo "$as_me: failed program was:" >&5
9329 sed 's/^/| /' conftest.$ac_ext >&5
9330
9331 ac_cv_lib_m_atanh=no
9332 fi
9333 rm -f conftest.err conftest.$ac_objext \
9334       conftest$ac_exeext conftest.$ac_ext
9335 LIBS=$ac_check_lib_save_LIBS
9336 fi
9337 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanh" >&5
9338 echo "${ECHO_T}$ac_cv_lib_m_atanh" >&6
9339 if test $ac_cv_lib_m_atanh = yes; then
9340
9341 cat >>confdefs.h <<\_ACEOF
9342 #define HAVE_ATANH 1
9343 _ACEOF
9344
9345 fi
9346
9347 echo "$as_me:$LINENO: checking for atanhl in -lm" >&5
9348 echo $ECHO_N "checking for atanhl in -lm... $ECHO_C" >&6
9349 if test "${ac_cv_lib_m_atanhl+set}" = set; then
9350   echo $ECHO_N "(cached) $ECHO_C" >&6
9351 else
9352   ac_check_lib_save_LIBS=$LIBS
9353 LIBS="-lm  $LIBS"
9354 if test x$gcc_no_link = xyes; then
9355   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9356 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9357    { (exit 1); exit 1; }; }
9358 fi
9359 cat >conftest.$ac_ext <<_ACEOF
9360 /* confdefs.h.  */
9361 _ACEOF
9362 cat confdefs.h >>conftest.$ac_ext
9363 cat >>conftest.$ac_ext <<_ACEOF
9364 /* end confdefs.h.  */
9365
9366 /* Override any gcc2 internal prototype to avoid an error.  */
9367 #ifdef __cplusplus
9368 extern "C"
9369 #endif
9370 /* We use char because int might match the return type of a gcc2
9371    builtin and then its argument prototype would still apply.  */
9372 char atanhl ();
9373 int
9374 main ()
9375 {
9376 atanhl ();
9377   ;
9378   return 0;
9379 }
9380 _ACEOF
9381 rm -f conftest.$ac_objext conftest$ac_exeext
9382 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9383   (eval $ac_link) 2>conftest.er1
9384   ac_status=$?
9385   grep -v '^ *+' conftest.er1 >conftest.err
9386   rm -f conftest.er1
9387   cat conftest.err >&5
9388   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9389   (exit $ac_status); } &&
9390          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9391   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9392   (eval $ac_try) 2>&5
9393   ac_status=$?
9394   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9395   (exit $ac_status); }; } &&
9396          { ac_try='test -s conftest$ac_exeext'
9397   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9398   (eval $ac_try) 2>&5
9399   ac_status=$?
9400   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9401   (exit $ac_status); }; }; then
9402   ac_cv_lib_m_atanhl=yes
9403 else
9404   echo "$as_me: failed program was:" >&5
9405 sed 's/^/| /' conftest.$ac_ext >&5
9406
9407 ac_cv_lib_m_atanhl=no
9408 fi
9409 rm -f conftest.err conftest.$ac_objext \
9410       conftest$ac_exeext conftest.$ac_ext
9411 LIBS=$ac_check_lib_save_LIBS
9412 fi
9413 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanhl" >&5
9414 echo "${ECHO_T}$ac_cv_lib_m_atanhl" >&6
9415 if test $ac_cv_lib_m_atanhl = yes; then
9416
9417 cat >>confdefs.h <<\_ACEOF
9418 #define HAVE_ATANHL 1
9419 _ACEOF
9420
9421 fi
9422
9423 echo "$as_me:$LINENO: checking for cargf in -lm" >&5
9424 echo $ECHO_N "checking for cargf in -lm... $ECHO_C" >&6
9425 if test "${ac_cv_lib_m_cargf+set}" = set; then
9426   echo $ECHO_N "(cached) $ECHO_C" >&6
9427 else
9428   ac_check_lib_save_LIBS=$LIBS
9429 LIBS="-lm  $LIBS"
9430 if test x$gcc_no_link = xyes; then
9431   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9432 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9433    { (exit 1); exit 1; }; }
9434 fi
9435 cat >conftest.$ac_ext <<_ACEOF
9436 /* confdefs.h.  */
9437 _ACEOF
9438 cat confdefs.h >>conftest.$ac_ext
9439 cat >>conftest.$ac_ext <<_ACEOF
9440 /* end confdefs.h.  */
9441
9442 /* Override any gcc2 internal prototype to avoid an error.  */
9443 #ifdef __cplusplus
9444 extern "C"
9445 #endif
9446 /* We use char because int might match the return type of a gcc2
9447    builtin and then its argument prototype would still apply.  */
9448 char cargf ();
9449 int
9450 main ()
9451 {
9452 cargf ();
9453   ;
9454   return 0;
9455 }
9456 _ACEOF
9457 rm -f conftest.$ac_objext conftest$ac_exeext
9458 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9459   (eval $ac_link) 2>conftest.er1
9460   ac_status=$?
9461   grep -v '^ *+' conftest.er1 >conftest.err
9462   rm -f conftest.er1
9463   cat conftest.err >&5
9464   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9465   (exit $ac_status); } &&
9466          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9467   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9468   (eval $ac_try) 2>&5
9469   ac_status=$?
9470   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9471   (exit $ac_status); }; } &&
9472          { ac_try='test -s conftest$ac_exeext'
9473   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9474   (eval $ac_try) 2>&5
9475   ac_status=$?
9476   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9477   (exit $ac_status); }; }; then
9478   ac_cv_lib_m_cargf=yes
9479 else
9480   echo "$as_me: failed program was:" >&5
9481 sed 's/^/| /' conftest.$ac_ext >&5
9482
9483 ac_cv_lib_m_cargf=no
9484 fi
9485 rm -f conftest.err conftest.$ac_objext \
9486       conftest$ac_exeext conftest.$ac_ext
9487 LIBS=$ac_check_lib_save_LIBS
9488 fi
9489 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cargf" >&5
9490 echo "${ECHO_T}$ac_cv_lib_m_cargf" >&6
9491 if test $ac_cv_lib_m_cargf = yes; then
9492
9493 cat >>confdefs.h <<\_ACEOF
9494 #define HAVE_CARGF 1
9495 _ACEOF
9496
9497 fi
9498
9499 echo "$as_me:$LINENO: checking for carg in -lm" >&5
9500 echo $ECHO_N "checking for carg in -lm... $ECHO_C" >&6
9501 if test "${ac_cv_lib_m_carg+set}" = set; then
9502   echo $ECHO_N "(cached) $ECHO_C" >&6
9503 else
9504   ac_check_lib_save_LIBS=$LIBS
9505 LIBS="-lm  $LIBS"
9506 if test x$gcc_no_link = xyes; then
9507   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9508 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9509    { (exit 1); exit 1; }; }
9510 fi
9511 cat >conftest.$ac_ext <<_ACEOF
9512 /* confdefs.h.  */
9513 _ACEOF
9514 cat confdefs.h >>conftest.$ac_ext
9515 cat >>conftest.$ac_ext <<_ACEOF
9516 /* end confdefs.h.  */
9517
9518 /* Override any gcc2 internal prototype to avoid an error.  */
9519 #ifdef __cplusplus
9520 extern "C"
9521 #endif
9522 /* We use char because int might match the return type of a gcc2
9523    builtin and then its argument prototype would still apply.  */
9524 char carg ();
9525 int
9526 main ()
9527 {
9528 carg ();
9529   ;
9530   return 0;
9531 }
9532 _ACEOF
9533 rm -f conftest.$ac_objext conftest$ac_exeext
9534 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9535   (eval $ac_link) 2>conftest.er1
9536   ac_status=$?
9537   grep -v '^ *+' conftest.er1 >conftest.err
9538   rm -f conftest.er1
9539   cat conftest.err >&5
9540   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9541   (exit $ac_status); } &&
9542          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9543   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9544   (eval $ac_try) 2>&5
9545   ac_status=$?
9546   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9547   (exit $ac_status); }; } &&
9548          { ac_try='test -s conftest$ac_exeext'
9549   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9550   (eval $ac_try) 2>&5
9551   ac_status=$?
9552   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9553   (exit $ac_status); }; }; then
9554   ac_cv_lib_m_carg=yes
9555 else
9556   echo "$as_me: failed program was:" >&5
9557 sed 's/^/| /' conftest.$ac_ext >&5
9558
9559 ac_cv_lib_m_carg=no
9560 fi
9561 rm -f conftest.err conftest.$ac_objext \
9562       conftest$ac_exeext conftest.$ac_ext
9563 LIBS=$ac_check_lib_save_LIBS
9564 fi
9565 echo "$as_me:$LINENO: result: $ac_cv_lib_m_carg" >&5
9566 echo "${ECHO_T}$ac_cv_lib_m_carg" >&6
9567 if test $ac_cv_lib_m_carg = yes; then
9568
9569 cat >>confdefs.h <<\_ACEOF
9570 #define HAVE_CARG 1
9571 _ACEOF
9572
9573 fi
9574
9575 echo "$as_me:$LINENO: checking for cargl in -lm" >&5
9576 echo $ECHO_N "checking for cargl in -lm... $ECHO_C" >&6
9577 if test "${ac_cv_lib_m_cargl+set}" = set; then
9578   echo $ECHO_N "(cached) $ECHO_C" >&6
9579 else
9580   ac_check_lib_save_LIBS=$LIBS
9581 LIBS="-lm  $LIBS"
9582 if test x$gcc_no_link = xyes; then
9583   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9584 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9585    { (exit 1); exit 1; }; }
9586 fi
9587 cat >conftest.$ac_ext <<_ACEOF
9588 /* confdefs.h.  */
9589 _ACEOF
9590 cat confdefs.h >>conftest.$ac_ext
9591 cat >>conftest.$ac_ext <<_ACEOF
9592 /* end confdefs.h.  */
9593
9594 /* Override any gcc2 internal prototype to avoid an error.  */
9595 #ifdef __cplusplus
9596 extern "C"
9597 #endif
9598 /* We use char because int might match the return type of a gcc2
9599    builtin and then its argument prototype would still apply.  */
9600 char cargl ();
9601 int
9602 main ()
9603 {
9604 cargl ();
9605   ;
9606   return 0;
9607 }
9608 _ACEOF
9609 rm -f conftest.$ac_objext conftest$ac_exeext
9610 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9611   (eval $ac_link) 2>conftest.er1
9612   ac_status=$?
9613   grep -v '^ *+' conftest.er1 >conftest.err
9614   rm -f conftest.er1
9615   cat conftest.err >&5
9616   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9617   (exit $ac_status); } &&
9618          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9619   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9620   (eval $ac_try) 2>&5
9621   ac_status=$?
9622   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9623   (exit $ac_status); }; } &&
9624          { ac_try='test -s conftest$ac_exeext'
9625   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9626   (eval $ac_try) 2>&5
9627   ac_status=$?
9628   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9629   (exit $ac_status); }; }; then
9630   ac_cv_lib_m_cargl=yes
9631 else
9632   echo "$as_me: failed program was:" >&5
9633 sed 's/^/| /' conftest.$ac_ext >&5
9634
9635 ac_cv_lib_m_cargl=no
9636 fi
9637 rm -f conftest.err conftest.$ac_objext \
9638       conftest$ac_exeext conftest.$ac_ext
9639 LIBS=$ac_check_lib_save_LIBS
9640 fi
9641 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cargl" >&5
9642 echo "${ECHO_T}$ac_cv_lib_m_cargl" >&6
9643 if test $ac_cv_lib_m_cargl = yes; then
9644
9645 cat >>confdefs.h <<\_ACEOF
9646 #define HAVE_CARGL 1
9647 _ACEOF
9648
9649 fi
9650
9651 echo "$as_me:$LINENO: checking for ceilf in -lm" >&5
9652 echo $ECHO_N "checking for ceilf in -lm... $ECHO_C" >&6
9653 if test "${ac_cv_lib_m_ceilf+set}" = set; then
9654   echo $ECHO_N "(cached) $ECHO_C" >&6
9655 else
9656   ac_check_lib_save_LIBS=$LIBS
9657 LIBS="-lm  $LIBS"
9658 if test x$gcc_no_link = xyes; then
9659   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9660 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9661    { (exit 1); exit 1; }; }
9662 fi
9663 cat >conftest.$ac_ext <<_ACEOF
9664 /* confdefs.h.  */
9665 _ACEOF
9666 cat confdefs.h >>conftest.$ac_ext
9667 cat >>conftest.$ac_ext <<_ACEOF
9668 /* end confdefs.h.  */
9669
9670 /* Override any gcc2 internal prototype to avoid an error.  */
9671 #ifdef __cplusplus
9672 extern "C"
9673 #endif
9674 /* We use char because int might match the return type of a gcc2
9675    builtin and then its argument prototype would still apply.  */
9676 char ceilf ();
9677 int
9678 main ()
9679 {
9680 ceilf ();
9681   ;
9682   return 0;
9683 }
9684 _ACEOF
9685 rm -f conftest.$ac_objext conftest$ac_exeext
9686 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9687   (eval $ac_link) 2>conftest.er1
9688   ac_status=$?
9689   grep -v '^ *+' conftest.er1 >conftest.err
9690   rm -f conftest.er1
9691   cat conftest.err >&5
9692   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9693   (exit $ac_status); } &&
9694          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9695   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9696   (eval $ac_try) 2>&5
9697   ac_status=$?
9698   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9699   (exit $ac_status); }; } &&
9700          { ac_try='test -s conftest$ac_exeext'
9701   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9702   (eval $ac_try) 2>&5
9703   ac_status=$?
9704   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9705   (exit $ac_status); }; }; then
9706   ac_cv_lib_m_ceilf=yes
9707 else
9708   echo "$as_me: failed program was:" >&5
9709 sed 's/^/| /' conftest.$ac_ext >&5
9710
9711 ac_cv_lib_m_ceilf=no
9712 fi
9713 rm -f conftest.err conftest.$ac_objext \
9714       conftest$ac_exeext conftest.$ac_ext
9715 LIBS=$ac_check_lib_save_LIBS
9716 fi
9717 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceilf" >&5
9718 echo "${ECHO_T}$ac_cv_lib_m_ceilf" >&6
9719 if test $ac_cv_lib_m_ceilf = yes; then
9720
9721 cat >>confdefs.h <<\_ACEOF
9722 #define HAVE_CEILF 1
9723 _ACEOF
9724
9725 fi
9726
9727 echo "$as_me:$LINENO: checking for ceil in -lm" >&5
9728 echo $ECHO_N "checking for ceil in -lm... $ECHO_C" >&6
9729 if test "${ac_cv_lib_m_ceil+set}" = set; then
9730   echo $ECHO_N "(cached) $ECHO_C" >&6
9731 else
9732   ac_check_lib_save_LIBS=$LIBS
9733 LIBS="-lm  $LIBS"
9734 if test x$gcc_no_link = xyes; then
9735   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9736 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9737    { (exit 1); exit 1; }; }
9738 fi
9739 cat >conftest.$ac_ext <<_ACEOF
9740 /* confdefs.h.  */
9741 _ACEOF
9742 cat confdefs.h >>conftest.$ac_ext
9743 cat >>conftest.$ac_ext <<_ACEOF
9744 /* end confdefs.h.  */
9745
9746 /* Override any gcc2 internal prototype to avoid an error.  */
9747 #ifdef __cplusplus
9748 extern "C"
9749 #endif
9750 /* We use char because int might match the return type of a gcc2
9751    builtin and then its argument prototype would still apply.  */
9752 char ceil ();
9753 int
9754 main ()
9755 {
9756 ceil ();
9757   ;
9758   return 0;
9759 }
9760 _ACEOF
9761 rm -f conftest.$ac_objext conftest$ac_exeext
9762 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9763   (eval $ac_link) 2>conftest.er1
9764   ac_status=$?
9765   grep -v '^ *+' conftest.er1 >conftest.err
9766   rm -f conftest.er1
9767   cat conftest.err >&5
9768   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9769   (exit $ac_status); } &&
9770          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9771   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9772   (eval $ac_try) 2>&5
9773   ac_status=$?
9774   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9775   (exit $ac_status); }; } &&
9776          { ac_try='test -s conftest$ac_exeext'
9777   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9778   (eval $ac_try) 2>&5
9779   ac_status=$?
9780   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9781   (exit $ac_status); }; }; then
9782   ac_cv_lib_m_ceil=yes
9783 else
9784   echo "$as_me: failed program was:" >&5
9785 sed 's/^/| /' conftest.$ac_ext >&5
9786
9787 ac_cv_lib_m_ceil=no
9788 fi
9789 rm -f conftest.err conftest.$ac_objext \
9790       conftest$ac_exeext conftest.$ac_ext
9791 LIBS=$ac_check_lib_save_LIBS
9792 fi
9793 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceil" >&5
9794 echo "${ECHO_T}$ac_cv_lib_m_ceil" >&6
9795 if test $ac_cv_lib_m_ceil = yes; then
9796
9797 cat >>confdefs.h <<\_ACEOF
9798 #define HAVE_CEIL 1
9799 _ACEOF
9800
9801 fi
9802
9803 echo "$as_me:$LINENO: checking for ceill in -lm" >&5
9804 echo $ECHO_N "checking for ceill in -lm... $ECHO_C" >&6
9805 if test "${ac_cv_lib_m_ceill+set}" = set; then
9806   echo $ECHO_N "(cached) $ECHO_C" >&6
9807 else
9808   ac_check_lib_save_LIBS=$LIBS
9809 LIBS="-lm  $LIBS"
9810 if test x$gcc_no_link = xyes; then
9811   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9812 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9813    { (exit 1); exit 1; }; }
9814 fi
9815 cat >conftest.$ac_ext <<_ACEOF
9816 /* confdefs.h.  */
9817 _ACEOF
9818 cat confdefs.h >>conftest.$ac_ext
9819 cat >>conftest.$ac_ext <<_ACEOF
9820 /* end confdefs.h.  */
9821
9822 /* Override any gcc2 internal prototype to avoid an error.  */
9823 #ifdef __cplusplus
9824 extern "C"
9825 #endif
9826 /* We use char because int might match the return type of a gcc2
9827    builtin and then its argument prototype would still apply.  */
9828 char ceill ();
9829 int
9830 main ()
9831 {
9832 ceill ();
9833   ;
9834   return 0;
9835 }
9836 _ACEOF
9837 rm -f conftest.$ac_objext conftest$ac_exeext
9838 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9839   (eval $ac_link) 2>conftest.er1
9840   ac_status=$?
9841   grep -v '^ *+' conftest.er1 >conftest.err
9842   rm -f conftest.er1
9843   cat conftest.err >&5
9844   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9845   (exit $ac_status); } &&
9846          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9847   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9848   (eval $ac_try) 2>&5
9849   ac_status=$?
9850   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9851   (exit $ac_status); }; } &&
9852          { ac_try='test -s conftest$ac_exeext'
9853   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9854   (eval $ac_try) 2>&5
9855   ac_status=$?
9856   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9857   (exit $ac_status); }; }; then
9858   ac_cv_lib_m_ceill=yes
9859 else
9860   echo "$as_me: failed program was:" >&5
9861 sed 's/^/| /' conftest.$ac_ext >&5
9862
9863 ac_cv_lib_m_ceill=no
9864 fi
9865 rm -f conftest.err conftest.$ac_objext \
9866       conftest$ac_exeext conftest.$ac_ext
9867 LIBS=$ac_check_lib_save_LIBS
9868 fi
9869 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceill" >&5
9870 echo "${ECHO_T}$ac_cv_lib_m_ceill" >&6
9871 if test $ac_cv_lib_m_ceill = yes; then
9872
9873 cat >>confdefs.h <<\_ACEOF
9874 #define HAVE_CEILL 1
9875 _ACEOF
9876
9877 fi
9878
9879 echo "$as_me:$LINENO: checking for copysignf in -lm" >&5
9880 echo $ECHO_N "checking for copysignf in -lm... $ECHO_C" >&6
9881 if test "${ac_cv_lib_m_copysignf+set}" = set; then
9882   echo $ECHO_N "(cached) $ECHO_C" >&6
9883 else
9884   ac_check_lib_save_LIBS=$LIBS
9885 LIBS="-lm  $LIBS"
9886 if test x$gcc_no_link = xyes; then
9887   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9888 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9889    { (exit 1); exit 1; }; }
9890 fi
9891 cat >conftest.$ac_ext <<_ACEOF
9892 /* confdefs.h.  */
9893 _ACEOF
9894 cat confdefs.h >>conftest.$ac_ext
9895 cat >>conftest.$ac_ext <<_ACEOF
9896 /* end confdefs.h.  */
9897
9898 /* Override any gcc2 internal prototype to avoid an error.  */
9899 #ifdef __cplusplus
9900 extern "C"
9901 #endif
9902 /* We use char because int might match the return type of a gcc2
9903    builtin and then its argument prototype would still apply.  */
9904 char copysignf ();
9905 int
9906 main ()
9907 {
9908 copysignf ();
9909   ;
9910   return 0;
9911 }
9912 _ACEOF
9913 rm -f conftest.$ac_objext conftest$ac_exeext
9914 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9915   (eval $ac_link) 2>conftest.er1
9916   ac_status=$?
9917   grep -v '^ *+' conftest.er1 >conftest.err
9918   rm -f conftest.er1
9919   cat conftest.err >&5
9920   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9921   (exit $ac_status); } &&
9922          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9923   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9924   (eval $ac_try) 2>&5
9925   ac_status=$?
9926   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9927   (exit $ac_status); }; } &&
9928          { ac_try='test -s conftest$ac_exeext'
9929   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9930   (eval $ac_try) 2>&5
9931   ac_status=$?
9932   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9933   (exit $ac_status); }; }; then
9934   ac_cv_lib_m_copysignf=yes
9935 else
9936   echo "$as_me: failed program was:" >&5
9937 sed 's/^/| /' conftest.$ac_ext >&5
9938
9939 ac_cv_lib_m_copysignf=no
9940 fi
9941 rm -f conftest.err conftest.$ac_objext \
9942       conftest$ac_exeext conftest.$ac_ext
9943 LIBS=$ac_check_lib_save_LIBS
9944 fi
9945 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysignf" >&5
9946 echo "${ECHO_T}$ac_cv_lib_m_copysignf" >&6
9947 if test $ac_cv_lib_m_copysignf = yes; then
9948
9949 cat >>confdefs.h <<\_ACEOF
9950 #define HAVE_COPYSIGNF 1
9951 _ACEOF
9952
9953 fi
9954
9955 echo "$as_me:$LINENO: checking for copysign in -lm" >&5
9956 echo $ECHO_N "checking for copysign in -lm... $ECHO_C" >&6
9957 if test "${ac_cv_lib_m_copysign+set}" = set; then
9958   echo $ECHO_N "(cached) $ECHO_C" >&6
9959 else
9960   ac_check_lib_save_LIBS=$LIBS
9961 LIBS="-lm  $LIBS"
9962 if test x$gcc_no_link = xyes; then
9963   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9964 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9965    { (exit 1); exit 1; }; }
9966 fi
9967 cat >conftest.$ac_ext <<_ACEOF
9968 /* confdefs.h.  */
9969 _ACEOF
9970 cat confdefs.h >>conftest.$ac_ext
9971 cat >>conftest.$ac_ext <<_ACEOF
9972 /* end confdefs.h.  */
9973
9974 /* Override any gcc2 internal prototype to avoid an error.  */
9975 #ifdef __cplusplus
9976 extern "C"
9977 #endif
9978 /* We use char because int might match the return type of a gcc2
9979    builtin and then its argument prototype would still apply.  */
9980 char copysign ();
9981 int
9982 main ()
9983 {
9984 copysign ();
9985   ;
9986   return 0;
9987 }
9988 _ACEOF
9989 rm -f conftest.$ac_objext conftest$ac_exeext
9990 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9991   (eval $ac_link) 2>conftest.er1
9992   ac_status=$?
9993   grep -v '^ *+' conftest.er1 >conftest.err
9994   rm -f conftest.er1
9995   cat conftest.err >&5
9996   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9997   (exit $ac_status); } &&
9998          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9999   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10000   (eval $ac_try) 2>&5
10001   ac_status=$?
10002   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10003   (exit $ac_status); }; } &&
10004          { ac_try='test -s conftest$ac_exeext'
10005   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10006   (eval $ac_try) 2>&5
10007   ac_status=$?
10008   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10009   (exit $ac_status); }; }; then
10010   ac_cv_lib_m_copysign=yes
10011 else
10012   echo "$as_me: failed program was:" >&5
10013 sed 's/^/| /' conftest.$ac_ext >&5
10014
10015 ac_cv_lib_m_copysign=no
10016 fi
10017 rm -f conftest.err conftest.$ac_objext \
10018       conftest$ac_exeext conftest.$ac_ext
10019 LIBS=$ac_check_lib_save_LIBS
10020 fi
10021 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysign" >&5
10022 echo "${ECHO_T}$ac_cv_lib_m_copysign" >&6
10023 if test $ac_cv_lib_m_copysign = yes; then
10024
10025 cat >>confdefs.h <<\_ACEOF
10026 #define HAVE_COPYSIGN 1
10027 _ACEOF
10028
10029 fi
10030
10031 echo "$as_me:$LINENO: checking for copysignl in -lm" >&5
10032 echo $ECHO_N "checking for copysignl in -lm... $ECHO_C" >&6
10033 if test "${ac_cv_lib_m_copysignl+set}" = set; then
10034   echo $ECHO_N "(cached) $ECHO_C" >&6
10035 else
10036   ac_check_lib_save_LIBS=$LIBS
10037 LIBS="-lm  $LIBS"
10038 if test x$gcc_no_link = xyes; then
10039   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10040 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10041    { (exit 1); exit 1; }; }
10042 fi
10043 cat >conftest.$ac_ext <<_ACEOF
10044 /* confdefs.h.  */
10045 _ACEOF
10046 cat confdefs.h >>conftest.$ac_ext
10047 cat >>conftest.$ac_ext <<_ACEOF
10048 /* end confdefs.h.  */
10049
10050 /* Override any gcc2 internal prototype to avoid an error.  */
10051 #ifdef __cplusplus
10052 extern "C"
10053 #endif
10054 /* We use char because int might match the return type of a gcc2
10055    builtin and then its argument prototype would still apply.  */
10056 char copysignl ();
10057 int
10058 main ()
10059 {
10060 copysignl ();
10061   ;
10062   return 0;
10063 }
10064 _ACEOF
10065 rm -f conftest.$ac_objext conftest$ac_exeext
10066 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10067   (eval $ac_link) 2>conftest.er1
10068   ac_status=$?
10069   grep -v '^ *+' conftest.er1 >conftest.err
10070   rm -f conftest.er1
10071   cat conftest.err >&5
10072   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10073   (exit $ac_status); } &&
10074          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
10075   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10076   (eval $ac_try) 2>&5
10077   ac_status=$?
10078   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10079   (exit $ac_status); }; } &&
10080          { ac_try='test -s conftest$ac_exeext'
10081   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10082   (eval $ac_try) 2>&5
10083   ac_status=$?
10084   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10085   (exit $ac_status); }; }; then
10086   ac_cv_lib_m_copysignl=yes
10087 else
10088   echo "$as_me: failed program was:" >&5
10089 sed 's/^/| /' conftest.$ac_ext >&5
10090
10091 ac_cv_lib_m_copysignl=no
10092 fi
10093 rm -f conftest.err conftest.$ac_objext \
10094       conftest$ac_exeext conftest.$ac_ext
10095 LIBS=$ac_check_lib_save_LIBS
10096 fi
10097 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysignl" >&5
10098 echo "${ECHO_T}$ac_cv_lib_m_copysignl" >&6
10099 if test $ac_cv_lib_m_copysignl = yes; then
10100
10101 cat >>confdefs.h <<\_ACEOF
10102 #define HAVE_COPYSIGNL 1
10103 _ACEOF
10104
10105 fi
10106
10107 echo "$as_me:$LINENO: checking for cosf in -lm" >&5
10108 echo $ECHO_N "checking for cosf in -lm... $ECHO_C" >&6
10109 if test "${ac_cv_lib_m_cosf+set}" = set; then
10110   echo $ECHO_N "(cached) $ECHO_C" >&6
10111 else
10112   ac_check_lib_save_LIBS=$LIBS
10113 LIBS="-lm  $LIBS"
10114 if test x$gcc_no_link = xyes; then
10115   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10116 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10117    { (exit 1); exit 1; }; }
10118 fi
10119 cat >conftest.$ac_ext <<_ACEOF
10120 /* confdefs.h.  */
10121 _ACEOF
10122 cat confdefs.h >>conftest.$ac_ext
10123 cat >>conftest.$ac_ext <<_ACEOF
10124 /* end confdefs.h.  */
10125
10126 /* Override any gcc2 internal prototype to avoid an error.  */
10127 #ifdef __cplusplus
10128 extern "C"
10129 #endif
10130 /* We use char because int might match the return type of a gcc2
10131    builtin and then its argument prototype would still apply.  */
10132 char cosf ();
10133 int
10134 main ()
10135 {
10136 cosf ();
10137   ;
10138   return 0;
10139 }
10140 _ACEOF
10141 rm -f conftest.$ac_objext conftest$ac_exeext
10142 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10143   (eval $ac_link) 2>conftest.er1
10144   ac_status=$?
10145   grep -v '^ *+' conftest.er1 >conftest.err
10146   rm -f conftest.er1
10147   cat conftest.err >&5
10148   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10149   (exit $ac_status); } &&
10150          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
10151   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10152   (eval $ac_try) 2>&5
10153   ac_status=$?
10154   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10155   (exit $ac_status); }; } &&
10156          { ac_try='test -s conftest$ac_exeext'
10157   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10158   (eval $ac_try) 2>&5
10159   ac_status=$?
10160   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10161   (exit $ac_status); }; }; then
10162   ac_cv_lib_m_cosf=yes
10163 else
10164   echo "$as_me: failed program was:" >&5
10165 sed 's/^/| /' conftest.$ac_ext >&5
10166
10167 ac_cv_lib_m_cosf=no
10168 fi
10169 rm -f conftest.err conftest.$ac_objext \
10170       conftest$ac_exeext conftest.$ac_ext
10171 LIBS=$ac_check_lib_save_LIBS
10172 fi
10173 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosf" >&5
10174 echo "${ECHO_T}$ac_cv_lib_m_cosf" >&6
10175 if test $ac_cv_lib_m_cosf = yes; then
10176
10177 cat >>confdefs.h <<\_ACEOF
10178 #define HAVE_COSF 1
10179 _ACEOF
10180
10181 fi
10182
10183 echo "$as_me:$LINENO: checking for cos in -lm" >&5
10184 echo $ECHO_N "checking for cos in -lm... $ECHO_C" >&6
10185 if test "${ac_cv_lib_m_cos+set}" = set; then
10186   echo $ECHO_N "(cached) $ECHO_C" >&6
10187 else
10188   ac_check_lib_save_LIBS=$LIBS
10189 LIBS="-lm  $LIBS"
10190 if test x$gcc_no_link = xyes; then
10191   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10192 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10193    { (exit 1); exit 1; }; }
10194 fi
10195 cat >conftest.$ac_ext <<_ACEOF
10196 /* confdefs.h.  */
10197 _ACEOF
10198 cat confdefs.h >>conftest.$ac_ext
10199 cat >>conftest.$ac_ext <<_ACEOF
10200 /* end confdefs.h.  */
10201
10202 /* Override any gcc2 internal prototype to avoid an error.  */
10203 #ifdef __cplusplus
10204 extern "C"
10205 #endif
10206 /* We use char because int might match the return type of a gcc2
10207    builtin and then its argument prototype would still apply.  */
10208 char cos ();
10209 int
10210 main ()
10211 {
10212 cos ();
10213   ;
10214   return 0;
10215 }
10216 _ACEOF
10217 rm -f conftest.$ac_objext conftest$ac_exeext
10218 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10219   (eval $ac_link) 2>conftest.er1
10220   ac_status=$?
10221   grep -v '^ *+' conftest.er1 >conftest.err
10222   rm -f conftest.er1
10223   cat conftest.err >&5
10224   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10225   (exit $ac_status); } &&
10226          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
10227   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10228   (eval $ac_try) 2>&5
10229   ac_status=$?
10230   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10231   (exit $ac_status); }; } &&
10232          { ac_try='test -s conftest$ac_exeext'
10233   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10234   (eval $ac_try) 2>&5
10235   ac_status=$?
10236   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10237   (exit $ac_status); }; }; then
10238   ac_cv_lib_m_cos=yes
10239 else
10240   echo "$as_me: failed program was:" >&5
10241 sed 's/^/| /' conftest.$ac_ext >&5
10242
10243 ac_cv_lib_m_cos=no
10244 fi
10245 rm -f conftest.err conftest.$ac_objext \
10246       conftest$ac_exeext conftest.$ac_ext
10247 LIBS=$ac_check_lib_save_LIBS
10248 fi
10249 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cos" >&5
10250 echo "${ECHO_T}$ac_cv_lib_m_cos" >&6
10251 if test $ac_cv_lib_m_cos = yes; then
10252
10253 cat >>confdefs.h <<\_ACEOF
10254 #define HAVE_COS 1
10255 _ACEOF
10256
10257 fi
10258
10259 echo "$as_me:$LINENO: checking for cosl in -lm" >&5
10260 echo $ECHO_N "checking for cosl in -lm... $ECHO_C" >&6
10261 if test "${ac_cv_lib_m_cosl+set}" = set; then
10262   echo $ECHO_N "(cached) $ECHO_C" >&6
10263 else
10264   ac_check_lib_save_LIBS=$LIBS
10265 LIBS="-lm  $LIBS"
10266 if test x$gcc_no_link = xyes; then
10267   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10268 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10269    { (exit 1); exit 1; }; }
10270 fi
10271 cat >conftest.$ac_ext <<_ACEOF
10272 /* confdefs.h.  */
10273 _ACEOF
10274 cat confdefs.h >>conftest.$ac_ext
10275 cat >>conftest.$ac_ext <<_ACEOF
10276 /* end confdefs.h.  */
10277
10278 /* Override any gcc2 internal prototype to avoid an error.  */
10279 #ifdef __cplusplus
10280 extern "C"
10281 #endif
10282 /* We use char because int might match the return type of a gcc2
10283    builtin and then its argument prototype would still apply.  */
10284 char cosl ();
10285 int
10286 main ()
10287 {
10288 cosl ();
10289   ;
10290   return 0;
10291 }
10292 _ACEOF
10293 rm -f conftest.$ac_objext conftest$ac_exeext
10294 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10295   (eval $ac_link) 2>conftest.er1
10296   ac_status=$?
10297   grep -v '^ *+' conftest.er1 >conftest.err
10298   rm -f conftest.er1
10299   cat conftest.err >&5
10300   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10301   (exit $ac_status); } &&
10302          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
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); }; } &&
10308          { ac_try='test -s conftest$ac_exeext'
10309   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10310   (eval $ac_try) 2>&5
10311   ac_status=$?
10312   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10313   (exit $ac_status); }; }; then
10314   ac_cv_lib_m_cosl=yes
10315 else
10316   echo "$as_me: failed program was:" >&5
10317 sed 's/^/| /' conftest.$ac_ext >&5
10318
10319 ac_cv_lib_m_cosl=no
10320 fi
10321 rm -f conftest.err conftest.$ac_objext \
10322       conftest$ac_exeext conftest.$ac_ext
10323 LIBS=$ac_check_lib_save_LIBS
10324 fi
10325 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosl" >&5
10326 echo "${ECHO_T}$ac_cv_lib_m_cosl" >&6
10327 if test $ac_cv_lib_m_cosl = yes; then
10328
10329 cat >>confdefs.h <<\_ACEOF
10330 #define HAVE_COSL 1
10331 _ACEOF
10332
10333 fi
10334
10335 echo "$as_me:$LINENO: checking for ccosf in -lm" >&5
10336 echo $ECHO_N "checking for ccosf in -lm... $ECHO_C" >&6
10337 if test "${ac_cv_lib_m_ccosf+set}" = set; then
10338   echo $ECHO_N "(cached) $ECHO_C" >&6
10339 else
10340   ac_check_lib_save_LIBS=$LIBS
10341 LIBS="-lm  $LIBS"
10342 if test x$gcc_no_link = xyes; then
10343   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10344 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10345    { (exit 1); exit 1; }; }
10346 fi
10347 cat >conftest.$ac_ext <<_ACEOF
10348 /* confdefs.h.  */
10349 _ACEOF
10350 cat confdefs.h >>conftest.$ac_ext
10351 cat >>conftest.$ac_ext <<_ACEOF
10352 /* end confdefs.h.  */
10353
10354 /* Override any gcc2 internal prototype to avoid an error.  */
10355 #ifdef __cplusplus
10356 extern "C"
10357 #endif
10358 /* We use char because int might match the return type of a gcc2
10359    builtin and then its argument prototype would still apply.  */
10360 char ccosf ();
10361 int
10362 main ()
10363 {
10364 ccosf ();
10365   ;
10366   return 0;
10367 }
10368 _ACEOF
10369 rm -f conftest.$ac_objext conftest$ac_exeext
10370 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10371   (eval $ac_link) 2>conftest.er1
10372   ac_status=$?
10373   grep -v '^ *+' conftest.er1 >conftest.err
10374   rm -f conftest.er1
10375   cat conftest.err >&5
10376   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10377   (exit $ac_status); } &&
10378          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
10379   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10380   (eval $ac_try) 2>&5
10381   ac_status=$?
10382   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10383   (exit $ac_status); }; } &&
10384          { ac_try='test -s conftest$ac_exeext'
10385   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10386   (eval $ac_try) 2>&5
10387   ac_status=$?
10388   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10389   (exit $ac_status); }; }; then
10390   ac_cv_lib_m_ccosf=yes
10391 else
10392   echo "$as_me: failed program was:" >&5
10393 sed 's/^/| /' conftest.$ac_ext >&5
10394
10395 ac_cv_lib_m_ccosf=no
10396 fi
10397 rm -f conftest.err conftest.$ac_objext \
10398       conftest$ac_exeext conftest.$ac_ext
10399 LIBS=$ac_check_lib_save_LIBS
10400 fi
10401 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosf" >&5
10402 echo "${ECHO_T}$ac_cv_lib_m_ccosf" >&6
10403 if test $ac_cv_lib_m_ccosf = yes; then
10404
10405 cat >>confdefs.h <<\_ACEOF
10406 #define HAVE_CCOSF 1
10407 _ACEOF
10408
10409 fi
10410
10411 echo "$as_me:$LINENO: checking for ccos in -lm" >&5
10412 echo $ECHO_N "checking for ccos in -lm... $ECHO_C" >&6
10413 if test "${ac_cv_lib_m_ccos+set}" = set; then
10414   echo $ECHO_N "(cached) $ECHO_C" >&6
10415 else
10416   ac_check_lib_save_LIBS=$LIBS
10417 LIBS="-lm  $LIBS"
10418 if test x$gcc_no_link = xyes; then
10419   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10420 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10421    { (exit 1); exit 1; }; }
10422 fi
10423 cat >conftest.$ac_ext <<_ACEOF
10424 /* confdefs.h.  */
10425 _ACEOF
10426 cat confdefs.h >>conftest.$ac_ext
10427 cat >>conftest.$ac_ext <<_ACEOF
10428 /* end confdefs.h.  */
10429
10430 /* Override any gcc2 internal prototype to avoid an error.  */
10431 #ifdef __cplusplus
10432 extern "C"
10433 #endif
10434 /* We use char because int might match the return type of a gcc2
10435    builtin and then its argument prototype would still apply.  */
10436 char ccos ();
10437 int
10438 main ()
10439 {
10440 ccos ();
10441   ;
10442   return 0;
10443 }
10444 _ACEOF
10445 rm -f conftest.$ac_objext conftest$ac_exeext
10446 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10447   (eval $ac_link) 2>conftest.er1
10448   ac_status=$?
10449   grep -v '^ *+' conftest.er1 >conftest.err
10450   rm -f conftest.er1
10451   cat conftest.err >&5
10452   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10453   (exit $ac_status); } &&
10454          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
10455   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10456   (eval $ac_try) 2>&5
10457   ac_status=$?
10458   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10459   (exit $ac_status); }; } &&
10460          { ac_try='test -s conftest$ac_exeext'
10461   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10462   (eval $ac_try) 2>&5
10463   ac_status=$?
10464   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10465   (exit $ac_status); }; }; then
10466   ac_cv_lib_m_ccos=yes
10467 else
10468   echo "$as_me: failed program was:" >&5
10469 sed 's/^/| /' conftest.$ac_ext >&5
10470
10471 ac_cv_lib_m_ccos=no
10472 fi
10473 rm -f conftest.err conftest.$ac_objext \
10474       conftest$ac_exeext conftest.$ac_ext
10475 LIBS=$ac_check_lib_save_LIBS
10476 fi
10477 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccos" >&5
10478 echo "${ECHO_T}$ac_cv_lib_m_ccos" >&6
10479 if test $ac_cv_lib_m_ccos = yes; then
10480
10481 cat >>confdefs.h <<\_ACEOF
10482 #define HAVE_CCOS 1
10483 _ACEOF
10484
10485 fi
10486
10487 echo "$as_me:$LINENO: checking for ccosl in -lm" >&5
10488 echo $ECHO_N "checking for ccosl in -lm... $ECHO_C" >&6
10489 if test "${ac_cv_lib_m_ccosl+set}" = set; then
10490   echo $ECHO_N "(cached) $ECHO_C" >&6
10491 else
10492   ac_check_lib_save_LIBS=$LIBS
10493 LIBS="-lm  $LIBS"
10494 if test x$gcc_no_link = xyes; then
10495   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10496 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10497    { (exit 1); exit 1; }; }
10498 fi
10499 cat >conftest.$ac_ext <<_ACEOF
10500 /* confdefs.h.  */
10501 _ACEOF
10502 cat confdefs.h >>conftest.$ac_ext
10503 cat >>conftest.$ac_ext <<_ACEOF
10504 /* end confdefs.h.  */
10505
10506 /* Override any gcc2 internal prototype to avoid an error.  */
10507 #ifdef __cplusplus
10508 extern "C"
10509 #endif
10510 /* We use char because int might match the return type of a gcc2
10511    builtin and then its argument prototype would still apply.  */
10512 char ccosl ();
10513 int
10514 main ()
10515 {
10516 ccosl ();
10517   ;
10518   return 0;
10519 }
10520 _ACEOF
10521 rm -f conftest.$ac_objext conftest$ac_exeext
10522 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10523   (eval $ac_link) 2>conftest.er1
10524   ac_status=$?
10525   grep -v '^ *+' conftest.er1 >conftest.err
10526   rm -f conftest.er1
10527   cat conftest.err >&5
10528   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10529   (exit $ac_status); } &&
10530          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
10531   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10532   (eval $ac_try) 2>&5
10533   ac_status=$?
10534   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10535   (exit $ac_status); }; } &&
10536          { ac_try='test -s conftest$ac_exeext'
10537   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10538   (eval $ac_try) 2>&5
10539   ac_status=$?
10540   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10541   (exit $ac_status); }; }; then
10542   ac_cv_lib_m_ccosl=yes
10543 else
10544   echo "$as_me: failed program was:" >&5
10545 sed 's/^/| /' conftest.$ac_ext >&5
10546
10547 ac_cv_lib_m_ccosl=no
10548 fi
10549 rm -f conftest.err conftest.$ac_objext \
10550       conftest$ac_exeext conftest.$ac_ext
10551 LIBS=$ac_check_lib_save_LIBS
10552 fi
10553 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosl" >&5
10554 echo "${ECHO_T}$ac_cv_lib_m_ccosl" >&6
10555 if test $ac_cv_lib_m_ccosl = yes; then
10556
10557 cat >>confdefs.h <<\_ACEOF
10558 #define HAVE_CCOSL 1
10559 _ACEOF
10560
10561 fi
10562
10563 echo "$as_me:$LINENO: checking for coshf in -lm" >&5
10564 echo $ECHO_N "checking for coshf in -lm... $ECHO_C" >&6
10565 if test "${ac_cv_lib_m_coshf+set}" = set; then
10566   echo $ECHO_N "(cached) $ECHO_C" >&6
10567 else
10568   ac_check_lib_save_LIBS=$LIBS
10569 LIBS="-lm  $LIBS"
10570 if test x$gcc_no_link = xyes; then
10571   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10572 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10573    { (exit 1); exit 1; }; }
10574 fi
10575 cat >conftest.$ac_ext <<_ACEOF
10576 /* confdefs.h.  */
10577 _ACEOF
10578 cat confdefs.h >>conftest.$ac_ext
10579 cat >>conftest.$ac_ext <<_ACEOF
10580 /* end confdefs.h.  */
10581
10582 /* Override any gcc2 internal prototype to avoid an error.  */
10583 #ifdef __cplusplus
10584 extern "C"
10585 #endif
10586 /* We use char because int might match the return type of a gcc2
10587    builtin and then its argument prototype would still apply.  */
10588 char coshf ();
10589 int
10590 main ()
10591 {
10592 coshf ();
10593   ;
10594   return 0;
10595 }
10596 _ACEOF
10597 rm -f conftest.$ac_objext conftest$ac_exeext
10598 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10599   (eval $ac_link) 2>conftest.er1
10600   ac_status=$?
10601   grep -v '^ *+' conftest.er1 >conftest.err
10602   rm -f conftest.er1
10603   cat conftest.err >&5
10604   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10605   (exit $ac_status); } &&
10606          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
10607   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10608   (eval $ac_try) 2>&5
10609   ac_status=$?
10610   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10611   (exit $ac_status); }; } &&
10612          { ac_try='test -s conftest$ac_exeext'
10613   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10614   (eval $ac_try) 2>&5
10615   ac_status=$?
10616   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10617   (exit $ac_status); }; }; then
10618   ac_cv_lib_m_coshf=yes
10619 else
10620   echo "$as_me: failed program was:" >&5
10621 sed 's/^/| /' conftest.$ac_ext >&5
10622
10623 ac_cv_lib_m_coshf=no
10624 fi
10625 rm -f conftest.err conftest.$ac_objext \
10626       conftest$ac_exeext conftest.$ac_ext
10627 LIBS=$ac_check_lib_save_LIBS
10628 fi
10629 echo "$as_me:$LINENO: result: $ac_cv_lib_m_coshf" >&5
10630 echo "${ECHO_T}$ac_cv_lib_m_coshf" >&6
10631 if test $ac_cv_lib_m_coshf = yes; then
10632
10633 cat >>confdefs.h <<\_ACEOF
10634 #define HAVE_COSHF 1
10635 _ACEOF
10636
10637 fi
10638
10639 echo "$as_me:$LINENO: checking for cosh in -lm" >&5
10640 echo $ECHO_N "checking for cosh in -lm... $ECHO_C" >&6
10641 if test "${ac_cv_lib_m_cosh+set}" = set; then
10642   echo $ECHO_N "(cached) $ECHO_C" >&6
10643 else
10644   ac_check_lib_save_LIBS=$LIBS
10645 LIBS="-lm  $LIBS"
10646 if test x$gcc_no_link = xyes; then
10647   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10648 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10649    { (exit 1); exit 1; }; }
10650 fi
10651 cat >conftest.$ac_ext <<_ACEOF
10652 /* confdefs.h.  */
10653 _ACEOF
10654 cat confdefs.h >>conftest.$ac_ext
10655 cat >>conftest.$ac_ext <<_ACEOF
10656 /* end confdefs.h.  */
10657
10658 /* Override any gcc2 internal prototype to avoid an error.  */
10659 #ifdef __cplusplus
10660 extern "C"
10661 #endif
10662 /* We use char because int might match the return type of a gcc2
10663    builtin and then its argument prototype would still apply.  */
10664 char cosh ();
10665 int
10666 main ()
10667 {
10668 cosh ();
10669   ;
10670   return 0;
10671 }
10672 _ACEOF
10673 rm -f conftest.$ac_objext conftest$ac_exeext
10674 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10675   (eval $ac_link) 2>conftest.er1
10676   ac_status=$?
10677   grep -v '^ *+' conftest.er1 >conftest.err
10678   rm -f conftest.er1
10679   cat conftest.err >&5
10680   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10681   (exit $ac_status); } &&
10682          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
10683   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10684   (eval $ac_try) 2>&5
10685   ac_status=$?
10686   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10687   (exit $ac_status); }; } &&
10688          { ac_try='test -s conftest$ac_exeext'
10689   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10690   (eval $ac_try) 2>&5
10691   ac_status=$?
10692   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10693   (exit $ac_status); }; }; then
10694   ac_cv_lib_m_cosh=yes
10695 else
10696   echo "$as_me: failed program was:" >&5
10697 sed 's/^/| /' conftest.$ac_ext >&5
10698
10699 ac_cv_lib_m_cosh=no
10700 fi
10701 rm -f conftest.err conftest.$ac_objext \
10702       conftest$ac_exeext conftest.$ac_ext
10703 LIBS=$ac_check_lib_save_LIBS
10704 fi
10705 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosh" >&5
10706 echo "${ECHO_T}$ac_cv_lib_m_cosh" >&6
10707 if test $ac_cv_lib_m_cosh = yes; then
10708
10709 cat >>confdefs.h <<\_ACEOF
10710 #define HAVE_COSH 1
10711 _ACEOF
10712
10713 fi
10714
10715 echo "$as_me:$LINENO: checking for coshl in -lm" >&5
10716 echo $ECHO_N "checking for coshl in -lm... $ECHO_C" >&6
10717 if test "${ac_cv_lib_m_coshl+set}" = set; then
10718   echo $ECHO_N "(cached) $ECHO_C" >&6
10719 else
10720   ac_check_lib_save_LIBS=$LIBS
10721 LIBS="-lm  $LIBS"
10722 if test x$gcc_no_link = xyes; then
10723   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10724 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10725    { (exit 1); exit 1; }; }
10726 fi
10727 cat >conftest.$ac_ext <<_ACEOF
10728 /* confdefs.h.  */
10729 _ACEOF
10730 cat confdefs.h >>conftest.$ac_ext
10731 cat >>conftest.$ac_ext <<_ACEOF
10732 /* end confdefs.h.  */
10733
10734 /* Override any gcc2 internal prototype to avoid an error.  */
10735 #ifdef __cplusplus
10736 extern "C"
10737 #endif
10738 /* We use char because int might match the return type of a gcc2
10739    builtin and then its argument prototype would still apply.  */
10740 char coshl ();
10741 int
10742 main ()
10743 {
10744 coshl ();
10745   ;
10746   return 0;
10747 }
10748 _ACEOF
10749 rm -f conftest.$ac_objext conftest$ac_exeext
10750 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10751   (eval $ac_link) 2>conftest.er1
10752   ac_status=$?
10753   grep -v '^ *+' conftest.er1 >conftest.err
10754   rm -f conftest.er1
10755   cat conftest.err >&5
10756   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10757   (exit $ac_status); } &&
10758          { ac_try='test -z "$ac_c_werror_flag"                   || 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_coshl=yes
10771 else
10772   echo "$as_me: failed program was:" >&5
10773 sed 's/^/| /' conftest.$ac_ext >&5
10774
10775 ac_cv_lib_m_coshl=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_coshl" >&5
10782 echo "${ECHO_T}$ac_cv_lib_m_coshl" >&6
10783 if test $ac_cv_lib_m_coshl = yes; then
10784
10785 cat >>confdefs.h <<\_ACEOF
10786 #define HAVE_COSHL 1
10787 _ACEOF
10788
10789 fi
10790
10791 echo "$as_me:$LINENO: checking for ccoshf in -lm" >&5
10792 echo $ECHO_N "checking for ccoshf in -lm... $ECHO_C" >&6
10793 if test "${ac_cv_lib_m_ccoshf+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 ccoshf ();
10817 int
10818 main ()
10819 {
10820 ccoshf ();
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"                   || test ! -s conftest.err'
10835   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10836   (eval $ac_try) 2>&5
10837   ac_status=$?
10838   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10839   (exit $ac_status); }; } &&
10840          { ac_try='test -s conftest$ac_exeext'
10841   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10842   (eval $ac_try) 2>&5
10843   ac_status=$?
10844   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10845   (exit $ac_status); }; }; then
10846   ac_cv_lib_m_ccoshf=yes
10847 else
10848   echo "$as_me: failed program was:" >&5
10849 sed 's/^/| /' conftest.$ac_ext >&5
10850
10851 ac_cv_lib_m_ccoshf=no
10852 fi
10853 rm -f conftest.err conftest.$ac_objext \
10854       conftest$ac_exeext conftest.$ac_ext
10855 LIBS=$ac_check_lib_save_LIBS
10856 fi
10857 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccoshf" >&5
10858 echo "${ECHO_T}$ac_cv_lib_m_ccoshf" >&6
10859 if test $ac_cv_lib_m_ccoshf = yes; then
10860
10861 cat >>confdefs.h <<\_ACEOF
10862 #define HAVE_CCOSHF 1
10863 _ACEOF
10864
10865 fi
10866
10867 echo "$as_me:$LINENO: checking for ccosh in -lm" >&5
10868 echo $ECHO_N "checking for ccosh in -lm... $ECHO_C" >&6
10869 if test "${ac_cv_lib_m_ccosh+set}" = set; then
10870   echo $ECHO_N "(cached) $ECHO_C" >&6
10871 else
10872   ac_check_lib_save_LIBS=$LIBS
10873 LIBS="-lm  $LIBS"
10874 if test x$gcc_no_link = xyes; then
10875   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10876 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10877    { (exit 1); exit 1; }; }
10878 fi
10879 cat >conftest.$ac_ext <<_ACEOF
10880 /* confdefs.h.  */
10881 _ACEOF
10882 cat confdefs.h >>conftest.$ac_ext
10883 cat >>conftest.$ac_ext <<_ACEOF
10884 /* end confdefs.h.  */
10885
10886 /* Override any gcc2 internal prototype to avoid an error.  */
10887 #ifdef __cplusplus
10888 extern "C"
10889 #endif
10890 /* We use char because int might match the return type of a gcc2
10891    builtin and then its argument prototype would still apply.  */
10892 char ccosh ();
10893 int
10894 main ()
10895 {
10896 ccosh ();
10897   ;
10898   return 0;
10899 }
10900 _ACEOF
10901 rm -f conftest.$ac_objext conftest$ac_exeext
10902 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10903   (eval $ac_link) 2>conftest.er1
10904   ac_status=$?
10905   grep -v '^ *+' conftest.er1 >conftest.err
10906   rm -f conftest.er1
10907   cat conftest.err >&5
10908   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10909   (exit $ac_status); } &&
10910          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
10911   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10912   (eval $ac_try) 2>&5
10913   ac_status=$?
10914   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10915   (exit $ac_status); }; } &&
10916          { ac_try='test -s conftest$ac_exeext'
10917   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10918   (eval $ac_try) 2>&5
10919   ac_status=$?
10920   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10921   (exit $ac_status); }; }; then
10922   ac_cv_lib_m_ccosh=yes
10923 else
10924   echo "$as_me: failed program was:" >&5
10925 sed 's/^/| /' conftest.$ac_ext >&5
10926
10927 ac_cv_lib_m_ccosh=no
10928 fi
10929 rm -f conftest.err conftest.$ac_objext \
10930       conftest$ac_exeext conftest.$ac_ext
10931 LIBS=$ac_check_lib_save_LIBS
10932 fi
10933 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosh" >&5
10934 echo "${ECHO_T}$ac_cv_lib_m_ccosh" >&6
10935 if test $ac_cv_lib_m_ccosh = yes; then
10936
10937 cat >>confdefs.h <<\_ACEOF
10938 #define HAVE_CCOSH 1
10939 _ACEOF
10940
10941 fi
10942
10943 echo "$as_me:$LINENO: checking for ccoshl in -lm" >&5
10944 echo $ECHO_N "checking for ccoshl in -lm... $ECHO_C" >&6
10945 if test "${ac_cv_lib_m_ccoshl+set}" = set; then
10946   echo $ECHO_N "(cached) $ECHO_C" >&6
10947 else
10948   ac_check_lib_save_LIBS=$LIBS
10949 LIBS="-lm  $LIBS"
10950 if test x$gcc_no_link = xyes; then
10951   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10952 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10953    { (exit 1); exit 1; }; }
10954 fi
10955 cat >conftest.$ac_ext <<_ACEOF
10956 /* confdefs.h.  */
10957 _ACEOF
10958 cat confdefs.h >>conftest.$ac_ext
10959 cat >>conftest.$ac_ext <<_ACEOF
10960 /* end confdefs.h.  */
10961
10962 /* Override any gcc2 internal prototype to avoid an error.  */
10963 #ifdef __cplusplus
10964 extern "C"
10965 #endif
10966 /* We use char because int might match the return type of a gcc2
10967    builtin and then its argument prototype would still apply.  */
10968 char ccoshl ();
10969 int
10970 main ()
10971 {
10972 ccoshl ();
10973   ;
10974   return 0;
10975 }
10976 _ACEOF
10977 rm -f conftest.$ac_objext conftest$ac_exeext
10978 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10979   (eval $ac_link) 2>conftest.er1
10980   ac_status=$?
10981   grep -v '^ *+' conftest.er1 >conftest.err
10982   rm -f conftest.er1
10983   cat conftest.err >&5
10984   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10985   (exit $ac_status); } &&
10986          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
10987   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10988   (eval $ac_try) 2>&5
10989   ac_status=$?
10990   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10991   (exit $ac_status); }; } &&
10992          { ac_try='test -s conftest$ac_exeext'
10993   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10994   (eval $ac_try) 2>&5
10995   ac_status=$?
10996   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10997   (exit $ac_status); }; }; then
10998   ac_cv_lib_m_ccoshl=yes
10999 else
11000   echo "$as_me: failed program was:" >&5
11001 sed 's/^/| /' conftest.$ac_ext >&5
11002
11003 ac_cv_lib_m_ccoshl=no
11004 fi
11005 rm -f conftest.err conftest.$ac_objext \
11006       conftest$ac_exeext conftest.$ac_ext
11007 LIBS=$ac_check_lib_save_LIBS
11008 fi
11009 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccoshl" >&5
11010 echo "${ECHO_T}$ac_cv_lib_m_ccoshl" >&6
11011 if test $ac_cv_lib_m_ccoshl = yes; then
11012
11013 cat >>confdefs.h <<\_ACEOF
11014 #define HAVE_CCOSHL 1
11015 _ACEOF
11016
11017 fi
11018
11019 echo "$as_me:$LINENO: checking for expf in -lm" >&5
11020 echo $ECHO_N "checking for expf in -lm... $ECHO_C" >&6
11021 if test "${ac_cv_lib_m_expf+set}" = set; then
11022   echo $ECHO_N "(cached) $ECHO_C" >&6
11023 else
11024   ac_check_lib_save_LIBS=$LIBS
11025 LIBS="-lm  $LIBS"
11026 if test x$gcc_no_link = xyes; then
11027   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11028 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11029    { (exit 1); exit 1; }; }
11030 fi
11031 cat >conftest.$ac_ext <<_ACEOF
11032 /* confdefs.h.  */
11033 _ACEOF
11034 cat confdefs.h >>conftest.$ac_ext
11035 cat >>conftest.$ac_ext <<_ACEOF
11036 /* end confdefs.h.  */
11037
11038 /* Override any gcc2 internal prototype to avoid an error.  */
11039 #ifdef __cplusplus
11040 extern "C"
11041 #endif
11042 /* We use char because int might match the return type of a gcc2
11043    builtin and then its argument prototype would still apply.  */
11044 char expf ();
11045 int
11046 main ()
11047 {
11048 expf ();
11049   ;
11050   return 0;
11051 }
11052 _ACEOF
11053 rm -f conftest.$ac_objext conftest$ac_exeext
11054 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11055   (eval $ac_link) 2>conftest.er1
11056   ac_status=$?
11057   grep -v '^ *+' conftest.er1 >conftest.err
11058   rm -f conftest.er1
11059   cat conftest.err >&5
11060   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11061   (exit $ac_status); } &&
11062          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11063   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11064   (eval $ac_try) 2>&5
11065   ac_status=$?
11066   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11067   (exit $ac_status); }; } &&
11068          { ac_try='test -s conftest$ac_exeext'
11069   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11070   (eval $ac_try) 2>&5
11071   ac_status=$?
11072   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11073   (exit $ac_status); }; }; then
11074   ac_cv_lib_m_expf=yes
11075 else
11076   echo "$as_me: failed program was:" >&5
11077 sed 's/^/| /' conftest.$ac_ext >&5
11078
11079 ac_cv_lib_m_expf=no
11080 fi
11081 rm -f conftest.err conftest.$ac_objext \
11082       conftest$ac_exeext conftest.$ac_ext
11083 LIBS=$ac_check_lib_save_LIBS
11084 fi
11085 echo "$as_me:$LINENO: result: $ac_cv_lib_m_expf" >&5
11086 echo "${ECHO_T}$ac_cv_lib_m_expf" >&6
11087 if test $ac_cv_lib_m_expf = yes; then
11088
11089 cat >>confdefs.h <<\_ACEOF
11090 #define HAVE_EXPF 1
11091 _ACEOF
11092
11093 fi
11094
11095 echo "$as_me:$LINENO: checking for exp in -lm" >&5
11096 echo $ECHO_N "checking for exp in -lm... $ECHO_C" >&6
11097 if test "${ac_cv_lib_m_exp+set}" = set; then
11098   echo $ECHO_N "(cached) $ECHO_C" >&6
11099 else
11100   ac_check_lib_save_LIBS=$LIBS
11101 LIBS="-lm  $LIBS"
11102 if test x$gcc_no_link = xyes; then
11103   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11104 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11105    { (exit 1); exit 1; }; }
11106 fi
11107 cat >conftest.$ac_ext <<_ACEOF
11108 /* confdefs.h.  */
11109 _ACEOF
11110 cat confdefs.h >>conftest.$ac_ext
11111 cat >>conftest.$ac_ext <<_ACEOF
11112 /* end confdefs.h.  */
11113
11114 /* Override any gcc2 internal prototype to avoid an error.  */
11115 #ifdef __cplusplus
11116 extern "C"
11117 #endif
11118 /* We use char because int might match the return type of a gcc2
11119    builtin and then its argument prototype would still apply.  */
11120 char exp ();
11121 int
11122 main ()
11123 {
11124 exp ();
11125   ;
11126   return 0;
11127 }
11128 _ACEOF
11129 rm -f conftest.$ac_objext conftest$ac_exeext
11130 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11131   (eval $ac_link) 2>conftest.er1
11132   ac_status=$?
11133   grep -v '^ *+' conftest.er1 >conftest.err
11134   rm -f conftest.er1
11135   cat conftest.err >&5
11136   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11137   (exit $ac_status); } &&
11138          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11139   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11140   (eval $ac_try) 2>&5
11141   ac_status=$?
11142   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11143   (exit $ac_status); }; } &&
11144          { ac_try='test -s conftest$ac_exeext'
11145   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11146   (eval $ac_try) 2>&5
11147   ac_status=$?
11148   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11149   (exit $ac_status); }; }; then
11150   ac_cv_lib_m_exp=yes
11151 else
11152   echo "$as_me: failed program was:" >&5
11153 sed 's/^/| /' conftest.$ac_ext >&5
11154
11155 ac_cv_lib_m_exp=no
11156 fi
11157 rm -f conftest.err conftest.$ac_objext \
11158       conftest$ac_exeext conftest.$ac_ext
11159 LIBS=$ac_check_lib_save_LIBS
11160 fi
11161 echo "$as_me:$LINENO: result: $ac_cv_lib_m_exp" >&5
11162 echo "${ECHO_T}$ac_cv_lib_m_exp" >&6
11163 if test $ac_cv_lib_m_exp = yes; then
11164
11165 cat >>confdefs.h <<\_ACEOF
11166 #define HAVE_EXP 1
11167 _ACEOF
11168
11169 fi
11170
11171 echo "$as_me:$LINENO: checking for expl in -lm" >&5
11172 echo $ECHO_N "checking for expl in -lm... $ECHO_C" >&6
11173 if test "${ac_cv_lib_m_expl+set}" = set; then
11174   echo $ECHO_N "(cached) $ECHO_C" >&6
11175 else
11176   ac_check_lib_save_LIBS=$LIBS
11177 LIBS="-lm  $LIBS"
11178 if test x$gcc_no_link = xyes; then
11179   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11180 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11181    { (exit 1); exit 1; }; }
11182 fi
11183 cat >conftest.$ac_ext <<_ACEOF
11184 /* confdefs.h.  */
11185 _ACEOF
11186 cat confdefs.h >>conftest.$ac_ext
11187 cat >>conftest.$ac_ext <<_ACEOF
11188 /* end confdefs.h.  */
11189
11190 /* Override any gcc2 internal prototype to avoid an error.  */
11191 #ifdef __cplusplus
11192 extern "C"
11193 #endif
11194 /* We use char because int might match the return type of a gcc2
11195    builtin and then its argument prototype would still apply.  */
11196 char expl ();
11197 int
11198 main ()
11199 {
11200 expl ();
11201   ;
11202   return 0;
11203 }
11204 _ACEOF
11205 rm -f conftest.$ac_objext conftest$ac_exeext
11206 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11207   (eval $ac_link) 2>conftest.er1
11208   ac_status=$?
11209   grep -v '^ *+' conftest.er1 >conftest.err
11210   rm -f conftest.er1
11211   cat conftest.err >&5
11212   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11213   (exit $ac_status); } &&
11214          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11215   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11216   (eval $ac_try) 2>&5
11217   ac_status=$?
11218   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11219   (exit $ac_status); }; } &&
11220          { ac_try='test -s conftest$ac_exeext'
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); }; }; then
11226   ac_cv_lib_m_expl=yes
11227 else
11228   echo "$as_me: failed program was:" >&5
11229 sed 's/^/| /' conftest.$ac_ext >&5
11230
11231 ac_cv_lib_m_expl=no
11232 fi
11233 rm -f conftest.err conftest.$ac_objext \
11234       conftest$ac_exeext conftest.$ac_ext
11235 LIBS=$ac_check_lib_save_LIBS
11236 fi
11237 echo "$as_me:$LINENO: result: $ac_cv_lib_m_expl" >&5
11238 echo "${ECHO_T}$ac_cv_lib_m_expl" >&6
11239 if test $ac_cv_lib_m_expl = yes; then
11240
11241 cat >>confdefs.h <<\_ACEOF
11242 #define HAVE_EXPL 1
11243 _ACEOF
11244
11245 fi
11246
11247 echo "$as_me:$LINENO: checking for cexpf in -lm" >&5
11248 echo $ECHO_N "checking for cexpf in -lm... $ECHO_C" >&6
11249 if test "${ac_cv_lib_m_cexpf+set}" = set; then
11250   echo $ECHO_N "(cached) $ECHO_C" >&6
11251 else
11252   ac_check_lib_save_LIBS=$LIBS
11253 LIBS="-lm  $LIBS"
11254 if test x$gcc_no_link = xyes; then
11255   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11256 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11257    { (exit 1); exit 1; }; }
11258 fi
11259 cat >conftest.$ac_ext <<_ACEOF
11260 /* confdefs.h.  */
11261 _ACEOF
11262 cat confdefs.h >>conftest.$ac_ext
11263 cat >>conftest.$ac_ext <<_ACEOF
11264 /* end confdefs.h.  */
11265
11266 /* Override any gcc2 internal prototype to avoid an error.  */
11267 #ifdef __cplusplus
11268 extern "C"
11269 #endif
11270 /* We use char because int might match the return type of a gcc2
11271    builtin and then its argument prototype would still apply.  */
11272 char cexpf ();
11273 int
11274 main ()
11275 {
11276 cexpf ();
11277   ;
11278   return 0;
11279 }
11280 _ACEOF
11281 rm -f conftest.$ac_objext conftest$ac_exeext
11282 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11283   (eval $ac_link) 2>conftest.er1
11284   ac_status=$?
11285   grep -v '^ *+' conftest.er1 >conftest.err
11286   rm -f conftest.er1
11287   cat conftest.err >&5
11288   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11289   (exit $ac_status); } &&
11290          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11291   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11292   (eval $ac_try) 2>&5
11293   ac_status=$?
11294   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11295   (exit $ac_status); }; } &&
11296          { ac_try='test -s conftest$ac_exeext'
11297   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11298   (eval $ac_try) 2>&5
11299   ac_status=$?
11300   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11301   (exit $ac_status); }; }; then
11302   ac_cv_lib_m_cexpf=yes
11303 else
11304   echo "$as_me: failed program was:" >&5
11305 sed 's/^/| /' conftest.$ac_ext >&5
11306
11307 ac_cv_lib_m_cexpf=no
11308 fi
11309 rm -f conftest.err conftest.$ac_objext \
11310       conftest$ac_exeext conftest.$ac_ext
11311 LIBS=$ac_check_lib_save_LIBS
11312 fi
11313 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexpf" >&5
11314 echo "${ECHO_T}$ac_cv_lib_m_cexpf" >&6
11315 if test $ac_cv_lib_m_cexpf = yes; then
11316
11317 cat >>confdefs.h <<\_ACEOF
11318 #define HAVE_CEXPF 1
11319 _ACEOF
11320
11321 fi
11322
11323 echo "$as_me:$LINENO: checking for cexp in -lm" >&5
11324 echo $ECHO_N "checking for cexp in -lm... $ECHO_C" >&6
11325 if test "${ac_cv_lib_m_cexp+set}" = set; then
11326   echo $ECHO_N "(cached) $ECHO_C" >&6
11327 else
11328   ac_check_lib_save_LIBS=$LIBS
11329 LIBS="-lm  $LIBS"
11330 if test x$gcc_no_link = xyes; then
11331   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11332 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11333    { (exit 1); exit 1; }; }
11334 fi
11335 cat >conftest.$ac_ext <<_ACEOF
11336 /* confdefs.h.  */
11337 _ACEOF
11338 cat confdefs.h >>conftest.$ac_ext
11339 cat >>conftest.$ac_ext <<_ACEOF
11340 /* end confdefs.h.  */
11341
11342 /* Override any gcc2 internal prototype to avoid an error.  */
11343 #ifdef __cplusplus
11344 extern "C"
11345 #endif
11346 /* We use char because int might match the return type of a gcc2
11347    builtin and then its argument prototype would still apply.  */
11348 char cexp ();
11349 int
11350 main ()
11351 {
11352 cexp ();
11353   ;
11354   return 0;
11355 }
11356 _ACEOF
11357 rm -f conftest.$ac_objext conftest$ac_exeext
11358 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11359   (eval $ac_link) 2>conftest.er1
11360   ac_status=$?
11361   grep -v '^ *+' conftest.er1 >conftest.err
11362   rm -f conftest.er1
11363   cat conftest.err >&5
11364   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11365   (exit $ac_status); } &&
11366          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11367   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11368   (eval $ac_try) 2>&5
11369   ac_status=$?
11370   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11371   (exit $ac_status); }; } &&
11372          { ac_try='test -s conftest$ac_exeext'
11373   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11374   (eval $ac_try) 2>&5
11375   ac_status=$?
11376   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11377   (exit $ac_status); }; }; then
11378   ac_cv_lib_m_cexp=yes
11379 else
11380   echo "$as_me: failed program was:" >&5
11381 sed 's/^/| /' conftest.$ac_ext >&5
11382
11383 ac_cv_lib_m_cexp=no
11384 fi
11385 rm -f conftest.err conftest.$ac_objext \
11386       conftest$ac_exeext conftest.$ac_ext
11387 LIBS=$ac_check_lib_save_LIBS
11388 fi
11389 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexp" >&5
11390 echo "${ECHO_T}$ac_cv_lib_m_cexp" >&6
11391 if test $ac_cv_lib_m_cexp = yes; then
11392
11393 cat >>confdefs.h <<\_ACEOF
11394 #define HAVE_CEXP 1
11395 _ACEOF
11396
11397 fi
11398
11399 echo "$as_me:$LINENO: checking for cexpl in -lm" >&5
11400 echo $ECHO_N "checking for cexpl in -lm... $ECHO_C" >&6
11401 if test "${ac_cv_lib_m_cexpl+set}" = set; then
11402   echo $ECHO_N "(cached) $ECHO_C" >&6
11403 else
11404   ac_check_lib_save_LIBS=$LIBS
11405 LIBS="-lm  $LIBS"
11406 if test x$gcc_no_link = xyes; then
11407   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11408 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11409    { (exit 1); exit 1; }; }
11410 fi
11411 cat >conftest.$ac_ext <<_ACEOF
11412 /* confdefs.h.  */
11413 _ACEOF
11414 cat confdefs.h >>conftest.$ac_ext
11415 cat >>conftest.$ac_ext <<_ACEOF
11416 /* end confdefs.h.  */
11417
11418 /* Override any gcc2 internal prototype to avoid an error.  */
11419 #ifdef __cplusplus
11420 extern "C"
11421 #endif
11422 /* We use char because int might match the return type of a gcc2
11423    builtin and then its argument prototype would still apply.  */
11424 char cexpl ();
11425 int
11426 main ()
11427 {
11428 cexpl ();
11429   ;
11430   return 0;
11431 }
11432 _ACEOF
11433 rm -f conftest.$ac_objext conftest$ac_exeext
11434 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11435   (eval $ac_link) 2>conftest.er1
11436   ac_status=$?
11437   grep -v '^ *+' conftest.er1 >conftest.err
11438   rm -f conftest.er1
11439   cat conftest.err >&5
11440   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11441   (exit $ac_status); } &&
11442          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11443   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11444   (eval $ac_try) 2>&5
11445   ac_status=$?
11446   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11447   (exit $ac_status); }; } &&
11448          { ac_try='test -s conftest$ac_exeext'
11449   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11450   (eval $ac_try) 2>&5
11451   ac_status=$?
11452   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11453   (exit $ac_status); }; }; then
11454   ac_cv_lib_m_cexpl=yes
11455 else
11456   echo "$as_me: failed program was:" >&5
11457 sed 's/^/| /' conftest.$ac_ext >&5
11458
11459 ac_cv_lib_m_cexpl=no
11460 fi
11461 rm -f conftest.err conftest.$ac_objext \
11462       conftest$ac_exeext conftest.$ac_ext
11463 LIBS=$ac_check_lib_save_LIBS
11464 fi
11465 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexpl" >&5
11466 echo "${ECHO_T}$ac_cv_lib_m_cexpl" >&6
11467 if test $ac_cv_lib_m_cexpl = yes; then
11468
11469 cat >>confdefs.h <<\_ACEOF
11470 #define HAVE_CEXPL 1
11471 _ACEOF
11472
11473 fi
11474
11475 echo "$as_me:$LINENO: checking for fabsf in -lm" >&5
11476 echo $ECHO_N "checking for fabsf in -lm... $ECHO_C" >&6
11477 if test "${ac_cv_lib_m_fabsf+set}" = set; then
11478   echo $ECHO_N "(cached) $ECHO_C" >&6
11479 else
11480   ac_check_lib_save_LIBS=$LIBS
11481 LIBS="-lm  $LIBS"
11482 if test x$gcc_no_link = xyes; then
11483   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11484 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11485    { (exit 1); exit 1; }; }
11486 fi
11487 cat >conftest.$ac_ext <<_ACEOF
11488 /* confdefs.h.  */
11489 _ACEOF
11490 cat confdefs.h >>conftest.$ac_ext
11491 cat >>conftest.$ac_ext <<_ACEOF
11492 /* end confdefs.h.  */
11493
11494 /* Override any gcc2 internal prototype to avoid an error.  */
11495 #ifdef __cplusplus
11496 extern "C"
11497 #endif
11498 /* We use char because int might match the return type of a gcc2
11499    builtin and then its argument prototype would still apply.  */
11500 char fabsf ();
11501 int
11502 main ()
11503 {
11504 fabsf ();
11505   ;
11506   return 0;
11507 }
11508 _ACEOF
11509 rm -f conftest.$ac_objext conftest$ac_exeext
11510 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11511   (eval $ac_link) 2>conftest.er1
11512   ac_status=$?
11513   grep -v '^ *+' conftest.er1 >conftest.err
11514   rm -f conftest.er1
11515   cat conftest.err >&5
11516   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11517   (exit $ac_status); } &&
11518          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11519   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11520   (eval $ac_try) 2>&5
11521   ac_status=$?
11522   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11523   (exit $ac_status); }; } &&
11524          { ac_try='test -s conftest$ac_exeext'
11525   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11526   (eval $ac_try) 2>&5
11527   ac_status=$?
11528   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11529   (exit $ac_status); }; }; then
11530   ac_cv_lib_m_fabsf=yes
11531 else
11532   echo "$as_me: failed program was:" >&5
11533 sed 's/^/| /' conftest.$ac_ext >&5
11534
11535 ac_cv_lib_m_fabsf=no
11536 fi
11537 rm -f conftest.err conftest.$ac_objext \
11538       conftest$ac_exeext conftest.$ac_ext
11539 LIBS=$ac_check_lib_save_LIBS
11540 fi
11541 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabsf" >&5
11542 echo "${ECHO_T}$ac_cv_lib_m_fabsf" >&6
11543 if test $ac_cv_lib_m_fabsf = yes; then
11544
11545 cat >>confdefs.h <<\_ACEOF
11546 #define HAVE_FABSF 1
11547 _ACEOF
11548
11549 fi
11550
11551 echo "$as_me:$LINENO: checking for fabs in -lm" >&5
11552 echo $ECHO_N "checking for fabs in -lm... $ECHO_C" >&6
11553 if test "${ac_cv_lib_m_fabs+set}" = set; then
11554   echo $ECHO_N "(cached) $ECHO_C" >&6
11555 else
11556   ac_check_lib_save_LIBS=$LIBS
11557 LIBS="-lm  $LIBS"
11558 if test x$gcc_no_link = xyes; then
11559   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11560 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11561    { (exit 1); exit 1; }; }
11562 fi
11563 cat >conftest.$ac_ext <<_ACEOF
11564 /* confdefs.h.  */
11565 _ACEOF
11566 cat confdefs.h >>conftest.$ac_ext
11567 cat >>conftest.$ac_ext <<_ACEOF
11568 /* end confdefs.h.  */
11569
11570 /* Override any gcc2 internal prototype to avoid an error.  */
11571 #ifdef __cplusplus
11572 extern "C"
11573 #endif
11574 /* We use char because int might match the return type of a gcc2
11575    builtin and then its argument prototype would still apply.  */
11576 char fabs ();
11577 int
11578 main ()
11579 {
11580 fabs ();
11581   ;
11582   return 0;
11583 }
11584 _ACEOF
11585 rm -f conftest.$ac_objext conftest$ac_exeext
11586 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11587   (eval $ac_link) 2>conftest.er1
11588   ac_status=$?
11589   grep -v '^ *+' conftest.er1 >conftest.err
11590   rm -f conftest.er1
11591   cat conftest.err >&5
11592   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11593   (exit $ac_status); } &&
11594          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11595   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11596   (eval $ac_try) 2>&5
11597   ac_status=$?
11598   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11599   (exit $ac_status); }; } &&
11600          { ac_try='test -s conftest$ac_exeext'
11601   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11602   (eval $ac_try) 2>&5
11603   ac_status=$?
11604   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11605   (exit $ac_status); }; }; then
11606   ac_cv_lib_m_fabs=yes
11607 else
11608   echo "$as_me: failed program was:" >&5
11609 sed 's/^/| /' conftest.$ac_ext >&5
11610
11611 ac_cv_lib_m_fabs=no
11612 fi
11613 rm -f conftest.err conftest.$ac_objext \
11614       conftest$ac_exeext conftest.$ac_ext
11615 LIBS=$ac_check_lib_save_LIBS
11616 fi
11617 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabs" >&5
11618 echo "${ECHO_T}$ac_cv_lib_m_fabs" >&6
11619 if test $ac_cv_lib_m_fabs = yes; then
11620
11621 cat >>confdefs.h <<\_ACEOF
11622 #define HAVE_FABS 1
11623 _ACEOF
11624
11625 fi
11626
11627 echo "$as_me:$LINENO: checking for fabsl in -lm" >&5
11628 echo $ECHO_N "checking for fabsl in -lm... $ECHO_C" >&6
11629 if test "${ac_cv_lib_m_fabsl+set}" = set; then
11630   echo $ECHO_N "(cached) $ECHO_C" >&6
11631 else
11632   ac_check_lib_save_LIBS=$LIBS
11633 LIBS="-lm  $LIBS"
11634 if test x$gcc_no_link = xyes; then
11635   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11636 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11637    { (exit 1); exit 1; }; }
11638 fi
11639 cat >conftest.$ac_ext <<_ACEOF
11640 /* confdefs.h.  */
11641 _ACEOF
11642 cat confdefs.h >>conftest.$ac_ext
11643 cat >>conftest.$ac_ext <<_ACEOF
11644 /* end confdefs.h.  */
11645
11646 /* Override any gcc2 internal prototype to avoid an error.  */
11647 #ifdef __cplusplus
11648 extern "C"
11649 #endif
11650 /* We use char because int might match the return type of a gcc2
11651    builtin and then its argument prototype would still apply.  */
11652 char fabsl ();
11653 int
11654 main ()
11655 {
11656 fabsl ();
11657   ;
11658   return 0;
11659 }
11660 _ACEOF
11661 rm -f conftest.$ac_objext conftest$ac_exeext
11662 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11663   (eval $ac_link) 2>conftest.er1
11664   ac_status=$?
11665   grep -v '^ *+' conftest.er1 >conftest.err
11666   rm -f conftest.er1
11667   cat conftest.err >&5
11668   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11669   (exit $ac_status); } &&
11670          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11671   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11672   (eval $ac_try) 2>&5
11673   ac_status=$?
11674   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11675   (exit $ac_status); }; } &&
11676          { ac_try='test -s conftest$ac_exeext'
11677   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11678   (eval $ac_try) 2>&5
11679   ac_status=$?
11680   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11681   (exit $ac_status); }; }; then
11682   ac_cv_lib_m_fabsl=yes
11683 else
11684   echo "$as_me: failed program was:" >&5
11685 sed 's/^/| /' conftest.$ac_ext >&5
11686
11687 ac_cv_lib_m_fabsl=no
11688 fi
11689 rm -f conftest.err conftest.$ac_objext \
11690       conftest$ac_exeext conftest.$ac_ext
11691 LIBS=$ac_check_lib_save_LIBS
11692 fi
11693 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabsl" >&5
11694 echo "${ECHO_T}$ac_cv_lib_m_fabsl" >&6
11695 if test $ac_cv_lib_m_fabsl = yes; then
11696
11697 cat >>confdefs.h <<\_ACEOF
11698 #define HAVE_FABSL 1
11699 _ACEOF
11700
11701 fi
11702
11703 echo "$as_me:$LINENO: checking for cabsf in -lm" >&5
11704 echo $ECHO_N "checking for cabsf in -lm... $ECHO_C" >&6
11705 if test "${ac_cv_lib_m_cabsf+set}" = set; then
11706   echo $ECHO_N "(cached) $ECHO_C" >&6
11707 else
11708   ac_check_lib_save_LIBS=$LIBS
11709 LIBS="-lm  $LIBS"
11710 if test x$gcc_no_link = xyes; then
11711   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11712 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11713    { (exit 1); exit 1; }; }
11714 fi
11715 cat >conftest.$ac_ext <<_ACEOF
11716 /* confdefs.h.  */
11717 _ACEOF
11718 cat confdefs.h >>conftest.$ac_ext
11719 cat >>conftest.$ac_ext <<_ACEOF
11720 /* end confdefs.h.  */
11721
11722 /* Override any gcc2 internal prototype to avoid an error.  */
11723 #ifdef __cplusplus
11724 extern "C"
11725 #endif
11726 /* We use char because int might match the return type of a gcc2
11727    builtin and then its argument prototype would still apply.  */
11728 char cabsf ();
11729 int
11730 main ()
11731 {
11732 cabsf ();
11733   ;
11734   return 0;
11735 }
11736 _ACEOF
11737 rm -f conftest.$ac_objext conftest$ac_exeext
11738 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11739   (eval $ac_link) 2>conftest.er1
11740   ac_status=$?
11741   grep -v '^ *+' conftest.er1 >conftest.err
11742   rm -f conftest.er1
11743   cat conftest.err >&5
11744   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11745   (exit $ac_status); } &&
11746          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11747   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11748   (eval $ac_try) 2>&5
11749   ac_status=$?
11750   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11751   (exit $ac_status); }; } &&
11752          { ac_try='test -s conftest$ac_exeext'
11753   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11754   (eval $ac_try) 2>&5
11755   ac_status=$?
11756   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11757   (exit $ac_status); }; }; then
11758   ac_cv_lib_m_cabsf=yes
11759 else
11760   echo "$as_me: failed program was:" >&5
11761 sed 's/^/| /' conftest.$ac_ext >&5
11762
11763 ac_cv_lib_m_cabsf=no
11764 fi
11765 rm -f conftest.err conftest.$ac_objext \
11766       conftest$ac_exeext conftest.$ac_ext
11767 LIBS=$ac_check_lib_save_LIBS
11768 fi
11769 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabsf" >&5
11770 echo "${ECHO_T}$ac_cv_lib_m_cabsf" >&6
11771 if test $ac_cv_lib_m_cabsf = yes; then
11772
11773 cat >>confdefs.h <<\_ACEOF
11774 #define HAVE_CABSF 1
11775 _ACEOF
11776
11777 fi
11778
11779 echo "$as_me:$LINENO: checking for cabs in -lm" >&5
11780 echo $ECHO_N "checking for cabs in -lm... $ECHO_C" >&6
11781 if test "${ac_cv_lib_m_cabs+set}" = set; then
11782   echo $ECHO_N "(cached) $ECHO_C" >&6
11783 else
11784   ac_check_lib_save_LIBS=$LIBS
11785 LIBS="-lm  $LIBS"
11786 if test x$gcc_no_link = xyes; then
11787   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11788 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11789    { (exit 1); exit 1; }; }
11790 fi
11791 cat >conftest.$ac_ext <<_ACEOF
11792 /* confdefs.h.  */
11793 _ACEOF
11794 cat confdefs.h >>conftest.$ac_ext
11795 cat >>conftest.$ac_ext <<_ACEOF
11796 /* end confdefs.h.  */
11797
11798 /* Override any gcc2 internal prototype to avoid an error.  */
11799 #ifdef __cplusplus
11800 extern "C"
11801 #endif
11802 /* We use char because int might match the return type of a gcc2
11803    builtin and then its argument prototype would still apply.  */
11804 char cabs ();
11805 int
11806 main ()
11807 {
11808 cabs ();
11809   ;
11810   return 0;
11811 }
11812 _ACEOF
11813 rm -f conftest.$ac_objext conftest$ac_exeext
11814 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11815   (eval $ac_link) 2>conftest.er1
11816   ac_status=$?
11817   grep -v '^ *+' conftest.er1 >conftest.err
11818   rm -f conftest.er1
11819   cat conftest.err >&5
11820   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11821   (exit $ac_status); } &&
11822          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11823   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11824   (eval $ac_try) 2>&5
11825   ac_status=$?
11826   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11827   (exit $ac_status); }; } &&
11828          { ac_try='test -s conftest$ac_exeext'
11829   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11830   (eval $ac_try) 2>&5
11831   ac_status=$?
11832   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11833   (exit $ac_status); }; }; then
11834   ac_cv_lib_m_cabs=yes
11835 else
11836   echo "$as_me: failed program was:" >&5
11837 sed 's/^/| /' conftest.$ac_ext >&5
11838
11839 ac_cv_lib_m_cabs=no
11840 fi
11841 rm -f conftest.err conftest.$ac_objext \
11842       conftest$ac_exeext conftest.$ac_ext
11843 LIBS=$ac_check_lib_save_LIBS
11844 fi
11845 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabs" >&5
11846 echo "${ECHO_T}$ac_cv_lib_m_cabs" >&6
11847 if test $ac_cv_lib_m_cabs = yes; then
11848
11849 cat >>confdefs.h <<\_ACEOF
11850 #define HAVE_CABS 1
11851 _ACEOF
11852
11853 fi
11854
11855 echo "$as_me:$LINENO: checking for cabsl in -lm" >&5
11856 echo $ECHO_N "checking for cabsl in -lm... $ECHO_C" >&6
11857 if test "${ac_cv_lib_m_cabsl+set}" = set; then
11858   echo $ECHO_N "(cached) $ECHO_C" >&6
11859 else
11860   ac_check_lib_save_LIBS=$LIBS
11861 LIBS="-lm  $LIBS"
11862 if test x$gcc_no_link = xyes; then
11863   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11864 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11865    { (exit 1); exit 1; }; }
11866 fi
11867 cat >conftest.$ac_ext <<_ACEOF
11868 /* confdefs.h.  */
11869 _ACEOF
11870 cat confdefs.h >>conftest.$ac_ext
11871 cat >>conftest.$ac_ext <<_ACEOF
11872 /* end confdefs.h.  */
11873
11874 /* Override any gcc2 internal prototype to avoid an error.  */
11875 #ifdef __cplusplus
11876 extern "C"
11877 #endif
11878 /* We use char because int might match the return type of a gcc2
11879    builtin and then its argument prototype would still apply.  */
11880 char cabsl ();
11881 int
11882 main ()
11883 {
11884 cabsl ();
11885   ;
11886   return 0;
11887 }
11888 _ACEOF
11889 rm -f conftest.$ac_objext conftest$ac_exeext
11890 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11891   (eval $ac_link) 2>conftest.er1
11892   ac_status=$?
11893   grep -v '^ *+' conftest.er1 >conftest.err
11894   rm -f conftest.er1
11895   cat conftest.err >&5
11896   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11897   (exit $ac_status); } &&
11898          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11899   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11900   (eval $ac_try) 2>&5
11901   ac_status=$?
11902   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11903   (exit $ac_status); }; } &&
11904          { ac_try='test -s conftest$ac_exeext'
11905   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11906   (eval $ac_try) 2>&5
11907   ac_status=$?
11908   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11909   (exit $ac_status); }; }; then
11910   ac_cv_lib_m_cabsl=yes
11911 else
11912   echo "$as_me: failed program was:" >&5
11913 sed 's/^/| /' conftest.$ac_ext >&5
11914
11915 ac_cv_lib_m_cabsl=no
11916 fi
11917 rm -f conftest.err conftest.$ac_objext \
11918       conftest$ac_exeext conftest.$ac_ext
11919 LIBS=$ac_check_lib_save_LIBS
11920 fi
11921 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabsl" >&5
11922 echo "${ECHO_T}$ac_cv_lib_m_cabsl" >&6
11923 if test $ac_cv_lib_m_cabsl = yes; then
11924
11925 cat >>confdefs.h <<\_ACEOF
11926 #define HAVE_CABSL 1
11927 _ACEOF
11928
11929 fi
11930
11931 echo "$as_me:$LINENO: checking for floorf in -lm" >&5
11932 echo $ECHO_N "checking for floorf in -lm... $ECHO_C" >&6
11933 if test "${ac_cv_lib_m_floorf+set}" = set; then
11934   echo $ECHO_N "(cached) $ECHO_C" >&6
11935 else
11936   ac_check_lib_save_LIBS=$LIBS
11937 LIBS="-lm  $LIBS"
11938 if test x$gcc_no_link = xyes; then
11939   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11940 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11941    { (exit 1); exit 1; }; }
11942 fi
11943 cat >conftest.$ac_ext <<_ACEOF
11944 /* confdefs.h.  */
11945 _ACEOF
11946 cat confdefs.h >>conftest.$ac_ext
11947 cat >>conftest.$ac_ext <<_ACEOF
11948 /* end confdefs.h.  */
11949
11950 /* Override any gcc2 internal prototype to avoid an error.  */
11951 #ifdef __cplusplus
11952 extern "C"
11953 #endif
11954 /* We use char because int might match the return type of a gcc2
11955    builtin and then its argument prototype would still apply.  */
11956 char floorf ();
11957 int
11958 main ()
11959 {
11960 floorf ();
11961   ;
11962   return 0;
11963 }
11964 _ACEOF
11965 rm -f conftest.$ac_objext conftest$ac_exeext
11966 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11967   (eval $ac_link) 2>conftest.er1
11968   ac_status=$?
11969   grep -v '^ *+' conftest.er1 >conftest.err
11970   rm -f conftest.er1
11971   cat conftest.err >&5
11972   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11973   (exit $ac_status); } &&
11974          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11975   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11976   (eval $ac_try) 2>&5
11977   ac_status=$?
11978   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11979   (exit $ac_status); }; } &&
11980          { ac_try='test -s conftest$ac_exeext'
11981   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11982   (eval $ac_try) 2>&5
11983   ac_status=$?
11984   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11985   (exit $ac_status); }; }; then
11986   ac_cv_lib_m_floorf=yes
11987 else
11988   echo "$as_me: failed program was:" >&5
11989 sed 's/^/| /' conftest.$ac_ext >&5
11990
11991 ac_cv_lib_m_floorf=no
11992 fi
11993 rm -f conftest.err conftest.$ac_objext \
11994       conftest$ac_exeext conftest.$ac_ext
11995 LIBS=$ac_check_lib_save_LIBS
11996 fi
11997 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floorf" >&5
11998 echo "${ECHO_T}$ac_cv_lib_m_floorf" >&6
11999 if test $ac_cv_lib_m_floorf = yes; then
12000
12001 cat >>confdefs.h <<\_ACEOF
12002 #define HAVE_FLOORF 1
12003 _ACEOF
12004
12005 fi
12006
12007 echo "$as_me:$LINENO: checking for floor in -lm" >&5
12008 echo $ECHO_N "checking for floor in -lm... $ECHO_C" >&6
12009 if test "${ac_cv_lib_m_floor+set}" = set; then
12010   echo $ECHO_N "(cached) $ECHO_C" >&6
12011 else
12012   ac_check_lib_save_LIBS=$LIBS
12013 LIBS="-lm  $LIBS"
12014 if test x$gcc_no_link = xyes; then
12015   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12016 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12017    { (exit 1); exit 1; }; }
12018 fi
12019 cat >conftest.$ac_ext <<_ACEOF
12020 /* confdefs.h.  */
12021 _ACEOF
12022 cat confdefs.h >>conftest.$ac_ext
12023 cat >>conftest.$ac_ext <<_ACEOF
12024 /* end confdefs.h.  */
12025
12026 /* Override any gcc2 internal prototype to avoid an error.  */
12027 #ifdef __cplusplus
12028 extern "C"
12029 #endif
12030 /* We use char because int might match the return type of a gcc2
12031    builtin and then its argument prototype would still apply.  */
12032 char floor ();
12033 int
12034 main ()
12035 {
12036 floor ();
12037   ;
12038   return 0;
12039 }
12040 _ACEOF
12041 rm -f conftest.$ac_objext conftest$ac_exeext
12042 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12043   (eval $ac_link) 2>conftest.er1
12044   ac_status=$?
12045   grep -v '^ *+' conftest.er1 >conftest.err
12046   rm -f conftest.er1
12047   cat conftest.err >&5
12048   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12049   (exit $ac_status); } &&
12050          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
12051   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12052   (eval $ac_try) 2>&5
12053   ac_status=$?
12054   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12055   (exit $ac_status); }; } &&
12056          { ac_try='test -s conftest$ac_exeext'
12057   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12058   (eval $ac_try) 2>&5
12059   ac_status=$?
12060   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12061   (exit $ac_status); }; }; then
12062   ac_cv_lib_m_floor=yes
12063 else
12064   echo "$as_me: failed program was:" >&5
12065 sed 's/^/| /' conftest.$ac_ext >&5
12066
12067 ac_cv_lib_m_floor=no
12068 fi
12069 rm -f conftest.err conftest.$ac_objext \
12070       conftest$ac_exeext conftest.$ac_ext
12071 LIBS=$ac_check_lib_save_LIBS
12072 fi
12073 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floor" >&5
12074 echo "${ECHO_T}$ac_cv_lib_m_floor" >&6
12075 if test $ac_cv_lib_m_floor = yes; then
12076
12077 cat >>confdefs.h <<\_ACEOF
12078 #define HAVE_FLOOR 1
12079 _ACEOF
12080
12081 fi
12082
12083 echo "$as_me:$LINENO: checking for floorl in -lm" >&5
12084 echo $ECHO_N "checking for floorl in -lm... $ECHO_C" >&6
12085 if test "${ac_cv_lib_m_floorl+set}" = set; then
12086   echo $ECHO_N "(cached) $ECHO_C" >&6
12087 else
12088   ac_check_lib_save_LIBS=$LIBS
12089 LIBS="-lm  $LIBS"
12090 if test x$gcc_no_link = xyes; then
12091   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12092 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12093    { (exit 1); exit 1; }; }
12094 fi
12095 cat >conftest.$ac_ext <<_ACEOF
12096 /* confdefs.h.  */
12097 _ACEOF
12098 cat confdefs.h >>conftest.$ac_ext
12099 cat >>conftest.$ac_ext <<_ACEOF
12100 /* end confdefs.h.  */
12101
12102 /* Override any gcc2 internal prototype to avoid an error.  */
12103 #ifdef __cplusplus
12104 extern "C"
12105 #endif
12106 /* We use char because int might match the return type of a gcc2
12107    builtin and then its argument prototype would still apply.  */
12108 char floorl ();
12109 int
12110 main ()
12111 {
12112 floorl ();
12113   ;
12114   return 0;
12115 }
12116 _ACEOF
12117 rm -f conftest.$ac_objext conftest$ac_exeext
12118 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12119   (eval $ac_link) 2>conftest.er1
12120   ac_status=$?
12121   grep -v '^ *+' conftest.er1 >conftest.err
12122   rm -f conftest.er1
12123   cat conftest.err >&5
12124   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12125   (exit $ac_status); } &&
12126          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
12127   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12128   (eval $ac_try) 2>&5
12129   ac_status=$?
12130   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12131   (exit $ac_status); }; } &&
12132          { ac_try='test -s conftest$ac_exeext'
12133   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12134   (eval $ac_try) 2>&5
12135   ac_status=$?
12136   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12137   (exit $ac_status); }; }; then
12138   ac_cv_lib_m_floorl=yes
12139 else
12140   echo "$as_me: failed program was:" >&5
12141 sed 's/^/| /' conftest.$ac_ext >&5
12142
12143 ac_cv_lib_m_floorl=no
12144 fi
12145 rm -f conftest.err conftest.$ac_objext \
12146       conftest$ac_exeext conftest.$ac_ext
12147 LIBS=$ac_check_lib_save_LIBS
12148 fi
12149 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floorl" >&5
12150 echo "${ECHO_T}$ac_cv_lib_m_floorl" >&6
12151 if test $ac_cv_lib_m_floorl = yes; then
12152
12153 cat >>confdefs.h <<\_ACEOF
12154 #define HAVE_FLOORL 1
12155 _ACEOF
12156
12157 fi
12158
12159 echo "$as_me:$LINENO: checking for frexpf in -lm" >&5
12160 echo $ECHO_N "checking for frexpf in -lm... $ECHO_C" >&6
12161 if test "${ac_cv_lib_m_frexpf+set}" = set; then
12162   echo $ECHO_N "(cached) $ECHO_C" >&6
12163 else
12164   ac_check_lib_save_LIBS=$LIBS
12165 LIBS="-lm  $LIBS"
12166 if test x$gcc_no_link = xyes; then
12167   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12168 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12169    { (exit 1); exit 1; }; }
12170 fi
12171 cat >conftest.$ac_ext <<_ACEOF
12172 /* confdefs.h.  */
12173 _ACEOF
12174 cat confdefs.h >>conftest.$ac_ext
12175 cat >>conftest.$ac_ext <<_ACEOF
12176 /* end confdefs.h.  */
12177
12178 /* Override any gcc2 internal prototype to avoid an error.  */
12179 #ifdef __cplusplus
12180 extern "C"
12181 #endif
12182 /* We use char because int might match the return type of a gcc2
12183    builtin and then its argument prototype would still apply.  */
12184 char frexpf ();
12185 int
12186 main ()
12187 {
12188 frexpf ();
12189   ;
12190   return 0;
12191 }
12192 _ACEOF
12193 rm -f conftest.$ac_objext conftest$ac_exeext
12194 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12195   (eval $ac_link) 2>conftest.er1
12196   ac_status=$?
12197   grep -v '^ *+' conftest.er1 >conftest.err
12198   rm -f conftest.er1
12199   cat conftest.err >&5
12200   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12201   (exit $ac_status); } &&
12202          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
12203   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12204   (eval $ac_try) 2>&5
12205   ac_status=$?
12206   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12207   (exit $ac_status); }; } &&
12208          { ac_try='test -s conftest$ac_exeext'
12209   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12210   (eval $ac_try) 2>&5
12211   ac_status=$?
12212   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12213   (exit $ac_status); }; }; then
12214   ac_cv_lib_m_frexpf=yes
12215 else
12216   echo "$as_me: failed program was:" >&5
12217 sed 's/^/| /' conftest.$ac_ext >&5
12218
12219 ac_cv_lib_m_frexpf=no
12220 fi
12221 rm -f conftest.err conftest.$ac_objext \
12222       conftest$ac_exeext conftest.$ac_ext
12223 LIBS=$ac_check_lib_save_LIBS
12224 fi
12225 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexpf" >&5
12226 echo "${ECHO_T}$ac_cv_lib_m_frexpf" >&6
12227 if test $ac_cv_lib_m_frexpf = yes; then
12228
12229 cat >>confdefs.h <<\_ACEOF
12230 #define HAVE_FREXPF 1
12231 _ACEOF
12232
12233 fi
12234
12235 echo "$as_me:$LINENO: checking for frexp in -lm" >&5
12236 echo $ECHO_N "checking for frexp in -lm... $ECHO_C" >&6
12237 if test "${ac_cv_lib_m_frexp+set}" = set; then
12238   echo $ECHO_N "(cached) $ECHO_C" >&6
12239 else
12240   ac_check_lib_save_LIBS=$LIBS
12241 LIBS="-lm  $LIBS"
12242 if test x$gcc_no_link = xyes; then
12243   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12244 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12245    { (exit 1); exit 1; }; }
12246 fi
12247 cat >conftest.$ac_ext <<_ACEOF
12248 /* confdefs.h.  */
12249 _ACEOF
12250 cat confdefs.h >>conftest.$ac_ext
12251 cat >>conftest.$ac_ext <<_ACEOF
12252 /* end confdefs.h.  */
12253
12254 /* Override any gcc2 internal prototype to avoid an error.  */
12255 #ifdef __cplusplus
12256 extern "C"
12257 #endif
12258 /* We use char because int might match the return type of a gcc2
12259    builtin and then its argument prototype would still apply.  */
12260 char frexp ();
12261 int
12262 main ()
12263 {
12264 frexp ();
12265   ;
12266   return 0;
12267 }
12268 _ACEOF
12269 rm -f conftest.$ac_objext conftest$ac_exeext
12270 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12271   (eval $ac_link) 2>conftest.er1
12272   ac_status=$?
12273   grep -v '^ *+' conftest.er1 >conftest.err
12274   rm -f conftest.er1
12275   cat conftest.err >&5
12276   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12277   (exit $ac_status); } &&
12278          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
12279   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12280   (eval $ac_try) 2>&5
12281   ac_status=$?
12282   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12283   (exit $ac_status); }; } &&
12284          { ac_try='test -s conftest$ac_exeext'
12285   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12286   (eval $ac_try) 2>&5
12287   ac_status=$?
12288   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12289   (exit $ac_status); }; }; then
12290   ac_cv_lib_m_frexp=yes
12291 else
12292   echo "$as_me: failed program was:" >&5
12293 sed 's/^/| /' conftest.$ac_ext >&5
12294
12295 ac_cv_lib_m_frexp=no
12296 fi
12297 rm -f conftest.err conftest.$ac_objext \
12298       conftest$ac_exeext conftest.$ac_ext
12299 LIBS=$ac_check_lib_save_LIBS
12300 fi
12301 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexp" >&5
12302 echo "${ECHO_T}$ac_cv_lib_m_frexp" >&6
12303 if test $ac_cv_lib_m_frexp = yes; then
12304
12305 cat >>confdefs.h <<\_ACEOF
12306 #define HAVE_FREXP 1
12307 _ACEOF
12308
12309 fi
12310
12311 echo "$as_me:$LINENO: checking for frexpl in -lm" >&5
12312 echo $ECHO_N "checking for frexpl in -lm... $ECHO_C" >&6
12313 if test "${ac_cv_lib_m_frexpl+set}" = set; then
12314   echo $ECHO_N "(cached) $ECHO_C" >&6
12315 else
12316   ac_check_lib_save_LIBS=$LIBS
12317 LIBS="-lm  $LIBS"
12318 if test x$gcc_no_link = xyes; then
12319   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12320 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12321    { (exit 1); exit 1; }; }
12322 fi
12323 cat >conftest.$ac_ext <<_ACEOF
12324 /* confdefs.h.  */
12325 _ACEOF
12326 cat confdefs.h >>conftest.$ac_ext
12327 cat >>conftest.$ac_ext <<_ACEOF
12328 /* end confdefs.h.  */
12329
12330 /* Override any gcc2 internal prototype to avoid an error.  */
12331 #ifdef __cplusplus
12332 extern "C"
12333 #endif
12334 /* We use char because int might match the return type of a gcc2
12335    builtin and then its argument prototype would still apply.  */
12336 char frexpl ();
12337 int
12338 main ()
12339 {
12340 frexpl ();
12341   ;
12342   return 0;
12343 }
12344 _ACEOF
12345 rm -f conftest.$ac_objext conftest$ac_exeext
12346 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12347   (eval $ac_link) 2>conftest.er1
12348   ac_status=$?
12349   grep -v '^ *+' conftest.er1 >conftest.err
12350   rm -f conftest.er1
12351   cat conftest.err >&5
12352   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12353   (exit $ac_status); } &&
12354          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
12355   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12356   (eval $ac_try) 2>&5
12357   ac_status=$?
12358   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12359   (exit $ac_status); }; } &&
12360          { ac_try='test -s conftest$ac_exeext'
12361   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12362   (eval $ac_try) 2>&5
12363   ac_status=$?
12364   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12365   (exit $ac_status); }; }; then
12366   ac_cv_lib_m_frexpl=yes
12367 else
12368   echo "$as_me: failed program was:" >&5
12369 sed 's/^/| /' conftest.$ac_ext >&5
12370
12371 ac_cv_lib_m_frexpl=no
12372 fi
12373 rm -f conftest.err conftest.$ac_objext \
12374       conftest$ac_exeext conftest.$ac_ext
12375 LIBS=$ac_check_lib_save_LIBS
12376 fi
12377 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexpl" >&5
12378 echo "${ECHO_T}$ac_cv_lib_m_frexpl" >&6
12379 if test $ac_cv_lib_m_frexpl = yes; then
12380
12381 cat >>confdefs.h <<\_ACEOF
12382 #define HAVE_FREXPL 1
12383 _ACEOF
12384
12385 fi
12386
12387 echo "$as_me:$LINENO: checking for hypotf in -lm" >&5
12388 echo $ECHO_N "checking for hypotf in -lm... $ECHO_C" >&6
12389 if test "${ac_cv_lib_m_hypotf+set}" = set; then
12390   echo $ECHO_N "(cached) $ECHO_C" >&6
12391 else
12392   ac_check_lib_save_LIBS=$LIBS
12393 LIBS="-lm  $LIBS"
12394 if test x$gcc_no_link = xyes; then
12395   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12396 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12397    { (exit 1); exit 1; }; }
12398 fi
12399 cat >conftest.$ac_ext <<_ACEOF
12400 /* confdefs.h.  */
12401 _ACEOF
12402 cat confdefs.h >>conftest.$ac_ext
12403 cat >>conftest.$ac_ext <<_ACEOF
12404 /* end confdefs.h.  */
12405
12406 /* Override any gcc2 internal prototype to avoid an error.  */
12407 #ifdef __cplusplus
12408 extern "C"
12409 #endif
12410 /* We use char because int might match the return type of a gcc2
12411    builtin and then its argument prototype would still apply.  */
12412 char hypotf ();
12413 int
12414 main ()
12415 {
12416 hypotf ();
12417   ;
12418   return 0;
12419 }
12420 _ACEOF
12421 rm -f conftest.$ac_objext conftest$ac_exeext
12422 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12423   (eval $ac_link) 2>conftest.er1
12424   ac_status=$?
12425   grep -v '^ *+' conftest.er1 >conftest.err
12426   rm -f conftest.er1
12427   cat conftest.err >&5
12428   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12429   (exit $ac_status); } &&
12430          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
12431   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12432   (eval $ac_try) 2>&5
12433   ac_status=$?
12434   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12435   (exit $ac_status); }; } &&
12436          { ac_try='test -s conftest$ac_exeext'
12437   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12438   (eval $ac_try) 2>&5
12439   ac_status=$?
12440   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12441   (exit $ac_status); }; }; then
12442   ac_cv_lib_m_hypotf=yes
12443 else
12444   echo "$as_me: failed program was:" >&5
12445 sed 's/^/| /' conftest.$ac_ext >&5
12446
12447 ac_cv_lib_m_hypotf=no
12448 fi
12449 rm -f conftest.err conftest.$ac_objext \
12450       conftest$ac_exeext conftest.$ac_ext
12451 LIBS=$ac_check_lib_save_LIBS
12452 fi
12453 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypotf" >&5
12454 echo "${ECHO_T}$ac_cv_lib_m_hypotf" >&6
12455 if test $ac_cv_lib_m_hypotf = yes; then
12456
12457 cat >>confdefs.h <<\_ACEOF
12458 #define HAVE_HYPOTF 1
12459 _ACEOF
12460
12461 fi
12462
12463 echo "$as_me:$LINENO: checking for hypot in -lm" >&5
12464 echo $ECHO_N "checking for hypot in -lm... $ECHO_C" >&6
12465 if test "${ac_cv_lib_m_hypot+set}" = set; then
12466   echo $ECHO_N "(cached) $ECHO_C" >&6
12467 else
12468   ac_check_lib_save_LIBS=$LIBS
12469 LIBS="-lm  $LIBS"
12470 if test x$gcc_no_link = xyes; then
12471   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12472 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12473    { (exit 1); exit 1; }; }
12474 fi
12475 cat >conftest.$ac_ext <<_ACEOF
12476 /* confdefs.h.  */
12477 _ACEOF
12478 cat confdefs.h >>conftest.$ac_ext
12479 cat >>conftest.$ac_ext <<_ACEOF
12480 /* end confdefs.h.  */
12481
12482 /* Override any gcc2 internal prototype to avoid an error.  */
12483 #ifdef __cplusplus
12484 extern "C"
12485 #endif
12486 /* We use char because int might match the return type of a gcc2
12487    builtin and then its argument prototype would still apply.  */
12488 char hypot ();
12489 int
12490 main ()
12491 {
12492 hypot ();
12493   ;
12494   return 0;
12495 }
12496 _ACEOF
12497 rm -f conftest.$ac_objext conftest$ac_exeext
12498 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12499   (eval $ac_link) 2>conftest.er1
12500   ac_status=$?
12501   grep -v '^ *+' conftest.er1 >conftest.err
12502   rm -f conftest.er1
12503   cat conftest.err >&5
12504   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12505   (exit $ac_status); } &&
12506          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
12507   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12508   (eval $ac_try) 2>&5
12509   ac_status=$?
12510   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12511   (exit $ac_status); }; } &&
12512          { ac_try='test -s conftest$ac_exeext'
12513   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12514   (eval $ac_try) 2>&5
12515   ac_status=$?
12516   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12517   (exit $ac_status); }; }; then
12518   ac_cv_lib_m_hypot=yes
12519 else
12520   echo "$as_me: failed program was:" >&5
12521 sed 's/^/| /' conftest.$ac_ext >&5
12522
12523 ac_cv_lib_m_hypot=no
12524 fi
12525 rm -f conftest.err conftest.$ac_objext \
12526       conftest$ac_exeext conftest.$ac_ext
12527 LIBS=$ac_check_lib_save_LIBS
12528 fi
12529 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypot" >&5
12530 echo "${ECHO_T}$ac_cv_lib_m_hypot" >&6
12531 if test $ac_cv_lib_m_hypot = yes; then
12532
12533 cat >>confdefs.h <<\_ACEOF
12534 #define HAVE_HYPOT 1
12535 _ACEOF
12536
12537 fi
12538
12539 echo "$as_me:$LINENO: checking for hypotl in -lm" >&5
12540 echo $ECHO_N "checking for hypotl in -lm... $ECHO_C" >&6
12541 if test "${ac_cv_lib_m_hypotl+set}" = set; then
12542   echo $ECHO_N "(cached) $ECHO_C" >&6
12543 else
12544   ac_check_lib_save_LIBS=$LIBS
12545 LIBS="-lm  $LIBS"
12546 if test x$gcc_no_link = xyes; then
12547   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12548 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12549    { (exit 1); exit 1; }; }
12550 fi
12551 cat >conftest.$ac_ext <<_ACEOF
12552 /* confdefs.h.  */
12553 _ACEOF
12554 cat confdefs.h >>conftest.$ac_ext
12555 cat >>conftest.$ac_ext <<_ACEOF
12556 /* end confdefs.h.  */
12557
12558 /* Override any gcc2 internal prototype to avoid an error.  */
12559 #ifdef __cplusplus
12560 extern "C"
12561 #endif
12562 /* We use char because int might match the return type of a gcc2
12563    builtin and then its argument prototype would still apply.  */
12564 char hypotl ();
12565 int
12566 main ()
12567 {
12568 hypotl ();
12569   ;
12570   return 0;
12571 }
12572 _ACEOF
12573 rm -f conftest.$ac_objext conftest$ac_exeext
12574 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12575   (eval $ac_link) 2>conftest.er1
12576   ac_status=$?
12577   grep -v '^ *+' conftest.er1 >conftest.err
12578   rm -f conftest.er1
12579   cat conftest.err >&5
12580   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12581   (exit $ac_status); } &&
12582          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
12583   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12584   (eval $ac_try) 2>&5
12585   ac_status=$?
12586   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12587   (exit $ac_status); }; } &&
12588          { ac_try='test -s conftest$ac_exeext'
12589   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12590   (eval $ac_try) 2>&5
12591   ac_status=$?
12592   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12593   (exit $ac_status); }; }; then
12594   ac_cv_lib_m_hypotl=yes
12595 else
12596   echo "$as_me: failed program was:" >&5
12597 sed 's/^/| /' conftest.$ac_ext >&5
12598
12599 ac_cv_lib_m_hypotl=no
12600 fi
12601 rm -f conftest.err conftest.$ac_objext \
12602       conftest$ac_exeext conftest.$ac_ext
12603 LIBS=$ac_check_lib_save_LIBS
12604 fi
12605 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypotl" >&5
12606 echo "${ECHO_T}$ac_cv_lib_m_hypotl" >&6
12607 if test $ac_cv_lib_m_hypotl = yes; then
12608
12609 cat >>confdefs.h <<\_ACEOF
12610 #define HAVE_HYPOTL 1
12611 _ACEOF
12612
12613 fi
12614
12615 echo "$as_me:$LINENO: checking for logf in -lm" >&5
12616 echo $ECHO_N "checking for logf in -lm... $ECHO_C" >&6
12617 if test "${ac_cv_lib_m_logf+set}" = set; then
12618   echo $ECHO_N "(cached) $ECHO_C" >&6
12619 else
12620   ac_check_lib_save_LIBS=$LIBS
12621 LIBS="-lm  $LIBS"
12622 if test x$gcc_no_link = xyes; then
12623   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12624 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12625    { (exit 1); exit 1; }; }
12626 fi
12627 cat >conftest.$ac_ext <<_ACEOF
12628 /* confdefs.h.  */
12629 _ACEOF
12630 cat confdefs.h >>conftest.$ac_ext
12631 cat >>conftest.$ac_ext <<_ACEOF
12632 /* end confdefs.h.  */
12633
12634 /* Override any gcc2 internal prototype to avoid an error.  */
12635 #ifdef __cplusplus
12636 extern "C"
12637 #endif
12638 /* We use char because int might match the return type of a gcc2
12639    builtin and then its argument prototype would still apply.  */
12640 char logf ();
12641 int
12642 main ()
12643 {
12644 logf ();
12645   ;
12646   return 0;
12647 }
12648 _ACEOF
12649 rm -f conftest.$ac_objext conftest$ac_exeext
12650 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12651   (eval $ac_link) 2>conftest.er1
12652   ac_status=$?
12653   grep -v '^ *+' conftest.er1 >conftest.err
12654   rm -f conftest.er1
12655   cat conftest.err >&5
12656   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12657   (exit $ac_status); } &&
12658          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
12659   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12660   (eval $ac_try) 2>&5
12661   ac_status=$?
12662   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12663   (exit $ac_status); }; } &&
12664          { ac_try='test -s conftest$ac_exeext'
12665   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12666   (eval $ac_try) 2>&5
12667   ac_status=$?
12668   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12669   (exit $ac_status); }; }; then
12670   ac_cv_lib_m_logf=yes
12671 else
12672   echo "$as_me: failed program was:" >&5
12673 sed 's/^/| /' conftest.$ac_ext >&5
12674
12675 ac_cv_lib_m_logf=no
12676 fi
12677 rm -f conftest.err conftest.$ac_objext \
12678       conftest$ac_exeext conftest.$ac_ext
12679 LIBS=$ac_check_lib_save_LIBS
12680 fi
12681 echo "$as_me:$LINENO: result: $ac_cv_lib_m_logf" >&5
12682 echo "${ECHO_T}$ac_cv_lib_m_logf" >&6
12683 if test $ac_cv_lib_m_logf = yes; then
12684
12685 cat >>confdefs.h <<\_ACEOF
12686 #define HAVE_LOGF 1
12687 _ACEOF
12688
12689 fi
12690
12691 echo "$as_me:$LINENO: checking for log in -lm" >&5
12692 echo $ECHO_N "checking for log in -lm... $ECHO_C" >&6
12693 if test "${ac_cv_lib_m_log+set}" = set; then
12694   echo $ECHO_N "(cached) $ECHO_C" >&6
12695 else
12696   ac_check_lib_save_LIBS=$LIBS
12697 LIBS="-lm  $LIBS"
12698 if test x$gcc_no_link = xyes; then
12699   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12700 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12701    { (exit 1); exit 1; }; }
12702 fi
12703 cat >conftest.$ac_ext <<_ACEOF
12704 /* confdefs.h.  */
12705 _ACEOF
12706 cat confdefs.h >>conftest.$ac_ext
12707 cat >>conftest.$ac_ext <<_ACEOF
12708 /* end confdefs.h.  */
12709
12710 /* Override any gcc2 internal prototype to avoid an error.  */
12711 #ifdef __cplusplus
12712 extern "C"
12713 #endif
12714 /* We use char because int might match the return type of a gcc2
12715    builtin and then its argument prototype would still apply.  */
12716 char log ();
12717 int
12718 main ()
12719 {
12720 log ();
12721   ;
12722   return 0;
12723 }
12724 _ACEOF
12725 rm -f conftest.$ac_objext conftest$ac_exeext
12726 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12727   (eval $ac_link) 2>conftest.er1
12728   ac_status=$?
12729   grep -v '^ *+' conftest.er1 >conftest.err
12730   rm -f conftest.er1
12731   cat conftest.err >&5
12732   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12733   (exit $ac_status); } &&
12734          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
12735   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12736   (eval $ac_try) 2>&5
12737   ac_status=$?
12738   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12739   (exit $ac_status); }; } &&
12740          { ac_try='test -s conftest$ac_exeext'
12741   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12742   (eval $ac_try) 2>&5
12743   ac_status=$?
12744   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12745   (exit $ac_status); }; }; then
12746   ac_cv_lib_m_log=yes
12747 else
12748   echo "$as_me: failed program was:" >&5
12749 sed 's/^/| /' conftest.$ac_ext >&5
12750
12751 ac_cv_lib_m_log=no
12752 fi
12753 rm -f conftest.err conftest.$ac_objext \
12754       conftest$ac_exeext conftest.$ac_ext
12755 LIBS=$ac_check_lib_save_LIBS
12756 fi
12757 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log" >&5
12758 echo "${ECHO_T}$ac_cv_lib_m_log" >&6
12759 if test $ac_cv_lib_m_log = yes; then
12760
12761 cat >>confdefs.h <<\_ACEOF
12762 #define HAVE_LOG 1
12763 _ACEOF
12764
12765 fi
12766
12767 echo "$as_me:$LINENO: checking for logl in -lm" >&5
12768 echo $ECHO_N "checking for logl in -lm... $ECHO_C" >&6
12769 if test "${ac_cv_lib_m_logl+set}" = set; then
12770   echo $ECHO_N "(cached) $ECHO_C" >&6
12771 else
12772   ac_check_lib_save_LIBS=$LIBS
12773 LIBS="-lm  $LIBS"
12774 if test x$gcc_no_link = xyes; then
12775   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12776 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12777    { (exit 1); exit 1; }; }
12778 fi
12779 cat >conftest.$ac_ext <<_ACEOF
12780 /* confdefs.h.  */
12781 _ACEOF
12782 cat confdefs.h >>conftest.$ac_ext
12783 cat >>conftest.$ac_ext <<_ACEOF
12784 /* end confdefs.h.  */
12785
12786 /* Override any gcc2 internal prototype to avoid an error.  */
12787 #ifdef __cplusplus
12788 extern "C"
12789 #endif
12790 /* We use char because int might match the return type of a gcc2
12791    builtin and then its argument prototype would still apply.  */
12792 char logl ();
12793 int
12794 main ()
12795 {
12796 logl ();
12797   ;
12798   return 0;
12799 }
12800 _ACEOF
12801 rm -f conftest.$ac_objext conftest$ac_exeext
12802 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12803   (eval $ac_link) 2>conftest.er1
12804   ac_status=$?
12805   grep -v '^ *+' conftest.er1 >conftest.err
12806   rm -f conftest.er1
12807   cat conftest.err >&5
12808   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12809   (exit $ac_status); } &&
12810          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
12811   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12812   (eval $ac_try) 2>&5
12813   ac_status=$?
12814   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12815   (exit $ac_status); }; } &&
12816          { ac_try='test -s conftest$ac_exeext'
12817   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12818   (eval $ac_try) 2>&5
12819   ac_status=$?
12820   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12821   (exit $ac_status); }; }; then
12822   ac_cv_lib_m_logl=yes
12823 else
12824   echo "$as_me: failed program was:" >&5
12825 sed 's/^/| /' conftest.$ac_ext >&5
12826
12827 ac_cv_lib_m_logl=no
12828 fi
12829 rm -f conftest.err conftest.$ac_objext \
12830       conftest$ac_exeext conftest.$ac_ext
12831 LIBS=$ac_check_lib_save_LIBS
12832 fi
12833 echo "$as_me:$LINENO: result: $ac_cv_lib_m_logl" >&5
12834 echo "${ECHO_T}$ac_cv_lib_m_logl" >&6
12835 if test $ac_cv_lib_m_logl = yes; then
12836
12837 cat >>confdefs.h <<\_ACEOF
12838 #define HAVE_LOGL 1
12839 _ACEOF
12840
12841 fi
12842
12843 echo "$as_me:$LINENO: checking for clogf in -lm" >&5
12844 echo $ECHO_N "checking for clogf in -lm... $ECHO_C" >&6
12845 if test "${ac_cv_lib_m_clogf+set}" = set; then
12846   echo $ECHO_N "(cached) $ECHO_C" >&6
12847 else
12848   ac_check_lib_save_LIBS=$LIBS
12849 LIBS="-lm  $LIBS"
12850 if test x$gcc_no_link = xyes; then
12851   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12852 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12853    { (exit 1); exit 1; }; }
12854 fi
12855 cat >conftest.$ac_ext <<_ACEOF
12856 /* confdefs.h.  */
12857 _ACEOF
12858 cat confdefs.h >>conftest.$ac_ext
12859 cat >>conftest.$ac_ext <<_ACEOF
12860 /* end confdefs.h.  */
12861
12862 /* Override any gcc2 internal prototype to avoid an error.  */
12863 #ifdef __cplusplus
12864 extern "C"
12865 #endif
12866 /* We use char because int might match the return type of a gcc2
12867    builtin and then its argument prototype would still apply.  */
12868 char clogf ();
12869 int
12870 main ()
12871 {
12872 clogf ();
12873   ;
12874   return 0;
12875 }
12876 _ACEOF
12877 rm -f conftest.$ac_objext conftest$ac_exeext
12878 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12879   (eval $ac_link) 2>conftest.er1
12880   ac_status=$?
12881   grep -v '^ *+' conftest.er1 >conftest.err
12882   rm -f conftest.er1
12883   cat conftest.err >&5
12884   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12885   (exit $ac_status); } &&
12886          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
12887   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12888   (eval $ac_try) 2>&5
12889   ac_status=$?
12890   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12891   (exit $ac_status); }; } &&
12892          { ac_try='test -s conftest$ac_exeext'
12893   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12894   (eval $ac_try) 2>&5
12895   ac_status=$?
12896   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12897   (exit $ac_status); }; }; then
12898   ac_cv_lib_m_clogf=yes
12899 else
12900   echo "$as_me: failed program was:" >&5
12901 sed 's/^/| /' conftest.$ac_ext >&5
12902
12903 ac_cv_lib_m_clogf=no
12904 fi
12905 rm -f conftest.err conftest.$ac_objext \
12906       conftest$ac_exeext conftest.$ac_ext
12907 LIBS=$ac_check_lib_save_LIBS
12908 fi
12909 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clogf" >&5
12910 echo "${ECHO_T}$ac_cv_lib_m_clogf" >&6
12911 if test $ac_cv_lib_m_clogf = yes; then
12912
12913 cat >>confdefs.h <<\_ACEOF
12914 #define HAVE_CLOGF 1
12915 _ACEOF
12916
12917 fi
12918
12919 echo "$as_me:$LINENO: checking for clog in -lm" >&5
12920 echo $ECHO_N "checking for clog in -lm... $ECHO_C" >&6
12921 if test "${ac_cv_lib_m_clog+set}" = set; then
12922   echo $ECHO_N "(cached) $ECHO_C" >&6
12923 else
12924   ac_check_lib_save_LIBS=$LIBS
12925 LIBS="-lm  $LIBS"
12926 if test x$gcc_no_link = xyes; then
12927   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12928 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12929    { (exit 1); exit 1; }; }
12930 fi
12931 cat >conftest.$ac_ext <<_ACEOF
12932 /* confdefs.h.  */
12933 _ACEOF
12934 cat confdefs.h >>conftest.$ac_ext
12935 cat >>conftest.$ac_ext <<_ACEOF
12936 /* end confdefs.h.  */
12937
12938 /* Override any gcc2 internal prototype to avoid an error.  */
12939 #ifdef __cplusplus
12940 extern "C"
12941 #endif
12942 /* We use char because int might match the return type of a gcc2
12943    builtin and then its argument prototype would still apply.  */
12944 char clog ();
12945 int
12946 main ()
12947 {
12948 clog ();
12949   ;
12950   return 0;
12951 }
12952 _ACEOF
12953 rm -f conftest.$ac_objext conftest$ac_exeext
12954 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12955   (eval $ac_link) 2>conftest.er1
12956   ac_status=$?
12957   grep -v '^ *+' conftest.er1 >conftest.err
12958   rm -f conftest.er1
12959   cat conftest.err >&5
12960   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12961   (exit $ac_status); } &&
12962          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
12963   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12964   (eval $ac_try) 2>&5
12965   ac_status=$?
12966   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12967   (exit $ac_status); }; } &&
12968          { ac_try='test -s conftest$ac_exeext'
12969   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12970   (eval $ac_try) 2>&5
12971   ac_status=$?
12972   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12973   (exit $ac_status); }; }; then
12974   ac_cv_lib_m_clog=yes
12975 else
12976   echo "$as_me: failed program was:" >&5
12977 sed 's/^/| /' conftest.$ac_ext >&5
12978
12979 ac_cv_lib_m_clog=no
12980 fi
12981 rm -f conftest.err conftest.$ac_objext \
12982       conftest$ac_exeext conftest.$ac_ext
12983 LIBS=$ac_check_lib_save_LIBS
12984 fi
12985 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog" >&5
12986 echo "${ECHO_T}$ac_cv_lib_m_clog" >&6
12987 if test $ac_cv_lib_m_clog = yes; then
12988
12989 cat >>confdefs.h <<\_ACEOF
12990 #define HAVE_CLOG 1
12991 _ACEOF
12992
12993 fi
12994
12995 echo "$as_me:$LINENO: checking for clogl in -lm" >&5
12996 echo $ECHO_N "checking for clogl in -lm... $ECHO_C" >&6
12997 if test "${ac_cv_lib_m_clogl+set}" = set; then
12998   echo $ECHO_N "(cached) $ECHO_C" >&6
12999 else
13000   ac_check_lib_save_LIBS=$LIBS
13001 LIBS="-lm  $LIBS"
13002 if test x$gcc_no_link = xyes; then
13003   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13004 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13005    { (exit 1); exit 1; }; }
13006 fi
13007 cat >conftest.$ac_ext <<_ACEOF
13008 /* confdefs.h.  */
13009 _ACEOF
13010 cat confdefs.h >>conftest.$ac_ext
13011 cat >>conftest.$ac_ext <<_ACEOF
13012 /* end confdefs.h.  */
13013
13014 /* Override any gcc2 internal prototype to avoid an error.  */
13015 #ifdef __cplusplus
13016 extern "C"
13017 #endif
13018 /* We use char because int might match the return type of a gcc2
13019    builtin and then its argument prototype would still apply.  */
13020 char clogl ();
13021 int
13022 main ()
13023 {
13024 clogl ();
13025   ;
13026   return 0;
13027 }
13028 _ACEOF
13029 rm -f conftest.$ac_objext conftest$ac_exeext
13030 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13031   (eval $ac_link) 2>conftest.er1
13032   ac_status=$?
13033   grep -v '^ *+' conftest.er1 >conftest.err
13034   rm -f conftest.er1
13035   cat conftest.err >&5
13036   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13037   (exit $ac_status); } &&
13038          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13039   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13040   (eval $ac_try) 2>&5
13041   ac_status=$?
13042   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13043   (exit $ac_status); }; } &&
13044          { ac_try='test -s conftest$ac_exeext'
13045   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13046   (eval $ac_try) 2>&5
13047   ac_status=$?
13048   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13049   (exit $ac_status); }; }; then
13050   ac_cv_lib_m_clogl=yes
13051 else
13052   echo "$as_me: failed program was:" >&5
13053 sed 's/^/| /' conftest.$ac_ext >&5
13054
13055 ac_cv_lib_m_clogl=no
13056 fi
13057 rm -f conftest.err conftest.$ac_objext \
13058       conftest$ac_exeext conftest.$ac_ext
13059 LIBS=$ac_check_lib_save_LIBS
13060 fi
13061 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clogl" >&5
13062 echo "${ECHO_T}$ac_cv_lib_m_clogl" >&6
13063 if test $ac_cv_lib_m_clogl = yes; then
13064
13065 cat >>confdefs.h <<\_ACEOF
13066 #define HAVE_CLOGL 1
13067 _ACEOF
13068
13069 fi
13070
13071 echo "$as_me:$LINENO: checking for log10f in -lm" >&5
13072 echo $ECHO_N "checking for log10f in -lm... $ECHO_C" >&6
13073 if test "${ac_cv_lib_m_log10f+set}" = set; then
13074   echo $ECHO_N "(cached) $ECHO_C" >&6
13075 else
13076   ac_check_lib_save_LIBS=$LIBS
13077 LIBS="-lm  $LIBS"
13078 if test x$gcc_no_link = xyes; then
13079   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13080 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13081    { (exit 1); exit 1; }; }
13082 fi
13083 cat >conftest.$ac_ext <<_ACEOF
13084 /* confdefs.h.  */
13085 _ACEOF
13086 cat confdefs.h >>conftest.$ac_ext
13087 cat >>conftest.$ac_ext <<_ACEOF
13088 /* end confdefs.h.  */
13089
13090 /* Override any gcc2 internal prototype to avoid an error.  */
13091 #ifdef __cplusplus
13092 extern "C"
13093 #endif
13094 /* We use char because int might match the return type of a gcc2
13095    builtin and then its argument prototype would still apply.  */
13096 char log10f ();
13097 int
13098 main ()
13099 {
13100 log10f ();
13101   ;
13102   return 0;
13103 }
13104 _ACEOF
13105 rm -f conftest.$ac_objext conftest$ac_exeext
13106 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13107   (eval $ac_link) 2>conftest.er1
13108   ac_status=$?
13109   grep -v '^ *+' conftest.er1 >conftest.err
13110   rm -f conftest.er1
13111   cat conftest.err >&5
13112   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13113   (exit $ac_status); } &&
13114          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13115   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13116   (eval $ac_try) 2>&5
13117   ac_status=$?
13118   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13119   (exit $ac_status); }; } &&
13120          { ac_try='test -s conftest$ac_exeext'
13121   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13122   (eval $ac_try) 2>&5
13123   ac_status=$?
13124   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13125   (exit $ac_status); }; }; then
13126   ac_cv_lib_m_log10f=yes
13127 else
13128   echo "$as_me: failed program was:" >&5
13129 sed 's/^/| /' conftest.$ac_ext >&5
13130
13131 ac_cv_lib_m_log10f=no
13132 fi
13133 rm -f conftest.err conftest.$ac_objext \
13134       conftest$ac_exeext conftest.$ac_ext
13135 LIBS=$ac_check_lib_save_LIBS
13136 fi
13137 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10f" >&5
13138 echo "${ECHO_T}$ac_cv_lib_m_log10f" >&6
13139 if test $ac_cv_lib_m_log10f = yes; then
13140
13141 cat >>confdefs.h <<\_ACEOF
13142 #define HAVE_LOG10F 1
13143 _ACEOF
13144
13145 fi
13146
13147 echo "$as_me:$LINENO: checking for log10 in -lm" >&5
13148 echo $ECHO_N "checking for log10 in -lm... $ECHO_C" >&6
13149 if test "${ac_cv_lib_m_log10+set}" = set; then
13150   echo $ECHO_N "(cached) $ECHO_C" >&6
13151 else
13152   ac_check_lib_save_LIBS=$LIBS
13153 LIBS="-lm  $LIBS"
13154 if test x$gcc_no_link = xyes; then
13155   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13156 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13157    { (exit 1); exit 1; }; }
13158 fi
13159 cat >conftest.$ac_ext <<_ACEOF
13160 /* confdefs.h.  */
13161 _ACEOF
13162 cat confdefs.h >>conftest.$ac_ext
13163 cat >>conftest.$ac_ext <<_ACEOF
13164 /* end confdefs.h.  */
13165
13166 /* Override any gcc2 internal prototype to avoid an error.  */
13167 #ifdef __cplusplus
13168 extern "C"
13169 #endif
13170 /* We use char because int might match the return type of a gcc2
13171    builtin and then its argument prototype would still apply.  */
13172 char log10 ();
13173 int
13174 main ()
13175 {
13176 log10 ();
13177   ;
13178   return 0;
13179 }
13180 _ACEOF
13181 rm -f conftest.$ac_objext conftest$ac_exeext
13182 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13183   (eval $ac_link) 2>conftest.er1
13184   ac_status=$?
13185   grep -v '^ *+' conftest.er1 >conftest.err
13186   rm -f conftest.er1
13187   cat conftest.err >&5
13188   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13189   (exit $ac_status); } &&
13190          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13191   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13192   (eval $ac_try) 2>&5
13193   ac_status=$?
13194   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13195   (exit $ac_status); }; } &&
13196          { ac_try='test -s conftest$ac_exeext'
13197   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13198   (eval $ac_try) 2>&5
13199   ac_status=$?
13200   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13201   (exit $ac_status); }; }; then
13202   ac_cv_lib_m_log10=yes
13203 else
13204   echo "$as_me: failed program was:" >&5
13205 sed 's/^/| /' conftest.$ac_ext >&5
13206
13207 ac_cv_lib_m_log10=no
13208 fi
13209 rm -f conftest.err conftest.$ac_objext \
13210       conftest$ac_exeext conftest.$ac_ext
13211 LIBS=$ac_check_lib_save_LIBS
13212 fi
13213 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10" >&5
13214 echo "${ECHO_T}$ac_cv_lib_m_log10" >&6
13215 if test $ac_cv_lib_m_log10 = yes; then
13216
13217 cat >>confdefs.h <<\_ACEOF
13218 #define HAVE_LOG10 1
13219 _ACEOF
13220
13221 fi
13222
13223 echo "$as_me:$LINENO: checking for log10l in -lm" >&5
13224 echo $ECHO_N "checking for log10l in -lm... $ECHO_C" >&6
13225 if test "${ac_cv_lib_m_log10l+set}" = set; then
13226   echo $ECHO_N "(cached) $ECHO_C" >&6
13227 else
13228   ac_check_lib_save_LIBS=$LIBS
13229 LIBS="-lm  $LIBS"
13230 if test x$gcc_no_link = xyes; then
13231   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13232 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13233    { (exit 1); exit 1; }; }
13234 fi
13235 cat >conftest.$ac_ext <<_ACEOF
13236 /* confdefs.h.  */
13237 _ACEOF
13238 cat confdefs.h >>conftest.$ac_ext
13239 cat >>conftest.$ac_ext <<_ACEOF
13240 /* end confdefs.h.  */
13241
13242 /* Override any gcc2 internal prototype to avoid an error.  */
13243 #ifdef __cplusplus
13244 extern "C"
13245 #endif
13246 /* We use char because int might match the return type of a gcc2
13247    builtin and then its argument prototype would still apply.  */
13248 char log10l ();
13249 int
13250 main ()
13251 {
13252 log10l ();
13253   ;
13254   return 0;
13255 }
13256 _ACEOF
13257 rm -f conftest.$ac_objext conftest$ac_exeext
13258 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13259   (eval $ac_link) 2>conftest.er1
13260   ac_status=$?
13261   grep -v '^ *+' conftest.er1 >conftest.err
13262   rm -f conftest.er1
13263   cat conftest.err >&5
13264   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13265   (exit $ac_status); } &&
13266          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13267   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13268   (eval $ac_try) 2>&5
13269   ac_status=$?
13270   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13271   (exit $ac_status); }; } &&
13272          { ac_try='test -s conftest$ac_exeext'
13273   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13274   (eval $ac_try) 2>&5
13275   ac_status=$?
13276   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13277   (exit $ac_status); }; }; then
13278   ac_cv_lib_m_log10l=yes
13279 else
13280   echo "$as_me: failed program was:" >&5
13281 sed 's/^/| /' conftest.$ac_ext >&5
13282
13283 ac_cv_lib_m_log10l=no
13284 fi
13285 rm -f conftest.err conftest.$ac_objext \
13286       conftest$ac_exeext conftest.$ac_ext
13287 LIBS=$ac_check_lib_save_LIBS
13288 fi
13289 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10l" >&5
13290 echo "${ECHO_T}$ac_cv_lib_m_log10l" >&6
13291 if test $ac_cv_lib_m_log10l = yes; then
13292
13293 cat >>confdefs.h <<\_ACEOF
13294 #define HAVE_LOG10L 1
13295 _ACEOF
13296
13297 fi
13298
13299 echo "$as_me:$LINENO: checking for clog10f in -lm" >&5
13300 echo $ECHO_N "checking for clog10f in -lm... $ECHO_C" >&6
13301 if test "${ac_cv_lib_m_clog10f+set}" = set; then
13302   echo $ECHO_N "(cached) $ECHO_C" >&6
13303 else
13304   ac_check_lib_save_LIBS=$LIBS
13305 LIBS="-lm  $LIBS"
13306 if test x$gcc_no_link = xyes; then
13307   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13308 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13309    { (exit 1); exit 1; }; }
13310 fi
13311 cat >conftest.$ac_ext <<_ACEOF
13312 /* confdefs.h.  */
13313 _ACEOF
13314 cat confdefs.h >>conftest.$ac_ext
13315 cat >>conftest.$ac_ext <<_ACEOF
13316 /* end confdefs.h.  */
13317
13318 /* Override any gcc2 internal prototype to avoid an error.  */
13319 #ifdef __cplusplus
13320 extern "C"
13321 #endif
13322 /* We use char because int might match the return type of a gcc2
13323    builtin and then its argument prototype would still apply.  */
13324 char clog10f ();
13325 int
13326 main ()
13327 {
13328 clog10f ();
13329   ;
13330   return 0;
13331 }
13332 _ACEOF
13333 rm -f conftest.$ac_objext conftest$ac_exeext
13334 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13335   (eval $ac_link) 2>conftest.er1
13336   ac_status=$?
13337   grep -v '^ *+' conftest.er1 >conftest.err
13338   rm -f conftest.er1
13339   cat conftest.err >&5
13340   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13341   (exit $ac_status); } &&
13342          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13343   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13344   (eval $ac_try) 2>&5
13345   ac_status=$?
13346   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13347   (exit $ac_status); }; } &&
13348          { ac_try='test -s conftest$ac_exeext'
13349   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13350   (eval $ac_try) 2>&5
13351   ac_status=$?
13352   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13353   (exit $ac_status); }; }; then
13354   ac_cv_lib_m_clog10f=yes
13355 else
13356   echo "$as_me: failed program was:" >&5
13357 sed 's/^/| /' conftest.$ac_ext >&5
13358
13359 ac_cv_lib_m_clog10f=no
13360 fi
13361 rm -f conftest.err conftest.$ac_objext \
13362       conftest$ac_exeext conftest.$ac_ext
13363 LIBS=$ac_check_lib_save_LIBS
13364 fi
13365 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10f" >&5
13366 echo "${ECHO_T}$ac_cv_lib_m_clog10f" >&6
13367 if test $ac_cv_lib_m_clog10f = yes; then
13368
13369 cat >>confdefs.h <<\_ACEOF
13370 #define HAVE_CLOG10F 1
13371 _ACEOF
13372
13373 fi
13374
13375 echo "$as_me:$LINENO: checking for clog10 in -lm" >&5
13376 echo $ECHO_N "checking for clog10 in -lm... $ECHO_C" >&6
13377 if test "${ac_cv_lib_m_clog10+set}" = set; then
13378   echo $ECHO_N "(cached) $ECHO_C" >&6
13379 else
13380   ac_check_lib_save_LIBS=$LIBS
13381 LIBS="-lm  $LIBS"
13382 if test x$gcc_no_link = xyes; then
13383   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13384 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13385    { (exit 1); exit 1; }; }
13386 fi
13387 cat >conftest.$ac_ext <<_ACEOF
13388 /* confdefs.h.  */
13389 _ACEOF
13390 cat confdefs.h >>conftest.$ac_ext
13391 cat >>conftest.$ac_ext <<_ACEOF
13392 /* end confdefs.h.  */
13393
13394 /* Override any gcc2 internal prototype to avoid an error.  */
13395 #ifdef __cplusplus
13396 extern "C"
13397 #endif
13398 /* We use char because int might match the return type of a gcc2
13399    builtin and then its argument prototype would still apply.  */
13400 char clog10 ();
13401 int
13402 main ()
13403 {
13404 clog10 ();
13405   ;
13406   return 0;
13407 }
13408 _ACEOF
13409 rm -f conftest.$ac_objext conftest$ac_exeext
13410 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13411   (eval $ac_link) 2>conftest.er1
13412   ac_status=$?
13413   grep -v '^ *+' conftest.er1 >conftest.err
13414   rm -f conftest.er1
13415   cat conftest.err >&5
13416   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13417   (exit $ac_status); } &&
13418          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13419   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13420   (eval $ac_try) 2>&5
13421   ac_status=$?
13422   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13423   (exit $ac_status); }; } &&
13424          { ac_try='test -s conftest$ac_exeext'
13425   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13426   (eval $ac_try) 2>&5
13427   ac_status=$?
13428   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13429   (exit $ac_status); }; }; then
13430   ac_cv_lib_m_clog10=yes
13431 else
13432   echo "$as_me: failed program was:" >&5
13433 sed 's/^/| /' conftest.$ac_ext >&5
13434
13435 ac_cv_lib_m_clog10=no
13436 fi
13437 rm -f conftest.err conftest.$ac_objext \
13438       conftest$ac_exeext conftest.$ac_ext
13439 LIBS=$ac_check_lib_save_LIBS
13440 fi
13441 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10" >&5
13442 echo "${ECHO_T}$ac_cv_lib_m_clog10" >&6
13443 if test $ac_cv_lib_m_clog10 = yes; then
13444
13445 cat >>confdefs.h <<\_ACEOF
13446 #define HAVE_CLOG10 1
13447 _ACEOF
13448
13449 fi
13450
13451 echo "$as_me:$LINENO: checking for clog10l in -lm" >&5
13452 echo $ECHO_N "checking for clog10l in -lm... $ECHO_C" >&6
13453 if test "${ac_cv_lib_m_clog10l+set}" = set; then
13454   echo $ECHO_N "(cached) $ECHO_C" >&6
13455 else
13456   ac_check_lib_save_LIBS=$LIBS
13457 LIBS="-lm  $LIBS"
13458 if test x$gcc_no_link = xyes; then
13459   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13460 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13461    { (exit 1); exit 1; }; }
13462 fi
13463 cat >conftest.$ac_ext <<_ACEOF
13464 /* confdefs.h.  */
13465 _ACEOF
13466 cat confdefs.h >>conftest.$ac_ext
13467 cat >>conftest.$ac_ext <<_ACEOF
13468 /* end confdefs.h.  */
13469
13470 /* Override any gcc2 internal prototype to avoid an error.  */
13471 #ifdef __cplusplus
13472 extern "C"
13473 #endif
13474 /* We use char because int might match the return type of a gcc2
13475    builtin and then its argument prototype would still apply.  */
13476 char clog10l ();
13477 int
13478 main ()
13479 {
13480 clog10l ();
13481   ;
13482   return 0;
13483 }
13484 _ACEOF
13485 rm -f conftest.$ac_objext conftest$ac_exeext
13486 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13487   (eval $ac_link) 2>conftest.er1
13488   ac_status=$?
13489   grep -v '^ *+' conftest.er1 >conftest.err
13490   rm -f conftest.er1
13491   cat conftest.err >&5
13492   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13493   (exit $ac_status); } &&
13494          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13495   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13496   (eval $ac_try) 2>&5
13497   ac_status=$?
13498   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13499   (exit $ac_status); }; } &&
13500          { ac_try='test -s conftest$ac_exeext'
13501   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13502   (eval $ac_try) 2>&5
13503   ac_status=$?
13504   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13505   (exit $ac_status); }; }; then
13506   ac_cv_lib_m_clog10l=yes
13507 else
13508   echo "$as_me: failed program was:" >&5
13509 sed 's/^/| /' conftest.$ac_ext >&5
13510
13511 ac_cv_lib_m_clog10l=no
13512 fi
13513 rm -f conftest.err conftest.$ac_objext \
13514       conftest$ac_exeext conftest.$ac_ext
13515 LIBS=$ac_check_lib_save_LIBS
13516 fi
13517 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10l" >&5
13518 echo "${ECHO_T}$ac_cv_lib_m_clog10l" >&6
13519 if test $ac_cv_lib_m_clog10l = yes; then
13520
13521 cat >>confdefs.h <<\_ACEOF
13522 #define HAVE_CLOG10L 1
13523 _ACEOF
13524
13525 fi
13526
13527 echo "$as_me:$LINENO: checking for nextafterf in -lm" >&5
13528 echo $ECHO_N "checking for nextafterf in -lm... $ECHO_C" >&6
13529 if test "${ac_cv_lib_m_nextafterf+set}" = set; then
13530   echo $ECHO_N "(cached) $ECHO_C" >&6
13531 else
13532   ac_check_lib_save_LIBS=$LIBS
13533 LIBS="-lm  $LIBS"
13534 if test x$gcc_no_link = xyes; then
13535   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13536 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13537    { (exit 1); exit 1; }; }
13538 fi
13539 cat >conftest.$ac_ext <<_ACEOF
13540 /* confdefs.h.  */
13541 _ACEOF
13542 cat confdefs.h >>conftest.$ac_ext
13543 cat >>conftest.$ac_ext <<_ACEOF
13544 /* end confdefs.h.  */
13545
13546 /* Override any gcc2 internal prototype to avoid an error.  */
13547 #ifdef __cplusplus
13548 extern "C"
13549 #endif
13550 /* We use char because int might match the return type of a gcc2
13551    builtin and then its argument prototype would still apply.  */
13552 char nextafterf ();
13553 int
13554 main ()
13555 {
13556 nextafterf ();
13557   ;
13558   return 0;
13559 }
13560 _ACEOF
13561 rm -f conftest.$ac_objext conftest$ac_exeext
13562 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13563   (eval $ac_link) 2>conftest.er1
13564   ac_status=$?
13565   grep -v '^ *+' conftest.er1 >conftest.err
13566   rm -f conftest.er1
13567   cat conftest.err >&5
13568   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13569   (exit $ac_status); } &&
13570          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13571   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13572   (eval $ac_try) 2>&5
13573   ac_status=$?
13574   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13575   (exit $ac_status); }; } &&
13576          { ac_try='test -s conftest$ac_exeext'
13577   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13578   (eval $ac_try) 2>&5
13579   ac_status=$?
13580   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13581   (exit $ac_status); }; }; then
13582   ac_cv_lib_m_nextafterf=yes
13583 else
13584   echo "$as_me: failed program was:" >&5
13585 sed 's/^/| /' conftest.$ac_ext >&5
13586
13587 ac_cv_lib_m_nextafterf=no
13588 fi
13589 rm -f conftest.err conftest.$ac_objext \
13590       conftest$ac_exeext conftest.$ac_ext
13591 LIBS=$ac_check_lib_save_LIBS
13592 fi
13593 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafterf" >&5
13594 echo "${ECHO_T}$ac_cv_lib_m_nextafterf" >&6
13595 if test $ac_cv_lib_m_nextafterf = yes; then
13596
13597 cat >>confdefs.h <<\_ACEOF
13598 #define HAVE_NEXTAFTERF 1
13599 _ACEOF
13600
13601 fi
13602
13603 echo "$as_me:$LINENO: checking for nextafter in -lm" >&5
13604 echo $ECHO_N "checking for nextafter in -lm... $ECHO_C" >&6
13605 if test "${ac_cv_lib_m_nextafter+set}" = set; then
13606   echo $ECHO_N "(cached) $ECHO_C" >&6
13607 else
13608   ac_check_lib_save_LIBS=$LIBS
13609 LIBS="-lm  $LIBS"
13610 if test x$gcc_no_link = xyes; then
13611   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13612 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13613    { (exit 1); exit 1; }; }
13614 fi
13615 cat >conftest.$ac_ext <<_ACEOF
13616 /* confdefs.h.  */
13617 _ACEOF
13618 cat confdefs.h >>conftest.$ac_ext
13619 cat >>conftest.$ac_ext <<_ACEOF
13620 /* end confdefs.h.  */
13621
13622 /* Override any gcc2 internal prototype to avoid an error.  */
13623 #ifdef __cplusplus
13624 extern "C"
13625 #endif
13626 /* We use char because int might match the return type of a gcc2
13627    builtin and then its argument prototype would still apply.  */
13628 char nextafter ();
13629 int
13630 main ()
13631 {
13632 nextafter ();
13633   ;
13634   return 0;
13635 }
13636 _ACEOF
13637 rm -f conftest.$ac_objext conftest$ac_exeext
13638 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13639   (eval $ac_link) 2>conftest.er1
13640   ac_status=$?
13641   grep -v '^ *+' conftest.er1 >conftest.err
13642   rm -f conftest.er1
13643   cat conftest.err >&5
13644   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13645   (exit $ac_status); } &&
13646          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13647   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13648   (eval $ac_try) 2>&5
13649   ac_status=$?
13650   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13651   (exit $ac_status); }; } &&
13652          { ac_try='test -s conftest$ac_exeext'
13653   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13654   (eval $ac_try) 2>&5
13655   ac_status=$?
13656   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13657   (exit $ac_status); }; }; then
13658   ac_cv_lib_m_nextafter=yes
13659 else
13660   echo "$as_me: failed program was:" >&5
13661 sed 's/^/| /' conftest.$ac_ext >&5
13662
13663 ac_cv_lib_m_nextafter=no
13664 fi
13665 rm -f conftest.err conftest.$ac_objext \
13666       conftest$ac_exeext conftest.$ac_ext
13667 LIBS=$ac_check_lib_save_LIBS
13668 fi
13669 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafter" >&5
13670 echo "${ECHO_T}$ac_cv_lib_m_nextafter" >&6
13671 if test $ac_cv_lib_m_nextafter = yes; then
13672
13673 cat >>confdefs.h <<\_ACEOF
13674 #define HAVE_NEXTAFTER 1
13675 _ACEOF
13676
13677 fi
13678
13679 echo "$as_me:$LINENO: checking for nextafterl in -lm" >&5
13680 echo $ECHO_N "checking for nextafterl in -lm... $ECHO_C" >&6
13681 if test "${ac_cv_lib_m_nextafterl+set}" = set; then
13682   echo $ECHO_N "(cached) $ECHO_C" >&6
13683 else
13684   ac_check_lib_save_LIBS=$LIBS
13685 LIBS="-lm  $LIBS"
13686 if test x$gcc_no_link = xyes; then
13687   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13688 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13689    { (exit 1); exit 1; }; }
13690 fi
13691 cat >conftest.$ac_ext <<_ACEOF
13692 /* confdefs.h.  */
13693 _ACEOF
13694 cat confdefs.h >>conftest.$ac_ext
13695 cat >>conftest.$ac_ext <<_ACEOF
13696 /* end confdefs.h.  */
13697
13698 /* Override any gcc2 internal prototype to avoid an error.  */
13699 #ifdef __cplusplus
13700 extern "C"
13701 #endif
13702 /* We use char because int might match the return type of a gcc2
13703    builtin and then its argument prototype would still apply.  */
13704 char nextafterl ();
13705 int
13706 main ()
13707 {
13708 nextafterl ();
13709   ;
13710   return 0;
13711 }
13712 _ACEOF
13713 rm -f conftest.$ac_objext conftest$ac_exeext
13714 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13715   (eval $ac_link) 2>conftest.er1
13716   ac_status=$?
13717   grep -v '^ *+' conftest.er1 >conftest.err
13718   rm -f conftest.er1
13719   cat conftest.err >&5
13720   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13721   (exit $ac_status); } &&
13722          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13723   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13724   (eval $ac_try) 2>&5
13725   ac_status=$?
13726   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13727   (exit $ac_status); }; } &&
13728          { ac_try='test -s conftest$ac_exeext'
13729   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13730   (eval $ac_try) 2>&5
13731   ac_status=$?
13732   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13733   (exit $ac_status); }; }; then
13734   ac_cv_lib_m_nextafterl=yes
13735 else
13736   echo "$as_me: failed program was:" >&5
13737 sed 's/^/| /' conftest.$ac_ext >&5
13738
13739 ac_cv_lib_m_nextafterl=no
13740 fi
13741 rm -f conftest.err conftest.$ac_objext \
13742       conftest$ac_exeext conftest.$ac_ext
13743 LIBS=$ac_check_lib_save_LIBS
13744 fi
13745 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafterl" >&5
13746 echo "${ECHO_T}$ac_cv_lib_m_nextafterl" >&6
13747 if test $ac_cv_lib_m_nextafterl = yes; then
13748
13749 cat >>confdefs.h <<\_ACEOF
13750 #define HAVE_NEXTAFTERL 1
13751 _ACEOF
13752
13753 fi
13754
13755 echo "$as_me:$LINENO: checking for powf in -lm" >&5
13756 echo $ECHO_N "checking for powf in -lm... $ECHO_C" >&6
13757 if test "${ac_cv_lib_m_powf+set}" = set; then
13758   echo $ECHO_N "(cached) $ECHO_C" >&6
13759 else
13760   ac_check_lib_save_LIBS=$LIBS
13761 LIBS="-lm  $LIBS"
13762 if test x$gcc_no_link = xyes; then
13763   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13764 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13765    { (exit 1); exit 1; }; }
13766 fi
13767 cat >conftest.$ac_ext <<_ACEOF
13768 /* confdefs.h.  */
13769 _ACEOF
13770 cat confdefs.h >>conftest.$ac_ext
13771 cat >>conftest.$ac_ext <<_ACEOF
13772 /* end confdefs.h.  */
13773
13774 /* Override any gcc2 internal prototype to avoid an error.  */
13775 #ifdef __cplusplus
13776 extern "C"
13777 #endif
13778 /* We use char because int might match the return type of a gcc2
13779    builtin and then its argument prototype would still apply.  */
13780 char powf ();
13781 int
13782 main ()
13783 {
13784 powf ();
13785   ;
13786   return 0;
13787 }
13788 _ACEOF
13789 rm -f conftest.$ac_objext conftest$ac_exeext
13790 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13791   (eval $ac_link) 2>conftest.er1
13792   ac_status=$?
13793   grep -v '^ *+' conftest.er1 >conftest.err
13794   rm -f conftest.er1
13795   cat conftest.err >&5
13796   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13797   (exit $ac_status); } &&
13798          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13799   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13800   (eval $ac_try) 2>&5
13801   ac_status=$?
13802   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13803   (exit $ac_status); }; } &&
13804          { ac_try='test -s conftest$ac_exeext'
13805   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13806   (eval $ac_try) 2>&5
13807   ac_status=$?
13808   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13809   (exit $ac_status); }; }; then
13810   ac_cv_lib_m_powf=yes
13811 else
13812   echo "$as_me: failed program was:" >&5
13813 sed 's/^/| /' conftest.$ac_ext >&5
13814
13815 ac_cv_lib_m_powf=no
13816 fi
13817 rm -f conftest.err conftest.$ac_objext \
13818       conftest$ac_exeext conftest.$ac_ext
13819 LIBS=$ac_check_lib_save_LIBS
13820 fi
13821 echo "$as_me:$LINENO: result: $ac_cv_lib_m_powf" >&5
13822 echo "${ECHO_T}$ac_cv_lib_m_powf" >&6
13823 if test $ac_cv_lib_m_powf = yes; then
13824
13825 cat >>confdefs.h <<\_ACEOF
13826 #define HAVE_POWF 1
13827 _ACEOF
13828
13829 fi
13830
13831 echo "$as_me:$LINENO: checking for pow in -lm" >&5
13832 echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
13833 if test "${ac_cv_lib_m_pow+set}" = set; then
13834   echo $ECHO_N "(cached) $ECHO_C" >&6
13835 else
13836   ac_check_lib_save_LIBS=$LIBS
13837 LIBS="-lm  $LIBS"
13838 if test x$gcc_no_link = xyes; then
13839   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13840 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13841    { (exit 1); exit 1; }; }
13842 fi
13843 cat >conftest.$ac_ext <<_ACEOF
13844 /* confdefs.h.  */
13845 _ACEOF
13846 cat confdefs.h >>conftest.$ac_ext
13847 cat >>conftest.$ac_ext <<_ACEOF
13848 /* end confdefs.h.  */
13849
13850 /* Override any gcc2 internal prototype to avoid an error.  */
13851 #ifdef __cplusplus
13852 extern "C"
13853 #endif
13854 /* We use char because int might match the return type of a gcc2
13855    builtin and then its argument prototype would still apply.  */
13856 char pow ();
13857 int
13858 main ()
13859 {
13860 pow ();
13861   ;
13862   return 0;
13863 }
13864 _ACEOF
13865 rm -f conftest.$ac_objext conftest$ac_exeext
13866 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13867   (eval $ac_link) 2>conftest.er1
13868   ac_status=$?
13869   grep -v '^ *+' conftest.er1 >conftest.err
13870   rm -f conftest.er1
13871   cat conftest.err >&5
13872   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13873   (exit $ac_status); } &&
13874          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13875   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13876   (eval $ac_try) 2>&5
13877   ac_status=$?
13878   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13879   (exit $ac_status); }; } &&
13880          { ac_try='test -s conftest$ac_exeext'
13881   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13882   (eval $ac_try) 2>&5
13883   ac_status=$?
13884   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13885   (exit $ac_status); }; }; then
13886   ac_cv_lib_m_pow=yes
13887 else
13888   echo "$as_me: failed program was:" >&5
13889 sed 's/^/| /' conftest.$ac_ext >&5
13890
13891 ac_cv_lib_m_pow=no
13892 fi
13893 rm -f conftest.err conftest.$ac_objext \
13894       conftest$ac_exeext conftest.$ac_ext
13895 LIBS=$ac_check_lib_save_LIBS
13896 fi
13897 echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
13898 echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
13899 if test $ac_cv_lib_m_pow = yes; then
13900
13901 cat >>confdefs.h <<\_ACEOF
13902 #define HAVE_POW 1
13903 _ACEOF
13904
13905 fi
13906
13907 echo "$as_me:$LINENO: checking for powl in -lm" >&5
13908 echo $ECHO_N "checking for powl in -lm... $ECHO_C" >&6
13909 if test "${ac_cv_lib_m_powl+set}" = set; then
13910   echo $ECHO_N "(cached) $ECHO_C" >&6
13911 else
13912   ac_check_lib_save_LIBS=$LIBS
13913 LIBS="-lm  $LIBS"
13914 if test x$gcc_no_link = xyes; then
13915   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13916 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13917    { (exit 1); exit 1; }; }
13918 fi
13919 cat >conftest.$ac_ext <<_ACEOF
13920 /* confdefs.h.  */
13921 _ACEOF
13922 cat confdefs.h >>conftest.$ac_ext
13923 cat >>conftest.$ac_ext <<_ACEOF
13924 /* end confdefs.h.  */
13925
13926 /* Override any gcc2 internal prototype to avoid an error.  */
13927 #ifdef __cplusplus
13928 extern "C"
13929 #endif
13930 /* We use char because int might match the return type of a gcc2
13931    builtin and then its argument prototype would still apply.  */
13932 char powl ();
13933 int
13934 main ()
13935 {
13936 powl ();
13937   ;
13938   return 0;
13939 }
13940 _ACEOF
13941 rm -f conftest.$ac_objext conftest$ac_exeext
13942 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13943   (eval $ac_link) 2>conftest.er1
13944   ac_status=$?
13945   grep -v '^ *+' conftest.er1 >conftest.err
13946   rm -f conftest.er1
13947   cat conftest.err >&5
13948   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13949   (exit $ac_status); } &&
13950          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13951   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13952   (eval $ac_try) 2>&5
13953   ac_status=$?
13954   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13955   (exit $ac_status); }; } &&
13956          { ac_try='test -s conftest$ac_exeext'
13957   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13958   (eval $ac_try) 2>&5
13959   ac_status=$?
13960   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13961   (exit $ac_status); }; }; then
13962   ac_cv_lib_m_powl=yes
13963 else
13964   echo "$as_me: failed program was:" >&5
13965 sed 's/^/| /' conftest.$ac_ext >&5
13966
13967 ac_cv_lib_m_powl=no
13968 fi
13969 rm -f conftest.err conftest.$ac_objext \
13970       conftest$ac_exeext conftest.$ac_ext
13971 LIBS=$ac_check_lib_save_LIBS
13972 fi
13973 echo "$as_me:$LINENO: result: $ac_cv_lib_m_powl" >&5
13974 echo "${ECHO_T}$ac_cv_lib_m_powl" >&6
13975 if test $ac_cv_lib_m_powl = yes; then
13976
13977 cat >>confdefs.h <<\_ACEOF
13978 #define HAVE_POWL 1
13979 _ACEOF
13980
13981 fi
13982
13983 echo "$as_me:$LINENO: checking for cpowf in -lm" >&5
13984 echo $ECHO_N "checking for cpowf in -lm... $ECHO_C" >&6
13985 if test "${ac_cv_lib_m_cpowf+set}" = set; then
13986   echo $ECHO_N "(cached) $ECHO_C" >&6
13987 else
13988   ac_check_lib_save_LIBS=$LIBS
13989 LIBS="-lm  $LIBS"
13990 if test x$gcc_no_link = xyes; then
13991   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13992 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13993    { (exit 1); exit 1; }; }
13994 fi
13995 cat >conftest.$ac_ext <<_ACEOF
13996 /* confdefs.h.  */
13997 _ACEOF
13998 cat confdefs.h >>conftest.$ac_ext
13999 cat >>conftest.$ac_ext <<_ACEOF
14000 /* end confdefs.h.  */
14001
14002 /* Override any gcc2 internal prototype to avoid an error.  */
14003 #ifdef __cplusplus
14004 extern "C"
14005 #endif
14006 /* We use char because int might match the return type of a gcc2
14007    builtin and then its argument prototype would still apply.  */
14008 char cpowf ();
14009 int
14010 main ()
14011 {
14012 cpowf ();
14013   ;
14014   return 0;
14015 }
14016 _ACEOF
14017 rm -f conftest.$ac_objext conftest$ac_exeext
14018 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14019   (eval $ac_link) 2>conftest.er1
14020   ac_status=$?
14021   grep -v '^ *+' conftest.er1 >conftest.err
14022   rm -f conftest.er1
14023   cat conftest.err >&5
14024   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14025   (exit $ac_status); } &&
14026          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
14027   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14028   (eval $ac_try) 2>&5
14029   ac_status=$?
14030   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14031   (exit $ac_status); }; } &&
14032          { ac_try='test -s conftest$ac_exeext'
14033   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14034   (eval $ac_try) 2>&5
14035   ac_status=$?
14036   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14037   (exit $ac_status); }; }; then
14038   ac_cv_lib_m_cpowf=yes
14039 else
14040   echo "$as_me: failed program was:" >&5
14041 sed 's/^/| /' conftest.$ac_ext >&5
14042
14043 ac_cv_lib_m_cpowf=no
14044 fi
14045 rm -f conftest.err conftest.$ac_objext \
14046       conftest$ac_exeext conftest.$ac_ext
14047 LIBS=$ac_check_lib_save_LIBS
14048 fi
14049 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpowf" >&5
14050 echo "${ECHO_T}$ac_cv_lib_m_cpowf" >&6
14051 if test $ac_cv_lib_m_cpowf = yes; then
14052
14053 cat >>confdefs.h <<\_ACEOF
14054 #define HAVE_CPOWF 1
14055 _ACEOF
14056
14057 fi
14058
14059 echo "$as_me:$LINENO: checking for cpow in -lm" >&5
14060 echo $ECHO_N "checking for cpow in -lm... $ECHO_C" >&6
14061 if test "${ac_cv_lib_m_cpow+set}" = set; then
14062   echo $ECHO_N "(cached) $ECHO_C" >&6
14063 else
14064   ac_check_lib_save_LIBS=$LIBS
14065 LIBS="-lm  $LIBS"
14066 if test x$gcc_no_link = xyes; then
14067   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14068 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14069    { (exit 1); exit 1; }; }
14070 fi
14071 cat >conftest.$ac_ext <<_ACEOF
14072 /* confdefs.h.  */
14073 _ACEOF
14074 cat confdefs.h >>conftest.$ac_ext
14075 cat >>conftest.$ac_ext <<_ACEOF
14076 /* end confdefs.h.  */
14077
14078 /* Override any gcc2 internal prototype to avoid an error.  */
14079 #ifdef __cplusplus
14080 extern "C"
14081 #endif
14082 /* We use char because int might match the return type of a gcc2
14083    builtin and then its argument prototype would still apply.  */
14084 char cpow ();
14085 int
14086 main ()
14087 {
14088 cpow ();
14089   ;
14090   return 0;
14091 }
14092 _ACEOF
14093 rm -f conftest.$ac_objext conftest$ac_exeext
14094 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14095   (eval $ac_link) 2>conftest.er1
14096   ac_status=$?
14097   grep -v '^ *+' conftest.er1 >conftest.err
14098   rm -f conftest.er1
14099   cat conftest.err >&5
14100   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14101   (exit $ac_status); } &&
14102          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
14103   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14104   (eval $ac_try) 2>&5
14105   ac_status=$?
14106   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14107   (exit $ac_status); }; } &&
14108          { ac_try='test -s conftest$ac_exeext'
14109   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14110   (eval $ac_try) 2>&5
14111   ac_status=$?
14112   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14113   (exit $ac_status); }; }; then
14114   ac_cv_lib_m_cpow=yes
14115 else
14116   echo "$as_me: failed program was:" >&5
14117 sed 's/^/| /' conftest.$ac_ext >&5
14118
14119 ac_cv_lib_m_cpow=no
14120 fi
14121 rm -f conftest.err conftest.$ac_objext \
14122       conftest$ac_exeext conftest.$ac_ext
14123 LIBS=$ac_check_lib_save_LIBS
14124 fi
14125 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpow" >&5
14126 echo "${ECHO_T}$ac_cv_lib_m_cpow" >&6
14127 if test $ac_cv_lib_m_cpow = yes; then
14128
14129 cat >>confdefs.h <<\_ACEOF
14130 #define HAVE_CPOW 1
14131 _ACEOF
14132
14133 fi
14134
14135 echo "$as_me:$LINENO: checking for cpowl in -lm" >&5
14136 echo $ECHO_N "checking for cpowl in -lm... $ECHO_C" >&6
14137 if test "${ac_cv_lib_m_cpowl+set}" = set; then
14138   echo $ECHO_N "(cached) $ECHO_C" >&6
14139 else
14140   ac_check_lib_save_LIBS=$LIBS
14141 LIBS="-lm  $LIBS"
14142 if test x$gcc_no_link = xyes; then
14143   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14144 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14145    { (exit 1); exit 1; }; }
14146 fi
14147 cat >conftest.$ac_ext <<_ACEOF
14148 /* confdefs.h.  */
14149 _ACEOF
14150 cat confdefs.h >>conftest.$ac_ext
14151 cat >>conftest.$ac_ext <<_ACEOF
14152 /* end confdefs.h.  */
14153
14154 /* Override any gcc2 internal prototype to avoid an error.  */
14155 #ifdef __cplusplus
14156 extern "C"
14157 #endif
14158 /* We use char because int might match the return type of a gcc2
14159    builtin and then its argument prototype would still apply.  */
14160 char cpowl ();
14161 int
14162 main ()
14163 {
14164 cpowl ();
14165   ;
14166   return 0;
14167 }
14168 _ACEOF
14169 rm -f conftest.$ac_objext conftest$ac_exeext
14170 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14171   (eval $ac_link) 2>conftest.er1
14172   ac_status=$?
14173   grep -v '^ *+' conftest.er1 >conftest.err
14174   rm -f conftest.er1
14175   cat conftest.err >&5
14176   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14177   (exit $ac_status); } &&
14178          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
14179   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14180   (eval $ac_try) 2>&5
14181   ac_status=$?
14182   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14183   (exit $ac_status); }; } &&
14184          { ac_try='test -s conftest$ac_exeext'
14185   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14186   (eval $ac_try) 2>&5
14187   ac_status=$?
14188   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14189   (exit $ac_status); }; }; then
14190   ac_cv_lib_m_cpowl=yes
14191 else
14192   echo "$as_me: failed program was:" >&5
14193 sed 's/^/| /' conftest.$ac_ext >&5
14194
14195 ac_cv_lib_m_cpowl=no
14196 fi
14197 rm -f conftest.err conftest.$ac_objext \
14198       conftest$ac_exeext conftest.$ac_ext
14199 LIBS=$ac_check_lib_save_LIBS
14200 fi
14201 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpowl" >&5
14202 echo "${ECHO_T}$ac_cv_lib_m_cpowl" >&6
14203 if test $ac_cv_lib_m_cpowl = yes; then
14204
14205 cat >>confdefs.h <<\_ACEOF
14206 #define HAVE_CPOWL 1
14207 _ACEOF
14208
14209 fi
14210
14211 echo "$as_me:$LINENO: checking for roundf in -lm" >&5
14212 echo $ECHO_N "checking for roundf in -lm... $ECHO_C" >&6
14213 if test "${ac_cv_lib_m_roundf+set}" = set; then
14214   echo $ECHO_N "(cached) $ECHO_C" >&6
14215 else
14216   ac_check_lib_save_LIBS=$LIBS
14217 LIBS="-lm  $LIBS"
14218 if test x$gcc_no_link = xyes; then
14219   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14220 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14221    { (exit 1); exit 1; }; }
14222 fi
14223 cat >conftest.$ac_ext <<_ACEOF
14224 /* confdefs.h.  */
14225 _ACEOF
14226 cat confdefs.h >>conftest.$ac_ext
14227 cat >>conftest.$ac_ext <<_ACEOF
14228 /* end confdefs.h.  */
14229
14230 /* Override any gcc2 internal prototype to avoid an error.  */
14231 #ifdef __cplusplus
14232 extern "C"
14233 #endif
14234 /* We use char because int might match the return type of a gcc2
14235    builtin and then its argument prototype would still apply.  */
14236 char roundf ();
14237 int
14238 main ()
14239 {
14240 roundf ();
14241   ;
14242   return 0;
14243 }
14244 _ACEOF
14245 rm -f conftest.$ac_objext conftest$ac_exeext
14246 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14247   (eval $ac_link) 2>conftest.er1
14248   ac_status=$?
14249   grep -v '^ *+' conftest.er1 >conftest.err
14250   rm -f conftest.er1
14251   cat conftest.err >&5
14252   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14253   (exit $ac_status); } &&
14254          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
14255   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14256   (eval $ac_try) 2>&5
14257   ac_status=$?
14258   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14259   (exit $ac_status); }; } &&
14260          { ac_try='test -s conftest$ac_exeext'
14261   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14262   (eval $ac_try) 2>&5
14263   ac_status=$?
14264   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14265   (exit $ac_status); }; }; then
14266   ac_cv_lib_m_roundf=yes
14267 else
14268   echo "$as_me: failed program was:" >&5
14269 sed 's/^/| /' conftest.$ac_ext >&5
14270
14271 ac_cv_lib_m_roundf=no
14272 fi
14273 rm -f conftest.err conftest.$ac_objext \
14274       conftest$ac_exeext conftest.$ac_ext
14275 LIBS=$ac_check_lib_save_LIBS
14276 fi
14277 echo "$as_me:$LINENO: result: $ac_cv_lib_m_roundf" >&5
14278 echo "${ECHO_T}$ac_cv_lib_m_roundf" >&6
14279 if test $ac_cv_lib_m_roundf = yes; then
14280
14281 cat >>confdefs.h <<\_ACEOF
14282 #define HAVE_ROUNDF 1
14283 _ACEOF
14284
14285 fi
14286
14287 echo "$as_me:$LINENO: checking for round in -lm" >&5
14288 echo $ECHO_N "checking for round in -lm... $ECHO_C" >&6
14289 if test "${ac_cv_lib_m_round+set}" = set; then
14290   echo $ECHO_N "(cached) $ECHO_C" >&6
14291 else
14292   ac_check_lib_save_LIBS=$LIBS
14293 LIBS="-lm  $LIBS"
14294 if test x$gcc_no_link = xyes; then
14295   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14296 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14297    { (exit 1); exit 1; }; }
14298 fi
14299 cat >conftest.$ac_ext <<_ACEOF
14300 /* confdefs.h.  */
14301 _ACEOF
14302 cat confdefs.h >>conftest.$ac_ext
14303 cat >>conftest.$ac_ext <<_ACEOF
14304 /* end confdefs.h.  */
14305
14306 /* Override any gcc2 internal prototype to avoid an error.  */
14307 #ifdef __cplusplus
14308 extern "C"
14309 #endif
14310 /* We use char because int might match the return type of a gcc2
14311    builtin and then its argument prototype would still apply.  */
14312 char round ();
14313 int
14314 main ()
14315 {
14316 round ();
14317   ;
14318   return 0;
14319 }
14320 _ACEOF
14321 rm -f conftest.$ac_objext conftest$ac_exeext
14322 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14323   (eval $ac_link) 2>conftest.er1
14324   ac_status=$?
14325   grep -v '^ *+' conftest.er1 >conftest.err
14326   rm -f conftest.er1
14327   cat conftest.err >&5
14328   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14329   (exit $ac_status); } &&
14330          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
14331   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14332   (eval $ac_try) 2>&5
14333   ac_status=$?
14334   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14335   (exit $ac_status); }; } &&
14336          { ac_try='test -s conftest$ac_exeext'
14337   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14338   (eval $ac_try) 2>&5
14339   ac_status=$?
14340   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14341   (exit $ac_status); }; }; then
14342   ac_cv_lib_m_round=yes
14343 else
14344   echo "$as_me: failed program was:" >&5
14345 sed 's/^/| /' conftest.$ac_ext >&5
14346
14347 ac_cv_lib_m_round=no
14348 fi
14349 rm -f conftest.err conftest.$ac_objext \
14350       conftest$ac_exeext conftest.$ac_ext
14351 LIBS=$ac_check_lib_save_LIBS
14352 fi
14353 echo "$as_me:$LINENO: result: $ac_cv_lib_m_round" >&5
14354 echo "${ECHO_T}$ac_cv_lib_m_round" >&6
14355 if test $ac_cv_lib_m_round = yes; then
14356
14357 cat >>confdefs.h <<\_ACEOF
14358 #define HAVE_ROUND 1
14359 _ACEOF
14360
14361 fi
14362
14363 echo "$as_me:$LINENO: checking for roundl in -lm" >&5
14364 echo $ECHO_N "checking for roundl in -lm... $ECHO_C" >&6
14365 if test "${ac_cv_lib_m_roundl+set}" = set; then
14366   echo $ECHO_N "(cached) $ECHO_C" >&6
14367 else
14368   ac_check_lib_save_LIBS=$LIBS
14369 LIBS="-lm  $LIBS"
14370 if test x$gcc_no_link = xyes; then
14371   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14372 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14373    { (exit 1); exit 1; }; }
14374 fi
14375 cat >conftest.$ac_ext <<_ACEOF
14376 /* confdefs.h.  */
14377 _ACEOF
14378 cat confdefs.h >>conftest.$ac_ext
14379 cat >>conftest.$ac_ext <<_ACEOF
14380 /* end confdefs.h.  */
14381
14382 /* Override any gcc2 internal prototype to avoid an error.  */
14383 #ifdef __cplusplus
14384 extern "C"
14385 #endif
14386 /* We use char because int might match the return type of a gcc2
14387    builtin and then its argument prototype would still apply.  */
14388 char roundl ();
14389 int
14390 main ()
14391 {
14392 roundl ();
14393   ;
14394   return 0;
14395 }
14396 _ACEOF
14397 rm -f conftest.$ac_objext conftest$ac_exeext
14398 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14399   (eval $ac_link) 2>conftest.er1
14400   ac_status=$?
14401   grep -v '^ *+' conftest.er1 >conftest.err
14402   rm -f conftest.er1
14403   cat conftest.err >&5
14404   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14405   (exit $ac_status); } &&
14406          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
14407   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14408   (eval $ac_try) 2>&5
14409   ac_status=$?
14410   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14411   (exit $ac_status); }; } &&
14412          { ac_try='test -s conftest$ac_exeext'
14413   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14414   (eval $ac_try) 2>&5
14415   ac_status=$?
14416   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14417   (exit $ac_status); }; }; then
14418   ac_cv_lib_m_roundl=yes
14419 else
14420   echo "$as_me: failed program was:" >&5
14421 sed 's/^/| /' conftest.$ac_ext >&5
14422
14423 ac_cv_lib_m_roundl=no
14424 fi
14425 rm -f conftest.err conftest.$ac_objext \
14426       conftest$ac_exeext conftest.$ac_ext
14427 LIBS=$ac_check_lib_save_LIBS
14428 fi
14429 echo "$as_me:$LINENO: result: $ac_cv_lib_m_roundl" >&5
14430 echo "${ECHO_T}$ac_cv_lib_m_roundl" >&6
14431 if test $ac_cv_lib_m_roundl = yes; then
14432
14433 cat >>confdefs.h <<\_ACEOF
14434 #define HAVE_ROUNDL 1
14435 _ACEOF
14436
14437 fi
14438
14439 echo "$as_me:$LINENO: checking for scalbnf in -lm" >&5
14440 echo $ECHO_N "checking for scalbnf in -lm... $ECHO_C" >&6
14441 if test "${ac_cv_lib_m_scalbnf+set}" = set; then
14442   echo $ECHO_N "(cached) $ECHO_C" >&6
14443 else
14444   ac_check_lib_save_LIBS=$LIBS
14445 LIBS="-lm  $LIBS"
14446 if test x$gcc_no_link = xyes; then
14447   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14448 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14449    { (exit 1); exit 1; }; }
14450 fi
14451 cat >conftest.$ac_ext <<_ACEOF
14452 /* confdefs.h.  */
14453 _ACEOF
14454 cat confdefs.h >>conftest.$ac_ext
14455 cat >>conftest.$ac_ext <<_ACEOF
14456 /* end confdefs.h.  */
14457
14458 /* Override any gcc2 internal prototype to avoid an error.  */
14459 #ifdef __cplusplus
14460 extern "C"
14461 #endif
14462 /* We use char because int might match the return type of a gcc2
14463    builtin and then its argument prototype would still apply.  */
14464 char scalbnf ();
14465 int
14466 main ()
14467 {
14468 scalbnf ();
14469   ;
14470   return 0;
14471 }
14472 _ACEOF
14473 rm -f conftest.$ac_objext conftest$ac_exeext
14474 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14475   (eval $ac_link) 2>conftest.er1
14476   ac_status=$?
14477   grep -v '^ *+' conftest.er1 >conftest.err
14478   rm -f conftest.er1
14479   cat conftest.err >&5
14480   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14481   (exit $ac_status); } &&
14482          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
14483   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14484   (eval $ac_try) 2>&5
14485   ac_status=$?
14486   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14487   (exit $ac_status); }; } &&
14488          { ac_try='test -s conftest$ac_exeext'
14489   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14490   (eval $ac_try) 2>&5
14491   ac_status=$?
14492   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14493   (exit $ac_status); }; }; then
14494   ac_cv_lib_m_scalbnf=yes
14495 else
14496   echo "$as_me: failed program was:" >&5
14497 sed 's/^/| /' conftest.$ac_ext >&5
14498
14499 ac_cv_lib_m_scalbnf=no
14500 fi
14501 rm -f conftest.err conftest.$ac_objext \
14502       conftest$ac_exeext conftest.$ac_ext
14503 LIBS=$ac_check_lib_save_LIBS
14504 fi
14505 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbnf" >&5
14506 echo "${ECHO_T}$ac_cv_lib_m_scalbnf" >&6
14507 if test $ac_cv_lib_m_scalbnf = yes; then
14508
14509 cat >>confdefs.h <<\_ACEOF
14510 #define HAVE_SCALBNF 1
14511 _ACEOF
14512
14513 fi
14514
14515 echo "$as_me:$LINENO: checking for scalbn in -lm" >&5
14516 echo $ECHO_N "checking for scalbn in -lm... $ECHO_C" >&6
14517 if test "${ac_cv_lib_m_scalbn+set}" = set; then
14518   echo $ECHO_N "(cached) $ECHO_C" >&6
14519 else
14520   ac_check_lib_save_LIBS=$LIBS
14521 LIBS="-lm  $LIBS"
14522 if test x$gcc_no_link = xyes; then
14523   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14524 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14525    { (exit 1); exit 1; }; }
14526 fi
14527 cat >conftest.$ac_ext <<_ACEOF
14528 /* confdefs.h.  */
14529 _ACEOF
14530 cat confdefs.h >>conftest.$ac_ext
14531 cat >>conftest.$ac_ext <<_ACEOF
14532 /* end confdefs.h.  */
14533
14534 /* Override any gcc2 internal prototype to avoid an error.  */
14535 #ifdef __cplusplus
14536 extern "C"
14537 #endif
14538 /* We use char because int might match the return type of a gcc2
14539    builtin and then its argument prototype would still apply.  */
14540 char scalbn ();
14541 int
14542 main ()
14543 {
14544 scalbn ();
14545   ;
14546   return 0;
14547 }
14548 _ACEOF
14549 rm -f conftest.$ac_objext conftest$ac_exeext
14550 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14551   (eval $ac_link) 2>conftest.er1
14552   ac_status=$?
14553   grep -v '^ *+' conftest.er1 >conftest.err
14554   rm -f conftest.er1
14555   cat conftest.err >&5
14556   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14557   (exit $ac_status); } &&
14558          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
14559   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14560   (eval $ac_try) 2>&5
14561   ac_status=$?
14562   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14563   (exit $ac_status); }; } &&
14564          { ac_try='test -s conftest$ac_exeext'
14565   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14566   (eval $ac_try) 2>&5
14567   ac_status=$?
14568   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14569   (exit $ac_status); }; }; then
14570   ac_cv_lib_m_scalbn=yes
14571 else
14572   echo "$as_me: failed program was:" >&5
14573 sed 's/^/| /' conftest.$ac_ext >&5
14574
14575 ac_cv_lib_m_scalbn=no
14576 fi
14577 rm -f conftest.err conftest.$ac_objext \
14578       conftest$ac_exeext conftest.$ac_ext
14579 LIBS=$ac_check_lib_save_LIBS
14580 fi
14581 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbn" >&5
14582 echo "${ECHO_T}$ac_cv_lib_m_scalbn" >&6
14583 if test $ac_cv_lib_m_scalbn = yes; then
14584
14585 cat >>confdefs.h <<\_ACEOF
14586 #define HAVE_SCALBN 1
14587 _ACEOF
14588
14589 fi
14590
14591 echo "$as_me:$LINENO: checking for scalbnl in -lm" >&5
14592 echo $ECHO_N "checking for scalbnl in -lm... $ECHO_C" >&6
14593 if test "${ac_cv_lib_m_scalbnl+set}" = set; then
14594   echo $ECHO_N "(cached) $ECHO_C" >&6
14595 else
14596   ac_check_lib_save_LIBS=$LIBS
14597 LIBS="-lm  $LIBS"
14598 if test x$gcc_no_link = xyes; then
14599   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14600 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14601    { (exit 1); exit 1; }; }
14602 fi
14603 cat >conftest.$ac_ext <<_ACEOF
14604 /* confdefs.h.  */
14605 _ACEOF
14606 cat confdefs.h >>conftest.$ac_ext
14607 cat >>conftest.$ac_ext <<_ACEOF
14608 /* end confdefs.h.  */
14609
14610 /* Override any gcc2 internal prototype to avoid an error.  */
14611 #ifdef __cplusplus
14612 extern "C"
14613 #endif
14614 /* We use char because int might match the return type of a gcc2
14615    builtin and then its argument prototype would still apply.  */
14616 char scalbnl ();
14617 int
14618 main ()
14619 {
14620 scalbnl ();
14621   ;
14622   return 0;
14623 }
14624 _ACEOF
14625 rm -f conftest.$ac_objext conftest$ac_exeext
14626 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14627   (eval $ac_link) 2>conftest.er1
14628   ac_status=$?
14629   grep -v '^ *+' conftest.er1 >conftest.err
14630   rm -f conftest.er1
14631   cat conftest.err >&5
14632   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14633   (exit $ac_status); } &&
14634          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
14635   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14636   (eval $ac_try) 2>&5
14637   ac_status=$?
14638   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14639   (exit $ac_status); }; } &&
14640          { ac_try='test -s conftest$ac_exeext'
14641   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14642   (eval $ac_try) 2>&5
14643   ac_status=$?
14644   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14645   (exit $ac_status); }; }; then
14646   ac_cv_lib_m_scalbnl=yes
14647 else
14648   echo "$as_me: failed program was:" >&5
14649 sed 's/^/| /' conftest.$ac_ext >&5
14650
14651 ac_cv_lib_m_scalbnl=no
14652 fi
14653 rm -f conftest.err conftest.$ac_objext \
14654       conftest$ac_exeext conftest.$ac_ext
14655 LIBS=$ac_check_lib_save_LIBS
14656 fi
14657 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbnl" >&5
14658 echo "${ECHO_T}$ac_cv_lib_m_scalbnl" >&6
14659 if test $ac_cv_lib_m_scalbnl = yes; then
14660
14661 cat >>confdefs.h <<\_ACEOF
14662 #define HAVE_SCALBNL 1
14663 _ACEOF
14664
14665 fi
14666
14667 echo "$as_me:$LINENO: checking for sinf in -lm" >&5
14668 echo $ECHO_N "checking for sinf in -lm... $ECHO_C" >&6
14669 if test "${ac_cv_lib_m_sinf+set}" = set; then
14670   echo $ECHO_N "(cached) $ECHO_C" >&6
14671 else
14672   ac_check_lib_save_LIBS=$LIBS
14673 LIBS="-lm  $LIBS"
14674 if test x$gcc_no_link = xyes; then
14675   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14676 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14677    { (exit 1); exit 1; }; }
14678 fi
14679 cat >conftest.$ac_ext <<_ACEOF
14680 /* confdefs.h.  */
14681 _ACEOF
14682 cat confdefs.h >>conftest.$ac_ext
14683 cat >>conftest.$ac_ext <<_ACEOF
14684 /* end confdefs.h.  */
14685
14686 /* Override any gcc2 internal prototype to avoid an error.  */
14687 #ifdef __cplusplus
14688 extern "C"
14689 #endif
14690 /* We use char because int might match the return type of a gcc2
14691    builtin and then its argument prototype would still apply.  */
14692 char sinf ();
14693 int
14694 main ()
14695 {
14696 sinf ();
14697   ;
14698   return 0;
14699 }
14700 _ACEOF
14701 rm -f conftest.$ac_objext conftest$ac_exeext
14702 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14703   (eval $ac_link) 2>conftest.er1
14704   ac_status=$?
14705   grep -v '^ *+' conftest.er1 >conftest.err
14706   rm -f conftest.er1
14707   cat conftest.err >&5
14708   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14709   (exit $ac_status); } &&
14710          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
14711   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14712   (eval $ac_try) 2>&5
14713   ac_status=$?
14714   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14715   (exit $ac_status); }; } &&
14716          { ac_try='test -s conftest$ac_exeext'
14717   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14718   (eval $ac_try) 2>&5
14719   ac_status=$?
14720   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14721   (exit $ac_status); }; }; then
14722   ac_cv_lib_m_sinf=yes
14723 else
14724   echo "$as_me: failed program was:" >&5
14725 sed 's/^/| /' conftest.$ac_ext >&5
14726
14727 ac_cv_lib_m_sinf=no
14728 fi
14729 rm -f conftest.err conftest.$ac_objext \
14730       conftest$ac_exeext conftest.$ac_ext
14731 LIBS=$ac_check_lib_save_LIBS
14732 fi
14733 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinf" >&5
14734 echo "${ECHO_T}$ac_cv_lib_m_sinf" >&6
14735 if test $ac_cv_lib_m_sinf = yes; then
14736
14737 cat >>confdefs.h <<\_ACEOF
14738 #define HAVE_SINF 1
14739 _ACEOF
14740
14741 fi
14742
14743 echo "$as_me:$LINENO: checking for sin in -lm" >&5
14744 echo $ECHO_N "checking for sin in -lm... $ECHO_C" >&6
14745 if test "${ac_cv_lib_m_sin+set}" = set; then
14746   echo $ECHO_N "(cached) $ECHO_C" >&6
14747 else
14748   ac_check_lib_save_LIBS=$LIBS
14749 LIBS="-lm  $LIBS"
14750 if test x$gcc_no_link = xyes; then
14751   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14752 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14753    { (exit 1); exit 1; }; }
14754 fi
14755 cat >conftest.$ac_ext <<_ACEOF
14756 /* confdefs.h.  */
14757 _ACEOF
14758 cat confdefs.h >>conftest.$ac_ext
14759 cat >>conftest.$ac_ext <<_ACEOF
14760 /* end confdefs.h.  */
14761
14762 /* Override any gcc2 internal prototype to avoid an error.  */
14763 #ifdef __cplusplus
14764 extern "C"
14765 #endif
14766 /* We use char because int might match the return type of a gcc2
14767    builtin and then its argument prototype would still apply.  */
14768 char sin ();
14769 int
14770 main ()
14771 {
14772 sin ();
14773   ;
14774   return 0;
14775 }
14776 _ACEOF
14777 rm -f conftest.$ac_objext conftest$ac_exeext
14778 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14779   (eval $ac_link) 2>conftest.er1
14780   ac_status=$?
14781   grep -v '^ *+' conftest.er1 >conftest.err
14782   rm -f conftest.er1
14783   cat conftest.err >&5
14784   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14785   (exit $ac_status); } &&
14786          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
14787   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14788   (eval $ac_try) 2>&5
14789   ac_status=$?
14790   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14791   (exit $ac_status); }; } &&
14792          { ac_try='test -s conftest$ac_exeext'
14793   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14794   (eval $ac_try) 2>&5
14795   ac_status=$?
14796   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14797   (exit $ac_status); }; }; then
14798   ac_cv_lib_m_sin=yes
14799 else
14800   echo "$as_me: failed program was:" >&5
14801 sed 's/^/| /' conftest.$ac_ext >&5
14802
14803 ac_cv_lib_m_sin=no
14804 fi
14805 rm -f conftest.err conftest.$ac_objext \
14806       conftest$ac_exeext conftest.$ac_ext
14807 LIBS=$ac_check_lib_save_LIBS
14808 fi
14809 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sin" >&5
14810 echo "${ECHO_T}$ac_cv_lib_m_sin" >&6
14811 if test $ac_cv_lib_m_sin = yes; then
14812
14813 cat >>confdefs.h <<\_ACEOF
14814 #define HAVE_SIN 1
14815 _ACEOF
14816
14817 fi
14818
14819 echo "$as_me:$LINENO: checking for sinl in -lm" >&5
14820 echo $ECHO_N "checking for sinl in -lm... $ECHO_C" >&6
14821 if test "${ac_cv_lib_m_sinl+set}" = set; then
14822   echo $ECHO_N "(cached) $ECHO_C" >&6
14823 else
14824   ac_check_lib_save_LIBS=$LIBS
14825 LIBS="-lm  $LIBS"
14826 if test x$gcc_no_link = xyes; then
14827   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14828 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14829    { (exit 1); exit 1; }; }
14830 fi
14831 cat >conftest.$ac_ext <<_ACEOF
14832 /* confdefs.h.  */
14833 _ACEOF
14834 cat confdefs.h >>conftest.$ac_ext
14835 cat >>conftest.$ac_ext <<_ACEOF
14836 /* end confdefs.h.  */
14837
14838 /* Override any gcc2 internal prototype to avoid an error.  */
14839 #ifdef __cplusplus
14840 extern "C"
14841 #endif
14842 /* We use char because int might match the return type of a gcc2
14843    builtin and then its argument prototype would still apply.  */
14844 char sinl ();
14845 int
14846 main ()
14847 {
14848 sinl ();
14849   ;
14850   return 0;
14851 }
14852 _ACEOF
14853 rm -f conftest.$ac_objext conftest$ac_exeext
14854 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14855   (eval $ac_link) 2>conftest.er1
14856   ac_status=$?
14857   grep -v '^ *+' conftest.er1 >conftest.err
14858   rm -f conftest.er1
14859   cat conftest.err >&5
14860   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14861   (exit $ac_status); } &&
14862          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
14863   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14864   (eval $ac_try) 2>&5
14865   ac_status=$?
14866   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14867   (exit $ac_status); }; } &&
14868          { ac_try='test -s conftest$ac_exeext'
14869   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14870   (eval $ac_try) 2>&5
14871   ac_status=$?
14872   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14873   (exit $ac_status); }; }; then
14874   ac_cv_lib_m_sinl=yes
14875 else
14876   echo "$as_me: failed program was:" >&5
14877 sed 's/^/| /' conftest.$ac_ext >&5
14878
14879 ac_cv_lib_m_sinl=no
14880 fi
14881 rm -f conftest.err conftest.$ac_objext \
14882       conftest$ac_exeext conftest.$ac_ext
14883 LIBS=$ac_check_lib_save_LIBS
14884 fi
14885 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinl" >&5
14886 echo "${ECHO_T}$ac_cv_lib_m_sinl" >&6
14887 if test $ac_cv_lib_m_sinl = yes; then
14888
14889 cat >>confdefs.h <<\_ACEOF
14890 #define HAVE_SINL 1
14891 _ACEOF
14892
14893 fi
14894
14895 echo "$as_me:$LINENO: checking for csinf in -lm" >&5
14896 echo $ECHO_N "checking for csinf in -lm... $ECHO_C" >&6
14897 if test "${ac_cv_lib_m_csinf+set}" = set; then
14898   echo $ECHO_N "(cached) $ECHO_C" >&6
14899 else
14900   ac_check_lib_save_LIBS=$LIBS
14901 LIBS="-lm  $LIBS"
14902 if test x$gcc_no_link = xyes; then
14903   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14904 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14905    { (exit 1); exit 1; }; }
14906 fi
14907 cat >conftest.$ac_ext <<_ACEOF
14908 /* confdefs.h.  */
14909 _ACEOF
14910 cat confdefs.h >>conftest.$ac_ext
14911 cat >>conftest.$ac_ext <<_ACEOF
14912 /* end confdefs.h.  */
14913
14914 /* Override any gcc2 internal prototype to avoid an error.  */
14915 #ifdef __cplusplus
14916 extern "C"
14917 #endif
14918 /* We use char because int might match the return type of a gcc2
14919    builtin and then its argument prototype would still apply.  */
14920 char csinf ();
14921 int
14922 main ()
14923 {
14924 csinf ();
14925   ;
14926   return 0;
14927 }
14928 _ACEOF
14929 rm -f conftest.$ac_objext conftest$ac_exeext
14930 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14931   (eval $ac_link) 2>conftest.er1
14932   ac_status=$?
14933   grep -v '^ *+' conftest.er1 >conftest.err
14934   rm -f conftest.er1
14935   cat conftest.err >&5
14936   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14937   (exit $ac_status); } &&
14938          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
14939   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14940   (eval $ac_try) 2>&5
14941   ac_status=$?
14942   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14943   (exit $ac_status); }; } &&
14944          { ac_try='test -s conftest$ac_exeext'
14945   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14946   (eval $ac_try) 2>&5
14947   ac_status=$?
14948   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14949   (exit $ac_status); }; }; then
14950   ac_cv_lib_m_csinf=yes
14951 else
14952   echo "$as_me: failed program was:" >&5
14953 sed 's/^/| /' conftest.$ac_ext >&5
14954
14955 ac_cv_lib_m_csinf=no
14956 fi
14957 rm -f conftest.err conftest.$ac_objext \
14958       conftest$ac_exeext conftest.$ac_ext
14959 LIBS=$ac_check_lib_save_LIBS
14960 fi
14961 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinf" >&5
14962 echo "${ECHO_T}$ac_cv_lib_m_csinf" >&6
14963 if test $ac_cv_lib_m_csinf = yes; then
14964
14965 cat >>confdefs.h <<\_ACEOF
14966 #define HAVE_CSINF 1
14967 _ACEOF
14968
14969 fi
14970
14971 echo "$as_me:$LINENO: checking for csin in -lm" >&5
14972 echo $ECHO_N "checking for csin in -lm... $ECHO_C" >&6
14973 if test "${ac_cv_lib_m_csin+set}" = set; then
14974   echo $ECHO_N "(cached) $ECHO_C" >&6
14975 else
14976   ac_check_lib_save_LIBS=$LIBS
14977 LIBS="-lm  $LIBS"
14978 if test x$gcc_no_link = xyes; then
14979   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14980 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14981    { (exit 1); exit 1; }; }
14982 fi
14983 cat >conftest.$ac_ext <<_ACEOF
14984 /* confdefs.h.  */
14985 _ACEOF
14986 cat confdefs.h >>conftest.$ac_ext
14987 cat >>conftest.$ac_ext <<_ACEOF
14988 /* end confdefs.h.  */
14989
14990 /* Override any gcc2 internal prototype to avoid an error.  */
14991 #ifdef __cplusplus
14992 extern "C"
14993 #endif
14994 /* We use char because int might match the return type of a gcc2
14995    builtin and then its argument prototype would still apply.  */
14996 char csin ();
14997 int
14998 main ()
14999 {
15000 csin ();
15001   ;
15002   return 0;
15003 }
15004 _ACEOF
15005 rm -f conftest.$ac_objext conftest$ac_exeext
15006 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15007   (eval $ac_link) 2>conftest.er1
15008   ac_status=$?
15009   grep -v '^ *+' conftest.er1 >conftest.err
15010   rm -f conftest.er1
15011   cat conftest.err >&5
15012   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15013   (exit $ac_status); } &&
15014          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
15015   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15016   (eval $ac_try) 2>&5
15017   ac_status=$?
15018   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15019   (exit $ac_status); }; } &&
15020          { ac_try='test -s conftest$ac_exeext'
15021   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15022   (eval $ac_try) 2>&5
15023   ac_status=$?
15024   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15025   (exit $ac_status); }; }; then
15026   ac_cv_lib_m_csin=yes
15027 else
15028   echo "$as_me: failed program was:" >&5
15029 sed 's/^/| /' conftest.$ac_ext >&5
15030
15031 ac_cv_lib_m_csin=no
15032 fi
15033 rm -f conftest.err conftest.$ac_objext \
15034       conftest$ac_exeext conftest.$ac_ext
15035 LIBS=$ac_check_lib_save_LIBS
15036 fi
15037 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csin" >&5
15038 echo "${ECHO_T}$ac_cv_lib_m_csin" >&6
15039 if test $ac_cv_lib_m_csin = yes; then
15040
15041 cat >>confdefs.h <<\_ACEOF
15042 #define HAVE_CSIN 1
15043 _ACEOF
15044
15045 fi
15046
15047 echo "$as_me:$LINENO: checking for csinl in -lm" >&5
15048 echo $ECHO_N "checking for csinl in -lm... $ECHO_C" >&6
15049 if test "${ac_cv_lib_m_csinl+set}" = set; then
15050   echo $ECHO_N "(cached) $ECHO_C" >&6
15051 else
15052   ac_check_lib_save_LIBS=$LIBS
15053 LIBS="-lm  $LIBS"
15054 if test x$gcc_no_link = xyes; then
15055   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15056 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15057    { (exit 1); exit 1; }; }
15058 fi
15059 cat >conftest.$ac_ext <<_ACEOF
15060 /* confdefs.h.  */
15061 _ACEOF
15062 cat confdefs.h >>conftest.$ac_ext
15063 cat >>conftest.$ac_ext <<_ACEOF
15064 /* end confdefs.h.  */
15065
15066 /* Override any gcc2 internal prototype to avoid an error.  */
15067 #ifdef __cplusplus
15068 extern "C"
15069 #endif
15070 /* We use char because int might match the return type of a gcc2
15071    builtin and then its argument prototype would still apply.  */
15072 char csinl ();
15073 int
15074 main ()
15075 {
15076 csinl ();
15077   ;
15078   return 0;
15079 }
15080 _ACEOF
15081 rm -f conftest.$ac_objext conftest$ac_exeext
15082 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15083   (eval $ac_link) 2>conftest.er1
15084   ac_status=$?
15085   grep -v '^ *+' conftest.er1 >conftest.err
15086   rm -f conftest.er1
15087   cat conftest.err >&5
15088   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15089   (exit $ac_status); } &&
15090          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
15091   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15092   (eval $ac_try) 2>&5
15093   ac_status=$?
15094   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15095   (exit $ac_status); }; } &&
15096          { ac_try='test -s conftest$ac_exeext'
15097   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15098   (eval $ac_try) 2>&5
15099   ac_status=$?
15100   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15101   (exit $ac_status); }; }; then
15102   ac_cv_lib_m_csinl=yes
15103 else
15104   echo "$as_me: failed program was:" >&5
15105 sed 's/^/| /' conftest.$ac_ext >&5
15106
15107 ac_cv_lib_m_csinl=no
15108 fi
15109 rm -f conftest.err conftest.$ac_objext \
15110       conftest$ac_exeext conftest.$ac_ext
15111 LIBS=$ac_check_lib_save_LIBS
15112 fi
15113 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinl" >&5
15114 echo "${ECHO_T}$ac_cv_lib_m_csinl" >&6
15115 if test $ac_cv_lib_m_csinl = yes; then
15116
15117 cat >>confdefs.h <<\_ACEOF
15118 #define HAVE_CSINL 1
15119 _ACEOF
15120
15121 fi
15122
15123 echo "$as_me:$LINENO: checking for sinhf in -lm" >&5
15124 echo $ECHO_N "checking for sinhf in -lm... $ECHO_C" >&6
15125 if test "${ac_cv_lib_m_sinhf+set}" = set; then
15126   echo $ECHO_N "(cached) $ECHO_C" >&6
15127 else
15128   ac_check_lib_save_LIBS=$LIBS
15129 LIBS="-lm  $LIBS"
15130 if test x$gcc_no_link = xyes; then
15131   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15132 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15133    { (exit 1); exit 1; }; }
15134 fi
15135 cat >conftest.$ac_ext <<_ACEOF
15136 /* confdefs.h.  */
15137 _ACEOF
15138 cat confdefs.h >>conftest.$ac_ext
15139 cat >>conftest.$ac_ext <<_ACEOF
15140 /* end confdefs.h.  */
15141
15142 /* Override any gcc2 internal prototype to avoid an error.  */
15143 #ifdef __cplusplus
15144 extern "C"
15145 #endif
15146 /* We use char because int might match the return type of a gcc2
15147    builtin and then its argument prototype would still apply.  */
15148 char sinhf ();
15149 int
15150 main ()
15151 {
15152 sinhf ();
15153   ;
15154   return 0;
15155 }
15156 _ACEOF
15157 rm -f conftest.$ac_objext conftest$ac_exeext
15158 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15159   (eval $ac_link) 2>conftest.er1
15160   ac_status=$?
15161   grep -v '^ *+' conftest.er1 >conftest.err
15162   rm -f conftest.er1
15163   cat conftest.err >&5
15164   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15165   (exit $ac_status); } &&
15166          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
15167   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15168   (eval $ac_try) 2>&5
15169   ac_status=$?
15170   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15171   (exit $ac_status); }; } &&
15172          { ac_try='test -s conftest$ac_exeext'
15173   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15174   (eval $ac_try) 2>&5
15175   ac_status=$?
15176   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15177   (exit $ac_status); }; }; then
15178   ac_cv_lib_m_sinhf=yes
15179 else
15180   echo "$as_me: failed program was:" >&5
15181 sed 's/^/| /' conftest.$ac_ext >&5
15182
15183 ac_cv_lib_m_sinhf=no
15184 fi
15185 rm -f conftest.err conftest.$ac_objext \
15186       conftest$ac_exeext conftest.$ac_ext
15187 LIBS=$ac_check_lib_save_LIBS
15188 fi
15189 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinhf" >&5
15190 echo "${ECHO_T}$ac_cv_lib_m_sinhf" >&6
15191 if test $ac_cv_lib_m_sinhf = yes; then
15192
15193 cat >>confdefs.h <<\_ACEOF
15194 #define HAVE_SINHF 1
15195 _ACEOF
15196
15197 fi
15198
15199 echo "$as_me:$LINENO: checking for sinh in -lm" >&5
15200 echo $ECHO_N "checking for sinh in -lm... $ECHO_C" >&6
15201 if test "${ac_cv_lib_m_sinh+set}" = set; then
15202   echo $ECHO_N "(cached) $ECHO_C" >&6
15203 else
15204   ac_check_lib_save_LIBS=$LIBS
15205 LIBS="-lm  $LIBS"
15206 if test x$gcc_no_link = xyes; then
15207   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15208 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15209    { (exit 1); exit 1; }; }
15210 fi
15211 cat >conftest.$ac_ext <<_ACEOF
15212 /* confdefs.h.  */
15213 _ACEOF
15214 cat confdefs.h >>conftest.$ac_ext
15215 cat >>conftest.$ac_ext <<_ACEOF
15216 /* end confdefs.h.  */
15217
15218 /* Override any gcc2 internal prototype to avoid an error.  */
15219 #ifdef __cplusplus
15220 extern "C"
15221 #endif
15222 /* We use char because int might match the return type of a gcc2
15223    builtin and then its argument prototype would still apply.  */
15224 char sinh ();
15225 int
15226 main ()
15227 {
15228 sinh ();
15229   ;
15230   return 0;
15231 }
15232 _ACEOF
15233 rm -f conftest.$ac_objext conftest$ac_exeext
15234 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15235   (eval $ac_link) 2>conftest.er1
15236   ac_status=$?
15237   grep -v '^ *+' conftest.er1 >conftest.err
15238   rm -f conftest.er1
15239   cat conftest.err >&5
15240   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15241   (exit $ac_status); } &&
15242          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
15243   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15244   (eval $ac_try) 2>&5
15245   ac_status=$?
15246   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15247   (exit $ac_status); }; } &&
15248          { ac_try='test -s conftest$ac_exeext'
15249   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15250   (eval $ac_try) 2>&5
15251   ac_status=$?
15252   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15253   (exit $ac_status); }; }; then
15254   ac_cv_lib_m_sinh=yes
15255 else
15256   echo "$as_me: failed program was:" >&5
15257 sed 's/^/| /' conftest.$ac_ext >&5
15258
15259 ac_cv_lib_m_sinh=no
15260 fi
15261 rm -f conftest.err conftest.$ac_objext \
15262       conftest$ac_exeext conftest.$ac_ext
15263 LIBS=$ac_check_lib_save_LIBS
15264 fi
15265 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinh" >&5
15266 echo "${ECHO_T}$ac_cv_lib_m_sinh" >&6
15267 if test $ac_cv_lib_m_sinh = yes; then
15268
15269 cat >>confdefs.h <<\_ACEOF
15270 #define HAVE_SINH 1
15271 _ACEOF
15272
15273 fi
15274
15275 echo "$as_me:$LINENO: checking for sinhl in -lm" >&5
15276 echo $ECHO_N "checking for sinhl in -lm... $ECHO_C" >&6
15277 if test "${ac_cv_lib_m_sinhl+set}" = set; then
15278   echo $ECHO_N "(cached) $ECHO_C" >&6
15279 else
15280   ac_check_lib_save_LIBS=$LIBS
15281 LIBS="-lm  $LIBS"
15282 if test x$gcc_no_link = xyes; then
15283   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15284 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15285    { (exit 1); exit 1; }; }
15286 fi
15287 cat >conftest.$ac_ext <<_ACEOF
15288 /* confdefs.h.  */
15289 _ACEOF
15290 cat confdefs.h >>conftest.$ac_ext
15291 cat >>conftest.$ac_ext <<_ACEOF
15292 /* end confdefs.h.  */
15293
15294 /* Override any gcc2 internal prototype to avoid an error.  */
15295 #ifdef __cplusplus
15296 extern "C"
15297 #endif
15298 /* We use char because int might match the return type of a gcc2
15299    builtin and then its argument prototype would still apply.  */
15300 char sinhl ();
15301 int
15302 main ()
15303 {
15304 sinhl ();
15305   ;
15306   return 0;
15307 }
15308 _ACEOF
15309 rm -f conftest.$ac_objext conftest$ac_exeext
15310 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15311   (eval $ac_link) 2>conftest.er1
15312   ac_status=$?
15313   grep -v '^ *+' conftest.er1 >conftest.err
15314   rm -f conftest.er1
15315   cat conftest.err >&5
15316   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15317   (exit $ac_status); } &&
15318          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
15319   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15320   (eval $ac_try) 2>&5
15321   ac_status=$?
15322   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15323   (exit $ac_status); }; } &&
15324          { ac_try='test -s conftest$ac_exeext'
15325   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15326   (eval $ac_try) 2>&5
15327   ac_status=$?
15328   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15329   (exit $ac_status); }; }; then
15330   ac_cv_lib_m_sinhl=yes
15331 else
15332   echo "$as_me: failed program was:" >&5
15333 sed 's/^/| /' conftest.$ac_ext >&5
15334
15335 ac_cv_lib_m_sinhl=no
15336 fi
15337 rm -f conftest.err conftest.$ac_objext \
15338       conftest$ac_exeext conftest.$ac_ext
15339 LIBS=$ac_check_lib_save_LIBS
15340 fi
15341 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinhl" >&5
15342 echo "${ECHO_T}$ac_cv_lib_m_sinhl" >&6
15343 if test $ac_cv_lib_m_sinhl = yes; then
15344
15345 cat >>confdefs.h <<\_ACEOF
15346 #define HAVE_SINHL 1
15347 _ACEOF
15348
15349 fi
15350
15351 echo "$as_me:$LINENO: checking for csinhf in -lm" >&5
15352 echo $ECHO_N "checking for csinhf in -lm... $ECHO_C" >&6
15353 if test "${ac_cv_lib_m_csinhf+set}" = set; then
15354   echo $ECHO_N "(cached) $ECHO_C" >&6
15355 else
15356   ac_check_lib_save_LIBS=$LIBS
15357 LIBS="-lm  $LIBS"
15358 if test x$gcc_no_link = xyes; then
15359   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15360 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15361    { (exit 1); exit 1; }; }
15362 fi
15363 cat >conftest.$ac_ext <<_ACEOF
15364 /* confdefs.h.  */
15365 _ACEOF
15366 cat confdefs.h >>conftest.$ac_ext
15367 cat >>conftest.$ac_ext <<_ACEOF
15368 /* end confdefs.h.  */
15369
15370 /* Override any gcc2 internal prototype to avoid an error.  */
15371 #ifdef __cplusplus
15372 extern "C"
15373 #endif
15374 /* We use char because int might match the return type of a gcc2
15375    builtin and then its argument prototype would still apply.  */
15376 char csinhf ();
15377 int
15378 main ()
15379 {
15380 csinhf ();
15381   ;
15382   return 0;
15383 }
15384 _ACEOF
15385 rm -f conftest.$ac_objext conftest$ac_exeext
15386 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15387   (eval $ac_link) 2>conftest.er1
15388   ac_status=$?
15389   grep -v '^ *+' conftest.er1 >conftest.err
15390   rm -f conftest.er1
15391   cat conftest.err >&5
15392   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15393   (exit $ac_status); } &&
15394          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
15395   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15396   (eval $ac_try) 2>&5
15397   ac_status=$?
15398   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15399   (exit $ac_status); }; } &&
15400          { ac_try='test -s conftest$ac_exeext'
15401   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15402   (eval $ac_try) 2>&5
15403   ac_status=$?
15404   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15405   (exit $ac_status); }; }; then
15406   ac_cv_lib_m_csinhf=yes
15407 else
15408   echo "$as_me: failed program was:" >&5
15409 sed 's/^/| /' conftest.$ac_ext >&5
15410
15411 ac_cv_lib_m_csinhf=no
15412 fi
15413 rm -f conftest.err conftest.$ac_objext \
15414       conftest$ac_exeext conftest.$ac_ext
15415 LIBS=$ac_check_lib_save_LIBS
15416 fi
15417 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinhf" >&5
15418 echo "${ECHO_T}$ac_cv_lib_m_csinhf" >&6
15419 if test $ac_cv_lib_m_csinhf = yes; then
15420
15421 cat >>confdefs.h <<\_ACEOF
15422 #define HAVE_CSINHF 1
15423 _ACEOF
15424
15425 fi
15426
15427 echo "$as_me:$LINENO: checking for csinh in -lm" >&5
15428 echo $ECHO_N "checking for csinh in -lm... $ECHO_C" >&6
15429 if test "${ac_cv_lib_m_csinh+set}" = set; then
15430   echo $ECHO_N "(cached) $ECHO_C" >&6
15431 else
15432   ac_check_lib_save_LIBS=$LIBS
15433 LIBS="-lm  $LIBS"
15434 if test x$gcc_no_link = xyes; then
15435   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15436 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15437    { (exit 1); exit 1; }; }
15438 fi
15439 cat >conftest.$ac_ext <<_ACEOF
15440 /* confdefs.h.  */
15441 _ACEOF
15442 cat confdefs.h >>conftest.$ac_ext
15443 cat >>conftest.$ac_ext <<_ACEOF
15444 /* end confdefs.h.  */
15445
15446 /* Override any gcc2 internal prototype to avoid an error.  */
15447 #ifdef __cplusplus
15448 extern "C"
15449 #endif
15450 /* We use char because int might match the return type of a gcc2
15451    builtin and then its argument prototype would still apply.  */
15452 char csinh ();
15453 int
15454 main ()
15455 {
15456 csinh ();
15457   ;
15458   return 0;
15459 }
15460 _ACEOF
15461 rm -f conftest.$ac_objext conftest$ac_exeext
15462 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15463   (eval $ac_link) 2>conftest.er1
15464   ac_status=$?
15465   grep -v '^ *+' conftest.er1 >conftest.err
15466   rm -f conftest.er1
15467   cat conftest.err >&5
15468   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15469   (exit $ac_status); } &&
15470          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
15471   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15472   (eval $ac_try) 2>&5
15473   ac_status=$?
15474   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15475   (exit $ac_status); }; } &&
15476          { ac_try='test -s conftest$ac_exeext'
15477   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15478   (eval $ac_try) 2>&5
15479   ac_status=$?
15480   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15481   (exit $ac_status); }; }; then
15482   ac_cv_lib_m_csinh=yes
15483 else
15484   echo "$as_me: failed program was:" >&5
15485 sed 's/^/| /' conftest.$ac_ext >&5
15486
15487 ac_cv_lib_m_csinh=no
15488 fi
15489 rm -f conftest.err conftest.$ac_objext \
15490       conftest$ac_exeext conftest.$ac_ext
15491 LIBS=$ac_check_lib_save_LIBS
15492 fi
15493 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinh" >&5
15494 echo "${ECHO_T}$ac_cv_lib_m_csinh" >&6
15495 if test $ac_cv_lib_m_csinh = yes; then
15496
15497 cat >>confdefs.h <<\_ACEOF
15498 #define HAVE_CSINH 1
15499 _ACEOF
15500
15501 fi
15502
15503 echo "$as_me:$LINENO: checking for csinhl in -lm" >&5
15504 echo $ECHO_N "checking for csinhl in -lm... $ECHO_C" >&6
15505 if test "${ac_cv_lib_m_csinhl+set}" = set; then
15506   echo $ECHO_N "(cached) $ECHO_C" >&6
15507 else
15508   ac_check_lib_save_LIBS=$LIBS
15509 LIBS="-lm  $LIBS"
15510 if test x$gcc_no_link = xyes; then
15511   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15512 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15513    { (exit 1); exit 1; }; }
15514 fi
15515 cat >conftest.$ac_ext <<_ACEOF
15516 /* confdefs.h.  */
15517 _ACEOF
15518 cat confdefs.h >>conftest.$ac_ext
15519 cat >>conftest.$ac_ext <<_ACEOF
15520 /* end confdefs.h.  */
15521
15522 /* Override any gcc2 internal prototype to avoid an error.  */
15523 #ifdef __cplusplus
15524 extern "C"
15525 #endif
15526 /* We use char because int might match the return type of a gcc2
15527    builtin and then its argument prototype would still apply.  */
15528 char csinhl ();
15529 int
15530 main ()
15531 {
15532 csinhl ();
15533   ;
15534   return 0;
15535 }
15536 _ACEOF
15537 rm -f conftest.$ac_objext conftest$ac_exeext
15538 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15539   (eval $ac_link) 2>conftest.er1
15540   ac_status=$?
15541   grep -v '^ *+' conftest.er1 >conftest.err
15542   rm -f conftest.er1
15543   cat conftest.err >&5
15544   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15545   (exit $ac_status); } &&
15546          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
15547   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15548   (eval $ac_try) 2>&5
15549   ac_status=$?
15550   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15551   (exit $ac_status); }; } &&
15552          { ac_try='test -s conftest$ac_exeext'
15553   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15554   (eval $ac_try) 2>&5
15555   ac_status=$?
15556   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15557   (exit $ac_status); }; }; then
15558   ac_cv_lib_m_csinhl=yes
15559 else
15560   echo "$as_me: failed program was:" >&5
15561 sed 's/^/| /' conftest.$ac_ext >&5
15562
15563 ac_cv_lib_m_csinhl=no
15564 fi
15565 rm -f conftest.err conftest.$ac_objext \
15566       conftest$ac_exeext conftest.$ac_ext
15567 LIBS=$ac_check_lib_save_LIBS
15568 fi
15569 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinhl" >&5
15570 echo "${ECHO_T}$ac_cv_lib_m_csinhl" >&6
15571 if test $ac_cv_lib_m_csinhl = yes; then
15572
15573 cat >>confdefs.h <<\_ACEOF
15574 #define HAVE_CSINHL 1
15575 _ACEOF
15576
15577 fi
15578
15579 echo "$as_me:$LINENO: checking for sqrtf in -lm" >&5
15580 echo $ECHO_N "checking for sqrtf in -lm... $ECHO_C" >&6
15581 if test "${ac_cv_lib_m_sqrtf+set}" = set; then
15582   echo $ECHO_N "(cached) $ECHO_C" >&6
15583 else
15584   ac_check_lib_save_LIBS=$LIBS
15585 LIBS="-lm  $LIBS"
15586 if test x$gcc_no_link = xyes; then
15587   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15588 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15589    { (exit 1); exit 1; }; }
15590 fi
15591 cat >conftest.$ac_ext <<_ACEOF
15592 /* confdefs.h.  */
15593 _ACEOF
15594 cat confdefs.h >>conftest.$ac_ext
15595 cat >>conftest.$ac_ext <<_ACEOF
15596 /* end confdefs.h.  */
15597
15598 /* Override any gcc2 internal prototype to avoid an error.  */
15599 #ifdef __cplusplus
15600 extern "C"
15601 #endif
15602 /* We use char because int might match the return type of a gcc2
15603    builtin and then its argument prototype would still apply.  */
15604 char sqrtf ();
15605 int
15606 main ()
15607 {
15608 sqrtf ();
15609   ;
15610   return 0;
15611 }
15612 _ACEOF
15613 rm -f conftest.$ac_objext conftest$ac_exeext
15614 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15615   (eval $ac_link) 2>conftest.er1
15616   ac_status=$?
15617   grep -v '^ *+' conftest.er1 >conftest.err
15618   rm -f conftest.er1
15619   cat conftest.err >&5
15620   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15621   (exit $ac_status); } &&
15622          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
15623   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15624   (eval $ac_try) 2>&5
15625   ac_status=$?
15626   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15627   (exit $ac_status); }; } &&
15628          { ac_try='test -s conftest$ac_exeext'
15629   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15630   (eval $ac_try) 2>&5
15631   ac_status=$?
15632   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15633   (exit $ac_status); }; }; then
15634   ac_cv_lib_m_sqrtf=yes
15635 else
15636   echo "$as_me: failed program was:" >&5
15637 sed 's/^/| /' conftest.$ac_ext >&5
15638
15639 ac_cv_lib_m_sqrtf=no
15640 fi
15641 rm -f conftest.err conftest.$ac_objext \
15642       conftest$ac_exeext conftest.$ac_ext
15643 LIBS=$ac_check_lib_save_LIBS
15644 fi
15645 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrtf" >&5
15646 echo "${ECHO_T}$ac_cv_lib_m_sqrtf" >&6
15647 if test $ac_cv_lib_m_sqrtf = yes; then
15648
15649 cat >>confdefs.h <<\_ACEOF
15650 #define HAVE_SQRTF 1
15651 _ACEOF
15652
15653 fi
15654
15655 echo "$as_me:$LINENO: checking for sqrt in -lm" >&5
15656 echo $ECHO_N "checking for sqrt in -lm... $ECHO_C" >&6
15657 if test "${ac_cv_lib_m_sqrt+set}" = set; then
15658   echo $ECHO_N "(cached) $ECHO_C" >&6
15659 else
15660   ac_check_lib_save_LIBS=$LIBS
15661 LIBS="-lm  $LIBS"
15662 if test x$gcc_no_link = xyes; then
15663   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15664 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15665    { (exit 1); exit 1; }; }
15666 fi
15667 cat >conftest.$ac_ext <<_ACEOF
15668 /* confdefs.h.  */
15669 _ACEOF
15670 cat confdefs.h >>conftest.$ac_ext
15671 cat >>conftest.$ac_ext <<_ACEOF
15672 /* end confdefs.h.  */
15673
15674 /* Override any gcc2 internal prototype to avoid an error.  */
15675 #ifdef __cplusplus
15676 extern "C"
15677 #endif
15678 /* We use char because int might match the return type of a gcc2
15679    builtin and then its argument prototype would still apply.  */
15680 char sqrt ();
15681 int
15682 main ()
15683 {
15684 sqrt ();
15685   ;
15686   return 0;
15687 }
15688 _ACEOF
15689 rm -f conftest.$ac_objext conftest$ac_exeext
15690 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15691   (eval $ac_link) 2>conftest.er1
15692   ac_status=$?
15693   grep -v '^ *+' conftest.er1 >conftest.err
15694   rm -f conftest.er1
15695   cat conftest.err >&5
15696   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15697   (exit $ac_status); } &&
15698          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
15699   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15700   (eval $ac_try) 2>&5
15701   ac_status=$?
15702   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15703   (exit $ac_status); }; } &&
15704          { ac_try='test -s conftest$ac_exeext'
15705   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15706   (eval $ac_try) 2>&5
15707   ac_status=$?
15708   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15709   (exit $ac_status); }; }; then
15710   ac_cv_lib_m_sqrt=yes
15711 else
15712   echo "$as_me: failed program was:" >&5
15713 sed 's/^/| /' conftest.$ac_ext >&5
15714
15715 ac_cv_lib_m_sqrt=no
15716 fi
15717 rm -f conftest.err conftest.$ac_objext \
15718       conftest$ac_exeext conftest.$ac_ext
15719 LIBS=$ac_check_lib_save_LIBS
15720 fi
15721 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrt" >&5
15722 echo "${ECHO_T}$ac_cv_lib_m_sqrt" >&6
15723 if test $ac_cv_lib_m_sqrt = yes; then
15724
15725 cat >>confdefs.h <<\_ACEOF
15726 #define HAVE_SQRT 1
15727 _ACEOF
15728
15729 fi
15730
15731 echo "$as_me:$LINENO: checking for sqrtl in -lm" >&5
15732 echo $ECHO_N "checking for sqrtl in -lm... $ECHO_C" >&6
15733 if test "${ac_cv_lib_m_sqrtl+set}" = set; then
15734   echo $ECHO_N "(cached) $ECHO_C" >&6
15735 else
15736   ac_check_lib_save_LIBS=$LIBS
15737 LIBS="-lm  $LIBS"
15738 if test x$gcc_no_link = xyes; then
15739   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15740 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15741    { (exit 1); exit 1; }; }
15742 fi
15743 cat >conftest.$ac_ext <<_ACEOF
15744 /* confdefs.h.  */
15745 _ACEOF
15746 cat confdefs.h >>conftest.$ac_ext
15747 cat >>conftest.$ac_ext <<_ACEOF
15748 /* end confdefs.h.  */
15749
15750 /* Override any gcc2 internal prototype to avoid an error.  */
15751 #ifdef __cplusplus
15752 extern "C"
15753 #endif
15754 /* We use char because int might match the return type of a gcc2
15755    builtin and then its argument prototype would still apply.  */
15756 char sqrtl ();
15757 int
15758 main ()
15759 {
15760 sqrtl ();
15761   ;
15762   return 0;
15763 }
15764 _ACEOF
15765 rm -f conftest.$ac_objext conftest$ac_exeext
15766 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15767   (eval $ac_link) 2>conftest.er1
15768   ac_status=$?
15769   grep -v '^ *+' conftest.er1 >conftest.err
15770   rm -f conftest.er1
15771   cat conftest.err >&5
15772   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15773   (exit $ac_status); } &&
15774          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
15775   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15776   (eval $ac_try) 2>&5
15777   ac_status=$?
15778   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15779   (exit $ac_status); }; } &&
15780          { ac_try='test -s conftest$ac_exeext'
15781   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15782   (eval $ac_try) 2>&5
15783   ac_status=$?
15784   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15785   (exit $ac_status); }; }; then
15786   ac_cv_lib_m_sqrtl=yes
15787 else
15788   echo "$as_me: failed program was:" >&5
15789 sed 's/^/| /' conftest.$ac_ext >&5
15790
15791 ac_cv_lib_m_sqrtl=no
15792 fi
15793 rm -f conftest.err conftest.$ac_objext \
15794       conftest$ac_exeext conftest.$ac_ext
15795 LIBS=$ac_check_lib_save_LIBS
15796 fi
15797 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrtl" >&5
15798 echo "${ECHO_T}$ac_cv_lib_m_sqrtl" >&6
15799 if test $ac_cv_lib_m_sqrtl = yes; then
15800
15801 cat >>confdefs.h <<\_ACEOF
15802 #define HAVE_SQRTL 1
15803 _ACEOF
15804
15805 fi
15806
15807 echo "$as_me:$LINENO: checking for csqrtf in -lm" >&5
15808 echo $ECHO_N "checking for csqrtf in -lm... $ECHO_C" >&6
15809 if test "${ac_cv_lib_m_csqrtf+set}" = set; then
15810   echo $ECHO_N "(cached) $ECHO_C" >&6
15811 else
15812   ac_check_lib_save_LIBS=$LIBS
15813 LIBS="-lm  $LIBS"
15814 if test x$gcc_no_link = xyes; then
15815   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15816 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15817    { (exit 1); exit 1; }; }
15818 fi
15819 cat >conftest.$ac_ext <<_ACEOF
15820 /* confdefs.h.  */
15821 _ACEOF
15822 cat confdefs.h >>conftest.$ac_ext
15823 cat >>conftest.$ac_ext <<_ACEOF
15824 /* end confdefs.h.  */
15825
15826 /* Override any gcc2 internal prototype to avoid an error.  */
15827 #ifdef __cplusplus
15828 extern "C"
15829 #endif
15830 /* We use char because int might match the return type of a gcc2
15831    builtin and then its argument prototype would still apply.  */
15832 char csqrtf ();
15833 int
15834 main ()
15835 {
15836 csqrtf ();
15837   ;
15838   return 0;
15839 }
15840 _ACEOF
15841 rm -f conftest.$ac_objext conftest$ac_exeext
15842 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15843   (eval $ac_link) 2>conftest.er1
15844   ac_status=$?
15845   grep -v '^ *+' conftest.er1 >conftest.err
15846   rm -f conftest.er1
15847   cat conftest.err >&5
15848   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15849   (exit $ac_status); } &&
15850          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
15851   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15852   (eval $ac_try) 2>&5
15853   ac_status=$?
15854   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15855   (exit $ac_status); }; } &&
15856          { ac_try='test -s conftest$ac_exeext'
15857   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15858   (eval $ac_try) 2>&5
15859   ac_status=$?
15860   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15861   (exit $ac_status); }; }; then
15862   ac_cv_lib_m_csqrtf=yes
15863 else
15864   echo "$as_me: failed program was:" >&5
15865 sed 's/^/| /' conftest.$ac_ext >&5
15866
15867 ac_cv_lib_m_csqrtf=no
15868 fi
15869 rm -f conftest.err conftest.$ac_objext \
15870       conftest$ac_exeext conftest.$ac_ext
15871 LIBS=$ac_check_lib_save_LIBS
15872 fi
15873 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrtf" >&5
15874 echo "${ECHO_T}$ac_cv_lib_m_csqrtf" >&6
15875 if test $ac_cv_lib_m_csqrtf = yes; then
15876
15877 cat >>confdefs.h <<\_ACEOF
15878 #define HAVE_CSQRTF 1
15879 _ACEOF
15880
15881 fi
15882
15883 echo "$as_me:$LINENO: checking for csqrt in -lm" >&5
15884 echo $ECHO_N "checking for csqrt in -lm... $ECHO_C" >&6
15885 if test "${ac_cv_lib_m_csqrt+set}" = set; then
15886   echo $ECHO_N "(cached) $ECHO_C" >&6
15887 else
15888   ac_check_lib_save_LIBS=$LIBS
15889 LIBS="-lm  $LIBS"
15890 if test x$gcc_no_link = xyes; then
15891   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15892 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15893    { (exit 1); exit 1; }; }
15894 fi
15895 cat >conftest.$ac_ext <<_ACEOF
15896 /* confdefs.h.  */
15897 _ACEOF
15898 cat confdefs.h >>conftest.$ac_ext
15899 cat >>conftest.$ac_ext <<_ACEOF
15900 /* end confdefs.h.  */
15901
15902 /* Override any gcc2 internal prototype to avoid an error.  */
15903 #ifdef __cplusplus
15904 extern "C"
15905 #endif
15906 /* We use char because int might match the return type of a gcc2
15907    builtin and then its argument prototype would still apply.  */
15908 char csqrt ();
15909 int
15910 main ()
15911 {
15912 csqrt ();
15913   ;
15914   return 0;
15915 }
15916 _ACEOF
15917 rm -f conftest.$ac_objext conftest$ac_exeext
15918 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15919   (eval $ac_link) 2>conftest.er1
15920   ac_status=$?
15921   grep -v '^ *+' conftest.er1 >conftest.err
15922   rm -f conftest.er1
15923   cat conftest.err >&5
15924   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15925   (exit $ac_status); } &&
15926          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
15927   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15928   (eval $ac_try) 2>&5
15929   ac_status=$?
15930   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15931   (exit $ac_status); }; } &&
15932          { ac_try='test -s conftest$ac_exeext'
15933   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15934   (eval $ac_try) 2>&5
15935   ac_status=$?
15936   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15937   (exit $ac_status); }; }; then
15938   ac_cv_lib_m_csqrt=yes
15939 else
15940   echo "$as_me: failed program was:" >&5
15941 sed 's/^/| /' conftest.$ac_ext >&5
15942
15943 ac_cv_lib_m_csqrt=no
15944 fi
15945 rm -f conftest.err conftest.$ac_objext \
15946       conftest$ac_exeext conftest.$ac_ext
15947 LIBS=$ac_check_lib_save_LIBS
15948 fi
15949 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrt" >&5
15950 echo "${ECHO_T}$ac_cv_lib_m_csqrt" >&6
15951 if test $ac_cv_lib_m_csqrt = yes; then
15952
15953 cat >>confdefs.h <<\_ACEOF
15954 #define HAVE_CSQRT 1
15955 _ACEOF
15956
15957 fi
15958
15959 echo "$as_me:$LINENO: checking for csqrtl in -lm" >&5
15960 echo $ECHO_N "checking for csqrtl in -lm... $ECHO_C" >&6
15961 if test "${ac_cv_lib_m_csqrtl+set}" = set; then
15962   echo $ECHO_N "(cached) $ECHO_C" >&6
15963 else
15964   ac_check_lib_save_LIBS=$LIBS
15965 LIBS="-lm  $LIBS"
15966 if test x$gcc_no_link = xyes; then
15967   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15968 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15969    { (exit 1); exit 1; }; }
15970 fi
15971 cat >conftest.$ac_ext <<_ACEOF
15972 /* confdefs.h.  */
15973 _ACEOF
15974 cat confdefs.h >>conftest.$ac_ext
15975 cat >>conftest.$ac_ext <<_ACEOF
15976 /* end confdefs.h.  */
15977
15978 /* Override any gcc2 internal prototype to avoid an error.  */
15979 #ifdef __cplusplus
15980 extern "C"
15981 #endif
15982 /* We use char because int might match the return type of a gcc2
15983    builtin and then its argument prototype would still apply.  */
15984 char csqrtl ();
15985 int
15986 main ()
15987 {
15988 csqrtl ();
15989   ;
15990   return 0;
15991 }
15992 _ACEOF
15993 rm -f conftest.$ac_objext conftest$ac_exeext
15994 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15995   (eval $ac_link) 2>conftest.er1
15996   ac_status=$?
15997   grep -v '^ *+' conftest.er1 >conftest.err
15998   rm -f conftest.er1
15999   cat conftest.err >&5
16000   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16001   (exit $ac_status); } &&
16002          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
16003   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16004   (eval $ac_try) 2>&5
16005   ac_status=$?
16006   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16007   (exit $ac_status); }; } &&
16008          { ac_try='test -s conftest$ac_exeext'
16009   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16010   (eval $ac_try) 2>&5
16011   ac_status=$?
16012   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16013   (exit $ac_status); }; }; then
16014   ac_cv_lib_m_csqrtl=yes
16015 else
16016   echo "$as_me: failed program was:" >&5
16017 sed 's/^/| /' conftest.$ac_ext >&5
16018
16019 ac_cv_lib_m_csqrtl=no
16020 fi
16021 rm -f conftest.err conftest.$ac_objext \
16022       conftest$ac_exeext conftest.$ac_ext
16023 LIBS=$ac_check_lib_save_LIBS
16024 fi
16025 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrtl" >&5
16026 echo "${ECHO_T}$ac_cv_lib_m_csqrtl" >&6
16027 if test $ac_cv_lib_m_csqrtl = yes; then
16028
16029 cat >>confdefs.h <<\_ACEOF
16030 #define HAVE_CSQRTL 1
16031 _ACEOF
16032
16033 fi
16034
16035 echo "$as_me:$LINENO: checking for tanf in -lm" >&5
16036 echo $ECHO_N "checking for tanf in -lm... $ECHO_C" >&6
16037 if test "${ac_cv_lib_m_tanf+set}" = set; then
16038   echo $ECHO_N "(cached) $ECHO_C" >&6
16039 else
16040   ac_check_lib_save_LIBS=$LIBS
16041 LIBS="-lm  $LIBS"
16042 if test x$gcc_no_link = xyes; then
16043   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16044 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16045    { (exit 1); exit 1; }; }
16046 fi
16047 cat >conftest.$ac_ext <<_ACEOF
16048 /* confdefs.h.  */
16049 _ACEOF
16050 cat confdefs.h >>conftest.$ac_ext
16051 cat >>conftest.$ac_ext <<_ACEOF
16052 /* end confdefs.h.  */
16053
16054 /* Override any gcc2 internal prototype to avoid an error.  */
16055 #ifdef __cplusplus
16056 extern "C"
16057 #endif
16058 /* We use char because int might match the return type of a gcc2
16059    builtin and then its argument prototype would still apply.  */
16060 char tanf ();
16061 int
16062 main ()
16063 {
16064 tanf ();
16065   ;
16066   return 0;
16067 }
16068 _ACEOF
16069 rm -f conftest.$ac_objext conftest$ac_exeext
16070 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16071   (eval $ac_link) 2>conftest.er1
16072   ac_status=$?
16073   grep -v '^ *+' conftest.er1 >conftest.err
16074   rm -f conftest.er1
16075   cat conftest.err >&5
16076   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16077   (exit $ac_status); } &&
16078          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
16079   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16080   (eval $ac_try) 2>&5
16081   ac_status=$?
16082   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16083   (exit $ac_status); }; } &&
16084          { ac_try='test -s conftest$ac_exeext'
16085   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16086   (eval $ac_try) 2>&5
16087   ac_status=$?
16088   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16089   (exit $ac_status); }; }; then
16090   ac_cv_lib_m_tanf=yes
16091 else
16092   echo "$as_me: failed program was:" >&5
16093 sed 's/^/| /' conftest.$ac_ext >&5
16094
16095 ac_cv_lib_m_tanf=no
16096 fi
16097 rm -f conftest.err conftest.$ac_objext \
16098       conftest$ac_exeext conftest.$ac_ext
16099 LIBS=$ac_check_lib_save_LIBS
16100 fi
16101 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanf" >&5
16102 echo "${ECHO_T}$ac_cv_lib_m_tanf" >&6
16103 if test $ac_cv_lib_m_tanf = yes; then
16104
16105 cat >>confdefs.h <<\_ACEOF
16106 #define HAVE_TANF 1
16107 _ACEOF
16108
16109 fi
16110
16111 echo "$as_me:$LINENO: checking for tan in -lm" >&5
16112 echo $ECHO_N "checking for tan in -lm... $ECHO_C" >&6
16113 if test "${ac_cv_lib_m_tan+set}" = set; then
16114   echo $ECHO_N "(cached) $ECHO_C" >&6
16115 else
16116   ac_check_lib_save_LIBS=$LIBS
16117 LIBS="-lm  $LIBS"
16118 if test x$gcc_no_link = xyes; then
16119   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16120 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16121    { (exit 1); exit 1; }; }
16122 fi
16123 cat >conftest.$ac_ext <<_ACEOF
16124 /* confdefs.h.  */
16125 _ACEOF
16126 cat confdefs.h >>conftest.$ac_ext
16127 cat >>conftest.$ac_ext <<_ACEOF
16128 /* end confdefs.h.  */
16129
16130 /* Override any gcc2 internal prototype to avoid an error.  */
16131 #ifdef __cplusplus
16132 extern "C"
16133 #endif
16134 /* We use char because int might match the return type of a gcc2
16135    builtin and then its argument prototype would still apply.  */
16136 char tan ();
16137 int
16138 main ()
16139 {
16140 tan ();
16141   ;
16142   return 0;
16143 }
16144 _ACEOF
16145 rm -f conftest.$ac_objext conftest$ac_exeext
16146 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16147   (eval $ac_link) 2>conftest.er1
16148   ac_status=$?
16149   grep -v '^ *+' conftest.er1 >conftest.err
16150   rm -f conftest.er1
16151   cat conftest.err >&5
16152   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16153   (exit $ac_status); } &&
16154          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
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); }; } &&
16160          { ac_try='test -s conftest$ac_exeext'
16161   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16162   (eval $ac_try) 2>&5
16163   ac_status=$?
16164   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16165   (exit $ac_status); }; }; then
16166   ac_cv_lib_m_tan=yes
16167 else
16168   echo "$as_me: failed program was:" >&5
16169 sed 's/^/| /' conftest.$ac_ext >&5
16170
16171 ac_cv_lib_m_tan=no
16172 fi
16173 rm -f conftest.err conftest.$ac_objext \
16174       conftest$ac_exeext conftest.$ac_ext
16175 LIBS=$ac_check_lib_save_LIBS
16176 fi
16177 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tan" >&5
16178 echo "${ECHO_T}$ac_cv_lib_m_tan" >&6
16179 if test $ac_cv_lib_m_tan = yes; then
16180
16181 cat >>confdefs.h <<\_ACEOF
16182 #define HAVE_TAN 1
16183 _ACEOF
16184
16185 fi
16186
16187 echo "$as_me:$LINENO: checking for tanl in -lm" >&5
16188 echo $ECHO_N "checking for tanl in -lm... $ECHO_C" >&6
16189 if test "${ac_cv_lib_m_tanl+set}" = set; then
16190   echo $ECHO_N "(cached) $ECHO_C" >&6
16191 else
16192   ac_check_lib_save_LIBS=$LIBS
16193 LIBS="-lm  $LIBS"
16194 if test x$gcc_no_link = xyes; then
16195   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16196 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16197    { (exit 1); exit 1; }; }
16198 fi
16199 cat >conftest.$ac_ext <<_ACEOF
16200 /* confdefs.h.  */
16201 _ACEOF
16202 cat confdefs.h >>conftest.$ac_ext
16203 cat >>conftest.$ac_ext <<_ACEOF
16204 /* end confdefs.h.  */
16205
16206 /* Override any gcc2 internal prototype to avoid an error.  */
16207 #ifdef __cplusplus
16208 extern "C"
16209 #endif
16210 /* We use char because int might match the return type of a gcc2
16211    builtin and then its argument prototype would still apply.  */
16212 char tanl ();
16213 int
16214 main ()
16215 {
16216 tanl ();
16217   ;
16218   return 0;
16219 }
16220 _ACEOF
16221 rm -f conftest.$ac_objext conftest$ac_exeext
16222 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16223   (eval $ac_link) 2>conftest.er1
16224   ac_status=$?
16225   grep -v '^ *+' conftest.er1 >conftest.err
16226   rm -f conftest.er1
16227   cat conftest.err >&5
16228   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16229   (exit $ac_status); } &&
16230          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
16231   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16232   (eval $ac_try) 2>&5
16233   ac_status=$?
16234   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16235   (exit $ac_status); }; } &&
16236          { ac_try='test -s conftest$ac_exeext'
16237   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16238   (eval $ac_try) 2>&5
16239   ac_status=$?
16240   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16241   (exit $ac_status); }; }; then
16242   ac_cv_lib_m_tanl=yes
16243 else
16244   echo "$as_me: failed program was:" >&5
16245 sed 's/^/| /' conftest.$ac_ext >&5
16246
16247 ac_cv_lib_m_tanl=no
16248 fi
16249 rm -f conftest.err conftest.$ac_objext \
16250       conftest$ac_exeext conftest.$ac_ext
16251 LIBS=$ac_check_lib_save_LIBS
16252 fi
16253 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanl" >&5
16254 echo "${ECHO_T}$ac_cv_lib_m_tanl" >&6
16255 if test $ac_cv_lib_m_tanl = yes; then
16256
16257 cat >>confdefs.h <<\_ACEOF
16258 #define HAVE_TANL 1
16259 _ACEOF
16260
16261 fi
16262
16263 echo "$as_me:$LINENO: checking for ctanf in -lm" >&5
16264 echo $ECHO_N "checking for ctanf in -lm... $ECHO_C" >&6
16265 if test "${ac_cv_lib_m_ctanf+set}" = set; then
16266   echo $ECHO_N "(cached) $ECHO_C" >&6
16267 else
16268   ac_check_lib_save_LIBS=$LIBS
16269 LIBS="-lm  $LIBS"
16270 if test x$gcc_no_link = xyes; then
16271   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16272 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16273    { (exit 1); exit 1; }; }
16274 fi
16275 cat >conftest.$ac_ext <<_ACEOF
16276 /* confdefs.h.  */
16277 _ACEOF
16278 cat confdefs.h >>conftest.$ac_ext
16279 cat >>conftest.$ac_ext <<_ACEOF
16280 /* end confdefs.h.  */
16281
16282 /* Override any gcc2 internal prototype to avoid an error.  */
16283 #ifdef __cplusplus
16284 extern "C"
16285 #endif
16286 /* We use char because int might match the return type of a gcc2
16287    builtin and then its argument prototype would still apply.  */
16288 char ctanf ();
16289 int
16290 main ()
16291 {
16292 ctanf ();
16293   ;
16294   return 0;
16295 }
16296 _ACEOF
16297 rm -f conftest.$ac_objext conftest$ac_exeext
16298 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16299   (eval $ac_link) 2>conftest.er1
16300   ac_status=$?
16301   grep -v '^ *+' conftest.er1 >conftest.err
16302   rm -f conftest.er1
16303   cat conftest.err >&5
16304   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16305   (exit $ac_status); } &&
16306          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
16307   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16308   (eval $ac_try) 2>&5
16309   ac_status=$?
16310   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16311   (exit $ac_status); }; } &&
16312          { ac_try='test -s conftest$ac_exeext'
16313   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16314   (eval $ac_try) 2>&5
16315   ac_status=$?
16316   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16317   (exit $ac_status); }; }; then
16318   ac_cv_lib_m_ctanf=yes
16319 else
16320   echo "$as_me: failed program was:" >&5
16321 sed 's/^/| /' conftest.$ac_ext >&5
16322
16323 ac_cv_lib_m_ctanf=no
16324 fi
16325 rm -f conftest.err conftest.$ac_objext \
16326       conftest$ac_exeext conftest.$ac_ext
16327 LIBS=$ac_check_lib_save_LIBS
16328 fi
16329 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanf" >&5
16330 echo "${ECHO_T}$ac_cv_lib_m_ctanf" >&6
16331 if test $ac_cv_lib_m_ctanf = yes; then
16332
16333 cat >>confdefs.h <<\_ACEOF
16334 #define HAVE_CTANF 1
16335 _ACEOF
16336
16337 fi
16338
16339 echo "$as_me:$LINENO: checking for ctan in -lm" >&5
16340 echo $ECHO_N "checking for ctan in -lm... $ECHO_C" >&6
16341 if test "${ac_cv_lib_m_ctan+set}" = set; then
16342   echo $ECHO_N "(cached) $ECHO_C" >&6
16343 else
16344   ac_check_lib_save_LIBS=$LIBS
16345 LIBS="-lm  $LIBS"
16346 if test x$gcc_no_link = xyes; then
16347   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16348 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16349    { (exit 1); exit 1; }; }
16350 fi
16351 cat >conftest.$ac_ext <<_ACEOF
16352 /* confdefs.h.  */
16353 _ACEOF
16354 cat confdefs.h >>conftest.$ac_ext
16355 cat >>conftest.$ac_ext <<_ACEOF
16356 /* end confdefs.h.  */
16357
16358 /* Override any gcc2 internal prototype to avoid an error.  */
16359 #ifdef __cplusplus
16360 extern "C"
16361 #endif
16362 /* We use char because int might match the return type of a gcc2
16363    builtin and then its argument prototype would still apply.  */
16364 char ctan ();
16365 int
16366 main ()
16367 {
16368 ctan ();
16369   ;
16370   return 0;
16371 }
16372 _ACEOF
16373 rm -f conftest.$ac_objext conftest$ac_exeext
16374 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16375   (eval $ac_link) 2>conftest.er1
16376   ac_status=$?
16377   grep -v '^ *+' conftest.er1 >conftest.err
16378   rm -f conftest.er1
16379   cat conftest.err >&5
16380   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16381   (exit $ac_status); } &&
16382          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
16383   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16384   (eval $ac_try) 2>&5
16385   ac_status=$?
16386   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16387   (exit $ac_status); }; } &&
16388          { ac_try='test -s conftest$ac_exeext'
16389   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16390   (eval $ac_try) 2>&5
16391   ac_status=$?
16392   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16393   (exit $ac_status); }; }; then
16394   ac_cv_lib_m_ctan=yes
16395 else
16396   echo "$as_me: failed program was:" >&5
16397 sed 's/^/| /' conftest.$ac_ext >&5
16398
16399 ac_cv_lib_m_ctan=no
16400 fi
16401 rm -f conftest.err conftest.$ac_objext \
16402       conftest$ac_exeext conftest.$ac_ext
16403 LIBS=$ac_check_lib_save_LIBS
16404 fi
16405 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctan" >&5
16406 echo "${ECHO_T}$ac_cv_lib_m_ctan" >&6
16407 if test $ac_cv_lib_m_ctan = yes; then
16408
16409 cat >>confdefs.h <<\_ACEOF
16410 #define HAVE_CTAN 1
16411 _ACEOF
16412
16413 fi
16414
16415 echo "$as_me:$LINENO: checking for ctanl in -lm" >&5
16416 echo $ECHO_N "checking for ctanl in -lm... $ECHO_C" >&6
16417 if test "${ac_cv_lib_m_ctanl+set}" = set; then
16418   echo $ECHO_N "(cached) $ECHO_C" >&6
16419 else
16420   ac_check_lib_save_LIBS=$LIBS
16421 LIBS="-lm  $LIBS"
16422 if test x$gcc_no_link = xyes; then
16423   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16424 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16425    { (exit 1); exit 1; }; }
16426 fi
16427 cat >conftest.$ac_ext <<_ACEOF
16428 /* confdefs.h.  */
16429 _ACEOF
16430 cat confdefs.h >>conftest.$ac_ext
16431 cat >>conftest.$ac_ext <<_ACEOF
16432 /* end confdefs.h.  */
16433
16434 /* Override any gcc2 internal prototype to avoid an error.  */
16435 #ifdef __cplusplus
16436 extern "C"
16437 #endif
16438 /* We use char because int might match the return type of a gcc2
16439    builtin and then its argument prototype would still apply.  */
16440 char ctanl ();
16441 int
16442 main ()
16443 {
16444 ctanl ();
16445   ;
16446   return 0;
16447 }
16448 _ACEOF
16449 rm -f conftest.$ac_objext conftest$ac_exeext
16450 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16451   (eval $ac_link) 2>conftest.er1
16452   ac_status=$?
16453   grep -v '^ *+' conftest.er1 >conftest.err
16454   rm -f conftest.er1
16455   cat conftest.err >&5
16456   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16457   (exit $ac_status); } &&
16458          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
16459   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16460   (eval $ac_try) 2>&5
16461   ac_status=$?
16462   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16463   (exit $ac_status); }; } &&
16464          { ac_try='test -s conftest$ac_exeext'
16465   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16466   (eval $ac_try) 2>&5
16467   ac_status=$?
16468   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16469   (exit $ac_status); }; }; then
16470   ac_cv_lib_m_ctanl=yes
16471 else
16472   echo "$as_me: failed program was:" >&5
16473 sed 's/^/| /' conftest.$ac_ext >&5
16474
16475 ac_cv_lib_m_ctanl=no
16476 fi
16477 rm -f conftest.err conftest.$ac_objext \
16478       conftest$ac_exeext conftest.$ac_ext
16479 LIBS=$ac_check_lib_save_LIBS
16480 fi
16481 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanl" >&5
16482 echo "${ECHO_T}$ac_cv_lib_m_ctanl" >&6
16483 if test $ac_cv_lib_m_ctanl = yes; then
16484
16485 cat >>confdefs.h <<\_ACEOF
16486 #define HAVE_CTANL 1
16487 _ACEOF
16488
16489 fi
16490
16491 echo "$as_me:$LINENO: checking for tanhf in -lm" >&5
16492 echo $ECHO_N "checking for tanhf in -lm... $ECHO_C" >&6
16493 if test "${ac_cv_lib_m_tanhf+set}" = set; then
16494   echo $ECHO_N "(cached) $ECHO_C" >&6
16495 else
16496   ac_check_lib_save_LIBS=$LIBS
16497 LIBS="-lm  $LIBS"
16498 if test x$gcc_no_link = xyes; then
16499   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16500 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16501    { (exit 1); exit 1; }; }
16502 fi
16503 cat >conftest.$ac_ext <<_ACEOF
16504 /* confdefs.h.  */
16505 _ACEOF
16506 cat confdefs.h >>conftest.$ac_ext
16507 cat >>conftest.$ac_ext <<_ACEOF
16508 /* end confdefs.h.  */
16509
16510 /* Override any gcc2 internal prototype to avoid an error.  */
16511 #ifdef __cplusplus
16512 extern "C"
16513 #endif
16514 /* We use char because int might match the return type of a gcc2
16515    builtin and then its argument prototype would still apply.  */
16516 char tanhf ();
16517 int
16518 main ()
16519 {
16520 tanhf ();
16521   ;
16522   return 0;
16523 }
16524 _ACEOF
16525 rm -f conftest.$ac_objext conftest$ac_exeext
16526 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16527   (eval $ac_link) 2>conftest.er1
16528   ac_status=$?
16529   grep -v '^ *+' conftest.er1 >conftest.err
16530   rm -f conftest.er1
16531   cat conftest.err >&5
16532   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16533   (exit $ac_status); } &&
16534          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
16535   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16536   (eval $ac_try) 2>&5
16537   ac_status=$?
16538   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16539   (exit $ac_status); }; } &&
16540          { ac_try='test -s conftest$ac_exeext'
16541   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16542   (eval $ac_try) 2>&5
16543   ac_status=$?
16544   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16545   (exit $ac_status); }; }; then
16546   ac_cv_lib_m_tanhf=yes
16547 else
16548   echo "$as_me: failed program was:" >&5
16549 sed 's/^/| /' conftest.$ac_ext >&5
16550
16551 ac_cv_lib_m_tanhf=no
16552 fi
16553 rm -f conftest.err conftest.$ac_objext \
16554       conftest$ac_exeext conftest.$ac_ext
16555 LIBS=$ac_check_lib_save_LIBS
16556 fi
16557 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanhf" >&5
16558 echo "${ECHO_T}$ac_cv_lib_m_tanhf" >&6
16559 if test $ac_cv_lib_m_tanhf = yes; then
16560
16561 cat >>confdefs.h <<\_ACEOF
16562 #define HAVE_TANHF 1
16563 _ACEOF
16564
16565 fi
16566
16567 echo "$as_me:$LINENO: checking for tanh in -lm" >&5
16568 echo $ECHO_N "checking for tanh in -lm... $ECHO_C" >&6
16569 if test "${ac_cv_lib_m_tanh+set}" = set; then
16570   echo $ECHO_N "(cached) $ECHO_C" >&6
16571 else
16572   ac_check_lib_save_LIBS=$LIBS
16573 LIBS="-lm  $LIBS"
16574 if test x$gcc_no_link = xyes; then
16575   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16576 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16577    { (exit 1); exit 1; }; }
16578 fi
16579 cat >conftest.$ac_ext <<_ACEOF
16580 /* confdefs.h.  */
16581 _ACEOF
16582 cat confdefs.h >>conftest.$ac_ext
16583 cat >>conftest.$ac_ext <<_ACEOF
16584 /* end confdefs.h.  */
16585
16586 /* Override any gcc2 internal prototype to avoid an error.  */
16587 #ifdef __cplusplus
16588 extern "C"
16589 #endif
16590 /* We use char because int might match the return type of a gcc2
16591    builtin and then its argument prototype would still apply.  */
16592 char tanh ();
16593 int
16594 main ()
16595 {
16596 tanh ();
16597   ;
16598   return 0;
16599 }
16600 _ACEOF
16601 rm -f conftest.$ac_objext conftest$ac_exeext
16602 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16603   (eval $ac_link) 2>conftest.er1
16604   ac_status=$?
16605   grep -v '^ *+' conftest.er1 >conftest.err
16606   rm -f conftest.er1
16607   cat conftest.err >&5
16608   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16609   (exit $ac_status); } &&
16610          { ac_try='test -z "$ac_c_werror_flag"                   || 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_tanh=yes
16623 else
16624   echo "$as_me: failed program was:" >&5
16625 sed 's/^/| /' conftest.$ac_ext >&5
16626
16627 ac_cv_lib_m_tanh=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_tanh" >&5
16634 echo "${ECHO_T}$ac_cv_lib_m_tanh" >&6
16635 if test $ac_cv_lib_m_tanh = yes; then
16636
16637 cat >>confdefs.h <<\_ACEOF
16638 #define HAVE_TANH 1
16639 _ACEOF
16640
16641 fi
16642
16643 echo "$as_me:$LINENO: checking for tanhl in -lm" >&5
16644 echo $ECHO_N "checking for tanhl in -lm... $ECHO_C" >&6
16645 if test "${ac_cv_lib_m_tanhl+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 tanhl ();
16669 int
16670 main ()
16671 {
16672 tanhl ();
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"                   || test ! -s conftest.err'
16687   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16688   (eval $ac_try) 2>&5
16689   ac_status=$?
16690   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16691   (exit $ac_status); }; } &&
16692          { ac_try='test -s conftest$ac_exeext'
16693   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16694   (eval $ac_try) 2>&5
16695   ac_status=$?
16696   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16697   (exit $ac_status); }; }; then
16698   ac_cv_lib_m_tanhl=yes
16699 else
16700   echo "$as_me: failed program was:" >&5
16701 sed 's/^/| /' conftest.$ac_ext >&5
16702
16703 ac_cv_lib_m_tanhl=no
16704 fi
16705 rm -f conftest.err conftest.$ac_objext \
16706       conftest$ac_exeext conftest.$ac_ext
16707 LIBS=$ac_check_lib_save_LIBS
16708 fi
16709 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanhl" >&5
16710 echo "${ECHO_T}$ac_cv_lib_m_tanhl" >&6
16711 if test $ac_cv_lib_m_tanhl = yes; then
16712
16713 cat >>confdefs.h <<\_ACEOF
16714 #define HAVE_TANHL 1
16715 _ACEOF
16716
16717 fi
16718
16719 echo "$as_me:$LINENO: checking for ctanhf in -lm" >&5
16720 echo $ECHO_N "checking for ctanhf in -lm... $ECHO_C" >&6
16721 if test "${ac_cv_lib_m_ctanhf+set}" = set; then
16722   echo $ECHO_N "(cached) $ECHO_C" >&6
16723 else
16724   ac_check_lib_save_LIBS=$LIBS
16725 LIBS="-lm  $LIBS"
16726 if test x$gcc_no_link = xyes; then
16727   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16728 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16729    { (exit 1); exit 1; }; }
16730 fi
16731 cat >conftest.$ac_ext <<_ACEOF
16732 /* confdefs.h.  */
16733 _ACEOF
16734 cat confdefs.h >>conftest.$ac_ext
16735 cat >>conftest.$ac_ext <<_ACEOF
16736 /* end confdefs.h.  */
16737
16738 /* Override any gcc2 internal prototype to avoid an error.  */
16739 #ifdef __cplusplus
16740 extern "C"
16741 #endif
16742 /* We use char because int might match the return type of a gcc2
16743    builtin and then its argument prototype would still apply.  */
16744 char ctanhf ();
16745 int
16746 main ()
16747 {
16748 ctanhf ();
16749   ;
16750   return 0;
16751 }
16752 _ACEOF
16753 rm -f conftest.$ac_objext conftest$ac_exeext
16754 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16755   (eval $ac_link) 2>conftest.er1
16756   ac_status=$?
16757   grep -v '^ *+' conftest.er1 >conftest.err
16758   rm -f conftest.er1
16759   cat conftest.err >&5
16760   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16761   (exit $ac_status); } &&
16762          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
16763   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16764   (eval $ac_try) 2>&5
16765   ac_status=$?
16766   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16767   (exit $ac_status); }; } &&
16768          { ac_try='test -s conftest$ac_exeext'
16769   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16770   (eval $ac_try) 2>&5
16771   ac_status=$?
16772   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16773   (exit $ac_status); }; }; then
16774   ac_cv_lib_m_ctanhf=yes
16775 else
16776   echo "$as_me: failed program was:" >&5
16777 sed 's/^/| /' conftest.$ac_ext >&5
16778
16779 ac_cv_lib_m_ctanhf=no
16780 fi
16781 rm -f conftest.err conftest.$ac_objext \
16782       conftest$ac_exeext conftest.$ac_ext
16783 LIBS=$ac_check_lib_save_LIBS
16784 fi
16785 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanhf" >&5
16786 echo "${ECHO_T}$ac_cv_lib_m_ctanhf" >&6
16787 if test $ac_cv_lib_m_ctanhf = yes; then
16788
16789 cat >>confdefs.h <<\_ACEOF
16790 #define HAVE_CTANHF 1
16791 _ACEOF
16792
16793 fi
16794
16795 echo "$as_me:$LINENO: checking for ctanh in -lm" >&5
16796 echo $ECHO_N "checking for ctanh in -lm... $ECHO_C" >&6
16797 if test "${ac_cv_lib_m_ctanh+set}" = set; then
16798   echo $ECHO_N "(cached) $ECHO_C" >&6
16799 else
16800   ac_check_lib_save_LIBS=$LIBS
16801 LIBS="-lm  $LIBS"
16802 if test x$gcc_no_link = xyes; then
16803   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16804 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16805    { (exit 1); exit 1; }; }
16806 fi
16807 cat >conftest.$ac_ext <<_ACEOF
16808 /* confdefs.h.  */
16809 _ACEOF
16810 cat confdefs.h >>conftest.$ac_ext
16811 cat >>conftest.$ac_ext <<_ACEOF
16812 /* end confdefs.h.  */
16813
16814 /* Override any gcc2 internal prototype to avoid an error.  */
16815 #ifdef __cplusplus
16816 extern "C"
16817 #endif
16818 /* We use char because int might match the return type of a gcc2
16819    builtin and then its argument prototype would still apply.  */
16820 char ctanh ();
16821 int
16822 main ()
16823 {
16824 ctanh ();
16825   ;
16826   return 0;
16827 }
16828 _ACEOF
16829 rm -f conftest.$ac_objext conftest$ac_exeext
16830 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16831   (eval $ac_link) 2>conftest.er1
16832   ac_status=$?
16833   grep -v '^ *+' conftest.er1 >conftest.err
16834   rm -f conftest.er1
16835   cat conftest.err >&5
16836   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16837   (exit $ac_status); } &&
16838          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
16839   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16840   (eval $ac_try) 2>&5
16841   ac_status=$?
16842   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16843   (exit $ac_status); }; } &&
16844          { ac_try='test -s conftest$ac_exeext'
16845   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16846   (eval $ac_try) 2>&5
16847   ac_status=$?
16848   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16849   (exit $ac_status); }; }; then
16850   ac_cv_lib_m_ctanh=yes
16851 else
16852   echo "$as_me: failed program was:" >&5
16853 sed 's/^/| /' conftest.$ac_ext >&5
16854
16855 ac_cv_lib_m_ctanh=no
16856 fi
16857 rm -f conftest.err conftest.$ac_objext \
16858       conftest$ac_exeext conftest.$ac_ext
16859 LIBS=$ac_check_lib_save_LIBS
16860 fi
16861 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanh" >&5
16862 echo "${ECHO_T}$ac_cv_lib_m_ctanh" >&6
16863 if test $ac_cv_lib_m_ctanh = yes; then
16864
16865 cat >>confdefs.h <<\_ACEOF
16866 #define HAVE_CTANH 1
16867 _ACEOF
16868
16869 fi
16870
16871 echo "$as_me:$LINENO: checking for ctanhl in -lm" >&5
16872 echo $ECHO_N "checking for ctanhl in -lm... $ECHO_C" >&6
16873 if test "${ac_cv_lib_m_ctanhl+set}" = set; then
16874   echo $ECHO_N "(cached) $ECHO_C" >&6
16875 else
16876   ac_check_lib_save_LIBS=$LIBS
16877 LIBS="-lm  $LIBS"
16878 if test x$gcc_no_link = xyes; then
16879   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16880 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16881    { (exit 1); exit 1; }; }
16882 fi
16883 cat >conftest.$ac_ext <<_ACEOF
16884 /* confdefs.h.  */
16885 _ACEOF
16886 cat confdefs.h >>conftest.$ac_ext
16887 cat >>conftest.$ac_ext <<_ACEOF
16888 /* end confdefs.h.  */
16889
16890 /* Override any gcc2 internal prototype to avoid an error.  */
16891 #ifdef __cplusplus
16892 extern "C"
16893 #endif
16894 /* We use char because int might match the return type of a gcc2
16895    builtin and then its argument prototype would still apply.  */
16896 char ctanhl ();
16897 int
16898 main ()
16899 {
16900 ctanhl ();
16901   ;
16902   return 0;
16903 }
16904 _ACEOF
16905 rm -f conftest.$ac_objext conftest$ac_exeext
16906 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16907   (eval $ac_link) 2>conftest.er1
16908   ac_status=$?
16909   grep -v '^ *+' conftest.er1 >conftest.err
16910   rm -f conftest.er1
16911   cat conftest.err >&5
16912   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16913   (exit $ac_status); } &&
16914          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
16915   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16916   (eval $ac_try) 2>&5
16917   ac_status=$?
16918   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16919   (exit $ac_status); }; } &&
16920          { ac_try='test -s conftest$ac_exeext'
16921   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16922   (eval $ac_try) 2>&5
16923   ac_status=$?
16924   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16925   (exit $ac_status); }; }; then
16926   ac_cv_lib_m_ctanhl=yes
16927 else
16928   echo "$as_me: failed program was:" >&5
16929 sed 's/^/| /' conftest.$ac_ext >&5
16930
16931 ac_cv_lib_m_ctanhl=no
16932 fi
16933 rm -f conftest.err conftest.$ac_objext \
16934       conftest$ac_exeext conftest.$ac_ext
16935 LIBS=$ac_check_lib_save_LIBS
16936 fi
16937 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanhl" >&5
16938 echo "${ECHO_T}$ac_cv_lib_m_ctanhl" >&6
16939 if test $ac_cv_lib_m_ctanhl = yes; then
16940
16941 cat >>confdefs.h <<\_ACEOF
16942 #define HAVE_CTANHL 1
16943 _ACEOF
16944
16945 fi
16946
16947 echo "$as_me:$LINENO: checking for truncf in -lm" >&5
16948 echo $ECHO_N "checking for truncf in -lm... $ECHO_C" >&6
16949 if test "${ac_cv_lib_m_truncf+set}" = set; then
16950   echo $ECHO_N "(cached) $ECHO_C" >&6
16951 else
16952   ac_check_lib_save_LIBS=$LIBS
16953 LIBS="-lm  $LIBS"
16954 if test x$gcc_no_link = xyes; then
16955   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16956 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16957    { (exit 1); exit 1; }; }
16958 fi
16959 cat >conftest.$ac_ext <<_ACEOF
16960 /* confdefs.h.  */
16961 _ACEOF
16962 cat confdefs.h >>conftest.$ac_ext
16963 cat >>conftest.$ac_ext <<_ACEOF
16964 /* end confdefs.h.  */
16965
16966 /* Override any gcc2 internal prototype to avoid an error.  */
16967 #ifdef __cplusplus
16968 extern "C"
16969 #endif
16970 /* We use char because int might match the return type of a gcc2
16971    builtin and then its argument prototype would still apply.  */
16972 char truncf ();
16973 int
16974 main ()
16975 {
16976 truncf ();
16977   ;
16978   return 0;
16979 }
16980 _ACEOF
16981 rm -f conftest.$ac_objext conftest$ac_exeext
16982 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16983   (eval $ac_link) 2>conftest.er1
16984   ac_status=$?
16985   grep -v '^ *+' conftest.er1 >conftest.err
16986   rm -f conftest.er1
16987   cat conftest.err >&5
16988   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16989   (exit $ac_status); } &&
16990          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
16991   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16992   (eval $ac_try) 2>&5
16993   ac_status=$?
16994   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16995   (exit $ac_status); }; } &&
16996          { ac_try='test -s conftest$ac_exeext'
16997   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16998   (eval $ac_try) 2>&5
16999   ac_status=$?
17000   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17001   (exit $ac_status); }; }; then
17002   ac_cv_lib_m_truncf=yes
17003 else
17004   echo "$as_me: failed program was:" >&5
17005 sed 's/^/| /' conftest.$ac_ext >&5
17006
17007 ac_cv_lib_m_truncf=no
17008 fi
17009 rm -f conftest.err conftest.$ac_objext \
17010       conftest$ac_exeext conftest.$ac_ext
17011 LIBS=$ac_check_lib_save_LIBS
17012 fi
17013 echo "$as_me:$LINENO: result: $ac_cv_lib_m_truncf" >&5
17014 echo "${ECHO_T}$ac_cv_lib_m_truncf" >&6
17015 if test $ac_cv_lib_m_truncf = yes; then
17016
17017 cat >>confdefs.h <<\_ACEOF
17018 #define HAVE_TRUNCF 1
17019 _ACEOF
17020
17021 fi
17022
17023 echo "$as_me:$LINENO: checking for trunc in -lm" >&5
17024 echo $ECHO_N "checking for trunc in -lm... $ECHO_C" >&6
17025 if test "${ac_cv_lib_m_trunc+set}" = set; then
17026   echo $ECHO_N "(cached) $ECHO_C" >&6
17027 else
17028   ac_check_lib_save_LIBS=$LIBS
17029 LIBS="-lm  $LIBS"
17030 if test x$gcc_no_link = xyes; then
17031   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17032 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17033    { (exit 1); exit 1; }; }
17034 fi
17035 cat >conftest.$ac_ext <<_ACEOF
17036 /* confdefs.h.  */
17037 _ACEOF
17038 cat confdefs.h >>conftest.$ac_ext
17039 cat >>conftest.$ac_ext <<_ACEOF
17040 /* end confdefs.h.  */
17041
17042 /* Override any gcc2 internal prototype to avoid an error.  */
17043 #ifdef __cplusplus
17044 extern "C"
17045 #endif
17046 /* We use char because int might match the return type of a gcc2
17047    builtin and then its argument prototype would still apply.  */
17048 char trunc ();
17049 int
17050 main ()
17051 {
17052 trunc ();
17053   ;
17054   return 0;
17055 }
17056 _ACEOF
17057 rm -f conftest.$ac_objext conftest$ac_exeext
17058 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17059   (eval $ac_link) 2>conftest.er1
17060   ac_status=$?
17061   grep -v '^ *+' conftest.er1 >conftest.err
17062   rm -f conftest.er1
17063   cat conftest.err >&5
17064   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17065   (exit $ac_status); } &&
17066          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
17067   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17068   (eval $ac_try) 2>&5
17069   ac_status=$?
17070   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17071   (exit $ac_status); }; } &&
17072          { ac_try='test -s conftest$ac_exeext'
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); }; }; then
17078   ac_cv_lib_m_trunc=yes
17079 else
17080   echo "$as_me: failed program was:" >&5
17081 sed 's/^/| /' conftest.$ac_ext >&5
17082
17083 ac_cv_lib_m_trunc=no
17084 fi
17085 rm -f conftest.err conftest.$ac_objext \
17086       conftest$ac_exeext conftest.$ac_ext
17087 LIBS=$ac_check_lib_save_LIBS
17088 fi
17089 echo "$as_me:$LINENO: result: $ac_cv_lib_m_trunc" >&5
17090 echo "${ECHO_T}$ac_cv_lib_m_trunc" >&6
17091 if test $ac_cv_lib_m_trunc = yes; then
17092
17093 cat >>confdefs.h <<\_ACEOF
17094 #define HAVE_TRUNC 1
17095 _ACEOF
17096
17097 fi
17098
17099 echo "$as_me:$LINENO: checking for truncl in -lm" >&5
17100 echo $ECHO_N "checking for truncl in -lm... $ECHO_C" >&6
17101 if test "${ac_cv_lib_m_truncl+set}" = set; then
17102   echo $ECHO_N "(cached) $ECHO_C" >&6
17103 else
17104   ac_check_lib_save_LIBS=$LIBS
17105 LIBS="-lm  $LIBS"
17106 if test x$gcc_no_link = xyes; then
17107   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17108 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17109    { (exit 1); exit 1; }; }
17110 fi
17111 cat >conftest.$ac_ext <<_ACEOF
17112 /* confdefs.h.  */
17113 _ACEOF
17114 cat confdefs.h >>conftest.$ac_ext
17115 cat >>conftest.$ac_ext <<_ACEOF
17116 /* end confdefs.h.  */
17117
17118 /* Override any gcc2 internal prototype to avoid an error.  */
17119 #ifdef __cplusplus
17120 extern "C"
17121 #endif
17122 /* We use char because int might match the return type of a gcc2
17123    builtin and then its argument prototype would still apply.  */
17124 char truncl ();
17125 int
17126 main ()
17127 {
17128 truncl ();
17129   ;
17130   return 0;
17131 }
17132 _ACEOF
17133 rm -f conftest.$ac_objext conftest$ac_exeext
17134 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17135   (eval $ac_link) 2>conftest.er1
17136   ac_status=$?
17137   grep -v '^ *+' conftest.er1 >conftest.err
17138   rm -f conftest.er1
17139   cat conftest.err >&5
17140   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17141   (exit $ac_status); } &&
17142          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
17143   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17144   (eval $ac_try) 2>&5
17145   ac_status=$?
17146   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17147   (exit $ac_status); }; } &&
17148          { ac_try='test -s conftest$ac_exeext'
17149   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17150   (eval $ac_try) 2>&5
17151   ac_status=$?
17152   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17153   (exit $ac_status); }; }; then
17154   ac_cv_lib_m_truncl=yes
17155 else
17156   echo "$as_me: failed program was:" >&5
17157 sed 's/^/| /' conftest.$ac_ext >&5
17158
17159 ac_cv_lib_m_truncl=no
17160 fi
17161 rm -f conftest.err conftest.$ac_objext \
17162       conftest$ac_exeext conftest.$ac_ext
17163 LIBS=$ac_check_lib_save_LIBS
17164 fi
17165 echo "$as_me:$LINENO: result: $ac_cv_lib_m_truncl" >&5
17166 echo "${ECHO_T}$ac_cv_lib_m_truncl" >&6
17167 if test $ac_cv_lib_m_truncl = yes; then
17168
17169 cat >>confdefs.h <<\_ACEOF
17170 #define HAVE_TRUNCL 1
17171 _ACEOF
17172
17173 fi
17174
17175 echo "$as_me:$LINENO: checking for erff in -lm" >&5
17176 echo $ECHO_N "checking for erff in -lm... $ECHO_C" >&6
17177 if test "${ac_cv_lib_m_erff+set}" = set; then
17178   echo $ECHO_N "(cached) $ECHO_C" >&6
17179 else
17180   ac_check_lib_save_LIBS=$LIBS
17181 LIBS="-lm  $LIBS"
17182 if test x$gcc_no_link = xyes; then
17183   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17184 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17185    { (exit 1); exit 1; }; }
17186 fi
17187 cat >conftest.$ac_ext <<_ACEOF
17188 /* confdefs.h.  */
17189 _ACEOF
17190 cat confdefs.h >>conftest.$ac_ext
17191 cat >>conftest.$ac_ext <<_ACEOF
17192 /* end confdefs.h.  */
17193
17194 /* Override any gcc2 internal prototype to avoid an error.  */
17195 #ifdef __cplusplus
17196 extern "C"
17197 #endif
17198 /* We use char because int might match the return type of a gcc2
17199    builtin and then its argument prototype would still apply.  */
17200 char erff ();
17201 int
17202 main ()
17203 {
17204 erff ();
17205   ;
17206   return 0;
17207 }
17208 _ACEOF
17209 rm -f conftest.$ac_objext conftest$ac_exeext
17210 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17211   (eval $ac_link) 2>conftest.er1
17212   ac_status=$?
17213   grep -v '^ *+' conftest.er1 >conftest.err
17214   rm -f conftest.er1
17215   cat conftest.err >&5
17216   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17217   (exit $ac_status); } &&
17218          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
17219   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17220   (eval $ac_try) 2>&5
17221   ac_status=$?
17222   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17223   (exit $ac_status); }; } &&
17224          { ac_try='test -s conftest$ac_exeext'
17225   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17226   (eval $ac_try) 2>&5
17227   ac_status=$?
17228   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17229   (exit $ac_status); }; }; then
17230   ac_cv_lib_m_erff=yes
17231 else
17232   echo "$as_me: failed program was:" >&5
17233 sed 's/^/| /' conftest.$ac_ext >&5
17234
17235 ac_cv_lib_m_erff=no
17236 fi
17237 rm -f conftest.err conftest.$ac_objext \
17238       conftest$ac_exeext conftest.$ac_ext
17239 LIBS=$ac_check_lib_save_LIBS
17240 fi
17241 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erff" >&5
17242 echo "${ECHO_T}$ac_cv_lib_m_erff" >&6
17243 if test $ac_cv_lib_m_erff = yes; then
17244
17245 cat >>confdefs.h <<\_ACEOF
17246 #define HAVE_ERFF 1
17247 _ACEOF
17248
17249 fi
17250
17251 echo "$as_me:$LINENO: checking for erf in -lm" >&5
17252 echo $ECHO_N "checking for erf in -lm... $ECHO_C" >&6
17253 if test "${ac_cv_lib_m_erf+set}" = set; then
17254   echo $ECHO_N "(cached) $ECHO_C" >&6
17255 else
17256   ac_check_lib_save_LIBS=$LIBS
17257 LIBS="-lm  $LIBS"
17258 if test x$gcc_no_link = xyes; then
17259   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17260 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17261    { (exit 1); exit 1; }; }
17262 fi
17263 cat >conftest.$ac_ext <<_ACEOF
17264 /* confdefs.h.  */
17265 _ACEOF
17266 cat confdefs.h >>conftest.$ac_ext
17267 cat >>conftest.$ac_ext <<_ACEOF
17268 /* end confdefs.h.  */
17269
17270 /* Override any gcc2 internal prototype to avoid an error.  */
17271 #ifdef __cplusplus
17272 extern "C"
17273 #endif
17274 /* We use char because int might match the return type of a gcc2
17275    builtin and then its argument prototype would still apply.  */
17276 char erf ();
17277 int
17278 main ()
17279 {
17280 erf ();
17281   ;
17282   return 0;
17283 }
17284 _ACEOF
17285 rm -f conftest.$ac_objext conftest$ac_exeext
17286 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17287   (eval $ac_link) 2>conftest.er1
17288   ac_status=$?
17289   grep -v '^ *+' conftest.er1 >conftest.err
17290   rm -f conftest.er1
17291   cat conftest.err >&5
17292   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17293   (exit $ac_status); } &&
17294          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
17295   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17296   (eval $ac_try) 2>&5
17297   ac_status=$?
17298   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17299   (exit $ac_status); }; } &&
17300          { ac_try='test -s conftest$ac_exeext'
17301   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17302   (eval $ac_try) 2>&5
17303   ac_status=$?
17304   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17305   (exit $ac_status); }; }; then
17306   ac_cv_lib_m_erf=yes
17307 else
17308   echo "$as_me: failed program was:" >&5
17309 sed 's/^/| /' conftest.$ac_ext >&5
17310
17311 ac_cv_lib_m_erf=no
17312 fi
17313 rm -f conftest.err conftest.$ac_objext \
17314       conftest$ac_exeext conftest.$ac_ext
17315 LIBS=$ac_check_lib_save_LIBS
17316 fi
17317 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erf" >&5
17318 echo "${ECHO_T}$ac_cv_lib_m_erf" >&6
17319 if test $ac_cv_lib_m_erf = yes; then
17320
17321 cat >>confdefs.h <<\_ACEOF
17322 #define HAVE_ERF 1
17323 _ACEOF
17324
17325 fi
17326
17327 echo "$as_me:$LINENO: checking for erfl in -lm" >&5
17328 echo $ECHO_N "checking for erfl in -lm... $ECHO_C" >&6
17329 if test "${ac_cv_lib_m_erfl+set}" = set; then
17330   echo $ECHO_N "(cached) $ECHO_C" >&6
17331 else
17332   ac_check_lib_save_LIBS=$LIBS
17333 LIBS="-lm  $LIBS"
17334 if test x$gcc_no_link = xyes; then
17335   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17336 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17337    { (exit 1); exit 1; }; }
17338 fi
17339 cat >conftest.$ac_ext <<_ACEOF
17340 /* confdefs.h.  */
17341 _ACEOF
17342 cat confdefs.h >>conftest.$ac_ext
17343 cat >>conftest.$ac_ext <<_ACEOF
17344 /* end confdefs.h.  */
17345
17346 /* Override any gcc2 internal prototype to avoid an error.  */
17347 #ifdef __cplusplus
17348 extern "C"
17349 #endif
17350 /* We use char because int might match the return type of a gcc2
17351    builtin and then its argument prototype would still apply.  */
17352 char erfl ();
17353 int
17354 main ()
17355 {
17356 erfl ();
17357   ;
17358   return 0;
17359 }
17360 _ACEOF
17361 rm -f conftest.$ac_objext conftest$ac_exeext
17362 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17363   (eval $ac_link) 2>conftest.er1
17364   ac_status=$?
17365   grep -v '^ *+' conftest.er1 >conftest.err
17366   rm -f conftest.er1
17367   cat conftest.err >&5
17368   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17369   (exit $ac_status); } &&
17370          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
17371   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17372   (eval $ac_try) 2>&5
17373   ac_status=$?
17374   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17375   (exit $ac_status); }; } &&
17376          { ac_try='test -s conftest$ac_exeext'
17377   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17378   (eval $ac_try) 2>&5
17379   ac_status=$?
17380   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17381   (exit $ac_status); }; }; then
17382   ac_cv_lib_m_erfl=yes
17383 else
17384   echo "$as_me: failed program was:" >&5
17385 sed 's/^/| /' conftest.$ac_ext >&5
17386
17387 ac_cv_lib_m_erfl=no
17388 fi
17389 rm -f conftest.err conftest.$ac_objext \
17390       conftest$ac_exeext conftest.$ac_ext
17391 LIBS=$ac_check_lib_save_LIBS
17392 fi
17393 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfl" >&5
17394 echo "${ECHO_T}$ac_cv_lib_m_erfl" >&6
17395 if test $ac_cv_lib_m_erfl = yes; then
17396
17397 cat >>confdefs.h <<\_ACEOF
17398 #define HAVE_ERFL 1
17399 _ACEOF
17400
17401 fi
17402
17403 echo "$as_me:$LINENO: checking for erfcf in -lm" >&5
17404 echo $ECHO_N "checking for erfcf in -lm... $ECHO_C" >&6
17405 if test "${ac_cv_lib_m_erfcf+set}" = set; then
17406   echo $ECHO_N "(cached) $ECHO_C" >&6
17407 else
17408   ac_check_lib_save_LIBS=$LIBS
17409 LIBS="-lm  $LIBS"
17410 if test x$gcc_no_link = xyes; then
17411   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17412 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17413    { (exit 1); exit 1; }; }
17414 fi
17415 cat >conftest.$ac_ext <<_ACEOF
17416 /* confdefs.h.  */
17417 _ACEOF
17418 cat confdefs.h >>conftest.$ac_ext
17419 cat >>conftest.$ac_ext <<_ACEOF
17420 /* end confdefs.h.  */
17421
17422 /* Override any gcc2 internal prototype to avoid an error.  */
17423 #ifdef __cplusplus
17424 extern "C"
17425 #endif
17426 /* We use char because int might match the return type of a gcc2
17427    builtin and then its argument prototype would still apply.  */
17428 char erfcf ();
17429 int
17430 main ()
17431 {
17432 erfcf ();
17433   ;
17434   return 0;
17435 }
17436 _ACEOF
17437 rm -f conftest.$ac_objext conftest$ac_exeext
17438 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17439   (eval $ac_link) 2>conftest.er1
17440   ac_status=$?
17441   grep -v '^ *+' conftest.er1 >conftest.err
17442   rm -f conftest.er1
17443   cat conftest.err >&5
17444   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17445   (exit $ac_status); } &&
17446          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
17447   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17448   (eval $ac_try) 2>&5
17449   ac_status=$?
17450   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17451   (exit $ac_status); }; } &&
17452          { ac_try='test -s conftest$ac_exeext'
17453   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17454   (eval $ac_try) 2>&5
17455   ac_status=$?
17456   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17457   (exit $ac_status); }; }; then
17458   ac_cv_lib_m_erfcf=yes
17459 else
17460   echo "$as_me: failed program was:" >&5
17461 sed 's/^/| /' conftest.$ac_ext >&5
17462
17463 ac_cv_lib_m_erfcf=no
17464 fi
17465 rm -f conftest.err conftest.$ac_objext \
17466       conftest$ac_exeext conftest.$ac_ext
17467 LIBS=$ac_check_lib_save_LIBS
17468 fi
17469 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfcf" >&5
17470 echo "${ECHO_T}$ac_cv_lib_m_erfcf" >&6
17471 if test $ac_cv_lib_m_erfcf = yes; then
17472
17473 cat >>confdefs.h <<\_ACEOF
17474 #define HAVE_ERFCF 1
17475 _ACEOF
17476
17477 fi
17478
17479 echo "$as_me:$LINENO: checking for erfc in -lm" >&5
17480 echo $ECHO_N "checking for erfc in -lm... $ECHO_C" >&6
17481 if test "${ac_cv_lib_m_erfc+set}" = set; then
17482   echo $ECHO_N "(cached) $ECHO_C" >&6
17483 else
17484   ac_check_lib_save_LIBS=$LIBS
17485 LIBS="-lm  $LIBS"
17486 if test x$gcc_no_link = xyes; then
17487   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17488 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17489    { (exit 1); exit 1; }; }
17490 fi
17491 cat >conftest.$ac_ext <<_ACEOF
17492 /* confdefs.h.  */
17493 _ACEOF
17494 cat confdefs.h >>conftest.$ac_ext
17495 cat >>conftest.$ac_ext <<_ACEOF
17496 /* end confdefs.h.  */
17497
17498 /* Override any gcc2 internal prototype to avoid an error.  */
17499 #ifdef __cplusplus
17500 extern "C"
17501 #endif
17502 /* We use char because int might match the return type of a gcc2
17503    builtin and then its argument prototype would still apply.  */
17504 char erfc ();
17505 int
17506 main ()
17507 {
17508 erfc ();
17509   ;
17510   return 0;
17511 }
17512 _ACEOF
17513 rm -f conftest.$ac_objext conftest$ac_exeext
17514 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17515   (eval $ac_link) 2>conftest.er1
17516   ac_status=$?
17517   grep -v '^ *+' conftest.er1 >conftest.err
17518   rm -f conftest.er1
17519   cat conftest.err >&5
17520   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17521   (exit $ac_status); } &&
17522          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
17523   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17524   (eval $ac_try) 2>&5
17525   ac_status=$?
17526   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17527   (exit $ac_status); }; } &&
17528          { ac_try='test -s conftest$ac_exeext'
17529   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17530   (eval $ac_try) 2>&5
17531   ac_status=$?
17532   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17533   (exit $ac_status); }; }; then
17534   ac_cv_lib_m_erfc=yes
17535 else
17536   echo "$as_me: failed program was:" >&5
17537 sed 's/^/| /' conftest.$ac_ext >&5
17538
17539 ac_cv_lib_m_erfc=no
17540 fi
17541 rm -f conftest.err conftest.$ac_objext \
17542       conftest$ac_exeext conftest.$ac_ext
17543 LIBS=$ac_check_lib_save_LIBS
17544 fi
17545 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfc" >&5
17546 echo "${ECHO_T}$ac_cv_lib_m_erfc" >&6
17547 if test $ac_cv_lib_m_erfc = yes; then
17548
17549 cat >>confdefs.h <<\_ACEOF
17550 #define HAVE_ERFC 1
17551 _ACEOF
17552
17553 fi
17554
17555 echo "$as_me:$LINENO: checking for erfcl in -lm" >&5
17556 echo $ECHO_N "checking for erfcl in -lm... $ECHO_C" >&6
17557 if test "${ac_cv_lib_m_erfcl+set}" = set; then
17558   echo $ECHO_N "(cached) $ECHO_C" >&6
17559 else
17560   ac_check_lib_save_LIBS=$LIBS
17561 LIBS="-lm  $LIBS"
17562 if test x$gcc_no_link = xyes; then
17563   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17564 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17565    { (exit 1); exit 1; }; }
17566 fi
17567 cat >conftest.$ac_ext <<_ACEOF
17568 /* confdefs.h.  */
17569 _ACEOF
17570 cat confdefs.h >>conftest.$ac_ext
17571 cat >>conftest.$ac_ext <<_ACEOF
17572 /* end confdefs.h.  */
17573
17574 /* Override any gcc2 internal prototype to avoid an error.  */
17575 #ifdef __cplusplus
17576 extern "C"
17577 #endif
17578 /* We use char because int might match the return type of a gcc2
17579    builtin and then its argument prototype would still apply.  */
17580 char erfcl ();
17581 int
17582 main ()
17583 {
17584 erfcl ();
17585   ;
17586   return 0;
17587 }
17588 _ACEOF
17589 rm -f conftest.$ac_objext conftest$ac_exeext
17590 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17591   (eval $ac_link) 2>conftest.er1
17592   ac_status=$?
17593   grep -v '^ *+' conftest.er1 >conftest.err
17594   rm -f conftest.er1
17595   cat conftest.err >&5
17596   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17597   (exit $ac_status); } &&
17598          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
17599   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17600   (eval $ac_try) 2>&5
17601   ac_status=$?
17602   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17603   (exit $ac_status); }; } &&
17604          { ac_try='test -s conftest$ac_exeext'
17605   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17606   (eval $ac_try) 2>&5
17607   ac_status=$?
17608   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17609   (exit $ac_status); }; }; then
17610   ac_cv_lib_m_erfcl=yes
17611 else
17612   echo "$as_me: failed program was:" >&5
17613 sed 's/^/| /' conftest.$ac_ext >&5
17614
17615 ac_cv_lib_m_erfcl=no
17616 fi
17617 rm -f conftest.err conftest.$ac_objext \
17618       conftest$ac_exeext conftest.$ac_ext
17619 LIBS=$ac_check_lib_save_LIBS
17620 fi
17621 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfcl" >&5
17622 echo "${ECHO_T}$ac_cv_lib_m_erfcl" >&6
17623 if test $ac_cv_lib_m_erfcl = yes; then
17624
17625 cat >>confdefs.h <<\_ACEOF
17626 #define HAVE_ERFCL 1
17627 _ACEOF
17628
17629 fi
17630
17631 echo "$as_me:$LINENO: checking for j0f in -lm" >&5
17632 echo $ECHO_N "checking for j0f in -lm... $ECHO_C" >&6
17633 if test "${ac_cv_lib_m_j0f+set}" = set; then
17634   echo $ECHO_N "(cached) $ECHO_C" >&6
17635 else
17636   ac_check_lib_save_LIBS=$LIBS
17637 LIBS="-lm  $LIBS"
17638 if test x$gcc_no_link = xyes; then
17639   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17640 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17641    { (exit 1); exit 1; }; }
17642 fi
17643 cat >conftest.$ac_ext <<_ACEOF
17644 /* confdefs.h.  */
17645 _ACEOF
17646 cat confdefs.h >>conftest.$ac_ext
17647 cat >>conftest.$ac_ext <<_ACEOF
17648 /* end confdefs.h.  */
17649
17650 /* Override any gcc2 internal prototype to avoid an error.  */
17651 #ifdef __cplusplus
17652 extern "C"
17653 #endif
17654 /* We use char because int might match the return type of a gcc2
17655    builtin and then its argument prototype would still apply.  */
17656 char j0f ();
17657 int
17658 main ()
17659 {
17660 j0f ();
17661   ;
17662   return 0;
17663 }
17664 _ACEOF
17665 rm -f conftest.$ac_objext conftest$ac_exeext
17666 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17667   (eval $ac_link) 2>conftest.er1
17668   ac_status=$?
17669   grep -v '^ *+' conftest.er1 >conftest.err
17670   rm -f conftest.er1
17671   cat conftest.err >&5
17672   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17673   (exit $ac_status); } &&
17674          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
17675   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17676   (eval $ac_try) 2>&5
17677   ac_status=$?
17678   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17679   (exit $ac_status); }; } &&
17680          { ac_try='test -s conftest$ac_exeext'
17681   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17682   (eval $ac_try) 2>&5
17683   ac_status=$?
17684   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17685   (exit $ac_status); }; }; then
17686   ac_cv_lib_m_j0f=yes
17687 else
17688   echo "$as_me: failed program was:" >&5
17689 sed 's/^/| /' conftest.$ac_ext >&5
17690
17691 ac_cv_lib_m_j0f=no
17692 fi
17693 rm -f conftest.err conftest.$ac_objext \
17694       conftest$ac_exeext conftest.$ac_ext
17695 LIBS=$ac_check_lib_save_LIBS
17696 fi
17697 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0f" >&5
17698 echo "${ECHO_T}$ac_cv_lib_m_j0f" >&6
17699 if test $ac_cv_lib_m_j0f = yes; then
17700
17701 cat >>confdefs.h <<\_ACEOF
17702 #define HAVE_J0F 1
17703 _ACEOF
17704
17705 fi
17706
17707 echo "$as_me:$LINENO: checking for j0 in -lm" >&5
17708 echo $ECHO_N "checking for j0 in -lm... $ECHO_C" >&6
17709 if test "${ac_cv_lib_m_j0+set}" = set; then
17710   echo $ECHO_N "(cached) $ECHO_C" >&6
17711 else
17712   ac_check_lib_save_LIBS=$LIBS
17713 LIBS="-lm  $LIBS"
17714 if test x$gcc_no_link = xyes; then
17715   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17716 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17717    { (exit 1); exit 1; }; }
17718 fi
17719 cat >conftest.$ac_ext <<_ACEOF
17720 /* confdefs.h.  */
17721 _ACEOF
17722 cat confdefs.h >>conftest.$ac_ext
17723 cat >>conftest.$ac_ext <<_ACEOF
17724 /* end confdefs.h.  */
17725
17726 /* Override any gcc2 internal prototype to avoid an error.  */
17727 #ifdef __cplusplus
17728 extern "C"
17729 #endif
17730 /* We use char because int might match the return type of a gcc2
17731    builtin and then its argument prototype would still apply.  */
17732 char j0 ();
17733 int
17734 main ()
17735 {
17736 j0 ();
17737   ;
17738   return 0;
17739 }
17740 _ACEOF
17741 rm -f conftest.$ac_objext conftest$ac_exeext
17742 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17743   (eval $ac_link) 2>conftest.er1
17744   ac_status=$?
17745   grep -v '^ *+' conftest.er1 >conftest.err
17746   rm -f conftest.er1
17747   cat conftest.err >&5
17748   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17749   (exit $ac_status); } &&
17750          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
17751   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17752   (eval $ac_try) 2>&5
17753   ac_status=$?
17754   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17755   (exit $ac_status); }; } &&
17756          { ac_try='test -s conftest$ac_exeext'
17757   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17758   (eval $ac_try) 2>&5
17759   ac_status=$?
17760   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17761   (exit $ac_status); }; }; then
17762   ac_cv_lib_m_j0=yes
17763 else
17764   echo "$as_me: failed program was:" >&5
17765 sed 's/^/| /' conftest.$ac_ext >&5
17766
17767 ac_cv_lib_m_j0=no
17768 fi
17769 rm -f conftest.err conftest.$ac_objext \
17770       conftest$ac_exeext conftest.$ac_ext
17771 LIBS=$ac_check_lib_save_LIBS
17772 fi
17773 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0" >&5
17774 echo "${ECHO_T}$ac_cv_lib_m_j0" >&6
17775 if test $ac_cv_lib_m_j0 = yes; then
17776
17777 cat >>confdefs.h <<\_ACEOF
17778 #define HAVE_J0 1
17779 _ACEOF
17780
17781 fi
17782
17783 echo "$as_me:$LINENO: checking for j0l in -lm" >&5
17784 echo $ECHO_N "checking for j0l in -lm... $ECHO_C" >&6
17785 if test "${ac_cv_lib_m_j0l+set}" = set; then
17786   echo $ECHO_N "(cached) $ECHO_C" >&6
17787 else
17788   ac_check_lib_save_LIBS=$LIBS
17789 LIBS="-lm  $LIBS"
17790 if test x$gcc_no_link = xyes; then
17791   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17792 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17793    { (exit 1); exit 1; }; }
17794 fi
17795 cat >conftest.$ac_ext <<_ACEOF
17796 /* confdefs.h.  */
17797 _ACEOF
17798 cat confdefs.h >>conftest.$ac_ext
17799 cat >>conftest.$ac_ext <<_ACEOF
17800 /* end confdefs.h.  */
17801
17802 /* Override any gcc2 internal prototype to avoid an error.  */
17803 #ifdef __cplusplus
17804 extern "C"
17805 #endif
17806 /* We use char because int might match the return type of a gcc2
17807    builtin and then its argument prototype would still apply.  */
17808 char j0l ();
17809 int
17810 main ()
17811 {
17812 j0l ();
17813   ;
17814   return 0;
17815 }
17816 _ACEOF
17817 rm -f conftest.$ac_objext conftest$ac_exeext
17818 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17819   (eval $ac_link) 2>conftest.er1
17820   ac_status=$?
17821   grep -v '^ *+' conftest.er1 >conftest.err
17822   rm -f conftest.er1
17823   cat conftest.err >&5
17824   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17825   (exit $ac_status); } &&
17826          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
17827   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17828   (eval $ac_try) 2>&5
17829   ac_status=$?
17830   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17831   (exit $ac_status); }; } &&
17832          { ac_try='test -s conftest$ac_exeext'
17833   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17834   (eval $ac_try) 2>&5
17835   ac_status=$?
17836   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17837   (exit $ac_status); }; }; then
17838   ac_cv_lib_m_j0l=yes
17839 else
17840   echo "$as_me: failed program was:" >&5
17841 sed 's/^/| /' conftest.$ac_ext >&5
17842
17843 ac_cv_lib_m_j0l=no
17844 fi
17845 rm -f conftest.err conftest.$ac_objext \
17846       conftest$ac_exeext conftest.$ac_ext
17847 LIBS=$ac_check_lib_save_LIBS
17848 fi
17849 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0l" >&5
17850 echo "${ECHO_T}$ac_cv_lib_m_j0l" >&6
17851 if test $ac_cv_lib_m_j0l = yes; then
17852
17853 cat >>confdefs.h <<\_ACEOF
17854 #define HAVE_J0L 1
17855 _ACEOF
17856
17857 fi
17858
17859 echo "$as_me:$LINENO: checking for j1f in -lm" >&5
17860 echo $ECHO_N "checking for j1f in -lm... $ECHO_C" >&6
17861 if test "${ac_cv_lib_m_j1f+set}" = set; then
17862   echo $ECHO_N "(cached) $ECHO_C" >&6
17863 else
17864   ac_check_lib_save_LIBS=$LIBS
17865 LIBS="-lm  $LIBS"
17866 if test x$gcc_no_link = xyes; then
17867   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17868 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17869    { (exit 1); exit 1; }; }
17870 fi
17871 cat >conftest.$ac_ext <<_ACEOF
17872 /* confdefs.h.  */
17873 _ACEOF
17874 cat confdefs.h >>conftest.$ac_ext
17875 cat >>conftest.$ac_ext <<_ACEOF
17876 /* end confdefs.h.  */
17877
17878 /* Override any gcc2 internal prototype to avoid an error.  */
17879 #ifdef __cplusplus
17880 extern "C"
17881 #endif
17882 /* We use char because int might match the return type of a gcc2
17883    builtin and then its argument prototype would still apply.  */
17884 char j1f ();
17885 int
17886 main ()
17887 {
17888 j1f ();
17889   ;
17890   return 0;
17891 }
17892 _ACEOF
17893 rm -f conftest.$ac_objext conftest$ac_exeext
17894 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17895   (eval $ac_link) 2>conftest.er1
17896   ac_status=$?
17897   grep -v '^ *+' conftest.er1 >conftest.err
17898   rm -f conftest.er1
17899   cat conftest.err >&5
17900   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17901   (exit $ac_status); } &&
17902          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
17903   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17904   (eval $ac_try) 2>&5
17905   ac_status=$?
17906   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17907   (exit $ac_status); }; } &&
17908          { ac_try='test -s conftest$ac_exeext'
17909   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17910   (eval $ac_try) 2>&5
17911   ac_status=$?
17912   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17913   (exit $ac_status); }; }; then
17914   ac_cv_lib_m_j1f=yes
17915 else
17916   echo "$as_me: failed program was:" >&5
17917 sed 's/^/| /' conftest.$ac_ext >&5
17918
17919 ac_cv_lib_m_j1f=no
17920 fi
17921 rm -f conftest.err conftest.$ac_objext \
17922       conftest$ac_exeext conftest.$ac_ext
17923 LIBS=$ac_check_lib_save_LIBS
17924 fi
17925 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1f" >&5
17926 echo "${ECHO_T}$ac_cv_lib_m_j1f" >&6
17927 if test $ac_cv_lib_m_j1f = yes; then
17928
17929 cat >>confdefs.h <<\_ACEOF
17930 #define HAVE_J1F 1
17931 _ACEOF
17932
17933 fi
17934
17935 echo "$as_me:$LINENO: checking for j1 in -lm" >&5
17936 echo $ECHO_N "checking for j1 in -lm... $ECHO_C" >&6
17937 if test "${ac_cv_lib_m_j1+set}" = set; then
17938   echo $ECHO_N "(cached) $ECHO_C" >&6
17939 else
17940   ac_check_lib_save_LIBS=$LIBS
17941 LIBS="-lm  $LIBS"
17942 if test x$gcc_no_link = xyes; then
17943   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17944 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17945    { (exit 1); exit 1; }; }
17946 fi
17947 cat >conftest.$ac_ext <<_ACEOF
17948 /* confdefs.h.  */
17949 _ACEOF
17950 cat confdefs.h >>conftest.$ac_ext
17951 cat >>conftest.$ac_ext <<_ACEOF
17952 /* end confdefs.h.  */
17953
17954 /* Override any gcc2 internal prototype to avoid an error.  */
17955 #ifdef __cplusplus
17956 extern "C"
17957 #endif
17958 /* We use char because int might match the return type of a gcc2
17959    builtin and then its argument prototype would still apply.  */
17960 char j1 ();
17961 int
17962 main ()
17963 {
17964 j1 ();
17965   ;
17966   return 0;
17967 }
17968 _ACEOF
17969 rm -f conftest.$ac_objext conftest$ac_exeext
17970 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17971   (eval $ac_link) 2>conftest.er1
17972   ac_status=$?
17973   grep -v '^ *+' conftest.er1 >conftest.err
17974   rm -f conftest.er1
17975   cat conftest.err >&5
17976   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17977   (exit $ac_status); } &&
17978          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
17979   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17980   (eval $ac_try) 2>&5
17981   ac_status=$?
17982   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17983   (exit $ac_status); }; } &&
17984          { ac_try='test -s conftest$ac_exeext'
17985   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17986   (eval $ac_try) 2>&5
17987   ac_status=$?
17988   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17989   (exit $ac_status); }; }; then
17990   ac_cv_lib_m_j1=yes
17991 else
17992   echo "$as_me: failed program was:" >&5
17993 sed 's/^/| /' conftest.$ac_ext >&5
17994
17995 ac_cv_lib_m_j1=no
17996 fi
17997 rm -f conftest.err conftest.$ac_objext \
17998       conftest$ac_exeext conftest.$ac_ext
17999 LIBS=$ac_check_lib_save_LIBS
18000 fi
18001 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1" >&5
18002 echo "${ECHO_T}$ac_cv_lib_m_j1" >&6
18003 if test $ac_cv_lib_m_j1 = yes; then
18004
18005 cat >>confdefs.h <<\_ACEOF
18006 #define HAVE_J1 1
18007 _ACEOF
18008
18009 fi
18010
18011 echo "$as_me:$LINENO: checking for j1l in -lm" >&5
18012 echo $ECHO_N "checking for j1l in -lm... $ECHO_C" >&6
18013 if test "${ac_cv_lib_m_j1l+set}" = set; then
18014   echo $ECHO_N "(cached) $ECHO_C" >&6
18015 else
18016   ac_check_lib_save_LIBS=$LIBS
18017 LIBS="-lm  $LIBS"
18018 if test x$gcc_no_link = xyes; then
18019   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18020 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18021    { (exit 1); exit 1; }; }
18022 fi
18023 cat >conftest.$ac_ext <<_ACEOF
18024 /* confdefs.h.  */
18025 _ACEOF
18026 cat confdefs.h >>conftest.$ac_ext
18027 cat >>conftest.$ac_ext <<_ACEOF
18028 /* end confdefs.h.  */
18029
18030 /* Override any gcc2 internal prototype to avoid an error.  */
18031 #ifdef __cplusplus
18032 extern "C"
18033 #endif
18034 /* We use char because int might match the return type of a gcc2
18035    builtin and then its argument prototype would still apply.  */
18036 char j1l ();
18037 int
18038 main ()
18039 {
18040 j1l ();
18041   ;
18042   return 0;
18043 }
18044 _ACEOF
18045 rm -f conftest.$ac_objext conftest$ac_exeext
18046 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18047   (eval $ac_link) 2>conftest.er1
18048   ac_status=$?
18049   grep -v '^ *+' conftest.er1 >conftest.err
18050   rm -f conftest.er1
18051   cat conftest.err >&5
18052   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18053   (exit $ac_status); } &&
18054          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
18055   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18056   (eval $ac_try) 2>&5
18057   ac_status=$?
18058   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18059   (exit $ac_status); }; } &&
18060          { ac_try='test -s conftest$ac_exeext'
18061   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18062   (eval $ac_try) 2>&5
18063   ac_status=$?
18064   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18065   (exit $ac_status); }; }; then
18066   ac_cv_lib_m_j1l=yes
18067 else
18068   echo "$as_me: failed program was:" >&5
18069 sed 's/^/| /' conftest.$ac_ext >&5
18070
18071 ac_cv_lib_m_j1l=no
18072 fi
18073 rm -f conftest.err conftest.$ac_objext \
18074       conftest$ac_exeext conftest.$ac_ext
18075 LIBS=$ac_check_lib_save_LIBS
18076 fi
18077 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1l" >&5
18078 echo "${ECHO_T}$ac_cv_lib_m_j1l" >&6
18079 if test $ac_cv_lib_m_j1l = yes; then
18080
18081 cat >>confdefs.h <<\_ACEOF
18082 #define HAVE_J1L 1
18083 _ACEOF
18084
18085 fi
18086
18087 echo "$as_me:$LINENO: checking for jnf in -lm" >&5
18088 echo $ECHO_N "checking for jnf in -lm... $ECHO_C" >&6
18089 if test "${ac_cv_lib_m_jnf+set}" = set; then
18090   echo $ECHO_N "(cached) $ECHO_C" >&6
18091 else
18092   ac_check_lib_save_LIBS=$LIBS
18093 LIBS="-lm  $LIBS"
18094 if test x$gcc_no_link = xyes; then
18095   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18096 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18097    { (exit 1); exit 1; }; }
18098 fi
18099 cat >conftest.$ac_ext <<_ACEOF
18100 /* confdefs.h.  */
18101 _ACEOF
18102 cat confdefs.h >>conftest.$ac_ext
18103 cat >>conftest.$ac_ext <<_ACEOF
18104 /* end confdefs.h.  */
18105
18106 /* Override any gcc2 internal prototype to avoid an error.  */
18107 #ifdef __cplusplus
18108 extern "C"
18109 #endif
18110 /* We use char because int might match the return type of a gcc2
18111    builtin and then its argument prototype would still apply.  */
18112 char jnf ();
18113 int
18114 main ()
18115 {
18116 jnf ();
18117   ;
18118   return 0;
18119 }
18120 _ACEOF
18121 rm -f conftest.$ac_objext conftest$ac_exeext
18122 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18123   (eval $ac_link) 2>conftest.er1
18124   ac_status=$?
18125   grep -v '^ *+' conftest.er1 >conftest.err
18126   rm -f conftest.er1
18127   cat conftest.err >&5
18128   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18129   (exit $ac_status); } &&
18130          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
18131   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18132   (eval $ac_try) 2>&5
18133   ac_status=$?
18134   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18135   (exit $ac_status); }; } &&
18136          { ac_try='test -s conftest$ac_exeext'
18137   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18138   (eval $ac_try) 2>&5
18139   ac_status=$?
18140   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18141   (exit $ac_status); }; }; then
18142   ac_cv_lib_m_jnf=yes
18143 else
18144   echo "$as_me: failed program was:" >&5
18145 sed 's/^/| /' conftest.$ac_ext >&5
18146
18147 ac_cv_lib_m_jnf=no
18148 fi
18149 rm -f conftest.err conftest.$ac_objext \
18150       conftest$ac_exeext conftest.$ac_ext
18151 LIBS=$ac_check_lib_save_LIBS
18152 fi
18153 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jnf" >&5
18154 echo "${ECHO_T}$ac_cv_lib_m_jnf" >&6
18155 if test $ac_cv_lib_m_jnf = yes; then
18156
18157 cat >>confdefs.h <<\_ACEOF
18158 #define HAVE_JNF 1
18159 _ACEOF
18160
18161 fi
18162
18163 echo "$as_me:$LINENO: checking for jn in -lm" >&5
18164 echo $ECHO_N "checking for jn in -lm... $ECHO_C" >&6
18165 if test "${ac_cv_lib_m_jn+set}" = set; then
18166   echo $ECHO_N "(cached) $ECHO_C" >&6
18167 else
18168   ac_check_lib_save_LIBS=$LIBS
18169 LIBS="-lm  $LIBS"
18170 if test x$gcc_no_link = xyes; then
18171   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18172 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18173    { (exit 1); exit 1; }; }
18174 fi
18175 cat >conftest.$ac_ext <<_ACEOF
18176 /* confdefs.h.  */
18177 _ACEOF
18178 cat confdefs.h >>conftest.$ac_ext
18179 cat >>conftest.$ac_ext <<_ACEOF
18180 /* end confdefs.h.  */
18181
18182 /* Override any gcc2 internal prototype to avoid an error.  */
18183 #ifdef __cplusplus
18184 extern "C"
18185 #endif
18186 /* We use char because int might match the return type of a gcc2
18187    builtin and then its argument prototype would still apply.  */
18188 char jn ();
18189 int
18190 main ()
18191 {
18192 jn ();
18193   ;
18194   return 0;
18195 }
18196 _ACEOF
18197 rm -f conftest.$ac_objext conftest$ac_exeext
18198 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18199   (eval $ac_link) 2>conftest.er1
18200   ac_status=$?
18201   grep -v '^ *+' conftest.er1 >conftest.err
18202   rm -f conftest.er1
18203   cat conftest.err >&5
18204   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18205   (exit $ac_status); } &&
18206          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
18207   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18208   (eval $ac_try) 2>&5
18209   ac_status=$?
18210   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18211   (exit $ac_status); }; } &&
18212          { ac_try='test -s conftest$ac_exeext'
18213   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18214   (eval $ac_try) 2>&5
18215   ac_status=$?
18216   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18217   (exit $ac_status); }; }; then
18218   ac_cv_lib_m_jn=yes
18219 else
18220   echo "$as_me: failed program was:" >&5
18221 sed 's/^/| /' conftest.$ac_ext >&5
18222
18223 ac_cv_lib_m_jn=no
18224 fi
18225 rm -f conftest.err conftest.$ac_objext \
18226       conftest$ac_exeext conftest.$ac_ext
18227 LIBS=$ac_check_lib_save_LIBS
18228 fi
18229 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jn" >&5
18230 echo "${ECHO_T}$ac_cv_lib_m_jn" >&6
18231 if test $ac_cv_lib_m_jn = yes; then
18232
18233 cat >>confdefs.h <<\_ACEOF
18234 #define HAVE_JN 1
18235 _ACEOF
18236
18237 fi
18238
18239 echo "$as_me:$LINENO: checking for jnl in -lm" >&5
18240 echo $ECHO_N "checking for jnl in -lm... $ECHO_C" >&6
18241 if test "${ac_cv_lib_m_jnl+set}" = set; then
18242   echo $ECHO_N "(cached) $ECHO_C" >&6
18243 else
18244   ac_check_lib_save_LIBS=$LIBS
18245 LIBS="-lm  $LIBS"
18246 if test x$gcc_no_link = xyes; then
18247   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18248 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18249    { (exit 1); exit 1; }; }
18250 fi
18251 cat >conftest.$ac_ext <<_ACEOF
18252 /* confdefs.h.  */
18253 _ACEOF
18254 cat confdefs.h >>conftest.$ac_ext
18255 cat >>conftest.$ac_ext <<_ACEOF
18256 /* end confdefs.h.  */
18257
18258 /* Override any gcc2 internal prototype to avoid an error.  */
18259 #ifdef __cplusplus
18260 extern "C"
18261 #endif
18262 /* We use char because int might match the return type of a gcc2
18263    builtin and then its argument prototype would still apply.  */
18264 char jnl ();
18265 int
18266 main ()
18267 {
18268 jnl ();
18269   ;
18270   return 0;
18271 }
18272 _ACEOF
18273 rm -f conftest.$ac_objext conftest$ac_exeext
18274 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18275   (eval $ac_link) 2>conftest.er1
18276   ac_status=$?
18277   grep -v '^ *+' conftest.er1 >conftest.err
18278   rm -f conftest.er1
18279   cat conftest.err >&5
18280   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18281   (exit $ac_status); } &&
18282          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
18283   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18284   (eval $ac_try) 2>&5
18285   ac_status=$?
18286   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18287   (exit $ac_status); }; } &&
18288          { ac_try='test -s conftest$ac_exeext'
18289   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18290   (eval $ac_try) 2>&5
18291   ac_status=$?
18292   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18293   (exit $ac_status); }; }; then
18294   ac_cv_lib_m_jnl=yes
18295 else
18296   echo "$as_me: failed program was:" >&5
18297 sed 's/^/| /' conftest.$ac_ext >&5
18298
18299 ac_cv_lib_m_jnl=no
18300 fi
18301 rm -f conftest.err conftest.$ac_objext \
18302       conftest$ac_exeext conftest.$ac_ext
18303 LIBS=$ac_check_lib_save_LIBS
18304 fi
18305 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jnl" >&5
18306 echo "${ECHO_T}$ac_cv_lib_m_jnl" >&6
18307 if test $ac_cv_lib_m_jnl = yes; then
18308
18309 cat >>confdefs.h <<\_ACEOF
18310 #define HAVE_JNL 1
18311 _ACEOF
18312
18313 fi
18314
18315 echo "$as_me:$LINENO: checking for y0f in -lm" >&5
18316 echo $ECHO_N "checking for y0f in -lm... $ECHO_C" >&6
18317 if test "${ac_cv_lib_m_y0f+set}" = set; then
18318   echo $ECHO_N "(cached) $ECHO_C" >&6
18319 else
18320   ac_check_lib_save_LIBS=$LIBS
18321 LIBS="-lm  $LIBS"
18322 if test x$gcc_no_link = xyes; then
18323   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18324 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18325    { (exit 1); exit 1; }; }
18326 fi
18327 cat >conftest.$ac_ext <<_ACEOF
18328 /* confdefs.h.  */
18329 _ACEOF
18330 cat confdefs.h >>conftest.$ac_ext
18331 cat >>conftest.$ac_ext <<_ACEOF
18332 /* end confdefs.h.  */
18333
18334 /* Override any gcc2 internal prototype to avoid an error.  */
18335 #ifdef __cplusplus
18336 extern "C"
18337 #endif
18338 /* We use char because int might match the return type of a gcc2
18339    builtin and then its argument prototype would still apply.  */
18340 char y0f ();
18341 int
18342 main ()
18343 {
18344 y0f ();
18345   ;
18346   return 0;
18347 }
18348 _ACEOF
18349 rm -f conftest.$ac_objext conftest$ac_exeext
18350 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18351   (eval $ac_link) 2>conftest.er1
18352   ac_status=$?
18353   grep -v '^ *+' conftest.er1 >conftest.err
18354   rm -f conftest.er1
18355   cat conftest.err >&5
18356   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18357   (exit $ac_status); } &&
18358          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
18359   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18360   (eval $ac_try) 2>&5
18361   ac_status=$?
18362   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18363   (exit $ac_status); }; } &&
18364          { ac_try='test -s conftest$ac_exeext'
18365   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18366   (eval $ac_try) 2>&5
18367   ac_status=$?
18368   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18369   (exit $ac_status); }; }; then
18370   ac_cv_lib_m_y0f=yes
18371 else
18372   echo "$as_me: failed program was:" >&5
18373 sed 's/^/| /' conftest.$ac_ext >&5
18374
18375 ac_cv_lib_m_y0f=no
18376 fi
18377 rm -f conftest.err conftest.$ac_objext \
18378       conftest$ac_exeext conftest.$ac_ext
18379 LIBS=$ac_check_lib_save_LIBS
18380 fi
18381 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0f" >&5
18382 echo "${ECHO_T}$ac_cv_lib_m_y0f" >&6
18383 if test $ac_cv_lib_m_y0f = yes; then
18384
18385 cat >>confdefs.h <<\_ACEOF
18386 #define HAVE_Y0F 1
18387 _ACEOF
18388
18389 fi
18390
18391 echo "$as_me:$LINENO: checking for y0 in -lm" >&5
18392 echo $ECHO_N "checking for y0 in -lm... $ECHO_C" >&6
18393 if test "${ac_cv_lib_m_y0+set}" = set; then
18394   echo $ECHO_N "(cached) $ECHO_C" >&6
18395 else
18396   ac_check_lib_save_LIBS=$LIBS
18397 LIBS="-lm  $LIBS"
18398 if test x$gcc_no_link = xyes; then
18399   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18400 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18401    { (exit 1); exit 1; }; }
18402 fi
18403 cat >conftest.$ac_ext <<_ACEOF
18404 /* confdefs.h.  */
18405 _ACEOF
18406 cat confdefs.h >>conftest.$ac_ext
18407 cat >>conftest.$ac_ext <<_ACEOF
18408 /* end confdefs.h.  */
18409
18410 /* Override any gcc2 internal prototype to avoid an error.  */
18411 #ifdef __cplusplus
18412 extern "C"
18413 #endif
18414 /* We use char because int might match the return type of a gcc2
18415    builtin and then its argument prototype would still apply.  */
18416 char y0 ();
18417 int
18418 main ()
18419 {
18420 y0 ();
18421   ;
18422   return 0;
18423 }
18424 _ACEOF
18425 rm -f conftest.$ac_objext conftest$ac_exeext
18426 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18427   (eval $ac_link) 2>conftest.er1
18428   ac_status=$?
18429   grep -v '^ *+' conftest.er1 >conftest.err
18430   rm -f conftest.er1
18431   cat conftest.err >&5
18432   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18433   (exit $ac_status); } &&
18434          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
18435   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18436   (eval $ac_try) 2>&5
18437   ac_status=$?
18438   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18439   (exit $ac_status); }; } &&
18440          { ac_try='test -s conftest$ac_exeext'
18441   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18442   (eval $ac_try) 2>&5
18443   ac_status=$?
18444   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18445   (exit $ac_status); }; }; then
18446   ac_cv_lib_m_y0=yes
18447 else
18448   echo "$as_me: failed program was:" >&5
18449 sed 's/^/| /' conftest.$ac_ext >&5
18450
18451 ac_cv_lib_m_y0=no
18452 fi
18453 rm -f conftest.err conftest.$ac_objext \
18454       conftest$ac_exeext conftest.$ac_ext
18455 LIBS=$ac_check_lib_save_LIBS
18456 fi
18457 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0" >&5
18458 echo "${ECHO_T}$ac_cv_lib_m_y0" >&6
18459 if test $ac_cv_lib_m_y0 = yes; then
18460
18461 cat >>confdefs.h <<\_ACEOF
18462 #define HAVE_Y0 1
18463 _ACEOF
18464
18465 fi
18466
18467 echo "$as_me:$LINENO: checking for y0l in -lm" >&5
18468 echo $ECHO_N "checking for y0l in -lm... $ECHO_C" >&6
18469 if test "${ac_cv_lib_m_y0l+set}" = set; then
18470   echo $ECHO_N "(cached) $ECHO_C" >&6
18471 else
18472   ac_check_lib_save_LIBS=$LIBS
18473 LIBS="-lm  $LIBS"
18474 if test x$gcc_no_link = xyes; then
18475   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18476 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18477    { (exit 1); exit 1; }; }
18478 fi
18479 cat >conftest.$ac_ext <<_ACEOF
18480 /* confdefs.h.  */
18481 _ACEOF
18482 cat confdefs.h >>conftest.$ac_ext
18483 cat >>conftest.$ac_ext <<_ACEOF
18484 /* end confdefs.h.  */
18485
18486 /* Override any gcc2 internal prototype to avoid an error.  */
18487 #ifdef __cplusplus
18488 extern "C"
18489 #endif
18490 /* We use char because int might match the return type of a gcc2
18491    builtin and then its argument prototype would still apply.  */
18492 char y0l ();
18493 int
18494 main ()
18495 {
18496 y0l ();
18497   ;
18498   return 0;
18499 }
18500 _ACEOF
18501 rm -f conftest.$ac_objext conftest$ac_exeext
18502 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18503   (eval $ac_link) 2>conftest.er1
18504   ac_status=$?
18505   grep -v '^ *+' conftest.er1 >conftest.err
18506   rm -f conftest.er1
18507   cat conftest.err >&5
18508   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18509   (exit $ac_status); } &&
18510          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
18511   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18512   (eval $ac_try) 2>&5
18513   ac_status=$?
18514   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18515   (exit $ac_status); }; } &&
18516          { ac_try='test -s conftest$ac_exeext'
18517   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18518   (eval $ac_try) 2>&5
18519   ac_status=$?
18520   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18521   (exit $ac_status); }; }; then
18522   ac_cv_lib_m_y0l=yes
18523 else
18524   echo "$as_me: failed program was:" >&5
18525 sed 's/^/| /' conftest.$ac_ext >&5
18526
18527 ac_cv_lib_m_y0l=no
18528 fi
18529 rm -f conftest.err conftest.$ac_objext \
18530       conftest$ac_exeext conftest.$ac_ext
18531 LIBS=$ac_check_lib_save_LIBS
18532 fi
18533 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0l" >&5
18534 echo "${ECHO_T}$ac_cv_lib_m_y0l" >&6
18535 if test $ac_cv_lib_m_y0l = yes; then
18536
18537 cat >>confdefs.h <<\_ACEOF
18538 #define HAVE_Y0L 1
18539 _ACEOF
18540
18541 fi
18542
18543 echo "$as_me:$LINENO: checking for y1f in -lm" >&5
18544 echo $ECHO_N "checking for y1f in -lm... $ECHO_C" >&6
18545 if test "${ac_cv_lib_m_y1f+set}" = set; then
18546   echo $ECHO_N "(cached) $ECHO_C" >&6
18547 else
18548   ac_check_lib_save_LIBS=$LIBS
18549 LIBS="-lm  $LIBS"
18550 if test x$gcc_no_link = xyes; then
18551   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18552 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18553    { (exit 1); exit 1; }; }
18554 fi
18555 cat >conftest.$ac_ext <<_ACEOF
18556 /* confdefs.h.  */
18557 _ACEOF
18558 cat confdefs.h >>conftest.$ac_ext
18559 cat >>conftest.$ac_ext <<_ACEOF
18560 /* end confdefs.h.  */
18561
18562 /* Override any gcc2 internal prototype to avoid an error.  */
18563 #ifdef __cplusplus
18564 extern "C"
18565 #endif
18566 /* We use char because int might match the return type of a gcc2
18567    builtin and then its argument prototype would still apply.  */
18568 char y1f ();
18569 int
18570 main ()
18571 {
18572 y1f ();
18573   ;
18574   return 0;
18575 }
18576 _ACEOF
18577 rm -f conftest.$ac_objext conftest$ac_exeext
18578 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18579   (eval $ac_link) 2>conftest.er1
18580   ac_status=$?
18581   grep -v '^ *+' conftest.er1 >conftest.err
18582   rm -f conftest.er1
18583   cat conftest.err >&5
18584   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18585   (exit $ac_status); } &&
18586          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
18587   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18588   (eval $ac_try) 2>&5
18589   ac_status=$?
18590   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18591   (exit $ac_status); }; } &&
18592          { ac_try='test -s conftest$ac_exeext'
18593   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18594   (eval $ac_try) 2>&5
18595   ac_status=$?
18596   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18597   (exit $ac_status); }; }; then
18598   ac_cv_lib_m_y1f=yes
18599 else
18600   echo "$as_me: failed program was:" >&5
18601 sed 's/^/| /' conftest.$ac_ext >&5
18602
18603 ac_cv_lib_m_y1f=no
18604 fi
18605 rm -f conftest.err conftest.$ac_objext \
18606       conftest$ac_exeext conftest.$ac_ext
18607 LIBS=$ac_check_lib_save_LIBS
18608 fi
18609 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1f" >&5
18610 echo "${ECHO_T}$ac_cv_lib_m_y1f" >&6
18611 if test $ac_cv_lib_m_y1f = yes; then
18612
18613 cat >>confdefs.h <<\_ACEOF
18614 #define HAVE_Y1F 1
18615 _ACEOF
18616
18617 fi
18618
18619 echo "$as_me:$LINENO: checking for y1 in -lm" >&5
18620 echo $ECHO_N "checking for y1 in -lm... $ECHO_C" >&6
18621 if test "${ac_cv_lib_m_y1+set}" = set; then
18622   echo $ECHO_N "(cached) $ECHO_C" >&6
18623 else
18624   ac_check_lib_save_LIBS=$LIBS
18625 LIBS="-lm  $LIBS"
18626 if test x$gcc_no_link = xyes; then
18627   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18628 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18629    { (exit 1); exit 1; }; }
18630 fi
18631 cat >conftest.$ac_ext <<_ACEOF
18632 /* confdefs.h.  */
18633 _ACEOF
18634 cat confdefs.h >>conftest.$ac_ext
18635 cat >>conftest.$ac_ext <<_ACEOF
18636 /* end confdefs.h.  */
18637
18638 /* Override any gcc2 internal prototype to avoid an error.  */
18639 #ifdef __cplusplus
18640 extern "C"
18641 #endif
18642 /* We use char because int might match the return type of a gcc2
18643    builtin and then its argument prototype would still apply.  */
18644 char y1 ();
18645 int
18646 main ()
18647 {
18648 y1 ();
18649   ;
18650   return 0;
18651 }
18652 _ACEOF
18653 rm -f conftest.$ac_objext conftest$ac_exeext
18654 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18655   (eval $ac_link) 2>conftest.er1
18656   ac_status=$?
18657   grep -v '^ *+' conftest.er1 >conftest.err
18658   rm -f conftest.er1
18659   cat conftest.err >&5
18660   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18661   (exit $ac_status); } &&
18662          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
18663   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18664   (eval $ac_try) 2>&5
18665   ac_status=$?
18666   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18667   (exit $ac_status); }; } &&
18668          { ac_try='test -s conftest$ac_exeext'
18669   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18670   (eval $ac_try) 2>&5
18671   ac_status=$?
18672   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18673   (exit $ac_status); }; }; then
18674   ac_cv_lib_m_y1=yes
18675 else
18676   echo "$as_me: failed program was:" >&5
18677 sed 's/^/| /' conftest.$ac_ext >&5
18678
18679 ac_cv_lib_m_y1=no
18680 fi
18681 rm -f conftest.err conftest.$ac_objext \
18682       conftest$ac_exeext conftest.$ac_ext
18683 LIBS=$ac_check_lib_save_LIBS
18684 fi
18685 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1" >&5
18686 echo "${ECHO_T}$ac_cv_lib_m_y1" >&6
18687 if test $ac_cv_lib_m_y1 = yes; then
18688
18689 cat >>confdefs.h <<\_ACEOF
18690 #define HAVE_Y1 1
18691 _ACEOF
18692
18693 fi
18694
18695 echo "$as_me:$LINENO: checking for y1l in -lm" >&5
18696 echo $ECHO_N "checking for y1l in -lm... $ECHO_C" >&6
18697 if test "${ac_cv_lib_m_y1l+set}" = set; then
18698   echo $ECHO_N "(cached) $ECHO_C" >&6
18699 else
18700   ac_check_lib_save_LIBS=$LIBS
18701 LIBS="-lm  $LIBS"
18702 if test x$gcc_no_link = xyes; then
18703   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18704 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18705    { (exit 1); exit 1; }; }
18706 fi
18707 cat >conftest.$ac_ext <<_ACEOF
18708 /* confdefs.h.  */
18709 _ACEOF
18710 cat confdefs.h >>conftest.$ac_ext
18711 cat >>conftest.$ac_ext <<_ACEOF
18712 /* end confdefs.h.  */
18713
18714 /* Override any gcc2 internal prototype to avoid an error.  */
18715 #ifdef __cplusplus
18716 extern "C"
18717 #endif
18718 /* We use char because int might match the return type of a gcc2
18719    builtin and then its argument prototype would still apply.  */
18720 char y1l ();
18721 int
18722 main ()
18723 {
18724 y1l ();
18725   ;
18726   return 0;
18727 }
18728 _ACEOF
18729 rm -f conftest.$ac_objext conftest$ac_exeext
18730 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18731   (eval $ac_link) 2>conftest.er1
18732   ac_status=$?
18733   grep -v '^ *+' conftest.er1 >conftest.err
18734   rm -f conftest.er1
18735   cat conftest.err >&5
18736   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18737   (exit $ac_status); } &&
18738          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
18739   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18740   (eval $ac_try) 2>&5
18741   ac_status=$?
18742   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18743   (exit $ac_status); }; } &&
18744          { ac_try='test -s conftest$ac_exeext'
18745   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18746   (eval $ac_try) 2>&5
18747   ac_status=$?
18748   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18749   (exit $ac_status); }; }; then
18750   ac_cv_lib_m_y1l=yes
18751 else
18752   echo "$as_me: failed program was:" >&5
18753 sed 's/^/| /' conftest.$ac_ext >&5
18754
18755 ac_cv_lib_m_y1l=no
18756 fi
18757 rm -f conftest.err conftest.$ac_objext \
18758       conftest$ac_exeext conftest.$ac_ext
18759 LIBS=$ac_check_lib_save_LIBS
18760 fi
18761 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1l" >&5
18762 echo "${ECHO_T}$ac_cv_lib_m_y1l" >&6
18763 if test $ac_cv_lib_m_y1l = yes; then
18764
18765 cat >>confdefs.h <<\_ACEOF
18766 #define HAVE_Y1L 1
18767 _ACEOF
18768
18769 fi
18770
18771 echo "$as_me:$LINENO: checking for ynf in -lm" >&5
18772 echo $ECHO_N "checking for ynf in -lm... $ECHO_C" >&6
18773 if test "${ac_cv_lib_m_ynf+set}" = set; then
18774   echo $ECHO_N "(cached) $ECHO_C" >&6
18775 else
18776   ac_check_lib_save_LIBS=$LIBS
18777 LIBS="-lm  $LIBS"
18778 if test x$gcc_no_link = xyes; then
18779   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18780 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18781    { (exit 1); exit 1; }; }
18782 fi
18783 cat >conftest.$ac_ext <<_ACEOF
18784 /* confdefs.h.  */
18785 _ACEOF
18786 cat confdefs.h >>conftest.$ac_ext
18787 cat >>conftest.$ac_ext <<_ACEOF
18788 /* end confdefs.h.  */
18789
18790 /* Override any gcc2 internal prototype to avoid an error.  */
18791 #ifdef __cplusplus
18792 extern "C"
18793 #endif
18794 /* We use char because int might match the return type of a gcc2
18795    builtin and then its argument prototype would still apply.  */
18796 char ynf ();
18797 int
18798 main ()
18799 {
18800 ynf ();
18801   ;
18802   return 0;
18803 }
18804 _ACEOF
18805 rm -f conftest.$ac_objext conftest$ac_exeext
18806 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18807   (eval $ac_link) 2>conftest.er1
18808   ac_status=$?
18809   grep -v '^ *+' conftest.er1 >conftest.err
18810   rm -f conftest.er1
18811   cat conftest.err >&5
18812   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18813   (exit $ac_status); } &&
18814          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
18815   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18816   (eval $ac_try) 2>&5
18817   ac_status=$?
18818   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18819   (exit $ac_status); }; } &&
18820          { ac_try='test -s conftest$ac_exeext'
18821   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18822   (eval $ac_try) 2>&5
18823   ac_status=$?
18824   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18825   (exit $ac_status); }; }; then
18826   ac_cv_lib_m_ynf=yes
18827 else
18828   echo "$as_me: failed program was:" >&5
18829 sed 's/^/| /' conftest.$ac_ext >&5
18830
18831 ac_cv_lib_m_ynf=no
18832 fi
18833 rm -f conftest.err conftest.$ac_objext \
18834       conftest$ac_exeext conftest.$ac_ext
18835 LIBS=$ac_check_lib_save_LIBS
18836 fi
18837 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ynf" >&5
18838 echo "${ECHO_T}$ac_cv_lib_m_ynf" >&6
18839 if test $ac_cv_lib_m_ynf = yes; then
18840
18841 cat >>confdefs.h <<\_ACEOF
18842 #define HAVE_YNF 1
18843 _ACEOF
18844
18845 fi
18846
18847 echo "$as_me:$LINENO: checking for yn in -lm" >&5
18848 echo $ECHO_N "checking for yn in -lm... $ECHO_C" >&6
18849 if test "${ac_cv_lib_m_yn+set}" = set; then
18850   echo $ECHO_N "(cached) $ECHO_C" >&6
18851 else
18852   ac_check_lib_save_LIBS=$LIBS
18853 LIBS="-lm  $LIBS"
18854 if test x$gcc_no_link = xyes; then
18855   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18856 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18857    { (exit 1); exit 1; }; }
18858 fi
18859 cat >conftest.$ac_ext <<_ACEOF
18860 /* confdefs.h.  */
18861 _ACEOF
18862 cat confdefs.h >>conftest.$ac_ext
18863 cat >>conftest.$ac_ext <<_ACEOF
18864 /* end confdefs.h.  */
18865
18866 /* Override any gcc2 internal prototype to avoid an error.  */
18867 #ifdef __cplusplus
18868 extern "C"
18869 #endif
18870 /* We use char because int might match the return type of a gcc2
18871    builtin and then its argument prototype would still apply.  */
18872 char yn ();
18873 int
18874 main ()
18875 {
18876 yn ();
18877   ;
18878   return 0;
18879 }
18880 _ACEOF
18881 rm -f conftest.$ac_objext conftest$ac_exeext
18882 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18883   (eval $ac_link) 2>conftest.er1
18884   ac_status=$?
18885   grep -v '^ *+' conftest.er1 >conftest.err
18886   rm -f conftest.er1
18887   cat conftest.err >&5
18888   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18889   (exit $ac_status); } &&
18890          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
18891   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18892   (eval $ac_try) 2>&5
18893   ac_status=$?
18894   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18895   (exit $ac_status); }; } &&
18896          { ac_try='test -s conftest$ac_exeext'
18897   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18898   (eval $ac_try) 2>&5
18899   ac_status=$?
18900   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18901   (exit $ac_status); }; }; then
18902   ac_cv_lib_m_yn=yes
18903 else
18904   echo "$as_me: failed program was:" >&5
18905 sed 's/^/| /' conftest.$ac_ext >&5
18906
18907 ac_cv_lib_m_yn=no
18908 fi
18909 rm -f conftest.err conftest.$ac_objext \
18910       conftest$ac_exeext conftest.$ac_ext
18911 LIBS=$ac_check_lib_save_LIBS
18912 fi
18913 echo "$as_me:$LINENO: result: $ac_cv_lib_m_yn" >&5
18914 echo "${ECHO_T}$ac_cv_lib_m_yn" >&6
18915 if test $ac_cv_lib_m_yn = yes; then
18916
18917 cat >>confdefs.h <<\_ACEOF
18918 #define HAVE_YN 1
18919 _ACEOF
18920
18921 fi
18922
18923 echo "$as_me:$LINENO: checking for ynl in -lm" >&5
18924 echo $ECHO_N "checking for ynl in -lm... $ECHO_C" >&6
18925 if test "${ac_cv_lib_m_ynl+set}" = set; then
18926   echo $ECHO_N "(cached) $ECHO_C" >&6
18927 else
18928   ac_check_lib_save_LIBS=$LIBS
18929 LIBS="-lm  $LIBS"
18930 if test x$gcc_no_link = xyes; then
18931   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18932 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18933    { (exit 1); exit 1; }; }
18934 fi
18935 cat >conftest.$ac_ext <<_ACEOF
18936 /* confdefs.h.  */
18937 _ACEOF
18938 cat confdefs.h >>conftest.$ac_ext
18939 cat >>conftest.$ac_ext <<_ACEOF
18940 /* end confdefs.h.  */
18941
18942 /* Override any gcc2 internal prototype to avoid an error.  */
18943 #ifdef __cplusplus
18944 extern "C"
18945 #endif
18946 /* We use char because int might match the return type of a gcc2
18947    builtin and then its argument prototype would still apply.  */
18948 char ynl ();
18949 int
18950 main ()
18951 {
18952 ynl ();
18953   ;
18954   return 0;
18955 }
18956 _ACEOF
18957 rm -f conftest.$ac_objext conftest$ac_exeext
18958 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18959   (eval $ac_link) 2>conftest.er1
18960   ac_status=$?
18961   grep -v '^ *+' conftest.er1 >conftest.err
18962   rm -f conftest.er1
18963   cat conftest.err >&5
18964   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18965   (exit $ac_status); } &&
18966          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
18967   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18968   (eval $ac_try) 2>&5
18969   ac_status=$?
18970   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18971   (exit $ac_status); }; } &&
18972          { ac_try='test -s conftest$ac_exeext'
18973   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18974   (eval $ac_try) 2>&5
18975   ac_status=$?
18976   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18977   (exit $ac_status); }; }; then
18978   ac_cv_lib_m_ynl=yes
18979 else
18980   echo "$as_me: failed program was:" >&5
18981 sed 's/^/| /' conftest.$ac_ext >&5
18982
18983 ac_cv_lib_m_ynl=no
18984 fi
18985 rm -f conftest.err conftest.$ac_objext \
18986       conftest$ac_exeext conftest.$ac_ext
18987 LIBS=$ac_check_lib_save_LIBS
18988 fi
18989 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ynl" >&5
18990 echo "${ECHO_T}$ac_cv_lib_m_ynl" >&6
18991 if test $ac_cv_lib_m_ynl = yes; then
18992
18993 cat >>confdefs.h <<\_ACEOF
18994 #define HAVE_YNL 1
18995 _ACEOF
18996
18997 fi
18998
18999
19000 # On AIX, clog is present in libm as __clog
19001 echo "$as_me:$LINENO: checking for __clog in -lm" >&5
19002 echo $ECHO_N "checking for __clog in -lm... $ECHO_C" >&6
19003 if test "${ac_cv_lib_m___clog+set}" = set; then
19004   echo $ECHO_N "(cached) $ECHO_C" >&6
19005 else
19006   ac_check_lib_save_LIBS=$LIBS
19007 LIBS="-lm  $LIBS"
19008 if test x$gcc_no_link = xyes; then
19009   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19010 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19011    { (exit 1); exit 1; }; }
19012 fi
19013 cat >conftest.$ac_ext <<_ACEOF
19014 /* confdefs.h.  */
19015 _ACEOF
19016 cat confdefs.h >>conftest.$ac_ext
19017 cat >>conftest.$ac_ext <<_ACEOF
19018 /* end confdefs.h.  */
19019
19020 /* Override any gcc2 internal prototype to avoid an error.  */
19021 #ifdef __cplusplus
19022 extern "C"
19023 #endif
19024 /* We use char because int might match the return type of a gcc2
19025    builtin and then its argument prototype would still apply.  */
19026 char __clog ();
19027 int
19028 main ()
19029 {
19030 __clog ();
19031   ;
19032   return 0;
19033 }
19034 _ACEOF
19035 rm -f conftest.$ac_objext conftest$ac_exeext
19036 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19037   (eval $ac_link) 2>conftest.er1
19038   ac_status=$?
19039   grep -v '^ *+' conftest.er1 >conftest.err
19040   rm -f conftest.er1
19041   cat conftest.err >&5
19042   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19043   (exit $ac_status); } &&
19044          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
19045   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19046   (eval $ac_try) 2>&5
19047   ac_status=$?
19048   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19049   (exit $ac_status); }; } &&
19050          { ac_try='test -s conftest$ac_exeext'
19051   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19052   (eval $ac_try) 2>&5
19053   ac_status=$?
19054   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19055   (exit $ac_status); }; }; then
19056   ac_cv_lib_m___clog=yes
19057 else
19058   echo "$as_me: failed program was:" >&5
19059 sed 's/^/| /' conftest.$ac_ext >&5
19060
19061 ac_cv_lib_m___clog=no
19062 fi
19063 rm -f conftest.err conftest.$ac_objext \
19064       conftest$ac_exeext conftest.$ac_ext
19065 LIBS=$ac_check_lib_save_LIBS
19066 fi
19067 echo "$as_me:$LINENO: result: $ac_cv_lib_m___clog" >&5
19068 echo "${ECHO_T}$ac_cv_lib_m___clog" >&6
19069 if test $ac_cv_lib_m___clog = yes; then
19070
19071 cat >>confdefs.h <<\_ACEOF
19072 #define HAVE_CLOG 1
19073 _ACEOF
19074
19075 fi
19076
19077
19078 # Check for a isfinite macro that works on long doubles.
19079
19080   echo "$as_me:$LINENO: checking whether isfinite is broken" >&5
19081 echo $ECHO_N "checking whether isfinite is broken... $ECHO_C" >&6
19082 if test "${have_broken_isfinite+set}" = set; then
19083   echo $ECHO_N "(cached) $ECHO_C" >&6
19084 else
19085
19086   libgfor_check_for_broken_isfinite_save_LIBS=$LIBS
19087   LIBS="$LIBS -lm"
19088   if test "$cross_compiling" = yes; then
19089
19090 case "${target}" in
19091   hppa*-*-hpux*) have_broken_isfinite=yes ;;
19092   *) have_broken_isfinite=no ;;
19093 esac
19094 else
19095   cat >conftest.$ac_ext <<_ACEOF
19096 /* confdefs.h.  */
19097 _ACEOF
19098 cat confdefs.h >>conftest.$ac_ext
19099 cat >>conftest.$ac_ext <<_ACEOF
19100 /* end confdefs.h.  */
19101
19102 #ifdef HAVE_MATH_H
19103 #include <math.h>
19104 #endif
19105 #include <float.h>
19106 int main ()
19107 {
19108 #ifdef isfinite
19109 #ifdef LDBL_MAX
19110   if (!isfinite(LDBL_MAX)) return 1;
19111 #endif
19112 #ifdef DBL_MAX
19113   if (!isfinite(DBL_MAX)) return 1;
19114 #endif
19115 #endif
19116 return 0;
19117 }
19118 _ACEOF
19119 rm -f conftest$ac_exeext
19120 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19121   (eval $ac_link) 2>&5
19122   ac_status=$?
19123   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19124   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
19125   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19126   (eval $ac_try) 2>&5
19127   ac_status=$?
19128   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19129   (exit $ac_status); }; }; then
19130   have_broken_isfinite=no
19131 else
19132   echo "$as_me: program exited with status $ac_status" >&5
19133 echo "$as_me: failed program was:" >&5
19134 sed 's/^/| /' conftest.$ac_ext >&5
19135
19136 ( exit $ac_status )
19137 have_broken_isfinite=yes
19138 fi
19139 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
19140 fi
19141   LIBS=$libgfor_check_for_broken_isfinite_save_LIBS
19142 fi
19143 echo "$as_me:$LINENO: result: $have_broken_isfinite" >&5
19144 echo "${ECHO_T}$have_broken_isfinite" >&6
19145 if test x"$have_broken_isfinite" = xyes; then
19146
19147 cat >>confdefs.h <<\_ACEOF
19148 #define HAVE_BROKEN_ISFINITE 1
19149 _ACEOF
19150
19151 fi
19152
19153 # Check for a isnan macro that works on long doubles.
19154
19155   echo "$as_me:$LINENO: checking whether isnan is broken" >&5
19156 echo $ECHO_N "checking whether isnan is broken... $ECHO_C" >&6
19157 if test "${have_broken_isnan+set}" = set; then
19158   echo $ECHO_N "(cached) $ECHO_C" >&6
19159 else
19160
19161   libgfor_check_for_broken_isnan_save_LIBS=$LIBS
19162   LIBS="$LIBS -lm"
19163   if test "$cross_compiling" = yes; then
19164
19165 case "${target}" in
19166   hppa*-*-hpux*) have_broken_isnan=yes ;;
19167   *) have_broken_isnan=no ;;
19168 esac
19169 else
19170   cat >conftest.$ac_ext <<_ACEOF
19171 /* confdefs.h.  */
19172 _ACEOF
19173 cat confdefs.h >>conftest.$ac_ext
19174 cat >>conftest.$ac_ext <<_ACEOF
19175 /* end confdefs.h.  */
19176
19177 #ifdef HAVE_MATH_H
19178 #include <math.h>
19179 #endif
19180 #include <float.h>
19181 int main ()
19182 {
19183 #ifdef isnan
19184 #ifdef LDBL_MAX
19185   {
19186     long double x;
19187     x = __builtin_nanl ("");
19188     if (!isnan(x)) return 1;
19189     if (isnan(LDBL_MAX)) return 1;
19190 #ifdef NAN
19191     x = (long double) NAN;
19192     if (!isnan(x)) return 1;
19193 #endif
19194   }
19195 #endif
19196 #ifdef DBL_MAX
19197   {
19198     double y;
19199     y = __builtin_nan ("");
19200     if (!isnan(y)) return 1;
19201     if (isnan(DBL_MAX)) return 1;
19202 #ifdef NAN
19203     y = (double) NAN;
19204     if (!isnan(y)) return 1;
19205 #endif
19206   }
19207 #endif
19208 #endif
19209 return 0;
19210 }
19211 _ACEOF
19212 rm -f conftest$ac_exeext
19213 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19214   (eval $ac_link) 2>&5
19215   ac_status=$?
19216   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19217   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
19218   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19219   (eval $ac_try) 2>&5
19220   ac_status=$?
19221   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19222   (exit $ac_status); }; }; then
19223   have_broken_isnan=no
19224 else
19225   echo "$as_me: program exited with status $ac_status" >&5
19226 echo "$as_me: failed program was:" >&5
19227 sed 's/^/| /' conftest.$ac_ext >&5
19228
19229 ( exit $ac_status )
19230 have_broken_isnan=yes
19231 fi
19232 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
19233 fi
19234   LIBS=$libgfor_check_for_broken_isnan_save_LIBS
19235 fi
19236 echo "$as_me:$LINENO: result: $have_broken_isnan" >&5
19237 echo "${ECHO_T}$have_broken_isnan" >&6
19238 if test x"$have_broken_isnan" = xyes; then
19239
19240 cat >>confdefs.h <<\_ACEOF
19241 #define HAVE_BROKEN_ISNAN 1
19242 _ACEOF
19243
19244 fi
19245
19246 # Check for a fpclassify macro that works on long doubles.
19247
19248   echo "$as_me:$LINENO: checking whether fpclassify is broken" >&5
19249 echo $ECHO_N "checking whether fpclassify is broken... $ECHO_C" >&6
19250 if test "${have_broken_fpclassify+set}" = set; then
19251   echo $ECHO_N "(cached) $ECHO_C" >&6
19252 else
19253
19254   libgfor_check_for_broken_fpclassify_save_LIBS=$LIBS
19255   LIBS="$LIBS -lm"
19256   if test "$cross_compiling" = yes; then
19257
19258 case "${target}" in
19259   hppa*-*-hpux*) have_broken_fpclassify=yes ;;
19260   *) have_broken_fpclassify=no ;;
19261 esac
19262 else
19263   cat >conftest.$ac_ext <<_ACEOF
19264 /* confdefs.h.  */
19265 _ACEOF
19266 cat confdefs.h >>conftest.$ac_ext
19267 cat >>conftest.$ac_ext <<_ACEOF
19268 /* end confdefs.h.  */
19269
19270 #ifdef HAVE_MATH_H
19271 #include <math.h>
19272 #endif
19273 #include <float.h>
19274 int main ()
19275 {
19276 #ifdef fpclassify
19277 #ifdef LDBL_MAX
19278         if (fpclassify(LDBL_MAX) == FP_NAN
19279             || fpclassify(LDBL_MAX) == FP_INFINITE) return 1;
19280 #endif
19281 #ifdef DBL_MAX
19282         if (fpclassify(DBL_MAX) == FP_NAN
19283             || fpclassify(DBL_MAX) == FP_INFINITE) return 1;
19284 #endif
19285 #endif
19286 return 0;
19287 }
19288 _ACEOF
19289 rm -f conftest$ac_exeext
19290 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19291   (eval $ac_link) 2>&5
19292   ac_status=$?
19293   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19294   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
19295   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19296   (eval $ac_try) 2>&5
19297   ac_status=$?
19298   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19299   (exit $ac_status); }; }; then
19300   have_broken_fpclassify=no
19301 else
19302   echo "$as_me: program exited with status $ac_status" >&5
19303 echo "$as_me: failed program was:" >&5
19304 sed 's/^/| /' conftest.$ac_ext >&5
19305
19306 ( exit $ac_status )
19307 have_broken_fpclassify=yes
19308 fi
19309 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
19310 fi
19311   LIBS=$libgfor_check_for_broken_fpclassify_save_LIBS
19312 fi
19313 echo "$as_me:$LINENO: result: $have_broken_fpclassify" >&5
19314 echo "${ECHO_T}$have_broken_fpclassify" >&6
19315 if test x"$have_broken_fpclassify" = xyes; then
19316
19317 cat >>confdefs.h <<\_ACEOF
19318 #define HAVE_BROKEN_FPCLASSIFY 1
19319 _ACEOF
19320
19321 fi
19322
19323 # Check whether the system has a working stat()
19324
19325   echo "$as_me:$LINENO: checking whether the target stat is reliable" >&5
19326 echo $ECHO_N "checking whether the target stat is reliable... $ECHO_C" >&6
19327 if test "${have_working_stat+set}" = set; then
19328   echo $ECHO_N "(cached) $ECHO_C" >&6
19329 else
19330
19331   if test "$cross_compiling" = yes; then
19332
19333 case "${target}" in
19334   *mingw*) have_working_stat=no ;;
19335   *) have_working_stat=yes;;
19336 esac
19337 else
19338   cat >conftest.$ac_ext <<_ACEOF
19339 /* confdefs.h.  */
19340 _ACEOF
19341 cat confdefs.h >>conftest.$ac_ext
19342 cat >>conftest.$ac_ext <<_ACEOF
19343 /* end confdefs.h.  */
19344
19345 #include <stdio.h>
19346 #include <sys/types.h>
19347 #include <sys/stat.h>
19348 #include <unistd.h>
19349
19350 int main ()
19351 {
19352   FILE *f, *g;
19353   struct stat st1, st2;
19354
19355   f = fopen ("foo", "w");
19356   g = fopen ("bar", "w");
19357   if (stat ("foo", &st1) != 0 || stat ("bar", &st2))
19358     return 1;
19359   if (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino)
19360     return 1;
19361   fclose(f);
19362   fclose(g);
19363   return 0;
19364 }
19365 _ACEOF
19366 rm -f conftest$ac_exeext
19367 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19368   (eval $ac_link) 2>&5
19369   ac_status=$?
19370   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19371   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
19372   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19373   (eval $ac_try) 2>&5
19374   ac_status=$?
19375   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19376   (exit $ac_status); }; }; then
19377   have_working_stat=yes
19378 else
19379   echo "$as_me: program exited with status $ac_status" >&5
19380 echo "$as_me: failed program was:" >&5
19381 sed 's/^/| /' conftest.$ac_ext >&5
19382
19383 ( exit $ac_status )
19384 have_working_stat=no
19385 fi
19386 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
19387 fi
19388 fi
19389 echo "$as_me:$LINENO: result: $have_working_stat" >&5
19390 echo "${ECHO_T}$have_working_stat" >&6
19391 if test x"$have_working_stat" = xyes; then
19392
19393 cat >>confdefs.h <<\_ACEOF
19394 #define HAVE_WORKING_STAT 1
19395 _ACEOF
19396
19397 fi
19398
19399 # Fallback in case isfinite is not available.
19400 echo "$as_me:$LINENO: checking for finite in -lm" >&5
19401 echo $ECHO_N "checking for finite in -lm... $ECHO_C" >&6
19402 if test "${ac_cv_lib_m_finite+set}" = set; then
19403   echo $ECHO_N "(cached) $ECHO_C" >&6
19404 else
19405   ac_check_lib_save_LIBS=$LIBS
19406 LIBS="-lm  $LIBS"
19407 if test x$gcc_no_link = xyes; then
19408   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19409 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19410    { (exit 1); exit 1; }; }
19411 fi
19412 cat >conftest.$ac_ext <<_ACEOF
19413 /* confdefs.h.  */
19414 _ACEOF
19415 cat confdefs.h >>conftest.$ac_ext
19416 cat >>conftest.$ac_ext <<_ACEOF
19417 /* end confdefs.h.  */
19418
19419 /* Override any gcc2 internal prototype to avoid an error.  */
19420 #ifdef __cplusplus
19421 extern "C"
19422 #endif
19423 /* We use char because int might match the return type of a gcc2
19424    builtin and then its argument prototype would still apply.  */
19425 char finite ();
19426 int
19427 main ()
19428 {
19429 finite ();
19430   ;
19431   return 0;
19432 }
19433 _ACEOF
19434 rm -f conftest.$ac_objext conftest$ac_exeext
19435 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19436   (eval $ac_link) 2>conftest.er1
19437   ac_status=$?
19438   grep -v '^ *+' conftest.er1 >conftest.err
19439   rm -f conftest.er1
19440   cat conftest.err >&5
19441   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19442   (exit $ac_status); } &&
19443          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
19444   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19445   (eval $ac_try) 2>&5
19446   ac_status=$?
19447   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19448   (exit $ac_status); }; } &&
19449          { ac_try='test -s conftest$ac_exeext'
19450   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19451   (eval $ac_try) 2>&5
19452   ac_status=$?
19453   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19454   (exit $ac_status); }; }; then
19455   ac_cv_lib_m_finite=yes
19456 else
19457   echo "$as_me: failed program was:" >&5
19458 sed 's/^/| /' conftest.$ac_ext >&5
19459
19460 ac_cv_lib_m_finite=no
19461 fi
19462 rm -f conftest.err conftest.$ac_objext \
19463       conftest$ac_exeext conftest.$ac_ext
19464 LIBS=$ac_check_lib_save_LIBS
19465 fi
19466 echo "$as_me:$LINENO: result: $ac_cv_lib_m_finite" >&5
19467 echo "${ECHO_T}$ac_cv_lib_m_finite" >&6
19468 if test $ac_cv_lib_m_finite = yes; then
19469
19470 cat >>confdefs.h <<\_ACEOF
19471 #define HAVE_FINITE 1
19472 _ACEOF
19473
19474 fi
19475
19476
19477 # Check for GNU libc feenableexcept
19478 echo "$as_me:$LINENO: checking for feenableexcept in -lm" >&5
19479 echo $ECHO_N "checking for feenableexcept in -lm... $ECHO_C" >&6
19480 if test "${ac_cv_lib_m_feenableexcept+set}" = set; then
19481   echo $ECHO_N "(cached) $ECHO_C" >&6
19482 else
19483   ac_check_lib_save_LIBS=$LIBS
19484 LIBS="-lm  $LIBS"
19485 if test x$gcc_no_link = xyes; then
19486   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19487 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19488    { (exit 1); exit 1; }; }
19489 fi
19490 cat >conftest.$ac_ext <<_ACEOF
19491 /* confdefs.h.  */
19492 _ACEOF
19493 cat confdefs.h >>conftest.$ac_ext
19494 cat >>conftest.$ac_ext <<_ACEOF
19495 /* end confdefs.h.  */
19496
19497 /* Override any gcc2 internal prototype to avoid an error.  */
19498 #ifdef __cplusplus
19499 extern "C"
19500 #endif
19501 /* We use char because int might match the return type of a gcc2
19502    builtin and then its argument prototype would still apply.  */
19503 char feenableexcept ();
19504 int
19505 main ()
19506 {
19507 feenableexcept ();
19508   ;
19509   return 0;
19510 }
19511 _ACEOF
19512 rm -f conftest.$ac_objext conftest$ac_exeext
19513 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19514   (eval $ac_link) 2>conftest.er1
19515   ac_status=$?
19516   grep -v '^ *+' conftest.er1 >conftest.err
19517   rm -f conftest.er1
19518   cat conftest.err >&5
19519   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19520   (exit $ac_status); } &&
19521          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
19522   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19523   (eval $ac_try) 2>&5
19524   ac_status=$?
19525   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19526   (exit $ac_status); }; } &&
19527          { ac_try='test -s conftest$ac_exeext'
19528   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19529   (eval $ac_try) 2>&5
19530   ac_status=$?
19531   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19532   (exit $ac_status); }; }; then
19533   ac_cv_lib_m_feenableexcept=yes
19534 else
19535   echo "$as_me: failed program was:" >&5
19536 sed 's/^/| /' conftest.$ac_ext >&5
19537
19538 ac_cv_lib_m_feenableexcept=no
19539 fi
19540 rm -f conftest.err conftest.$ac_objext \
19541       conftest$ac_exeext conftest.$ac_ext
19542 LIBS=$ac_check_lib_save_LIBS
19543 fi
19544 echo "$as_me:$LINENO: result: $ac_cv_lib_m_feenableexcept" >&5
19545 echo "${ECHO_T}$ac_cv_lib_m_feenableexcept" >&6
19546 if test $ac_cv_lib_m_feenableexcept = yes; then
19547   have_feenableexcept=yes
19548 cat >>confdefs.h <<\_ACEOF
19549 #define HAVE_FEENABLEEXCEPT 1
19550 _ACEOF
19551
19552 fi
19553
19554
19555 # Check for SysV fpsetmask
19556
19557   echo "$as_me:$LINENO: checking whether fpsetmask is present" >&5
19558 echo $ECHO_N "checking whether fpsetmask is present... $ECHO_C" >&6
19559 if test "${have_fpsetmask+set}" = set; then
19560   echo $ECHO_N "(cached) $ECHO_C" >&6
19561 else
19562
19563     if test x$gcc_no_link = xyes; then
19564   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19565 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19566    { (exit 1); exit 1; }; }
19567 fi
19568 cat >conftest.$ac_ext <<_ACEOF
19569 /* confdefs.h.  */
19570 _ACEOF
19571 cat confdefs.h >>conftest.$ac_ext
19572 cat >>conftest.$ac_ext <<_ACEOF
19573 /* end confdefs.h.  */
19574
19575 #if HAVE_FLOATINGPOINT_H
19576 # include <floatingpoint.h>
19577 #endif /* HAVE_FLOATINGPOINT_H */
19578 #if HAVE_IEEEFP_H
19579 # include <ieeefp.h>
19580 #endif /* HAVE_IEEEFP_H */
19581 int
19582 main ()
19583 {
19584 fpsetmask(0);
19585   ;
19586   return 0;
19587 }
19588 _ACEOF
19589 rm -f conftest.$ac_objext conftest$ac_exeext
19590 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19591   (eval $ac_link) 2>conftest.er1
19592   ac_status=$?
19593   grep -v '^ *+' conftest.er1 >conftest.err
19594   rm -f conftest.er1
19595   cat conftest.err >&5
19596   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19597   (exit $ac_status); } &&
19598          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
19599   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19600   (eval $ac_try) 2>&5
19601   ac_status=$?
19602   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19603   (exit $ac_status); }; } &&
19604          { ac_try='test -s conftest$ac_exeext'
19605   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19606   (eval $ac_try) 2>&5
19607   ac_status=$?
19608   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19609   (exit $ac_status); }; }; then
19610   eval "have_fpsetmask=yes"
19611 else
19612   echo "$as_me: failed program was:" >&5
19613 sed 's/^/| /' conftest.$ac_ext >&5
19614
19615 eval "have_fpsetmask=no"
19616 fi
19617 rm -f conftest.err conftest.$ac_objext \
19618       conftest$ac_exeext conftest.$ac_ext
19619
19620 fi
19621 echo "$as_me:$LINENO: result: $have_fpsetmask" >&5
19622 echo "${ECHO_T}$have_fpsetmask" >&6
19623   if test x"$have_fpsetmask" = xyes; then
19624
19625 cat >>confdefs.h <<\_ACEOF
19626 #define HAVE_FPSETMASK 1
19627 _ACEOF
19628
19629   fi
19630
19631
19632 # Check for AIX fp_trap and fp_enable
19633 echo "$as_me:$LINENO: checking for fp_trap" >&5
19634 echo $ECHO_N "checking for fp_trap... $ECHO_C" >&6
19635 if test "${ac_cv_func_fp_trap+set}" = set; then
19636   echo $ECHO_N "(cached) $ECHO_C" >&6
19637 else
19638   if test x$gcc_no_link = xyes; then
19639   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19640 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19641    { (exit 1); exit 1; }; }
19642 fi
19643 cat >conftest.$ac_ext <<_ACEOF
19644 /* confdefs.h.  */
19645 _ACEOF
19646 cat confdefs.h >>conftest.$ac_ext
19647 cat >>conftest.$ac_ext <<_ACEOF
19648 /* end confdefs.h.  */
19649 /* Define fp_trap to an innocuous variant, in case <limits.h> declares fp_trap.
19650    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
19651 #define fp_trap innocuous_fp_trap
19652
19653 /* System header to define __stub macros and hopefully few prototypes,
19654     which can conflict with char fp_trap (); below.
19655     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
19656     <limits.h> exists even on freestanding compilers.  */
19657
19658 #ifdef __STDC__
19659 # include <limits.h>
19660 #else
19661 # include <assert.h>
19662 #endif
19663
19664 #undef fp_trap
19665
19666 /* Override any gcc2 internal prototype to avoid an error.  */
19667 #ifdef __cplusplus
19668 extern "C"
19669 {
19670 #endif
19671 /* We use char because int might match the return type of a gcc2
19672    builtin and then its argument prototype would still apply.  */
19673 char fp_trap ();
19674 /* The GNU C library defines this for functions which it implements
19675     to always fail with ENOSYS.  Some functions are actually named
19676     something starting with __ and the normal name is an alias.  */
19677 #if defined (__stub_fp_trap) || defined (__stub___fp_trap)
19678 choke me
19679 #else
19680 char (*f) () = fp_trap;
19681 #endif
19682 #ifdef __cplusplus
19683 }
19684 #endif
19685
19686 int
19687 main ()
19688 {
19689 return f != fp_trap;
19690   ;
19691   return 0;
19692 }
19693 _ACEOF
19694 rm -f conftest.$ac_objext conftest$ac_exeext
19695 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19696   (eval $ac_link) 2>conftest.er1
19697   ac_status=$?
19698   grep -v '^ *+' conftest.er1 >conftest.err
19699   rm -f conftest.er1
19700   cat conftest.err >&5
19701   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19702   (exit $ac_status); } &&
19703          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
19704   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19705   (eval $ac_try) 2>&5
19706   ac_status=$?
19707   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19708   (exit $ac_status); }; } &&
19709          { ac_try='test -s conftest$ac_exeext'
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); }; }; then
19715   ac_cv_func_fp_trap=yes
19716 else
19717   echo "$as_me: failed program was:" >&5
19718 sed 's/^/| /' conftest.$ac_ext >&5
19719
19720 ac_cv_func_fp_trap=no
19721 fi
19722 rm -f conftest.err conftest.$ac_objext \
19723       conftest$ac_exeext conftest.$ac_ext
19724 fi
19725 echo "$as_me:$LINENO: result: $ac_cv_func_fp_trap" >&5
19726 echo "${ECHO_T}$ac_cv_func_fp_trap" >&6
19727 if test $ac_cv_func_fp_trap = yes; then
19728   have_fp_trap=yes
19729 cat >>confdefs.h <<\_ACEOF
19730 #define HAVE_FP_TRAP 1
19731 _ACEOF
19732
19733 fi
19734
19735 echo "$as_me:$LINENO: checking for fp_enable" >&5
19736 echo $ECHO_N "checking for fp_enable... $ECHO_C" >&6
19737 if test "${ac_cv_func_fp_enable+set}" = set; then
19738   echo $ECHO_N "(cached) $ECHO_C" >&6
19739 else
19740   if test x$gcc_no_link = xyes; then
19741   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19742 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19743    { (exit 1); exit 1; }; }
19744 fi
19745 cat >conftest.$ac_ext <<_ACEOF
19746 /* confdefs.h.  */
19747 _ACEOF
19748 cat confdefs.h >>conftest.$ac_ext
19749 cat >>conftest.$ac_ext <<_ACEOF
19750 /* end confdefs.h.  */
19751 /* Define fp_enable to an innocuous variant, in case <limits.h> declares fp_enable.
19752    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
19753 #define fp_enable innocuous_fp_enable
19754
19755 /* System header to define __stub macros and hopefully few prototypes,
19756     which can conflict with char fp_enable (); below.
19757     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
19758     <limits.h> exists even on freestanding compilers.  */
19759
19760 #ifdef __STDC__
19761 # include <limits.h>
19762 #else
19763 # include <assert.h>
19764 #endif
19765
19766 #undef fp_enable
19767
19768 /* Override any gcc2 internal prototype to avoid an error.  */
19769 #ifdef __cplusplus
19770 extern "C"
19771 {
19772 #endif
19773 /* We use char because int might match the return type of a gcc2
19774    builtin and then its argument prototype would still apply.  */
19775 char fp_enable ();
19776 /* The GNU C library defines this for functions which it implements
19777     to always fail with ENOSYS.  Some functions are actually named
19778     something starting with __ and the normal name is an alias.  */
19779 #if defined (__stub_fp_enable) || defined (__stub___fp_enable)
19780 choke me
19781 #else
19782 char (*f) () = fp_enable;
19783 #endif
19784 #ifdef __cplusplus
19785 }
19786 #endif
19787
19788 int
19789 main ()
19790 {
19791 return f != fp_enable;
19792   ;
19793   return 0;
19794 }
19795 _ACEOF
19796 rm -f conftest.$ac_objext conftest$ac_exeext
19797 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19798   (eval $ac_link) 2>conftest.er1
19799   ac_status=$?
19800   grep -v '^ *+' conftest.er1 >conftest.err
19801   rm -f conftest.er1
19802   cat conftest.err >&5
19803   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19804   (exit $ac_status); } &&
19805          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
19806   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19807   (eval $ac_try) 2>&5
19808   ac_status=$?
19809   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19810   (exit $ac_status); }; } &&
19811          { ac_try='test -s conftest$ac_exeext'
19812   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19813   (eval $ac_try) 2>&5
19814   ac_status=$?
19815   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19816   (exit $ac_status); }; }; then
19817   ac_cv_func_fp_enable=yes
19818 else
19819   echo "$as_me: failed program was:" >&5
19820 sed 's/^/| /' conftest.$ac_ext >&5
19821
19822 ac_cv_func_fp_enable=no
19823 fi
19824 rm -f conftest.err conftest.$ac_objext \
19825       conftest$ac_exeext conftest.$ac_ext
19826 fi
19827 echo "$as_me:$LINENO: result: $ac_cv_func_fp_enable" >&5
19828 echo "${ECHO_T}$ac_cv_func_fp_enable" >&6
19829 if test $ac_cv_func_fp_enable = yes; then
19830   have_fp_enable=yes
19831 cat >>confdefs.h <<\_ACEOF
19832 #define HAVE_FP_ENABLE 1
19833 _ACEOF
19834
19835 fi
19836
19837
19838 # Runs configure.host to set up necessary host-dependent shell variables.
19839 # We then display a message about it, and propagate them through the
19840 # build chain.
19841 . ${srcdir}/configure.host
19842 { echo "$as_me:$LINENO: FPU dependent file will be ${fpu_host}.h" >&5
19843 echo "$as_me: FPU dependent file will be ${fpu_host}.h" >&6;}
19844 FPU_HOST_HEADER=config/${fpu_host}.h
19845
19846
19847 # The standard autoconf HAVE_STRUCT_TIMEZONE doesn't actually check
19848 # for struct timezone, as you might think.  We also need to check how
19849 # to call gettimeofday if we have it.
19850 echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
19851 echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
19852 if test "${ac_cv_header_time+set}" = set; then
19853   echo $ECHO_N "(cached) $ECHO_C" >&6
19854 else
19855   cat >conftest.$ac_ext <<_ACEOF
19856 /* confdefs.h.  */
19857 _ACEOF
19858 cat confdefs.h >>conftest.$ac_ext
19859 cat >>conftest.$ac_ext <<_ACEOF
19860 /* end confdefs.h.  */
19861 #include <sys/types.h>
19862 #include <sys/time.h>
19863 #include <time.h>
19864
19865 int
19866 main ()
19867 {
19868 if ((struct tm *) 0)
19869 return 0;
19870   ;
19871   return 0;
19872 }
19873 _ACEOF
19874 rm -f conftest.$ac_objext
19875 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
19876   (eval $ac_compile) 2>conftest.er1
19877   ac_status=$?
19878   grep -v '^ *+' conftest.er1 >conftest.err
19879   rm -f conftest.er1
19880   cat conftest.err >&5
19881   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19882   (exit $ac_status); } &&
19883          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
19884   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19885   (eval $ac_try) 2>&5
19886   ac_status=$?
19887   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19888   (exit $ac_status); }; } &&
19889          { ac_try='test -s conftest.$ac_objext'
19890   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19891   (eval $ac_try) 2>&5
19892   ac_status=$?
19893   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19894   (exit $ac_status); }; }; then
19895   ac_cv_header_time=yes
19896 else
19897   echo "$as_me: failed program was:" >&5
19898 sed 's/^/| /' conftest.$ac_ext >&5
19899
19900 ac_cv_header_time=no
19901 fi
19902 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
19903 fi
19904 echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
19905 echo "${ECHO_T}$ac_cv_header_time" >&6
19906 if test $ac_cv_header_time = yes; then
19907
19908 cat >>confdefs.h <<\_ACEOF
19909 #define TIME_WITH_SYS_TIME 1
19910 _ACEOF
19911
19912 fi
19913
19914
19915
19916 for ac_func in gettimeofday
19917 do
19918 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
19919 echo "$as_me:$LINENO: checking for $ac_func" >&5
19920 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
19921 if eval "test \"\${$as_ac_var+set}\" = set"; then
19922   echo $ECHO_N "(cached) $ECHO_C" >&6
19923 else
19924   if test x$gcc_no_link = xyes; then
19925   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19926 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19927    { (exit 1); exit 1; }; }
19928 fi
19929 cat >conftest.$ac_ext <<_ACEOF
19930 /* confdefs.h.  */
19931 _ACEOF
19932 cat confdefs.h >>conftest.$ac_ext
19933 cat >>conftest.$ac_ext <<_ACEOF
19934 /* end confdefs.h.  */
19935 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
19936    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
19937 #define $ac_func innocuous_$ac_func
19938
19939 /* System header to define __stub macros and hopefully few prototypes,
19940     which can conflict with char $ac_func (); below.
19941     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
19942     <limits.h> exists even on freestanding compilers.  */
19943
19944 #ifdef __STDC__
19945 # include <limits.h>
19946 #else
19947 # include <assert.h>
19948 #endif
19949
19950 #undef $ac_func
19951
19952 /* Override any gcc2 internal prototype to avoid an error.  */
19953 #ifdef __cplusplus
19954 extern "C"
19955 {
19956 #endif
19957 /* We use char because int might match the return type of a gcc2
19958    builtin and then its argument prototype would still apply.  */
19959 char $ac_func ();
19960 /* The GNU C library defines this for functions which it implements
19961     to always fail with ENOSYS.  Some functions are actually named
19962     something starting with __ and the normal name is an alias.  */
19963 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
19964 choke me
19965 #else
19966 char (*f) () = $ac_func;
19967 #endif
19968 #ifdef __cplusplus
19969 }
19970 #endif
19971
19972 int
19973 main ()
19974 {
19975 return f != $ac_func;
19976   ;
19977   return 0;
19978 }
19979 _ACEOF
19980 rm -f conftest.$ac_objext conftest$ac_exeext
19981 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19982   (eval $ac_link) 2>conftest.er1
19983   ac_status=$?
19984   grep -v '^ *+' conftest.er1 >conftest.err
19985   rm -f conftest.er1
19986   cat conftest.err >&5
19987   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19988   (exit $ac_status); } &&
19989          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
19990   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19991   (eval $ac_try) 2>&5
19992   ac_status=$?
19993   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19994   (exit $ac_status); }; } &&
19995          { ac_try='test -s conftest$ac_exeext'
19996   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19997   (eval $ac_try) 2>&5
19998   ac_status=$?
19999   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20000   (exit $ac_status); }; }; then
20001   eval "$as_ac_var=yes"
20002 else
20003   echo "$as_me: failed program was:" >&5
20004 sed 's/^/| /' conftest.$ac_ext >&5
20005
20006 eval "$as_ac_var=no"
20007 fi
20008 rm -f conftest.err conftest.$ac_objext \
20009       conftest$ac_exeext conftest.$ac_ext
20010 fi
20011 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
20012 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
20013 if test `eval echo '${'$as_ac_var'}'` = yes; then
20014   cat >>confdefs.h <<_ACEOF
20015 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
20016 _ACEOF
20017
20018 fi
20019 done
20020
20021   if test "$ac_cv_func_gettimeofday" = yes; then
20022     echo "$as_me:$LINENO: checking for struct timezone" >&5
20023 echo $ECHO_N "checking for struct timezone... $ECHO_C" >&6
20024 if test "${gfor_cv_struct_timezone+set}" = set; then
20025   echo $ECHO_N "(cached) $ECHO_C" >&6
20026 else
20027   cat >conftest.$ac_ext <<_ACEOF
20028 /* confdefs.h.  */
20029 _ACEOF
20030 cat confdefs.h >>conftest.$ac_ext
20031 cat >>conftest.$ac_ext <<_ACEOF
20032 /* end confdefs.h.  */
20033 #include <sys/time.h>
20034 int
20035 main ()
20036 {
20037 struct timezone tz;
20038   ;
20039   return 0;
20040 }
20041 _ACEOF
20042 rm -f conftest.$ac_objext
20043 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
20044   (eval $ac_compile) 2>conftest.er1
20045   ac_status=$?
20046   grep -v '^ *+' conftest.er1 >conftest.err
20047   rm -f conftest.er1
20048   cat conftest.err >&5
20049   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20050   (exit $ac_status); } &&
20051          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
20052   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20053   (eval $ac_try) 2>&5
20054   ac_status=$?
20055   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20056   (exit $ac_status); }; } &&
20057          { ac_try='test -s conftest.$ac_objext'
20058   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20059   (eval $ac_try) 2>&5
20060   ac_status=$?
20061   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20062   (exit $ac_status); }; }; then
20063   gfor_cv_struct_timezone=yes
20064 else
20065   echo "$as_me: failed program was:" >&5
20066 sed 's/^/| /' conftest.$ac_ext >&5
20067
20068 gfor_cv_struct_timezone=no
20069 fi
20070 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
20071 fi
20072 echo "$as_me:$LINENO: result: $gfor_cv_struct_timezone" >&5
20073 echo "${ECHO_T}$gfor_cv_struct_timezone" >&6
20074     if test $gfor_cv_struct_timezone = yes; then
20075                   if test "$cross_compiling" = yes; then
20076   gfor_have_struct_timezone=yes
20077 else
20078   cat >conftest.$ac_ext <<_ACEOF
20079 /* confdefs.h.  */
20080 _ACEOF
20081 cat confdefs.h >>conftest.$ac_ext
20082 cat >>conftest.$ac_ext <<_ACEOF
20083 /* end confdefs.h.  */
20084
20085 #ifdef TIME_WITH_SYS_TIME
20086 #include <sys/time.h>
20087 #include <time.h>
20088 #else
20089 #ifdef HAVE_SYS_TIME_H
20090 #include <sys/time.h>
20091 #else
20092 #include <time.h>
20093 #endif
20094 #endif
20095 main ()
20096 {
20097   struct timeval time;
20098   struct timezone dummy;
20099   if (gettimeofday (&time, &dummy))
20100     exit (1);
20101   else
20102     exit (0);
20103 }
20104 _ACEOF
20105 rm -f conftest$ac_exeext
20106 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20107   (eval $ac_link) 2>&5
20108   ac_status=$?
20109   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20110   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
20111   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20112   (eval $ac_try) 2>&5
20113   ac_status=$?
20114   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20115   (exit $ac_status); }; }; then
20116   gfor_have_struct_timezone=yes
20117 else
20118   echo "$as_me: program exited with status $ac_status" >&5
20119 echo "$as_me: failed program was:" >&5
20120 sed 's/^/| /' conftest.$ac_ext >&5
20121
20122 ( exit $ac_status )
20123 gfor_have_struct_timezone=no
20124 fi
20125 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
20126 fi
20127       if test $gfor_have_struct_timezone = yes; then
20128
20129 cat >>confdefs.h <<\_ACEOF
20130 #define HAVE_TIMEZONE 1
20131 _ACEOF
20132
20133       fi
20134     fi
20135
20136     echo "$as_me:$LINENO: checking whether gettimeofday can accept two arguments" >&5
20137 echo $ECHO_N "checking whether gettimeofday can accept two arguments... $ECHO_C" >&6
20138 if test "${emacs_cv_gettimeofday_two_arguments+set}" = set; then
20139   echo $ECHO_N "(cached) $ECHO_C" >&6
20140 else
20141   if test x$gcc_no_link = xyes; then
20142   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20143 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20144    { (exit 1); exit 1; }; }
20145 fi
20146 cat >conftest.$ac_ext <<_ACEOF
20147 /* confdefs.h.  */
20148 _ACEOF
20149 cat confdefs.h >>conftest.$ac_ext
20150 cat >>conftest.$ac_ext <<_ACEOF
20151 /* end confdefs.h.  */
20152
20153 #ifdef TIME_WITH_SYS_TIME
20154 #include <sys/time.h>
20155 #include <time.h>
20156 #else
20157 #ifdef HAVE_SYS_TIME_H
20158 #include <sys/time.h>
20159 #else
20160 #include <time.h>
20161 #endif
20162 #endif
20163
20164 int
20165 main ()
20166 {
20167
20168       struct timeval time;
20169 #ifdef HAVE_TIMEZONE
20170       struct timezone dummy;
20171 #define DUMMY &dummy
20172 #else
20173 #define DUMMY NULL
20174 #endif
20175       gettimeofday (&time, DUMMY);
20176   ;
20177   return 0;
20178 }
20179 _ACEOF
20180 rm -f conftest.$ac_objext conftest$ac_exeext
20181 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20182   (eval $ac_link) 2>conftest.er1
20183   ac_status=$?
20184   grep -v '^ *+' conftest.er1 >conftest.err
20185   rm -f conftest.er1
20186   cat conftest.err >&5
20187   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20188   (exit $ac_status); } &&
20189          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
20190   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20191   (eval $ac_try) 2>&5
20192   ac_status=$?
20193   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20194   (exit $ac_status); }; } &&
20195          { ac_try='test -s conftest$ac_exeext'
20196   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20197   (eval $ac_try) 2>&5
20198   ac_status=$?
20199   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20200   (exit $ac_status); }; }; then
20201   emacs_cv_gettimeofday_two_arguments=yes
20202 else
20203   echo "$as_me: failed program was:" >&5
20204 sed 's/^/| /' conftest.$ac_ext >&5
20205
20206 emacs_cv_gettimeofday_two_arguments=no
20207 fi
20208 rm -f conftest.err conftest.$ac_objext \
20209       conftest$ac_exeext conftest.$ac_ext
20210 fi
20211 echo "$as_me:$LINENO: result: $emacs_cv_gettimeofday_two_arguments" >&5
20212 echo "${ECHO_T}$emacs_cv_gettimeofday_two_arguments" >&6
20213     if test $emacs_cv_gettimeofday_two_arguments = no; then
20214
20215 cat >>confdefs.h <<\_ACEOF
20216 #define GETTIMEOFDAY_ONE_ARGUMENT 1
20217 _ACEOF
20218
20219     fi
20220   fi
20221
20222 # Attempt to assert that the target is of common type in case we don't
20223 # have C99 integer types at all.
20224
20225   echo "$as_me:$LINENO: checking whether the target is ILP32" >&5
20226 echo $ECHO_N "checking whether the target is ILP32... $ECHO_C" >&6
20227 if test "${target_ilp32+set}" = set; then
20228   echo $ECHO_N "(cached) $ECHO_C" >&6
20229 else
20230
20231   save_CFLAGS="$CFLAGS"
20232   CFLAGS="-O2"
20233   if test x$gcc_no_link = xyes; then
20234   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20235 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20236    { (exit 1); exit 1; }; }
20237 fi
20238 cat >conftest.$ac_ext <<_ACEOF
20239 /* confdefs.h.  */
20240 _ACEOF
20241 cat confdefs.h >>conftest.$ac_ext
20242 cat >>conftest.$ac_ext <<_ACEOF
20243 /* end confdefs.h.  */
20244
20245 int
20246 main ()
20247 {
20248
20249 if (sizeof(int) == 4 && sizeof(long) == 4 && sizeof(void *) == 4)
20250   ;
20251 else
20252   undefined_function ();
20253
20254   ;
20255   return 0;
20256 }
20257 _ACEOF
20258 rm -f conftest.$ac_objext conftest$ac_exeext
20259 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20260   (eval $ac_link) 2>conftest.er1
20261   ac_status=$?
20262   grep -v '^ *+' conftest.er1 >conftest.err
20263   rm -f conftest.er1
20264   cat conftest.err >&5
20265   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20266   (exit $ac_status); } &&
20267          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
20268   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20269   (eval $ac_try) 2>&5
20270   ac_status=$?
20271   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20272   (exit $ac_status); }; } &&
20273          { ac_try='test -s conftest$ac_exeext'
20274   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20275   (eval $ac_try) 2>&5
20276   ac_status=$?
20277   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20278   (exit $ac_status); }; }; then
20279   target_ilp32=yes
20280 else
20281   echo "$as_me: failed program was:" >&5
20282 sed 's/^/| /' conftest.$ac_ext >&5
20283
20284 target_ilp32=no
20285 fi
20286 rm -f conftest.err conftest.$ac_objext \
20287       conftest$ac_exeext conftest.$ac_ext
20288   CFLAGS="$save_CFLAGS"
20289 fi
20290 echo "$as_me:$LINENO: result: $target_ilp32" >&5
20291 echo "${ECHO_T}$target_ilp32" >&6
20292   if test $target_ilp32 = yes; then
20293
20294 cat >>confdefs.h <<\_ACEOF
20295 #define TARGET_ILP32 1
20296 _ACEOF
20297
20298   fi
20299
20300
20301 # Check out attribute support.
20302
20303   echo "$as_me:$LINENO: checking whether the target supports hidden visibility" >&5
20304 echo $ECHO_N "checking whether the target supports hidden visibility... $ECHO_C" >&6
20305 if test "${have_attribute_visibility+set}" = set; then
20306   echo $ECHO_N "(cached) $ECHO_C" >&6
20307 else
20308
20309   save_CFLAGS="$CFLAGS"
20310   CFLAGS="$CFLAGS -Werror"
20311   cat >conftest.$ac_ext <<_ACEOF
20312 /* confdefs.h.  */
20313 _ACEOF
20314 cat confdefs.h >>conftest.$ac_ext
20315 cat >>conftest.$ac_ext <<_ACEOF
20316 /* end confdefs.h.  */
20317 void __attribute__((visibility("hidden"))) foo(void) { }
20318 int
20319 main ()
20320 {
20321
20322   ;
20323   return 0;
20324 }
20325 _ACEOF
20326 rm -f conftest.$ac_objext
20327 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
20328   (eval $ac_compile) 2>conftest.er1
20329   ac_status=$?
20330   grep -v '^ *+' conftest.er1 >conftest.err
20331   rm -f conftest.er1
20332   cat conftest.err >&5
20333   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20334   (exit $ac_status); } &&
20335          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
20336   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20337   (eval $ac_try) 2>&5
20338   ac_status=$?
20339   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20340   (exit $ac_status); }; } &&
20341          { ac_try='test -s conftest.$ac_objext'
20342   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20343   (eval $ac_try) 2>&5
20344   ac_status=$?
20345   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20346   (exit $ac_status); }; }; then
20347   have_attribute_visibility=yes
20348 else
20349   echo "$as_me: failed program was:" >&5
20350 sed 's/^/| /' conftest.$ac_ext >&5
20351
20352 have_attribute_visibility=no
20353 fi
20354 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
20355   CFLAGS="$save_CFLAGS"
20356 fi
20357 echo "$as_me:$LINENO: result: $have_attribute_visibility" >&5
20358 echo "${ECHO_T}$have_attribute_visibility" >&6
20359   if test $have_attribute_visibility = yes; then
20360
20361 cat >>confdefs.h <<\_ACEOF
20362 #define HAVE_ATTRIBUTE_VISIBILITY 1
20363 _ACEOF
20364
20365   fi
20366
20367   echo "$as_me:$LINENO: checking whether the target supports dllexport" >&5
20368 echo $ECHO_N "checking whether the target supports dllexport... $ECHO_C" >&6
20369 if test "${have_attribute_dllexport+set}" = set; then
20370   echo $ECHO_N "(cached) $ECHO_C" >&6
20371 else
20372
20373   save_CFLAGS="$CFLAGS"
20374   CFLAGS="$CFLAGS -Werror"
20375   cat >conftest.$ac_ext <<_ACEOF
20376 /* confdefs.h.  */
20377 _ACEOF
20378 cat confdefs.h >>conftest.$ac_ext
20379 cat >>conftest.$ac_ext <<_ACEOF
20380 /* end confdefs.h.  */
20381 void __attribute__((dllexport)) foo(void) { }
20382 int
20383 main ()
20384 {
20385
20386   ;
20387   return 0;
20388 }
20389 _ACEOF
20390 rm -f conftest.$ac_objext
20391 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
20392   (eval $ac_compile) 2>conftest.er1
20393   ac_status=$?
20394   grep -v '^ *+' conftest.er1 >conftest.err
20395   rm -f conftest.er1
20396   cat conftest.err >&5
20397   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20398   (exit $ac_status); } &&
20399          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
20400   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20401   (eval $ac_try) 2>&5
20402   ac_status=$?
20403   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20404   (exit $ac_status); }; } &&
20405          { ac_try='test -s conftest.$ac_objext'
20406   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20407   (eval $ac_try) 2>&5
20408   ac_status=$?
20409   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20410   (exit $ac_status); }; }; then
20411   have_attribute_dllexport=yes
20412 else
20413   echo "$as_me: failed program was:" >&5
20414 sed 's/^/| /' conftest.$ac_ext >&5
20415
20416 have_attribute_dllexport=no
20417 fi
20418 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
20419   CFLAGS="$save_CFLAGS"
20420 fi
20421 echo "$as_me:$LINENO: result: $have_attribute_dllexport" >&5
20422 echo "${ECHO_T}$have_attribute_dllexport" >&6
20423   if test $have_attribute_dllexport = yes; then
20424
20425 cat >>confdefs.h <<\_ACEOF
20426 #define HAVE_ATTRIBUTE_DLLEXPORT 1
20427 _ACEOF
20428
20429   fi
20430
20431   echo "$as_me:$LINENO: checking whether the target supports symbol aliases" >&5
20432 echo $ECHO_N "checking whether the target supports symbol aliases... $ECHO_C" >&6
20433 if test "${have_attribute_alias+set}" = set; then
20434   echo $ECHO_N "(cached) $ECHO_C" >&6
20435 else
20436
20437   if test x$gcc_no_link = xyes; then
20438   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20439 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20440    { (exit 1); exit 1; }; }
20441 fi
20442 cat >conftest.$ac_ext <<_ACEOF
20443 /* confdefs.h.  */
20444 _ACEOF
20445 cat confdefs.h >>conftest.$ac_ext
20446 cat >>conftest.$ac_ext <<_ACEOF
20447 /* end confdefs.h.  */
20448
20449 #define ULP     STR1(__USER_LABEL_PREFIX__)
20450 #define STR1(x) STR2(x)
20451 #define STR2(x) #x
20452 void foo(void) { }
20453 extern void bar(void) __attribute__((alias(ULP "foo")));
20454 int
20455 main ()
20456 {
20457 bar();
20458   ;
20459   return 0;
20460 }
20461 _ACEOF
20462 rm -f conftest.$ac_objext conftest$ac_exeext
20463 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20464   (eval $ac_link) 2>conftest.er1
20465   ac_status=$?
20466   grep -v '^ *+' conftest.er1 >conftest.err
20467   rm -f conftest.er1
20468   cat conftest.err >&5
20469   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20470   (exit $ac_status); } &&
20471          { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
20472   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20473   (eval $ac_try) 2>&5
20474   ac_status=$?
20475   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20476   (exit $ac_status); }; } &&
20477          { ac_try='test -s conftest$ac_exeext'
20478   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20479   (eval $ac_try) 2>&5
20480   ac_status=$?
20481   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20482   (exit $ac_status); }; }; then
20483   have_attribute_alias=yes
20484 else
20485   echo "$as_me: failed program was:" >&5
20486 sed 's/^/| /' conftest.$ac_ext >&5
20487
20488 have_attribute_alias=no
20489 fi
20490 rm -f conftest.err conftest.$ac_objext \
20491       conftest$ac_exeext conftest.$ac_ext
20492 fi
20493 echo "$as_me:$LINENO: result: $have_attribute_alias" >&5
20494 echo "${ECHO_T}$have_attribute_alias" >&6
20495   if test $have_attribute_alias = yes; then
20496
20497 cat >>confdefs.h <<\_ACEOF
20498 #define HAVE_ATTRIBUTE_ALIAS 1
20499 _ACEOF
20500
20501   fi
20502
20503 # Various other checks on target
20504
20505   echo "$as_me:$LINENO: checking whether the target can unlink an open file" >&5
20506 echo $ECHO_N "checking whether the target can unlink an open file... $ECHO_C" >&6
20507 if test "${have_unlink_open_file+set}" = set; then
20508   echo $ECHO_N "(cached) $ECHO_C" >&6
20509 else
20510
20511   if test "$cross_compiling" = yes; then
20512
20513 case "${target}" in
20514   *mingw*) have_unlink_open_file=no ;;
20515   *) have_unlink_open_file=yes;;
20516 esac
20517 else
20518   cat >conftest.$ac_ext <<_ACEOF
20519 /* confdefs.h.  */
20520 _ACEOF
20521 cat confdefs.h >>conftest.$ac_ext
20522 cat >>conftest.$ac_ext <<_ACEOF
20523 /* end confdefs.h.  */
20524
20525 #include <errno.h>
20526 #include <fcntl.h>
20527 #include <unistd.h>
20528 #include <sys/stat.h>
20529
20530 int main ()
20531 {
20532   int fd;
20533
20534   fd = open ("testfile", O_RDWR | O_CREAT, S_IWRITE | S_IREAD);
20535   if (fd <= 0)
20536     return 0;
20537   if (unlink ("testfile") == -1)
20538     return 1;
20539   write (fd, "This is a test\n", 15);
20540   close (fd);
20541
20542   if (open ("testfile", O_RDONLY, S_IWRITE | S_IREAD) == -1 && errno == ENOENT)
20543     return 0;
20544   else
20545     return 1;
20546 }
20547 _ACEOF
20548 rm -f conftest$ac_exeext
20549 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20550   (eval $ac_link) 2>&5
20551   ac_status=$?
20552   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20553   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
20554   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20555   (eval $ac_try) 2>&5
20556   ac_status=$?
20557   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20558   (exit $ac_status); }; }; then
20559   have_unlink_open_file=yes
20560 else
20561   echo "$as_me: program exited with status $ac_status" >&5
20562 echo "$as_me: failed program was:" >&5
20563 sed 's/^/| /' conftest.$ac_ext >&5
20564
20565 ( exit $ac_status )
20566 have_unlink_open_file=no
20567 fi
20568 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
20569 fi
20570 fi
20571 echo "$as_me:$LINENO: result: $have_unlink_open_file" >&5
20572 echo "${ECHO_T}$have_unlink_open_file" >&6
20573 if test x"$have_unlink_open_file" = xyes; then
20574
20575 cat >>confdefs.h <<\_ACEOF
20576 #define HAVE_UNLINK_OPEN_FILE 1
20577 _ACEOF
20578
20579 fi
20580
20581 # Check whether line terminator is LF or CRLF
20582
20583   echo "$as_me:$LINENO: checking whether the target has CRLF as line terminator" >&5
20584 echo $ECHO_N "checking whether the target has CRLF as line terminator... $ECHO_C" >&6
20585 if test "${have_crlf+set}" = set; then
20586   echo $ECHO_N "(cached) $ECHO_C" >&6
20587 else
20588
20589   if test "$cross_compiling" = yes; then
20590
20591 case "${target}" in
20592   *mingw*) have_crlf=yes ;;
20593   *) have_crlf=no;;
20594 esac
20595 else
20596   cat >conftest.$ac_ext <<_ACEOF
20597 /* confdefs.h.  */
20598 _ACEOF
20599 cat confdefs.h >>conftest.$ac_ext
20600 cat >>conftest.$ac_ext <<_ACEOF
20601 /* end confdefs.h.  */
20602
20603 /* This test program should exit with status 0 if system uses a CRLF as
20604    line terminator, and status 1 otherwise.
20605    Since it is used to check for mingw systems, and should return 0 in any
20606    other case, in case of a failure we will not use CRLF.  */
20607 #include <sys/stat.h>
20608 #include <stdlib.h>
20609 #include <fcntl.h>
20610 #include <stdio.h>
20611
20612 int main ()
20613 {
20614 #ifndef O_BINARY
20615   exit(1);
20616 #else
20617   int fd, bytes;
20618   char buff[5];
20619
20620   fd = open ("foo", O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
20621   if (fd < 0)
20622     exit(1);
20623   if (write (fd, "\n", 1) < 0)
20624     perror ("write");
20625
20626   close (fd);
20627
20628   if ((fd = open ("foo", O_RDONLY | O_BINARY, S_IRWXU)) < 0)
20629     exit(1);
20630   bytes = read (fd, buff, 5);
20631   if (bytes == 2 && buff[0] == '\r' && buff[1] == '\n')
20632     exit(0);
20633   else
20634     exit(1);
20635 #endif
20636 }
20637 _ACEOF
20638 rm -f conftest$ac_exeext
20639 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20640   (eval $ac_link) 2>&5
20641   ac_status=$?
20642   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20643   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
20644   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20645   (eval $ac_try) 2>&5
20646   ac_status=$?
20647   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20648   (exit $ac_status); }; }; then
20649   have_crlf=yes
20650 else
20651   echo "$as_me: program exited with status $ac_status" >&5
20652 echo "$as_me: failed program was:" >&5
20653 sed 's/^/| /' conftest.$ac_ext >&5
20654
20655 ( exit $ac_status )
20656 have_crlf=no
20657 fi
20658 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
20659 fi
20660 fi
20661 echo "$as_me:$LINENO: result: $have_crlf" >&5
20662 echo "${ECHO_T}$have_crlf" >&6
20663 if test x"$have_crlf" = xyes; then
20664
20665 cat >>confdefs.h <<\_ACEOF
20666 #define HAVE_CRLF 1
20667 _ACEOF
20668
20669 fi
20670
20671 cat >confcache <<\_ACEOF
20672 # This file is a shell script that caches the results of configure
20673 # tests run on this system so they can be shared between configure
20674 # scripts and configure runs, see configure's option --config-cache.
20675 # It is not useful on other systems.  If it contains results you don't
20676 # want to keep, you may remove or edit it.
20677 #
20678 # config.status only pays attention to the cache file if you give it
20679 # the --recheck option to rerun configure.
20680 #
20681 # `ac_cv_env_foo' variables (set or unset) will be overridden when
20682 # loading this file, other *unset* `ac_cv_foo' will be assigned the
20683 # following values.
20684
20685 _ACEOF
20686
20687 # The following way of writing the cache mishandles newlines in values,
20688 # but we know of no workaround that is simple, portable, and efficient.
20689 # So, don't put newlines in cache variables' values.
20690 # Ultrix sh set writes to stderr and can't be redirected directly,
20691 # and sets the high bit in the cache file unless we assign to the vars.
20692 {
20693   (set) 2>&1 |
20694     case `(ac_space=' '; set | grep ac_space) 2>&1` in
20695     *ac_space=\ *)
20696       # `set' does not quote correctly, so add quotes (double-quote
20697       # substitution turns \\\\ into \\, and sed turns \\ into \).
20698       sed -n \
20699         "s/'/'\\\\''/g;
20700           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
20701       ;;
20702     *)
20703       # `set' quotes correctly as required by POSIX, so do not add quotes.
20704       sed -n \
20705         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
20706       ;;
20707     esac;
20708 } |
20709   sed '
20710      t clear
20711      : clear
20712      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
20713      t end
20714      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
20715      : end' >>confcache
20716 if diff $cache_file confcache >/dev/null 2>&1; then :; else
20717   if test -w $cache_file; then
20718     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
20719     cat confcache >$cache_file
20720   else
20721     echo "not updating unwritable cache $cache_file"
20722   fi
20723 fi
20724 rm -f confcache
20725
20726 if test ${multilib} = yes; then
20727   multilib_arg="--enable-multilib"
20728 else
20729   multilib_arg=
20730 fi
20731
20732 # Write our Makefile.
20733           ac_config_files="$ac_config_files Makefile"
20734
20735 cat >confcache <<\_ACEOF
20736 # This file is a shell script that caches the results of configure
20737 # tests run on this system so they can be shared between configure
20738 # scripts and configure runs, see configure's option --config-cache.
20739 # It is not useful on other systems.  If it contains results you don't
20740 # want to keep, you may remove or edit it.
20741 #
20742 # config.status only pays attention to the cache file if you give it
20743 # the --recheck option to rerun configure.
20744 #
20745 # `ac_cv_env_foo' variables (set or unset) will be overridden when
20746 # loading this file, other *unset* `ac_cv_foo' will be assigned the
20747 # following values.
20748
20749 _ACEOF
20750
20751 # The following way of writing the cache mishandles newlines in values,
20752 # but we know of no workaround that is simple, portable, and efficient.
20753 # So, don't put newlines in cache variables' values.
20754 # Ultrix sh set writes to stderr and can't be redirected directly,
20755 # and sets the high bit in the cache file unless we assign to the vars.
20756 {
20757   (set) 2>&1 |
20758     case `(ac_space=' '; set | grep ac_space) 2>&1` in
20759     *ac_space=\ *)
20760       # `set' does not quote correctly, so add quotes (double-quote
20761       # substitution turns \\\\ into \\, and sed turns \\ into \).
20762       sed -n \
20763         "s/'/'\\\\''/g;
20764           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
20765       ;;
20766     *)
20767       # `set' quotes correctly as required by POSIX, so do not add quotes.
20768       sed -n \
20769         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
20770       ;;
20771     esac;
20772 } |
20773   sed '
20774      t clear
20775      : clear
20776      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
20777      t end
20778      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
20779      : end' >>confcache
20780 if diff $cache_file confcache >/dev/null 2>&1; then :; else
20781   if test -w $cache_file; then
20782     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
20783     cat confcache >$cache_file
20784   else
20785     echo "not updating unwritable cache $cache_file"
20786   fi
20787 fi
20788 rm -f confcache
20789
20790 test "x$prefix" = xNONE && prefix=$ac_default_prefix
20791 # Let make expand exec_prefix.
20792 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
20793
20794 # VPATH may cause trouble with some makes, so we remove $(srcdir),
20795 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
20796 # trailing colons and then remove the whole line if VPATH becomes empty
20797 # (actually we leave an empty line to preserve line numbers).
20798 if test "x$srcdir" = x.; then
20799   ac_vpsub='/^[  ]*VPATH[        ]*=/{
20800 s/:*\$(srcdir):*/:/;
20801 s/:*\${srcdir}:*/:/;
20802 s/:*@srcdir@:*/:/;
20803 s/^\([^=]*=[     ]*\):*/\1/;
20804 s/:*$//;
20805 s/^[^=]*=[       ]*$//;
20806 }'
20807 fi
20808
20809 DEFS=-DHAVE_CONFIG_H
20810
20811 ac_libobjs=
20812 ac_ltlibobjs=
20813 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
20814   # 1. Remove the extension, and $U if already installed.
20815   ac_i=`echo "$ac_i" |
20816          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
20817   # 2. Add them.
20818   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
20819   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
20820 done
20821 LIBOBJS=$ac_libobjs
20822
20823 LTLIBOBJS=$ac_ltlibobjs
20824
20825
20826 if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then
20827   { { echo "$as_me:$LINENO: error: conditional \"MAINTAINER_MODE\" was never defined.
20828 Usually this means the macro was only invoked conditionally." >&5
20829 echo "$as_me: error: conditional \"MAINTAINER_MODE\" was never defined.
20830 Usually this means the macro was only invoked conditionally." >&2;}
20831    { (exit 1); exit 1; }; }
20832 fi
20833
20834 : ${CONFIG_STATUS=./config.status}
20835 ac_clean_files_save=$ac_clean_files
20836 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
20837 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
20838 echo "$as_me: creating $CONFIG_STATUS" >&6;}
20839 cat >$CONFIG_STATUS <<_ACEOF
20840 #! $SHELL
20841 # Generated by $as_me.
20842 # Run this file to recreate the current configuration.
20843 # Compiler output produced by configure, useful for debugging
20844 # configure, is in config.log if it exists.
20845
20846 debug=false
20847 ac_cs_recheck=false
20848 ac_cs_silent=false
20849 SHELL=\${CONFIG_SHELL-$SHELL}
20850 _ACEOF
20851
20852 cat >>$CONFIG_STATUS <<\_ACEOF
20853 ## --------------------- ##
20854 ## M4sh Initialization.  ##
20855 ## --------------------- ##
20856
20857 # Be Bourne compatible
20858 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
20859   emulate sh
20860   NULLCMD=:
20861   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
20862   # is contrary to our usage.  Disable this feature.
20863   alias -g '${1+"$@"}'='"$@"'
20864 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
20865   set -o posix
20866 fi
20867 DUALCASE=1; export DUALCASE # for MKS sh
20868
20869 # Support unset when possible.
20870 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
20871   as_unset=unset
20872 else
20873   as_unset=false
20874 fi
20875
20876
20877 # Work around bugs in pre-3.0 UWIN ksh.
20878 $as_unset ENV MAIL MAILPATH
20879 PS1='$ '
20880 PS2='> '
20881 PS4='+ '
20882
20883 # NLS nuisances.
20884 for as_var in \
20885   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
20886   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
20887   LC_TELEPHONE LC_TIME
20888 do
20889   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
20890     eval $as_var=C; export $as_var
20891   else
20892     $as_unset $as_var
20893   fi
20894 done
20895
20896 # Required to use basename.
20897 if expr a : '\(a\)' >/dev/null 2>&1; then
20898   as_expr=expr
20899 else
20900   as_expr=false
20901 fi
20902
20903 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
20904   as_basename=basename
20905 else
20906   as_basename=false
20907 fi
20908
20909
20910 # Name of the executable.
20911 as_me=`$as_basename "$0" ||
20912 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
20913          X"$0" : 'X\(//\)$' \| \
20914          X"$0" : 'X\(/\)$' \| \
20915          .     : '\(.\)' 2>/dev/null ||
20916 echo X/"$0" |
20917     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
20918           /^X\/\(\/\/\)$/{ s//\1/; q; }
20919           /^X\/\(\/\).*/{ s//\1/; q; }
20920           s/.*/./; q'`
20921
20922
20923 # PATH needs CR, and LINENO needs CR and PATH.
20924 # Avoid depending upon Character Ranges.
20925 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
20926 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
20927 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
20928 as_cr_digits='0123456789'
20929 as_cr_alnum=$as_cr_Letters$as_cr_digits
20930
20931 # The user is always right.
20932 if test "${PATH_SEPARATOR+set}" != set; then
20933   echo "#! /bin/sh" >conf$$.sh
20934   echo  "exit 0"   >>conf$$.sh
20935   chmod +x conf$$.sh
20936   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
20937     PATH_SEPARATOR=';'
20938   else
20939     PATH_SEPARATOR=:
20940   fi
20941   rm -f conf$$.sh
20942 fi
20943
20944
20945   as_lineno_1=$LINENO
20946   as_lineno_2=$LINENO
20947   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
20948   test "x$as_lineno_1" != "x$as_lineno_2" &&
20949   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
20950   # Find who we are.  Look in the path if we contain no path at all
20951   # relative or not.
20952   case $0 in
20953     *[\\/]* ) as_myself=$0 ;;
20954     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20955 for as_dir in $PATH
20956 do
20957   IFS=$as_save_IFS
20958   test -z "$as_dir" && as_dir=.
20959   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
20960 done
20961
20962        ;;
20963   esac
20964   # We did not find ourselves, most probably we were run as `sh COMMAND'
20965   # in which case we are not to be found in the path.
20966   if test "x$as_myself" = x; then
20967     as_myself=$0
20968   fi
20969   if test ! -f "$as_myself"; then
20970     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
20971 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
20972    { (exit 1); exit 1; }; }
20973   fi
20974   case $CONFIG_SHELL in
20975   '')
20976     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20977 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
20978 do
20979   IFS=$as_save_IFS
20980   test -z "$as_dir" && as_dir=.
20981   for as_base in sh bash ksh sh5; do
20982          case $as_dir in
20983          /*)
20984            if ("$as_dir/$as_base" -c '
20985   as_lineno_1=$LINENO
20986   as_lineno_2=$LINENO
20987   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
20988   test "x$as_lineno_1" != "x$as_lineno_2" &&
20989   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
20990              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
20991              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
20992              CONFIG_SHELL=$as_dir/$as_base
20993              export CONFIG_SHELL
20994              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
20995            fi;;
20996          esac
20997        done
20998 done
20999 ;;
21000   esac
21001
21002   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
21003   # uniformly replaced by the line number.  The first 'sed' inserts a
21004   # line-number line before each line; the second 'sed' does the real
21005   # work.  The second script uses 'N' to pair each line-number line
21006   # with the numbered line, and appends trailing '-' during
21007   # substitution so that $LINENO is not a special case at line end.
21008   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
21009   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
21010   sed '=' <$as_myself |
21011     sed '
21012       N
21013       s,$,-,
21014       : loop
21015       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
21016       t loop
21017       s,-$,,
21018       s,^['$as_cr_digits']*\n,,
21019     ' >$as_me.lineno &&
21020   chmod +x $as_me.lineno ||
21021     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
21022 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
21023    { (exit 1); exit 1; }; }
21024
21025   # Don't try to exec as it changes $[0], causing all sort of problems
21026   # (the dirname of $[0] is not the place where we might find the
21027   # original and so on.  Autoconf is especially sensible to this).
21028   . ./$as_me.lineno
21029   # Exit status is that of the last command.
21030   exit
21031 }
21032
21033
21034 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
21035   *c*,-n*) ECHO_N= ECHO_C='
21036 ' ECHO_T='      ' ;;
21037   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
21038   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
21039 esac
21040
21041 if expr a : '\(a\)' >/dev/null 2>&1; then
21042   as_expr=expr
21043 else
21044   as_expr=false
21045 fi
21046
21047 rm -f conf$$ conf$$.exe conf$$.file
21048 echo >conf$$.file
21049 if ln -s conf$$.file conf$$ 2>/dev/null; then
21050   # We could just check for DJGPP; but this test a) works b) is more generic
21051   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
21052   if test -f conf$$.exe; then
21053     # Don't use ln at all; we don't have any links
21054     as_ln_s='cp -p'
21055   else
21056     as_ln_s='ln -s'
21057   fi
21058 elif ln conf$$.file conf$$ 2>/dev/null; then
21059   as_ln_s=ln
21060 else
21061   as_ln_s='cp -p'
21062 fi
21063 rm -f conf$$ conf$$.exe conf$$.file
21064
21065 if mkdir -p . 2>/dev/null; then
21066   as_mkdir_p=:
21067 else
21068   test -d ./-p && rmdir ./-p
21069   as_mkdir_p=false
21070 fi
21071
21072 as_executable_p="test -f"
21073
21074 # Sed expression to map a string onto a valid CPP name.
21075 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
21076
21077 # Sed expression to map a string onto a valid variable name.
21078 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
21079
21080
21081 # IFS
21082 # We need space, tab and new line, in precisely that order.
21083 as_nl='
21084 '
21085 IFS="   $as_nl"
21086
21087 # CDPATH.
21088 $as_unset CDPATH
21089
21090 exec 6>&1
21091
21092 # Open the log real soon, to keep \$[0] and so on meaningful, and to
21093 # report actual input values of CONFIG_FILES etc. instead of their
21094 # values after options handling.  Logging --version etc. is OK.
21095 exec 5>>config.log
21096 {
21097   echo
21098   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
21099 ## Running $as_me. ##
21100 _ASBOX
21101 } >&5
21102 cat >&5 <<_CSEOF
21103
21104 This file was extended by GNU Fortran Runtime Library $as_me 0.2, which was
21105 generated by GNU Autoconf 2.59.  Invocation command line was
21106
21107   CONFIG_FILES    = $CONFIG_FILES
21108   CONFIG_HEADERS  = $CONFIG_HEADERS
21109   CONFIG_LINKS    = $CONFIG_LINKS
21110   CONFIG_COMMANDS = $CONFIG_COMMANDS
21111   $ $0 $@
21112
21113 _CSEOF
21114 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
21115 echo >&5
21116 _ACEOF
21117
21118 # Files that config.status was made for.
21119 if test -n "$ac_config_files"; then
21120   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
21121 fi
21122
21123 if test -n "$ac_config_headers"; then
21124   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
21125 fi
21126
21127 if test -n "$ac_config_links"; then
21128   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
21129 fi
21130
21131 if test -n "$ac_config_commands"; then
21132   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
21133 fi
21134
21135 cat >>$CONFIG_STATUS <<\_ACEOF
21136
21137 ac_cs_usage="\
21138 \`$as_me' instantiates files from templates according to the
21139 current configuration.
21140
21141 Usage: $0 [OPTIONS] [FILE]...
21142
21143   -h, --help       print this help, then exit
21144   -V, --version    print version number, then exit
21145   -q, --quiet      do not print progress messages
21146   -d, --debug      don't remove temporary files
21147       --recheck    update $as_me by reconfiguring in the same conditions
21148   --file=FILE[:TEMPLATE]
21149                    instantiate the configuration file FILE
21150   --header=FILE[:TEMPLATE]
21151                    instantiate the configuration header FILE
21152
21153 Configuration files:
21154 $config_files
21155
21156 Configuration headers:
21157 $config_headers
21158
21159 Configuration commands:
21160 $config_commands
21161
21162 Report bugs to <bug-autoconf@gnu.org>."
21163 _ACEOF
21164
21165 cat >>$CONFIG_STATUS <<_ACEOF
21166 ac_cs_version="\\
21167 GNU Fortran Runtime Library config.status 0.2
21168 configured by $0, generated by GNU Autoconf 2.59,
21169   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
21170
21171 Copyright (C) 2003 Free Software Foundation, Inc.
21172 This config.status script is free software; the Free Software Foundation
21173 gives unlimited permission to copy, distribute and modify it."
21174 srcdir=$srcdir
21175 INSTALL="$INSTALL"
21176 _ACEOF
21177
21178 cat >>$CONFIG_STATUS <<\_ACEOF
21179 # If no file are specified by the user, then we need to provide default
21180 # value.  By we need to know if files were specified by the user.
21181 ac_need_defaults=:
21182 while test $# != 0
21183 do
21184   case $1 in
21185   --*=*)
21186     ac_option=`expr "x$1" : 'x\([^=]*\)='`
21187     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
21188     ac_shift=:
21189     ;;
21190   -*)
21191     ac_option=$1
21192     ac_optarg=$2
21193     ac_shift=shift
21194     ;;
21195   *) # This is not an option, so the user has probably given explicit
21196      # arguments.
21197      ac_option=$1
21198      ac_need_defaults=false;;
21199   esac
21200
21201   case $ac_option in
21202   # Handling of the options.
21203 _ACEOF
21204 cat >>$CONFIG_STATUS <<\_ACEOF
21205   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
21206     ac_cs_recheck=: ;;
21207   --version | --vers* | -V )
21208     echo "$ac_cs_version"; exit 0 ;;
21209   --he | --h)
21210     # Conflict between --help and --header
21211     { { echo "$as_me:$LINENO: error: ambiguous option: $1
21212 Try \`$0 --help' for more information." >&5
21213 echo "$as_me: error: ambiguous option: $1
21214 Try \`$0 --help' for more information." >&2;}
21215    { (exit 1); exit 1; }; };;
21216   --help | --hel | -h )
21217     echo "$ac_cs_usage"; exit 0 ;;
21218   --debug | --d* | -d )
21219     debug=: ;;
21220   --file | --fil | --fi | --f )
21221     $ac_shift
21222     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
21223     ac_need_defaults=false;;
21224   --header | --heade | --head | --hea )
21225     $ac_shift
21226     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
21227     ac_need_defaults=false;;
21228   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
21229   | -silent | --silent | --silen | --sile | --sil | --si | --s)
21230     ac_cs_silent=: ;;
21231
21232   # This is an error.
21233   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
21234 Try \`$0 --help' for more information." >&5
21235 echo "$as_me: error: unrecognized option: $1
21236 Try \`$0 --help' for more information." >&2;}
21237    { (exit 1); exit 1; }; } ;;
21238
21239   *) ac_config_targets="$ac_config_targets $1" ;;
21240
21241   esac
21242   shift
21243 done
21244
21245 ac_configure_extra_args=
21246
21247 if $ac_cs_silent; then
21248   exec 6>/dev/null
21249   ac_configure_extra_args="$ac_configure_extra_args --silent"
21250 fi
21251
21252 _ACEOF
21253 cat >>$CONFIG_STATUS <<_ACEOF
21254 if \$ac_cs_recheck; then
21255   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
21256   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
21257 fi
21258
21259 _ACEOF
21260
21261 cat >>$CONFIG_STATUS <<_ACEOF
21262 #
21263 # INIT-COMMANDS section.
21264 #
21265
21266
21267 srcdir="$srcdir"
21268 host="$host"
21269 target="$target"
21270 with_multisubdir="$with_multisubdir"
21271 with_multisrctop="$with_multisrctop"
21272 with_target_subdir="$with_target_subdir"
21273 ac_configure_args="${multilib_arg} ${ac_configure_args}"
21274 multi_basedir="$multi_basedir"
21275 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
21276 CC="$CC"
21277
21278 _ACEOF
21279
21280
21281
21282 cat >>$CONFIG_STATUS <<\_ACEOF
21283 for ac_config_target in $ac_config_targets
21284 do
21285   case "$ac_config_target" in
21286   # Handling of arguments.
21287   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
21288   "default-1" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default-1" ;;
21289   "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
21290   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
21291 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
21292    { (exit 1); exit 1; }; };;
21293   esac
21294 done
21295
21296 # If the user did not use the arguments to specify the items to instantiate,
21297 # then the envvar interface is used.  Set only those that are not.
21298 # We use the long form for the default assignment because of an extremely
21299 # bizarre bug on SunOS 4.1.3.
21300 if $ac_need_defaults; then
21301   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
21302   test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
21303   test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
21304 fi
21305
21306 # Have a temporary directory for convenience.  Make it in the build tree
21307 # simply because there is no reason to put it here, and in addition,
21308 # creating and moving files from /tmp can sometimes cause problems.
21309 # Create a temporary directory, and hook for its removal unless debugging.
21310 $debug ||
21311 {
21312   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
21313   trap '{ (exit 1); exit 1; }' 1 2 13 15
21314 }
21315
21316 # Create a (secure) tmp directory for tmp files.
21317
21318 {
21319   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
21320   test -n "$tmp" && test -d "$tmp"
21321 }  ||
21322 {
21323   tmp=./confstat$$-$RANDOM
21324   (umask 077 && mkdir $tmp)
21325 } ||
21326 {
21327    echo "$me: cannot create a temporary directory in ." >&2
21328    { (exit 1); exit 1; }
21329 }
21330
21331 _ACEOF
21332
21333 cat >>$CONFIG_STATUS <<_ACEOF
21334
21335 #
21336 # CONFIG_FILES section.
21337 #
21338
21339 # No need to generate the scripts if there are no CONFIG_FILES.
21340 # This happens for instance when ./config.status config.h
21341 if test -n "\$CONFIG_FILES"; then
21342   # Protect against being on the right side of a sed subst in config.status.
21343   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
21344    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
21345 s,@SHELL@,$SHELL,;t t
21346 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
21347 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
21348 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
21349 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
21350 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
21351 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
21352 s,@exec_prefix@,$exec_prefix,;t t
21353 s,@prefix@,$prefix,;t t
21354 s,@program_transform_name@,$program_transform_name,;t t
21355 s,@bindir@,$bindir,;t t
21356 s,@sbindir@,$sbindir,;t t
21357 s,@libexecdir@,$libexecdir,;t t
21358 s,@datadir@,$datadir,;t t
21359 s,@sysconfdir@,$sysconfdir,;t t
21360 s,@sharedstatedir@,$sharedstatedir,;t t
21361 s,@localstatedir@,$localstatedir,;t t
21362 s,@libdir@,$libdir,;t t
21363 s,@includedir@,$includedir,;t t
21364 s,@oldincludedir@,$oldincludedir,;t t
21365 s,@infodir@,$infodir,;t t
21366 s,@mandir@,$mandir,;t t
21367 s,@build_alias@,$build_alias,;t t
21368 s,@host_alias@,$host_alias,;t t
21369 s,@target_alias@,$target_alias,;t t
21370 s,@DEFS@,$DEFS,;t t
21371 s,@ECHO_C@,$ECHO_C,;t t
21372 s,@ECHO_N@,$ECHO_N,;t t
21373 s,@ECHO_T@,$ECHO_T,;t t
21374 s,@LIBS@,$LIBS,;t t
21375 s,@build@,$build,;t t
21376 s,@build_cpu@,$build_cpu,;t t
21377 s,@build_vendor@,$build_vendor,;t t
21378 s,@build_os@,$build_os,;t t
21379 s,@host@,$host,;t t
21380 s,@host_cpu@,$host_cpu,;t t
21381 s,@host_vendor@,$host_vendor,;t t
21382 s,@host_os@,$host_os,;t t
21383 s,@target@,$target,;t t
21384 s,@target_cpu@,$target_cpu,;t t
21385 s,@target_vendor@,$target_vendor,;t t
21386 s,@target_os@,$target_os,;t t
21387 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
21388 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
21389 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
21390 s,@CYGPATH_W@,$CYGPATH_W,;t t
21391 s,@PACKAGE@,$PACKAGE,;t t
21392 s,@VERSION@,$VERSION,;t t
21393 s,@ACLOCAL@,$ACLOCAL,;t t
21394 s,@AUTOCONF@,$AUTOCONF,;t t
21395 s,@AUTOMAKE@,$AUTOMAKE,;t t
21396 s,@AUTOHEADER@,$AUTOHEADER,;t t
21397 s,@MAKEINFO@,$MAKEINFO,;t t
21398 s,@install_sh@,$install_sh,;t t
21399 s,@STRIP@,$STRIP,;t t
21400 s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t
21401 s,@INSTALL_STRIP_PROGRAM@,$INSTALL_STRIP_PROGRAM,;t t
21402 s,@mkdir_p@,$mkdir_p,;t t
21403 s,@AWK@,$AWK,;t t
21404 s,@SET_MAKE@,$SET_MAKE,;t t
21405 s,@am__leading_dot@,$am__leading_dot,;t t
21406 s,@AMTAR@,$AMTAR,;t t
21407 s,@am__tar@,$am__tar,;t t
21408 s,@am__untar@,$am__untar,;t t
21409 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
21410 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
21411 s,@MAINT@,$MAINT,;t t
21412 s,@multi_basedir@,$multi_basedir,;t t
21413 s,@toolexecdir@,$toolexecdir,;t t
21414 s,@toolexeclibdir@,$toolexeclibdir,;t t
21415 s,@CC@,$CC,;t t
21416 s,@ac_ct_CC@,$ac_ct_CC,;t t
21417 s,@EXEEXT@,$EXEEXT,;t t
21418 s,@OBJEXT@,$OBJEXT,;t t
21419 s,@AM_FCFLAGS@,$AM_FCFLAGS,;t t
21420 s,@AM_CFLAGS@,$AM_CFLAGS,;t t
21421 s,@AS@,$AS,;t t
21422 s,@ac_ct_AS@,$ac_ct_AS,;t t
21423 s,@AR@,$AR,;t t
21424 s,@ac_ct_AR@,$ac_ct_AR,;t t
21425 s,@RANLIB@,$RANLIB,;t t
21426 s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
21427 s,@LN_S@,$LN_S,;t t
21428 s,@LIBTOOL@,$LIBTOOL,;t t
21429 s,@enable_shared@,$enable_shared,;t t
21430 s,@enable_static@,$enable_static,;t t
21431 s,@FC@,$FC,;t t
21432 s,@FCFLAGS@,$FCFLAGS,;t t
21433 s,@LDFLAGS@,$LDFLAGS,;t t
21434 s,@ac_ct_FC@,$ac_ct_FC,;t t
21435 s,@extra_ldflags_libgfortran@,$extra_ldflags_libgfortran,;t t
21436 s,@CPP@,$CPP,;t t
21437 s,@CPPFLAGS@,$CPPFLAGS,;t t
21438 s,@EGREP@,$EGREP,;t t
21439 s,@FPU_HOST_HEADER@,$FPU_HOST_HEADER,;t t
21440 s,@LIBOBJS@,$LIBOBJS,;t t
21441 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
21442 CEOF
21443
21444 _ACEOF
21445
21446   cat >>$CONFIG_STATUS <<\_ACEOF
21447   # Split the substitutions into bite-sized pieces for seds with
21448   # small command number limits, like on Digital OSF/1 and HP-UX.
21449   ac_max_sed_lines=48
21450   ac_sed_frag=1 # Number of current file.
21451   ac_beg=1 # First line for current file.
21452   ac_end=$ac_max_sed_lines # Line after last line for current file.
21453   ac_more_lines=:
21454   ac_sed_cmds=
21455   while $ac_more_lines; do
21456     if test $ac_beg -gt 1; then
21457       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
21458     else
21459       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
21460     fi
21461     if test ! -s $tmp/subs.frag; then
21462       ac_more_lines=false
21463     else
21464       # The purpose of the label and of the branching condition is to
21465       # speed up the sed processing (if there are no `@' at all, there
21466       # is no need to browse any of the substitutions).
21467       # These are the two extra sed commands mentioned above.
21468       (echo ':t
21469   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
21470       if test -z "$ac_sed_cmds"; then
21471         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
21472       else
21473         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
21474       fi
21475       ac_sed_frag=`expr $ac_sed_frag + 1`
21476       ac_beg=$ac_end
21477       ac_end=`expr $ac_end + $ac_max_sed_lines`
21478     fi
21479   done
21480   if test -z "$ac_sed_cmds"; then
21481     ac_sed_cmds=cat
21482   fi
21483 fi # test -n "$CONFIG_FILES"
21484
21485 _ACEOF
21486 cat >>$CONFIG_STATUS <<\_ACEOF
21487 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
21488   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
21489   case $ac_file in
21490   - | *:- | *:-:* ) # input from stdin
21491         cat >$tmp/stdin
21492         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
21493         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
21494   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
21495         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
21496   * )   ac_file_in=$ac_file.in ;;
21497   esac
21498
21499   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
21500   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
21501 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
21502          X"$ac_file" : 'X\(//\)[^/]' \| \
21503          X"$ac_file" : 'X\(//\)$' \| \
21504          X"$ac_file" : 'X\(/\)' \| \
21505          .     : '\(.\)' 2>/dev/null ||
21506 echo X"$ac_file" |
21507     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
21508           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
21509           /^X\(\/\/\)$/{ s//\1/; q; }
21510           /^X\(\/\).*/{ s//\1/; q; }
21511           s/.*/./; q'`
21512   { if $as_mkdir_p; then
21513     mkdir -p "$ac_dir"
21514   else
21515     as_dir="$ac_dir"
21516     as_dirs=
21517     while test ! -d "$as_dir"; do
21518       as_dirs="$as_dir $as_dirs"
21519       as_dir=`(dirname "$as_dir") 2>/dev/null ||
21520 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
21521          X"$as_dir" : 'X\(//\)[^/]' \| \
21522          X"$as_dir" : 'X\(//\)$' \| \
21523          X"$as_dir" : 'X\(/\)' \| \
21524          .     : '\(.\)' 2>/dev/null ||
21525 echo X"$as_dir" |
21526     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
21527           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
21528           /^X\(\/\/\)$/{ s//\1/; q; }
21529           /^X\(\/\).*/{ s//\1/; q; }
21530           s/.*/./; q'`
21531     done
21532     test ! -n "$as_dirs" || mkdir $as_dirs
21533   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
21534 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
21535    { (exit 1); exit 1; }; }; }
21536
21537   ac_builddir=.
21538
21539 if test "$ac_dir" != .; then
21540   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
21541   # A "../" for each directory in $ac_dir_suffix.
21542   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
21543 else
21544   ac_dir_suffix= ac_top_builddir=
21545 fi
21546
21547 case $srcdir in
21548   .)  # No --srcdir option.  We are building in place.
21549     ac_srcdir=.
21550     if test -z "$ac_top_builddir"; then
21551        ac_top_srcdir=.
21552     else
21553        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
21554     fi ;;
21555   [\\/]* | ?:[\\/]* )  # Absolute path.
21556     ac_srcdir=$srcdir$ac_dir_suffix;
21557     ac_top_srcdir=$srcdir ;;
21558   *) # Relative path.
21559     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
21560     ac_top_srcdir=$ac_top_builddir$srcdir ;;
21561 esac
21562
21563 # Do not use `cd foo && pwd` to compute absolute paths, because
21564 # the directories may not exist.
21565 case `pwd` in
21566 .) ac_abs_builddir="$ac_dir";;
21567 *)
21568   case "$ac_dir" in
21569   .) ac_abs_builddir=`pwd`;;
21570   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
21571   *) ac_abs_builddir=`pwd`/"$ac_dir";;
21572   esac;;
21573 esac
21574 case $ac_abs_builddir in
21575 .) ac_abs_top_builddir=${ac_top_builddir}.;;
21576 *)
21577   case ${ac_top_builddir}. in
21578   .) ac_abs_top_builddir=$ac_abs_builddir;;
21579   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
21580   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
21581   esac;;
21582 esac
21583 case $ac_abs_builddir in
21584 .) ac_abs_srcdir=$ac_srcdir;;
21585 *)
21586   case $ac_srcdir in
21587   .) ac_abs_srcdir=$ac_abs_builddir;;
21588   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
21589   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
21590   esac;;
21591 esac
21592 case $ac_abs_builddir in
21593 .) ac_abs_top_srcdir=$ac_top_srcdir;;
21594 *)
21595   case $ac_top_srcdir in
21596   .) ac_abs_top_srcdir=$ac_abs_builddir;;
21597   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
21598   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
21599   esac;;
21600 esac
21601
21602
21603   case $INSTALL in
21604   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
21605   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
21606   esac
21607
21608   # Let's still pretend it is `configure' which instantiates (i.e., don't
21609   # use $as_me), people would be surprised to read:
21610   #    /* config.h.  Generated by config.status.  */
21611   if test x"$ac_file" = x-; then
21612     configure_input=
21613   else
21614     configure_input="$ac_file.  "
21615   fi
21616   configure_input=$configure_input"Generated from `echo $ac_file_in |
21617                                      sed 's,.*/,,'` by configure."
21618
21619   # First look for the input files in the build tree, otherwise in the
21620   # src tree.
21621   ac_file_inputs=`IFS=:
21622     for f in $ac_file_in; do
21623       case $f in
21624       -) echo $tmp/stdin ;;
21625       [\\/$]*)
21626          # Absolute (can't be DOS-style, as IFS=:)
21627          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
21628 echo "$as_me: error: cannot find input file: $f" >&2;}
21629    { (exit 1); exit 1; }; }
21630          echo "$f";;
21631       *) # Relative
21632          if test -f "$f"; then
21633            # Build tree
21634            echo "$f"
21635          elif test -f "$srcdir/$f"; then
21636            # Source tree
21637            echo "$srcdir/$f"
21638          else
21639            # /dev/null tree
21640            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
21641 echo "$as_me: error: cannot find input file: $f" >&2;}
21642    { (exit 1); exit 1; }; }
21643          fi;;
21644       esac
21645     done` || { (exit 1); exit 1; }
21646
21647   if test x"$ac_file" != x-; then
21648     { echo "$as_me:$LINENO: creating $ac_file" >&5
21649 echo "$as_me: creating $ac_file" >&6;}
21650     rm -f "$ac_file"
21651   fi
21652 _ACEOF
21653 cat >>$CONFIG_STATUS <<_ACEOF
21654   sed "$ac_vpsub
21655 $extrasub
21656 _ACEOF
21657 cat >>$CONFIG_STATUS <<\_ACEOF
21658 :t
21659 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
21660 s,@configure_input@,$configure_input,;t t
21661 s,@srcdir@,$ac_srcdir,;t t
21662 s,@abs_srcdir@,$ac_abs_srcdir,;t t
21663 s,@top_srcdir@,$ac_top_srcdir,;t t
21664 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
21665 s,@builddir@,$ac_builddir,;t t
21666 s,@abs_builddir@,$ac_abs_builddir,;t t
21667 s,@top_builddir@,$ac_top_builddir,;t t
21668 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
21669 s,@INSTALL@,$ac_INSTALL,;t t
21670 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
21671   rm -f $tmp/stdin
21672   if test x"$ac_file" != x-; then
21673     mv $tmp/out $ac_file
21674   else
21675     cat $tmp/out
21676     rm -f $tmp/out
21677   fi
21678
21679 done
21680 _ACEOF
21681 cat >>$CONFIG_STATUS <<\_ACEOF
21682
21683 #
21684 # CONFIG_HEADER section.
21685 #
21686
21687 # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
21688 # NAME is the cpp macro being defined and VALUE is the value it is being given.
21689 #
21690 # ac_d sets the value in "#define NAME VALUE" lines.
21691 ac_dA='s,^\([    ]*\)#\([        ]*define[       ][      ]*\)'
21692 ac_dB='[         ].*$,\1#\2'
21693 ac_dC=' '
21694 ac_dD=',;t'
21695 # ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
21696 ac_uA='s,^\([    ]*\)#\([        ]*\)undef\([    ][      ]*\)'
21697 ac_uB='$,\1#\2define\3'
21698 ac_uC=' '
21699 ac_uD=',;t'
21700
21701 for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue
21702   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
21703   case $ac_file in
21704   - | *:- | *:-:* ) # input from stdin
21705         cat >$tmp/stdin
21706         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
21707         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
21708   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
21709         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
21710   * )   ac_file_in=$ac_file.in ;;
21711   esac
21712
21713   test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5
21714 echo "$as_me: creating $ac_file" >&6;}
21715
21716   # First look for the input files in the build tree, otherwise in the
21717   # src tree.
21718   ac_file_inputs=`IFS=:
21719     for f in $ac_file_in; do
21720       case $f in
21721       -) echo $tmp/stdin ;;
21722       [\\/$]*)
21723          # Absolute (can't be DOS-style, as IFS=:)
21724          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
21725 echo "$as_me: error: cannot find input file: $f" >&2;}
21726    { (exit 1); exit 1; }; }
21727          # Do quote $f, to prevent DOS paths from being IFS'd.
21728          echo "$f";;
21729       *) # Relative
21730          if test -f "$f"; then
21731            # Build tree
21732            echo "$f"
21733          elif test -f "$srcdir/$f"; then
21734            # Source tree
21735            echo "$srcdir/$f"
21736          else
21737            # /dev/null tree
21738            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
21739 echo "$as_me: error: cannot find input file: $f" >&2;}
21740    { (exit 1); exit 1; }; }
21741          fi;;
21742       esac
21743     done` || { (exit 1); exit 1; }
21744   # Remove the trailing spaces.
21745   sed 's/[       ]*$//' $ac_file_inputs >$tmp/in
21746
21747 _ACEOF
21748
21749 # Transform confdefs.h into two sed scripts, `conftest.defines' and
21750 # `conftest.undefs', that substitutes the proper values into
21751 # config.h.in to produce config.h.  The first handles `#define'
21752 # templates, and the second `#undef' templates.
21753 # And first: Protect against being on the right side of a sed subst in
21754 # config.status.  Protect against being in an unquoted here document
21755 # in config.status.
21756 rm -f conftest.defines conftest.undefs
21757 # Using a here document instead of a string reduces the quoting nightmare.
21758 # Putting comments in sed scripts is not portable.
21759 #
21760 # `end' is used to avoid that the second main sed command (meant for
21761 # 0-ary CPP macros) applies to n-ary macro definitions.
21762 # See the Autoconf documentation for `clear'.
21763 cat >confdef2sed.sed <<\_ACEOF
21764 s/[\\&,]/\\&/g
21765 s,[\\$`],\\&,g
21766 t clear
21767 : clear
21768 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
21769 t end
21770 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
21771 : end
21772 _ACEOF
21773 # If some macros were called several times there might be several times
21774 # the same #defines, which is useless.  Nevertheless, we may not want to
21775 # sort them, since we want the *last* AC-DEFINE to be honored.
21776 uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines
21777 sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs
21778 rm -f confdef2sed.sed
21779
21780 # This sed command replaces #undef with comments.  This is necessary, for
21781 # example, in the case of _POSIX_SOURCE, which is predefined and required
21782 # on some systems where configure will not decide to define it.
21783 cat >>conftest.undefs <<\_ACEOF
21784 s,^[     ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
21785 _ACEOF
21786
21787 # Break up conftest.defines because some shells have a limit on the size
21788 # of here documents, and old seds have small limits too (100 cmds).
21789 echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
21790 echo '  if grep "^[      ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
21791 echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
21792 echo '  :' >>$CONFIG_STATUS
21793 rm -f conftest.tail
21794 while grep . conftest.defines >/dev/null
21795 do
21796   # Write a limited-size here document to $tmp/defines.sed.
21797   echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
21798   # Speed up: don't consider the non `#define' lines.
21799   echo '/^[      ]*#[    ]*define/!b' >>$CONFIG_STATUS
21800   # Work around the forget-to-reset-the-flag bug.
21801   echo 't clr' >>$CONFIG_STATUS
21802   echo ': clr' >>$CONFIG_STATUS
21803   sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS
21804   echo 'CEOF
21805   sed -f $tmp/defines.sed $tmp/in >$tmp/out
21806   rm -f $tmp/in
21807   mv $tmp/out $tmp/in
21808 ' >>$CONFIG_STATUS
21809   sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail
21810   rm -f conftest.defines
21811   mv conftest.tail conftest.defines
21812 done
21813 rm -f conftest.defines
21814 echo '  fi # grep' >>$CONFIG_STATUS
21815 echo >>$CONFIG_STATUS
21816
21817 # Break up conftest.undefs because some shells have a limit on the size
21818 # of here documents, and old seds have small limits too (100 cmds).
21819 echo '  # Handle all the #undef templates' >>$CONFIG_STATUS
21820 rm -f conftest.tail
21821 while grep . conftest.undefs >/dev/null
21822 do
21823   # Write a limited-size here document to $tmp/undefs.sed.
21824   echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
21825   # Speed up: don't consider the non `#undef'
21826   echo '/^[      ]*#[    ]*undef/!b' >>$CONFIG_STATUS
21827   # Work around the forget-to-reset-the-flag bug.
21828   echo 't clr' >>$CONFIG_STATUS
21829   echo ': clr' >>$CONFIG_STATUS
21830   sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS
21831   echo 'CEOF
21832   sed -f $tmp/undefs.sed $tmp/in >$tmp/out
21833   rm -f $tmp/in
21834   mv $tmp/out $tmp/in
21835 ' >>$CONFIG_STATUS
21836   sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail
21837   rm -f conftest.undefs
21838   mv conftest.tail conftest.undefs
21839 done
21840 rm -f conftest.undefs
21841
21842 cat >>$CONFIG_STATUS <<\_ACEOF
21843   # Let's still pretend it is `configure' which instantiates (i.e., don't
21844   # use $as_me), people would be surprised to read:
21845   #    /* config.h.  Generated by config.status.  */
21846   if test x"$ac_file" = x-; then
21847     echo "/* Generated by configure.  */" >$tmp/config.h
21848   else
21849     echo "/* $ac_file.  Generated by configure.  */" >$tmp/config.h
21850   fi
21851   cat $tmp/in >>$tmp/config.h
21852   rm -f $tmp/in
21853   if test x"$ac_file" != x-; then
21854     if diff $ac_file $tmp/config.h >/dev/null 2>&1; then
21855       { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
21856 echo "$as_me: $ac_file is unchanged" >&6;}
21857     else
21858       ac_dir=`(dirname "$ac_file") 2>/dev/null ||
21859 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
21860          X"$ac_file" : 'X\(//\)[^/]' \| \
21861          X"$ac_file" : 'X\(//\)$' \| \
21862          X"$ac_file" : 'X\(/\)' \| \
21863          .     : '\(.\)' 2>/dev/null ||
21864 echo X"$ac_file" |
21865     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
21866           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
21867           /^X\(\/\/\)$/{ s//\1/; q; }
21868           /^X\(\/\).*/{ s//\1/; q; }
21869           s/.*/./; q'`
21870       { if $as_mkdir_p; then
21871     mkdir -p "$ac_dir"
21872   else
21873     as_dir="$ac_dir"
21874     as_dirs=
21875     while test ! -d "$as_dir"; do
21876       as_dirs="$as_dir $as_dirs"
21877       as_dir=`(dirname "$as_dir") 2>/dev/null ||
21878 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
21879          X"$as_dir" : 'X\(//\)[^/]' \| \
21880          X"$as_dir" : 'X\(//\)$' \| \
21881          X"$as_dir" : 'X\(/\)' \| \
21882          .     : '\(.\)' 2>/dev/null ||
21883 echo X"$as_dir" |
21884     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
21885           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
21886           /^X\(\/\/\)$/{ s//\1/; q; }
21887           /^X\(\/\).*/{ s//\1/; q; }
21888           s/.*/./; q'`
21889     done
21890     test ! -n "$as_dirs" || mkdir $as_dirs
21891   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
21892 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
21893    { (exit 1); exit 1; }; }; }
21894
21895       rm -f $ac_file
21896       mv $tmp/config.h $ac_file
21897     fi
21898   else
21899     cat $tmp/config.h
21900     rm -f $tmp/config.h
21901   fi
21902 # Compute $ac_file's index in $config_headers.
21903 _am_stamp_count=1
21904 for _am_header in $config_headers :; do
21905   case $_am_header in
21906     $ac_file | $ac_file:* )
21907       break ;;
21908     * )
21909       _am_stamp_count=`expr $_am_stamp_count + 1` ;;
21910   esac
21911 done
21912 echo "timestamp for $ac_file" >`(dirname $ac_file) 2>/dev/null ||
21913 $as_expr X$ac_file : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
21914          X$ac_file : 'X\(//\)[^/]' \| \
21915          X$ac_file : 'X\(//\)$' \| \
21916          X$ac_file : 'X\(/\)' \| \
21917          .     : '\(.\)' 2>/dev/null ||
21918 echo X$ac_file |
21919     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
21920           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
21921           /^X\(\/\/\)$/{ s//\1/; q; }
21922           /^X\(\/\).*/{ s//\1/; q; }
21923           s/.*/./; q'`/stamp-h$_am_stamp_count
21924 done
21925 _ACEOF
21926 cat >>$CONFIG_STATUS <<\_ACEOF
21927
21928 #
21929 # CONFIG_COMMANDS section.
21930 #
21931 for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue
21932   ac_dest=`echo "$ac_file" | sed 's,:.*,,'`
21933   ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`
21934   ac_dir=`(dirname "$ac_dest") 2>/dev/null ||
21935 $as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
21936          X"$ac_dest" : 'X\(//\)[^/]' \| \
21937          X"$ac_dest" : 'X\(//\)$' \| \
21938          X"$ac_dest" : 'X\(/\)' \| \
21939          .     : '\(.\)' 2>/dev/null ||
21940 echo X"$ac_dest" |
21941     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
21942           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
21943           /^X\(\/\/\)$/{ s//\1/; q; }
21944           /^X\(\/\).*/{ s//\1/; q; }
21945           s/.*/./; q'`
21946   { if $as_mkdir_p; then
21947     mkdir -p "$ac_dir"
21948   else
21949     as_dir="$ac_dir"
21950     as_dirs=
21951     while test ! -d "$as_dir"; do
21952       as_dirs="$as_dir $as_dirs"
21953       as_dir=`(dirname "$as_dir") 2>/dev/null ||
21954 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
21955          X"$as_dir" : 'X\(//\)[^/]' \| \
21956          X"$as_dir" : 'X\(//\)$' \| \
21957          X"$as_dir" : 'X\(/\)' \| \
21958          .     : '\(.\)' 2>/dev/null ||
21959 echo X"$as_dir" |
21960     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
21961           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
21962           /^X\(\/\/\)$/{ s//\1/; q; }
21963           /^X\(\/\).*/{ s//\1/; q; }
21964           s/.*/./; q'`
21965     done
21966     test ! -n "$as_dirs" || mkdir $as_dirs
21967   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
21968 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
21969    { (exit 1); exit 1; }; }; }
21970
21971   ac_builddir=.
21972
21973 if test "$ac_dir" != .; then
21974   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
21975   # A "../" for each directory in $ac_dir_suffix.
21976   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
21977 else
21978   ac_dir_suffix= ac_top_builddir=
21979 fi
21980
21981 case $srcdir in
21982   .)  # No --srcdir option.  We are building in place.
21983     ac_srcdir=.
21984     if test -z "$ac_top_builddir"; then
21985        ac_top_srcdir=.
21986     else
21987        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
21988     fi ;;
21989   [\\/]* | ?:[\\/]* )  # Absolute path.
21990     ac_srcdir=$srcdir$ac_dir_suffix;
21991     ac_top_srcdir=$srcdir ;;
21992   *) # Relative path.
21993     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
21994     ac_top_srcdir=$ac_top_builddir$srcdir ;;
21995 esac
21996
21997 # Do not use `cd foo && pwd` to compute absolute paths, because
21998 # the directories may not exist.
21999 case `pwd` in
22000 .) ac_abs_builddir="$ac_dir";;
22001 *)
22002   case "$ac_dir" in
22003   .) ac_abs_builddir=`pwd`;;
22004   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
22005   *) ac_abs_builddir=`pwd`/"$ac_dir";;
22006   esac;;
22007 esac
22008 case $ac_abs_builddir in
22009 .) ac_abs_top_builddir=${ac_top_builddir}.;;
22010 *)
22011   case ${ac_top_builddir}. in
22012   .) ac_abs_top_builddir=$ac_abs_builddir;;
22013   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
22014   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
22015   esac;;
22016 esac
22017 case $ac_abs_builddir in
22018 .) ac_abs_srcdir=$ac_srcdir;;
22019 *)
22020   case $ac_srcdir in
22021   .) ac_abs_srcdir=$ac_abs_builddir;;
22022   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
22023   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
22024   esac;;
22025 esac
22026 case $ac_abs_builddir in
22027 .) ac_abs_top_srcdir=$ac_top_srcdir;;
22028 *)
22029   case $ac_top_srcdir in
22030   .) ac_abs_top_srcdir=$ac_abs_builddir;;
22031   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
22032   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
22033   esac;;
22034 esac
22035
22036
22037   { echo "$as_me:$LINENO: executing $ac_dest commands" >&5
22038 echo "$as_me: executing $ac_dest commands" >&6;}
22039   case $ac_dest in
22040     default-1 )
22041 # Only add multilib support code if we just rebuilt the top-level
22042 # Makefile.
22043 case " $CONFIG_FILES " in
22044  *" Makefile "*)
22045    ac_file=Makefile . ${multi_basedir}/config-ml.in
22046    ;;
22047 esac ;;
22048   esac
22049 done
22050 _ACEOF
22051
22052 cat >>$CONFIG_STATUS <<\_ACEOF
22053
22054 { (exit 0); exit 0; }
22055 _ACEOF
22056 chmod +x $CONFIG_STATUS
22057 ac_clean_files=$ac_clean_files_save
22058
22059
22060 # configure is writing to config.log, and then calls config.status.
22061 # config.status does its own redirection, appending to config.log.
22062 # Unfortunately, on DOS this fails, as config.log is still kept open
22063 # by configure, so config.status won't be able to write to it; its
22064 # output is simply discarded.  So we exec the FD to /dev/null,
22065 # effectively closing config.log, so it can be properly (re)opened and
22066 # appended to by config.status.  When coming back to configure, we
22067 # need to make the FD available again.
22068 if test "$no_create" != yes; then
22069   ac_cs_success=:
22070   ac_config_status_args=
22071   test "$silent" = yes &&
22072     ac_config_status_args="$ac_config_status_args --quiet"
22073   exec 5>/dev/null
22074   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
22075   exec 5>>config.log
22076   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
22077   # would make configure fail if this is the last instruction.
22078   $ac_cs_success || { (exit 1); exit 1; }
22079 fi
22080