libgfortran/configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59 for GNU Fortran Runtime Library 0.2.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME='GNU Fortran Runtime Library'
 269 PACKAGE_TARNAME='libgfortran'
 270 PACKAGE_VERSION='0.2'
 271 PACKAGE_STRING='GNU Fortran Runtime Library 0.2'
 272 PACKAGE_BUGREPORT=''
 273
 274 # Factoring default headers for most tests.
 275 ac_includes_default="\
 276 #include <stdio.h>
 277 #if HAVE_SYS_TYPES_H
 278 # include <sys/types.h>
 279 #endif
 280 #if HAVE_SYS_STAT_H
 281 # include <sys/stat.h>
 282 #endif
 283 #if STDC_HEADERS
 284 # include <stdlib.h>
 285 # include <stddef.h>
 286 #else
 287 # if HAVE_STDLIB_H
 288 #  include <stdlib.h>
 289 # endif
 290 #endif
 291 #if HAVE_STRING_H
 292 # if !STDC_HEADERS && HAVE_MEMORY_H
 293 #  include <memory.h>
 294 # endif
 295 # include <string.h>
 296 #endif
 297 #if HAVE_STRINGS_H
 298 # include <strings.h>
 299 #endif
 300 #if HAVE_INTTYPES_H
 301 # include <inttypes.h>
 302 #else
 303 # if HAVE_STDINT_H
 304 #  include <stdint.h>
 305 # endif
 306 #endif
 307 #if HAVE_UNISTD_H
 308 # include <unistd.h>
 309 #endif"
 310
 311 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA CYGPATH_W PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM mkdir_p AWK SET_MAKE am__leading_dot AMTAR am__tar am__untar MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT multi_basedir toolexecdir toolexeclibdir CC ac_ct_CC EXEEXT OBJEXT AM_FCFLAGS AM_CFLAGS AS ac_ct_AS AR ac_ct_AR RANLIB ac_ct_RANLIB LN_S LIBTOOL enable_shared enable_static FC FCFLAGS LDFLAGS ac_ct_FC extra_ldflags_libgfortran CPP CPPFLAGS EGREP FPU_HOST_HEADER LIBOBJS LTLIBOBJS'
 312 ac_subst_files=''
 313
 314 # Initialize some variables set by options.
 315 ac_init_help=
 316 ac_init_version=false
 317 # The variables have the same names as the options, with
 318 # dashes changed to underlines.
 319 cache_file=/dev/null
 320 exec_prefix=NONE
 321 no_create=
 322 no_recursion=
 323 prefix=NONE
 324 program_prefix=NONE
 325 program_suffix=NONE
 326 program_transform_name=s,x,x,
 327 silent=
 328 site=
 329 srcdir=
 330 verbose=
 331 x_includes=NONE
 332 x_libraries=NONE
 333
 334 # Installation directory options.
 335 # These are left unexpanded so users can "make install exec_prefix=/foo"
 336 # and all the variables that are supposed to be based on exec_prefix
 337 # by default will actually change.
 338 # Use braces instead of parens because sh, perl, etc. also accept them.
 339 bindir='${exec_prefix}/bin'
 340 sbindir='${exec_prefix}/sbin'
 341 libexecdir='${exec_prefix}/libexec'
 342 datadir='${prefix}/share'
 343 sysconfdir='${prefix}/etc'
 344 sharedstatedir='${prefix}/com'
 345 localstatedir='${prefix}/var'
 346 libdir='${exec_prefix}/lib'
 347 includedir='${prefix}/include'
 348 oldincludedir='/usr/include'
 349 infodir='${prefix}/info'
 350 mandir='${prefix}/man'
 351
 352 ac_prev=
 353 for ac_option
 354 do
 355   # If the previous option needs an argument, assign it.
 356   if test -n "$ac_prev"; then
 357     eval "$ac_prev=\$ac_option"
 358     ac_prev=
 359     continue
 360   fi
 361
 362   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 363
 364   # Accept the important Cygnus configure options, so we can diagnose typos.
 365
 366   case $ac_option in
 367
 368   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 369     ac_prev=bindir ;;
 370   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 371     bindir=$ac_optarg ;;
 372
 373   -build | --build | --buil | --bui | --bu)
 374     ac_prev=build_alias ;;
 375   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 376     build_alias=$ac_optarg ;;
 377
 378   -cache-file | --cache-file | --cache-fil | --cache-fi \
 379   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 380     ac_prev=cache_file ;;
 381   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 382   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 383     cache_file=$ac_optarg ;;
 384
 385   --config-cache | -C)
 386     cache_file=config.cache ;;
 387
 388   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 389     ac_prev=datadir ;;
 390   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 391   | --da=*)
 392     datadir=$ac_optarg ;;
 393
 394   -disable-* | --disable-*)
 395     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 396     # Reject names that are not valid shell variable names.
 397     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 398       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 399    { (exit 1); exit 1; }; }
 400     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 401     eval "enable_$ac_feature=no" ;;
 402
 403   -enable-* | --enable-*)
 404     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 405     # Reject names that are not valid shell variable names.
 406     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 407       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 408    { (exit 1); exit 1; }; }
 409     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 410     case $ac_option in
 411       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 412       *) ac_optarg=yes ;;
 413     esac
 414     eval "enable_$ac_feature='$ac_optarg'" ;;
 415
 416   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 417   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 418   | --exec | --exe | --ex)
 419     ac_prev=exec_prefix ;;
 420   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 421   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 422   | --exec=* | --exe=* | --ex=*)
 423     exec_prefix=$ac_optarg ;;
 424
 425   -gas | --gas | --ga | --g)
 426     # Obsolete; use --with-gas.
 427     with_gas=yes ;;
 428
 429   -help | --help | --hel | --he | -h)
 430     ac_init_help=long ;;
 431   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 432     ac_init_help=recursive ;;
 433   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 434     ac_init_help=short ;;
 435
 436   -host | --host | --hos | --ho)
 437     ac_prev=host_alias ;;
 438   -host=* | --host=* | --hos=* | --ho=*)
 439     host_alias=$ac_optarg ;;
 440
 441   -includedir | --includedir | --includedi | --included | --include \
 442   | --includ | --inclu | --incl | --inc)
 443     ac_prev=includedir ;;
 444   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 445   | --includ=* | --inclu=* | --incl=* | --inc=*)
 446     includedir=$ac_optarg ;;
 447
 448   -infodir | --infodir | --infodi | --infod | --info | --inf)
 449     ac_prev=infodir ;;
 450   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 451     infodir=$ac_optarg ;;
 452
 453   -libdir | --libdir | --libdi | --libd)
 454     ac_prev=libdir ;;
 455   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 456     libdir=$ac_optarg ;;
 457
 458   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 459   | --libexe | --libex | --libe)
 460     ac_prev=libexecdir ;;
 461   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 462   | --libexe=* | --libex=* | --libe=*)
 463     libexecdir=$ac_optarg ;;
 464
 465   -localstatedir | --localstatedir | --localstatedi | --localstated \
 466   | --localstate | --localstat | --localsta | --localst \
 467   | --locals | --local | --loca | --loc | --lo)
 468     ac_prev=localstatedir ;;
 469   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 470   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 471   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 472     localstatedir=$ac_optarg ;;
 473
 474   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 475     ac_prev=mandir ;;
 476   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 477     mandir=$ac_optarg ;;
 478
 479   -nfp | --nfp | --nf)
 480     # Obsolete; use --without-fp.
 481     with_fp=no ;;
 482
 483   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 484   | --no-cr | --no-c | -n)
 485     no_create=yes ;;
 486
 487   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 488   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 489     no_recursion=yes ;;
 490
 491   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 492   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 493   | --oldin | --oldi | --old | --ol | --o)
 494     ac_prev=oldincludedir ;;
 495   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 496   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 497   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 498     oldincludedir=$ac_optarg ;;
 499
 500   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 501     ac_prev=prefix ;;
 502   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 503     prefix=$ac_optarg ;;
 504
 505   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 506   | --program-pre | --program-pr | --program-p)
 507     ac_prev=program_prefix ;;
 508   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 509   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 510     program_prefix=$ac_optarg ;;
 511
 512   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 513   | --program-suf | --program-su | --program-s)
 514     ac_prev=program_suffix ;;
 515   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 516   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 517     program_suffix=$ac_optarg ;;
 518
 519   -program-transform-name | --program-transform-name \
 520   | --program-transform-nam | --program-transform-na \
 521   | --program-transform-n | --program-transform- \
 522   | --program-transform | --program-transfor \
 523   | --program-transfo | --program-transf \
 524   | --program-trans | --program-tran \
 525   | --progr-tra | --program-tr | --program-t)
 526     ac_prev=program_transform_name ;;
 527   -program-transform-name=* | --program-transform-name=* \
 528   | --program-transform-nam=* | --program-transform-na=* \
 529   | --program-transform-n=* | --program-transform-=* \
 530   | --program-transform=* | --program-transfor=* \
 531   | --program-transfo=* | --program-transf=* \
 532   | --program-trans=* | --program-tran=* \
 533   | --progr-tra=* | --program-tr=* | --program-t=*)
 534     program_transform_name=$ac_optarg ;;
 535
 536   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 537   | -silent | --silent | --silen | --sile | --sil)
 538     silent=yes ;;
 539
 540   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 541     ac_prev=sbindir ;;
 542   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 543   | --sbi=* | --sb=*)
 544     sbindir=$ac_optarg ;;
 545
 546   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 547   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 548   | --sharedst | --shareds | --shared | --share | --shar \
 549   | --sha | --sh)
 550     ac_prev=sharedstatedir ;;
 551   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 552   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 553   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 554   | --sha=* | --sh=*)
 555     sharedstatedir=$ac_optarg ;;
 556
 557   -site | --site | --sit)
 558     ac_prev=site ;;
 559   -site=* | --site=* | --sit=*)
 560     site=$ac_optarg ;;
 561
 562   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 563     ac_prev=srcdir ;;
 564   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 565     srcdir=$ac_optarg ;;
 566
 567   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 568   | --syscon | --sysco | --sysc | --sys | --sy)
 569     ac_prev=sysconfdir ;;
 570   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 571   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 572     sysconfdir=$ac_optarg ;;
 573
 574   -target | --target | --targe | --targ | --tar | --ta | --t)
 575     ac_prev=target_alias ;;
 576   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 577     target_alias=$ac_optarg ;;
 578
 579   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 580     verbose=yes ;;
 581
 582   -version | --version | --versio | --versi | --vers | -V)
 583     ac_init_version=: ;;
 584
 585   -with-* | --with-*)
 586     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 587     # Reject names that are not valid shell variable names.
 588     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 589       { echo "$as_me: error: invalid package name: $ac_package" >&2
 590    { (exit 1); exit 1; }; }
 591     ac_package=`echo $ac_package| sed 's/-/_/g'`
 592     case $ac_option in
 593       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 594       *) ac_optarg=yes ;;
 595     esac
 596     eval "with_$ac_package='$ac_optarg'" ;;
 597
 598   -without-* | --without-*)
 599     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 600     # Reject names that are not valid shell variable names.
 601     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 602       { echo "$as_me: error: invalid package name: $ac_package" >&2
 603    { (exit 1); exit 1; }; }
 604     ac_package=`echo $ac_package | sed 's/-/_/g'`
 605     eval "with_$ac_package=no" ;;
 606
 607   --x)
 608     # Obsolete; use --with-x.
 609     with_x=yes ;;
 610
 611   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 612   | --x-incl | --x-inc | --x-in | --x-i)
 613     ac_prev=x_includes ;;
 614   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 615   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 616     x_includes=$ac_optarg ;;
 617
 618   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 619   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 620     ac_prev=x_libraries ;;
 621   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 622   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 623     x_libraries=$ac_optarg ;;
 624
 625   -*) { echo "$as_me: error: unrecognized option: $ac_option
 626 Try \`$0 --help' for more information." >&2
 627    { (exit 1); exit 1; }; }
 628     ;;
 629
 630   *=*)
 631     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 632     # Reject names that are not valid shell variable names.
 633     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 634       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 635    { (exit 1); exit 1; }; }
 636     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 637     eval "$ac_envvar='$ac_optarg'"
 638     export $ac_envvar ;;
 639
 640   *)
 641     # FIXME: should be removed in autoconf 3.0.
 642     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 643     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 644       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 645     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 646     ;;
 647
 648   esac
 649 done
 650
 651 if test -n "$ac_prev"; then
 652   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 653   { echo "$as_me: error: missing argument to $ac_option" >&2
 654    { (exit 1); exit 1; }; }
 655 fi
 656
 657 # Be sure to have absolute paths.
 658 for ac_var in exec_prefix prefix
 659 do
 660   eval ac_val=$`echo $ac_var`
 661   case $ac_val in
 662     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 663     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 664    { (exit 1); exit 1; }; };;
 665   esac
 666 done
 667
 668 # Be sure to have absolute paths.
 669 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 670               localstatedir libdir includedir oldincludedir infodir mandir
 671 do
 672   eval ac_val=$`echo $ac_var`
 673   case $ac_val in
 674     [\\/$]* | ?:[\\/]* ) ;;
 675     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 676    { (exit 1); exit 1; }; };;
 677   esac
 678 done
 679
 680 # There might be people who depend on the old broken behavior: `$host'
 681 # used to hold the argument of --host etc.
 682 # FIXME: To remove some day.
 683 build=$build_alias
 684 host=$host_alias
 685 target=$target_alias
 686
 687 # FIXME: To remove some day.
 688 if test "x$host_alias" != x; then
 689   if test "x$build_alias" = x; then
 690     cross_compiling=maybe
 691     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 692     If a cross compiler is detected then cross compile mode will be used." >&2
 693   elif test "x$build_alias" != "x$host_alias"; then
 694     cross_compiling=yes
 695   fi
 696 fi
 697
 698 ac_tool_prefix=
 699 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 700
 701 test "$silent" = yes && exec 6>/dev/null
 702
 703
 704 # Find the source files, if location was not specified.
 705 if test -z "$srcdir"; then
 706   ac_srcdir_defaulted=yes
 707   # Try the directory containing this script, then its parent.
 708   ac_confdir=`(dirname "$0") 2>/dev/null ||
 709 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 710          X"$0" : 'X\(//\)[^/]' \| \
 711          X"$0" : 'X\(//\)$' \| \
 712          X"$0" : 'X\(/\)' \| \
 713          .     : '\(.\)' 2>/dev/null ||
 714 echo X"$0" |
 715     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 716           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 717           /^X\(\/\/\)$/{ s//\1/; q; }
 718           /^X\(\/\).*/{ s//\1/; q; }
 719           s/.*/./; q'`
 720   srcdir=$ac_confdir
 721   if test ! -r $srcdir/$ac_unique_file; then
 722     srcdir=..
 723   fi
 724 else
 725   ac_srcdir_defaulted=no
 726 fi
 727 if test ! -r $srcdir/$ac_unique_file; then
 728   if test "$ac_srcdir_defaulted" = yes; then
 729     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 730    { (exit 1); exit 1; }; }
 731   else
 732     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 733    { (exit 1); exit 1; }; }
 734   fi
 735 fi
 736 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 737   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 738    { (exit 1); exit 1; }; }
 739 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 740 ac_env_build_alias_set=${build_alias+set}
 741 ac_env_build_alias_value=$build_alias
 742 ac_cv_env_build_alias_set=${build_alias+set}
 743 ac_cv_env_build_alias_value=$build_alias
 744 ac_env_host_alias_set=${host_alias+set}
 745 ac_env_host_alias_value=$host_alias
 746 ac_cv_env_host_alias_set=${host_alias+set}
 747 ac_cv_env_host_alias_value=$host_alias
 748 ac_env_target_alias_set=${target_alias+set}
 749 ac_env_target_alias_value=$target_alias
 750 ac_cv_env_target_alias_set=${target_alias+set}
 751 ac_cv_env_target_alias_value=$target_alias
 752 ac_env_FC_set=${FC+set}
 753 ac_env_FC_value=$FC
 754 ac_cv_env_FC_set=${FC+set}
 755 ac_cv_env_FC_value=$FC
 756 ac_env_FCFLAGS_set=${FCFLAGS+set}
 757 ac_env_FCFLAGS_value=$FCFLAGS
 758 ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
 759 ac_cv_env_FCFLAGS_value=$FCFLAGS
 760 ac_env_LDFLAGS_set=${LDFLAGS+set}
 761 ac_env_LDFLAGS_value=$LDFLAGS
 762 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 763 ac_cv_env_LDFLAGS_value=$LDFLAGS
 764 ac_env_CPP_set=${CPP+set}
 765 ac_env_CPP_value=$CPP
 766 ac_cv_env_CPP_set=${CPP+set}
 767 ac_cv_env_CPP_value=$CPP
 768 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 769 ac_env_CPPFLAGS_value=$CPPFLAGS
 770 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 771 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 772
 773 #
 774 # Report the --help message.
 775 #
 776 if test "$ac_init_help" = "long"; then
 777   # Omit some internal or obsolete options to make the list less imposing.
 778   # This message is too long to be a string in the A/UX 3.1 sh.
 779   cat <<_ACEOF
 780 \`configure' configures GNU Fortran Runtime Library 0.2 to adapt to many kinds of systems.
 781
 782 Usage: $0 [OPTION]... [VAR=VALUE]...
 783
 784 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 785 VAR=VALUE.  See below for descriptions of some of the useful variables.
 786
 787 Defaults for the options are specified in brackets.
 788
 789 Configuration:
 790   -h, --help              display this help and exit
 791       --help=short        display options specific to this package
 792       --help=recursive    display the short help of all the included packages
 793   -V, --version           display version information and exit
 794   -q, --quiet, --silent   do not print \`checking...' messages
 795       --cache-file=FILE   cache test results in FILE [disabled]
 796   -C, --config-cache      alias for \`--cache-file=config.cache'
 797   -n, --no-create         do not create output files
 798       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 799
 800 _ACEOF
 801
 802   cat <<_ACEOF
 803 Installation directories:
 804   --prefix=PREFIX         install architecture-independent files in PREFIX
 805                           [$ac_default_prefix]
 806   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 807                           [PREFIX]
 808
 809 By default, \`make install' will install all the files in
 810 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 811 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 812 for instance \`--prefix=\$HOME'.
 813
 814 For better control, use the options below.
 815
 816 Fine tuning of the installation directories:
 817   --bindir=DIR           user executables [EPREFIX/bin]
 818   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 819   --libexecdir=DIR       program executables [EPREFIX/libexec]
 820   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 821   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 822   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 823   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 824   --libdir=DIR           object code libraries [EPREFIX/lib]
 825   --includedir=DIR       C header files [PREFIX/include]
 826   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 827   --infodir=DIR          info documentation [PREFIX/info]
 828   --mandir=DIR           man documentation [PREFIX/man]
 829 _ACEOF
 830
 831   cat <<\_ACEOF
 832
 833 Program names:
 834   --program-prefix=PREFIX            prepend PREFIX to installed program names
 835   --program-suffix=SUFFIX            append SUFFIX to installed program names
 836   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 837
 838 System types:
 839   --build=BUILD     configure for building on BUILD [guessed]
 840   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 841   --target=TARGET   configure for building compilers for TARGET [HOST]
 842 _ACEOF
 843 fi
 844
 845 if test -n "$ac_init_help"; then
 846   case $ac_init_help in
 847      short | recursive ) echo "Configuration of GNU Fortran Runtime Library 0.2:";;
 848    esac
 849   cat <<\_ACEOF
 850
 851 Optional Features:
 852   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 853   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 854   --enable-version-specific-runtime-libs    Specify that runtime libraries should be installed in a compiler-specific directory
 855   --enable-maintainer-mode  enable make rules and dependencies not useful
 856                           (and sometimes confusing) to the casual installer
 857   --enable-multilib       build many library versions (default)
 858   --enable-shared=PKGS  build shared libraries default=yes
 859   --enable-static=PKGS  build static libraries default=yes
 860   --enable-fast-install=PKGS  optimize for fast installation default=yes
 861   --disable-libtool-lock  avoid locking (might break parallel builds)
 862   --disable-largefile     omit support for large files
 863
 864 Optional Packages:
 865   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 866   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 867   --with-gnu-ld           assume the C compiler uses GNU ld default=no
 868   --with-pic              try to use only PIC/non-PIC objects default=use both
 869
 870 Some influential environment variables:
 871   CC          C compiler command
 872   CFLAGS      C compiler flags
 873   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 874               nonstandard directory <lib dir>
 875   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 876               headers in a nonstandard directory <include dir>
 877   FC          Fortran compiler command
 878   FCFLAGS     Fortran compiler flags
 879   CPP         C preprocessor
 880
 881 Use these variables to override the choices made by `configure' or to help
 882 it to find libraries and programs with nonstandard names/locations.
 883
 884 _ACEOF
 885 fi
 886
 887 if test "$ac_init_help" = "recursive"; then
 888   # If there are subdirs, report their specific --help.
 889   ac_popdir=`pwd`
 890   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
 891     test -d $ac_dir || continue
 892     ac_builddir=.
 893
 894 if test "$ac_dir" != .; then
 895   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
 896   # A "../" for each directory in $ac_dir_suffix.
 897   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
 898 else
 899   ac_dir_suffix= ac_top_builddir=
 900 fi
 901
 902 case $srcdir in
 903   .)  # No --srcdir option.  We are building in place.
 904     ac_srcdir=.
 905     if test -z "$ac_top_builddir"; then
 906        ac_top_srcdir=.
 907     else
 908        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
 909     fi ;;
 910   [\\/]* | ?:[\\/]* )  # Absolute path.
 911     ac_srcdir=$srcdir$ac_dir_suffix;
 912     ac_top_srcdir=$srcdir ;;
 913   *) # Relative path.
 914     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
 915     ac_top_srcdir=$ac_top_builddir$srcdir ;;
 916 esac
 917
 918 # Do not use `cd foo && pwd` to compute absolute paths, because
 919 # the directories may not exist.
 920 case `pwd` in
 921 .) ac_abs_builddir="$ac_dir";;
 922 *)
 923   case "$ac_dir" in
 924   .) ac_abs_builddir=`pwd`;;
 925   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
 926   *) ac_abs_builddir=`pwd`/"$ac_dir";;
 927   esac;;
 928 esac
 929 case $ac_abs_builddir in
 930 .) ac_abs_top_builddir=${ac_top_builddir}.;;
 931 *)
 932   case ${ac_top_builddir}. in
 933   .) ac_abs_top_builddir=$ac_abs_builddir;;
 934   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
 935   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
 936   esac;;
 937 esac
 938 case $ac_abs_builddir in
 939 .) ac_abs_srcdir=$ac_srcdir;;
 940 *)
 941   case $ac_srcdir in
 942   .) ac_abs_srcdir=$ac_abs_builddir;;
 943   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
 944   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
 945   esac;;
 946 esac
 947 case $ac_abs_builddir in
 948 .) ac_abs_top_srcdir=$ac_top_srcdir;;
 949 *)
 950   case $ac_top_srcdir in
 951   .) ac_abs_top_srcdir=$ac_abs_builddir;;
 952   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
 953   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
 954   esac;;
 955 esac
 956
 957     cd $ac_dir
 958     # Check for guested configure; otherwise get Cygnus style configure.
 959     if test -f $ac_srcdir/configure.gnu; then
 960       echo
 961       $SHELL $ac_srcdir/configure.gnu  --help=recursive
 962     elif test -f $ac_srcdir/configure; then
 963       echo
 964       $SHELL $ac_srcdir/configure  --help=recursive
 965     elif test -f $ac_srcdir/configure.ac ||
 966            test -f $ac_srcdir/configure.in; then
 967       echo
 968       $ac_configure --help
 969     else
 970       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
 971     fi
 972     cd $ac_popdir
 973   done
 974 fi
 975
 976 test -n "$ac_init_help" && exit 0
 977 if $ac_init_version; then
 978   cat <<\_ACEOF
 979 GNU Fortran Runtime Library configure 0.2
 980 generated by GNU Autoconf 2.59
 981
 982 Copyright (C) 2003 Free Software Foundation, Inc.
 983 This configure script is free software; the Free Software Foundation
 984 gives unlimited permission to copy, distribute and modify it.
 985 _ACEOF
 986   exit 0
 987 fi
 988 exec 5>config.log
 989 cat >&5 <<_ACEOF
 990 This file contains any messages produced by compilers while
 991 running configure, to aid debugging if configure makes a mistake.
 992
 993 It was created by GNU Fortran Runtime Library $as_me 0.2, which was
 994 generated by GNU Autoconf 2.59.  Invocation command line was
 995
 996   $ $0 $@
 997
 998 _ACEOF
 999 {
1000 cat <<_ASUNAME
1001 ## --------- ##
1002 ## Platform. ##
1003 ## --------- ##
1004
1005 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1006 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1007 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1008 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1009 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1010
1011 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1012 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1013
1014 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1015 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1016 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1017 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1018 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1019 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1020 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1021
1022 _ASUNAME
1023
1024 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1025 for as_dir in $PATH
1026 do
1027   IFS=$as_save_IFS
1028   test -z "$as_dir" && as_dir=.
1029   echo "PATH: $as_dir"
1030 done
1031
1032 } >&5
1033
1034 cat >&5 <<_ACEOF
1035
1036
1037 ## ----------- ##
1038 ## Core tests. ##
1039 ## ----------- ##
1040
1041 _ACEOF
1042
1043
1044 # Keep a trace of the command line.
1045 # Strip out --no-create and --no-recursion so they do not pile up.
1046 # Strip out --silent because we don't want to record it for future runs.
1047 # Also quote any args containing shell meta-characters.
1048 # Make two passes to allow for proper duplicate-argument suppression.
1049 ac_configure_args=
1050 ac_configure_args0=
1051 ac_configure_args1=
1052 ac_sep=
1053 ac_must_keep_next=false
1054 for ac_pass in 1 2
1055 do
1056   for ac_arg
1057   do
1058     case $ac_arg in
1059     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1060     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1061     | -silent | --silent | --silen | --sile | --sil)
1062       continue ;;
1063     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1064       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1065     esac
1066     case $ac_pass in
1067     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1068     2)
1069       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1070       if test $ac_must_keep_next = true; then
1071         ac_must_keep_next=false # Got value, back to normal.
1072       else
1073         case $ac_arg in
1074           *=* | --config-cache | -C | -disable-* | --disable-* \
1075           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1076           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1077           | -with-* | --with-* | -without-* | --without-* | --x)
1078             case "$ac_configure_args0 " in
1079               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1080             esac
1081             ;;
1082           -* ) ac_must_keep_next=true ;;
1083         esac
1084       fi
1085       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1086       # Get rid of the leading space.
1087       ac_sep=" "
1088       ;;
1089     esac
1090   done
1091 done
1092 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1093 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1094
1095 # When interrupted or exit'd, cleanup temporary files, and complete
1096 # config.log.  We remove comments because anyway the quotes in there
1097 # would cause problems or look ugly.
1098 # WARNING: Be sure not to use single quotes in there, as some shells,
1099 # such as our DU 5.0 friend, will then `close' the trap.
1100 trap 'exit_status=$?
1101   # Save into config.log some information that might help in debugging.
1102   {
1103     echo
1104
1105     cat <<\_ASBOX
1106 ## ---------------- ##
1107 ## Cache variables. ##
1108 ## ---------------- ##
1109 _ASBOX
1110     echo
1111     # The following way of writing the cache mishandles newlines in values,
1112 {
1113   (set) 2>&1 |
1114     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1115     *ac_space=\ *)
1116       sed -n \
1117         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1118           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1119       ;;
1120     *)
1121       sed -n \
1122         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1123       ;;
1124     esac;
1125 }
1126     echo
1127
1128     cat <<\_ASBOX
1129 ## ----------------- ##
1130 ## Output variables. ##
1131 ## ----------------- ##
1132 _ASBOX
1133     echo
1134     for ac_var in $ac_subst_vars
1135     do
1136       eval ac_val=$`echo $ac_var`
1137       echo "$ac_var='"'"'$ac_val'"'"'"
1138     done | sort
1139     echo
1140
1141     if test -n "$ac_subst_files"; then
1142       cat <<\_ASBOX
1143 ## ------------- ##
1144 ## Output files. ##
1145 ## ------------- ##
1146 _ASBOX
1147       echo
1148       for ac_var in $ac_subst_files
1149       do
1150         eval ac_val=$`echo $ac_var`
1151         echo "$ac_var='"'"'$ac_val'"'"'"
1152       done | sort
1153       echo
1154     fi
1155
1156     if test -s confdefs.h; then
1157       cat <<\_ASBOX
1158 ## ----------- ##
1159 ## confdefs.h. ##
1160 ## ----------- ##
1161 _ASBOX
1162       echo
1163       sed "/^$/d" confdefs.h | sort
1164       echo
1165     fi
1166     test "$ac_signal" != 0 &&
1167       echo "$as_me: caught signal $ac_signal"
1168     echo "$as_me: exit $exit_status"
1169   } >&5
1170   rm -f core *.core &&
1171   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1172     exit $exit_status
1173      ' 0
1174 for ac_signal in 1 2 13 15; do
1175   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1176 done
1177 ac_signal=0
1178
1179 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1180 rm -rf conftest* confdefs.h
1181 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1182 echo >confdefs.h
1183
1184 # Predefined preprocessor variables.
1185
1186 cat >>confdefs.h <<_ACEOF
1187 #define PACKAGE_NAME "$PACKAGE_NAME"
1188 _ACEOF
1189
1190
1191 cat >>confdefs.h <<_ACEOF
1192 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1193 _ACEOF
1194
1195
1196 cat >>confdefs.h <<_ACEOF
1197 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1198 _ACEOF
1199
1200
1201 cat >>confdefs.h <<_ACEOF
1202 #define PACKAGE_STRING "$PACKAGE_STRING"
1203 _ACEOF
1204
1205
1206 cat >>confdefs.h <<_ACEOF
1207 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1208 _ACEOF
1209
1210
1211 # Let the site file select an alternate cache file if it wants to.
1212 # Prefer explicitly selected file to automatically selected ones.
1213 if test -z "$CONFIG_SITE"; then
1214   if test "x$prefix" != xNONE; then
1215     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1216   else
1217     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1218   fi
1219 fi
1220 for ac_site_file in $CONFIG_SITE; do
1221   if test -r "$ac_site_file"; then
1222     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1223 echo "$as_me: loading site script $ac_site_file" >&6;}
1224     sed 's/^/| /' "$ac_site_file" >&5
1225     . "$ac_site_file"
1226   fi
1227 done
1228
1229 if test -r "$cache_file"; then
1230   # Some versions of bash will fail to source /dev/null (special
1231   # files actually), so we avoid doing that.
1232   if test -f "$cache_file"; then
1233     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1234 echo "$as_me: loading cache $cache_file" >&6;}
1235     case $cache_file in
1236       [\\/]* | ?:[\\/]* ) . $cache_file;;
1237       *)                      . ./$cache_file;;
1238     esac
1239   fi
1240 else
1241   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1242 echo "$as_me: creating cache $cache_file" >&6;}
1243   >$cache_file
1244 fi
1245
1246 # Check that the precious variables saved in the cache have kept the same
1247 # value.
1248 ac_cache_corrupted=false
1249 for ac_var in `(set) 2>&1 |
1250                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1251   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1252   eval ac_new_set=\$ac_env_${ac_var}_set
1253   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1254   eval ac_new_val="\$ac_env_${ac_var}_value"
1255   case $ac_old_set,$ac_new_set in
1256     set,)
1257       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1258 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1259       ac_cache_corrupted=: ;;
1260     ,set)
1261       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1262 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1263       ac_cache_corrupted=: ;;
1264     ,);;
1265     *)
1266       if test "x$ac_old_val" != "x$ac_new_val"; then
1267         { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1268 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1269         { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1270 echo "$as_me:   former value:  $ac_old_val" >&2;}
1271         { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1272 echo "$as_me:   current value: $ac_new_val" >&2;}
1273         ac_cache_corrupted=:
1274       fi;;
1275   esac
1276   # Pass precious variables to config.status.
1277   if test "$ac_new_set" = set; then
1278     case $ac_new_val in
1279     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1280       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1281     *) ac_arg=$ac_var=$ac_new_val ;;
1282     esac
1283     case " $ac_configure_args " in
1284       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1285       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1286     esac
1287   fi
1288 done
1289 if $ac_cache_corrupted; then
1290   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1291 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1292   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1293 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1294    { (exit 1); exit 1; }; }
1295 fi
1296
1297 ac_ext=c
1298 ac_cpp='$CPP $CPPFLAGS'
1299 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1300 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1301 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329           ac_config_headers="$ac_config_headers config.h"
1330
1331
1332 # -------
1333 # Options
1334 # -------
1335
1336 echo "$as_me:$LINENO: checking for --enable-version-specific-runtime-libs" >&5
1337 echo $ECHO_N "checking for --enable-version-specific-runtime-libs... $ECHO_C" >&6
1338 # Check whether --enable-version-specific-runtime-libs or --disable-version-specific-runtime-libs was given.
1339 if test "${enable_version_specific_runtime_libs+set}" = set; then
1340   enableval="$enable_version_specific_runtime_libs"
1341   case "$enableval" in
1342  yes) version_specific_libs=yes ;;
1343  no)  version_specific_libs=no ;;
1344  *)   { { echo "$as_me:$LINENO: error: Unknown argument to enable/disable version-specific libs" >&5
1345 echo "$as_me: error: Unknown argument to enable/disable version-specific libs" >&2;}
1346    { (exit 1); exit 1; }; };;
1347  esac
1348 else
1349   version_specific_libs=no
1350 fi;
1351 echo "$as_me:$LINENO: result: $version_specific_libs" >&5
1352 echo "${ECHO_T}$version_specific_libs" >&6
1353
1354
1355 # Gets build, host, target, *_vendor, *_cpu, *_os, etc.
1356 #
1357 # You will slowly go insane if you do not grok the following fact:  when
1358 # building this library, the top-level /target/ becomes the library's /host/.
1359 #
1360 # configure then causes --target to default to --host, exactly like any
1361 # other package using autoconf.  Therefore, 'target' and 'host' will
1362 # always be the same.  This makes sense both for native and cross compilers
1363 # just think about it for a little while.  :-)
1364 #
1365 # Also, if this library is being configured as part of a cross compiler, the
1366 # top-level configure script will pass the "real" host as $with_cross_host.
1367 #
1368 # Do not delete or change the following two lines.  For why, see
1369 # http://gcc.gnu.org/ml/libstdc++/2003-07/msg00451.html
1370 ac_aux_dir=
1371 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1372   if test -f $ac_dir/install-sh; then
1373     ac_aux_dir=$ac_dir
1374     ac_install_sh="$ac_aux_dir/install-sh -c"
1375     break
1376   elif test -f $ac_dir/install.sh; then
1377     ac_aux_dir=$ac_dir
1378     ac_install_sh="$ac_aux_dir/install.sh -c"
1379     break
1380   elif test -f $ac_dir/shtool; then
1381     ac_aux_dir=$ac_dir
1382     ac_install_sh="$ac_aux_dir/shtool install -c"
1383     break
1384   fi
1385 done
1386 if test -z "$ac_aux_dir"; then
1387   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1388 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1389    { (exit 1); exit 1; }; }
1390 fi
1391 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1392 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1393 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1394
1395 # Make sure we can run config.sub.
1396 $ac_config_sub sun4 >/dev/null 2>&1 ||
1397   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1398 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1399    { (exit 1); exit 1; }; }
1400
1401 echo "$as_me:$LINENO: checking build system type" >&5
1402 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1403 if test "${ac_cv_build+set}" = set; then
1404   echo $ECHO_N "(cached) $ECHO_C" >&6
1405 else
1406   ac_cv_build_alias=$build_alias
1407 test -z "$ac_cv_build_alias" &&
1408   ac_cv_build_alias=`$ac_config_guess`
1409 test -z "$ac_cv_build_alias" &&
1410   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1411 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1412    { (exit 1); exit 1; }; }
1413 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1414   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1415 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1416    { (exit 1); exit 1; }; }
1417
1418 fi
1419 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1420 echo "${ECHO_T}$ac_cv_build" >&6
1421 build=$ac_cv_build
1422 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1423 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1424 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1425
1426
1427 echo "$as_me:$LINENO: checking host system type" >&5
1428 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1429 if test "${ac_cv_host+set}" = set; then
1430   echo $ECHO_N "(cached) $ECHO_C" >&6
1431 else
1432   ac_cv_host_alias=$host_alias
1433 test -z "$ac_cv_host_alias" &&
1434   ac_cv_host_alias=$ac_cv_build_alias
1435 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1436   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1437 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1438    { (exit 1); exit 1; }; }
1439
1440 fi
1441 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1442 echo "${ECHO_T}$ac_cv_host" >&6
1443 host=$ac_cv_host
1444 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1445 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1446 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1447
1448
1449 echo "$as_me:$LINENO: checking target system type" >&5
1450 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1451 if test "${ac_cv_target+set}" = set; then
1452   echo $ECHO_N "(cached) $ECHO_C" >&6
1453 else
1454   ac_cv_target_alias=$target_alias
1455 test "x$ac_cv_target_alias" = "x" &&
1456   ac_cv_target_alias=$ac_cv_host_alias
1457 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1458   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1459 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1460    { (exit 1); exit 1; }; }
1461
1462 fi
1463 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1464 echo "${ECHO_T}$ac_cv_target" >&6
1465 target=$ac_cv_target
1466 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1467 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1468 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1469
1470
1471 # The aliases save the names the user supplied, while $host etc.
1472 # will get canonicalized.
1473 test -n "$target_alias" &&
1474   test "$program_prefix$program_suffix$program_transform_name" = \
1475     NONENONEs,x,x, &&
1476   program_prefix=${target_alias}-
1477 target_alias=${target_alias-$host_alias}
1478
1479 # Sets up automake.  Must come after AC_CANONICAL_SYSTEM.  Each of the
1480 # following is magically included in AUTOMAKE_OPTIONS in each Makefile.am.
1481 #  1.8.2:  minimum required version
1482 #  no-define:  PACKAGE and VERSION will not be #define'd in config.h (a bunch
1483 #              of other PACKAGE_* variables will, however, and there's nothing
1484 #              we can do about that; they come from AC_INIT).
1485 #  foreign:  we don't follow the normal rules for GNU packages (no COPYING
1486 #            file in the top srcdir, etc, etc), so stop complaining.
1487 #  no-dependencies:  turns off auto dependency generation (just for now)
1488 #  -Wall:  turns on all automake warnings...
1489 #  -Wno-portability:  ...except this one, since GNU make is required.
1490 am__api_version="1.9"
1491 # Find a good install program.  We prefer a C program (faster),
1492 # so one script is as good as another.  But avoid the broken or
1493 # incompatible versions:
1494 # SysV /etc/install, /usr/sbin/install
1495 # SunOS /usr/etc/install
1496 # IRIX /sbin/install
1497 # AIX /bin/install
1498 # AmigaOS /C/install, which installs bootblocks on floppy discs
1499 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1500 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1501 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1502 # OS/2's system install, which has a completely different semantic
1503 # ./install, which can be erroneously created by make from ./install.sh.
1504 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1505 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1506 if test -z "$INSTALL"; then
1507 if test "${ac_cv_path_install+set}" = set; then
1508   echo $ECHO_N "(cached) $ECHO_C" >&6
1509 else
1510   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1511 for as_dir in $PATH
1512 do
1513   IFS=$as_save_IFS
1514   test -z "$as_dir" && as_dir=.
1515   # Account for people who put trailing slashes in PATH elements.
1516 case $as_dir/ in
1517   ./ | .// | /cC/* | \
1518   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1519   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1520   /usr/ucb/* ) ;;
1521   *)
1522     # OSF1 and SCO ODT 3.0 have their own names for install.
1523     # Don't use installbsd from OSF since it installs stuff as root
1524     # by default.
1525     for ac_prog in ginstall scoinst install; do
1526       for ac_exec_ext in '' $ac_executable_extensions; do
1527         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1528           if test $ac_prog = install &&
1529             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1530             # AIX install.  It has an incompatible calling convention.
1531             :
1532           elif test $ac_prog = install &&
1533             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1534             # program-specific install script used by HP pwplus--don't use.
1535             :
1536           else
1537             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1538             break 3
1539           fi
1540         fi
1541       done
1542     done
1543     ;;
1544 esac
1545 done
1546
1547
1548 fi
1549   if test "${ac_cv_path_install+set}" = set; then
1550     INSTALL=$ac_cv_path_install
1551   else
1552     # As a last resort, use the slow shell script.  We don't cache a
1553     # path for INSTALL within a source directory, because that will
1554     # break other packages using the cache if that directory is
1555     # removed, or if the path is relative.
1556     INSTALL=$ac_install_sh
1557   fi
1558 fi
1559 echo "$as_me:$LINENO: result: $INSTALL" >&5
1560 echo "${ECHO_T}$INSTALL" >&6
1561
1562 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1563 # It thinks the first close brace ends the variable substitution.
1564 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1565
1566 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1567
1568 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1569
1570 echo "$as_me:$LINENO: checking whether build environment is sane" >&5
1571 echo $ECHO_N "checking whether build environment is sane... $ECHO_C" >&6
1572 # Just in case
1573 sleep 1
1574 echo timestamp > conftest.file
1575 # Do `set' in a subshell so we don't clobber the current shell's
1576 # arguments.  Must try -L first in case configure is actually a
1577 # symlink; some systems play weird games with the mod time of symlinks
1578 # (eg FreeBSD returns the mod time of the symlink's containing
1579 # directory).
1580 if (
1581    set X `ls -Lt $srcdir/configure conftest.file 2> /dev/null`
1582    if test "$*" = "X"; then
1583       # -L didn't work.
1584       set X `ls -t $srcdir/configure conftest.file`
1585    fi
1586    rm -f conftest.file
1587    if test "$*" != "X $srcdir/configure conftest.file" \
1588       && test "$*" != "X conftest.file $srcdir/configure"; then
1589
1590       # If neither matched, then we have a broken ls.  This can happen
1591       # if, for instance, CONFIG_SHELL is bash and it inherits a
1592       # broken ls alias from the environment.  This has actually
1593       # happened.  Such a system could not be considered "sane".
1594       { { echo "$as_me:$LINENO: error: ls -t appears to fail.  Make sure there is not a broken
1595 alias in your environment" >&5
1596 echo "$as_me: error: ls -t appears to fail.  Make sure there is not a broken
1597 alias in your environment" >&2;}
1598    { (exit 1); exit 1; }; }
1599    fi
1600
1601    test "$2" = conftest.file
1602    )
1603 then
1604    # Ok.
1605    :
1606 else
1607    { { echo "$as_me:$LINENO: error: newly created file is older than distributed files!
1608 Check your system clock" >&5
1609 echo "$as_me: error: newly created file is older than distributed files!
1610 Check your system clock" >&2;}
1611    { (exit 1); exit 1; }; }
1612 fi
1613 echo "$as_me:$LINENO: result: yes" >&5
1614 echo "${ECHO_T}yes" >&6
1615 test "$program_prefix" != NONE &&
1616   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1617 # Use a double $ so make ignores it.
1618 test "$program_suffix" != NONE &&
1619   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1620 # Double any \ or $.  echo might interpret backslashes.
1621 # By default was `s,x,x', remove it if useless.
1622 cat <<\_ACEOF >conftest.sed
1623 s/[\\$]/&&/g;s/;s,x,x,$//
1624 _ACEOF
1625 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1626 rm conftest.sed
1627
1628 # expand $ac_aux_dir to an absolute path
1629 am_aux_dir=`cd $ac_aux_dir && pwd`
1630
1631 test x"${MISSING+set}" = xset || MISSING="\${SHELL} $am_aux_dir/missing"
1632 # Use eval to expand $SHELL
1633 if eval "$MISSING --run true"; then
1634   am_missing_run="$MISSING --run "
1635 else
1636   am_missing_run=
1637   { echo "$as_me:$LINENO: WARNING: \`missing' script is too old or missing" >&5
1638 echo "$as_me: WARNING: \`missing' script is too old or missing" >&2;}
1639 fi
1640
1641 if mkdir -p --version . >/dev/null 2>&1 && test ! -d ./--version; then
1642   # We used to keeping the `.' as first argument, in order to
1643   # allow $(mkdir_p) to be used without argument.  As in
1644   #   $(mkdir_p) $(somedir)
1645   # where $(somedir) is conditionally defined.  However this is wrong
1646   # for two reasons:
1647   #  1. if the package is installed by a user who cannot write `.'
1648   #     make install will fail,
1649   #  2. the above comment should most certainly read
1650   #     $(mkdir_p) $(DESTDIR)$(somedir)
1651   #     so it does not work when $(somedir) is undefined and
1652   #     $(DESTDIR) is not.
1653   #  To support the latter case, we have to write
1654   #     test -z "$(somedir)" || $(mkdir_p) $(DESTDIR)$(somedir),
1655   #  so the `.' trick is pointless.
1656   mkdir_p='mkdir -p --'
1657 else
1658   # On NextStep and OpenStep, the `mkdir' command does not
1659   # recognize any option.  It will interpret all options as
1660   # directories to create, and then abort because `.' already
1661   # exists.
1662   for d in ./-p ./--version;
1663   do
1664     test -d $d && rmdir $d
1665   done
1666   # $(mkinstalldirs) is defined by Automake if mkinstalldirs exists.
1667   if test -f "$ac_aux_dir/mkinstalldirs"; then
1668     mkdir_p='$(mkinstalldirs)'
1669   else
1670     mkdir_p='$(install_sh) -d'
1671   fi
1672 fi
1673
1674 for ac_prog in gawk mawk nawk awk
1675 do
1676   # Extract the first word of "$ac_prog", so it can be a program name with args.
1677 set dummy $ac_prog; ac_word=$2
1678 echo "$as_me:$LINENO: checking for $ac_word" >&5
1679 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1680 if test "${ac_cv_prog_AWK+set}" = set; then
1681   echo $ECHO_N "(cached) $ECHO_C" >&6
1682 else
1683   if test -n "$AWK"; then
1684   ac_cv_prog_AWK="$AWK" # Let the user override the test.
1685 else
1686 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1687 for as_dir in $PATH
1688 do
1689   IFS=$as_save_IFS
1690   test -z "$as_dir" && as_dir=.
1691   for ac_exec_ext in '' $ac_executable_extensions; do
1692   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1693     ac_cv_prog_AWK="$ac_prog"
1694     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1695     break 2
1696   fi
1697 done
1698 done
1699
1700 fi
1701 fi
1702 AWK=$ac_cv_prog_AWK
1703 if test -n "$AWK"; then
1704   echo "$as_me:$LINENO: result: $AWK" >&5
1705 echo "${ECHO_T}$AWK" >&6
1706 else
1707   echo "$as_me:$LINENO: result: no" >&5
1708 echo "${ECHO_T}no" >&6
1709 fi
1710
1711   test -n "$AWK" && break
1712 done
1713
1714 echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
1715 echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
1716 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
1717 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
1718   echo $ECHO_N "(cached) $ECHO_C" >&6
1719 else
1720   cat >conftest.make <<\_ACEOF
1721 all:
1722         @echo 'ac_maketemp="$(MAKE)"'
1723 _ACEOF
1724 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
1725 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
1726 if test -n "$ac_maketemp"; then
1727   eval ac_cv_prog_make_${ac_make}_set=yes
1728 else
1729   eval ac_cv_prog_make_${ac_make}_set=no
1730 fi
1731 rm -f conftest.make
1732 fi
1733 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
1734   echo "$as_me:$LINENO: result: yes" >&5
1735 echo "${ECHO_T}yes" >&6
1736   SET_MAKE=
1737 else
1738   echo "$as_me:$LINENO: result: no" >&5
1739 echo "${ECHO_T}no" >&6
1740   SET_MAKE="MAKE=${MAKE-make}"
1741 fi
1742
1743 rm -rf .tst 2>/dev/null
1744 mkdir .tst 2>/dev/null
1745 if test -d .tst; then
1746   am__leading_dot=.
1747 else
1748   am__leading_dot=_
1749 fi
1750 rmdir .tst 2>/dev/null
1751
1752 # test to see if srcdir already configured
1753 if test "`cd $srcdir && pwd`" != "`pwd`" &&
1754    test -f $srcdir/config.status; then
1755   { { echo "$as_me:$LINENO: error: source directory already configured; run \"make distclean\" there first" >&5
1756 echo "$as_me: error: source directory already configured; run \"make distclean\" there first" >&2;}
1757    { (exit 1); exit 1; }; }
1758 fi
1759
1760 # test whether we have cygpath
1761 if test -z "$CYGPATH_W"; then
1762   if (cygpath --version) >/dev/null 2>/dev/null; then
1763     CYGPATH_W='cygpath -w'
1764   else
1765     CYGPATH_W=echo
1766   fi
1767 fi
1768
1769
1770 # Define the identity of the package.
1771  PACKAGE='libgfortran'
1772  VERSION='0.2'
1773
1774
1775 # Some tools Automake needs.
1776
1777 ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}
1778
1779
1780 AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}
1781
1782
1783 AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}
1784
1785
1786 AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}
1787
1788
1789 MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
1790
1791 install_sh=${install_sh-"$am_aux_dir/install-sh"}
1792
1793 # Installed binaries are usually stripped using `strip' when the user
1794 # run `make install-strip'.  However `strip' might not be the right
1795 # tool to use in cross-compilation environments, therefore Automake
1796 # will honor the `STRIP' environment variable to overrule this program.
1797 if test "$cross_compiling" != no; then
1798   if test -n "$ac_tool_prefix"; then
1799   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
1800 set dummy ${ac_tool_prefix}strip; ac_word=$2
1801 echo "$as_me:$LINENO: checking for $ac_word" >&5
1802 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1803 if test "${ac_cv_prog_STRIP+set}" = set; then
1804   echo $ECHO_N "(cached) $ECHO_C" >&6
1805 else
1806   if test -n "$STRIP"; then
1807   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
1808 else
1809 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1810 for as_dir in $PATH
1811 do
1812   IFS=$as_save_IFS
1813   test -z "$as_dir" && as_dir=.
1814   for ac_exec_ext in '' $ac_executable_extensions; do
1815   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1816     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
1817     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1818     break 2
1819   fi
1820 done
1821 done
1822
1823 fi
1824 fi
1825 STRIP=$ac_cv_prog_STRIP
1826 if test -n "$STRIP"; then
1827   echo "$as_me:$LINENO: result: $STRIP" >&5
1828 echo "${ECHO_T}$STRIP" >&6
1829 else
1830   echo "$as_me:$LINENO: result: no" >&5
1831 echo "${ECHO_T}no" >&6
1832 fi
1833
1834 fi
1835 if test -z "$ac_cv_prog_STRIP"; then
1836   ac_ct_STRIP=$STRIP
1837   # Extract the first word of "strip", so it can be a program name with args.
1838 set dummy strip; ac_word=$2
1839 echo "$as_me:$LINENO: checking for $ac_word" >&5
1840 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1841 if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
1842   echo $ECHO_N "(cached) $ECHO_C" >&6
1843 else
1844   if test -n "$ac_ct_STRIP"; then
1845   ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
1846 else
1847 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1848 for as_dir in $PATH
1849 do
1850   IFS=$as_save_IFS
1851   test -z "$as_dir" && as_dir=.
1852   for ac_exec_ext in '' $ac_executable_extensions; do
1853   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1854     ac_cv_prog_ac_ct_STRIP="strip"
1855     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1856     break 2
1857   fi
1858 done
1859 done
1860
1861   test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
1862 fi
1863 fi
1864 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
1865 if test -n "$ac_ct_STRIP"; then
1866   echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
1867 echo "${ECHO_T}$ac_ct_STRIP" >&6
1868 else
1869   echo "$as_me:$LINENO: result: no" >&5
1870 echo "${ECHO_T}no" >&6
1871 fi
1872
1873   STRIP=$ac_ct_STRIP
1874 else
1875   STRIP="$ac_cv_prog_STRIP"
1876 fi
1877
1878 fi
1879 INSTALL_STRIP_PROGRAM="\${SHELL} \$(install_sh) -c -s"
1880
1881 # We need awk for the "check" target.  The system "awk" is bad on
1882 # some platforms.
1883 # Always define AMTAR for backward compatibility.
1884
1885 AMTAR=${AMTAR-"${am_missing_run}tar"}
1886
1887 am__tar='${AMTAR} chof - "$$tardir"'; am__untar='${AMTAR} xf -'
1888
1889
1890
1891
1892
1893
1894 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
1895 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
1896     # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
1897 if test "${enable_maintainer_mode+set}" = set; then
1898   enableval="$enable_maintainer_mode"
1899   USE_MAINTAINER_MODE=$enableval
1900 else
1901   USE_MAINTAINER_MODE=no
1902 fi;
1903   echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
1904 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
1905
1906
1907 if test $USE_MAINTAINER_MODE = yes; then
1908   MAINTAINER_MODE_TRUE=
1909   MAINTAINER_MODE_FALSE='#'
1910 else
1911   MAINTAINER_MODE_TRUE='#'
1912   MAINTAINER_MODE_FALSE=
1913 fi
1914
1915   MAINT=$MAINTAINER_MODE_TRUE
1916
1917
1918 # Default to --enable-multilib
1919 # Check whether --enable-multilib or --disable-multilib was given.
1920 if test "${enable_multilib+set}" = set; then
1921   enableval="$enable_multilib"
1922   case "$enableval" in
1923   yes) multilib=yes ;;
1924   no)  multilib=no ;;
1925   *)   { { echo "$as_me:$LINENO: error: bad value $enableval for multilib option" >&5
1926 echo "$as_me: error: bad value $enableval for multilib option" >&2;}
1927    { (exit 1); exit 1; }; } ;;
1928  esac
1929 else
1930   multilib=yes
1931 fi;
1932
1933 # We may get other options which we leave undocumented:
1934 # --with-target-subdir, --with-multisrctop, --with-multisubdir
1935 # See config-ml.in if you want the gory details.
1936
1937 if test "$srcdir" = "."; then
1938   if test "$with_target_subdir" != "."; then
1939     multi_basedir="$srcdir/$with_multisrctop../.."
1940   else
1941     multi_basedir="$srcdir/$with_multisrctop.."
1942   fi
1943 else
1944   multi_basedir="$srcdir/.."
1945 fi
1946
1947
1948           ac_config_commands="$ac_config_commands default-1"
1949
1950
1951 # Handy for debugging:
1952 #AC_MSG_NOTICE($build / $host / $target / $host_alias / $target_alias); sleep 5
1953
1954 # Are we being configured with some form of cross compiler?
1955 # NB: We don't actually need to know this just now, but when, say, a test
1956 #     suite is included, we'll have to know.
1957 if test "$build" != "$host"; then
1958   LIBGFOR_IS_NATIVE=false
1959
1960 else
1961   LIBGFOR_IS_NATIVE=true
1962 fi
1963
1964 # Calculate toolexeclibdir
1965 # Also toolexecdir, though it's only used in toolexeclibdir
1966 case ${version_specific_libs} in
1967   yes)
1968     # Need the gcc compiler version to know where to install libraries
1969     # and header files if --enable-version-specific-runtime-libs option
1970     # is selected.
1971     toolexecdir='$(libdir)/gcc/$(target_alias)'
1972     toolexeclibdir='$(toolexecdir)/$(gcc_version)$(MULTISUBDIR)'
1973     ;;
1974   no)
1975     if test -n "$with_cross_host" &&
1976        test x"$with_cross_host" != x"no"; then
1977       # Install a library built with a cross compiler in tooldir, not libdir.
1978       toolexecdir='$(exec_prefix)/$(target_alias)'
1979       toolexeclibdir='$(toolexecdir)/lib'
1980     else
1981       toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
1982       toolexeclibdir='$(libdir)'
1983     fi
1984     multi_os_directory=`$CC -print-multi-os-directory`
1985     case $multi_os_directory in
1986       .) ;; # Avoid trailing /.
1987       *) toolexeclibdir=$toolexeclibdir/$multi_os_directory ;;
1988     esac
1989     ;;
1990 esac
1991
1992
1993
1994 # Check the compiler.
1995 # The same as in boehm-gc and libstdc++. Have to borrow it from there.
1996 # We must force CC to /not/ be precious variables; otherwise
1997 # the wrong, non-multilib-adjusted value will be used in multilibs.
1998 # As a side effect, we have to subst CFLAGS ourselves.
1999
2000
2001
2002 ac_ext=c
2003 ac_cpp='$CPP $CPPFLAGS'
2004 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2005 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2006 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2007 if test -n "$ac_tool_prefix"; then
2008   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2009 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2010 echo "$as_me:$LINENO: checking for $ac_word" >&5
2011 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2012 if test "${ac_cv_prog_CC+set}" = set; then
2013   echo $ECHO_N "(cached) $ECHO_C" >&6
2014 else
2015   if test -n "$CC"; then
2016   ac_cv_prog_CC="$CC" # Let the user override the test.
2017 else
2018 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2019 for as_dir in $PATH
2020 do
2021   IFS=$as_save_IFS
2022   test -z "$as_dir" && as_dir=.
2023   for ac_exec_ext in '' $ac_executable_extensions; do
2024   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2025     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2026     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2027     break 2
2028   fi
2029 done
2030 done
2031
2032 fi
2033 fi
2034 CC=$ac_cv_prog_CC
2035 if test -n "$CC"; then
2036   echo "$as_me:$LINENO: result: $CC" >&5
2037 echo "${ECHO_T}$CC" >&6
2038 else
2039   echo "$as_me:$LINENO: result: no" >&5
2040 echo "${ECHO_T}no" >&6
2041 fi
2042
2043 fi
2044 if test -z "$ac_cv_prog_CC"; then
2045   ac_ct_CC=$CC
2046   # Extract the first word of "gcc", so it can be a program name with args.
2047 set dummy gcc; ac_word=$2
2048 echo "$as_me:$LINENO: checking for $ac_word" >&5
2049 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2050 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2051   echo $ECHO_N "(cached) $ECHO_C" >&6
2052 else
2053   if test -n "$ac_ct_CC"; then
2054   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2055 else
2056 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2057 for as_dir in $PATH
2058 do
2059   IFS=$as_save_IFS
2060   test -z "$as_dir" && as_dir=.
2061   for ac_exec_ext in '' $ac_executable_extensions; do
2062   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2063     ac_cv_prog_ac_ct_CC="gcc"
2064     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2065     break 2
2066   fi
2067 done
2068 done
2069
2070 fi
2071 fi
2072 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2073 if test -n "$ac_ct_CC"; then
2074   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2075 echo "${ECHO_T}$ac_ct_CC" >&6
2076 else
2077   echo "$as_me:$LINENO: result: no" >&5
2078 echo "${ECHO_T}no" >&6
2079 fi
2080
2081   CC=$ac_ct_CC
2082 else
2083   CC="$ac_cv_prog_CC"
2084 fi
2085
2086 if test -z "$CC"; then
2087   if test -n "$ac_tool_prefix"; then
2088   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2089 set dummy ${ac_tool_prefix}cc; ac_word=$2
2090 echo "$as_me:$LINENO: checking for $ac_word" >&5
2091 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2092 if test "${ac_cv_prog_CC+set}" = set; then
2093   echo $ECHO_N "(cached) $ECHO_C" >&6
2094 else
2095   if test -n "$CC"; then
2096   ac_cv_prog_CC="$CC" # Let the user override the test.
2097 else
2098 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2099 for as_dir in $PATH
2100 do
2101   IFS=$as_save_IFS
2102   test -z "$as_dir" && as_dir=.
2103   for ac_exec_ext in '' $ac_executable_extensions; do
2104   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2105     ac_cv_prog_CC="${ac_tool_prefix}cc"
2106     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2107     break 2
2108   fi
2109 done
2110 done
2111
2112 fi
2113 fi
2114 CC=$ac_cv_prog_CC
2115 if test -n "$CC"; then
2116   echo "$as_me:$LINENO: result: $CC" >&5
2117 echo "${ECHO_T}$CC" >&6
2118 else
2119   echo "$as_me:$LINENO: result: no" >&5
2120 echo "${ECHO_T}no" >&6
2121 fi
2122
2123 fi
2124 if test -z "$ac_cv_prog_CC"; then
2125   ac_ct_CC=$CC
2126   # Extract the first word of "cc", so it can be a program name with args.
2127 set dummy cc; ac_word=$2
2128 echo "$as_me:$LINENO: checking for $ac_word" >&5
2129 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2130 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2131   echo $ECHO_N "(cached) $ECHO_C" >&6
2132 else
2133   if test -n "$ac_ct_CC"; then
2134   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2135 else
2136 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2137 for as_dir in $PATH
2138 do
2139   IFS=$as_save_IFS
2140   test -z "$as_dir" && as_dir=.
2141   for ac_exec_ext in '' $ac_executable_extensions; do
2142   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2143     ac_cv_prog_ac_ct_CC="cc"
2144     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2145     break 2
2146   fi
2147 done
2148 done
2149
2150 fi
2151 fi
2152 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2153 if test -n "$ac_ct_CC"; then
2154   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2155 echo "${ECHO_T}$ac_ct_CC" >&6
2156 else
2157   echo "$as_me:$LINENO: result: no" >&5
2158 echo "${ECHO_T}no" >&6
2159 fi
2160
2161   CC=$ac_ct_CC
2162 else
2163   CC="$ac_cv_prog_CC"
2164 fi
2165
2166 fi
2167 if test -z "$CC"; then
2168   # Extract the first word of "cc", so it can be a program name with args.
2169 set dummy cc; ac_word=$2
2170 echo "$as_me:$LINENO: checking for $ac_word" >&5
2171 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2172 if test "${ac_cv_prog_CC+set}" = set; then
2173   echo $ECHO_N "(cached) $ECHO_C" >&6
2174 else
2175   if test -n "$CC"; then
2176   ac_cv_prog_CC="$CC" # Let the user override the test.
2177 else
2178   ac_prog_rejected=no
2179 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2180 for as_dir in $PATH
2181 do
2182   IFS=$as_save_IFS
2183   test -z "$as_dir" && as_dir=.
2184   for ac_exec_ext in '' $ac_executable_extensions; do
2185   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2186     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2187        ac_prog_rejected=yes
2188        continue
2189      fi
2190     ac_cv_prog_CC="cc"
2191     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2192     break 2
2193   fi
2194 done
2195 done
2196
2197 if test $ac_prog_rejected = yes; then
2198   # We found a bogon in the path, so make sure we never use it.
2199   set dummy $ac_cv_prog_CC
2200   shift
2201   if test $# != 0; then
2202     # We chose a different compiler from the bogus one.
2203     # However, it has the same basename, so the bogon will be chosen
2204     # first if we set CC to just the basename; use the full file name.
2205     shift
2206     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
2207   fi
2208 fi
2209 fi
2210 fi
2211 CC=$ac_cv_prog_CC
2212 if test -n "$CC"; then
2213   echo "$as_me:$LINENO: result: $CC" >&5
2214 echo "${ECHO_T}$CC" >&6
2215 else
2216   echo "$as_me:$LINENO: result: no" >&5
2217 echo "${ECHO_T}no" >&6
2218 fi
2219
2220 fi
2221 if test -z "$CC"; then
2222   if test -n "$ac_tool_prefix"; then
2223   for ac_prog in cl
2224   do
2225     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2226 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2227 echo "$as_me:$LINENO: checking for $ac_word" >&5
2228 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2229 if test "${ac_cv_prog_CC+set}" = set; then
2230   echo $ECHO_N "(cached) $ECHO_C" >&6
2231 else
2232   if test -n "$CC"; then
2233   ac_cv_prog_CC="$CC" # Let the user override the test.
2234 else
2235 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2236 for as_dir in $PATH
2237 do
2238   IFS=$as_save_IFS
2239   test -z "$as_dir" && as_dir=.
2240   for ac_exec_ext in '' $ac_executable_extensions; do
2241   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2242     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2243     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2244     break 2
2245   fi
2246 done
2247 done
2248
2249 fi
2250 fi
2251 CC=$ac_cv_prog_CC
2252 if test -n "$CC"; then
2253   echo "$as_me:$LINENO: result: $CC" >&5
2254 echo "${ECHO_T}$CC" >&6
2255 else
2256   echo "$as_me:$LINENO: result: no" >&5
2257 echo "${ECHO_T}no" >&6
2258 fi
2259
2260     test -n "$CC" && break
2261   done
2262 fi
2263 if test -z "$CC"; then
2264   ac_ct_CC=$CC
2265   for ac_prog in cl
2266 do
2267   # Extract the first word of "$ac_prog", so it can be a program name with args.
2268 set dummy $ac_prog; ac_word=$2
2269 echo "$as_me:$LINENO: checking for $ac_word" >&5
2270 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2271 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2272   echo $ECHO_N "(cached) $ECHO_C" >&6
2273 else
2274   if test -n "$ac_ct_CC"; then
2275   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2276 else
2277 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2278 for as_dir in $PATH
2279 do
2280   IFS=$as_save_IFS
2281   test -z "$as_dir" && as_dir=.
2282   for ac_exec_ext in '' $ac_executable_extensions; do
2283   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2284     ac_cv_prog_ac_ct_CC="$ac_prog"
2285     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2286     break 2
2287   fi
2288 done
2289 done
2290
2291 fi
2292 fi
2293 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2294 if test -n "$ac_ct_CC"; then
2295   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2296 echo "${ECHO_T}$ac_ct_CC" >&6
2297 else
2298   echo "$as_me:$LINENO: result: no" >&5
2299 echo "${ECHO_T}no" >&6
2300 fi
2301
2302   test -n "$ac_ct_CC" && break
2303 done
2304
2305   CC=$ac_ct_CC
2306 fi
2307
2308 fi
2309
2310
2311 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2312 See \`config.log' for more details." >&5
2313 echo "$as_me: error: no acceptable C compiler found in \$PATH
2314 See \`config.log' for more details." >&2;}
2315    { (exit 1); exit 1; }; }
2316
2317 # Provide some information about the compiler.
2318 echo "$as_me:$LINENO:" \
2319      "checking for C compiler version" >&5
2320 ac_compiler=`set X $ac_compile; echo $2`
2321 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2322   (eval $ac_compiler --version </dev/null >&5) 2>&5
2323   ac_status=$?
2324   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2325   (exit $ac_status); }
2326 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2327   (eval $ac_compiler -v </dev/null >&5) 2>&5
2328   ac_status=$?
2329   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2330   (exit $ac_status); }
2331 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2332   (eval $ac_compiler -V </dev/null >&5) 2>&5
2333   ac_status=$?
2334   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2335   (exit $ac_status); }
2336
2337 cat >conftest.$ac_ext <<_ACEOF
2338 /* confdefs.h.  */
2339 _ACEOF
2340 cat confdefs.h >>conftest.$ac_ext
2341 cat >>conftest.$ac_ext <<_ACEOF
2342 /* end confdefs.h.  */
2343
2344 int
2345 main ()
2346 {
2347
2348   ;
2349   return 0;
2350 }
2351 _ACEOF
2352 # FIXME: Cleanup?
2353 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
2354   (eval $ac_link) 2>&5
2355   ac_status=$?
2356   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2357   (exit $ac_status); }; then
2358   gcc_no_link=no
2359 else
2360   gcc_no_link=yes
2361 fi
2362
2363 if test x$gcc_no_link = xyes; then
2364   # Setting cross_compile will disable run tests; it will
2365   # also disable AC_CHECK_FILE but that's generally
2366   # correct if we can't link.
2367   cross_compiling=yes
2368   EXEEXT=
2369 else
2370   cat >conftest.$ac_ext <<_ACEOF
2371 /* confdefs.h.  */
2372 _ACEOF
2373 cat confdefs.h >>conftest.$ac_ext
2374 cat >>conftest.$ac_ext <<_ACEOF
2375 /* end confdefs.h.  */
2376
2377 int
2378 main ()
2379 {
2380
2381   ;
2382   return 0;
2383 }
2384 _ACEOF
2385 ac_clean_files_save=$ac_clean_files
2386 ac_clean_files="$ac_clean_files a.out a.exe b.out"
2387 # Try to create an executable without -o first, disregard a.out.
2388 # It will help us diagnose broken compilers, and finding out an intuition
2389 # of exeext.
2390 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
2391 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
2392 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
2393 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
2394   (eval $ac_link_default) 2>&5
2395   ac_status=$?
2396   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2397   (exit $ac_status); }; then
2398   # Find the output, starting from the most likely.  This scheme is
2399 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
2400 # resort.
2401
2402 # Be careful to initialize this variable, since it used to be cached.
2403 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
2404 ac_cv_exeext=
2405 # b.out is created by i960 compilers.
2406 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
2407 do
2408   test -f "$ac_file" || continue
2409   case $ac_file in
2410     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
2411         ;;
2412     conftest.$ac_ext )
2413         # This is the source file.
2414         ;;
2415     [ab].out )
2416         # We found the default executable, but exeext='' is most
2417         # certainly right.
2418         break;;
2419     *.* )
2420         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
2421         # FIXME: I believe we export ac_cv_exeext for Libtool,
2422         # but it would be cool to find out if it's true.  Does anybody
2423         # maintain Libtool? --akim.
2424         export ac_cv_exeext
2425         break;;
2426     * )
2427         break;;
2428   esac
2429 done
2430 else
2431   echo "$as_me: failed program was:" >&5
2432 sed 's/^/| /' conftest.$ac_ext >&5
2433
2434 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
2435 See \`config.log' for more details." >&5
2436 echo "$as_me: error: C compiler cannot create executables
2437 See \`config.log' for more details." >&2;}
2438    { (exit 77); exit 77; }; }
2439 fi
2440
2441 ac_exeext=$ac_cv_exeext
2442 echo "$as_me:$LINENO: result: $ac_file" >&5
2443 echo "${ECHO_T}$ac_file" >&6
2444
2445 # Check the compiler produces executables we can run.  If not, either
2446 # the compiler is broken, or we cross compile.
2447 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
2448 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
2449 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
2450 # If not cross compiling, check that we can run a simple program.
2451 if test "$cross_compiling" != yes; then
2452   if { ac_try='./$ac_file'
2453   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2454   (eval $ac_try) 2>&5
2455   ac_status=$?
2456   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2457   (exit $ac_status); }; }; then
2458     cross_compiling=no
2459   else
2460     if test "$cross_compiling" = maybe; then
2461         cross_compiling=yes
2462     else
2463         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
2464 If you meant to cross compile, use \`--host'.
2465 See \`config.log' for more details." >&5
2466 echo "$as_me: error: cannot run C compiled programs.
2467 If you meant to cross compile, use \`--host'.
2468 See \`config.log' for more details." >&2;}
2469    { (exit 1); exit 1; }; }
2470     fi
2471   fi
2472 fi
2473 echo "$as_me:$LINENO: result: yes" >&5
2474 echo "${ECHO_T}yes" >&6
2475
2476 rm -f a.out a.exe conftest$ac_cv_exeext b.out
2477 ac_clean_files=$ac_clean_files_save
2478 # Check the compiler produces executables we can run.  If not, either
2479 # the compiler is broken, or we cross compile.
2480 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
2481 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
2482 echo "$as_me:$LINENO: result: $cross_compiling" >&5
2483 echo "${ECHO_T}$cross_compiling" >&6
2484
2485 echo "$as_me:$LINENO: checking for suffix of executables" >&5
2486 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
2487 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
2488   (eval $ac_link) 2>&5
2489   ac_status=$?
2490   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2491   (exit $ac_status); }; then
2492   # If both `conftest.exe' and `conftest' are `present' (well, observable)
2493 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
2494 # work properly (i.e., refer to `conftest.exe'), while it won't with
2495 # `rm'.
2496 for ac_file in conftest.exe conftest conftest.*; do
2497   test -f "$ac_file" || continue
2498   case $ac_file in
2499     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
2500     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
2501           export ac_cv_exeext
2502           break;;
2503     * ) break;;
2504   esac
2505 done
2506 else
2507   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
2508 See \`config.log' for more details." >&5
2509 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
2510 See \`config.log' for more details." >&2;}
2511    { (exit 1); exit 1; }; }
2512 fi
2513
2514 rm -f conftest$ac_cv_exeext
2515 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
2516 echo "${ECHO_T}$ac_cv_exeext" >&6
2517
2518 rm -f conftest.$ac_ext
2519 EXEEXT=$ac_cv_exeext
2520 ac_exeext=$EXEEXT
2521 fi
2522 echo "$as_me:$LINENO: checking for suffix of object files" >&5
2523 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
2524 if test "${ac_cv_objext+set}" = set; then
2525   echo $ECHO_N "(cached) $ECHO_C" >&6
2526 else
2527   cat >conftest.$ac_ext <<_ACEOF
2528 /* confdefs.h.  */
2529 _ACEOF
2530 cat confdefs.h >>conftest.$ac_ext
2531 cat >>conftest.$ac_ext <<_ACEOF
2532 /* end confdefs.h.  */
2533
2534 int
2535 main ()
2536 {
2537
2538   ;
2539   return 0;
2540 }
2541 _ACEOF
2542 rm -f conftest.o conftest.obj
2543 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2544   (eval $ac_compile) 2>&5
2545   ac_status=$?
2546   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2547   (exit $ac_status); }; then
2548   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
2549   case $ac_file in
2550     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
2551     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
2552        break;;
2553   esac
2554 done
2555 else
2556   echo "$as_me: failed program was:" >&5
2557 sed 's/^/| /' conftest.$ac_ext >&5
2558
2559 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
2560 See \`config.log' for more details." >&5
2561 echo "$as_me: error: cannot compute suffix of object files: cannot compile
2562 See \`config.log' for more details." >&2;}
2563    { (exit 1); exit 1; }; }
2564 fi
2565
2566 rm -f conftest.$ac_cv_objext conftest.$ac_ext
2567 fi
2568 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
2569 echo "${ECHO_T}$ac_cv_objext" >&6
2570 OBJEXT=$ac_cv_objext
2571 ac_objext=$OBJEXT
2572 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2573 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2574 if test "${ac_cv_c_compiler_gnu+set}" = set; then
2575   echo $ECHO_N "(cached) $ECHO_C" >&6
2576 else
2577   cat >conftest.$ac_ext <<_ACEOF
2578 /* confdefs.h.  */
2579 _ACEOF
2580 cat confdefs.h >>conftest.$ac_ext
2581 cat >>conftest.$ac_ext <<_ACEOF
2582 /* end confdefs.h.  */
2583
2584 int
2585 main ()
2586 {
2587 #ifndef __GNUC__
2588        choke me
2589 #endif
2590
2591   ;
2592   return 0;
2593 }
2594 _ACEOF
2595 rm -f conftest.$ac_objext
2596 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2597   (eval $ac_compile) 2>conftest.er1
2598   ac_status=$?
2599   grep -v '^ *+' conftest.er1 >conftest.err
2600   rm -f conftest.er1
2601   cat conftest.err >&5
2602   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2603   (exit $ac_status); } &&
2604          { ac_try='test -z "$ac_c_werror_flag"
2605                          || test ! -s conftest.err'
2606   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2607   (eval $ac_try) 2>&5
2608   ac_status=$?
2609   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2610   (exit $ac_status); }; } &&
2611          { ac_try='test -s conftest.$ac_objext'
2612   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2613   (eval $ac_try) 2>&5
2614   ac_status=$?
2615   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2616   (exit $ac_status); }; }; then
2617   ac_compiler_gnu=yes
2618 else
2619   echo "$as_me: failed program was:" >&5
2620 sed 's/^/| /' conftest.$ac_ext >&5
2621
2622 ac_compiler_gnu=no
2623 fi
2624 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2625 ac_cv_c_compiler_gnu=$ac_compiler_gnu
2626
2627 fi
2628 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2629 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2630 GCC=`test $ac_compiler_gnu = yes && echo yes`
2631 ac_test_CFLAGS=${CFLAGS+set}
2632 ac_save_CFLAGS=$CFLAGS
2633 CFLAGS="-g"
2634 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2635 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2636 if test "${ac_cv_prog_cc_g+set}" = set; then
2637   echo $ECHO_N "(cached) $ECHO_C" >&6
2638 else
2639   cat >conftest.$ac_ext <<_ACEOF
2640 /* confdefs.h.  */
2641 _ACEOF
2642 cat confdefs.h >>conftest.$ac_ext
2643 cat >>conftest.$ac_ext <<_ACEOF
2644 /* end confdefs.h.  */
2645
2646 int
2647 main ()
2648 {
2649
2650   ;
2651   return 0;
2652 }
2653 _ACEOF
2654 rm -f conftest.$ac_objext
2655 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2656   (eval $ac_compile) 2>conftest.er1
2657   ac_status=$?
2658   grep -v '^ *+' conftest.er1 >conftest.err
2659   rm -f conftest.er1
2660   cat conftest.err >&5
2661   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2662   (exit $ac_status); } &&
2663          { ac_try='test -z "$ac_c_werror_flag"
2664                          || test ! -s conftest.err'
2665   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2666   (eval $ac_try) 2>&5
2667   ac_status=$?
2668   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2669   (exit $ac_status); }; } &&
2670          { ac_try='test -s conftest.$ac_objext'
2671   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2672   (eval $ac_try) 2>&5
2673   ac_status=$?
2674   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2675   (exit $ac_status); }; }; then
2676   ac_cv_prog_cc_g=yes
2677 else
2678   echo "$as_me: failed program was:" >&5
2679 sed 's/^/| /' conftest.$ac_ext >&5
2680
2681 ac_cv_prog_cc_g=no
2682 fi
2683 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2684 fi
2685 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2686 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2687 if test "$ac_test_CFLAGS" = set; then
2688   CFLAGS=$ac_save_CFLAGS
2689 elif test $ac_cv_prog_cc_g = yes; then
2690   if test "$GCC" = yes; then
2691     CFLAGS="-g -O2"
2692   else
2693     CFLAGS="-g"
2694   fi
2695 else
2696   if test "$GCC" = yes; then
2697     CFLAGS="-O2"
2698   else
2699     CFLAGS=
2700   fi
2701 fi
2702 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2703 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2704 if test "${ac_cv_prog_cc_stdc+set}" = set; then
2705   echo $ECHO_N "(cached) $ECHO_C" >&6
2706 else
2707   ac_cv_prog_cc_stdc=no
2708 ac_save_CC=$CC
2709 cat >conftest.$ac_ext <<_ACEOF
2710 /* confdefs.h.  */
2711 _ACEOF
2712 cat confdefs.h >>conftest.$ac_ext
2713 cat >>conftest.$ac_ext <<_ACEOF
2714 /* end confdefs.h.  */
2715 #include <stdarg.h>
2716 #include <stdio.h>
2717 #include <sys/types.h>
2718 #include <sys/stat.h>
2719 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2720 struct buf { int x; };
2721 FILE * (*rcsopen) (struct buf *, struct stat *, int);
2722 static char *e (p, i)
2723      char **p;
2724      int i;
2725 {
2726   return p[i];
2727 }
2728 static char *f (char * (*g) (char **, int), char **p, ...)
2729 {
2730   char *s;
2731   va_list v;
2732   va_start (v,p);
2733   s = g (p, va_arg (v,int));
2734   va_end (v);
2735   return s;
2736 }
2737
2738 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2739    function prototypes and stuff, but not '\xHH' hex character constants.
2740    These don't provoke an error unfortunately, instead are silently treated
2741    as 'x'.  The following induces an error, until -std1 is added to get
2742    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2743    array size at least.  It's necessary to write '\x00'==0 to get something
2744    that's true only with -std1.  */
2745 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2746
2747 int test (int i, double x);
2748 struct s1 {int (*f) (int a);};
2749 struct s2 {int (*f) (double a);};
2750 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2751 int argc;
2752 char **argv;
2753 int
2754 main ()
2755 {
2756 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2757   ;
2758   return 0;
2759 }
2760 _ACEOF
2761 # Don't try gcc -ansi; that turns off useful extensions and
2762 # breaks some systems' header files.
2763 # AIX                   -qlanglvl=ansi
2764 # Ultrix and OSF/1      -std1
2765 # HP-UX 10.20 and later -Ae
2766 # HP-UX older versions  -Aa -D_HPUX_SOURCE
2767 # SVR4                  -Xc -D__EXTENSIONS__
2768 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2769 do
2770   CC="$ac_save_CC $ac_arg"
2771   rm -f conftest.$ac_objext
2772 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2773   (eval $ac_compile) 2>conftest.er1
2774   ac_status=$?
2775   grep -v '^ *+' conftest.er1 >conftest.err
2776   rm -f conftest.er1
2777   cat conftest.err >&5
2778   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2779   (exit $ac_status); } &&
2780          { ac_try='test -z "$ac_c_werror_flag"
2781                          || test ! -s conftest.err'
2782   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2783   (eval $ac_try) 2>&5
2784   ac_status=$?
2785   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2786   (exit $ac_status); }; } &&
2787          { ac_try='test -s conftest.$ac_objext'
2788   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2789   (eval $ac_try) 2>&5
2790   ac_status=$?
2791   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2792   (exit $ac_status); }; }; then
2793   ac_cv_prog_cc_stdc=$ac_arg
2794 break
2795 else
2796   echo "$as_me: failed program was:" >&5
2797 sed 's/^/| /' conftest.$ac_ext >&5
2798
2799 fi
2800 rm -f conftest.err conftest.$ac_objext
2801 done
2802 rm -f conftest.$ac_ext conftest.$ac_objext
2803 CC=$ac_save_CC
2804
2805 fi
2806
2807 case "x$ac_cv_prog_cc_stdc" in
2808   x|xno)
2809     echo "$as_me:$LINENO: result: none needed" >&5
2810 echo "${ECHO_T}none needed" >&6 ;;
2811   *)
2812     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2813 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2814     CC="$CC $ac_cv_prog_cc_stdc" ;;
2815 esac
2816
2817 # Some people use a C++ compiler to compile C.  Since we use `exit',
2818 # in C++ we need to declare it.  In case someone uses the same compiler
2819 # for both compiling C and C++ we need to have the C++ compiler decide
2820 # the declaration of exit, since it's the most demanding environment.
2821 cat >conftest.$ac_ext <<_ACEOF
2822 #ifndef __cplusplus
2823   choke me
2824 #endif
2825 _ACEOF
2826 rm -f conftest.$ac_objext
2827 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2828   (eval $ac_compile) 2>conftest.er1
2829   ac_status=$?
2830   grep -v '^ *+' conftest.er1 >conftest.err
2831   rm -f conftest.er1
2832   cat conftest.err >&5
2833   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2834   (exit $ac_status); } &&
2835          { ac_try='test -z "$ac_c_werror_flag"
2836                          || test ! -s conftest.err'
2837   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2838   (eval $ac_try) 2>&5
2839   ac_status=$?
2840   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2841   (exit $ac_status); }; } &&
2842          { ac_try='test -s conftest.$ac_objext'
2843   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2844   (eval $ac_try) 2>&5
2845   ac_status=$?
2846   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2847   (exit $ac_status); }; }; then
2848   for ac_declaration in \
2849    '' \
2850    'extern "C" void std::exit (int) throw (); using std::exit;' \
2851    'extern "C" void std::exit (int); using std::exit;' \
2852    'extern "C" void exit (int) throw ();' \
2853    'extern "C" void exit (int);' \
2854    'void exit (int);'
2855 do
2856   cat >conftest.$ac_ext <<_ACEOF
2857 /* confdefs.h.  */
2858 _ACEOF
2859 cat confdefs.h >>conftest.$ac_ext
2860 cat >>conftest.$ac_ext <<_ACEOF
2861 /* end confdefs.h.  */
2862 $ac_declaration
2863 #include <stdlib.h>
2864 int
2865 main ()
2866 {
2867 exit (42);
2868   ;
2869   return 0;
2870 }
2871 _ACEOF
2872 rm -f conftest.$ac_objext
2873 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2874   (eval $ac_compile) 2>conftest.er1
2875   ac_status=$?
2876   grep -v '^ *+' conftest.er1 >conftest.err
2877   rm -f conftest.er1
2878   cat conftest.err >&5
2879   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2880   (exit $ac_status); } &&
2881          { ac_try='test -z "$ac_c_werror_flag"
2882                          || test ! -s conftest.err'
2883   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2884   (eval $ac_try) 2>&5
2885   ac_status=$?
2886   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2887   (exit $ac_status); }; } &&
2888          { ac_try='test -s conftest.$ac_objext'
2889   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2890   (eval $ac_try) 2>&5
2891   ac_status=$?
2892   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2893   (exit $ac_status); }; }; then
2894   :
2895 else
2896   echo "$as_me: failed program was:" >&5
2897 sed 's/^/| /' conftest.$ac_ext >&5
2898
2899 continue
2900 fi
2901 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2902   cat >conftest.$ac_ext <<_ACEOF
2903 /* confdefs.h.  */
2904 _ACEOF
2905 cat confdefs.h >>conftest.$ac_ext
2906 cat >>conftest.$ac_ext <<_ACEOF
2907 /* end confdefs.h.  */
2908 $ac_declaration
2909 int
2910 main ()
2911 {
2912 exit (42);
2913   ;
2914   return 0;
2915 }
2916 _ACEOF
2917 rm -f conftest.$ac_objext
2918 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2919   (eval $ac_compile) 2>conftest.er1
2920   ac_status=$?
2921   grep -v '^ *+' conftest.er1 >conftest.err
2922   rm -f conftest.er1
2923   cat conftest.err >&5
2924   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2925   (exit $ac_status); } &&
2926          { ac_try='test -z "$ac_c_werror_flag"
2927                          || test ! -s conftest.err'
2928   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2929   (eval $ac_try) 2>&5
2930   ac_status=$?
2931   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2932   (exit $ac_status); }; } &&
2933          { ac_try='test -s conftest.$ac_objext'
2934   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2935   (eval $ac_try) 2>&5
2936   ac_status=$?
2937   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2938   (exit $ac_status); }; }; then
2939   break
2940 else
2941   echo "$as_me: failed program was:" >&5
2942 sed 's/^/| /' conftest.$ac_ext >&5
2943
2944 fi
2945 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2946 done
2947 rm -f conftest*
2948 if test -n "$ac_declaration"; then
2949   echo '#ifdef __cplusplus' >>confdefs.h
2950   echo $ac_declaration      >>confdefs.h
2951   echo '#endif'             >>confdefs.h
2952 fi
2953
2954 else
2955   echo "$as_me: failed program was:" >&5
2956 sed 's/^/| /' conftest.$ac_ext >&5
2957
2958 fi
2959 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2960 ac_ext=c
2961 ac_cpp='$CPP $CPPFLAGS'
2962 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2963 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2964 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2965
2966
2967
2968 # Add -Wall if we are using GCC.
2969 if test "x$GCC" = "xyes"; then
2970   AM_FCFLAGS="-Wall"
2971   ## We like to use C99 routines when available.  This makes sure that
2972   ## __STDC_VERSION__ is set such that libc includes make them available.
2973   AM_CFLAGS="-std=gnu99 -Wall -Wstrict-prototypes -Wmissing-prototypes -Wold-style-definition -Wextra -Wwrite-strings"
2974 fi
2975
2976
2977
2978 # Find other programs we need.
2979 if test -n "$ac_tool_prefix"; then
2980   # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
2981 set dummy ${ac_tool_prefix}as; ac_word=$2
2982 echo "$as_me:$LINENO: checking for $ac_word" >&5
2983 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2984 if test "${ac_cv_prog_AS+set}" = set; then
2985   echo $ECHO_N "(cached) $ECHO_C" >&6
2986 else
2987   if test -n "$AS"; then
2988   ac_cv_prog_AS="$AS" # Let the user override the test.
2989 else
2990 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2991 for as_dir in $PATH
2992 do
2993   IFS=$as_save_IFS
2994   test -z "$as_dir" && as_dir=.
2995   for ac_exec_ext in '' $ac_executable_extensions; do
2996   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2997     ac_cv_prog_AS="${ac_tool_prefix}as"
2998     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2999     break 2
3000   fi
3001 done
3002 done
3003
3004 fi
3005 fi
3006 AS=$ac_cv_prog_AS
3007 if test -n "$AS"; then
3008   echo "$as_me:$LINENO: result: $AS" >&5
3009 echo "${ECHO_T}$AS" >&6
3010 else
3011   echo "$as_me:$LINENO: result: no" >&5
3012 echo "${ECHO_T}no" >&6
3013 fi
3014
3015 fi
3016 if test -z "$ac_cv_prog_AS"; then
3017   ac_ct_AS=$AS
3018   # Extract the first word of "as", so it can be a program name with args.
3019 set dummy as; ac_word=$2
3020 echo "$as_me:$LINENO: checking for $ac_word" >&5
3021 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3022 if test "${ac_cv_prog_ac_ct_AS+set}" = set; then
3023   echo $ECHO_N "(cached) $ECHO_C" >&6
3024 else
3025   if test -n "$ac_ct_AS"; then
3026   ac_cv_prog_ac_ct_AS="$ac_ct_AS" # Let the user override the test.
3027 else
3028 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3029 for as_dir in $PATH
3030 do
3031   IFS=$as_save_IFS
3032   test -z "$as_dir" && as_dir=.
3033   for ac_exec_ext in '' $ac_executable_extensions; do
3034   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3035     ac_cv_prog_ac_ct_AS="as"
3036     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3037     break 2
3038   fi
3039 done
3040 done
3041
3042 fi
3043 fi
3044 ac_ct_AS=$ac_cv_prog_ac_ct_AS
3045 if test -n "$ac_ct_AS"; then
3046   echo "$as_me:$LINENO: result: $ac_ct_AS" >&5
3047 echo "${ECHO_T}$ac_ct_AS" >&6
3048 else
3049   echo "$as_me:$LINENO: result: no" >&5
3050 echo "${ECHO_T}no" >&6
3051 fi
3052
3053   AS=$ac_ct_AS
3054 else
3055   AS="$ac_cv_prog_AS"
3056 fi
3057
3058 if test -n "$ac_tool_prefix"; then
3059   # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
3060 set dummy ${ac_tool_prefix}ar; ac_word=$2
3061 echo "$as_me:$LINENO: checking for $ac_word" >&5
3062 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3063 if test "${ac_cv_prog_AR+set}" = set; then
3064   echo $ECHO_N "(cached) $ECHO_C" >&6
3065 else
3066   if test -n "$AR"; then
3067   ac_cv_prog_AR="$AR" # Let the user override the test.
3068 else
3069 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3070 for as_dir in $PATH
3071 do
3072   IFS=$as_save_IFS
3073   test -z "$as_dir" && as_dir=.
3074   for ac_exec_ext in '' $ac_executable_extensions; do
3075   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3076     ac_cv_prog_AR="${ac_tool_prefix}ar"
3077     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3078     break 2
3079   fi
3080 done
3081 done
3082
3083 fi
3084 fi
3085 AR=$ac_cv_prog_AR
3086 if test -n "$AR"; then
3087   echo "$as_me:$LINENO: result: $AR" >&5
3088 echo "${ECHO_T}$AR" >&6
3089 else
3090   echo "$as_me:$LINENO: result: no" >&5
3091 echo "${ECHO_T}no" >&6
3092 fi
3093
3094 fi
3095 if test -z "$ac_cv_prog_AR"; then
3096   ac_ct_AR=$AR
3097   # Extract the first word of "ar", so it can be a program name with args.
3098 set dummy ar; ac_word=$2
3099 echo "$as_me:$LINENO: checking for $ac_word" >&5
3100 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3101 if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
3102   echo $ECHO_N "(cached) $ECHO_C" >&6
3103 else
3104   if test -n "$ac_ct_AR"; then
3105   ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
3106 else
3107 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3108 for as_dir in $PATH
3109 do
3110   IFS=$as_save_IFS
3111   test -z "$as_dir" && as_dir=.
3112   for ac_exec_ext in '' $ac_executable_extensions; do
3113   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3114     ac_cv_prog_ac_ct_AR="ar"
3115     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3116     break 2
3117   fi
3118 done
3119 done
3120
3121 fi
3122 fi
3123 ac_ct_AR=$ac_cv_prog_ac_ct_AR
3124 if test -n "$ac_ct_AR"; then
3125   echo "$as_me:$LINENO: result: $ac_ct_AR" >&5
3126 echo "${ECHO_T}$ac_ct_AR" >&6
3127 else
3128   echo "$as_me:$LINENO: result: no" >&5
3129 echo "${ECHO_T}no" >&6
3130 fi
3131
3132   AR=$ac_ct_AR
3133 else
3134   AR="$ac_cv_prog_AR"
3135 fi
3136
3137 if test -n "$ac_tool_prefix"; then
3138   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3139 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3140 echo "$as_me:$LINENO: checking for $ac_word" >&5
3141 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3142 if test "${ac_cv_prog_RANLIB+set}" = set; then
3143   echo $ECHO_N "(cached) $ECHO_C" >&6
3144 else
3145   if test -n "$RANLIB"; then
3146   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3147 else
3148 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3149 for as_dir in $PATH
3150 do
3151   IFS=$as_save_IFS
3152   test -z "$as_dir" && as_dir=.
3153   for ac_exec_ext in '' $ac_executable_extensions; do
3154   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3155     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3156     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3157     break 2
3158   fi
3159 done
3160 done
3161
3162 fi
3163 fi
3164 RANLIB=$ac_cv_prog_RANLIB
3165 if test -n "$RANLIB"; then
3166   echo "$as_me:$LINENO: result: $RANLIB" >&5
3167 echo "${ECHO_T}$RANLIB" >&6
3168 else
3169   echo "$as_me:$LINENO: result: no" >&5
3170 echo "${ECHO_T}no" >&6
3171 fi
3172
3173 fi
3174 if test -z "$ac_cv_prog_RANLIB"; then
3175   ac_ct_RANLIB=$RANLIB
3176   # Extract the first word of "ranlib", so it can be a program name with args.
3177 set dummy ranlib; ac_word=$2
3178 echo "$as_me:$LINENO: checking for $ac_word" >&5
3179 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3180 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3181   echo $ECHO_N "(cached) $ECHO_C" >&6
3182 else
3183   if test -n "$ac_ct_RANLIB"; then
3184   ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3185 else
3186 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3187 for as_dir in $PATH
3188 do
3189   IFS=$as_save_IFS
3190   test -z "$as_dir" && as_dir=.
3191   for ac_exec_ext in '' $ac_executable_extensions; do
3192   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3193     ac_cv_prog_ac_ct_RANLIB="ranlib"
3194     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3195     break 2
3196   fi
3197 done
3198 done
3199
3200   test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB="ranlib-not-found-in-path-error"
3201 fi
3202 fi
3203 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3204 if test -n "$ac_ct_RANLIB"; then
3205   echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3206 echo "${ECHO_T}$ac_ct_RANLIB" >&6
3207 else
3208   echo "$as_me:$LINENO: result: no" >&5
3209 echo "${ECHO_T}no" >&6
3210 fi
3211
3212   RANLIB=$ac_ct_RANLIB
3213 else
3214   RANLIB="$ac_cv_prog_RANLIB"
3215 fi
3216
3217 echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3218 echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3219 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3220 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3221   echo $ECHO_N "(cached) $ECHO_C" >&6
3222 else
3223   cat >conftest.make <<\_ACEOF
3224 all:
3225         @echo 'ac_maketemp="$(MAKE)"'
3226 _ACEOF
3227 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3228 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3229 if test -n "$ac_maketemp"; then
3230   eval ac_cv_prog_make_${ac_make}_set=yes
3231 else
3232   eval ac_cv_prog_make_${ac_make}_set=no
3233 fi
3234 rm -f conftest.make
3235 fi
3236 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3237   echo "$as_me:$LINENO: result: yes" >&5
3238 echo "${ECHO_T}yes" >&6
3239   SET_MAKE=
3240 else
3241   echo "$as_me:$LINENO: result: no" >&5
3242 echo "${ECHO_T}no" >&6
3243   SET_MAKE="MAKE=${MAKE-make}"
3244 fi
3245
3246 # Find a good install program.  We prefer a C program (faster),
3247 # so one script is as good as another.  But avoid the broken or
3248 # incompatible versions:
3249 # SysV /etc/install, /usr/sbin/install
3250 # SunOS /usr/etc/install
3251 # IRIX /sbin/install
3252 # AIX /bin/install
3253 # AmigaOS /C/install, which installs bootblocks on floppy discs
3254 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3255 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3256 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3257 # OS/2's system install, which has a completely different semantic
3258 # ./install, which can be erroneously created by make from ./install.sh.
3259 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3260 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3261 if test -z "$INSTALL"; then
3262 if test "${ac_cv_path_install+set}" = set; then
3263   echo $ECHO_N "(cached) $ECHO_C" >&6
3264 else
3265   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3266 for as_dir in $PATH
3267 do
3268   IFS=$as_save_IFS
3269   test -z "$as_dir" && as_dir=.
3270   # Account for people who put trailing slashes in PATH elements.
3271 case $as_dir/ in
3272   ./ | .// | /cC/* | \
3273   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3274   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3275   /usr/ucb/* ) ;;
3276   *)
3277     # OSF1 and SCO ODT 3.0 have their own names for install.
3278     # Don't use installbsd from OSF since it installs stuff as root
3279     # by default.
3280     for ac_prog in ginstall scoinst install; do
3281       for ac_exec_ext in '' $ac_executable_extensions; do
3282         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3283           if test $ac_prog = install &&
3284             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3285             # AIX install.  It has an incompatible calling convention.
3286             :
3287           elif test $ac_prog = install &&
3288             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3289             # program-specific install script used by HP pwplus--don't use.
3290             :
3291           else
3292             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3293             break 3
3294           fi
3295         fi
3296       done
3297     done
3298     ;;
3299 esac
3300 done
3301
3302
3303 fi
3304   if test "${ac_cv_path_install+set}" = set; then
3305     INSTALL=$ac_cv_path_install
3306   else
3307     # As a last resort, use the slow shell script.  We don't cache a
3308     # path for INSTALL within a source directory, because that will
3309     # break other packages using the cache if that directory is
3310     # removed, or if the path is relative.
3311     INSTALL=$ac_install_sh
3312   fi
3313 fi
3314 echo "$as_me:$LINENO: result: $INSTALL" >&5
3315 echo "${ECHO_T}$INSTALL" >&6
3316
3317 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3318 # It thinks the first close brace ends the variable substitution.
3319 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3320
3321 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3322
3323 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3324
3325
3326 # Configure libtool
3327 #AC_MSG_NOTICE([====== Starting libtool configuration])
3328
3329 # Check whether --enable-shared or --disable-shared was given.
3330 if test "${enable_shared+set}" = set; then
3331   enableval="$enable_shared"
3332   p=${PACKAGE-default}
3333 case $enableval in
3334 yes) enable_shared=yes ;;
3335 no) enable_shared=no ;;
3336 *)
3337   enable_shared=no
3338   # Look at the argument we got.  We use all the common list separators.
3339   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3340   for pkg in $enableval; do
3341     if test "X$pkg" = "X$p"; then
3342       enable_shared=yes
3343     fi
3344   done
3345   IFS="$ac_save_ifs"
3346   ;;
3347 esac
3348 else
3349   enable_shared=yes
3350 fi;
3351 # Check whether --enable-static or --disable-static was given.
3352 if test "${enable_static+set}" = set; then
3353   enableval="$enable_static"
3354   p=${PACKAGE-default}
3355 case $enableval in
3356 yes) enable_static=yes ;;
3357 no) enable_static=no ;;
3358 *)
3359   enable_static=no
3360   # Look at the argument we got.  We use all the common list separators.
3361   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3362   for pkg in $enableval; do
3363     if test "X$pkg" = "X$p"; then
3364       enable_static=yes
3365     fi
3366   done
3367   IFS="$ac_save_ifs"
3368   ;;
3369 esac
3370 else
3371   enable_static=yes
3372 fi;
3373 # Check whether --enable-fast-install or --disable-fast-install was given.
3374 if test "${enable_fast_install+set}" = set; then
3375   enableval="$enable_fast_install"
3376   p=${PACKAGE-default}
3377 case $enableval in
3378 yes) enable_fast_install=yes ;;
3379 no) enable_fast_install=no ;;
3380 *)
3381   enable_fast_install=no
3382   # Look at the argument we got.  We use all the common list separators.
3383   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3384   for pkg in $enableval; do
3385     if test "X$pkg" = "X$p"; then
3386       enable_fast_install=yes
3387     fi
3388   done
3389   IFS="$ac_save_ifs"
3390   ;;
3391 esac
3392 else
3393   enable_fast_install=yes
3394 fi;
3395
3396 # Check whether --with-gnu-ld or --without-gnu-ld was given.
3397 if test "${with_gnu_ld+set}" = set; then
3398   withval="$with_gnu_ld"
3399   test "$withval" = no || with_gnu_ld=yes
3400 else
3401   with_gnu_ld=no
3402 fi;
3403 ac_prog=ld
3404 if test "$GCC" = yes; then
3405   # Check if gcc -print-prog-name=ld gives a path.
3406   echo "$as_me:$LINENO: checking for ld used by GCC" >&5
3407 echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6
3408   case $host in
3409   *-*-mingw*)
3410     # gcc leaves a trailing carriage return which upsets mingw
3411     ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
3412   *)
3413     ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
3414   esac
3415   case $ac_prog in
3416     # Accept absolute paths.
3417     [\\/]* | [A-Za-z]:[\\/]*)
3418       re_direlt='/[^/][^/]*/\.\./'
3419       # Canonicalize the path of ld
3420       ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
3421       while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
3422         ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
3423       done
3424       test -z "$LD" && LD="$ac_prog"
3425       ;;
3426   "")
3427     # If it fails, then pretend we aren't using GCC.
3428     ac_prog=ld
3429     ;;
3430   *)
3431     # If it is relative, then search for the first ld in PATH.
3432     with_gnu_ld=unknown
3433     ;;
3434   esac
3435 elif test "$with_gnu_ld" = yes; then
3436   echo "$as_me:$LINENO: checking for GNU ld" >&5
3437 echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6
3438 else
3439   echo "$as_me:$LINENO: checking for non-GNU ld" >&5
3440 echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6
3441 fi
3442 if test "${lt_cv_path_LD+set}" = set; then
3443   echo $ECHO_N "(cached) $ECHO_C" >&6
3444 else
3445   if test -z "$LD"; then
3446   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
3447   for ac_dir in $PATH; do
3448     test -z "$ac_dir" && ac_dir=.
3449     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
3450       lt_cv_path_LD="$ac_dir/$ac_prog"
3451       # Check to see if the program is GNU ld.  I'd rather use --version,
3452       # but apparently some GNU ld's only accept -v.
3453       # Break only if it was the GNU/non-GNU ld that we prefer.
3454       if "$lt_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
3455         test "$with_gnu_ld" != no && break
3456       else
3457         test "$with_gnu_ld" != yes && break
3458       fi
3459     fi
3460   done
3461   IFS="$ac_save_ifs"
3462 else
3463   lt_cv_path_LD="$LD" # Let the user override the test with a path.
3464 fi
3465 fi
3466
3467 LD="$lt_cv_path_LD"
3468 if test -n "$LD"; then
3469   echo "$as_me:$LINENO: result: $LD" >&5
3470 echo "${ECHO_T}$LD" >&6
3471 else
3472   echo "$as_me:$LINENO: result: no" >&5
3473 echo "${ECHO_T}no" >&6
3474 fi
3475 test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5
3476 echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}
3477    { (exit 1); exit 1; }; }
3478 echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
3479 echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6
3480 if test "${lt_cv_prog_gnu_ld+set}" = set; then
3481   echo $ECHO_N "(cached) $ECHO_C" >&6
3482 else
3483   # I'd rather use --version here, but apparently some GNU ld's only accept -v.
3484 if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
3485   lt_cv_prog_gnu_ld=yes
3486 else
3487   lt_cv_prog_gnu_ld=no
3488 fi
3489 fi
3490 echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
3491 echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6
3492 with_gnu_ld=$lt_cv_prog_gnu_ld
3493
3494
3495 echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
3496 echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6
3497 if test "${lt_cv_ld_reload_flag+set}" = set; then
3498   echo $ECHO_N "(cached) $ECHO_C" >&6
3499 else
3500   lt_cv_ld_reload_flag='-r'
3501 fi
3502 echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
3503 echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6
3504 reload_flag=$lt_cv_ld_reload_flag
3505 test -n "$reload_flag" && reload_flag=" $reload_flag"
3506
3507 echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
3508 echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6
3509 if test "${lt_cv_path_NM+set}" = set; then
3510   echo $ECHO_N "(cached) $ECHO_C" >&6
3511 else
3512   if test -n "$NM"; then
3513   # Let the user override the test.
3514   lt_cv_path_NM="$NM"
3515 else
3516   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
3517   for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
3518     test -z "$ac_dir" && ac_dir=.
3519     tmp_nm=$ac_dir/${ac_tool_prefix}nm
3520     if test -f $tmp_nm || test -f $tmp_nm$ac_exeext ; then
3521       # Check to see if the nm accepts a BSD-compat flag.
3522       # Adding the `sed 1q' prevents false positives on HP-UX, which says:
3523       #   nm: unknown option "B" ignored
3524       # Tru64's nm complains that /dev/null is an invalid object file
3525       if ($tmp_nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep '(/dev/null|Invalid file or object type)' >/dev/null; then
3526         lt_cv_path_NM="$tmp_nm -B"
3527         break
3528       elif ($tmp_nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
3529         lt_cv_path_NM="$tmp_nm -p"
3530         break
3531       else
3532         lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
3533         continue # so that we can try to find one that supports BSD flags
3534       fi
3535     fi
3536   done
3537   IFS="$ac_save_ifs"
3538   test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm
3539 fi
3540 fi
3541
3542 NM="$lt_cv_path_NM"
3543 echo "$as_me:$LINENO: result: $NM" >&5
3544 echo "${ECHO_T}$NM" >&6
3545
3546 echo "$as_me:$LINENO: checking whether ln -s works" >&5
3547 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3548 LN_S=$as_ln_s
3549 if test "$LN_S" = "ln -s"; then
3550   echo "$as_me:$LINENO: result: yes" >&5
3551 echo "${ECHO_T}yes" >&6
3552 else
3553   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3554 echo "${ECHO_T}no, using $LN_S" >&6
3555 fi
3556
3557 echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5
3558 echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6
3559 if test "${lt_cv_deplibs_check_method+set}" = set; then
3560   echo $ECHO_N "(cached) $ECHO_C" >&6
3561 else
3562   lt_cv_file_magic_cmd='$MAGIC_CMD'
3563 lt_cv_file_magic_test_file=
3564 lt_cv_deplibs_check_method='unknown'
3565 # Need to set the preceding variable on all platforms that support
3566 # interlibrary dependencies.
3567 # 'none' -- dependencies not supported.
3568 # `unknown' -- same as none, but documents that we really don't know.
3569 # 'pass_all' -- all dependencies passed with no checks.
3570 # 'test_compile' -- check by making test program.
3571 # 'file_magic [regex]' -- check by looking for files in library path
3572 # which responds to the $file_magic_cmd with a given egrep regex.
3573 # If you have `file' or equivalent on your system and you're not sure
3574 # whether `pass_all' will *always* work, you probably want this one.
3575
3576 case $host_os in
3577 aix*)
3578   lt_cv_deplibs_check_method=pass_all
3579   ;;
3580
3581 beos*)
3582   lt_cv_deplibs_check_method=pass_all
3583   ;;
3584
3585 bsdi4*)
3586   lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
3587   lt_cv_file_magic_cmd='/usr/bin/file -L'
3588   lt_cv_file_magic_test_file=/shlib/libc.so
3589   ;;
3590
3591 cygwin* | mingw* |pw32*)
3592   lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
3593   lt_cv_file_magic_cmd='$OBJDUMP -f'
3594   ;;
3595
3596 darwin* | rhapsody*)
3597   # this will be overwritten by pass_all, but leave it in just in case
3598   lt_cv_deplibs_check_method='file_magic Mach-O dynamically linked shared library'
3599   lt_cv_file_magic_cmd='/usr/bin/file -L'
3600   case "$host_os" in
3601   rhapsody* | darwin1.012)
3602     lt_cv_file_magic_test_file='/System/Library/Frameworks/System.framework/System'
3603     ;;
3604   *) # Darwin 1.3 on
3605     lt_cv_file_magic_test_file='/usr/lib/libSystem.dylib'
3606     ;;
3607   esac
3608   lt_cv_deplibs_check_method=pass_all
3609   ;;
3610
3611 freebsd* | kfreebsd*-gnu)
3612   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
3613     case $host_cpu in
3614     i*86 )
3615       # Not sure whether the presence of OpenBSD here was a mistake.
3616       # Let's accept both of them until this is cleared up.
3617       lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[3-9]86 (compact )?demand paged shared library'
3618       lt_cv_file_magic_cmd=/usr/bin/file
3619       lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
3620       ;;
3621     esac
3622   else
3623     lt_cv_deplibs_check_method=pass_all
3624   fi
3625   ;;
3626
3627 gnu*)
3628   lt_cv_deplibs_check_method=pass_all
3629   ;;
3630
3631 hpux10.20*|hpux11*)
3632   case $host_cpu in
3633   hppa*)
3634     lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library'
3635     lt_cv_file_magic_cmd=/usr/bin/file
3636     lt_cv_file_magic_test_file=/usr/lib/libc.sl
3637     ;;
3638   ia64*)
3639     lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
3640     lt_cv_file_magic_cmd=/usr/bin/file
3641     lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
3642     ;;
3643   esac
3644   ;;
3645
3646 irix5* | irix6*)
3647   case $host_os in
3648   irix5*)
3649     # this will be overridden with pass_all, but let us keep it just in case
3650     lt_cv_deplibs_check_method="file_magic ELF 32-bit MSB dynamic lib MIPS - version 1"
3651     ;;
3652   *)
3653     case $LD in
3654     *-32|*"-32 ") libmagic=32-bit;;
3655     *-n32|*"-n32 ") libmagic=N32;;
3656     *-64|*"-64 ") libmagic=64-bit;;
3657     *) libmagic=never-match;;
3658     esac
3659     # this will be overridden with pass_all, but let us keep it just in case
3660     lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[1234] dynamic lib MIPS - version 1"
3661     ;;
3662   esac
3663   lt_cv_file_magic_test_file=`echo /lib${libsuff}/libc.so*`
3664   lt_cv_deplibs_check_method=pass_all
3665   ;;
3666
3667 # This must be Linux ELF.
3668 linux-gnu*)
3669   lt_cv_deplibs_check_method=pass_all
3670   ;;
3671
3672 netbsd* | knetbsd*-gnu)
3673   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
3674     lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so\.[0-9]+\.[0-9]+$'
3675   else
3676     lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so$'
3677   fi
3678   ;;
3679
3680 newsos6)
3681   lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'
3682   lt_cv_file_magic_cmd=/usr/bin/file
3683   lt_cv_file_magic_test_file=/usr/lib/libnls.so
3684   ;;
3685
3686 osf3* | osf4* | osf5*)
3687   # this will be overridden with pass_all, but let us keep it just in case
3688   lt_cv_deplibs_check_method='file_magic COFF format alpha shared library'
3689   lt_cv_file_magic_test_file=/shlib/libc.so
3690   lt_cv_deplibs_check_method=pass_all
3691   ;;
3692
3693 sco3.2v5*)
3694   lt_cv_deplibs_check_method=pass_all
3695   ;;
3696
3697 solaris*)
3698   lt_cv_deplibs_check_method=pass_all
3699   lt_cv_file_magic_test_file=/lib/libc.so
3700   ;;
3701
3702 sysv5uw[78]* | sysv4*uw2*)
3703   lt_cv_deplibs_check_method=pass_all
3704   ;;
3705
3706 sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
3707   case $host_vendor in
3708   ncr)
3709     lt_cv_deplibs_check_method=pass_all
3710     ;;
3711   motorola)
3712     lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'
3713     lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
3714     ;;
3715   esac
3716   ;;
3717 esac
3718
3719 fi
3720 echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
3721 echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6
3722 file_magic_cmd=$lt_cv_file_magic_cmd
3723 deplibs_check_method=$lt_cv_deplibs_check_method
3724
3725
3726
3727
3728
3729 # Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
3730
3731 # find the maximum length of command line arguments
3732 echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
3733 echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6
3734 if test "${lt_cv_sys_max_cmd_len+set}" = set; then
3735   echo $ECHO_N "(cached) $ECHO_C" >&6
3736 else
3737     i=0
3738   teststring="ABCD"
3739
3740   case $build_os in
3741   msdosdjgpp*)
3742     # On DJGPP, this test can blow up pretty badly due to problems in libc
3743     # (any single argument exceeding 2000 bytes causes a buffer overrun
3744     # during glob expansion).  Even if it were fixed, the result of this
3745     # check would be larger than it should be.
3746     lt_cv_sys_max_cmd_len=12288;    # 12K is about right
3747     ;;
3748
3749   cygwin* | mingw*)
3750     # On Win9x/ME, this test blows up -- it succeeds, but takes
3751     # about 5 minutes as the teststring grows exponentially.
3752     # Worse, since 9x/ME are not pre-emptively multitasking,
3753     # you end up with a "frozen" computer, even though with patience
3754     # the test eventually succeeds (with a max line length of 256k).
3755     # Instead, let's just punt: use the minimum linelength reported by
3756     # all of the supported platforms: 8192 (on NT/2K/XP).
3757     lt_cv_sys_max_cmd_len=8192;
3758     ;;
3759
3760   amigaos*)
3761     # On AmigaOS with pdksh, this test takes hours, literally.
3762     # So we just punt and use a minimum line length of 8192.
3763     lt_cv_sys_max_cmd_len=8192;
3764     ;;
3765
3766   netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
3767     # This has been around since 386BSD, at least.  Likely further.
3768     if test -x /sbin/sysctl; then
3769       lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
3770     elif test -x /usr/sbin/sysctl; then
3771       lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
3772     else
3773       lt_cv_sys_max_cmd_len=65536 # usable default for *BSD
3774     fi
3775     # And add a safety zone
3776     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
3777     lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
3778     ;;
3779   esac
3780
3781 fi
3782
3783 if test -n "$lt_cv_sys_max_cmd_len" ; then
3784   echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
3785 echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6
3786 else
3787   echo "$as_me:$LINENO: result: none" >&5
3788 echo "${ECHO_T}none" >&6
3789 fi
3790
3791
3792 # Only perform the check for file, if the check method requires it
3793 case $deplibs_check_method in
3794 file_magic*)
3795   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
3796     echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
3797 echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6
3798 if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
3799   echo $ECHO_N "(cached) $ECHO_C" >&6
3800 else
3801   case $MAGIC_CMD in
3802   /*)
3803   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
3804   ;;
3805   ?:/*)
3806   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
3807   ;;
3808   *)
3809   ac_save_MAGIC_CMD="$MAGIC_CMD"
3810   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3811   ac_dummy="/usr/bin:$PATH"
3812   for ac_dir in $ac_dummy; do
3813     test -z "$ac_dir" && ac_dir=.
3814     if test -f $ac_dir/${ac_tool_prefix}file; then
3815       lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
3816       if test -n "$file_magic_test_file"; then
3817         case $deplibs_check_method in
3818         "file_magic "*)
3819           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
3820           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
3821           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
3822             egrep "$file_magic_regex" > /dev/null; then
3823             :
3824           else
3825             cat <<EOF 1>&2
3826
3827 *** Warning: the command libtool uses to detect shared libraries,
3828 *** $file_magic_cmd, produces output that libtool cannot recognize.
3829 *** The result is that libtool may fail to recognize shared libraries
3830 *** as such.  This will affect the creation of libtool libraries that
3831 *** depend on shared libraries, but programs linked with such libtool
3832 *** libraries will work regardless of this problem.  Nevertheless, you
3833 *** may want to report the problem to your system manager and/or to
3834 *** bug-libtool@gnu.org
3835
3836 EOF
3837           fi ;;
3838         esac
3839       fi
3840       break
3841     fi
3842   done
3843   IFS="$ac_save_ifs"
3844   MAGIC_CMD="$ac_save_MAGIC_CMD"
3845   ;;
3846 esac
3847 fi
3848
3849 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
3850 if test -n "$MAGIC_CMD"; then
3851   echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
3852 echo "${ECHO_T}$MAGIC_CMD" >&6
3853 else
3854   echo "$as_me:$LINENO: result: no" >&5
3855 echo "${ECHO_T}no" >&6
3856 fi
3857
3858 if test -z "$lt_cv_path_MAGIC_CMD"; then
3859   if test -n "$ac_tool_prefix"; then
3860     echo "$as_me:$LINENO: checking for file" >&5
3861 echo $ECHO_N "checking for file... $ECHO_C" >&6
3862 if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
3863   echo $ECHO_N "(cached) $ECHO_C" >&6
3864 else
3865   case $MAGIC_CMD in
3866   /*)
3867   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
3868   ;;
3869   ?:/*)
3870   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
3871   ;;
3872   *)
3873   ac_save_MAGIC_CMD="$MAGIC_CMD"
3874   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3875   ac_dummy="/usr/bin:$PATH"
3876   for ac_dir in $ac_dummy; do
3877     test -z "$ac_dir" && ac_dir=.
3878     if test -f $ac_dir/file; then
3879       lt_cv_path_MAGIC_CMD="$ac_dir/file"
3880       if test -n "$file_magic_test_file"; then
3881         case $deplibs_check_method in
3882         "file_magic "*)
3883           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
3884           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
3885           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
3886             egrep "$file_magic_regex" > /dev/null; then
3887             :
3888           else
3889             cat <<EOF 1>&2
3890
3891 *** Warning: the command libtool uses to detect shared libraries,
3892 *** $file_magic_cmd, produces output that libtool cannot recognize.
3893 *** The result is that libtool may fail to recognize shared libraries
3894 *** as such.  This will affect the creation of libtool libraries that
3895 *** depend on shared libraries, but programs linked with such libtool
3896 *** libraries will work regardless of this problem.  Nevertheless, you
3897 *** may want to report the problem to your system manager and/or to
3898 *** bug-libtool@gnu.org
3899
3900 EOF
3901           fi ;;
3902         esac
3903       fi
3904       break
3905     fi
3906   done
3907   IFS="$ac_save_ifs"
3908   MAGIC_CMD="$ac_save_MAGIC_CMD"
3909   ;;
3910 esac
3911 fi
3912
3913 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
3914 if test -n "$MAGIC_CMD"; then
3915   echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
3916 echo "${ECHO_T}$MAGIC_CMD" >&6
3917 else
3918   echo "$as_me:$LINENO: result: no" >&5
3919 echo "${ECHO_T}no" >&6
3920 fi
3921
3922   else
3923     MAGIC_CMD=:
3924   fi
3925 fi
3926
3927   fi
3928   ;;
3929 esac
3930
3931 if test -n "$ac_tool_prefix"; then
3932   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3933 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3934 echo "$as_me:$LINENO: checking for $ac_word" >&5
3935 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3936 if test "${ac_cv_prog_RANLIB+set}" = set; then
3937   echo $ECHO_N "(cached) $ECHO_C" >&6
3938 else
3939   if test -n "$RANLIB"; then
3940   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3941 else
3942 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3943 for as_dir in $PATH
3944 do
3945   IFS=$as_save_IFS
3946   test -z "$as_dir" && as_dir=.
3947   for ac_exec_ext in '' $ac_executable_extensions; do
3948   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3949     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3950     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3951     break 2
3952   fi
3953 done
3954 done
3955
3956 fi
3957 fi
3958 RANLIB=$ac_cv_prog_RANLIB
3959 if test -n "$RANLIB"; then
3960   echo "$as_me:$LINENO: result: $RANLIB" >&5
3961 echo "${ECHO_T}$RANLIB" >&6
3962 else
3963   echo "$as_me:$LINENO: result: no" >&5
3964 echo "${ECHO_T}no" >&6
3965 fi
3966
3967 fi
3968 if test -z "$ac_cv_prog_RANLIB"; then
3969   ac_ct_RANLIB=$RANLIB
3970   # Extract the first word of "ranlib", so it can be a program name with args.
3971 set dummy ranlib; ac_word=$2
3972 echo "$as_me:$LINENO: checking for $ac_word" >&5
3973 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3974 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3975   echo $ECHO_N "(cached) $ECHO_C" >&6
3976 else
3977   if test -n "$ac_ct_RANLIB"; then
3978   ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3979 else
3980 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3981 for as_dir in $PATH
3982 do
3983   IFS=$as_save_IFS
3984   test -z "$as_dir" && as_dir=.
3985   for ac_exec_ext in '' $ac_executable_extensions; do
3986   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3987     ac_cv_prog_ac_ct_RANLIB="ranlib"
3988     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3989     break 2
3990   fi
3991 done
3992 done
3993
3994   test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3995 fi
3996 fi
3997 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3998 if test -n "$ac_ct_RANLIB"; then
3999   echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
4000 echo "${ECHO_T}$ac_ct_RANLIB" >&6
4001 else
4002   echo "$as_me:$LINENO: result: no" >&5
4003 echo "${ECHO_T}no" >&6
4004 fi
4005
4006   RANLIB=$ac_ct_RANLIB
4007 else
4008   RANLIB="$ac_cv_prog_RANLIB"
4009 fi
4010
4011 if test -n "$ac_tool_prefix"; then
4012   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
4013 set dummy ${ac_tool_prefix}strip; ac_word=$2
4014 echo "$as_me:$LINENO: checking for $ac_word" >&5
4015 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4016 if test "${ac_cv_prog_STRIP+set}" = set; then
4017   echo $ECHO_N "(cached) $ECHO_C" >&6
4018 else
4019   if test -n "$STRIP"; then
4020   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
4021 else
4022 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4023 for as_dir in $PATH
4024 do
4025   IFS=$as_save_IFS
4026   test -z "$as_dir" && as_dir=.
4027   for ac_exec_ext in '' $ac_executable_extensions; do
4028   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4029     ac_cv_prog_STRIP="${ac_tool_prefix}strip"
4030     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4031     break 2
4032   fi
4033 done
4034 done
4035
4036 fi
4037 fi
4038 STRIP=$ac_cv_prog_STRIP
4039 if test -n "$STRIP"; then
4040   echo "$as_me:$LINENO: result: $STRIP" >&5
4041 echo "${ECHO_T}$STRIP" >&6
4042 else
4043   echo "$as_me:$LINENO: result: no" >&5
4044 echo "${ECHO_T}no" >&6
4045 fi
4046
4047 fi
4048 if test -z "$ac_cv_prog_STRIP"; then
4049   ac_ct_STRIP=$STRIP
4050   # Extract the first word of "strip", so it can be a program name with args.
4051 set dummy strip; ac_word=$2
4052 echo "$as_me:$LINENO: checking for $ac_word" >&5
4053 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4054 if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
4055   echo $ECHO_N "(cached) $ECHO_C" >&6
4056 else
4057   if test -n "$ac_ct_STRIP"; then
4058   ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
4059 else
4060 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4061 for as_dir in $PATH
4062 do
4063   IFS=$as_save_IFS
4064   test -z "$as_dir" && as_dir=.
4065   for ac_exec_ext in '' $ac_executable_extensions; do
4066   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4067     ac_cv_prog_ac_ct_STRIP="strip"
4068     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4069     break 2
4070   fi
4071 done
4072 done
4073
4074   test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
4075 fi
4076 fi
4077 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
4078 if test -n "$ac_ct_STRIP"; then
4079   echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
4080 echo "${ECHO_T}$ac_ct_STRIP" >&6
4081 else
4082   echo "$as_me:$LINENO: result: no" >&5
4083 echo "${ECHO_T}no" >&6
4084 fi
4085
4086   STRIP=$ac_ct_STRIP
4087 else
4088   STRIP="$ac_cv_prog_STRIP"
4089 fi
4090
4091
4092 # Check for any special flags to pass to ltconfig.
4093 libtool_flags="--cache-file=$cache_file"
4094 test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
4095 test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
4096 test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
4097 test "$GCC" = yes && libtool_flags="$libtool_flags --with-gcc"
4098 test "$lt_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
4099
4100
4101 # Check whether --enable-libtool-lock or --disable-libtool-lock was given.
4102 if test "${enable_libtool_lock+set}" = set; then
4103   enableval="$enable_libtool_lock"
4104
4105 fi;
4106 test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
4107 test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
4108
4109
4110 # Check whether --with-pic or --without-pic was given.
4111 if test "${with_pic+set}" = set; then
4112   withval="$with_pic"
4113   pic_mode="$withval"
4114 else
4115   pic_mode=default
4116 fi;
4117 test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic"
4118 test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
4119
4120 # Some flags need to be propagated to the compiler or linker for good
4121 # libtool support.
4122 case $host in
4123 *-*-irix6*)
4124   # Find out which ABI we are using.
4125   echo '#line 4125 "configure"' > conftest.$ac_ext
4126   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4127   (eval $ac_compile) 2>&5
4128   ac_status=$?
4129   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4130   (exit $ac_status); }; then
4131    if test "$lt_cv_prog_gnu_ld" = yes; then
4132     case `/usr/bin/file conftest.$ac_objext` in
4133     *32-bit*)
4134       LD="${LD-ld} -melf32bsmip"
4135       ;;
4136     *N32*)
4137       LD="${LD-ld} -melf32bmipn32"
4138       ;;
4139     *64-bit*)
4140       LD="${LD-ld} -melf64bmip"
4141       ;;
4142     esac
4143    else
4144     case `/usr/bin/file conftest.$ac_objext` in
4145     *32-bit*)
4146       LD="${LD-ld} -32"
4147       ;;
4148     *N32*)
4149       LD="${LD-ld} -n32"
4150       ;;
4151     *64-bit*)
4152       LD="${LD-ld} -64"
4153       ;;
4154     esac
4155    fi
4156   fi
4157   rm -rf conftest*
4158   ;;
4159
4160 ia64-*-hpux*)
4161   # Find out which ABI we are using.
4162   echo 'int i;' > conftest.$ac_ext
4163   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4164   (eval $ac_compile) 2>&5
4165   ac_status=$?
4166   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4167   (exit $ac_status); }; then
4168     case "`/usr/bin/file conftest.o`" in
4169     *ELF-32*)
4170       HPUX_IA64_MODE="32"
4171       ;;
4172     *ELF-64*)
4173       HPUX_IA64_MODE="64"
4174       ;;
4175     esac
4176   fi
4177   rm -rf conftest*
4178   ;;
4179
4180 x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*)
4181   # Find out which ABI we are using.
4182   echo 'int i;' > conftest.$ac_ext
4183   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4184   (eval $ac_compile) 2>&5
4185   ac_status=$?
4186   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4187   (exit $ac_status); }; then
4188     case "`/usr/bin/file conftest.o`" in
4189     *32-bit*)
4190       case $host in
4191         x86_64-*linux*)
4192           LD="${LD-ld} -m elf_i386"
4193           ;;
4194         ppc64-*linux*|powerpc64-*linux*)
4195           LD="${LD-ld} -m elf32ppclinux"
4196           ;;
4197         s390x-*linux*)
4198           LD="${LD-ld} -m elf_s390"
4199           ;;
4200         sparc64-*linux*)
4201           LD="${LD-ld} -m elf32_sparc"
4202           ;;
4203       esac
4204       ;;
4205     *64-bit*)
4206       case $host in
4207         x86_64-*linux*)
4208           LD="${LD-ld} -m elf_x86_64"
4209           ;;
4210         ppc*-*linux*|powerpc*-*linux*)
4211           LD="${LD-ld} -m elf64ppc"
4212           ;;
4213         s390*-*linux*)
4214           LD="${LD-ld} -m elf64_s390"
4215           ;;
4216         sparc*-*linux*)
4217           LD="${LD-ld} -m elf64_sparc"
4218           ;;
4219       esac
4220       ;;
4221     esac
4222   fi
4223   rm -rf conftest*
4224   ;;
4225
4226 *-*-sco3.2v5*)
4227   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
4228   SAVE_CFLAGS="$CFLAGS"
4229   CFLAGS="$CFLAGS -belf"
4230   echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
4231 echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6
4232 if test "${lt_cv_cc_needs_belf+set}" = set; then
4233   echo $ECHO_N "(cached) $ECHO_C" >&6
4234 else
4235
4236
4237      ac_ext=c
4238 ac_cpp='$CPP $CPPFLAGS'
4239 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4240 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4241 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4242
4243      if test x$gcc_no_link = xyes; then
4244   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
4245 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
4246    { (exit 1); exit 1; }; }
4247 fi
4248 cat >conftest.$ac_ext <<_ACEOF
4249 /* confdefs.h.  */
4250 _ACEOF
4251 cat confdefs.h >>conftest.$ac_ext
4252 cat >>conftest.$ac_ext <<_ACEOF
4253 /* end confdefs.h.  */
4254
4255 int
4256 main ()
4257 {
4258
4259   ;
4260   return 0;
4261 }
4262 _ACEOF
4263 rm -f conftest.$ac_objext conftest$ac_exeext
4264 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4265   (eval $ac_link) 2>conftest.er1
4266   ac_status=$?
4267   grep -v '^ *+' conftest.er1 >conftest.err
4268   rm -f conftest.er1
4269   cat conftest.err >&5
4270   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4271   (exit $ac_status); } &&
4272          { ac_try='test -z "$ac_c_werror_flag"
4273                          || test ! -s conftest.err'
4274   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4275   (eval $ac_try) 2>&5
4276   ac_status=$?
4277   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4278   (exit $ac_status); }; } &&
4279          { ac_try='test -s conftest$ac_exeext'
4280   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4281   (eval $ac_try) 2>&5
4282   ac_status=$?
4283   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4284   (exit $ac_status); }; }; then
4285   lt_cv_cc_needs_belf=yes
4286 else
4287   echo "$as_me: failed program was:" >&5
4288 sed 's/^/| /' conftest.$ac_ext >&5
4289
4290 lt_cv_cc_needs_belf=no
4291 fi
4292 rm -f conftest.err conftest.$ac_objext \
4293       conftest$ac_exeext conftest.$ac_ext
4294      ac_ext=c
4295 ac_cpp='$CPP $CPPFLAGS'
4296 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4297 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4298 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4299
4300 fi
4301 echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
4302 echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6
4303   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
4304     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
4305     CFLAGS="$SAVE_CFLAGS"
4306   fi
4307   ;;
4308
4309
4310 esac
4311
4312
4313 # Save cache, so that ltconfig can load it
4314 cat >confcache <<\_ACEOF
4315 # This file is a shell script that caches the results of configure
4316 # tests run on this system so they can be shared between configure
4317 # scripts and configure runs, see configure's option --config-cache.
4318 # It is not useful on other systems.  If it contains results you don't
4319 # want to keep, you may remove or edit it.
4320 #
4321 # config.status only pays attention to the cache file if you give it
4322 # the --recheck option to rerun configure.
4323 #
4324 # `ac_cv_env_foo' variables (set or unset) will be overridden when
4325 # loading this file, other *unset* `ac_cv_foo' will be assigned the
4326 # following values.
4327
4328 _ACEOF
4329
4330 # The following way of writing the cache mishandles newlines in values,
4331 # but we know of no workaround that is simple, portable, and efficient.
4332 # So, don't put newlines in cache variables' values.
4333 # Ultrix sh set writes to stderr and can't be redirected directly,
4334 # and sets the high bit in the cache file unless we assign to the vars.
4335 {
4336   (set) 2>&1 |
4337     case `(ac_space=' '; set | grep ac_space) 2>&1` in
4338     *ac_space=\ *)
4339       # `set' does not quote correctly, so add quotes (double-quote
4340       # substitution turns \\\\ into \\, and sed turns \\ into \).
4341       sed -n \
4342         "s/'/'\\\\''/g;
4343           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
4344       ;;
4345     *)
4346       # `set' quotes correctly as required by POSIX, so do not add quotes.
4347       sed -n \
4348         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
4349       ;;
4350     esac;
4351 } |
4352   sed '
4353      t clear
4354      : clear
4355      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
4356      t end
4357      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
4358      : end' >>confcache
4359 if diff $cache_file confcache >/dev/null 2>&1; then :; else
4360   if test -w $cache_file; then
4361     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
4362     cat confcache >$cache_file
4363   else
4364     echo "not updating unwritable cache $cache_file"
4365   fi
4366 fi
4367 rm -f confcache
4368
4369 # Actually configure libtool.  ac_aux_dir is where install-sh is found.
4370 AR="$AR" LTCC="$CC" CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
4371 MAGIC_CMD="$MAGIC_CMD" LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
4372 LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \
4373 AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \
4374 objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \
4375 deplibs_check_method="$deplibs_check_method" file_magic_cmd="$file_magic_cmd" \
4376 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
4377 $libtool_flags --no-verify --build="$build" $ac_aux_dir/ltmain.sh $host \
4378 || { { echo "$as_me:$LINENO: error: libtool configure failed" >&5
4379 echo "$as_me: error: libtool configure failed" >&2;}
4380    { (exit 1); exit 1; }; }
4381
4382 # Reload cache, that may have been modified by ltconfig
4383 if test -r "$cache_file"; then
4384   # Some versions of bash will fail to source /dev/null (special
4385   # files actually), so we avoid doing that.
4386   if test -f "$cache_file"; then
4387     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
4388 echo "$as_me: loading cache $cache_file" >&6;}
4389     case $cache_file in
4390       [\\/]* | ?:[\\/]* ) . $cache_file;;
4391       *)                      . ./$cache_file;;
4392     esac
4393   fi
4394 else
4395   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
4396 echo "$as_me: creating cache $cache_file" >&6;}
4397   >$cache_file
4398 fi
4399
4400
4401 # This can be used to rebuild libtool when needed
4402 LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh $ac_aux_dir/ltcf-c.sh"
4403
4404 # Always use our own libtool.
4405 LIBTOOL='$(SHELL) $(top_builddir)/libtool'
4406
4407 # Redirect the config.log output again, so that the ltconfig log is not
4408 # clobbered by the next message.
4409 exec 5>>./config.log
4410
4411
4412
4413
4414
4415
4416
4417
4418 #AC_MSG_NOTICE([====== Finished libtool configuration]) ; sleep 10
4419
4420 # We need gfortran to compile parts of the library
4421 # We can't use AC_PROG_FC because it expects a fully working gfortran.
4422 #AC_PROG_FC(gfortran)
4423 FC="$GFORTRAN"
4424 ac_ext=${FC_SRCEXT-f}
4425 ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4426 ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4427 ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4428 if test -n "$ac_tool_prefix"; then
4429   for ac_prog in gfortran
4430   do
4431     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4432 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4433 echo "$as_me:$LINENO: checking for $ac_word" >&5
4434 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4435 if test "${ac_cv_prog_FC+set}" = set; then
4436   echo $ECHO_N "(cached) $ECHO_C" >&6
4437 else
4438   if test -n "$FC"; then
4439   ac_cv_prog_FC="$FC" # Let the user override the test.
4440 else
4441 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4442 for as_dir in $PATH
4443 do
4444   IFS=$as_save_IFS
4445   test -z "$as_dir" && as_dir=.
4446   for ac_exec_ext in '' $ac_executable_extensions; do
4447   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4448     ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
4449     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4450     break 2
4451   fi
4452 done
4453 done
4454
4455 fi
4456 fi
4457 FC=$ac_cv_prog_FC
4458 if test -n "$FC"; then
4459   echo "$as_me:$LINENO: result: $FC" >&5
4460 echo "${ECHO_T}$FC" >&6
4461 else
4462   echo "$as_me:$LINENO: result: no" >&5
4463 echo "${ECHO_T}no" >&6
4464 fi
4465
4466     test -n "$FC" && break
4467   done
4468 fi
4469 if test -z "$FC"; then
4470   ac_ct_FC=$FC
4471   for ac_prog in gfortran
4472 do
4473   # Extract the first word of "$ac_prog", so it can be a program name with args.
4474 set dummy $ac_prog; ac_word=$2
4475 echo "$as_me:$LINENO: checking for $ac_word" >&5
4476 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4477 if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
4478   echo $ECHO_N "(cached) $ECHO_C" >&6
4479 else
4480   if test -n "$ac_ct_FC"; then
4481   ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
4482 else
4483 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4484 for as_dir in $PATH
4485 do
4486   IFS=$as_save_IFS
4487   test -z "$as_dir" && as_dir=.
4488   for ac_exec_ext in '' $ac_executable_extensions; do
4489   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4490     ac_cv_prog_ac_ct_FC="$ac_prog"
4491     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4492     break 2
4493   fi
4494 done
4495 done
4496
4497 fi
4498 fi
4499 ac_ct_FC=$ac_cv_prog_ac_ct_FC
4500 if test -n "$ac_ct_FC"; then
4501   echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
4502 echo "${ECHO_T}$ac_ct_FC" >&6
4503 else
4504   echo "$as_me:$LINENO: result: no" >&5
4505 echo "${ECHO_T}no" >&6
4506 fi
4507
4508   test -n "$ac_ct_FC" && break
4509 done
4510
4511   FC=$ac_ct_FC
4512 fi
4513
4514
4515 # Provide some information about the compiler.
4516 echo "$as_me:4516:" \
4517      "checking for Fortran compiler version" >&5
4518 ac_compiler=`set X $ac_compile; echo $2`
4519 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
4520   (eval $ac_compiler --version </dev/null >&5) 2>&5
4521   ac_status=$?
4522   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4523   (exit $ac_status); }
4524 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
4525   (eval $ac_compiler -v </dev/null >&5) 2>&5
4526   ac_status=$?
4527   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4528   (exit $ac_status); }
4529 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
4530   (eval $ac_compiler -V </dev/null >&5) 2>&5
4531   ac_status=$?
4532   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4533   (exit $ac_status); }
4534 rm -f a.out
4535
4536 # If we don't use `.F' as extension, the preprocessor is not run on the
4537 # input file.  (Note that this only needs to work for GNU compilers.)
4538 ac_save_ext=$ac_ext
4539 ac_ext=F
4540 echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
4541 echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
4542 if test "${ac_cv_fc_compiler_gnu+set}" = set; then
4543   echo $ECHO_N "(cached) $ECHO_C" >&6
4544 else
4545   cat >conftest.$ac_ext <<_ACEOF
4546       program main
4547 #ifndef __GNUC__
4548        choke me
4549 #endif
4550
4551       end
4552 _ACEOF
4553 rm -f conftest.$ac_objext
4554 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4555   (eval $ac_compile) 2>conftest.er1
4556   ac_status=$?
4557   grep -v '^ *+' conftest.er1 >conftest.err
4558   rm -f conftest.er1
4559   cat conftest.err >&5
4560   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4561   (exit $ac_status); } &&
4562          { ac_try='test -z "$ac_fc_werror_flag"
4563                          || test ! -s conftest.err'
4564   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4565   (eval $ac_try) 2>&5
4566   ac_status=$?
4567   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4568   (exit $ac_status); }; } &&
4569          { ac_try='test -s conftest.$ac_objext'
4570   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4571   (eval $ac_try) 2>&5
4572   ac_status=$?
4573   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4574   (exit $ac_status); }; }; then
4575   ac_compiler_gnu=yes
4576 else
4577   echo "$as_me: failed program was:" >&5
4578 sed 's/^/| /' conftest.$ac_ext >&5
4579
4580 ac_compiler_gnu=no
4581 fi
4582 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4583 ac_cv_fc_compiler_gnu=$ac_compiler_gnu
4584
4585 fi
4586 echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
4587 echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
4588 ac_ext=$ac_save_ext
4589 ac_test_FFLAGS=${FCFLAGS+set}
4590 ac_save_FFLAGS=$FCFLAGS
4591 FCFLAGS=
4592 echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
4593 echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
4594 if test "${ac_cv_prog_fc_g+set}" = set; then
4595   echo $ECHO_N "(cached) $ECHO_C" >&6
4596 else
4597   FCFLAGS=-g
4598 cat >conftest.$ac_ext <<_ACEOF
4599       program main
4600
4601       end
4602 _ACEOF
4603 rm -f conftest.$ac_objext
4604 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4605   (eval $ac_compile) 2>conftest.er1
4606   ac_status=$?
4607   grep -v '^ *+' conftest.er1 >conftest.err
4608   rm -f conftest.er1
4609   cat conftest.err >&5
4610   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4611   (exit $ac_status); } &&
4612          { ac_try='test -z "$ac_fc_werror_flag"
4613                          || test ! -s conftest.err'
4614   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4615   (eval $ac_try) 2>&5
4616   ac_status=$?
4617   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4618   (exit $ac_status); }; } &&
4619          { ac_try='test -s conftest.$ac_objext'
4620   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4621   (eval $ac_try) 2>&5
4622   ac_status=$?
4623   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4624   (exit $ac_status); }; }; then
4625   ac_cv_prog_fc_g=yes
4626 else
4627   echo "$as_me: failed program was:" >&5
4628 sed 's/^/| /' conftest.$ac_ext >&5
4629
4630 ac_cv_prog_fc_g=no
4631 fi
4632 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4633
4634 fi
4635 echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
4636 echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
4637 if test "$ac_test_FFLAGS" = set; then
4638   FCFLAGS=$ac_save_FFLAGS
4639 elif test $ac_cv_prog_fc_g = yes; then
4640   if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4641     FCFLAGS="-g -O2"
4642   else
4643     FCFLAGS="-g"
4644   fi
4645 else
4646   if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4647     FCFLAGS="-O2"
4648   else
4649     FCFLAGS=
4650   fi
4651 fi
4652
4653 ac_ext=c
4654 ac_cpp='$CPP $CPPFLAGS'
4655 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4656 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4657 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4658
4659 FCFLAGS="$FCFLAGS -Wall -fno-repack-arrays -fno-underscoring"
4660
4661 # extra LD Flags which are required for targets
4662 case "${host}" in
4663   *-darwin*)
4664     # Darwin needs -single_module when linking libgfortran
4665     extra_ldflags_libgfortran=-Wl,-single_module
4666     ;;
4667 esac
4668
4669
4670 # Check whether --enable-largefile or --disable-largefile was given.
4671 if test "${enable_largefile+set}" = set; then
4672   enableval="$enable_largefile"
4673
4674 fi;
4675 if test "$enable_largefile" != no; then
4676
4677   echo "$as_me:$LINENO: checking for special C compiler options needed for large files" >&5
4678 echo $ECHO_N "checking for special C compiler options needed for large files... $ECHO_C" >&6
4679 if test "${ac_cv_sys_largefile_CC+set}" = set; then
4680   echo $ECHO_N "(cached) $ECHO_C" >&6
4681 else
4682   ac_cv_sys_largefile_CC=no
4683      if test "$GCC" != yes; then
4684        ac_save_CC=$CC
4685        while :; do
4686          # IRIX 6.2 and later do not support large files by default,
4687          # so use the C compiler's -n32 option if that helps.
4688          cat >conftest.$ac_ext <<_ACEOF
4689 /* confdefs.h.  */
4690 _ACEOF
4691 cat confdefs.h >>conftest.$ac_ext
4692 cat >>conftest.$ac_ext <<_ACEOF
4693 /* end confdefs.h.  */
4694 #include <sys/types.h>
4695  /* Check that off_t can represent 2**63 - 1 correctly.
4696     We can't simply define LARGE_OFF_T to be 9223372036854775807,
4697     since some C++ compilers masquerading as C compilers
4698     incorrectly reject 9223372036854775807.  */
4699 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4700   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4701                        && LARGE_OFF_T % 2147483647 == 1)
4702                       ? 1 : -1];
4703 int
4704 main ()
4705 {
4706
4707   ;
4708   return 0;
4709 }
4710 _ACEOF
4711          rm -f conftest.$ac_objext
4712 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4713   (eval $ac_compile) 2>conftest.er1
4714   ac_status=$?
4715   grep -v '^ *+' conftest.er1 >conftest.err
4716   rm -f conftest.er1
4717   cat conftest.err >&5
4718   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4719   (exit $ac_status); } &&
4720          { ac_try='test -z "$ac_c_werror_flag"
4721                          || test ! -s conftest.err'
4722   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4723   (eval $ac_try) 2>&5
4724   ac_status=$?
4725   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4726   (exit $ac_status); }; } &&
4727          { ac_try='test -s conftest.$ac_objext'
4728   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4729   (eval $ac_try) 2>&5
4730   ac_status=$?
4731   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4732   (exit $ac_status); }; }; then
4733   break
4734 else
4735   echo "$as_me: failed program was:" >&5
4736 sed 's/^/| /' conftest.$ac_ext >&5
4737
4738 fi
4739 rm -f conftest.err conftest.$ac_objext
4740          CC="$CC -n32"
4741          rm -f conftest.$ac_objext
4742 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4743   (eval $ac_compile) 2>conftest.er1
4744   ac_status=$?
4745   grep -v '^ *+' conftest.er1 >conftest.err
4746   rm -f conftest.er1
4747   cat conftest.err >&5
4748   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4749   (exit $ac_status); } &&
4750          { ac_try='test -z "$ac_c_werror_flag"
4751                          || test ! -s conftest.err'
4752   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4753   (eval $ac_try) 2>&5
4754   ac_status=$?
4755   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4756   (exit $ac_status); }; } &&
4757          { ac_try='test -s conftest.$ac_objext'
4758   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4759   (eval $ac_try) 2>&5
4760   ac_status=$?
4761   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4762   (exit $ac_status); }; }; then
4763   ac_cv_sys_largefile_CC=' -n32'; break
4764 else
4765   echo "$as_me: failed program was:" >&5
4766 sed 's/^/| /' conftest.$ac_ext >&5
4767
4768 fi
4769 rm -f conftest.err conftest.$ac_objext
4770          break
4771        done
4772        CC=$ac_save_CC
4773        rm -f conftest.$ac_ext
4774     fi
4775 fi
4776 echo "$as_me:$LINENO: result: $ac_cv_sys_largefile_CC" >&5
4777 echo "${ECHO_T}$ac_cv_sys_largefile_CC" >&6
4778   if test "$ac_cv_sys_largefile_CC" != no; then
4779     CC=$CC$ac_cv_sys_largefile_CC
4780   fi
4781
4782   echo "$as_me:$LINENO: checking for _FILE_OFFSET_BITS value needed for large files" >&5
4783 echo $ECHO_N "checking for _FILE_OFFSET_BITS value needed for large files... $ECHO_C" >&6
4784 if test "${ac_cv_sys_file_offset_bits+set}" = set; then
4785   echo $ECHO_N "(cached) $ECHO_C" >&6
4786 else
4787   while :; do
4788   ac_cv_sys_file_offset_bits=no
4789   cat >conftest.$ac_ext <<_ACEOF
4790 /* confdefs.h.  */
4791 _ACEOF
4792 cat confdefs.h >>conftest.$ac_ext
4793 cat >>conftest.$ac_ext <<_ACEOF
4794 /* end confdefs.h.  */
4795 #include <sys/types.h>
4796  /* Check that off_t can represent 2**63 - 1 correctly.
4797     We can't simply define LARGE_OFF_T to be 9223372036854775807,
4798     since some C++ compilers masquerading as C compilers
4799     incorrectly reject 9223372036854775807.  */
4800 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4801   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4802                        && LARGE_OFF_T % 2147483647 == 1)
4803                       ? 1 : -1];
4804 int
4805 main ()
4806 {
4807
4808   ;
4809   return 0;
4810 }
4811 _ACEOF
4812 rm -f conftest.$ac_objext
4813 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4814   (eval $ac_compile) 2>conftest.er1
4815   ac_status=$?
4816   grep -v '^ *+' conftest.er1 >conftest.err
4817   rm -f conftest.er1
4818   cat conftest.err >&5
4819   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4820   (exit $ac_status); } &&
4821          { ac_try='test -z "$ac_c_werror_flag"
4822                          || test ! -s conftest.err'
4823   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4824   (eval $ac_try) 2>&5
4825   ac_status=$?
4826   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4827   (exit $ac_status); }; } &&
4828          { ac_try='test -s conftest.$ac_objext'
4829   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4830   (eval $ac_try) 2>&5
4831   ac_status=$?
4832   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4833   (exit $ac_status); }; }; then
4834   break
4835 else
4836   echo "$as_me: failed program was:" >&5
4837 sed 's/^/| /' conftest.$ac_ext >&5
4838
4839 fi
4840 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4841   cat >conftest.$ac_ext <<_ACEOF
4842 /* confdefs.h.  */
4843 _ACEOF
4844 cat confdefs.h >>conftest.$ac_ext
4845 cat >>conftest.$ac_ext <<_ACEOF
4846 /* end confdefs.h.  */
4847 #define _FILE_OFFSET_BITS 64
4848 #include <sys/types.h>
4849  /* Check that off_t can represent 2**63 - 1 correctly.
4850     We can't simply define LARGE_OFF_T to be 9223372036854775807,
4851     since some C++ compilers masquerading as C compilers
4852     incorrectly reject 9223372036854775807.  */
4853 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4854   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4855                        && LARGE_OFF_T % 2147483647 == 1)
4856                       ? 1 : -1];
4857 int
4858 main ()
4859 {
4860
4861   ;
4862   return 0;
4863 }
4864 _ACEOF
4865 rm -f conftest.$ac_objext
4866 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4867   (eval $ac_compile) 2>conftest.er1
4868   ac_status=$?
4869   grep -v '^ *+' conftest.er1 >conftest.err
4870   rm -f conftest.er1
4871   cat conftest.err >&5
4872   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4873   (exit $ac_status); } &&
4874          { ac_try='test -z "$ac_c_werror_flag"
4875                          || test ! -s conftest.err'
4876   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4877   (eval $ac_try) 2>&5
4878   ac_status=$?
4879   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4880   (exit $ac_status); }; } &&
4881          { ac_try='test -s conftest.$ac_objext'
4882   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4883   (eval $ac_try) 2>&5
4884   ac_status=$?
4885   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4886   (exit $ac_status); }; }; then
4887   ac_cv_sys_file_offset_bits=64; break
4888 else
4889   echo "$as_me: failed program was:" >&5
4890 sed 's/^/| /' conftest.$ac_ext >&5
4891
4892 fi
4893 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4894   break
4895 done
4896 fi
4897 echo "$as_me:$LINENO: result: $ac_cv_sys_file_offset_bits" >&5
4898 echo "${ECHO_T}$ac_cv_sys_file_offset_bits" >&6
4899 if test "$ac_cv_sys_file_offset_bits" != no; then
4900
4901 cat >>confdefs.h <<_ACEOF
4902 #define _FILE_OFFSET_BITS $ac_cv_sys_file_offset_bits
4903 _ACEOF
4904
4905 fi
4906 rm -f conftest*
4907   echo "$as_me:$LINENO: checking for _LARGE_FILES value needed for large files" >&5
4908 echo $ECHO_N "checking for _LARGE_FILES value needed for large files... $ECHO_C" >&6
4909 if test "${ac_cv_sys_large_files+set}" = set; then
4910   echo $ECHO_N "(cached) $ECHO_C" >&6
4911 else
4912   while :; do
4913   ac_cv_sys_large_files=no
4914   cat >conftest.$ac_ext <<_ACEOF
4915 /* confdefs.h.  */
4916 _ACEOF
4917 cat confdefs.h >>conftest.$ac_ext
4918 cat >>conftest.$ac_ext <<_ACEOF
4919 /* end confdefs.h.  */
4920 #include <sys/types.h>
4921  /* Check that off_t can represent 2**63 - 1 correctly.
4922     We can't simply define LARGE_OFF_T to be 9223372036854775807,
4923     since some C++ compilers masquerading as C compilers
4924     incorrectly reject 9223372036854775807.  */
4925 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4926   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4927                        && LARGE_OFF_T % 2147483647 == 1)
4928                       ? 1 : -1];
4929 int
4930 main ()
4931 {
4932
4933   ;
4934   return 0;
4935 }
4936 _ACEOF
4937 rm -f conftest.$ac_objext
4938 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4939   (eval $ac_compile) 2>conftest.er1
4940   ac_status=$?
4941   grep -v '^ *+' conftest.er1 >conftest.err
4942   rm -f conftest.er1
4943   cat conftest.err >&5
4944   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4945   (exit $ac_status); } &&
4946          { ac_try='test -z "$ac_c_werror_flag"
4947                          || test ! -s conftest.err'
4948   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4949   (eval $ac_try) 2>&5
4950   ac_status=$?
4951   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4952   (exit $ac_status); }; } &&
4953          { ac_try='test -s conftest.$ac_objext'
4954   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4955   (eval $ac_try) 2>&5
4956   ac_status=$?
4957   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4958   (exit $ac_status); }; }; then
4959   break
4960 else
4961   echo "$as_me: failed program was:" >&5
4962 sed 's/^/| /' conftest.$ac_ext >&5
4963
4964 fi
4965 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4966   cat >conftest.$ac_ext <<_ACEOF
4967 /* confdefs.h.  */
4968 _ACEOF
4969 cat confdefs.h >>conftest.$ac_ext
4970 cat >>conftest.$ac_ext <<_ACEOF
4971 /* end confdefs.h.  */
4972 #define _LARGE_FILES 1
4973 #include <sys/types.h>
4974  /* Check that off_t can represent 2**63 - 1 correctly.
4975     We can't simply define LARGE_OFF_T to be 9223372036854775807,
4976     since some C++ compilers masquerading as C compilers
4977     incorrectly reject 9223372036854775807.  */
4978 #define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
4979   int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
4980                        && LARGE_OFF_T % 2147483647 == 1)
4981                       ? 1 : -1];
4982 int
4983 main ()
4984 {
4985
4986   ;
4987   return 0;
4988 }
4989 _ACEOF
4990 rm -f conftest.$ac_objext
4991 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4992   (eval $ac_compile) 2>conftest.er1
4993   ac_status=$?
4994   grep -v '^ *+' conftest.er1 >conftest.err
4995   rm -f conftest.er1
4996   cat conftest.err >&5
4997   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4998   (exit $ac_status); } &&
4999          { ac_try='test -z "$ac_c_werror_flag"
5000                          || test ! -s conftest.err'
5001   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5002   (eval $ac_try) 2>&5
5003   ac_status=$?
5004   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5005   (exit $ac_status); }; } &&
5006          { ac_try='test -s conftest.$ac_objext'
5007   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5008   (eval $ac_try) 2>&5
5009   ac_status=$?
5010   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5011   (exit $ac_status); }; }; then
5012   ac_cv_sys_large_files=1; break
5013 else
5014   echo "$as_me: failed program was:" >&5
5015 sed 's/^/| /' conftest.$ac_ext >&5
5016
5017 fi
5018 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5019   break
5020 done
5021 fi
5022 echo "$as_me:$LINENO: result: $ac_cv_sys_large_files" >&5
5023 echo "${ECHO_T}$ac_cv_sys_large_files" >&6
5024 if test "$ac_cv_sys_large_files" != no; then
5025
5026 cat >>confdefs.h <<_ACEOF
5027 #define _LARGE_FILES $ac_cv_sys_large_files
5028 _ACEOF
5029
5030 fi
5031 rm -f conftest*
5032 fi
5033
5034 if test x$gcc_no_link = xyes; then
5035   if test "x${ac_cv_func_mmap_fixed_mapped+set}" != xset; then
5036     ac_cv_func_mmap_fixed_mapped=no
5037   fi
5038 fi
5039 if test "x${ac_cv_func_mmap_fixed_mapped}" != xno; then
5040   ac_ext=c
5041 ac_cpp='$CPP $CPPFLAGS'
5042 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5043 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5044 ac_compiler_gnu=$ac_cv_c_compiler_gnu
5045 echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
5046 echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
5047 # On Suns, sometimes $CPP names a directory.
5048 if test -n "$CPP" && test -d "$CPP"; then
5049   CPP=
5050 fi
5051 if test -z "$CPP"; then
5052   if test "${ac_cv_prog_CPP+set}" = set; then
5053   echo $ECHO_N "(cached) $ECHO_C" >&6
5054 else
5055       # Double quotes because CPP needs to be expanded
5056     for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
5057     do
5058       ac_preproc_ok=false
5059 for ac_c_preproc_warn_flag in '' yes
5060 do
5061   # Use a header file that comes with gcc, so configuring glibc
5062   # with a fresh cross-compiler works.
5063   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5064   # <limits.h> exists even on freestanding compilers.
5065   # On the NeXT, cc -E runs the code through the compiler's parser,
5066   # not just through cpp. "Syntax error" is here to catch this case.
5067   cat >conftest.$ac_ext <<_ACEOF
5068 /* confdefs.h.  */
5069 _ACEOF
5070 cat confdefs.h >>conftest.$ac_ext
5071 cat >>conftest.$ac_ext <<_ACEOF
5072 /* end confdefs.h.  */
5073 #ifdef __STDC__
5074 # include <limits.h>
5075 #else
5076 # include <assert.h>
5077 #endif
5078                      Syntax error
5079 _ACEOF
5080 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5081   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5082   ac_status=$?
5083   grep -v '^ *+' conftest.er1 >conftest.err
5084   rm -f conftest.er1
5085   cat conftest.err >&5
5086   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5087   (exit $ac_status); } >/dev/null; then
5088   if test -s conftest.err; then
5089     ac_cpp_err=$ac_c_preproc_warn_flag
5090     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5091   else
5092     ac_cpp_err=
5093   fi
5094 else
5095   ac_cpp_err=yes
5096 fi
5097 if test -z "$ac_cpp_err"; then
5098   :
5099 else
5100   echo "$as_me: failed program was:" >&5
5101 sed 's/^/| /' conftest.$ac_ext >&5
5102
5103   # Broken: fails on valid input.
5104 continue
5105 fi
5106 rm -f conftest.err conftest.$ac_ext
5107
5108   # OK, works on sane cases.  Now check whether non-existent headers
5109   # can be detected and how.
5110   cat >conftest.$ac_ext <<_ACEOF
5111 /* confdefs.h.  */
5112 _ACEOF
5113 cat confdefs.h >>conftest.$ac_ext
5114 cat >>conftest.$ac_ext <<_ACEOF
5115 /* end confdefs.h.  */
5116 #include <ac_nonexistent.h>
5117 _ACEOF
5118 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5119   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5120   ac_status=$?
5121   grep -v '^ *+' conftest.er1 >conftest.err
5122   rm -f conftest.er1
5123   cat conftest.err >&5
5124   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5125   (exit $ac_status); } >/dev/null; then
5126   if test -s conftest.err; then
5127     ac_cpp_err=$ac_c_preproc_warn_flag
5128     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5129   else
5130     ac_cpp_err=
5131   fi
5132 else
5133   ac_cpp_err=yes
5134 fi
5135 if test -z "$ac_cpp_err"; then
5136   # Broken: success on invalid input.
5137 continue
5138 else
5139   echo "$as_me: failed program was:" >&5
5140 sed 's/^/| /' conftest.$ac_ext >&5
5141
5142   # Passes both tests.
5143 ac_preproc_ok=:
5144 break
5145 fi
5146 rm -f conftest.err conftest.$ac_ext
5147
5148 done
5149 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5150 rm -f conftest.err conftest.$ac_ext
5151 if $ac_preproc_ok; then
5152   break
5153 fi
5154
5155     done
5156     ac_cv_prog_CPP=$CPP
5157
5158 fi
5159   CPP=$ac_cv_prog_CPP
5160 else
5161   ac_cv_prog_CPP=$CPP
5162 fi
5163 echo "$as_me:$LINENO: result: $CPP" >&5
5164 echo "${ECHO_T}$CPP" >&6
5165 ac_preproc_ok=false
5166 for ac_c_preproc_warn_flag in '' yes
5167 do
5168   # Use a header file that comes with gcc, so configuring glibc
5169   # with a fresh cross-compiler works.
5170   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5171   # <limits.h> exists even on freestanding compilers.
5172   # On the NeXT, cc -E runs the code through the compiler's parser,
5173   # not just through cpp. "Syntax error" is here to catch this case.
5174   cat >conftest.$ac_ext <<_ACEOF
5175 /* confdefs.h.  */
5176 _ACEOF
5177 cat confdefs.h >>conftest.$ac_ext
5178 cat >>conftest.$ac_ext <<_ACEOF
5179 /* end confdefs.h.  */
5180 #ifdef __STDC__
5181 # include <limits.h>
5182 #else
5183 # include <assert.h>
5184 #endif
5185                      Syntax error
5186 _ACEOF
5187 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5188   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5189   ac_status=$?
5190   grep -v '^ *+' conftest.er1 >conftest.err
5191   rm -f conftest.er1
5192   cat conftest.err >&5
5193   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5194   (exit $ac_status); } >/dev/null; then
5195   if test -s conftest.err; then
5196     ac_cpp_err=$ac_c_preproc_warn_flag
5197     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5198   else
5199     ac_cpp_err=
5200   fi
5201 else
5202   ac_cpp_err=yes
5203 fi
5204 if test -z "$ac_cpp_err"; then
5205   :
5206 else
5207   echo "$as_me: failed program was:" >&5
5208 sed 's/^/| /' conftest.$ac_ext >&5
5209
5210   # Broken: fails on valid input.
5211 continue
5212 fi
5213 rm -f conftest.err conftest.$ac_ext
5214
5215   # OK, works on sane cases.  Now check whether non-existent headers
5216   # can be detected and how.
5217   cat >conftest.$ac_ext <<_ACEOF
5218 /* confdefs.h.  */
5219 _ACEOF
5220 cat confdefs.h >>conftest.$ac_ext
5221 cat >>conftest.$ac_ext <<_ACEOF
5222 /* end confdefs.h.  */
5223 #include <ac_nonexistent.h>
5224 _ACEOF
5225 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5226   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5227   ac_status=$?
5228   grep -v '^ *+' conftest.er1 >conftest.err
5229   rm -f conftest.er1
5230   cat conftest.err >&5
5231   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5232   (exit $ac_status); } >/dev/null; then
5233   if test -s conftest.err; then
5234     ac_cpp_err=$ac_c_preproc_warn_flag
5235     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5236   else
5237     ac_cpp_err=
5238   fi
5239 else
5240   ac_cpp_err=yes
5241 fi
5242 if test -z "$ac_cpp_err"; then
5243   # Broken: success on invalid input.
5244 continue
5245 else
5246   echo "$as_me: failed program was:" >&5
5247 sed 's/^/| /' conftest.$ac_ext >&5
5248
5249   # Passes both tests.
5250 ac_preproc_ok=:
5251 break
5252 fi
5253 rm -f conftest.err conftest.$ac_ext
5254
5255 done
5256 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5257 rm -f conftest.err conftest.$ac_ext
5258 if $ac_preproc_ok; then
5259   :
5260 else
5261   { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
5262 See \`config.log' for more details." >&5
5263 echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
5264 See \`config.log' for more details." >&2;}
5265    { (exit 1); exit 1; }; }
5266 fi
5267
5268 ac_ext=c
5269 ac_cpp='$CPP $CPPFLAGS'
5270 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5271 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5272 ac_compiler_gnu=$ac_cv_c_compiler_gnu
5273
5274
5275 echo "$as_me:$LINENO: checking for egrep" >&5
5276 echo $ECHO_N "checking for egrep... $ECHO_C" >&6
5277 if test "${ac_cv_prog_egrep+set}" = set; then
5278   echo $ECHO_N "(cached) $ECHO_C" >&6
5279 else
5280   if echo a | (grep -E '(a|b)') >/dev/null 2>&1
5281     then ac_cv_prog_egrep='grep -E'
5282     else ac_cv_prog_egrep='egrep'
5283     fi
5284 fi
5285 echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
5286 echo "${ECHO_T}$ac_cv_prog_egrep" >&6
5287  EGREP=$ac_cv_prog_egrep
5288
5289
5290 echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5291 echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5292 if test "${ac_cv_header_stdc+set}" = set; then
5293   echo $ECHO_N "(cached) $ECHO_C" >&6
5294 else
5295   cat >conftest.$ac_ext <<_ACEOF
5296 /* confdefs.h.  */
5297 _ACEOF
5298 cat confdefs.h >>conftest.$ac_ext
5299 cat >>conftest.$ac_ext <<_ACEOF
5300 /* end confdefs.h.  */
5301 #include <stdlib.h>
5302 #include <stdarg.h>
5303 #include <string.h>
5304 #include <float.h>
5305
5306 int
5307 main ()
5308 {
5309
5310   ;
5311   return 0;
5312 }
5313 _ACEOF
5314 rm -f conftest.$ac_objext
5315 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5316   (eval $ac_compile) 2>conftest.er1
5317   ac_status=$?
5318   grep -v '^ *+' conftest.er1 >conftest.err
5319   rm -f conftest.er1
5320   cat conftest.err >&5
5321   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5322   (exit $ac_status); } &&
5323          { ac_try='test -z "$ac_c_werror_flag"
5324                          || test ! -s conftest.err'
5325   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5326   (eval $ac_try) 2>&5
5327   ac_status=$?
5328   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5329   (exit $ac_status); }; } &&
5330          { ac_try='test -s conftest.$ac_objext'
5331   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5332   (eval $ac_try) 2>&5
5333   ac_status=$?
5334   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5335   (exit $ac_status); }; }; then
5336   ac_cv_header_stdc=yes
5337 else
5338   echo "$as_me: failed program was:" >&5
5339 sed 's/^/| /' conftest.$ac_ext >&5
5340
5341 ac_cv_header_stdc=no
5342 fi
5343 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5344
5345 if test $ac_cv_header_stdc = yes; then
5346   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5347   cat >conftest.$ac_ext <<_ACEOF
5348 /* confdefs.h.  */
5349 _ACEOF
5350 cat confdefs.h >>conftest.$ac_ext
5351 cat >>conftest.$ac_ext <<_ACEOF
5352 /* end confdefs.h.  */
5353 #include <string.h>
5354
5355 _ACEOF
5356 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5357   $EGREP "memchr" >/dev/null 2>&1; then
5358   :
5359 else
5360   ac_cv_header_stdc=no
5361 fi
5362 rm -f conftest*
5363
5364 fi
5365
5366 if test $ac_cv_header_stdc = yes; then
5367   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5368   cat >conftest.$ac_ext <<_ACEOF
5369 /* confdefs.h.  */
5370 _ACEOF
5371 cat confdefs.h >>conftest.$ac_ext
5372 cat >>conftest.$ac_ext <<_ACEOF
5373 /* end confdefs.h.  */
5374 #include <stdlib.h>
5375
5376 _ACEOF
5377 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5378   $EGREP "free" >/dev/null 2>&1; then
5379   :
5380 else
5381   ac_cv_header_stdc=no
5382 fi
5383 rm -f conftest*
5384
5385 fi
5386
5387 if test $ac_cv_header_stdc = yes; then
5388   # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5389   if test "$cross_compiling" = yes; then
5390   :
5391 else
5392   cat >conftest.$ac_ext <<_ACEOF
5393 /* confdefs.h.  */
5394 _ACEOF
5395 cat confdefs.h >>conftest.$ac_ext
5396 cat >>conftest.$ac_ext <<_ACEOF
5397 /* end confdefs.h.  */
5398 #include <ctype.h>
5399 #if ((' ' & 0x0FF) == 0x020)
5400 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5401 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5402 #else
5403 # define ISLOWER(c) \
5404                    (('a' <= (c) && (c) <= 'i') \
5405                      || ('j' <= (c) && (c) <= 'r') \
5406                      || ('s' <= (c) && (c) <= 'z'))
5407 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5408 #endif
5409
5410 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5411 int
5412 main ()
5413 {
5414   int i;
5415   for (i = 0; i < 256; i++)
5416     if (XOR (islower (i), ISLOWER (i))
5417         || toupper (i) != TOUPPER (i))
5418       exit(2);
5419   exit (0);
5420 }
5421 _ACEOF
5422 rm -f conftest$ac_exeext
5423 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5424   (eval $ac_link) 2>&5
5425   ac_status=$?
5426   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5427   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5428   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5429   (eval $ac_try) 2>&5
5430   ac_status=$?
5431   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5432   (exit $ac_status); }; }; then
5433   :
5434 else
5435   echo "$as_me: program exited with status $ac_status" >&5
5436 echo "$as_me: failed program was:" >&5
5437 sed 's/^/| /' conftest.$ac_ext >&5
5438
5439 ( exit $ac_status )
5440 ac_cv_header_stdc=no
5441 fi
5442 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5443 fi
5444 fi
5445 fi
5446 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5447 echo "${ECHO_T}$ac_cv_header_stdc" >&6
5448 if test $ac_cv_header_stdc = yes; then
5449
5450 cat >>confdefs.h <<\_ACEOF
5451 #define STDC_HEADERS 1
5452 _ACEOF
5453
5454 fi
5455
5456 # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5457
5458
5459
5460
5461
5462
5463
5464
5465
5466 for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5467                   inttypes.h stdint.h unistd.h
5468 do
5469 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5470 echo "$as_me:$LINENO: checking for $ac_header" >&5
5471 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5472 if eval "test \"\${$as_ac_Header+set}\" = set"; then
5473   echo $ECHO_N "(cached) $ECHO_C" >&6
5474 else
5475   cat >conftest.$ac_ext <<_ACEOF
5476 /* confdefs.h.  */
5477 _ACEOF
5478 cat confdefs.h >>conftest.$ac_ext
5479 cat >>conftest.$ac_ext <<_ACEOF
5480 /* end confdefs.h.  */
5481 $ac_includes_default
5482
5483 #include <$ac_header>
5484 _ACEOF
5485 rm -f conftest.$ac_objext
5486 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5487   (eval $ac_compile) 2>conftest.er1
5488   ac_status=$?
5489   grep -v '^ *+' conftest.er1 >conftest.err
5490   rm -f conftest.er1
5491   cat conftest.err >&5
5492   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5493   (exit $ac_status); } &&
5494          { ac_try='test -z "$ac_c_werror_flag"
5495                          || test ! -s conftest.err'
5496   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5497   (eval $ac_try) 2>&5
5498   ac_status=$?
5499   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5500   (exit $ac_status); }; } &&
5501          { ac_try='test -s conftest.$ac_objext'
5502   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5503   (eval $ac_try) 2>&5
5504   ac_status=$?
5505   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5506   (exit $ac_status); }; }; then
5507   eval "$as_ac_Header=yes"
5508 else
5509   echo "$as_me: failed program was:" >&5
5510 sed 's/^/| /' conftest.$ac_ext >&5
5511
5512 eval "$as_ac_Header=no"
5513 fi
5514 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5515 fi
5516 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5517 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5518 if test `eval echo '${'$as_ac_Header'}'` = yes; then
5519   cat >>confdefs.h <<_ACEOF
5520 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5521 _ACEOF
5522
5523 fi
5524
5525 done
5526
5527
5528
5529
5530 for ac_header in stdlib.h unistd.h
5531 do
5532 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5533 if eval "test \"\${$as_ac_Header+set}\" = set"; then
5534   echo "$as_me:$LINENO: checking for $ac_header" >&5
5535 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5536 if eval "test \"\${$as_ac_Header+set}\" = set"; then
5537   echo $ECHO_N "(cached) $ECHO_C" >&6
5538 fi
5539 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5540 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5541 else
5542   # Is the header compilable?
5543 echo "$as_me:$LINENO: checking $ac_header usability" >&5
5544 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
5545 cat >conftest.$ac_ext <<_ACEOF
5546 /* confdefs.h.  */
5547 _ACEOF
5548 cat confdefs.h >>conftest.$ac_ext
5549 cat >>conftest.$ac_ext <<_ACEOF
5550 /* end confdefs.h.  */
5551 $ac_includes_default
5552 #include <$ac_header>
5553 _ACEOF
5554 rm -f conftest.$ac_objext
5555 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5556   (eval $ac_compile) 2>conftest.er1
5557   ac_status=$?
5558   grep -v '^ *+' conftest.er1 >conftest.err
5559   rm -f conftest.er1
5560   cat conftest.err >&5
5561   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5562   (exit $ac_status); } &&
5563          { ac_try='test -z "$ac_c_werror_flag"
5564                          || test ! -s conftest.err'
5565   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5566   (eval $ac_try) 2>&5
5567   ac_status=$?
5568   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5569   (exit $ac_status); }; } &&
5570          { ac_try='test -s conftest.$ac_objext'
5571   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5572   (eval $ac_try) 2>&5
5573   ac_status=$?
5574   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5575   (exit $ac_status); }; }; then
5576   ac_header_compiler=yes
5577 else
5578   echo "$as_me: failed program was:" >&5
5579 sed 's/^/| /' conftest.$ac_ext >&5
5580
5581 ac_header_compiler=no
5582 fi
5583 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5584 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5585 echo "${ECHO_T}$ac_header_compiler" >&6
5586
5587 # Is the header present?
5588 echo "$as_me:$LINENO: checking $ac_header presence" >&5
5589 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
5590 cat >conftest.$ac_ext <<_ACEOF
5591 /* confdefs.h.  */
5592 _ACEOF
5593 cat confdefs.h >>conftest.$ac_ext
5594 cat >>conftest.$ac_ext <<_ACEOF
5595 /* end confdefs.h.  */
5596 #include <$ac_header>
5597 _ACEOF
5598 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5599   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5600   ac_status=$?
5601   grep -v '^ *+' conftest.er1 >conftest.err
5602   rm -f conftest.er1
5603   cat conftest.err >&5
5604   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5605   (exit $ac_status); } >/dev/null; then
5606   if test -s conftest.err; then
5607     ac_cpp_err=$ac_c_preproc_warn_flag
5608     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5609   else
5610     ac_cpp_err=
5611   fi
5612 else
5613   ac_cpp_err=yes
5614 fi
5615 if test -z "$ac_cpp_err"; then
5616   ac_header_preproc=yes
5617 else
5618   echo "$as_me: failed program was:" >&5
5619 sed 's/^/| /' conftest.$ac_ext >&5
5620
5621   ac_header_preproc=no
5622 fi
5623 rm -f conftest.err conftest.$ac_ext
5624 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5625 echo "${ECHO_T}$ac_header_preproc" >&6
5626
5627 # So?  What about this header?
5628 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5629   yes:no: )
5630     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
5631 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
5632     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
5633 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
5634     ac_header_preproc=yes
5635     ;;
5636   no:yes:* )
5637     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
5638 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
5639     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
5640 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
5641     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
5642 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
5643     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
5644 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
5645     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
5646 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
5647     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
5648 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
5649     (
5650       cat <<\_ASBOX
5651 ## ------------------------------------------------------ ##
5652 ## Report this to the GNU Fortran Runtime Library lists.  ##
5653 ## ------------------------------------------------------ ##
5654 _ASBOX
5655     ) |
5656       sed "s/^/$as_me: WARNING:     /" >&2
5657     ;;
5658 esac
5659 echo "$as_me:$LINENO: checking for $ac_header" >&5
5660 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5661 if eval "test \"\${$as_ac_Header+set}\" = set"; then
5662   echo $ECHO_N "(cached) $ECHO_C" >&6
5663 else
5664   eval "$as_ac_Header=\$ac_header_preproc"
5665 fi
5666 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5667 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5668
5669 fi
5670 if test `eval echo '${'$as_ac_Header'}'` = yes; then
5671   cat >>confdefs.h <<_ACEOF
5672 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5673 _ACEOF
5674
5675 fi
5676
5677 done
5678
5679
5680 for ac_func in getpagesize
5681 do
5682 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
5683 echo "$as_me:$LINENO: checking for $ac_func" >&5
5684 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
5685 if eval "test \"\${$as_ac_var+set}\" = set"; then
5686   echo $ECHO_N "(cached) $ECHO_C" >&6
5687 else
5688   if test x$gcc_no_link = xyes; then
5689   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
5690 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
5691    { (exit 1); exit 1; }; }
5692 fi
5693 cat >conftest.$ac_ext <<_ACEOF
5694 /* confdefs.h.  */
5695 _ACEOF
5696 cat confdefs.h >>conftest.$ac_ext
5697 cat >>conftest.$ac_ext <<_ACEOF
5698 /* end confdefs.h.  */
5699 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
5700    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
5701 #define $ac_func innocuous_$ac_func
5702
5703 /* System header to define __stub macros and hopefully few prototypes,
5704     which can conflict with char $ac_func (); below.
5705     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5706     <limits.h> exists even on freestanding compilers.  */
5707
5708 #ifdef __STDC__
5709 # include <limits.h>
5710 #else
5711 # include <assert.h>
5712 #endif
5713
5714 #undef $ac_func
5715
5716 /* Override any gcc2 internal prototype to avoid an error.  */
5717 #ifdef __cplusplus
5718 extern "C"
5719 {
5720 #endif
5721 /* We use char because int might match the return type of a gcc2
5722    builtin and then its argument prototype would still apply.  */
5723 char $ac_func ();
5724 /* The GNU C library defines this for functions which it implements
5725     to always fail with ENOSYS.  Some functions are actually named
5726     something starting with __ and the normal name is an alias.  */
5727 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5728 choke me
5729 #else
5730 char (*f) () = $ac_func;
5731 #endif
5732 #ifdef __cplusplus
5733 }
5734 #endif
5735
5736 int
5737 main ()
5738 {
5739 return f != $ac_func;
5740   ;
5741   return 0;
5742 }
5743 _ACEOF
5744 rm -f conftest.$ac_objext conftest$ac_exeext
5745 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5746   (eval $ac_link) 2>conftest.er1
5747   ac_status=$?
5748   grep -v '^ *+' conftest.er1 >conftest.err
5749   rm -f conftest.er1
5750   cat conftest.err >&5
5751   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5752   (exit $ac_status); } &&
5753          { ac_try='test -z "$ac_c_werror_flag"
5754                          || test ! -s conftest.err'
5755   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5756   (eval $ac_try) 2>&5
5757   ac_status=$?
5758   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5759   (exit $ac_status); }; } &&
5760          { ac_try='test -s conftest$ac_exeext'
5761   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5762   (eval $ac_try) 2>&5
5763   ac_status=$?
5764   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5765   (exit $ac_status); }; }; then
5766   eval "$as_ac_var=yes"
5767 else
5768   echo "$as_me: failed program was:" >&5
5769 sed 's/^/| /' conftest.$ac_ext >&5
5770
5771 eval "$as_ac_var=no"
5772 fi
5773 rm -f conftest.err conftest.$ac_objext \
5774       conftest$ac_exeext conftest.$ac_ext
5775 fi
5776 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
5777 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
5778 if test `eval echo '${'$as_ac_var'}'` = yes; then
5779   cat >>confdefs.h <<_ACEOF
5780 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
5781 _ACEOF
5782
5783 fi
5784 done
5785
5786 echo "$as_me:$LINENO: checking for working mmap" >&5
5787 echo $ECHO_N "checking for working mmap... $ECHO_C" >&6
5788 if test "${ac_cv_func_mmap_fixed_mapped+set}" = set; then
5789   echo $ECHO_N "(cached) $ECHO_C" >&6
5790 else
5791   if test "$cross_compiling" = yes; then
5792   ac_cv_func_mmap_fixed_mapped=no
5793 else
5794   cat >conftest.$ac_ext <<_ACEOF
5795 /* confdefs.h.  */
5796 _ACEOF
5797 cat confdefs.h >>conftest.$ac_ext
5798 cat >>conftest.$ac_ext <<_ACEOF
5799 /* end confdefs.h.  */
5800 $ac_includes_default
5801 /* malloc might have been renamed as rpl_malloc. */
5802 #undef malloc
5803
5804 /* Thanks to Mike Haertel and Jim Avera for this test.
5805    Here is a matrix of mmap possibilities:
5806         mmap private not fixed
5807         mmap private fixed at somewhere currently unmapped
5808         mmap private fixed at somewhere already mapped
5809         mmap shared not fixed
5810         mmap shared fixed at somewhere currently unmapped
5811         mmap shared fixed at somewhere already mapped
5812    For private mappings, we should verify that changes cannot be read()
5813    back from the file, nor mmap's back from the file at a different
5814    address.  (There have been systems where private was not correctly
5815    implemented like the infamous i386 svr4.0, and systems where the
5816    VM page cache was not coherent with the file system buffer cache
5817    like early versions of FreeBSD and possibly contemporary NetBSD.)
5818    For shared mappings, we should conversely verify that changes get
5819    propagated back to all the places they're supposed to be.
5820
5821    Grep wants private fixed already mapped.
5822    The main things grep needs to know about mmap are:
5823    * does it exist and is it safe to write into the mmap'd area
5824    * how to use it (BSD variants)  */
5825
5826 #include <fcntl.h>
5827 #include <sys/mman.h>
5828
5829 #if !STDC_HEADERS && !HAVE_STDLIB_H
5830 char *malloc ();
5831 #endif
5832
5833 /* This mess was copied from the GNU getpagesize.h.  */
5834 #if !HAVE_GETPAGESIZE
5835 /* Assume that all systems that can run configure have sys/param.h.  */
5836 # if !HAVE_SYS_PARAM_H
5837 #  define HAVE_SYS_PARAM_H 1
5838 # endif
5839
5840 # ifdef _SC_PAGESIZE
5841 #  define getpagesize() sysconf(_SC_PAGESIZE)
5842 # else /* no _SC_PAGESIZE */
5843 #  if HAVE_SYS_PARAM_H
5844 #   include <sys/param.h>
5845 #   ifdef EXEC_PAGESIZE
5846 #    define getpagesize() EXEC_PAGESIZE
5847 #   else /* no EXEC_PAGESIZE */
5848 #    ifdef NBPG
5849 #     define getpagesize() NBPG * CLSIZE
5850 #     ifndef CLSIZE
5851 #      define CLSIZE 1
5852 #     endif /* no CLSIZE */
5853 #    else /* no NBPG */
5854 #     ifdef NBPC
5855 #      define getpagesize() NBPC
5856 #     else /* no NBPC */
5857 #      ifdef PAGESIZE
5858 #       define getpagesize() PAGESIZE
5859 #      endif /* PAGESIZE */
5860 #     endif /* no NBPC */
5861 #    endif /* no NBPG */
5862 #   endif /* no EXEC_PAGESIZE */
5863 #  else /* no HAVE_SYS_PARAM_H */
5864 #   define getpagesize() 8192   /* punt totally */
5865 #  endif /* no HAVE_SYS_PARAM_H */
5866 # endif /* no _SC_PAGESIZE */
5867
5868 #endif /* no HAVE_GETPAGESIZE */
5869
5870 int
5871 main ()
5872 {
5873   char *data, *data2, *data3;
5874   int i, pagesize;
5875   int fd;
5876
5877   pagesize = getpagesize ();
5878
5879   /* First, make a file with some known garbage in it. */
5880   data = (char *) malloc (pagesize);
5881   if (!data)
5882     exit (1);
5883   for (i = 0; i < pagesize; ++i)
5884     *(data + i) = rand ();
5885   umask (0);
5886   fd = creat ("conftest.mmap", 0600);
5887   if (fd < 0)
5888     exit (1);
5889   if (write (fd, data, pagesize) != pagesize)
5890     exit (1);
5891   close (fd);
5892
5893   /* Next, try to mmap the file at a fixed address which already has
5894      something else allocated at it.  If we can, also make sure that
5895      we see the same garbage.  */
5896   fd = open ("conftest.mmap", O_RDWR);
5897   if (fd < 0)
5898     exit (1);
5899   data2 = (char *) malloc (2 * pagesize);
5900   if (!data2)
5901     exit (1);
5902   data2 += (pagesize - ((long) data2 & (pagesize - 1))) & (pagesize - 1);
5903   if (data2 != mmap (data2, pagesize, PROT_READ | PROT_WRITE,
5904                      MAP_PRIVATE | MAP_FIXED, fd, 0L))
5905     exit (1);
5906   for (i = 0; i < pagesize; ++i)
5907     if (*(data + i) != *(data2 + i))
5908       exit (1);
5909
5910   /* Finally, make sure that changes to the mapped area do not
5911      percolate back to the file as seen by read().  (This is a bug on
5912      some variants of i386 svr4.0.)  */
5913   for (i = 0; i < pagesize; ++i)
5914     *(data2 + i) = *(data2 + i) + 1;
5915   data3 = (char *) malloc (pagesize);
5916   if (!data3)
5917     exit (1);
5918   if (read (fd, data3, pagesize) != pagesize)
5919     exit (1);
5920   for (i = 0; i < pagesize; ++i)
5921     if (*(data + i) != *(data3 + i))
5922       exit (1);
5923   close (fd);
5924   exit (0);
5925 }
5926 _ACEOF
5927 rm -f conftest$ac_exeext
5928 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5929   (eval $ac_link) 2>&5
5930   ac_status=$?
5931   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5932   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5933   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5934   (eval $ac_try) 2>&5
5935   ac_status=$?
5936   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5937   (exit $ac_status); }; }; then
5938   ac_cv_func_mmap_fixed_mapped=yes
5939 else
5940   echo "$as_me: program exited with status $ac_status" >&5
5941 echo "$as_me: failed program was:" >&5
5942 sed 's/^/| /' conftest.$ac_ext >&5
5943
5944 ( exit $ac_status )
5945 ac_cv_func_mmap_fixed_mapped=no
5946 fi
5947 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5948 fi
5949 fi
5950 echo "$as_me:$LINENO: result: $ac_cv_func_mmap_fixed_mapped" >&5
5951 echo "${ECHO_T}$ac_cv_func_mmap_fixed_mapped" >&6
5952 if test $ac_cv_func_mmap_fixed_mapped = yes; then
5953
5954 cat >>confdefs.h <<\_ACEOF
5955 #define HAVE_MMAP 1
5956 _ACEOF
5957
5958 fi
5959 rm -f conftest.mmap
5960
5961 fi
5962 echo "$as_me:$LINENO: checking for off_t" >&5
5963 echo $ECHO_N "checking for off_t... $ECHO_C" >&6
5964 if test "${ac_cv_type_off_t+set}" = set; then
5965   echo $ECHO_N "(cached) $ECHO_C" >&6
5966 else
5967   cat >conftest.$ac_ext <<_ACEOF
5968 /* confdefs.h.  */
5969 _ACEOF
5970 cat confdefs.h >>conftest.$ac_ext
5971 cat >>conftest.$ac_ext <<_ACEOF
5972 /* end confdefs.h.  */
5973 $ac_includes_default
5974 int
5975 main ()
5976 {
5977 if ((off_t *) 0)
5978   return 0;
5979 if (sizeof (off_t))
5980   return 0;
5981   ;
5982   return 0;
5983 }
5984 _ACEOF
5985 rm -f conftest.$ac_objext
5986 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5987   (eval $ac_compile) 2>conftest.er1
5988   ac_status=$?
5989   grep -v '^ *+' conftest.er1 >conftest.err
5990   rm -f conftest.er1
5991   cat conftest.err >&5
5992   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5993   (exit $ac_status); } &&
5994          { ac_try='test -z "$ac_c_werror_flag"
5995                          || test ! -s conftest.err'
5996   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5997   (eval $ac_try) 2>&5
5998   ac_status=$?
5999   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6000   (exit $ac_status); }; } &&
6001          { ac_try='test -s conftest.$ac_objext'
6002   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6003   (eval $ac_try) 2>&5
6004   ac_status=$?
6005   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6006   (exit $ac_status); }; }; then
6007   ac_cv_type_off_t=yes
6008 else
6009   echo "$as_me: failed program was:" >&5
6010 sed 's/^/| /' conftest.$ac_ext >&5
6011
6012 ac_cv_type_off_t=no
6013 fi
6014 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6015 fi
6016 echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5
6017 echo "${ECHO_T}$ac_cv_type_off_t" >&6
6018 if test $ac_cv_type_off_t = yes; then
6019   :
6020 else
6021
6022 cat >>confdefs.h <<_ACEOF
6023 #define off_t long
6024 _ACEOF
6025
6026 fi
6027
6028
6029 # check header files
6030 echo "$as_me:$LINENO: checking for ANSI C header files" >&5
6031 echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
6032 if test "${ac_cv_header_stdc+set}" = set; then
6033   echo $ECHO_N "(cached) $ECHO_C" >&6
6034 else
6035   cat >conftest.$ac_ext <<_ACEOF
6036 /* confdefs.h.  */
6037 _ACEOF
6038 cat confdefs.h >>conftest.$ac_ext
6039 cat >>conftest.$ac_ext <<_ACEOF
6040 /* end confdefs.h.  */
6041 #include <stdlib.h>
6042 #include <stdarg.h>
6043 #include <string.h>
6044 #include <float.h>
6045
6046 int
6047 main ()
6048 {
6049
6050   ;
6051   return 0;
6052 }
6053 _ACEOF
6054 rm -f conftest.$ac_objext
6055 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6056   (eval $ac_compile) 2>conftest.er1
6057   ac_status=$?
6058   grep -v '^ *+' conftest.er1 >conftest.err
6059   rm -f conftest.er1
6060   cat conftest.err >&5
6061   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6062   (exit $ac_status); } &&
6063          { ac_try='test -z "$ac_c_werror_flag"
6064                          || test ! -s conftest.err'
6065   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6066   (eval $ac_try) 2>&5
6067   ac_status=$?
6068   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6069   (exit $ac_status); }; } &&
6070          { ac_try='test -s conftest.$ac_objext'
6071   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6072   (eval $ac_try) 2>&5
6073   ac_status=$?
6074   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6075   (exit $ac_status); }; }; then
6076   ac_cv_header_stdc=yes
6077 else
6078   echo "$as_me: failed program was:" >&5
6079 sed 's/^/| /' conftest.$ac_ext >&5
6080
6081 ac_cv_header_stdc=no
6082 fi
6083 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6084
6085 if test $ac_cv_header_stdc = yes; then
6086   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
6087   cat >conftest.$ac_ext <<_ACEOF
6088 /* confdefs.h.  */
6089 _ACEOF
6090 cat confdefs.h >>conftest.$ac_ext
6091 cat >>conftest.$ac_ext <<_ACEOF
6092 /* end confdefs.h.  */
6093 #include <string.h>
6094
6095 _ACEOF
6096 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6097   $EGREP "memchr" >/dev/null 2>&1; then
6098   :
6099 else
6100   ac_cv_header_stdc=no
6101 fi
6102 rm -f conftest*
6103
6104 fi
6105
6106 if test $ac_cv_header_stdc = yes; then
6107   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
6108   cat >conftest.$ac_ext <<_ACEOF
6109 /* confdefs.h.  */
6110 _ACEOF
6111 cat confdefs.h >>conftest.$ac_ext
6112 cat >>conftest.$ac_ext <<_ACEOF
6113 /* end confdefs.h.  */
6114 #include <stdlib.h>
6115
6116 _ACEOF
6117 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6118   $EGREP "free" >/dev/null 2>&1; then
6119   :
6120 else
6121   ac_cv_header_stdc=no
6122 fi
6123 rm -f conftest*
6124
6125 fi
6126
6127 if test $ac_cv_header_stdc = yes; then
6128   # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
6129   if test "$cross_compiling" = yes; then
6130   :
6131 else
6132   cat >conftest.$ac_ext <<_ACEOF
6133 /* confdefs.h.  */
6134 _ACEOF
6135 cat confdefs.h >>conftest.$ac_ext
6136 cat >>conftest.$ac_ext <<_ACEOF
6137 /* end confdefs.h.  */
6138 #include <ctype.h>
6139 #if ((' ' & 0x0FF) == 0x020)
6140 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
6141 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
6142 #else
6143 # define ISLOWER(c) \
6144                    (('a' <= (c) && (c) <= 'i') \
6145                      || ('j' <= (c) && (c) <= 'r') \
6146                      || ('s' <= (c) && (c) <= 'z'))
6147 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
6148 #endif
6149
6150 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
6151 int
6152 main ()
6153 {
6154   int i;
6155   for (i = 0; i < 256; i++)
6156     if (XOR (islower (i), ISLOWER (i))
6157         || toupper (i) != TOUPPER (i))
6158       exit(2);
6159   exit (0);
6160 }
6161 _ACEOF
6162 rm -f conftest$ac_exeext
6163 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6164   (eval $ac_link) 2>&5
6165   ac_status=$?
6166   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6167   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
6168   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6169   (eval $ac_try) 2>&5
6170   ac_status=$?
6171   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6172   (exit $ac_status); }; }; then
6173   :
6174 else
6175   echo "$as_me: program exited with status $ac_status" >&5
6176 echo "$as_me: failed program was:" >&5
6177 sed 's/^/| /' conftest.$ac_ext >&5
6178
6179 ( exit $ac_status )
6180 ac_cv_header_stdc=no
6181 fi
6182 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
6183 fi
6184 fi
6185 fi
6186 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
6187 echo "${ECHO_T}$ac_cv_header_stdc" >&6
6188 if test $ac_cv_header_stdc = yes; then
6189
6190 cat >>confdefs.h <<\_ACEOF
6191 #define STDC_HEADERS 1
6192 _ACEOF
6193
6194 fi
6195
6196
6197
6198
6199
6200
6201
6202
6203 for ac_header in stdlib.h stdio.h string.h stddef.h math.h unistd.h signal.h
6204 do
6205 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6206 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6207   echo "$as_me:$LINENO: checking for $ac_header" >&5
6208 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6209 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6210   echo $ECHO_N "(cached) $ECHO_C" >&6
6211 fi
6212 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6213 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6214 else
6215   # Is the header compilable?
6216 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6217 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6218 cat >conftest.$ac_ext <<_ACEOF
6219 /* confdefs.h.  */
6220 _ACEOF
6221 cat confdefs.h >>conftest.$ac_ext
6222 cat >>conftest.$ac_ext <<_ACEOF
6223 /* end confdefs.h.  */
6224 $ac_includes_default
6225 #include <$ac_header>
6226 _ACEOF
6227 rm -f conftest.$ac_objext
6228 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6229   (eval $ac_compile) 2>conftest.er1
6230   ac_status=$?
6231   grep -v '^ *+' conftest.er1 >conftest.err
6232   rm -f conftest.er1
6233   cat conftest.err >&5
6234   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6235   (exit $ac_status); } &&
6236          { ac_try='test -z "$ac_c_werror_flag"
6237                          || test ! -s conftest.err'
6238   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6239   (eval $ac_try) 2>&5
6240   ac_status=$?
6241   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6242   (exit $ac_status); }; } &&
6243          { ac_try='test -s conftest.$ac_objext'
6244   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6245   (eval $ac_try) 2>&5
6246   ac_status=$?
6247   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6248   (exit $ac_status); }; }; then
6249   ac_header_compiler=yes
6250 else
6251   echo "$as_me: failed program was:" >&5
6252 sed 's/^/| /' conftest.$ac_ext >&5
6253
6254 ac_header_compiler=no
6255 fi
6256 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6257 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6258 echo "${ECHO_T}$ac_header_compiler" >&6
6259
6260 # Is the header present?
6261 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6262 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6263 cat >conftest.$ac_ext <<_ACEOF
6264 /* confdefs.h.  */
6265 _ACEOF
6266 cat confdefs.h >>conftest.$ac_ext
6267 cat >>conftest.$ac_ext <<_ACEOF
6268 /* end confdefs.h.  */
6269 #include <$ac_header>
6270 _ACEOF
6271 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6272   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6273   ac_status=$?
6274   grep -v '^ *+' conftest.er1 >conftest.err
6275   rm -f conftest.er1
6276   cat conftest.err >&5
6277   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6278   (exit $ac_status); } >/dev/null; then
6279   if test -s conftest.err; then
6280     ac_cpp_err=$ac_c_preproc_warn_flag
6281     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6282   else
6283     ac_cpp_err=
6284   fi
6285 else
6286   ac_cpp_err=yes
6287 fi
6288 if test -z "$ac_cpp_err"; then
6289   ac_header_preproc=yes
6290 else
6291   echo "$as_me: failed program was:" >&5
6292 sed 's/^/| /' conftest.$ac_ext >&5
6293
6294   ac_header_preproc=no
6295 fi
6296 rm -f conftest.err conftest.$ac_ext
6297 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6298 echo "${ECHO_T}$ac_header_preproc" >&6
6299
6300 # So?  What about this header?
6301 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6302   yes:no: )
6303     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6304 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6305     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6306 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6307     ac_header_preproc=yes
6308     ;;
6309   no:yes:* )
6310     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6311 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6312     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6313 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6314     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6315 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6316     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6317 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6318     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6319 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6320     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6321 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6322     (
6323       cat <<\_ASBOX
6324 ## ------------------------------------------------------ ##
6325 ## Report this to the GNU Fortran Runtime Library lists.  ##
6326 ## ------------------------------------------------------ ##
6327 _ASBOX
6328     ) |
6329       sed "s/^/$as_me: WARNING:     /" >&2
6330     ;;
6331 esac
6332 echo "$as_me:$LINENO: checking for $ac_header" >&5
6333 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6334 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6335   echo $ECHO_N "(cached) $ECHO_C" >&6
6336 else
6337   eval "$as_ac_Header=\$ac_header_preproc"
6338 fi
6339 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6340 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6341
6342 fi
6343 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6344   cat >>confdefs.h <<_ACEOF
6345 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6346 _ACEOF
6347
6348 fi
6349
6350 done
6351
6352
6353
6354
6355
6356
6357 for ac_header in time.h sys/params.h sys/time.h sys/times.h sys/resource.h
6358 do
6359 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6360 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6361   echo "$as_me:$LINENO: checking for $ac_header" >&5
6362 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6363 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6364   echo $ECHO_N "(cached) $ECHO_C" >&6
6365 fi
6366 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6367 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6368 else
6369   # Is the header compilable?
6370 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6371 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6372 cat >conftest.$ac_ext <<_ACEOF
6373 /* confdefs.h.  */
6374 _ACEOF
6375 cat confdefs.h >>conftest.$ac_ext
6376 cat >>conftest.$ac_ext <<_ACEOF
6377 /* end confdefs.h.  */
6378 $ac_includes_default
6379 #include <$ac_header>
6380 _ACEOF
6381 rm -f conftest.$ac_objext
6382 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6383   (eval $ac_compile) 2>conftest.er1
6384   ac_status=$?
6385   grep -v '^ *+' conftest.er1 >conftest.err
6386   rm -f conftest.er1
6387   cat conftest.err >&5
6388   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6389   (exit $ac_status); } &&
6390          { ac_try='test -z "$ac_c_werror_flag"
6391                          || test ! -s conftest.err'
6392   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6393   (eval $ac_try) 2>&5
6394   ac_status=$?
6395   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6396   (exit $ac_status); }; } &&
6397          { ac_try='test -s conftest.$ac_objext'
6398   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6399   (eval $ac_try) 2>&5
6400   ac_status=$?
6401   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6402   (exit $ac_status); }; }; then
6403   ac_header_compiler=yes
6404 else
6405   echo "$as_me: failed program was:" >&5
6406 sed 's/^/| /' conftest.$ac_ext >&5
6407
6408 ac_header_compiler=no
6409 fi
6410 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6411 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6412 echo "${ECHO_T}$ac_header_compiler" >&6
6413
6414 # Is the header present?
6415 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6416 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6417 cat >conftest.$ac_ext <<_ACEOF
6418 /* confdefs.h.  */
6419 _ACEOF
6420 cat confdefs.h >>conftest.$ac_ext
6421 cat >>conftest.$ac_ext <<_ACEOF
6422 /* end confdefs.h.  */
6423 #include <$ac_header>
6424 _ACEOF
6425 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6426   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6427   ac_status=$?
6428   grep -v '^ *+' conftest.er1 >conftest.err
6429   rm -f conftest.er1
6430   cat conftest.err >&5
6431   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6432   (exit $ac_status); } >/dev/null; then
6433   if test -s conftest.err; then
6434     ac_cpp_err=$ac_c_preproc_warn_flag
6435     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6436   else
6437     ac_cpp_err=
6438   fi
6439 else
6440   ac_cpp_err=yes
6441 fi
6442 if test -z "$ac_cpp_err"; then
6443   ac_header_preproc=yes
6444 else
6445   echo "$as_me: failed program was:" >&5
6446 sed 's/^/| /' conftest.$ac_ext >&5
6447
6448   ac_header_preproc=no
6449 fi
6450 rm -f conftest.err conftest.$ac_ext
6451 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6452 echo "${ECHO_T}$ac_header_preproc" >&6
6453
6454 # So?  What about this header?
6455 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6456   yes:no: )
6457     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6458 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6459     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6460 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6461     ac_header_preproc=yes
6462     ;;
6463   no:yes:* )
6464     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6465 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6466     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6467 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6468     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6469 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6470     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6471 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6472     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6473 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6474     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6475 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6476     (
6477       cat <<\_ASBOX
6478 ## ------------------------------------------------------ ##
6479 ## Report this to the GNU Fortran Runtime Library lists.  ##
6480 ## ------------------------------------------------------ ##
6481 _ASBOX
6482     ) |
6483       sed "s/^/$as_me: WARNING:     /" >&2
6484     ;;
6485 esac
6486 echo "$as_me:$LINENO: checking for $ac_header" >&5
6487 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6488 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6489   echo $ECHO_N "(cached) $ECHO_C" >&6
6490 else
6491   eval "$as_ac_Header=\$ac_header_preproc"
6492 fi
6493 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6494 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6495
6496 fi
6497 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6498   cat >>confdefs.h <<_ACEOF
6499 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6500 _ACEOF
6501
6502 fi
6503
6504 done
6505
6506
6507
6508
6509
6510
6511 for ac_header in sys/mman.h sys/types.h sys/stat.h ieeefp.h fenv.h
6512 do
6513 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6514 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6515   echo "$as_me:$LINENO: checking for $ac_header" >&5
6516 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6517 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6518   echo $ECHO_N "(cached) $ECHO_C" >&6
6519 fi
6520 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6521 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6522 else
6523   # Is the header compilable?
6524 echo "$as_me:$LINENO: checking $ac_header usability" >&5
6525 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
6526 cat >conftest.$ac_ext <<_ACEOF
6527 /* confdefs.h.  */
6528 _ACEOF
6529 cat confdefs.h >>conftest.$ac_ext
6530 cat >>conftest.$ac_ext <<_ACEOF
6531 /* end confdefs.h.  */
6532 $ac_includes_default
6533 #include <$ac_header>
6534 _ACEOF
6535 rm -f conftest.$ac_objext
6536 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6537   (eval $ac_compile) 2>conftest.er1
6538   ac_status=$?
6539   grep -v '^ *+' conftest.er1 >conftest.err
6540   rm -f conftest.er1
6541   cat conftest.err >&5
6542   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6543   (exit $ac_status); } &&
6544          { ac_try='test -z "$ac_c_werror_flag"
6545                          || test ! -s conftest.err'
6546   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6547   (eval $ac_try) 2>&5
6548   ac_status=$?
6549   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6550   (exit $ac_status); }; } &&
6551          { ac_try='test -s conftest.$ac_objext'
6552   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6553   (eval $ac_try) 2>&5
6554   ac_status=$?
6555   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6556   (exit $ac_status); }; }; then
6557   ac_header_compiler=yes
6558 else
6559   echo "$as_me: failed program was:" >&5
6560 sed 's/^/| /' conftest.$ac_ext >&5
6561
6562 ac_header_compiler=no
6563 fi
6564 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6565 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6566 echo "${ECHO_T}$ac_header_compiler" >&6
6567
6568 # Is the header present?
6569 echo "$as_me:$LINENO: checking $ac_header presence" >&5
6570 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
6571 cat >conftest.$ac_ext <<_ACEOF
6572 /* confdefs.h.  */
6573 _ACEOF
6574 cat confdefs.h >>conftest.$ac_ext
6575 cat >>conftest.$ac_ext <<_ACEOF
6576 /* end confdefs.h.  */
6577 #include <$ac_header>
6578 _ACEOF
6579 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6580   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6581   ac_status=$?
6582   grep -v '^ *+' conftest.er1 >conftest.err
6583   rm -f conftest.er1
6584   cat conftest.err >&5
6585   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6586   (exit $ac_status); } >/dev/null; then
6587   if test -s conftest.err; then
6588     ac_cpp_err=$ac_c_preproc_warn_flag
6589     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6590   else
6591     ac_cpp_err=
6592   fi
6593 else
6594   ac_cpp_err=yes
6595 fi
6596 if test -z "$ac_cpp_err"; then
6597   ac_header_preproc=yes
6598 else
6599   echo "$as_me: failed program was:" >&5
6600 sed 's/^/| /' conftest.$ac_ext >&5
6601
6602   ac_header_preproc=no
6603 fi
6604 rm -f conftest.err conftest.$ac_ext
6605 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6606 echo "${ECHO_T}$ac_header_preproc" >&6
6607
6608 # So?  What about this header?
6609 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6610   yes:no: )
6611     { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6612 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6613     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6614 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
6615     ac_header_preproc=yes
6616     ;;
6617   no:yes:* )
6618     { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
6619 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6620     { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6621 echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6622     { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6623 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6624     { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6625 echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6626     { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6627 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6628     { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6629 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
6630     (
6631       cat <<\_ASBOX
6632 ## ------------------------------------------------------ ##
6633 ## Report this to the GNU Fortran Runtime Library lists.  ##
6634 ## ------------------------------------------------------ ##
6635 _ASBOX
6636     ) |
6637       sed "s/^/$as_me: WARNING:     /" >&2
6638     ;;
6639 esac
6640 echo "$as_me:$LINENO: checking for $ac_header" >&5
6641 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6642 if eval "test \"\${$as_ac_Header+set}\" = set"; then
6643   echo $ECHO_N "(cached) $ECHO_C" >&6
6644 else
6645   eval "$as_ac_Header=\$ac_header_preproc"
6646 fi
6647 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6648 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6649
6650 fi
6651 if test `eval echo '${'$as_ac_Header'}'` = yes; then
6652   cat >>confdefs.h <<_ACEOF
6653 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6654 _ACEOF
6655
6656 fi
6657
6658 done
6659
6660 if test "${ac_cv_header_complex_h+set}" = set; then
6661   echo "$as_me:$LINENO: checking for complex.h" >&5
6662 echo $ECHO_N "checking for complex.h... $ECHO_C" >&6
6663 if test "${ac_cv_header_complex_h+set}" = set; then
6664   echo $ECHO_N "(cached) $ECHO_C" >&6
6665 fi
6666 echo "$as_me:$LINENO: result: $ac_cv_header_complex_h" >&5
6667 echo "${ECHO_T}$ac_cv_header_complex_h" >&6
6668 else
6669   # Is the header compilable?
6670 echo "$as_me:$LINENO: checking complex.h usability" >&5
6671 echo $ECHO_N "checking complex.h usability... $ECHO_C" >&6
6672 cat >conftest.$ac_ext <<_ACEOF
6673 /* confdefs.h.  */
6674 _ACEOF
6675 cat confdefs.h >>conftest.$ac_ext
6676 cat >>conftest.$ac_ext <<_ACEOF
6677 /* end confdefs.h.  */
6678 $ac_includes_default
6679 #include <complex.h>
6680 _ACEOF
6681 rm -f conftest.$ac_objext
6682 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6683   (eval $ac_compile) 2>conftest.er1
6684   ac_status=$?
6685   grep -v '^ *+' conftest.er1 >conftest.err
6686   rm -f conftest.er1
6687   cat conftest.err >&5
6688   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6689   (exit $ac_status); } &&
6690          { ac_try='test -z "$ac_c_werror_flag"
6691                          || test ! -s conftest.err'
6692   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6693   (eval $ac_try) 2>&5
6694   ac_status=$?
6695   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6696   (exit $ac_status); }; } &&
6697          { ac_try='test -s conftest.$ac_objext'
6698   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6699   (eval $ac_try) 2>&5
6700   ac_status=$?
6701   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6702   (exit $ac_status); }; }; then
6703   ac_header_compiler=yes
6704 else
6705   echo "$as_me: failed program was:" >&5
6706 sed 's/^/| /' conftest.$ac_ext >&5
6707
6708 ac_header_compiler=no
6709 fi
6710 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6711 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6712 echo "${ECHO_T}$ac_header_compiler" >&6
6713
6714 # Is the header present?
6715 echo "$as_me:$LINENO: checking complex.h presence" >&5
6716 echo $ECHO_N "checking complex.h presence... $ECHO_C" >&6
6717 cat >conftest.$ac_ext <<_ACEOF
6718 /* confdefs.h.  */
6719 _ACEOF
6720 cat confdefs.h >>conftest.$ac_ext
6721 cat >>conftest.$ac_ext <<_ACEOF
6722 /* end confdefs.h.  */
6723 #include <complex.h>
6724 _ACEOF
6725 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6726   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6727   ac_status=$?
6728   grep -v '^ *+' conftest.er1 >conftest.err
6729   rm -f conftest.er1
6730   cat conftest.err >&5
6731   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6732   (exit $ac_status); } >/dev/null; then
6733   if test -s conftest.err; then
6734     ac_cpp_err=$ac_c_preproc_warn_flag
6735     ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6736   else
6737     ac_cpp_err=
6738   fi
6739 else
6740   ac_cpp_err=yes
6741 fi
6742 if test -z "$ac_cpp_err"; then
6743   ac_header_preproc=yes
6744 else
6745   echo "$as_me: failed program was:" >&5
6746 sed 's/^/| /' conftest.$ac_ext >&5
6747
6748   ac_header_preproc=no
6749 fi
6750 rm -f conftest.err conftest.$ac_ext
6751 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6752 echo "${ECHO_T}$ac_header_preproc" >&6
6753
6754 # So?  What about this header?
6755 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6756   yes:no: )
6757     { echo "$as_me:$LINENO: WARNING: complex.h: accepted by the compiler, rejected by the preprocessor!" >&5
6758 echo "$as_me: WARNING: complex.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6759     { echo "$as_me:$LINENO: WARNING: complex.h: proceeding with the compiler's result" >&5
6760 echo "$as_me: WARNING: complex.h: proceeding with the compiler's result" >&2;}
6761     ac_header_preproc=yes
6762     ;;
6763   no:yes:* )
6764     { echo "$as_me:$LINENO: WARNING: complex.h: present but cannot be compiled" >&5
6765 echo "$as_me: WARNING: complex.h: present but cannot be compiled" >&2;}
6766     { echo "$as_me:$LINENO: WARNING: complex.h:     check for missing prerequisite headers?" >&5
6767 echo "$as_me: WARNING: complex.h:     check for missing prerequisite headers?" >&2;}
6768     { echo "$as_me:$LINENO: WARNING: complex.h: see the Autoconf documentation" >&5
6769 echo "$as_me: WARNING: complex.h: see the Autoconf documentation" >&2;}
6770     { echo "$as_me:$LINENO: WARNING: complex.h:     section \"Present But Cannot Be Compiled\"" >&5
6771 echo "$as_me: WARNING: complex.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6772     { echo "$as_me:$LINENO: WARNING: complex.h: proceeding with the preprocessor's result" >&5
6773 echo "$as_me: WARNING: complex.h: proceeding with the preprocessor's result" >&2;}
6774     { echo "$as_me:$LINENO: WARNING: complex.h: in the future, the compiler will take precedence" >&5
6775 echo "$as_me: WARNING: complex.h: in the future, the compiler will take precedence" >&2;}
6776     (
6777       cat <<\_ASBOX
6778 ## ------------------------------------------------------ ##
6779 ## Report this to the GNU Fortran Runtime Library lists.  ##
6780 ## ------------------------------------------------------ ##
6781 _ASBOX
6782     ) |
6783       sed "s/^/$as_me: WARNING:     /" >&2
6784     ;;
6785 esac
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 else
6791   ac_cv_header_complex_h=$ac_header_preproc
6792 fi
6793 echo "$as_me:$LINENO: result: $ac_cv_header_complex_h" >&5
6794 echo "${ECHO_T}$ac_cv_header_complex_h" >&6
6795
6796 fi
6797 if test $ac_cv_header_complex_h = yes; then
6798
6799 cat >>confdefs.h <<\_ACEOF
6800 #define HAVE_COMPLEX_H 1
6801 _ACEOF
6802
6803 fi
6804
6805
6806
6807 echo "$as_me:$LINENO: checking for struct stat.st_blksize" >&5
6808 echo $ECHO_N "checking for struct stat.st_blksize... $ECHO_C" >&6
6809 if test "${ac_cv_member_struct_stat_st_blksize+set}" = set; then
6810   echo $ECHO_N "(cached) $ECHO_C" >&6
6811 else
6812   cat >conftest.$ac_ext <<_ACEOF
6813 /* confdefs.h.  */
6814 _ACEOF
6815 cat confdefs.h >>conftest.$ac_ext
6816 cat >>conftest.$ac_ext <<_ACEOF
6817 /* end confdefs.h.  */
6818 $ac_includes_default
6819 int
6820 main ()
6821 {
6822 static struct stat ac_aggr;
6823 if (ac_aggr.st_blksize)
6824 return 0;
6825   ;
6826   return 0;
6827 }
6828 _ACEOF
6829 rm -f conftest.$ac_objext
6830 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6831   (eval $ac_compile) 2>conftest.er1
6832   ac_status=$?
6833   grep -v '^ *+' conftest.er1 >conftest.err
6834   rm -f conftest.er1
6835   cat conftest.err >&5
6836   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6837   (exit $ac_status); } &&
6838          { ac_try='test -z "$ac_c_werror_flag"
6839                          || test ! -s conftest.err'
6840   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6841   (eval $ac_try) 2>&5
6842   ac_status=$?
6843   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6844   (exit $ac_status); }; } &&
6845          { ac_try='test -s conftest.$ac_objext'
6846   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6847   (eval $ac_try) 2>&5
6848   ac_status=$?
6849   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6850   (exit $ac_status); }; }; then
6851   ac_cv_member_struct_stat_st_blksize=yes
6852 else
6853   echo "$as_me: failed program was:" >&5
6854 sed 's/^/| /' conftest.$ac_ext >&5
6855
6856 cat >conftest.$ac_ext <<_ACEOF
6857 /* confdefs.h.  */
6858 _ACEOF
6859 cat confdefs.h >>conftest.$ac_ext
6860 cat >>conftest.$ac_ext <<_ACEOF
6861 /* end confdefs.h.  */
6862 $ac_includes_default
6863 int
6864 main ()
6865 {
6866 static struct stat ac_aggr;
6867 if (sizeof ac_aggr.st_blksize)
6868 return 0;
6869   ;
6870   return 0;
6871 }
6872 _ACEOF
6873 rm -f conftest.$ac_objext
6874 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6875   (eval $ac_compile) 2>conftest.er1
6876   ac_status=$?
6877   grep -v '^ *+' conftest.er1 >conftest.err
6878   rm -f conftest.er1
6879   cat conftest.err >&5
6880   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6881   (exit $ac_status); } &&
6882          { ac_try='test -z "$ac_c_werror_flag"
6883                          || test ! -s conftest.err'
6884   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6885   (eval $ac_try) 2>&5
6886   ac_status=$?
6887   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6888   (exit $ac_status); }; } &&
6889          { ac_try='test -s conftest.$ac_objext'
6890   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6891   (eval $ac_try) 2>&5
6892   ac_status=$?
6893   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6894   (exit $ac_status); }; }; then
6895   ac_cv_member_struct_stat_st_blksize=yes
6896 else
6897   echo "$as_me: failed program was:" >&5
6898 sed 's/^/| /' conftest.$ac_ext >&5
6899
6900 ac_cv_member_struct_stat_st_blksize=no
6901 fi
6902 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6903 fi
6904 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6905 fi
6906 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blksize" >&5
6907 echo "${ECHO_T}$ac_cv_member_struct_stat_st_blksize" >&6
6908 if test $ac_cv_member_struct_stat_st_blksize = yes; then
6909
6910 cat >>confdefs.h <<_ACEOF
6911 #define HAVE_STRUCT_STAT_ST_BLKSIZE 1
6912 _ACEOF
6913
6914
6915 fi
6916
6917 echo "$as_me:$LINENO: checking for struct stat.st_blocks" >&5
6918 echo $ECHO_N "checking for struct stat.st_blocks... $ECHO_C" >&6
6919 if test "${ac_cv_member_struct_stat_st_blocks+set}" = set; then
6920   echo $ECHO_N "(cached) $ECHO_C" >&6
6921 else
6922   cat >conftest.$ac_ext <<_ACEOF
6923 /* confdefs.h.  */
6924 _ACEOF
6925 cat confdefs.h >>conftest.$ac_ext
6926 cat >>conftest.$ac_ext <<_ACEOF
6927 /* end confdefs.h.  */
6928 $ac_includes_default
6929 int
6930 main ()
6931 {
6932 static struct stat ac_aggr;
6933 if (ac_aggr.st_blocks)
6934 return 0;
6935   ;
6936   return 0;
6937 }
6938 _ACEOF
6939 rm -f conftest.$ac_objext
6940 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6941   (eval $ac_compile) 2>conftest.er1
6942   ac_status=$?
6943   grep -v '^ *+' conftest.er1 >conftest.err
6944   rm -f conftest.er1
6945   cat conftest.err >&5
6946   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6947   (exit $ac_status); } &&
6948          { ac_try='test -z "$ac_c_werror_flag"
6949                          || test ! -s conftest.err'
6950   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6951   (eval $ac_try) 2>&5
6952   ac_status=$?
6953   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6954   (exit $ac_status); }; } &&
6955          { ac_try='test -s conftest.$ac_objext'
6956   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6957   (eval $ac_try) 2>&5
6958   ac_status=$?
6959   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6960   (exit $ac_status); }; }; then
6961   ac_cv_member_struct_stat_st_blocks=yes
6962 else
6963   echo "$as_me: failed program was:" >&5
6964 sed 's/^/| /' conftest.$ac_ext >&5
6965
6966 cat >conftest.$ac_ext <<_ACEOF
6967 /* confdefs.h.  */
6968 _ACEOF
6969 cat confdefs.h >>conftest.$ac_ext
6970 cat >>conftest.$ac_ext <<_ACEOF
6971 /* end confdefs.h.  */
6972 $ac_includes_default
6973 int
6974 main ()
6975 {
6976 static struct stat ac_aggr;
6977 if (sizeof ac_aggr.st_blocks)
6978 return 0;
6979   ;
6980   return 0;
6981 }
6982 _ACEOF
6983 rm -f conftest.$ac_objext
6984 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6985   (eval $ac_compile) 2>conftest.er1
6986   ac_status=$?
6987   grep -v '^ *+' conftest.er1 >conftest.err
6988   rm -f conftest.er1
6989   cat conftest.err >&5
6990   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6991   (exit $ac_status); } &&
6992          { ac_try='test -z "$ac_c_werror_flag"
6993                          || test ! -s conftest.err'
6994   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6995   (eval $ac_try) 2>&5
6996   ac_status=$?
6997   echo "$as_me:$LINENO: \$? = $ac_status" >&5
6998   (exit $ac_status); }; } &&
6999          { ac_try='test -s conftest.$ac_objext'
7000   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7001   (eval $ac_try) 2>&5
7002   ac_status=$?
7003   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7004   (exit $ac_status); }; }; then
7005   ac_cv_member_struct_stat_st_blocks=yes
7006 else
7007   echo "$as_me: failed program was:" >&5
7008 sed 's/^/| /' conftest.$ac_ext >&5
7009
7010 ac_cv_member_struct_stat_st_blocks=no
7011 fi
7012 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7013 fi
7014 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7015 fi
7016 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_blocks" >&5
7017 echo "${ECHO_T}$ac_cv_member_struct_stat_st_blocks" >&6
7018 if test $ac_cv_member_struct_stat_st_blocks = yes; then
7019
7020 cat >>confdefs.h <<_ACEOF
7021 #define HAVE_STRUCT_STAT_ST_BLOCKS 1
7022 _ACEOF
7023
7024
7025 fi
7026
7027 echo "$as_me:$LINENO: checking for struct stat.st_rdev" >&5
7028 echo $ECHO_N "checking for struct stat.st_rdev... $ECHO_C" >&6
7029 if test "${ac_cv_member_struct_stat_st_rdev+set}" = set; then
7030   echo $ECHO_N "(cached) $ECHO_C" >&6
7031 else
7032   cat >conftest.$ac_ext <<_ACEOF
7033 /* confdefs.h.  */
7034 _ACEOF
7035 cat confdefs.h >>conftest.$ac_ext
7036 cat >>conftest.$ac_ext <<_ACEOF
7037 /* end confdefs.h.  */
7038 $ac_includes_default
7039 int
7040 main ()
7041 {
7042 static struct stat ac_aggr;
7043 if (ac_aggr.st_rdev)
7044 return 0;
7045   ;
7046   return 0;
7047 }
7048 _ACEOF
7049 rm -f conftest.$ac_objext
7050 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7051   (eval $ac_compile) 2>conftest.er1
7052   ac_status=$?
7053   grep -v '^ *+' conftest.er1 >conftest.err
7054   rm -f conftest.er1
7055   cat conftest.err >&5
7056   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7057   (exit $ac_status); } &&
7058          { ac_try='test -z "$ac_c_werror_flag"
7059                          || test ! -s conftest.err'
7060   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7061   (eval $ac_try) 2>&5
7062   ac_status=$?
7063   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7064   (exit $ac_status); }; } &&
7065          { ac_try='test -s conftest.$ac_objext'
7066   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7067   (eval $ac_try) 2>&5
7068   ac_status=$?
7069   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7070   (exit $ac_status); }; }; then
7071   ac_cv_member_struct_stat_st_rdev=yes
7072 else
7073   echo "$as_me: failed program was:" >&5
7074 sed 's/^/| /' conftest.$ac_ext >&5
7075
7076 cat >conftest.$ac_ext <<_ACEOF
7077 /* confdefs.h.  */
7078 _ACEOF
7079 cat confdefs.h >>conftest.$ac_ext
7080 cat >>conftest.$ac_ext <<_ACEOF
7081 /* end confdefs.h.  */
7082 $ac_includes_default
7083 int
7084 main ()
7085 {
7086 static struct stat ac_aggr;
7087 if (sizeof ac_aggr.st_rdev)
7088 return 0;
7089   ;
7090   return 0;
7091 }
7092 _ACEOF
7093 rm -f conftest.$ac_objext
7094 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7095   (eval $ac_compile) 2>conftest.er1
7096   ac_status=$?
7097   grep -v '^ *+' conftest.er1 >conftest.err
7098   rm -f conftest.er1
7099   cat conftest.err >&5
7100   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7101   (exit $ac_status); } &&
7102          { ac_try='test -z "$ac_c_werror_flag"
7103                          || test ! -s conftest.err'
7104   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7105   (eval $ac_try) 2>&5
7106   ac_status=$?
7107   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7108   (exit $ac_status); }; } &&
7109          { ac_try='test -s conftest.$ac_objext'
7110   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7111   (eval $ac_try) 2>&5
7112   ac_status=$?
7113   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7114   (exit $ac_status); }; }; then
7115   ac_cv_member_struct_stat_st_rdev=yes
7116 else
7117   echo "$as_me: failed program was:" >&5
7118 sed 's/^/| /' conftest.$ac_ext >&5
7119
7120 ac_cv_member_struct_stat_st_rdev=no
7121 fi
7122 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7123 fi
7124 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7125 fi
7126 echo "$as_me:$LINENO: result: $ac_cv_member_struct_stat_st_rdev" >&5
7127 echo "${ECHO_T}$ac_cv_member_struct_stat_st_rdev" >&6
7128 if test $ac_cv_member_struct_stat_st_rdev = yes; then
7129
7130 cat >>confdefs.h <<_ACEOF
7131 #define HAVE_STRUCT_STAT_ST_RDEV 1
7132 _ACEOF
7133
7134
7135 fi
7136
7137
7138 # Check for library functions.
7139
7140
7141
7142
7143
7144
7145
7146
7147 for ac_func in getrusage times mkstemp strtof strtold snprintf ftruncate chsize
7148 do
7149 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7150 echo "$as_me:$LINENO: checking for $ac_func" >&5
7151 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7152 if eval "test \"\${$as_ac_var+set}\" = set"; then
7153   echo $ECHO_N "(cached) $ECHO_C" >&6
7154 else
7155   if test x$gcc_no_link = xyes; then
7156   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7157 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7158    { (exit 1); exit 1; }; }
7159 fi
7160 cat >conftest.$ac_ext <<_ACEOF
7161 /* confdefs.h.  */
7162 _ACEOF
7163 cat confdefs.h >>conftest.$ac_ext
7164 cat >>conftest.$ac_ext <<_ACEOF
7165 /* end confdefs.h.  */
7166 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7167    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7168 #define $ac_func innocuous_$ac_func
7169
7170 /* System header to define __stub macros and hopefully few prototypes,
7171     which can conflict with char $ac_func (); below.
7172     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7173     <limits.h> exists even on freestanding compilers.  */
7174
7175 #ifdef __STDC__
7176 # include <limits.h>
7177 #else
7178 # include <assert.h>
7179 #endif
7180
7181 #undef $ac_func
7182
7183 /* Override any gcc2 internal prototype to avoid an error.  */
7184 #ifdef __cplusplus
7185 extern "C"
7186 {
7187 #endif
7188 /* We use char because int might match the return type of a gcc2
7189    builtin and then its argument prototype would still apply.  */
7190 char $ac_func ();
7191 /* The GNU C library defines this for functions which it implements
7192     to always fail with ENOSYS.  Some functions are actually named
7193     something starting with __ and the normal name is an alias.  */
7194 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7195 choke me
7196 #else
7197 char (*f) () = $ac_func;
7198 #endif
7199 #ifdef __cplusplus
7200 }
7201 #endif
7202
7203 int
7204 main ()
7205 {
7206 return f != $ac_func;
7207   ;
7208   return 0;
7209 }
7210 _ACEOF
7211 rm -f conftest.$ac_objext conftest$ac_exeext
7212 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7213   (eval $ac_link) 2>conftest.er1
7214   ac_status=$?
7215   grep -v '^ *+' conftest.er1 >conftest.err
7216   rm -f conftest.er1
7217   cat conftest.err >&5
7218   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7219   (exit $ac_status); } &&
7220          { ac_try='test -z "$ac_c_werror_flag"
7221                          || 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_exeext'
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   eval "$as_ac_var=yes"
7234 else
7235   echo "$as_me: failed program was:" >&5
7236 sed 's/^/| /' conftest.$ac_ext >&5
7237
7238 eval "$as_ac_var=no"
7239 fi
7240 rm -f conftest.err conftest.$ac_objext \
7241       conftest$ac_exeext conftest.$ac_ext
7242 fi
7243 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7244 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7245 if test `eval echo '${'$as_ac_var'}'` = yes; then
7246   cat >>confdefs.h <<_ACEOF
7247 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7248 _ACEOF
7249
7250 fi
7251 done
7252
7253
7254
7255
7256
7257
7258
7259
7260
7261 for ac_func in chdir strerror getlogin gethostname kill link symlink perror
7262 do
7263 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7264 echo "$as_me:$LINENO: checking for $ac_func" >&5
7265 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7266 if eval "test \"\${$as_ac_var+set}\" = set"; then
7267   echo $ECHO_N "(cached) $ECHO_C" >&6
7268 else
7269   if test x$gcc_no_link = xyes; then
7270   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7271 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7272    { (exit 1); exit 1; }; }
7273 fi
7274 cat >conftest.$ac_ext <<_ACEOF
7275 /* confdefs.h.  */
7276 _ACEOF
7277 cat confdefs.h >>conftest.$ac_ext
7278 cat >>conftest.$ac_ext <<_ACEOF
7279 /* end confdefs.h.  */
7280 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7281    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7282 #define $ac_func innocuous_$ac_func
7283
7284 /* System header to define __stub macros and hopefully few prototypes,
7285     which can conflict with char $ac_func (); below.
7286     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7287     <limits.h> exists even on freestanding compilers.  */
7288
7289 #ifdef __STDC__
7290 # include <limits.h>
7291 #else
7292 # include <assert.h>
7293 #endif
7294
7295 #undef $ac_func
7296
7297 /* Override any gcc2 internal prototype to avoid an error.  */
7298 #ifdef __cplusplus
7299 extern "C"
7300 {
7301 #endif
7302 /* We use char because int might match the return type of a gcc2
7303    builtin and then its argument prototype would still apply.  */
7304 char $ac_func ();
7305 /* The GNU C library defines this for functions which it implements
7306     to always fail with ENOSYS.  Some functions are actually named
7307     something starting with __ and the normal name is an alias.  */
7308 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7309 choke me
7310 #else
7311 char (*f) () = $ac_func;
7312 #endif
7313 #ifdef __cplusplus
7314 }
7315 #endif
7316
7317 int
7318 main ()
7319 {
7320 return f != $ac_func;
7321   ;
7322   return 0;
7323 }
7324 _ACEOF
7325 rm -f conftest.$ac_objext conftest$ac_exeext
7326 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7327   (eval $ac_link) 2>conftest.er1
7328   ac_status=$?
7329   grep -v '^ *+' conftest.er1 >conftest.err
7330   rm -f conftest.er1
7331   cat conftest.err >&5
7332   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7333   (exit $ac_status); } &&
7334          { ac_try='test -z "$ac_c_werror_flag"
7335                          || test ! -s conftest.err'
7336   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7337   (eval $ac_try) 2>&5
7338   ac_status=$?
7339   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7340   (exit $ac_status); }; } &&
7341          { ac_try='test -s conftest$ac_exeext'
7342   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7343   (eval $ac_try) 2>&5
7344   ac_status=$?
7345   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7346   (exit $ac_status); }; }; then
7347   eval "$as_ac_var=yes"
7348 else
7349   echo "$as_me: failed program was:" >&5
7350 sed 's/^/| /' conftest.$ac_ext >&5
7351
7352 eval "$as_ac_var=no"
7353 fi
7354 rm -f conftest.err conftest.$ac_objext \
7355       conftest$ac_exeext conftest.$ac_ext
7356 fi
7357 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7358 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7359 if test `eval echo '${'$as_ac_var'}'` = yes; then
7360   cat >>confdefs.h <<_ACEOF
7361 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7362 _ACEOF
7363
7364 fi
7365 done
7366
7367
7368
7369
7370 for ac_func in sleep time ttyname
7371 do
7372 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7373 echo "$as_me:$LINENO: checking for $ac_func" >&5
7374 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7375 if eval "test \"\${$as_ac_var+set}\" = set"; then
7376   echo $ECHO_N "(cached) $ECHO_C" >&6
7377 else
7378   if test x$gcc_no_link = xyes; then
7379   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7380 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7381    { (exit 1); exit 1; }; }
7382 fi
7383 cat >conftest.$ac_ext <<_ACEOF
7384 /* confdefs.h.  */
7385 _ACEOF
7386 cat confdefs.h >>conftest.$ac_ext
7387 cat >>conftest.$ac_ext <<_ACEOF
7388 /* end confdefs.h.  */
7389 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7390    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7391 #define $ac_func innocuous_$ac_func
7392
7393 /* System header to define __stub macros and hopefully few prototypes,
7394     which can conflict with char $ac_func (); below.
7395     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7396     <limits.h> exists even on freestanding compilers.  */
7397
7398 #ifdef __STDC__
7399 # include <limits.h>
7400 #else
7401 # include <assert.h>
7402 #endif
7403
7404 #undef $ac_func
7405
7406 /* Override any gcc2 internal prototype to avoid an error.  */
7407 #ifdef __cplusplus
7408 extern "C"
7409 {
7410 #endif
7411 /* We use char because int might match the return type of a gcc2
7412    builtin and then its argument prototype would still apply.  */
7413 char $ac_func ();
7414 /* The GNU C library defines this for functions which it implements
7415     to always fail with ENOSYS.  Some functions are actually named
7416     something starting with __ and the normal name is an alias.  */
7417 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7418 choke me
7419 #else
7420 char (*f) () = $ac_func;
7421 #endif
7422 #ifdef __cplusplus
7423 }
7424 #endif
7425
7426 int
7427 main ()
7428 {
7429 return f != $ac_func;
7430   ;
7431   return 0;
7432 }
7433 _ACEOF
7434 rm -f conftest.$ac_objext conftest$ac_exeext
7435 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7436   (eval $ac_link) 2>conftest.er1
7437   ac_status=$?
7438   grep -v '^ *+' conftest.er1 >conftest.err
7439   rm -f conftest.er1
7440   cat conftest.err >&5
7441   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7442   (exit $ac_status); } &&
7443          { ac_try='test -z "$ac_c_werror_flag"
7444                          || test ! -s conftest.err'
7445   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7446   (eval $ac_try) 2>&5
7447   ac_status=$?
7448   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7449   (exit $ac_status); }; } &&
7450          { ac_try='test -s conftest$ac_exeext'
7451   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7452   (eval $ac_try) 2>&5
7453   ac_status=$?
7454   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7455   (exit $ac_status); }; }; then
7456   eval "$as_ac_var=yes"
7457 else
7458   echo "$as_me: failed program was:" >&5
7459 sed 's/^/| /' conftest.$ac_ext >&5
7460
7461 eval "$as_ac_var=no"
7462 fi
7463 rm -f conftest.err conftest.$ac_objext \
7464       conftest$ac_exeext conftest.$ac_ext
7465 fi
7466 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7467 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7468 if test `eval echo '${'$as_ac_var'}'` = yes; then
7469   cat >>confdefs.h <<_ACEOF
7470 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7471 _ACEOF
7472
7473 fi
7474 done
7475
7476
7477 # Check libc for getgid, getpid, getuid
7478 echo "$as_me:$LINENO: checking for getgid in -lc" >&5
7479 echo $ECHO_N "checking for getgid in -lc... $ECHO_C" >&6
7480 if test "${ac_cv_lib_c_getgid+set}" = set; then
7481   echo $ECHO_N "(cached) $ECHO_C" >&6
7482 else
7483   ac_check_lib_save_LIBS=$LIBS
7484 LIBS="-lc  $LIBS"
7485 if test x$gcc_no_link = xyes; then
7486   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7487 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7488    { (exit 1); exit 1; }; }
7489 fi
7490 cat >conftest.$ac_ext <<_ACEOF
7491 /* confdefs.h.  */
7492 _ACEOF
7493 cat confdefs.h >>conftest.$ac_ext
7494 cat >>conftest.$ac_ext <<_ACEOF
7495 /* end confdefs.h.  */
7496
7497 /* Override any gcc2 internal prototype to avoid an error.  */
7498 #ifdef __cplusplus
7499 extern "C"
7500 #endif
7501 /* We use char because int might match the return type of a gcc2
7502    builtin and then its argument prototype would still apply.  */
7503 char getgid ();
7504 int
7505 main ()
7506 {
7507 getgid ();
7508   ;
7509   return 0;
7510 }
7511 _ACEOF
7512 rm -f conftest.$ac_objext conftest$ac_exeext
7513 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7514   (eval $ac_link) 2>conftest.er1
7515   ac_status=$?
7516   grep -v '^ *+' conftest.er1 >conftest.err
7517   rm -f conftest.er1
7518   cat conftest.err >&5
7519   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7520   (exit $ac_status); } &&
7521          { ac_try='test -z "$ac_c_werror_flag"
7522                          || test ! -s conftest.err'
7523   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7524   (eval $ac_try) 2>&5
7525   ac_status=$?
7526   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7527   (exit $ac_status); }; } &&
7528          { ac_try='test -s conftest$ac_exeext'
7529   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7530   (eval $ac_try) 2>&5
7531   ac_status=$?
7532   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7533   (exit $ac_status); }; }; then
7534   ac_cv_lib_c_getgid=yes
7535 else
7536   echo "$as_me: failed program was:" >&5
7537 sed 's/^/| /' conftest.$ac_ext >&5
7538
7539 ac_cv_lib_c_getgid=no
7540 fi
7541 rm -f conftest.err conftest.$ac_objext \
7542       conftest$ac_exeext conftest.$ac_ext
7543 LIBS=$ac_check_lib_save_LIBS
7544 fi
7545 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getgid" >&5
7546 echo "${ECHO_T}$ac_cv_lib_c_getgid" >&6
7547 if test $ac_cv_lib_c_getgid = yes; then
7548
7549 cat >>confdefs.h <<\_ACEOF
7550 #define HAVE_GETGID 1
7551 _ACEOF
7552
7553 fi
7554
7555 echo "$as_me:$LINENO: checking for getpid in -lc" >&5
7556 echo $ECHO_N "checking for getpid in -lc... $ECHO_C" >&6
7557 if test "${ac_cv_lib_c_getpid+set}" = set; then
7558   echo $ECHO_N "(cached) $ECHO_C" >&6
7559 else
7560   ac_check_lib_save_LIBS=$LIBS
7561 LIBS="-lc  $LIBS"
7562 if test x$gcc_no_link = xyes; then
7563   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7564 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7565    { (exit 1); exit 1; }; }
7566 fi
7567 cat >conftest.$ac_ext <<_ACEOF
7568 /* confdefs.h.  */
7569 _ACEOF
7570 cat confdefs.h >>conftest.$ac_ext
7571 cat >>conftest.$ac_ext <<_ACEOF
7572 /* end confdefs.h.  */
7573
7574 /* Override any gcc2 internal prototype to avoid an error.  */
7575 #ifdef __cplusplus
7576 extern "C"
7577 #endif
7578 /* We use char because int might match the return type of a gcc2
7579    builtin and then its argument prototype would still apply.  */
7580 char getpid ();
7581 int
7582 main ()
7583 {
7584 getpid ();
7585   ;
7586   return 0;
7587 }
7588 _ACEOF
7589 rm -f conftest.$ac_objext conftest$ac_exeext
7590 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7591   (eval $ac_link) 2>conftest.er1
7592   ac_status=$?
7593   grep -v '^ *+' conftest.er1 >conftest.err
7594   rm -f conftest.er1
7595   cat conftest.err >&5
7596   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7597   (exit $ac_status); } &&
7598          { ac_try='test -z "$ac_c_werror_flag"
7599                          || test ! -s conftest.err'
7600   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7601   (eval $ac_try) 2>&5
7602   ac_status=$?
7603   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7604   (exit $ac_status); }; } &&
7605          { ac_try='test -s conftest$ac_exeext'
7606   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7607   (eval $ac_try) 2>&5
7608   ac_status=$?
7609   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7610   (exit $ac_status); }; }; then
7611   ac_cv_lib_c_getpid=yes
7612 else
7613   echo "$as_me: failed program was:" >&5
7614 sed 's/^/| /' conftest.$ac_ext >&5
7615
7616 ac_cv_lib_c_getpid=no
7617 fi
7618 rm -f conftest.err conftest.$ac_objext \
7619       conftest$ac_exeext conftest.$ac_ext
7620 LIBS=$ac_check_lib_save_LIBS
7621 fi
7622 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getpid" >&5
7623 echo "${ECHO_T}$ac_cv_lib_c_getpid" >&6
7624 if test $ac_cv_lib_c_getpid = yes; then
7625
7626 cat >>confdefs.h <<\_ACEOF
7627 #define HAVE_GETPID 1
7628 _ACEOF
7629
7630 fi
7631
7632 echo "$as_me:$LINENO: checking for getuid in -lc" >&5
7633 echo $ECHO_N "checking for getuid in -lc... $ECHO_C" >&6
7634 if test "${ac_cv_lib_c_getuid+set}" = set; then
7635   echo $ECHO_N "(cached) $ECHO_C" >&6
7636 else
7637   ac_check_lib_save_LIBS=$LIBS
7638 LIBS="-lc  $LIBS"
7639 if test x$gcc_no_link = xyes; then
7640   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7641 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7642    { (exit 1); exit 1; }; }
7643 fi
7644 cat >conftest.$ac_ext <<_ACEOF
7645 /* confdefs.h.  */
7646 _ACEOF
7647 cat confdefs.h >>conftest.$ac_ext
7648 cat >>conftest.$ac_ext <<_ACEOF
7649 /* end confdefs.h.  */
7650
7651 /* Override any gcc2 internal prototype to avoid an error.  */
7652 #ifdef __cplusplus
7653 extern "C"
7654 #endif
7655 /* We use char because int might match the return type of a gcc2
7656    builtin and then its argument prototype would still apply.  */
7657 char getuid ();
7658 int
7659 main ()
7660 {
7661 getuid ();
7662   ;
7663   return 0;
7664 }
7665 _ACEOF
7666 rm -f conftest.$ac_objext conftest$ac_exeext
7667 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7668   (eval $ac_link) 2>conftest.er1
7669   ac_status=$?
7670   grep -v '^ *+' conftest.er1 >conftest.err
7671   rm -f conftest.er1
7672   cat conftest.err >&5
7673   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7674   (exit $ac_status); } &&
7675          { ac_try='test -z "$ac_c_werror_flag"
7676                          || test ! -s conftest.err'
7677   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7678   (eval $ac_try) 2>&5
7679   ac_status=$?
7680   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7681   (exit $ac_status); }; } &&
7682          { ac_try='test -s conftest$ac_exeext'
7683   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7684   (eval $ac_try) 2>&5
7685   ac_status=$?
7686   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7687   (exit $ac_status); }; }; then
7688   ac_cv_lib_c_getuid=yes
7689 else
7690   echo "$as_me: failed program was:" >&5
7691 sed 's/^/| /' conftest.$ac_ext >&5
7692
7693 ac_cv_lib_c_getuid=no
7694 fi
7695 rm -f conftest.err conftest.$ac_objext \
7696       conftest$ac_exeext conftest.$ac_ext
7697 LIBS=$ac_check_lib_save_LIBS
7698 fi
7699 echo "$as_me:$LINENO: result: $ac_cv_lib_c_getuid" >&5
7700 echo "${ECHO_T}$ac_cv_lib_c_getuid" >&6
7701 if test $ac_cv_lib_c_getuid = yes; then
7702
7703 cat >>confdefs.h <<\_ACEOF
7704 #define HAVE_GETUID 1
7705 _ACEOF
7706
7707 fi
7708
7709
7710 # Check for C99 (and other IEEE) math functions
7711 # ??? This list seems awful long. Is there a better way to test for these?
7712 echo "$as_me:$LINENO: checking for acosf in -lm" >&5
7713 echo $ECHO_N "checking for acosf in -lm... $ECHO_C" >&6
7714 if test "${ac_cv_lib_m_acosf+set}" = set; then
7715   echo $ECHO_N "(cached) $ECHO_C" >&6
7716 else
7717   ac_check_lib_save_LIBS=$LIBS
7718 LIBS="-lm  $LIBS"
7719 if test x$gcc_no_link = xyes; then
7720   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7721 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7722    { (exit 1); exit 1; }; }
7723 fi
7724 cat >conftest.$ac_ext <<_ACEOF
7725 /* confdefs.h.  */
7726 _ACEOF
7727 cat confdefs.h >>conftest.$ac_ext
7728 cat >>conftest.$ac_ext <<_ACEOF
7729 /* end confdefs.h.  */
7730
7731 /* Override any gcc2 internal prototype to avoid an error.  */
7732 #ifdef __cplusplus
7733 extern "C"
7734 #endif
7735 /* We use char because int might match the return type of a gcc2
7736    builtin and then its argument prototype would still apply.  */
7737 char acosf ();
7738 int
7739 main ()
7740 {
7741 acosf ();
7742   ;
7743   return 0;
7744 }
7745 _ACEOF
7746 rm -f conftest.$ac_objext conftest$ac_exeext
7747 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7748   (eval $ac_link) 2>conftest.er1
7749   ac_status=$?
7750   grep -v '^ *+' conftest.er1 >conftest.err
7751   rm -f conftest.er1
7752   cat conftest.err >&5
7753   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7754   (exit $ac_status); } &&
7755          { ac_try='test -z "$ac_c_werror_flag"
7756                          || test ! -s conftest.err'
7757   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7758   (eval $ac_try) 2>&5
7759   ac_status=$?
7760   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7761   (exit $ac_status); }; } &&
7762          { ac_try='test -s conftest$ac_exeext'
7763   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7764   (eval $ac_try) 2>&5
7765   ac_status=$?
7766   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7767   (exit $ac_status); }; }; then
7768   ac_cv_lib_m_acosf=yes
7769 else
7770   echo "$as_me: failed program was:" >&5
7771 sed 's/^/| /' conftest.$ac_ext >&5
7772
7773 ac_cv_lib_m_acosf=no
7774 fi
7775 rm -f conftest.err conftest.$ac_objext \
7776       conftest$ac_exeext conftest.$ac_ext
7777 LIBS=$ac_check_lib_save_LIBS
7778 fi
7779 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosf" >&5
7780 echo "${ECHO_T}$ac_cv_lib_m_acosf" >&6
7781 if test $ac_cv_lib_m_acosf = yes; then
7782
7783 cat >>confdefs.h <<\_ACEOF
7784 #define HAVE_ACOSF 1
7785 _ACEOF
7786
7787 fi
7788
7789 echo "$as_me:$LINENO: checking for acos in -lm" >&5
7790 echo $ECHO_N "checking for acos in -lm... $ECHO_C" >&6
7791 if test "${ac_cv_lib_m_acos+set}" = set; then
7792   echo $ECHO_N "(cached) $ECHO_C" >&6
7793 else
7794   ac_check_lib_save_LIBS=$LIBS
7795 LIBS="-lm  $LIBS"
7796 if test x$gcc_no_link = xyes; then
7797   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7798 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7799    { (exit 1); exit 1; }; }
7800 fi
7801 cat >conftest.$ac_ext <<_ACEOF
7802 /* confdefs.h.  */
7803 _ACEOF
7804 cat confdefs.h >>conftest.$ac_ext
7805 cat >>conftest.$ac_ext <<_ACEOF
7806 /* end confdefs.h.  */
7807
7808 /* Override any gcc2 internal prototype to avoid an error.  */
7809 #ifdef __cplusplus
7810 extern "C"
7811 #endif
7812 /* We use char because int might match the return type of a gcc2
7813    builtin and then its argument prototype would still apply.  */
7814 char acos ();
7815 int
7816 main ()
7817 {
7818 acos ();
7819   ;
7820   return 0;
7821 }
7822 _ACEOF
7823 rm -f conftest.$ac_objext conftest$ac_exeext
7824 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7825   (eval $ac_link) 2>conftest.er1
7826   ac_status=$?
7827   grep -v '^ *+' conftest.er1 >conftest.err
7828   rm -f conftest.er1
7829   cat conftest.err >&5
7830   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7831   (exit $ac_status); } &&
7832          { ac_try='test -z "$ac_c_werror_flag"
7833                          || test ! -s conftest.err'
7834   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7835   (eval $ac_try) 2>&5
7836   ac_status=$?
7837   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7838   (exit $ac_status); }; } &&
7839          { ac_try='test -s conftest$ac_exeext'
7840   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7841   (eval $ac_try) 2>&5
7842   ac_status=$?
7843   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7844   (exit $ac_status); }; }; then
7845   ac_cv_lib_m_acos=yes
7846 else
7847   echo "$as_me: failed program was:" >&5
7848 sed 's/^/| /' conftest.$ac_ext >&5
7849
7850 ac_cv_lib_m_acos=no
7851 fi
7852 rm -f conftest.err conftest.$ac_objext \
7853       conftest$ac_exeext conftest.$ac_ext
7854 LIBS=$ac_check_lib_save_LIBS
7855 fi
7856 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acos" >&5
7857 echo "${ECHO_T}$ac_cv_lib_m_acos" >&6
7858 if test $ac_cv_lib_m_acos = yes; then
7859
7860 cat >>confdefs.h <<\_ACEOF
7861 #define HAVE_ACOS 1
7862 _ACEOF
7863
7864 fi
7865
7866 echo "$as_me:$LINENO: checking for acosl in -lm" >&5
7867 echo $ECHO_N "checking for acosl in -lm... $ECHO_C" >&6
7868 if test "${ac_cv_lib_m_acosl+set}" = set; then
7869   echo $ECHO_N "(cached) $ECHO_C" >&6
7870 else
7871   ac_check_lib_save_LIBS=$LIBS
7872 LIBS="-lm  $LIBS"
7873 if test x$gcc_no_link = xyes; then
7874   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7875 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7876    { (exit 1); exit 1; }; }
7877 fi
7878 cat >conftest.$ac_ext <<_ACEOF
7879 /* confdefs.h.  */
7880 _ACEOF
7881 cat confdefs.h >>conftest.$ac_ext
7882 cat >>conftest.$ac_ext <<_ACEOF
7883 /* end confdefs.h.  */
7884
7885 /* Override any gcc2 internal prototype to avoid an error.  */
7886 #ifdef __cplusplus
7887 extern "C"
7888 #endif
7889 /* We use char because int might match the return type of a gcc2
7890    builtin and then its argument prototype would still apply.  */
7891 char acosl ();
7892 int
7893 main ()
7894 {
7895 acosl ();
7896   ;
7897   return 0;
7898 }
7899 _ACEOF
7900 rm -f conftest.$ac_objext conftest$ac_exeext
7901 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7902   (eval $ac_link) 2>conftest.er1
7903   ac_status=$?
7904   grep -v '^ *+' conftest.er1 >conftest.err
7905   rm -f conftest.er1
7906   cat conftest.err >&5
7907   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7908   (exit $ac_status); } &&
7909          { ac_try='test -z "$ac_c_werror_flag"
7910                          || test ! -s conftest.err'
7911   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7912   (eval $ac_try) 2>&5
7913   ac_status=$?
7914   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7915   (exit $ac_status); }; } &&
7916          { ac_try='test -s conftest$ac_exeext'
7917   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7918   (eval $ac_try) 2>&5
7919   ac_status=$?
7920   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7921   (exit $ac_status); }; }; then
7922   ac_cv_lib_m_acosl=yes
7923 else
7924   echo "$as_me: failed program was:" >&5
7925 sed 's/^/| /' conftest.$ac_ext >&5
7926
7927 ac_cv_lib_m_acosl=no
7928 fi
7929 rm -f conftest.err conftest.$ac_objext \
7930       conftest$ac_exeext conftest.$ac_ext
7931 LIBS=$ac_check_lib_save_LIBS
7932 fi
7933 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosl" >&5
7934 echo "${ECHO_T}$ac_cv_lib_m_acosl" >&6
7935 if test $ac_cv_lib_m_acosl = yes; then
7936
7937 cat >>confdefs.h <<\_ACEOF
7938 #define HAVE_ACOSL 1
7939 _ACEOF
7940
7941 fi
7942
7943 echo "$as_me:$LINENO: checking for acoshf in -lm" >&5
7944 echo $ECHO_N "checking for acoshf in -lm... $ECHO_C" >&6
7945 if test "${ac_cv_lib_m_acoshf+set}" = set; then
7946   echo $ECHO_N "(cached) $ECHO_C" >&6
7947 else
7948   ac_check_lib_save_LIBS=$LIBS
7949 LIBS="-lm  $LIBS"
7950 if test x$gcc_no_link = xyes; then
7951   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
7952 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
7953    { (exit 1); exit 1; }; }
7954 fi
7955 cat >conftest.$ac_ext <<_ACEOF
7956 /* confdefs.h.  */
7957 _ACEOF
7958 cat confdefs.h >>conftest.$ac_ext
7959 cat >>conftest.$ac_ext <<_ACEOF
7960 /* end confdefs.h.  */
7961
7962 /* Override any gcc2 internal prototype to avoid an error.  */
7963 #ifdef __cplusplus
7964 extern "C"
7965 #endif
7966 /* We use char because int might match the return type of a gcc2
7967    builtin and then its argument prototype would still apply.  */
7968 char acoshf ();
7969 int
7970 main ()
7971 {
7972 acoshf ();
7973   ;
7974   return 0;
7975 }
7976 _ACEOF
7977 rm -f conftest.$ac_objext conftest$ac_exeext
7978 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7979   (eval $ac_link) 2>conftest.er1
7980   ac_status=$?
7981   grep -v '^ *+' conftest.er1 >conftest.err
7982   rm -f conftest.er1
7983   cat conftest.err >&5
7984   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7985   (exit $ac_status); } &&
7986          { ac_try='test -z "$ac_c_werror_flag"
7987                          || test ! -s conftest.err'
7988   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7989   (eval $ac_try) 2>&5
7990   ac_status=$?
7991   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7992   (exit $ac_status); }; } &&
7993          { ac_try='test -s conftest$ac_exeext'
7994   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7995   (eval $ac_try) 2>&5
7996   ac_status=$?
7997   echo "$as_me:$LINENO: \$? = $ac_status" >&5
7998   (exit $ac_status); }; }; then
7999   ac_cv_lib_m_acoshf=yes
8000 else
8001   echo "$as_me: failed program was:" >&5
8002 sed 's/^/| /' conftest.$ac_ext >&5
8003
8004 ac_cv_lib_m_acoshf=no
8005 fi
8006 rm -f conftest.err conftest.$ac_objext \
8007       conftest$ac_exeext conftest.$ac_ext
8008 LIBS=$ac_check_lib_save_LIBS
8009 fi
8010 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acoshf" >&5
8011 echo "${ECHO_T}$ac_cv_lib_m_acoshf" >&6
8012 if test $ac_cv_lib_m_acoshf = yes; then
8013
8014 cat >>confdefs.h <<\_ACEOF
8015 #define HAVE_ACOSHF 1
8016 _ACEOF
8017
8018 fi
8019
8020 echo "$as_me:$LINENO: checking for acosh in -lm" >&5
8021 echo $ECHO_N "checking for acosh in -lm... $ECHO_C" >&6
8022 if test "${ac_cv_lib_m_acosh+set}" = set; then
8023   echo $ECHO_N "(cached) $ECHO_C" >&6
8024 else
8025   ac_check_lib_save_LIBS=$LIBS
8026 LIBS="-lm  $LIBS"
8027 if test x$gcc_no_link = xyes; then
8028   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8029 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8030    { (exit 1); exit 1; }; }
8031 fi
8032 cat >conftest.$ac_ext <<_ACEOF
8033 /* confdefs.h.  */
8034 _ACEOF
8035 cat confdefs.h >>conftest.$ac_ext
8036 cat >>conftest.$ac_ext <<_ACEOF
8037 /* end confdefs.h.  */
8038
8039 /* Override any gcc2 internal prototype to avoid an error.  */
8040 #ifdef __cplusplus
8041 extern "C"
8042 #endif
8043 /* We use char because int might match the return type of a gcc2
8044    builtin and then its argument prototype would still apply.  */
8045 char acosh ();
8046 int
8047 main ()
8048 {
8049 acosh ();
8050   ;
8051   return 0;
8052 }
8053 _ACEOF
8054 rm -f conftest.$ac_objext conftest$ac_exeext
8055 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8056   (eval $ac_link) 2>conftest.er1
8057   ac_status=$?
8058   grep -v '^ *+' conftest.er1 >conftest.err
8059   rm -f conftest.er1
8060   cat conftest.err >&5
8061   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8062   (exit $ac_status); } &&
8063          { ac_try='test -z "$ac_c_werror_flag"
8064                          || test ! -s conftest.err'
8065   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8066   (eval $ac_try) 2>&5
8067   ac_status=$?
8068   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8069   (exit $ac_status); }; } &&
8070          { ac_try='test -s conftest$ac_exeext'
8071   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8072   (eval $ac_try) 2>&5
8073   ac_status=$?
8074   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8075   (exit $ac_status); }; }; then
8076   ac_cv_lib_m_acosh=yes
8077 else
8078   echo "$as_me: failed program was:" >&5
8079 sed 's/^/| /' conftest.$ac_ext >&5
8080
8081 ac_cv_lib_m_acosh=no
8082 fi
8083 rm -f conftest.err conftest.$ac_objext \
8084       conftest$ac_exeext conftest.$ac_ext
8085 LIBS=$ac_check_lib_save_LIBS
8086 fi
8087 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acosh" >&5
8088 echo "${ECHO_T}$ac_cv_lib_m_acosh" >&6
8089 if test $ac_cv_lib_m_acosh = yes; then
8090
8091 cat >>confdefs.h <<\_ACEOF
8092 #define HAVE_ACOSH 1
8093 _ACEOF
8094
8095 fi
8096
8097 echo "$as_me:$LINENO: checking for acoshl in -lm" >&5
8098 echo $ECHO_N "checking for acoshl in -lm... $ECHO_C" >&6
8099 if test "${ac_cv_lib_m_acoshl+set}" = set; then
8100   echo $ECHO_N "(cached) $ECHO_C" >&6
8101 else
8102   ac_check_lib_save_LIBS=$LIBS
8103 LIBS="-lm  $LIBS"
8104 if test x$gcc_no_link = xyes; then
8105   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8106 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8107    { (exit 1); exit 1; }; }
8108 fi
8109 cat >conftest.$ac_ext <<_ACEOF
8110 /* confdefs.h.  */
8111 _ACEOF
8112 cat confdefs.h >>conftest.$ac_ext
8113 cat >>conftest.$ac_ext <<_ACEOF
8114 /* end confdefs.h.  */
8115
8116 /* Override any gcc2 internal prototype to avoid an error.  */
8117 #ifdef __cplusplus
8118 extern "C"
8119 #endif
8120 /* We use char because int might match the return type of a gcc2
8121    builtin and then its argument prototype would still apply.  */
8122 char acoshl ();
8123 int
8124 main ()
8125 {
8126 acoshl ();
8127   ;
8128   return 0;
8129 }
8130 _ACEOF
8131 rm -f conftest.$ac_objext conftest$ac_exeext
8132 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8133   (eval $ac_link) 2>conftest.er1
8134   ac_status=$?
8135   grep -v '^ *+' conftest.er1 >conftest.err
8136   rm -f conftest.er1
8137   cat conftest.err >&5
8138   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8139   (exit $ac_status); } &&
8140          { ac_try='test -z "$ac_c_werror_flag"
8141                          || test ! -s conftest.err'
8142   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8143   (eval $ac_try) 2>&5
8144   ac_status=$?
8145   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8146   (exit $ac_status); }; } &&
8147          { ac_try='test -s conftest$ac_exeext'
8148   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8149   (eval $ac_try) 2>&5
8150   ac_status=$?
8151   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8152   (exit $ac_status); }; }; then
8153   ac_cv_lib_m_acoshl=yes
8154 else
8155   echo "$as_me: failed program was:" >&5
8156 sed 's/^/| /' conftest.$ac_ext >&5
8157
8158 ac_cv_lib_m_acoshl=no
8159 fi
8160 rm -f conftest.err conftest.$ac_objext \
8161       conftest$ac_exeext conftest.$ac_ext
8162 LIBS=$ac_check_lib_save_LIBS
8163 fi
8164 echo "$as_me:$LINENO: result: $ac_cv_lib_m_acoshl" >&5
8165 echo "${ECHO_T}$ac_cv_lib_m_acoshl" >&6
8166 if test $ac_cv_lib_m_acoshl = yes; then
8167
8168 cat >>confdefs.h <<\_ACEOF
8169 #define HAVE_ACOSHL 1
8170 _ACEOF
8171
8172 fi
8173
8174 echo "$as_me:$LINENO: checking for asinf in -lm" >&5
8175 echo $ECHO_N "checking for asinf in -lm... $ECHO_C" >&6
8176 if test "${ac_cv_lib_m_asinf+set}" = set; then
8177   echo $ECHO_N "(cached) $ECHO_C" >&6
8178 else
8179   ac_check_lib_save_LIBS=$LIBS
8180 LIBS="-lm  $LIBS"
8181 if test x$gcc_no_link = xyes; then
8182   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8183 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8184    { (exit 1); exit 1; }; }
8185 fi
8186 cat >conftest.$ac_ext <<_ACEOF
8187 /* confdefs.h.  */
8188 _ACEOF
8189 cat confdefs.h >>conftest.$ac_ext
8190 cat >>conftest.$ac_ext <<_ACEOF
8191 /* end confdefs.h.  */
8192
8193 /* Override any gcc2 internal prototype to avoid an error.  */
8194 #ifdef __cplusplus
8195 extern "C"
8196 #endif
8197 /* We use char because int might match the return type of a gcc2
8198    builtin and then its argument prototype would still apply.  */
8199 char asinf ();
8200 int
8201 main ()
8202 {
8203 asinf ();
8204   ;
8205   return 0;
8206 }
8207 _ACEOF
8208 rm -f conftest.$ac_objext conftest$ac_exeext
8209 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8210   (eval $ac_link) 2>conftest.er1
8211   ac_status=$?
8212   grep -v '^ *+' conftest.er1 >conftest.err
8213   rm -f conftest.er1
8214   cat conftest.err >&5
8215   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8216   (exit $ac_status); } &&
8217          { ac_try='test -z "$ac_c_werror_flag"
8218                          || test ! -s conftest.err'
8219   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8220   (eval $ac_try) 2>&5
8221   ac_status=$?
8222   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8223   (exit $ac_status); }; } &&
8224          { ac_try='test -s conftest$ac_exeext'
8225   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8226   (eval $ac_try) 2>&5
8227   ac_status=$?
8228   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8229   (exit $ac_status); }; }; then
8230   ac_cv_lib_m_asinf=yes
8231 else
8232   echo "$as_me: failed program was:" >&5
8233 sed 's/^/| /' conftest.$ac_ext >&5
8234
8235 ac_cv_lib_m_asinf=no
8236 fi
8237 rm -f conftest.err conftest.$ac_objext \
8238       conftest$ac_exeext conftest.$ac_ext
8239 LIBS=$ac_check_lib_save_LIBS
8240 fi
8241 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinf" >&5
8242 echo "${ECHO_T}$ac_cv_lib_m_asinf" >&6
8243 if test $ac_cv_lib_m_asinf = yes; then
8244
8245 cat >>confdefs.h <<\_ACEOF
8246 #define HAVE_ASINF 1
8247 _ACEOF
8248
8249 fi
8250
8251 echo "$as_me:$LINENO: checking for asin in -lm" >&5
8252 echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
8253 if test "${ac_cv_lib_m_asin+set}" = set; then
8254   echo $ECHO_N "(cached) $ECHO_C" >&6
8255 else
8256   ac_check_lib_save_LIBS=$LIBS
8257 LIBS="-lm  $LIBS"
8258 if test x$gcc_no_link = xyes; then
8259   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8260 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8261    { (exit 1); exit 1; }; }
8262 fi
8263 cat >conftest.$ac_ext <<_ACEOF
8264 /* confdefs.h.  */
8265 _ACEOF
8266 cat confdefs.h >>conftest.$ac_ext
8267 cat >>conftest.$ac_ext <<_ACEOF
8268 /* end confdefs.h.  */
8269
8270 /* Override any gcc2 internal prototype to avoid an error.  */
8271 #ifdef __cplusplus
8272 extern "C"
8273 #endif
8274 /* We use char because int might match the return type of a gcc2
8275    builtin and then its argument prototype would still apply.  */
8276 char asin ();
8277 int
8278 main ()
8279 {
8280 asin ();
8281   ;
8282   return 0;
8283 }
8284 _ACEOF
8285 rm -f conftest.$ac_objext conftest$ac_exeext
8286 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8287   (eval $ac_link) 2>conftest.er1
8288   ac_status=$?
8289   grep -v '^ *+' conftest.er1 >conftest.err
8290   rm -f conftest.er1
8291   cat conftest.err >&5
8292   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8293   (exit $ac_status); } &&
8294          { ac_try='test -z "$ac_c_werror_flag"
8295                          || test ! -s conftest.err'
8296   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8297   (eval $ac_try) 2>&5
8298   ac_status=$?
8299   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8300   (exit $ac_status); }; } &&
8301          { ac_try='test -s conftest$ac_exeext'
8302   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8303   (eval $ac_try) 2>&5
8304   ac_status=$?
8305   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8306   (exit $ac_status); }; }; then
8307   ac_cv_lib_m_asin=yes
8308 else
8309   echo "$as_me: failed program was:" >&5
8310 sed 's/^/| /' conftest.$ac_ext >&5
8311
8312 ac_cv_lib_m_asin=no
8313 fi
8314 rm -f conftest.err conftest.$ac_objext \
8315       conftest$ac_exeext conftest.$ac_ext
8316 LIBS=$ac_check_lib_save_LIBS
8317 fi
8318 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
8319 echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
8320 if test $ac_cv_lib_m_asin = yes; then
8321
8322 cat >>confdefs.h <<\_ACEOF
8323 #define HAVE_ASIN 1
8324 _ACEOF
8325
8326 fi
8327
8328 echo "$as_me:$LINENO: checking for asinl in -lm" >&5
8329 echo $ECHO_N "checking for asinl in -lm... $ECHO_C" >&6
8330 if test "${ac_cv_lib_m_asinl+set}" = set; then
8331   echo $ECHO_N "(cached) $ECHO_C" >&6
8332 else
8333   ac_check_lib_save_LIBS=$LIBS
8334 LIBS="-lm  $LIBS"
8335 if test x$gcc_no_link = xyes; then
8336   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8337 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8338    { (exit 1); exit 1; }; }
8339 fi
8340 cat >conftest.$ac_ext <<_ACEOF
8341 /* confdefs.h.  */
8342 _ACEOF
8343 cat confdefs.h >>conftest.$ac_ext
8344 cat >>conftest.$ac_ext <<_ACEOF
8345 /* end confdefs.h.  */
8346
8347 /* Override any gcc2 internal prototype to avoid an error.  */
8348 #ifdef __cplusplus
8349 extern "C"
8350 #endif
8351 /* We use char because int might match the return type of a gcc2
8352    builtin and then its argument prototype would still apply.  */
8353 char asinl ();
8354 int
8355 main ()
8356 {
8357 asinl ();
8358   ;
8359   return 0;
8360 }
8361 _ACEOF
8362 rm -f conftest.$ac_objext conftest$ac_exeext
8363 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8364   (eval $ac_link) 2>conftest.er1
8365   ac_status=$?
8366   grep -v '^ *+' conftest.er1 >conftest.err
8367   rm -f conftest.er1
8368   cat conftest.err >&5
8369   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8370   (exit $ac_status); } &&
8371          { ac_try='test -z "$ac_c_werror_flag"
8372                          || test ! -s conftest.err'
8373   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8374   (eval $ac_try) 2>&5
8375   ac_status=$?
8376   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8377   (exit $ac_status); }; } &&
8378          { ac_try='test -s conftest$ac_exeext'
8379   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8380   (eval $ac_try) 2>&5
8381   ac_status=$?
8382   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8383   (exit $ac_status); }; }; then
8384   ac_cv_lib_m_asinl=yes
8385 else
8386   echo "$as_me: failed program was:" >&5
8387 sed 's/^/| /' conftest.$ac_ext >&5
8388
8389 ac_cv_lib_m_asinl=no
8390 fi
8391 rm -f conftest.err conftest.$ac_objext \
8392       conftest$ac_exeext conftest.$ac_ext
8393 LIBS=$ac_check_lib_save_LIBS
8394 fi
8395 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinl" >&5
8396 echo "${ECHO_T}$ac_cv_lib_m_asinl" >&6
8397 if test $ac_cv_lib_m_asinl = yes; then
8398
8399 cat >>confdefs.h <<\_ACEOF
8400 #define HAVE_ASINL 1
8401 _ACEOF
8402
8403 fi
8404
8405 echo "$as_me:$LINENO: checking for asinhf in -lm" >&5
8406 echo $ECHO_N "checking for asinhf in -lm... $ECHO_C" >&6
8407 if test "${ac_cv_lib_m_asinhf+set}" = set; then
8408   echo $ECHO_N "(cached) $ECHO_C" >&6
8409 else
8410   ac_check_lib_save_LIBS=$LIBS
8411 LIBS="-lm  $LIBS"
8412 if test x$gcc_no_link = xyes; then
8413   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8414 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8415    { (exit 1); exit 1; }; }
8416 fi
8417 cat >conftest.$ac_ext <<_ACEOF
8418 /* confdefs.h.  */
8419 _ACEOF
8420 cat confdefs.h >>conftest.$ac_ext
8421 cat >>conftest.$ac_ext <<_ACEOF
8422 /* end confdefs.h.  */
8423
8424 /* Override any gcc2 internal prototype to avoid an error.  */
8425 #ifdef __cplusplus
8426 extern "C"
8427 #endif
8428 /* We use char because int might match the return type of a gcc2
8429    builtin and then its argument prototype would still apply.  */
8430 char asinhf ();
8431 int
8432 main ()
8433 {
8434 asinhf ();
8435   ;
8436   return 0;
8437 }
8438 _ACEOF
8439 rm -f conftest.$ac_objext conftest$ac_exeext
8440 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8441   (eval $ac_link) 2>conftest.er1
8442   ac_status=$?
8443   grep -v '^ *+' conftest.er1 >conftest.err
8444   rm -f conftest.er1
8445   cat conftest.err >&5
8446   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8447   (exit $ac_status); } &&
8448          { ac_try='test -z "$ac_c_werror_flag"
8449                          || test ! -s conftest.err'
8450   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8451   (eval $ac_try) 2>&5
8452   ac_status=$?
8453   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8454   (exit $ac_status); }; } &&
8455          { ac_try='test -s conftest$ac_exeext'
8456   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8457   (eval $ac_try) 2>&5
8458   ac_status=$?
8459   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8460   (exit $ac_status); }; }; then
8461   ac_cv_lib_m_asinhf=yes
8462 else
8463   echo "$as_me: failed program was:" >&5
8464 sed 's/^/| /' conftest.$ac_ext >&5
8465
8466 ac_cv_lib_m_asinhf=no
8467 fi
8468 rm -f conftest.err conftest.$ac_objext \
8469       conftest$ac_exeext conftest.$ac_ext
8470 LIBS=$ac_check_lib_save_LIBS
8471 fi
8472 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinhf" >&5
8473 echo "${ECHO_T}$ac_cv_lib_m_asinhf" >&6
8474 if test $ac_cv_lib_m_asinhf = yes; then
8475
8476 cat >>confdefs.h <<\_ACEOF
8477 #define HAVE_ASINHF 1
8478 _ACEOF
8479
8480 fi
8481
8482 echo "$as_me:$LINENO: checking for asinh in -lm" >&5
8483 echo $ECHO_N "checking for asinh in -lm... $ECHO_C" >&6
8484 if test "${ac_cv_lib_m_asinh+set}" = set; then
8485   echo $ECHO_N "(cached) $ECHO_C" >&6
8486 else
8487   ac_check_lib_save_LIBS=$LIBS
8488 LIBS="-lm  $LIBS"
8489 if test x$gcc_no_link = xyes; then
8490   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8491 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8492    { (exit 1); exit 1; }; }
8493 fi
8494 cat >conftest.$ac_ext <<_ACEOF
8495 /* confdefs.h.  */
8496 _ACEOF
8497 cat confdefs.h >>conftest.$ac_ext
8498 cat >>conftest.$ac_ext <<_ACEOF
8499 /* end confdefs.h.  */
8500
8501 /* Override any gcc2 internal prototype to avoid an error.  */
8502 #ifdef __cplusplus
8503 extern "C"
8504 #endif
8505 /* We use char because int might match the return type of a gcc2
8506    builtin and then its argument prototype would still apply.  */
8507 char asinh ();
8508 int
8509 main ()
8510 {
8511 asinh ();
8512   ;
8513   return 0;
8514 }
8515 _ACEOF
8516 rm -f conftest.$ac_objext conftest$ac_exeext
8517 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8518   (eval $ac_link) 2>conftest.er1
8519   ac_status=$?
8520   grep -v '^ *+' conftest.er1 >conftest.err
8521   rm -f conftest.er1
8522   cat conftest.err >&5
8523   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8524   (exit $ac_status); } &&
8525          { ac_try='test -z "$ac_c_werror_flag"
8526                          || test ! -s conftest.err'
8527   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8528   (eval $ac_try) 2>&5
8529   ac_status=$?
8530   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8531   (exit $ac_status); }; } &&
8532          { ac_try='test -s conftest$ac_exeext'
8533   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8534   (eval $ac_try) 2>&5
8535   ac_status=$?
8536   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8537   (exit $ac_status); }; }; then
8538   ac_cv_lib_m_asinh=yes
8539 else
8540   echo "$as_me: failed program was:" >&5
8541 sed 's/^/| /' conftest.$ac_ext >&5
8542
8543 ac_cv_lib_m_asinh=no
8544 fi
8545 rm -f conftest.err conftest.$ac_objext \
8546       conftest$ac_exeext conftest.$ac_ext
8547 LIBS=$ac_check_lib_save_LIBS
8548 fi
8549 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinh" >&5
8550 echo "${ECHO_T}$ac_cv_lib_m_asinh" >&6
8551 if test $ac_cv_lib_m_asinh = yes; then
8552
8553 cat >>confdefs.h <<\_ACEOF
8554 #define HAVE_ASINH 1
8555 _ACEOF
8556
8557 fi
8558
8559 echo "$as_me:$LINENO: checking for asinhl in -lm" >&5
8560 echo $ECHO_N "checking for asinhl in -lm... $ECHO_C" >&6
8561 if test "${ac_cv_lib_m_asinhl+set}" = set; then
8562   echo $ECHO_N "(cached) $ECHO_C" >&6
8563 else
8564   ac_check_lib_save_LIBS=$LIBS
8565 LIBS="-lm  $LIBS"
8566 if test x$gcc_no_link = xyes; then
8567   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8568 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8569    { (exit 1); exit 1; }; }
8570 fi
8571 cat >conftest.$ac_ext <<_ACEOF
8572 /* confdefs.h.  */
8573 _ACEOF
8574 cat confdefs.h >>conftest.$ac_ext
8575 cat >>conftest.$ac_ext <<_ACEOF
8576 /* end confdefs.h.  */
8577
8578 /* Override any gcc2 internal prototype to avoid an error.  */
8579 #ifdef __cplusplus
8580 extern "C"
8581 #endif
8582 /* We use char because int might match the return type of a gcc2
8583    builtin and then its argument prototype would still apply.  */
8584 char asinhl ();
8585 int
8586 main ()
8587 {
8588 asinhl ();
8589   ;
8590   return 0;
8591 }
8592 _ACEOF
8593 rm -f conftest.$ac_objext conftest$ac_exeext
8594 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8595   (eval $ac_link) 2>conftest.er1
8596   ac_status=$?
8597   grep -v '^ *+' conftest.er1 >conftest.err
8598   rm -f conftest.er1
8599   cat conftest.err >&5
8600   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8601   (exit $ac_status); } &&
8602          { ac_try='test -z "$ac_c_werror_flag"
8603                          || test ! -s conftest.err'
8604   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8605   (eval $ac_try) 2>&5
8606   ac_status=$?
8607   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8608   (exit $ac_status); }; } &&
8609          { ac_try='test -s conftest$ac_exeext'
8610   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8611   (eval $ac_try) 2>&5
8612   ac_status=$?
8613   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8614   (exit $ac_status); }; }; then
8615   ac_cv_lib_m_asinhl=yes
8616 else
8617   echo "$as_me: failed program was:" >&5
8618 sed 's/^/| /' conftest.$ac_ext >&5
8619
8620 ac_cv_lib_m_asinhl=no
8621 fi
8622 rm -f conftest.err conftest.$ac_objext \
8623       conftest$ac_exeext conftest.$ac_ext
8624 LIBS=$ac_check_lib_save_LIBS
8625 fi
8626 echo "$as_me:$LINENO: result: $ac_cv_lib_m_asinhl" >&5
8627 echo "${ECHO_T}$ac_cv_lib_m_asinhl" >&6
8628 if test $ac_cv_lib_m_asinhl = yes; then
8629
8630 cat >>confdefs.h <<\_ACEOF
8631 #define HAVE_ASINHL 1
8632 _ACEOF
8633
8634 fi
8635
8636 echo "$as_me:$LINENO: checking for atan2f in -lm" >&5
8637 echo $ECHO_N "checking for atan2f in -lm... $ECHO_C" >&6
8638 if test "${ac_cv_lib_m_atan2f+set}" = set; then
8639   echo $ECHO_N "(cached) $ECHO_C" >&6
8640 else
8641   ac_check_lib_save_LIBS=$LIBS
8642 LIBS="-lm  $LIBS"
8643 if test x$gcc_no_link = xyes; then
8644   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8645 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8646    { (exit 1); exit 1; }; }
8647 fi
8648 cat >conftest.$ac_ext <<_ACEOF
8649 /* confdefs.h.  */
8650 _ACEOF
8651 cat confdefs.h >>conftest.$ac_ext
8652 cat >>conftest.$ac_ext <<_ACEOF
8653 /* end confdefs.h.  */
8654
8655 /* Override any gcc2 internal prototype to avoid an error.  */
8656 #ifdef __cplusplus
8657 extern "C"
8658 #endif
8659 /* We use char because int might match the return type of a gcc2
8660    builtin and then its argument prototype would still apply.  */
8661 char atan2f ();
8662 int
8663 main ()
8664 {
8665 atan2f ();
8666   ;
8667   return 0;
8668 }
8669 _ACEOF
8670 rm -f conftest.$ac_objext conftest$ac_exeext
8671 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8672   (eval $ac_link) 2>conftest.er1
8673   ac_status=$?
8674   grep -v '^ *+' conftest.er1 >conftest.err
8675   rm -f conftest.er1
8676   cat conftest.err >&5
8677   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8678   (exit $ac_status); } &&
8679          { ac_try='test -z "$ac_c_werror_flag"
8680                          || test ! -s conftest.err'
8681   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8682   (eval $ac_try) 2>&5
8683   ac_status=$?
8684   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8685   (exit $ac_status); }; } &&
8686          { ac_try='test -s conftest$ac_exeext'
8687   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8688   (eval $ac_try) 2>&5
8689   ac_status=$?
8690   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8691   (exit $ac_status); }; }; then
8692   ac_cv_lib_m_atan2f=yes
8693 else
8694   echo "$as_me: failed program was:" >&5
8695 sed 's/^/| /' conftest.$ac_ext >&5
8696
8697 ac_cv_lib_m_atan2f=no
8698 fi
8699 rm -f conftest.err conftest.$ac_objext \
8700       conftest$ac_exeext conftest.$ac_ext
8701 LIBS=$ac_check_lib_save_LIBS
8702 fi
8703 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2f" >&5
8704 echo "${ECHO_T}$ac_cv_lib_m_atan2f" >&6
8705 if test $ac_cv_lib_m_atan2f = yes; then
8706
8707 cat >>confdefs.h <<\_ACEOF
8708 #define HAVE_ATAN2F 1
8709 _ACEOF
8710
8711 fi
8712
8713 echo "$as_me:$LINENO: checking for atan2 in -lm" >&5
8714 echo $ECHO_N "checking for atan2 in -lm... $ECHO_C" >&6
8715 if test "${ac_cv_lib_m_atan2+set}" = set; then
8716   echo $ECHO_N "(cached) $ECHO_C" >&6
8717 else
8718   ac_check_lib_save_LIBS=$LIBS
8719 LIBS="-lm  $LIBS"
8720 if test x$gcc_no_link = xyes; then
8721   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8722 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8723    { (exit 1); exit 1; }; }
8724 fi
8725 cat >conftest.$ac_ext <<_ACEOF
8726 /* confdefs.h.  */
8727 _ACEOF
8728 cat confdefs.h >>conftest.$ac_ext
8729 cat >>conftest.$ac_ext <<_ACEOF
8730 /* end confdefs.h.  */
8731
8732 /* Override any gcc2 internal prototype to avoid an error.  */
8733 #ifdef __cplusplus
8734 extern "C"
8735 #endif
8736 /* We use char because int might match the return type of a gcc2
8737    builtin and then its argument prototype would still apply.  */
8738 char atan2 ();
8739 int
8740 main ()
8741 {
8742 atan2 ();
8743   ;
8744   return 0;
8745 }
8746 _ACEOF
8747 rm -f conftest.$ac_objext conftest$ac_exeext
8748 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8749   (eval $ac_link) 2>conftest.er1
8750   ac_status=$?
8751   grep -v '^ *+' conftest.er1 >conftest.err
8752   rm -f conftest.er1
8753   cat conftest.err >&5
8754   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8755   (exit $ac_status); } &&
8756          { ac_try='test -z "$ac_c_werror_flag"
8757                          || test ! -s conftest.err'
8758   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8759   (eval $ac_try) 2>&5
8760   ac_status=$?
8761   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8762   (exit $ac_status); }; } &&
8763          { ac_try='test -s conftest$ac_exeext'
8764   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8765   (eval $ac_try) 2>&5
8766   ac_status=$?
8767   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8768   (exit $ac_status); }; }; then
8769   ac_cv_lib_m_atan2=yes
8770 else
8771   echo "$as_me: failed program was:" >&5
8772 sed 's/^/| /' conftest.$ac_ext >&5
8773
8774 ac_cv_lib_m_atan2=no
8775 fi
8776 rm -f conftest.err conftest.$ac_objext \
8777       conftest$ac_exeext conftest.$ac_ext
8778 LIBS=$ac_check_lib_save_LIBS
8779 fi
8780 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2" >&5
8781 echo "${ECHO_T}$ac_cv_lib_m_atan2" >&6
8782 if test $ac_cv_lib_m_atan2 = yes; then
8783
8784 cat >>confdefs.h <<\_ACEOF
8785 #define HAVE_ATAN2 1
8786 _ACEOF
8787
8788 fi
8789
8790 echo "$as_me:$LINENO: checking for atan2l in -lm" >&5
8791 echo $ECHO_N "checking for atan2l in -lm... $ECHO_C" >&6
8792 if test "${ac_cv_lib_m_atan2l+set}" = set; then
8793   echo $ECHO_N "(cached) $ECHO_C" >&6
8794 else
8795   ac_check_lib_save_LIBS=$LIBS
8796 LIBS="-lm  $LIBS"
8797 if test x$gcc_no_link = xyes; then
8798   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8799 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8800    { (exit 1); exit 1; }; }
8801 fi
8802 cat >conftest.$ac_ext <<_ACEOF
8803 /* confdefs.h.  */
8804 _ACEOF
8805 cat confdefs.h >>conftest.$ac_ext
8806 cat >>conftest.$ac_ext <<_ACEOF
8807 /* end confdefs.h.  */
8808
8809 /* Override any gcc2 internal prototype to avoid an error.  */
8810 #ifdef __cplusplus
8811 extern "C"
8812 #endif
8813 /* We use char because int might match the return type of a gcc2
8814    builtin and then its argument prototype would still apply.  */
8815 char atan2l ();
8816 int
8817 main ()
8818 {
8819 atan2l ();
8820   ;
8821   return 0;
8822 }
8823 _ACEOF
8824 rm -f conftest.$ac_objext conftest$ac_exeext
8825 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8826   (eval $ac_link) 2>conftest.er1
8827   ac_status=$?
8828   grep -v '^ *+' conftest.er1 >conftest.err
8829   rm -f conftest.er1
8830   cat conftest.err >&5
8831   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8832   (exit $ac_status); } &&
8833          { ac_try='test -z "$ac_c_werror_flag"
8834                          || test ! -s conftest.err'
8835   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8836   (eval $ac_try) 2>&5
8837   ac_status=$?
8838   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8839   (exit $ac_status); }; } &&
8840          { ac_try='test -s conftest$ac_exeext'
8841   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8842   (eval $ac_try) 2>&5
8843   ac_status=$?
8844   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8845   (exit $ac_status); }; }; then
8846   ac_cv_lib_m_atan2l=yes
8847 else
8848   echo "$as_me: failed program was:" >&5
8849 sed 's/^/| /' conftest.$ac_ext >&5
8850
8851 ac_cv_lib_m_atan2l=no
8852 fi
8853 rm -f conftest.err conftest.$ac_objext \
8854       conftest$ac_exeext conftest.$ac_ext
8855 LIBS=$ac_check_lib_save_LIBS
8856 fi
8857 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan2l" >&5
8858 echo "${ECHO_T}$ac_cv_lib_m_atan2l" >&6
8859 if test $ac_cv_lib_m_atan2l = yes; then
8860
8861 cat >>confdefs.h <<\_ACEOF
8862 #define HAVE_ATAN2L 1
8863 _ACEOF
8864
8865 fi
8866
8867 echo "$as_me:$LINENO: checking for atanf in -lm" >&5
8868 echo $ECHO_N "checking for atanf in -lm... $ECHO_C" >&6
8869 if test "${ac_cv_lib_m_atanf+set}" = set; then
8870   echo $ECHO_N "(cached) $ECHO_C" >&6
8871 else
8872   ac_check_lib_save_LIBS=$LIBS
8873 LIBS="-lm  $LIBS"
8874 if test x$gcc_no_link = xyes; then
8875   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8876 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8877    { (exit 1); exit 1; }; }
8878 fi
8879 cat >conftest.$ac_ext <<_ACEOF
8880 /* confdefs.h.  */
8881 _ACEOF
8882 cat confdefs.h >>conftest.$ac_ext
8883 cat >>conftest.$ac_ext <<_ACEOF
8884 /* end confdefs.h.  */
8885
8886 /* Override any gcc2 internal prototype to avoid an error.  */
8887 #ifdef __cplusplus
8888 extern "C"
8889 #endif
8890 /* We use char because int might match the return type of a gcc2
8891    builtin and then its argument prototype would still apply.  */
8892 char atanf ();
8893 int
8894 main ()
8895 {
8896 atanf ();
8897   ;
8898   return 0;
8899 }
8900 _ACEOF
8901 rm -f conftest.$ac_objext conftest$ac_exeext
8902 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8903   (eval $ac_link) 2>conftest.er1
8904   ac_status=$?
8905   grep -v '^ *+' conftest.er1 >conftest.err
8906   rm -f conftest.er1
8907   cat conftest.err >&5
8908   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8909   (exit $ac_status); } &&
8910          { ac_try='test -z "$ac_c_werror_flag"
8911                          || test ! -s conftest.err'
8912   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8913   (eval $ac_try) 2>&5
8914   ac_status=$?
8915   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8916   (exit $ac_status); }; } &&
8917          { ac_try='test -s conftest$ac_exeext'
8918   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8919   (eval $ac_try) 2>&5
8920   ac_status=$?
8921   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8922   (exit $ac_status); }; }; then
8923   ac_cv_lib_m_atanf=yes
8924 else
8925   echo "$as_me: failed program was:" >&5
8926 sed 's/^/| /' conftest.$ac_ext >&5
8927
8928 ac_cv_lib_m_atanf=no
8929 fi
8930 rm -f conftest.err conftest.$ac_objext \
8931       conftest$ac_exeext conftest.$ac_ext
8932 LIBS=$ac_check_lib_save_LIBS
8933 fi
8934 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanf" >&5
8935 echo "${ECHO_T}$ac_cv_lib_m_atanf" >&6
8936 if test $ac_cv_lib_m_atanf = yes; then
8937
8938 cat >>confdefs.h <<\_ACEOF
8939 #define HAVE_ATANF 1
8940 _ACEOF
8941
8942 fi
8943
8944 echo "$as_me:$LINENO: checking for atan in -lm" >&5
8945 echo $ECHO_N "checking for atan in -lm... $ECHO_C" >&6
8946 if test "${ac_cv_lib_m_atan+set}" = set; then
8947   echo $ECHO_N "(cached) $ECHO_C" >&6
8948 else
8949   ac_check_lib_save_LIBS=$LIBS
8950 LIBS="-lm  $LIBS"
8951 if test x$gcc_no_link = xyes; then
8952   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
8953 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
8954    { (exit 1); exit 1; }; }
8955 fi
8956 cat >conftest.$ac_ext <<_ACEOF
8957 /* confdefs.h.  */
8958 _ACEOF
8959 cat confdefs.h >>conftest.$ac_ext
8960 cat >>conftest.$ac_ext <<_ACEOF
8961 /* end confdefs.h.  */
8962
8963 /* Override any gcc2 internal prototype to avoid an error.  */
8964 #ifdef __cplusplus
8965 extern "C"
8966 #endif
8967 /* We use char because int might match the return type of a gcc2
8968    builtin and then its argument prototype would still apply.  */
8969 char atan ();
8970 int
8971 main ()
8972 {
8973 atan ();
8974   ;
8975   return 0;
8976 }
8977 _ACEOF
8978 rm -f conftest.$ac_objext conftest$ac_exeext
8979 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8980   (eval $ac_link) 2>conftest.er1
8981   ac_status=$?
8982   grep -v '^ *+' conftest.er1 >conftest.err
8983   rm -f conftest.er1
8984   cat conftest.err >&5
8985   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8986   (exit $ac_status); } &&
8987          { ac_try='test -z "$ac_c_werror_flag"
8988                          || test ! -s conftest.err'
8989   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8990   (eval $ac_try) 2>&5
8991   ac_status=$?
8992   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8993   (exit $ac_status); }; } &&
8994          { ac_try='test -s conftest$ac_exeext'
8995   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8996   (eval $ac_try) 2>&5
8997   ac_status=$?
8998   echo "$as_me:$LINENO: \$? = $ac_status" >&5
8999   (exit $ac_status); }; }; then
9000   ac_cv_lib_m_atan=yes
9001 else
9002   echo "$as_me: failed program was:" >&5
9003 sed 's/^/| /' conftest.$ac_ext >&5
9004
9005 ac_cv_lib_m_atan=no
9006 fi
9007 rm -f conftest.err conftest.$ac_objext \
9008       conftest$ac_exeext conftest.$ac_ext
9009 LIBS=$ac_check_lib_save_LIBS
9010 fi
9011 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atan" >&5
9012 echo "${ECHO_T}$ac_cv_lib_m_atan" >&6
9013 if test $ac_cv_lib_m_atan = yes; then
9014
9015 cat >>confdefs.h <<\_ACEOF
9016 #define HAVE_ATAN 1
9017 _ACEOF
9018
9019 fi
9020
9021 echo "$as_me:$LINENO: checking for atanl in -lm" >&5
9022 echo $ECHO_N "checking for atanl in -lm... $ECHO_C" >&6
9023 if test "${ac_cv_lib_m_atanl+set}" = set; then
9024   echo $ECHO_N "(cached) $ECHO_C" >&6
9025 else
9026   ac_check_lib_save_LIBS=$LIBS
9027 LIBS="-lm  $LIBS"
9028 if test x$gcc_no_link = xyes; then
9029   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9030 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9031    { (exit 1); exit 1; }; }
9032 fi
9033 cat >conftest.$ac_ext <<_ACEOF
9034 /* confdefs.h.  */
9035 _ACEOF
9036 cat confdefs.h >>conftest.$ac_ext
9037 cat >>conftest.$ac_ext <<_ACEOF
9038 /* end confdefs.h.  */
9039
9040 /* Override any gcc2 internal prototype to avoid an error.  */
9041 #ifdef __cplusplus
9042 extern "C"
9043 #endif
9044 /* We use char because int might match the return type of a gcc2
9045    builtin and then its argument prototype would still apply.  */
9046 char atanl ();
9047 int
9048 main ()
9049 {
9050 atanl ();
9051   ;
9052   return 0;
9053 }
9054 _ACEOF
9055 rm -f conftest.$ac_objext conftest$ac_exeext
9056 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9057   (eval $ac_link) 2>conftest.er1
9058   ac_status=$?
9059   grep -v '^ *+' conftest.er1 >conftest.err
9060   rm -f conftest.er1
9061   cat conftest.err >&5
9062   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9063   (exit $ac_status); } &&
9064          { ac_try='test -z "$ac_c_werror_flag"
9065                          || test ! -s conftest.err'
9066   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9067   (eval $ac_try) 2>&5
9068   ac_status=$?
9069   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9070   (exit $ac_status); }; } &&
9071          { ac_try='test -s conftest$ac_exeext'
9072   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9073   (eval $ac_try) 2>&5
9074   ac_status=$?
9075   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9076   (exit $ac_status); }; }; then
9077   ac_cv_lib_m_atanl=yes
9078 else
9079   echo "$as_me: failed program was:" >&5
9080 sed 's/^/| /' conftest.$ac_ext >&5
9081
9082 ac_cv_lib_m_atanl=no
9083 fi
9084 rm -f conftest.err conftest.$ac_objext \
9085       conftest$ac_exeext conftest.$ac_ext
9086 LIBS=$ac_check_lib_save_LIBS
9087 fi
9088 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanl" >&5
9089 echo "${ECHO_T}$ac_cv_lib_m_atanl" >&6
9090 if test $ac_cv_lib_m_atanl = yes; then
9091
9092 cat >>confdefs.h <<\_ACEOF
9093 #define HAVE_ATANL 1
9094 _ACEOF
9095
9096 fi
9097
9098 echo "$as_me:$LINENO: checking for atanhf in -lm" >&5
9099 echo $ECHO_N "checking for atanhf in -lm... $ECHO_C" >&6
9100 if test "${ac_cv_lib_m_atanhf+set}" = set; then
9101   echo $ECHO_N "(cached) $ECHO_C" >&6
9102 else
9103   ac_check_lib_save_LIBS=$LIBS
9104 LIBS="-lm  $LIBS"
9105 if test x$gcc_no_link = xyes; then
9106   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9107 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9108    { (exit 1); exit 1; }; }
9109 fi
9110 cat >conftest.$ac_ext <<_ACEOF
9111 /* confdefs.h.  */
9112 _ACEOF
9113 cat confdefs.h >>conftest.$ac_ext
9114 cat >>conftest.$ac_ext <<_ACEOF
9115 /* end confdefs.h.  */
9116
9117 /* Override any gcc2 internal prototype to avoid an error.  */
9118 #ifdef __cplusplus
9119 extern "C"
9120 #endif
9121 /* We use char because int might match the return type of a gcc2
9122    builtin and then its argument prototype would still apply.  */
9123 char atanhf ();
9124 int
9125 main ()
9126 {
9127 atanhf ();
9128   ;
9129   return 0;
9130 }
9131 _ACEOF
9132 rm -f conftest.$ac_objext conftest$ac_exeext
9133 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9134   (eval $ac_link) 2>conftest.er1
9135   ac_status=$?
9136   grep -v '^ *+' conftest.er1 >conftest.err
9137   rm -f conftest.er1
9138   cat conftest.err >&5
9139   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9140   (exit $ac_status); } &&
9141          { ac_try='test -z "$ac_c_werror_flag"
9142                          || test ! -s conftest.err'
9143   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9144   (eval $ac_try) 2>&5
9145   ac_status=$?
9146   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9147   (exit $ac_status); }; } &&
9148          { ac_try='test -s conftest$ac_exeext'
9149   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9150   (eval $ac_try) 2>&5
9151   ac_status=$?
9152   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9153   (exit $ac_status); }; }; then
9154   ac_cv_lib_m_atanhf=yes
9155 else
9156   echo "$as_me: failed program was:" >&5
9157 sed 's/^/| /' conftest.$ac_ext >&5
9158
9159 ac_cv_lib_m_atanhf=no
9160 fi
9161 rm -f conftest.err conftest.$ac_objext \
9162       conftest$ac_exeext conftest.$ac_ext
9163 LIBS=$ac_check_lib_save_LIBS
9164 fi
9165 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanhf" >&5
9166 echo "${ECHO_T}$ac_cv_lib_m_atanhf" >&6
9167 if test $ac_cv_lib_m_atanhf = yes; then
9168
9169 cat >>confdefs.h <<\_ACEOF
9170 #define HAVE_ATANHF 1
9171 _ACEOF
9172
9173 fi
9174
9175 echo "$as_me:$LINENO: checking for atanh in -lm" >&5
9176 echo $ECHO_N "checking for atanh in -lm... $ECHO_C" >&6
9177 if test "${ac_cv_lib_m_atanh+set}" = set; then
9178   echo $ECHO_N "(cached) $ECHO_C" >&6
9179 else
9180   ac_check_lib_save_LIBS=$LIBS
9181 LIBS="-lm  $LIBS"
9182 if test x$gcc_no_link = xyes; then
9183   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9184 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9185    { (exit 1); exit 1; }; }
9186 fi
9187 cat >conftest.$ac_ext <<_ACEOF
9188 /* confdefs.h.  */
9189 _ACEOF
9190 cat confdefs.h >>conftest.$ac_ext
9191 cat >>conftest.$ac_ext <<_ACEOF
9192 /* end confdefs.h.  */
9193
9194 /* Override any gcc2 internal prototype to avoid an error.  */
9195 #ifdef __cplusplus
9196 extern "C"
9197 #endif
9198 /* We use char because int might match the return type of a gcc2
9199    builtin and then its argument prototype would still apply.  */
9200 char atanh ();
9201 int
9202 main ()
9203 {
9204 atanh ();
9205   ;
9206   return 0;
9207 }
9208 _ACEOF
9209 rm -f conftest.$ac_objext conftest$ac_exeext
9210 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9211   (eval $ac_link) 2>conftest.er1
9212   ac_status=$?
9213   grep -v '^ *+' conftest.er1 >conftest.err
9214   rm -f conftest.er1
9215   cat conftest.err >&5
9216   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9217   (exit $ac_status); } &&
9218          { ac_try='test -z "$ac_c_werror_flag"
9219                          || test ! -s conftest.err'
9220   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9221   (eval $ac_try) 2>&5
9222   ac_status=$?
9223   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9224   (exit $ac_status); }; } &&
9225          { ac_try='test -s conftest$ac_exeext'
9226   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9227   (eval $ac_try) 2>&5
9228   ac_status=$?
9229   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9230   (exit $ac_status); }; }; then
9231   ac_cv_lib_m_atanh=yes
9232 else
9233   echo "$as_me: failed program was:" >&5
9234 sed 's/^/| /' conftest.$ac_ext >&5
9235
9236 ac_cv_lib_m_atanh=no
9237 fi
9238 rm -f conftest.err conftest.$ac_objext \
9239       conftest$ac_exeext conftest.$ac_ext
9240 LIBS=$ac_check_lib_save_LIBS
9241 fi
9242 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanh" >&5
9243 echo "${ECHO_T}$ac_cv_lib_m_atanh" >&6
9244 if test $ac_cv_lib_m_atanh = yes; then
9245
9246 cat >>confdefs.h <<\_ACEOF
9247 #define HAVE_ATANH 1
9248 _ACEOF
9249
9250 fi
9251
9252 echo "$as_me:$LINENO: checking for atanhl in -lm" >&5
9253 echo $ECHO_N "checking for atanhl in -lm... $ECHO_C" >&6
9254 if test "${ac_cv_lib_m_atanhl+set}" = set; then
9255   echo $ECHO_N "(cached) $ECHO_C" >&6
9256 else
9257   ac_check_lib_save_LIBS=$LIBS
9258 LIBS="-lm  $LIBS"
9259 if test x$gcc_no_link = xyes; then
9260   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9261 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9262    { (exit 1); exit 1; }; }
9263 fi
9264 cat >conftest.$ac_ext <<_ACEOF
9265 /* confdefs.h.  */
9266 _ACEOF
9267 cat confdefs.h >>conftest.$ac_ext
9268 cat >>conftest.$ac_ext <<_ACEOF
9269 /* end confdefs.h.  */
9270
9271 /* Override any gcc2 internal prototype to avoid an error.  */
9272 #ifdef __cplusplus
9273 extern "C"
9274 #endif
9275 /* We use char because int might match the return type of a gcc2
9276    builtin and then its argument prototype would still apply.  */
9277 char atanhl ();
9278 int
9279 main ()
9280 {
9281 atanhl ();
9282   ;
9283   return 0;
9284 }
9285 _ACEOF
9286 rm -f conftest.$ac_objext conftest$ac_exeext
9287 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9288   (eval $ac_link) 2>conftest.er1
9289   ac_status=$?
9290   grep -v '^ *+' conftest.er1 >conftest.err
9291   rm -f conftest.er1
9292   cat conftest.err >&5
9293   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9294   (exit $ac_status); } &&
9295          { ac_try='test -z "$ac_c_werror_flag"
9296                          || test ! -s conftest.err'
9297   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9298   (eval $ac_try) 2>&5
9299   ac_status=$?
9300   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9301   (exit $ac_status); }; } &&
9302          { ac_try='test -s conftest$ac_exeext'
9303   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9304   (eval $ac_try) 2>&5
9305   ac_status=$?
9306   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9307   (exit $ac_status); }; }; then
9308   ac_cv_lib_m_atanhl=yes
9309 else
9310   echo "$as_me: failed program was:" >&5
9311 sed 's/^/| /' conftest.$ac_ext >&5
9312
9313 ac_cv_lib_m_atanhl=no
9314 fi
9315 rm -f conftest.err conftest.$ac_objext \
9316       conftest$ac_exeext conftest.$ac_ext
9317 LIBS=$ac_check_lib_save_LIBS
9318 fi
9319 echo "$as_me:$LINENO: result: $ac_cv_lib_m_atanhl" >&5
9320 echo "${ECHO_T}$ac_cv_lib_m_atanhl" >&6
9321 if test $ac_cv_lib_m_atanhl = yes; then
9322
9323 cat >>confdefs.h <<\_ACEOF
9324 #define HAVE_ATANHL 1
9325 _ACEOF
9326
9327 fi
9328
9329 echo "$as_me:$LINENO: checking for cargf in -lm" >&5
9330 echo $ECHO_N "checking for cargf in -lm... $ECHO_C" >&6
9331 if test "${ac_cv_lib_m_cargf+set}" = set; then
9332   echo $ECHO_N "(cached) $ECHO_C" >&6
9333 else
9334   ac_check_lib_save_LIBS=$LIBS
9335 LIBS="-lm  $LIBS"
9336 if test x$gcc_no_link = xyes; then
9337   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9338 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9339    { (exit 1); exit 1; }; }
9340 fi
9341 cat >conftest.$ac_ext <<_ACEOF
9342 /* confdefs.h.  */
9343 _ACEOF
9344 cat confdefs.h >>conftest.$ac_ext
9345 cat >>conftest.$ac_ext <<_ACEOF
9346 /* end confdefs.h.  */
9347
9348 /* Override any gcc2 internal prototype to avoid an error.  */
9349 #ifdef __cplusplus
9350 extern "C"
9351 #endif
9352 /* We use char because int might match the return type of a gcc2
9353    builtin and then its argument prototype would still apply.  */
9354 char cargf ();
9355 int
9356 main ()
9357 {
9358 cargf ();
9359   ;
9360   return 0;
9361 }
9362 _ACEOF
9363 rm -f conftest.$ac_objext conftest$ac_exeext
9364 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9365   (eval $ac_link) 2>conftest.er1
9366   ac_status=$?
9367   grep -v '^ *+' conftest.er1 >conftest.err
9368   rm -f conftest.er1
9369   cat conftest.err >&5
9370   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9371   (exit $ac_status); } &&
9372          { ac_try='test -z "$ac_c_werror_flag"
9373                          || test ! -s conftest.err'
9374   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9375   (eval $ac_try) 2>&5
9376   ac_status=$?
9377   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9378   (exit $ac_status); }; } &&
9379          { ac_try='test -s conftest$ac_exeext'
9380   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9381   (eval $ac_try) 2>&5
9382   ac_status=$?
9383   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9384   (exit $ac_status); }; }; then
9385   ac_cv_lib_m_cargf=yes
9386 else
9387   echo "$as_me: failed program was:" >&5
9388 sed 's/^/| /' conftest.$ac_ext >&5
9389
9390 ac_cv_lib_m_cargf=no
9391 fi
9392 rm -f conftest.err conftest.$ac_objext \
9393       conftest$ac_exeext conftest.$ac_ext
9394 LIBS=$ac_check_lib_save_LIBS
9395 fi
9396 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cargf" >&5
9397 echo "${ECHO_T}$ac_cv_lib_m_cargf" >&6
9398 if test $ac_cv_lib_m_cargf = yes; then
9399
9400 cat >>confdefs.h <<\_ACEOF
9401 #define HAVE_CARGF 1
9402 _ACEOF
9403
9404 fi
9405
9406 echo "$as_me:$LINENO: checking for carg in -lm" >&5
9407 echo $ECHO_N "checking for carg in -lm... $ECHO_C" >&6
9408 if test "${ac_cv_lib_m_carg+set}" = set; then
9409   echo $ECHO_N "(cached) $ECHO_C" >&6
9410 else
9411   ac_check_lib_save_LIBS=$LIBS
9412 LIBS="-lm  $LIBS"
9413 if test x$gcc_no_link = xyes; then
9414   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9415 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9416    { (exit 1); exit 1; }; }
9417 fi
9418 cat >conftest.$ac_ext <<_ACEOF
9419 /* confdefs.h.  */
9420 _ACEOF
9421 cat confdefs.h >>conftest.$ac_ext
9422 cat >>conftest.$ac_ext <<_ACEOF
9423 /* end confdefs.h.  */
9424
9425 /* Override any gcc2 internal prototype to avoid an error.  */
9426 #ifdef __cplusplus
9427 extern "C"
9428 #endif
9429 /* We use char because int might match the return type of a gcc2
9430    builtin and then its argument prototype would still apply.  */
9431 char carg ();
9432 int
9433 main ()
9434 {
9435 carg ();
9436   ;
9437   return 0;
9438 }
9439 _ACEOF
9440 rm -f conftest.$ac_objext conftest$ac_exeext
9441 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9442   (eval $ac_link) 2>conftest.er1
9443   ac_status=$?
9444   grep -v '^ *+' conftest.er1 >conftest.err
9445   rm -f conftest.er1
9446   cat conftest.err >&5
9447   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9448   (exit $ac_status); } &&
9449          { ac_try='test -z "$ac_c_werror_flag"
9450                          || test ! -s conftest.err'
9451   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9452   (eval $ac_try) 2>&5
9453   ac_status=$?
9454   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9455   (exit $ac_status); }; } &&
9456          { ac_try='test -s conftest$ac_exeext'
9457   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9458   (eval $ac_try) 2>&5
9459   ac_status=$?
9460   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9461   (exit $ac_status); }; }; then
9462   ac_cv_lib_m_carg=yes
9463 else
9464   echo "$as_me: failed program was:" >&5
9465 sed 's/^/| /' conftest.$ac_ext >&5
9466
9467 ac_cv_lib_m_carg=no
9468 fi
9469 rm -f conftest.err conftest.$ac_objext \
9470       conftest$ac_exeext conftest.$ac_ext
9471 LIBS=$ac_check_lib_save_LIBS
9472 fi
9473 echo "$as_me:$LINENO: result: $ac_cv_lib_m_carg" >&5
9474 echo "${ECHO_T}$ac_cv_lib_m_carg" >&6
9475 if test $ac_cv_lib_m_carg = yes; then
9476
9477 cat >>confdefs.h <<\_ACEOF
9478 #define HAVE_CARG 1
9479 _ACEOF
9480
9481 fi
9482
9483 echo "$as_me:$LINENO: checking for cargl in -lm" >&5
9484 echo $ECHO_N "checking for cargl in -lm... $ECHO_C" >&6
9485 if test "${ac_cv_lib_m_cargl+set}" = set; then
9486   echo $ECHO_N "(cached) $ECHO_C" >&6
9487 else
9488   ac_check_lib_save_LIBS=$LIBS
9489 LIBS="-lm  $LIBS"
9490 if test x$gcc_no_link = xyes; then
9491   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9492 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9493    { (exit 1); exit 1; }; }
9494 fi
9495 cat >conftest.$ac_ext <<_ACEOF
9496 /* confdefs.h.  */
9497 _ACEOF
9498 cat confdefs.h >>conftest.$ac_ext
9499 cat >>conftest.$ac_ext <<_ACEOF
9500 /* end confdefs.h.  */
9501
9502 /* Override any gcc2 internal prototype to avoid an error.  */
9503 #ifdef __cplusplus
9504 extern "C"
9505 #endif
9506 /* We use char because int might match the return type of a gcc2
9507    builtin and then its argument prototype would still apply.  */
9508 char cargl ();
9509 int
9510 main ()
9511 {
9512 cargl ();
9513   ;
9514   return 0;
9515 }
9516 _ACEOF
9517 rm -f conftest.$ac_objext conftest$ac_exeext
9518 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9519   (eval $ac_link) 2>conftest.er1
9520   ac_status=$?
9521   grep -v '^ *+' conftest.er1 >conftest.err
9522   rm -f conftest.er1
9523   cat conftest.err >&5
9524   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9525   (exit $ac_status); } &&
9526          { ac_try='test -z "$ac_c_werror_flag"
9527                          || test ! -s conftest.err'
9528   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9529   (eval $ac_try) 2>&5
9530   ac_status=$?
9531   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9532   (exit $ac_status); }; } &&
9533          { ac_try='test -s conftest$ac_exeext'
9534   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9535   (eval $ac_try) 2>&5
9536   ac_status=$?
9537   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9538   (exit $ac_status); }; }; then
9539   ac_cv_lib_m_cargl=yes
9540 else
9541   echo "$as_me: failed program was:" >&5
9542 sed 's/^/| /' conftest.$ac_ext >&5
9543
9544 ac_cv_lib_m_cargl=no
9545 fi
9546 rm -f conftest.err conftest.$ac_objext \
9547       conftest$ac_exeext conftest.$ac_ext
9548 LIBS=$ac_check_lib_save_LIBS
9549 fi
9550 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cargl" >&5
9551 echo "${ECHO_T}$ac_cv_lib_m_cargl" >&6
9552 if test $ac_cv_lib_m_cargl = yes; then
9553
9554 cat >>confdefs.h <<\_ACEOF
9555 #define HAVE_CARGL 1
9556 _ACEOF
9557
9558 fi
9559
9560 echo "$as_me:$LINENO: checking for ceilf in -lm" >&5
9561 echo $ECHO_N "checking for ceilf in -lm... $ECHO_C" >&6
9562 if test "${ac_cv_lib_m_ceilf+set}" = set; then
9563   echo $ECHO_N "(cached) $ECHO_C" >&6
9564 else
9565   ac_check_lib_save_LIBS=$LIBS
9566 LIBS="-lm  $LIBS"
9567 if test x$gcc_no_link = xyes; then
9568   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9569 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9570    { (exit 1); exit 1; }; }
9571 fi
9572 cat >conftest.$ac_ext <<_ACEOF
9573 /* confdefs.h.  */
9574 _ACEOF
9575 cat confdefs.h >>conftest.$ac_ext
9576 cat >>conftest.$ac_ext <<_ACEOF
9577 /* end confdefs.h.  */
9578
9579 /* Override any gcc2 internal prototype to avoid an error.  */
9580 #ifdef __cplusplus
9581 extern "C"
9582 #endif
9583 /* We use char because int might match the return type of a gcc2
9584    builtin and then its argument prototype would still apply.  */
9585 char ceilf ();
9586 int
9587 main ()
9588 {
9589 ceilf ();
9590   ;
9591   return 0;
9592 }
9593 _ACEOF
9594 rm -f conftest.$ac_objext conftest$ac_exeext
9595 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9596   (eval $ac_link) 2>conftest.er1
9597   ac_status=$?
9598   grep -v '^ *+' conftest.er1 >conftest.err
9599   rm -f conftest.er1
9600   cat conftest.err >&5
9601   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9602   (exit $ac_status); } &&
9603          { ac_try='test -z "$ac_c_werror_flag"
9604                          || test ! -s conftest.err'
9605   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9606   (eval $ac_try) 2>&5
9607   ac_status=$?
9608   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9609   (exit $ac_status); }; } &&
9610          { ac_try='test -s conftest$ac_exeext'
9611   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9612   (eval $ac_try) 2>&5
9613   ac_status=$?
9614   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9615   (exit $ac_status); }; }; then
9616   ac_cv_lib_m_ceilf=yes
9617 else
9618   echo "$as_me: failed program was:" >&5
9619 sed 's/^/| /' conftest.$ac_ext >&5
9620
9621 ac_cv_lib_m_ceilf=no
9622 fi
9623 rm -f conftest.err conftest.$ac_objext \
9624       conftest$ac_exeext conftest.$ac_ext
9625 LIBS=$ac_check_lib_save_LIBS
9626 fi
9627 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceilf" >&5
9628 echo "${ECHO_T}$ac_cv_lib_m_ceilf" >&6
9629 if test $ac_cv_lib_m_ceilf = yes; then
9630
9631 cat >>confdefs.h <<\_ACEOF
9632 #define HAVE_CEILF 1
9633 _ACEOF
9634
9635 fi
9636
9637 echo "$as_me:$LINENO: checking for ceil in -lm" >&5
9638 echo $ECHO_N "checking for ceil in -lm... $ECHO_C" >&6
9639 if test "${ac_cv_lib_m_ceil+set}" = set; then
9640   echo $ECHO_N "(cached) $ECHO_C" >&6
9641 else
9642   ac_check_lib_save_LIBS=$LIBS
9643 LIBS="-lm  $LIBS"
9644 if test x$gcc_no_link = xyes; then
9645   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9646 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9647    { (exit 1); exit 1; }; }
9648 fi
9649 cat >conftest.$ac_ext <<_ACEOF
9650 /* confdefs.h.  */
9651 _ACEOF
9652 cat confdefs.h >>conftest.$ac_ext
9653 cat >>conftest.$ac_ext <<_ACEOF
9654 /* end confdefs.h.  */
9655
9656 /* Override any gcc2 internal prototype to avoid an error.  */
9657 #ifdef __cplusplus
9658 extern "C"
9659 #endif
9660 /* We use char because int might match the return type of a gcc2
9661    builtin and then its argument prototype would still apply.  */
9662 char ceil ();
9663 int
9664 main ()
9665 {
9666 ceil ();
9667   ;
9668   return 0;
9669 }
9670 _ACEOF
9671 rm -f conftest.$ac_objext conftest$ac_exeext
9672 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9673   (eval $ac_link) 2>conftest.er1
9674   ac_status=$?
9675   grep -v '^ *+' conftest.er1 >conftest.err
9676   rm -f conftest.er1
9677   cat conftest.err >&5
9678   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9679   (exit $ac_status); } &&
9680          { ac_try='test -z "$ac_c_werror_flag"
9681                          || test ! -s conftest.err'
9682   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9683   (eval $ac_try) 2>&5
9684   ac_status=$?
9685   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9686   (exit $ac_status); }; } &&
9687          { ac_try='test -s conftest$ac_exeext'
9688   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9689   (eval $ac_try) 2>&5
9690   ac_status=$?
9691   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9692   (exit $ac_status); }; }; then
9693   ac_cv_lib_m_ceil=yes
9694 else
9695   echo "$as_me: failed program was:" >&5
9696 sed 's/^/| /' conftest.$ac_ext >&5
9697
9698 ac_cv_lib_m_ceil=no
9699 fi
9700 rm -f conftest.err conftest.$ac_objext \
9701       conftest$ac_exeext conftest.$ac_ext
9702 LIBS=$ac_check_lib_save_LIBS
9703 fi
9704 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceil" >&5
9705 echo "${ECHO_T}$ac_cv_lib_m_ceil" >&6
9706 if test $ac_cv_lib_m_ceil = yes; then
9707
9708 cat >>confdefs.h <<\_ACEOF
9709 #define HAVE_CEIL 1
9710 _ACEOF
9711
9712 fi
9713
9714 echo "$as_me:$LINENO: checking for ceill in -lm" >&5
9715 echo $ECHO_N "checking for ceill in -lm... $ECHO_C" >&6
9716 if test "${ac_cv_lib_m_ceill+set}" = set; then
9717   echo $ECHO_N "(cached) $ECHO_C" >&6
9718 else
9719   ac_check_lib_save_LIBS=$LIBS
9720 LIBS="-lm  $LIBS"
9721 if test x$gcc_no_link = xyes; then
9722   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9723 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9724    { (exit 1); exit 1; }; }
9725 fi
9726 cat >conftest.$ac_ext <<_ACEOF
9727 /* confdefs.h.  */
9728 _ACEOF
9729 cat confdefs.h >>conftest.$ac_ext
9730 cat >>conftest.$ac_ext <<_ACEOF
9731 /* end confdefs.h.  */
9732
9733 /* Override any gcc2 internal prototype to avoid an error.  */
9734 #ifdef __cplusplus
9735 extern "C"
9736 #endif
9737 /* We use char because int might match the return type of a gcc2
9738    builtin and then its argument prototype would still apply.  */
9739 char ceill ();
9740 int
9741 main ()
9742 {
9743 ceill ();
9744   ;
9745   return 0;
9746 }
9747 _ACEOF
9748 rm -f conftest.$ac_objext conftest$ac_exeext
9749 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9750   (eval $ac_link) 2>conftest.er1
9751   ac_status=$?
9752   grep -v '^ *+' conftest.er1 >conftest.err
9753   rm -f conftest.er1
9754   cat conftest.err >&5
9755   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9756   (exit $ac_status); } &&
9757          { ac_try='test -z "$ac_c_werror_flag"
9758                          || test ! -s conftest.err'
9759   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9760   (eval $ac_try) 2>&5
9761   ac_status=$?
9762   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9763   (exit $ac_status); }; } &&
9764          { ac_try='test -s conftest$ac_exeext'
9765   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9766   (eval $ac_try) 2>&5
9767   ac_status=$?
9768   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9769   (exit $ac_status); }; }; then
9770   ac_cv_lib_m_ceill=yes
9771 else
9772   echo "$as_me: failed program was:" >&5
9773 sed 's/^/| /' conftest.$ac_ext >&5
9774
9775 ac_cv_lib_m_ceill=no
9776 fi
9777 rm -f conftest.err conftest.$ac_objext \
9778       conftest$ac_exeext conftest.$ac_ext
9779 LIBS=$ac_check_lib_save_LIBS
9780 fi
9781 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ceill" >&5
9782 echo "${ECHO_T}$ac_cv_lib_m_ceill" >&6
9783 if test $ac_cv_lib_m_ceill = yes; then
9784
9785 cat >>confdefs.h <<\_ACEOF
9786 #define HAVE_CEILL 1
9787 _ACEOF
9788
9789 fi
9790
9791 echo "$as_me:$LINENO: checking for copysignf in -lm" >&5
9792 echo $ECHO_N "checking for copysignf in -lm... $ECHO_C" >&6
9793 if test "${ac_cv_lib_m_copysignf+set}" = set; then
9794   echo $ECHO_N "(cached) $ECHO_C" >&6
9795 else
9796   ac_check_lib_save_LIBS=$LIBS
9797 LIBS="-lm  $LIBS"
9798 if test x$gcc_no_link = xyes; then
9799   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9800 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9801    { (exit 1); exit 1; }; }
9802 fi
9803 cat >conftest.$ac_ext <<_ACEOF
9804 /* confdefs.h.  */
9805 _ACEOF
9806 cat confdefs.h >>conftest.$ac_ext
9807 cat >>conftest.$ac_ext <<_ACEOF
9808 /* end confdefs.h.  */
9809
9810 /* Override any gcc2 internal prototype to avoid an error.  */
9811 #ifdef __cplusplus
9812 extern "C"
9813 #endif
9814 /* We use char because int might match the return type of a gcc2
9815    builtin and then its argument prototype would still apply.  */
9816 char copysignf ();
9817 int
9818 main ()
9819 {
9820 copysignf ();
9821   ;
9822   return 0;
9823 }
9824 _ACEOF
9825 rm -f conftest.$ac_objext conftest$ac_exeext
9826 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9827   (eval $ac_link) 2>conftest.er1
9828   ac_status=$?
9829   grep -v '^ *+' conftest.er1 >conftest.err
9830   rm -f conftest.er1
9831   cat conftest.err >&5
9832   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9833   (exit $ac_status); } &&
9834          { ac_try='test -z "$ac_c_werror_flag"
9835                          || test ! -s conftest.err'
9836   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9837   (eval $ac_try) 2>&5
9838   ac_status=$?
9839   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9840   (exit $ac_status); }; } &&
9841          { ac_try='test -s conftest$ac_exeext'
9842   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9843   (eval $ac_try) 2>&5
9844   ac_status=$?
9845   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9846   (exit $ac_status); }; }; then
9847   ac_cv_lib_m_copysignf=yes
9848 else
9849   echo "$as_me: failed program was:" >&5
9850 sed 's/^/| /' conftest.$ac_ext >&5
9851
9852 ac_cv_lib_m_copysignf=no
9853 fi
9854 rm -f conftest.err conftest.$ac_objext \
9855       conftest$ac_exeext conftest.$ac_ext
9856 LIBS=$ac_check_lib_save_LIBS
9857 fi
9858 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysignf" >&5
9859 echo "${ECHO_T}$ac_cv_lib_m_copysignf" >&6
9860 if test $ac_cv_lib_m_copysignf = yes; then
9861
9862 cat >>confdefs.h <<\_ACEOF
9863 #define HAVE_COPYSIGNF 1
9864 _ACEOF
9865
9866 fi
9867
9868 echo "$as_me:$LINENO: checking for copysign in -lm" >&5
9869 echo $ECHO_N "checking for copysign in -lm... $ECHO_C" >&6
9870 if test "${ac_cv_lib_m_copysign+set}" = set; then
9871   echo $ECHO_N "(cached) $ECHO_C" >&6
9872 else
9873   ac_check_lib_save_LIBS=$LIBS
9874 LIBS="-lm  $LIBS"
9875 if test x$gcc_no_link = xyes; then
9876   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9877 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9878    { (exit 1); exit 1; }; }
9879 fi
9880 cat >conftest.$ac_ext <<_ACEOF
9881 /* confdefs.h.  */
9882 _ACEOF
9883 cat confdefs.h >>conftest.$ac_ext
9884 cat >>conftest.$ac_ext <<_ACEOF
9885 /* end confdefs.h.  */
9886
9887 /* Override any gcc2 internal prototype to avoid an error.  */
9888 #ifdef __cplusplus
9889 extern "C"
9890 #endif
9891 /* We use char because int might match the return type of a gcc2
9892    builtin and then its argument prototype would still apply.  */
9893 char copysign ();
9894 int
9895 main ()
9896 {
9897 copysign ();
9898   ;
9899   return 0;
9900 }
9901 _ACEOF
9902 rm -f conftest.$ac_objext conftest$ac_exeext
9903 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9904   (eval $ac_link) 2>conftest.er1
9905   ac_status=$?
9906   grep -v '^ *+' conftest.er1 >conftest.err
9907   rm -f conftest.er1
9908   cat conftest.err >&5
9909   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9910   (exit $ac_status); } &&
9911          { ac_try='test -z "$ac_c_werror_flag"
9912                          || test ! -s conftest.err'
9913   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9914   (eval $ac_try) 2>&5
9915   ac_status=$?
9916   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9917   (exit $ac_status); }; } &&
9918          { ac_try='test -s conftest$ac_exeext'
9919   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9920   (eval $ac_try) 2>&5
9921   ac_status=$?
9922   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9923   (exit $ac_status); }; }; then
9924   ac_cv_lib_m_copysign=yes
9925 else
9926   echo "$as_me: failed program was:" >&5
9927 sed 's/^/| /' conftest.$ac_ext >&5
9928
9929 ac_cv_lib_m_copysign=no
9930 fi
9931 rm -f conftest.err conftest.$ac_objext \
9932       conftest$ac_exeext conftest.$ac_ext
9933 LIBS=$ac_check_lib_save_LIBS
9934 fi
9935 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysign" >&5
9936 echo "${ECHO_T}$ac_cv_lib_m_copysign" >&6
9937 if test $ac_cv_lib_m_copysign = yes; then
9938
9939 cat >>confdefs.h <<\_ACEOF
9940 #define HAVE_COPYSIGN 1
9941 _ACEOF
9942
9943 fi
9944
9945 echo "$as_me:$LINENO: checking for copysignl in -lm" >&5
9946 echo $ECHO_N "checking for copysignl in -lm... $ECHO_C" >&6
9947 if test "${ac_cv_lib_m_copysignl+set}" = set; then
9948   echo $ECHO_N "(cached) $ECHO_C" >&6
9949 else
9950   ac_check_lib_save_LIBS=$LIBS
9951 LIBS="-lm  $LIBS"
9952 if test x$gcc_no_link = xyes; then
9953   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
9954 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
9955    { (exit 1); exit 1; }; }
9956 fi
9957 cat >conftest.$ac_ext <<_ACEOF
9958 /* confdefs.h.  */
9959 _ACEOF
9960 cat confdefs.h >>conftest.$ac_ext
9961 cat >>conftest.$ac_ext <<_ACEOF
9962 /* end confdefs.h.  */
9963
9964 /* Override any gcc2 internal prototype to avoid an error.  */
9965 #ifdef __cplusplus
9966 extern "C"
9967 #endif
9968 /* We use char because int might match the return type of a gcc2
9969    builtin and then its argument prototype would still apply.  */
9970 char copysignl ();
9971 int
9972 main ()
9973 {
9974 copysignl ();
9975   ;
9976   return 0;
9977 }
9978 _ACEOF
9979 rm -f conftest.$ac_objext conftest$ac_exeext
9980 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9981   (eval $ac_link) 2>conftest.er1
9982   ac_status=$?
9983   grep -v '^ *+' conftest.er1 >conftest.err
9984   rm -f conftest.er1
9985   cat conftest.err >&5
9986   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9987   (exit $ac_status); } &&
9988          { ac_try='test -z "$ac_c_werror_flag"
9989                          || test ! -s conftest.err'
9990   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9991   (eval $ac_try) 2>&5
9992   ac_status=$?
9993   echo "$as_me:$LINENO: \$? = $ac_status" >&5
9994   (exit $ac_status); }; } &&
9995          { ac_try='test -s conftest$ac_exeext'
9996   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9997   (eval $ac_try) 2>&5
9998   ac_status=$?
9999   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10000   (exit $ac_status); }; }; then
10001   ac_cv_lib_m_copysignl=yes
10002 else
10003   echo "$as_me: failed program was:" >&5
10004 sed 's/^/| /' conftest.$ac_ext >&5
10005
10006 ac_cv_lib_m_copysignl=no
10007 fi
10008 rm -f conftest.err conftest.$ac_objext \
10009       conftest$ac_exeext conftest.$ac_ext
10010 LIBS=$ac_check_lib_save_LIBS
10011 fi
10012 echo "$as_me:$LINENO: result: $ac_cv_lib_m_copysignl" >&5
10013 echo "${ECHO_T}$ac_cv_lib_m_copysignl" >&6
10014 if test $ac_cv_lib_m_copysignl = yes; then
10015
10016 cat >>confdefs.h <<\_ACEOF
10017 #define HAVE_COPYSIGNL 1
10018 _ACEOF
10019
10020 fi
10021
10022 echo "$as_me:$LINENO: checking for cosf in -lm" >&5
10023 echo $ECHO_N "checking for cosf in -lm... $ECHO_C" >&6
10024 if test "${ac_cv_lib_m_cosf+set}" = set; then
10025   echo $ECHO_N "(cached) $ECHO_C" >&6
10026 else
10027   ac_check_lib_save_LIBS=$LIBS
10028 LIBS="-lm  $LIBS"
10029 if test x$gcc_no_link = xyes; then
10030   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10031 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10032    { (exit 1); exit 1; }; }
10033 fi
10034 cat >conftest.$ac_ext <<_ACEOF
10035 /* confdefs.h.  */
10036 _ACEOF
10037 cat confdefs.h >>conftest.$ac_ext
10038 cat >>conftest.$ac_ext <<_ACEOF
10039 /* end confdefs.h.  */
10040
10041 /* Override any gcc2 internal prototype to avoid an error.  */
10042 #ifdef __cplusplus
10043 extern "C"
10044 #endif
10045 /* We use char because int might match the return type of a gcc2
10046    builtin and then its argument prototype would still apply.  */
10047 char cosf ();
10048 int
10049 main ()
10050 {
10051 cosf ();
10052   ;
10053   return 0;
10054 }
10055 _ACEOF
10056 rm -f conftest.$ac_objext conftest$ac_exeext
10057 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10058   (eval $ac_link) 2>conftest.er1
10059   ac_status=$?
10060   grep -v '^ *+' conftest.er1 >conftest.err
10061   rm -f conftest.er1
10062   cat conftest.err >&5
10063   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10064   (exit $ac_status); } &&
10065          { ac_try='test -z "$ac_c_werror_flag"
10066                          || test ! -s conftest.err'
10067   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10068   (eval $ac_try) 2>&5
10069   ac_status=$?
10070   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10071   (exit $ac_status); }; } &&
10072          { ac_try='test -s conftest$ac_exeext'
10073   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10074   (eval $ac_try) 2>&5
10075   ac_status=$?
10076   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10077   (exit $ac_status); }; }; then
10078   ac_cv_lib_m_cosf=yes
10079 else
10080   echo "$as_me: failed program was:" >&5
10081 sed 's/^/| /' conftest.$ac_ext >&5
10082
10083 ac_cv_lib_m_cosf=no
10084 fi
10085 rm -f conftest.err conftest.$ac_objext \
10086       conftest$ac_exeext conftest.$ac_ext
10087 LIBS=$ac_check_lib_save_LIBS
10088 fi
10089 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosf" >&5
10090 echo "${ECHO_T}$ac_cv_lib_m_cosf" >&6
10091 if test $ac_cv_lib_m_cosf = yes; then
10092
10093 cat >>confdefs.h <<\_ACEOF
10094 #define HAVE_COSF 1
10095 _ACEOF
10096
10097 fi
10098
10099 echo "$as_me:$LINENO: checking for cos in -lm" >&5
10100 echo $ECHO_N "checking for cos in -lm... $ECHO_C" >&6
10101 if test "${ac_cv_lib_m_cos+set}" = set; then
10102   echo $ECHO_N "(cached) $ECHO_C" >&6
10103 else
10104   ac_check_lib_save_LIBS=$LIBS
10105 LIBS="-lm  $LIBS"
10106 if test x$gcc_no_link = xyes; then
10107   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10108 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10109    { (exit 1); exit 1; }; }
10110 fi
10111 cat >conftest.$ac_ext <<_ACEOF
10112 /* confdefs.h.  */
10113 _ACEOF
10114 cat confdefs.h >>conftest.$ac_ext
10115 cat >>conftest.$ac_ext <<_ACEOF
10116 /* end confdefs.h.  */
10117
10118 /* Override any gcc2 internal prototype to avoid an error.  */
10119 #ifdef __cplusplus
10120 extern "C"
10121 #endif
10122 /* We use char because int might match the return type of a gcc2
10123    builtin and then its argument prototype would still apply.  */
10124 char cos ();
10125 int
10126 main ()
10127 {
10128 cos ();
10129   ;
10130   return 0;
10131 }
10132 _ACEOF
10133 rm -f conftest.$ac_objext conftest$ac_exeext
10134 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10135   (eval $ac_link) 2>conftest.er1
10136   ac_status=$?
10137   grep -v '^ *+' conftest.er1 >conftest.err
10138   rm -f conftest.er1
10139   cat conftest.err >&5
10140   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10141   (exit $ac_status); } &&
10142          { ac_try='test -z "$ac_c_werror_flag"
10143                          || test ! -s conftest.err'
10144   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10145   (eval $ac_try) 2>&5
10146   ac_status=$?
10147   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10148   (exit $ac_status); }; } &&
10149          { ac_try='test -s conftest$ac_exeext'
10150   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10151   (eval $ac_try) 2>&5
10152   ac_status=$?
10153   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10154   (exit $ac_status); }; }; then
10155   ac_cv_lib_m_cos=yes
10156 else
10157   echo "$as_me: failed program was:" >&5
10158 sed 's/^/| /' conftest.$ac_ext >&5
10159
10160 ac_cv_lib_m_cos=no
10161 fi
10162 rm -f conftest.err conftest.$ac_objext \
10163       conftest$ac_exeext conftest.$ac_ext
10164 LIBS=$ac_check_lib_save_LIBS
10165 fi
10166 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cos" >&5
10167 echo "${ECHO_T}$ac_cv_lib_m_cos" >&6
10168 if test $ac_cv_lib_m_cos = yes; then
10169
10170 cat >>confdefs.h <<\_ACEOF
10171 #define HAVE_COS 1
10172 _ACEOF
10173
10174 fi
10175
10176 echo "$as_me:$LINENO: checking for cosl in -lm" >&5
10177 echo $ECHO_N "checking for cosl in -lm... $ECHO_C" >&6
10178 if test "${ac_cv_lib_m_cosl+set}" = set; then
10179   echo $ECHO_N "(cached) $ECHO_C" >&6
10180 else
10181   ac_check_lib_save_LIBS=$LIBS
10182 LIBS="-lm  $LIBS"
10183 if test x$gcc_no_link = xyes; then
10184   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10185 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10186    { (exit 1); exit 1; }; }
10187 fi
10188 cat >conftest.$ac_ext <<_ACEOF
10189 /* confdefs.h.  */
10190 _ACEOF
10191 cat confdefs.h >>conftest.$ac_ext
10192 cat >>conftest.$ac_ext <<_ACEOF
10193 /* end confdefs.h.  */
10194
10195 /* Override any gcc2 internal prototype to avoid an error.  */
10196 #ifdef __cplusplus
10197 extern "C"
10198 #endif
10199 /* We use char because int might match the return type of a gcc2
10200    builtin and then its argument prototype would still apply.  */
10201 char cosl ();
10202 int
10203 main ()
10204 {
10205 cosl ();
10206   ;
10207   return 0;
10208 }
10209 _ACEOF
10210 rm -f conftest.$ac_objext conftest$ac_exeext
10211 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10212   (eval $ac_link) 2>conftest.er1
10213   ac_status=$?
10214   grep -v '^ *+' conftest.er1 >conftest.err
10215   rm -f conftest.er1
10216   cat conftest.err >&5
10217   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10218   (exit $ac_status); } &&
10219          { ac_try='test -z "$ac_c_werror_flag"
10220                          || test ! -s conftest.err'
10221   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10222   (eval $ac_try) 2>&5
10223   ac_status=$?
10224   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10225   (exit $ac_status); }; } &&
10226          { ac_try='test -s conftest$ac_exeext'
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); }; }; then
10232   ac_cv_lib_m_cosl=yes
10233 else
10234   echo "$as_me: failed program was:" >&5
10235 sed 's/^/| /' conftest.$ac_ext >&5
10236
10237 ac_cv_lib_m_cosl=no
10238 fi
10239 rm -f conftest.err conftest.$ac_objext \
10240       conftest$ac_exeext conftest.$ac_ext
10241 LIBS=$ac_check_lib_save_LIBS
10242 fi
10243 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosl" >&5
10244 echo "${ECHO_T}$ac_cv_lib_m_cosl" >&6
10245 if test $ac_cv_lib_m_cosl = yes; then
10246
10247 cat >>confdefs.h <<\_ACEOF
10248 #define HAVE_COSL 1
10249 _ACEOF
10250
10251 fi
10252
10253 echo "$as_me:$LINENO: checking for ccosf in -lm" >&5
10254 echo $ECHO_N "checking for ccosf in -lm... $ECHO_C" >&6
10255 if test "${ac_cv_lib_m_ccosf+set}" = set; then
10256   echo $ECHO_N "(cached) $ECHO_C" >&6
10257 else
10258   ac_check_lib_save_LIBS=$LIBS
10259 LIBS="-lm  $LIBS"
10260 if test x$gcc_no_link = xyes; then
10261   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10262 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10263    { (exit 1); exit 1; }; }
10264 fi
10265 cat >conftest.$ac_ext <<_ACEOF
10266 /* confdefs.h.  */
10267 _ACEOF
10268 cat confdefs.h >>conftest.$ac_ext
10269 cat >>conftest.$ac_ext <<_ACEOF
10270 /* end confdefs.h.  */
10271
10272 /* Override any gcc2 internal prototype to avoid an error.  */
10273 #ifdef __cplusplus
10274 extern "C"
10275 #endif
10276 /* We use char because int might match the return type of a gcc2
10277    builtin and then its argument prototype would still apply.  */
10278 char ccosf ();
10279 int
10280 main ()
10281 {
10282 ccosf ();
10283   ;
10284   return 0;
10285 }
10286 _ACEOF
10287 rm -f conftest.$ac_objext conftest$ac_exeext
10288 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10289   (eval $ac_link) 2>conftest.er1
10290   ac_status=$?
10291   grep -v '^ *+' conftest.er1 >conftest.err
10292   rm -f conftest.er1
10293   cat conftest.err >&5
10294   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10295   (exit $ac_status); } &&
10296          { ac_try='test -z "$ac_c_werror_flag"
10297                          || test ! -s conftest.err'
10298   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10299   (eval $ac_try) 2>&5
10300   ac_status=$?
10301   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10302   (exit $ac_status); }; } &&
10303          { ac_try='test -s conftest$ac_exeext'
10304   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10305   (eval $ac_try) 2>&5
10306   ac_status=$?
10307   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10308   (exit $ac_status); }; }; then
10309   ac_cv_lib_m_ccosf=yes
10310 else
10311   echo "$as_me: failed program was:" >&5
10312 sed 's/^/| /' conftest.$ac_ext >&5
10313
10314 ac_cv_lib_m_ccosf=no
10315 fi
10316 rm -f conftest.err conftest.$ac_objext \
10317       conftest$ac_exeext conftest.$ac_ext
10318 LIBS=$ac_check_lib_save_LIBS
10319 fi
10320 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosf" >&5
10321 echo "${ECHO_T}$ac_cv_lib_m_ccosf" >&6
10322 if test $ac_cv_lib_m_ccosf = yes; then
10323
10324 cat >>confdefs.h <<\_ACEOF
10325 #define HAVE_CCOSF 1
10326 _ACEOF
10327
10328 fi
10329
10330 echo "$as_me:$LINENO: checking for ccos in -lm" >&5
10331 echo $ECHO_N "checking for ccos in -lm... $ECHO_C" >&6
10332 if test "${ac_cv_lib_m_ccos+set}" = set; then
10333   echo $ECHO_N "(cached) $ECHO_C" >&6
10334 else
10335   ac_check_lib_save_LIBS=$LIBS
10336 LIBS="-lm  $LIBS"
10337 if test x$gcc_no_link = xyes; then
10338   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10339 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10340    { (exit 1); exit 1; }; }
10341 fi
10342 cat >conftest.$ac_ext <<_ACEOF
10343 /* confdefs.h.  */
10344 _ACEOF
10345 cat confdefs.h >>conftest.$ac_ext
10346 cat >>conftest.$ac_ext <<_ACEOF
10347 /* end confdefs.h.  */
10348
10349 /* Override any gcc2 internal prototype to avoid an error.  */
10350 #ifdef __cplusplus
10351 extern "C"
10352 #endif
10353 /* We use char because int might match the return type of a gcc2
10354    builtin and then its argument prototype would still apply.  */
10355 char ccos ();
10356 int
10357 main ()
10358 {
10359 ccos ();
10360   ;
10361   return 0;
10362 }
10363 _ACEOF
10364 rm -f conftest.$ac_objext conftest$ac_exeext
10365 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10366   (eval $ac_link) 2>conftest.er1
10367   ac_status=$?
10368   grep -v '^ *+' conftest.er1 >conftest.err
10369   rm -f conftest.er1
10370   cat conftest.err >&5
10371   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10372   (exit $ac_status); } &&
10373          { ac_try='test -z "$ac_c_werror_flag"
10374                          || test ! -s conftest.err'
10375   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10376   (eval $ac_try) 2>&5
10377   ac_status=$?
10378   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10379   (exit $ac_status); }; } &&
10380          { ac_try='test -s conftest$ac_exeext'
10381   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10382   (eval $ac_try) 2>&5
10383   ac_status=$?
10384   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10385   (exit $ac_status); }; }; then
10386   ac_cv_lib_m_ccos=yes
10387 else
10388   echo "$as_me: failed program was:" >&5
10389 sed 's/^/| /' conftest.$ac_ext >&5
10390
10391 ac_cv_lib_m_ccos=no
10392 fi
10393 rm -f conftest.err conftest.$ac_objext \
10394       conftest$ac_exeext conftest.$ac_ext
10395 LIBS=$ac_check_lib_save_LIBS
10396 fi
10397 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccos" >&5
10398 echo "${ECHO_T}$ac_cv_lib_m_ccos" >&6
10399 if test $ac_cv_lib_m_ccos = yes; then
10400
10401 cat >>confdefs.h <<\_ACEOF
10402 #define HAVE_CCOS 1
10403 _ACEOF
10404
10405 fi
10406
10407 echo "$as_me:$LINENO: checking for ccosl in -lm" >&5
10408 echo $ECHO_N "checking for ccosl in -lm... $ECHO_C" >&6
10409 if test "${ac_cv_lib_m_ccosl+set}" = set; then
10410   echo $ECHO_N "(cached) $ECHO_C" >&6
10411 else
10412   ac_check_lib_save_LIBS=$LIBS
10413 LIBS="-lm  $LIBS"
10414 if test x$gcc_no_link = xyes; then
10415   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10416 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10417    { (exit 1); exit 1; }; }
10418 fi
10419 cat >conftest.$ac_ext <<_ACEOF
10420 /* confdefs.h.  */
10421 _ACEOF
10422 cat confdefs.h >>conftest.$ac_ext
10423 cat >>conftest.$ac_ext <<_ACEOF
10424 /* end confdefs.h.  */
10425
10426 /* Override any gcc2 internal prototype to avoid an error.  */
10427 #ifdef __cplusplus
10428 extern "C"
10429 #endif
10430 /* We use char because int might match the return type of a gcc2
10431    builtin and then its argument prototype would still apply.  */
10432 char ccosl ();
10433 int
10434 main ()
10435 {
10436 ccosl ();
10437   ;
10438   return 0;
10439 }
10440 _ACEOF
10441 rm -f conftest.$ac_objext conftest$ac_exeext
10442 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10443   (eval $ac_link) 2>conftest.er1
10444   ac_status=$?
10445   grep -v '^ *+' conftest.er1 >conftest.err
10446   rm -f conftest.er1
10447   cat conftest.err >&5
10448   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10449   (exit $ac_status); } &&
10450          { ac_try='test -z "$ac_c_werror_flag"
10451                          || test ! -s conftest.err'
10452   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10453   (eval $ac_try) 2>&5
10454   ac_status=$?
10455   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10456   (exit $ac_status); }; } &&
10457          { ac_try='test -s conftest$ac_exeext'
10458   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10459   (eval $ac_try) 2>&5
10460   ac_status=$?
10461   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10462   (exit $ac_status); }; }; then
10463   ac_cv_lib_m_ccosl=yes
10464 else
10465   echo "$as_me: failed program was:" >&5
10466 sed 's/^/| /' conftest.$ac_ext >&5
10467
10468 ac_cv_lib_m_ccosl=no
10469 fi
10470 rm -f conftest.err conftest.$ac_objext \
10471       conftest$ac_exeext conftest.$ac_ext
10472 LIBS=$ac_check_lib_save_LIBS
10473 fi
10474 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosl" >&5
10475 echo "${ECHO_T}$ac_cv_lib_m_ccosl" >&6
10476 if test $ac_cv_lib_m_ccosl = yes; then
10477
10478 cat >>confdefs.h <<\_ACEOF
10479 #define HAVE_CCOSL 1
10480 _ACEOF
10481
10482 fi
10483
10484 echo "$as_me:$LINENO: checking for coshf in -lm" >&5
10485 echo $ECHO_N "checking for coshf in -lm... $ECHO_C" >&6
10486 if test "${ac_cv_lib_m_coshf+set}" = set; then
10487   echo $ECHO_N "(cached) $ECHO_C" >&6
10488 else
10489   ac_check_lib_save_LIBS=$LIBS
10490 LIBS="-lm  $LIBS"
10491 if test x$gcc_no_link = xyes; then
10492   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10493 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10494    { (exit 1); exit 1; }; }
10495 fi
10496 cat >conftest.$ac_ext <<_ACEOF
10497 /* confdefs.h.  */
10498 _ACEOF
10499 cat confdefs.h >>conftest.$ac_ext
10500 cat >>conftest.$ac_ext <<_ACEOF
10501 /* end confdefs.h.  */
10502
10503 /* Override any gcc2 internal prototype to avoid an error.  */
10504 #ifdef __cplusplus
10505 extern "C"
10506 #endif
10507 /* We use char because int might match the return type of a gcc2
10508    builtin and then its argument prototype would still apply.  */
10509 char coshf ();
10510 int
10511 main ()
10512 {
10513 coshf ();
10514   ;
10515   return 0;
10516 }
10517 _ACEOF
10518 rm -f conftest.$ac_objext conftest$ac_exeext
10519 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10520   (eval $ac_link) 2>conftest.er1
10521   ac_status=$?
10522   grep -v '^ *+' conftest.er1 >conftest.err
10523   rm -f conftest.er1
10524   cat conftest.err >&5
10525   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10526   (exit $ac_status); } &&
10527          { ac_try='test -z "$ac_c_werror_flag"
10528                          || test ! -s conftest.err'
10529   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10530   (eval $ac_try) 2>&5
10531   ac_status=$?
10532   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10533   (exit $ac_status); }; } &&
10534          { ac_try='test -s conftest$ac_exeext'
10535   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10536   (eval $ac_try) 2>&5
10537   ac_status=$?
10538   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10539   (exit $ac_status); }; }; then
10540   ac_cv_lib_m_coshf=yes
10541 else
10542   echo "$as_me: failed program was:" >&5
10543 sed 's/^/| /' conftest.$ac_ext >&5
10544
10545 ac_cv_lib_m_coshf=no
10546 fi
10547 rm -f conftest.err conftest.$ac_objext \
10548       conftest$ac_exeext conftest.$ac_ext
10549 LIBS=$ac_check_lib_save_LIBS
10550 fi
10551 echo "$as_me:$LINENO: result: $ac_cv_lib_m_coshf" >&5
10552 echo "${ECHO_T}$ac_cv_lib_m_coshf" >&6
10553 if test $ac_cv_lib_m_coshf = yes; then
10554
10555 cat >>confdefs.h <<\_ACEOF
10556 #define HAVE_COSHF 1
10557 _ACEOF
10558
10559 fi
10560
10561 echo "$as_me:$LINENO: checking for cosh in -lm" >&5
10562 echo $ECHO_N "checking for cosh in -lm... $ECHO_C" >&6
10563 if test "${ac_cv_lib_m_cosh+set}" = set; then
10564   echo $ECHO_N "(cached) $ECHO_C" >&6
10565 else
10566   ac_check_lib_save_LIBS=$LIBS
10567 LIBS="-lm  $LIBS"
10568 if test x$gcc_no_link = xyes; then
10569   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10570 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10571    { (exit 1); exit 1; }; }
10572 fi
10573 cat >conftest.$ac_ext <<_ACEOF
10574 /* confdefs.h.  */
10575 _ACEOF
10576 cat confdefs.h >>conftest.$ac_ext
10577 cat >>conftest.$ac_ext <<_ACEOF
10578 /* end confdefs.h.  */
10579
10580 /* Override any gcc2 internal prototype to avoid an error.  */
10581 #ifdef __cplusplus
10582 extern "C"
10583 #endif
10584 /* We use char because int might match the return type of a gcc2
10585    builtin and then its argument prototype would still apply.  */
10586 char cosh ();
10587 int
10588 main ()
10589 {
10590 cosh ();
10591   ;
10592   return 0;
10593 }
10594 _ACEOF
10595 rm -f conftest.$ac_objext conftest$ac_exeext
10596 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10597   (eval $ac_link) 2>conftest.er1
10598   ac_status=$?
10599   grep -v '^ *+' conftest.er1 >conftest.err
10600   rm -f conftest.er1
10601   cat conftest.err >&5
10602   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10603   (exit $ac_status); } &&
10604          { ac_try='test -z "$ac_c_werror_flag"
10605                          || test ! -s conftest.err'
10606   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10607   (eval $ac_try) 2>&5
10608   ac_status=$?
10609   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10610   (exit $ac_status); }; } &&
10611          { ac_try='test -s conftest$ac_exeext'
10612   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10613   (eval $ac_try) 2>&5
10614   ac_status=$?
10615   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10616   (exit $ac_status); }; }; then
10617   ac_cv_lib_m_cosh=yes
10618 else
10619   echo "$as_me: failed program was:" >&5
10620 sed 's/^/| /' conftest.$ac_ext >&5
10621
10622 ac_cv_lib_m_cosh=no
10623 fi
10624 rm -f conftest.err conftest.$ac_objext \
10625       conftest$ac_exeext conftest.$ac_ext
10626 LIBS=$ac_check_lib_save_LIBS
10627 fi
10628 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cosh" >&5
10629 echo "${ECHO_T}$ac_cv_lib_m_cosh" >&6
10630 if test $ac_cv_lib_m_cosh = yes; then
10631
10632 cat >>confdefs.h <<\_ACEOF
10633 #define HAVE_COSH 1
10634 _ACEOF
10635
10636 fi
10637
10638 echo "$as_me:$LINENO: checking for coshl in -lm" >&5
10639 echo $ECHO_N "checking for coshl in -lm... $ECHO_C" >&6
10640 if test "${ac_cv_lib_m_coshl+set}" = set; then
10641   echo $ECHO_N "(cached) $ECHO_C" >&6
10642 else
10643   ac_check_lib_save_LIBS=$LIBS
10644 LIBS="-lm  $LIBS"
10645 if test x$gcc_no_link = xyes; then
10646   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10647 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10648    { (exit 1); exit 1; }; }
10649 fi
10650 cat >conftest.$ac_ext <<_ACEOF
10651 /* confdefs.h.  */
10652 _ACEOF
10653 cat confdefs.h >>conftest.$ac_ext
10654 cat >>conftest.$ac_ext <<_ACEOF
10655 /* end confdefs.h.  */
10656
10657 /* Override any gcc2 internal prototype to avoid an error.  */
10658 #ifdef __cplusplus
10659 extern "C"
10660 #endif
10661 /* We use char because int might match the return type of a gcc2
10662    builtin and then its argument prototype would still apply.  */
10663 char coshl ();
10664 int
10665 main ()
10666 {
10667 coshl ();
10668   ;
10669   return 0;
10670 }
10671 _ACEOF
10672 rm -f conftest.$ac_objext conftest$ac_exeext
10673 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10674   (eval $ac_link) 2>conftest.er1
10675   ac_status=$?
10676   grep -v '^ *+' conftest.er1 >conftest.err
10677   rm -f conftest.er1
10678   cat conftest.err >&5
10679   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10680   (exit $ac_status); } &&
10681          { ac_try='test -z "$ac_c_werror_flag"
10682                          || 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_coshl=yes
10695 else
10696   echo "$as_me: failed program was:" >&5
10697 sed 's/^/| /' conftest.$ac_ext >&5
10698
10699 ac_cv_lib_m_coshl=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_coshl" >&5
10706 echo "${ECHO_T}$ac_cv_lib_m_coshl" >&6
10707 if test $ac_cv_lib_m_coshl = yes; then
10708
10709 cat >>confdefs.h <<\_ACEOF
10710 #define HAVE_COSHL 1
10711 _ACEOF
10712
10713 fi
10714
10715 echo "$as_me:$LINENO: checking for ccoshf in -lm" >&5
10716 echo $ECHO_N "checking for ccoshf in -lm... $ECHO_C" >&6
10717 if test "${ac_cv_lib_m_ccoshf+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 ccoshf ();
10741 int
10742 main ()
10743 {
10744 ccoshf ();
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"
10759                          || test ! -s conftest.err'
10760   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10761   (eval $ac_try) 2>&5
10762   ac_status=$?
10763   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10764   (exit $ac_status); }; } &&
10765          { ac_try='test -s conftest$ac_exeext'
10766   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10767   (eval $ac_try) 2>&5
10768   ac_status=$?
10769   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10770   (exit $ac_status); }; }; then
10771   ac_cv_lib_m_ccoshf=yes
10772 else
10773   echo "$as_me: failed program was:" >&5
10774 sed 's/^/| /' conftest.$ac_ext >&5
10775
10776 ac_cv_lib_m_ccoshf=no
10777 fi
10778 rm -f conftest.err conftest.$ac_objext \
10779       conftest$ac_exeext conftest.$ac_ext
10780 LIBS=$ac_check_lib_save_LIBS
10781 fi
10782 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccoshf" >&5
10783 echo "${ECHO_T}$ac_cv_lib_m_ccoshf" >&6
10784 if test $ac_cv_lib_m_ccoshf = yes; then
10785
10786 cat >>confdefs.h <<\_ACEOF
10787 #define HAVE_CCOSHF 1
10788 _ACEOF
10789
10790 fi
10791
10792 echo "$as_me:$LINENO: checking for ccosh in -lm" >&5
10793 echo $ECHO_N "checking for ccosh in -lm... $ECHO_C" >&6
10794 if test "${ac_cv_lib_m_ccosh+set}" = set; then
10795   echo $ECHO_N "(cached) $ECHO_C" >&6
10796 else
10797   ac_check_lib_save_LIBS=$LIBS
10798 LIBS="-lm  $LIBS"
10799 if test x$gcc_no_link = xyes; then
10800   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10801 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10802    { (exit 1); exit 1; }; }
10803 fi
10804 cat >conftest.$ac_ext <<_ACEOF
10805 /* confdefs.h.  */
10806 _ACEOF
10807 cat confdefs.h >>conftest.$ac_ext
10808 cat >>conftest.$ac_ext <<_ACEOF
10809 /* end confdefs.h.  */
10810
10811 /* Override any gcc2 internal prototype to avoid an error.  */
10812 #ifdef __cplusplus
10813 extern "C"
10814 #endif
10815 /* We use char because int might match the return type of a gcc2
10816    builtin and then its argument prototype would still apply.  */
10817 char ccosh ();
10818 int
10819 main ()
10820 {
10821 ccosh ();
10822   ;
10823   return 0;
10824 }
10825 _ACEOF
10826 rm -f conftest.$ac_objext conftest$ac_exeext
10827 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10828   (eval $ac_link) 2>conftest.er1
10829   ac_status=$?
10830   grep -v '^ *+' conftest.er1 >conftest.err
10831   rm -f conftest.er1
10832   cat conftest.err >&5
10833   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10834   (exit $ac_status); } &&
10835          { ac_try='test -z "$ac_c_werror_flag"
10836                          || test ! -s conftest.err'
10837   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10838   (eval $ac_try) 2>&5
10839   ac_status=$?
10840   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10841   (exit $ac_status); }; } &&
10842          { ac_try='test -s conftest$ac_exeext'
10843   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10844   (eval $ac_try) 2>&5
10845   ac_status=$?
10846   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10847   (exit $ac_status); }; }; then
10848   ac_cv_lib_m_ccosh=yes
10849 else
10850   echo "$as_me: failed program was:" >&5
10851 sed 's/^/| /' conftest.$ac_ext >&5
10852
10853 ac_cv_lib_m_ccosh=no
10854 fi
10855 rm -f conftest.err conftest.$ac_objext \
10856       conftest$ac_exeext conftest.$ac_ext
10857 LIBS=$ac_check_lib_save_LIBS
10858 fi
10859 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccosh" >&5
10860 echo "${ECHO_T}$ac_cv_lib_m_ccosh" >&6
10861 if test $ac_cv_lib_m_ccosh = yes; then
10862
10863 cat >>confdefs.h <<\_ACEOF
10864 #define HAVE_CCOSH 1
10865 _ACEOF
10866
10867 fi
10868
10869 echo "$as_me:$LINENO: checking for ccoshl in -lm" >&5
10870 echo $ECHO_N "checking for ccoshl in -lm... $ECHO_C" >&6
10871 if test "${ac_cv_lib_m_ccoshl+set}" = set; then
10872   echo $ECHO_N "(cached) $ECHO_C" >&6
10873 else
10874   ac_check_lib_save_LIBS=$LIBS
10875 LIBS="-lm  $LIBS"
10876 if test x$gcc_no_link = xyes; then
10877   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10878 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10879    { (exit 1); exit 1; }; }
10880 fi
10881 cat >conftest.$ac_ext <<_ACEOF
10882 /* confdefs.h.  */
10883 _ACEOF
10884 cat confdefs.h >>conftest.$ac_ext
10885 cat >>conftest.$ac_ext <<_ACEOF
10886 /* end confdefs.h.  */
10887
10888 /* Override any gcc2 internal prototype to avoid an error.  */
10889 #ifdef __cplusplus
10890 extern "C"
10891 #endif
10892 /* We use char because int might match the return type of a gcc2
10893    builtin and then its argument prototype would still apply.  */
10894 char ccoshl ();
10895 int
10896 main ()
10897 {
10898 ccoshl ();
10899   ;
10900   return 0;
10901 }
10902 _ACEOF
10903 rm -f conftest.$ac_objext conftest$ac_exeext
10904 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10905   (eval $ac_link) 2>conftest.er1
10906   ac_status=$?
10907   grep -v '^ *+' conftest.er1 >conftest.err
10908   rm -f conftest.er1
10909   cat conftest.err >&5
10910   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10911   (exit $ac_status); } &&
10912          { ac_try='test -z "$ac_c_werror_flag"
10913                          || test ! -s conftest.err'
10914   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10915   (eval $ac_try) 2>&5
10916   ac_status=$?
10917   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10918   (exit $ac_status); }; } &&
10919          { ac_try='test -s conftest$ac_exeext'
10920   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10921   (eval $ac_try) 2>&5
10922   ac_status=$?
10923   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10924   (exit $ac_status); }; }; then
10925   ac_cv_lib_m_ccoshl=yes
10926 else
10927   echo "$as_me: failed program was:" >&5
10928 sed 's/^/| /' conftest.$ac_ext >&5
10929
10930 ac_cv_lib_m_ccoshl=no
10931 fi
10932 rm -f conftest.err conftest.$ac_objext \
10933       conftest$ac_exeext conftest.$ac_ext
10934 LIBS=$ac_check_lib_save_LIBS
10935 fi
10936 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ccoshl" >&5
10937 echo "${ECHO_T}$ac_cv_lib_m_ccoshl" >&6
10938 if test $ac_cv_lib_m_ccoshl = yes; then
10939
10940 cat >>confdefs.h <<\_ACEOF
10941 #define HAVE_CCOSHL 1
10942 _ACEOF
10943
10944 fi
10945
10946 echo "$as_me:$LINENO: checking for expf in -lm" >&5
10947 echo $ECHO_N "checking for expf in -lm... $ECHO_C" >&6
10948 if test "${ac_cv_lib_m_expf+set}" = set; then
10949   echo $ECHO_N "(cached) $ECHO_C" >&6
10950 else
10951   ac_check_lib_save_LIBS=$LIBS
10952 LIBS="-lm  $LIBS"
10953 if test x$gcc_no_link = xyes; then
10954   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
10955 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
10956    { (exit 1); exit 1; }; }
10957 fi
10958 cat >conftest.$ac_ext <<_ACEOF
10959 /* confdefs.h.  */
10960 _ACEOF
10961 cat confdefs.h >>conftest.$ac_ext
10962 cat >>conftest.$ac_ext <<_ACEOF
10963 /* end confdefs.h.  */
10964
10965 /* Override any gcc2 internal prototype to avoid an error.  */
10966 #ifdef __cplusplus
10967 extern "C"
10968 #endif
10969 /* We use char because int might match the return type of a gcc2
10970    builtin and then its argument prototype would still apply.  */
10971 char expf ();
10972 int
10973 main ()
10974 {
10975 expf ();
10976   ;
10977   return 0;
10978 }
10979 _ACEOF
10980 rm -f conftest.$ac_objext conftest$ac_exeext
10981 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10982   (eval $ac_link) 2>conftest.er1
10983   ac_status=$?
10984   grep -v '^ *+' conftest.er1 >conftest.err
10985   rm -f conftest.er1
10986   cat conftest.err >&5
10987   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10988   (exit $ac_status); } &&
10989          { ac_try='test -z "$ac_c_werror_flag"
10990                          || test ! -s conftest.err'
10991   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10992   (eval $ac_try) 2>&5
10993   ac_status=$?
10994   echo "$as_me:$LINENO: \$? = $ac_status" >&5
10995   (exit $ac_status); }; } &&
10996          { ac_try='test -s conftest$ac_exeext'
10997   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10998   (eval $ac_try) 2>&5
10999   ac_status=$?
11000   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11001   (exit $ac_status); }; }; then
11002   ac_cv_lib_m_expf=yes
11003 else
11004   echo "$as_me: failed program was:" >&5
11005 sed 's/^/| /' conftest.$ac_ext >&5
11006
11007 ac_cv_lib_m_expf=no
11008 fi
11009 rm -f conftest.err conftest.$ac_objext \
11010       conftest$ac_exeext conftest.$ac_ext
11011 LIBS=$ac_check_lib_save_LIBS
11012 fi
11013 echo "$as_me:$LINENO: result: $ac_cv_lib_m_expf" >&5
11014 echo "${ECHO_T}$ac_cv_lib_m_expf" >&6
11015 if test $ac_cv_lib_m_expf = yes; then
11016
11017 cat >>confdefs.h <<\_ACEOF
11018 #define HAVE_EXPF 1
11019 _ACEOF
11020
11021 fi
11022
11023 echo "$as_me:$LINENO: checking for exp in -lm" >&5
11024 echo $ECHO_N "checking for exp in -lm... $ECHO_C" >&6
11025 if test "${ac_cv_lib_m_exp+set}" = set; then
11026   echo $ECHO_N "(cached) $ECHO_C" >&6
11027 else
11028   ac_check_lib_save_LIBS=$LIBS
11029 LIBS="-lm  $LIBS"
11030 if test x$gcc_no_link = xyes; then
11031   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11032 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11033    { (exit 1); exit 1; }; }
11034 fi
11035 cat >conftest.$ac_ext <<_ACEOF
11036 /* confdefs.h.  */
11037 _ACEOF
11038 cat confdefs.h >>conftest.$ac_ext
11039 cat >>conftest.$ac_ext <<_ACEOF
11040 /* end confdefs.h.  */
11041
11042 /* Override any gcc2 internal prototype to avoid an error.  */
11043 #ifdef __cplusplus
11044 extern "C"
11045 #endif
11046 /* We use char because int might match the return type of a gcc2
11047    builtin and then its argument prototype would still apply.  */
11048 char exp ();
11049 int
11050 main ()
11051 {
11052 exp ();
11053   ;
11054   return 0;
11055 }
11056 _ACEOF
11057 rm -f conftest.$ac_objext conftest$ac_exeext
11058 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11059   (eval $ac_link) 2>conftest.er1
11060   ac_status=$?
11061   grep -v '^ *+' conftest.er1 >conftest.err
11062   rm -f conftest.er1
11063   cat conftest.err >&5
11064   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11065   (exit $ac_status); } &&
11066          { ac_try='test -z "$ac_c_werror_flag"
11067                          || test ! -s conftest.err'
11068   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11069   (eval $ac_try) 2>&5
11070   ac_status=$?
11071   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11072   (exit $ac_status); }; } &&
11073          { ac_try='test -s conftest$ac_exeext'
11074   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11075   (eval $ac_try) 2>&5
11076   ac_status=$?
11077   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11078   (exit $ac_status); }; }; then
11079   ac_cv_lib_m_exp=yes
11080 else
11081   echo "$as_me: failed program was:" >&5
11082 sed 's/^/| /' conftest.$ac_ext >&5
11083
11084 ac_cv_lib_m_exp=no
11085 fi
11086 rm -f conftest.err conftest.$ac_objext \
11087       conftest$ac_exeext conftest.$ac_ext
11088 LIBS=$ac_check_lib_save_LIBS
11089 fi
11090 echo "$as_me:$LINENO: result: $ac_cv_lib_m_exp" >&5
11091 echo "${ECHO_T}$ac_cv_lib_m_exp" >&6
11092 if test $ac_cv_lib_m_exp = yes; then
11093
11094 cat >>confdefs.h <<\_ACEOF
11095 #define HAVE_EXP 1
11096 _ACEOF
11097
11098 fi
11099
11100 echo "$as_me:$LINENO: checking for expl in -lm" >&5
11101 echo $ECHO_N "checking for expl in -lm... $ECHO_C" >&6
11102 if test "${ac_cv_lib_m_expl+set}" = set; then
11103   echo $ECHO_N "(cached) $ECHO_C" >&6
11104 else
11105   ac_check_lib_save_LIBS=$LIBS
11106 LIBS="-lm  $LIBS"
11107 if test x$gcc_no_link = xyes; then
11108   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11109 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11110    { (exit 1); exit 1; }; }
11111 fi
11112 cat >conftest.$ac_ext <<_ACEOF
11113 /* confdefs.h.  */
11114 _ACEOF
11115 cat confdefs.h >>conftest.$ac_ext
11116 cat >>conftest.$ac_ext <<_ACEOF
11117 /* end confdefs.h.  */
11118
11119 /* Override any gcc2 internal prototype to avoid an error.  */
11120 #ifdef __cplusplus
11121 extern "C"
11122 #endif
11123 /* We use char because int might match the return type of a gcc2
11124    builtin and then its argument prototype would still apply.  */
11125 char expl ();
11126 int
11127 main ()
11128 {
11129 expl ();
11130   ;
11131   return 0;
11132 }
11133 _ACEOF
11134 rm -f conftest.$ac_objext conftest$ac_exeext
11135 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11136   (eval $ac_link) 2>conftest.er1
11137   ac_status=$?
11138   grep -v '^ *+' conftest.er1 >conftest.err
11139   rm -f conftest.er1
11140   cat conftest.err >&5
11141   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11142   (exit $ac_status); } &&
11143          { ac_try='test -z "$ac_c_werror_flag"
11144                          || test ! -s conftest.err'
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); }; } &&
11150          { ac_try='test -s conftest$ac_exeext'
11151   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11152   (eval $ac_try) 2>&5
11153   ac_status=$?
11154   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11155   (exit $ac_status); }; }; then
11156   ac_cv_lib_m_expl=yes
11157 else
11158   echo "$as_me: failed program was:" >&5
11159 sed 's/^/| /' conftest.$ac_ext >&5
11160
11161 ac_cv_lib_m_expl=no
11162 fi
11163 rm -f conftest.err conftest.$ac_objext \
11164       conftest$ac_exeext conftest.$ac_ext
11165 LIBS=$ac_check_lib_save_LIBS
11166 fi
11167 echo "$as_me:$LINENO: result: $ac_cv_lib_m_expl" >&5
11168 echo "${ECHO_T}$ac_cv_lib_m_expl" >&6
11169 if test $ac_cv_lib_m_expl = yes; then
11170
11171 cat >>confdefs.h <<\_ACEOF
11172 #define HAVE_EXPL 1
11173 _ACEOF
11174
11175 fi
11176
11177 echo "$as_me:$LINENO: checking for cexpf in -lm" >&5
11178 echo $ECHO_N "checking for cexpf in -lm... $ECHO_C" >&6
11179 if test "${ac_cv_lib_m_cexpf+set}" = set; then
11180   echo $ECHO_N "(cached) $ECHO_C" >&6
11181 else
11182   ac_check_lib_save_LIBS=$LIBS
11183 LIBS="-lm  $LIBS"
11184 if test x$gcc_no_link = xyes; then
11185   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11186 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11187    { (exit 1); exit 1; }; }
11188 fi
11189 cat >conftest.$ac_ext <<_ACEOF
11190 /* confdefs.h.  */
11191 _ACEOF
11192 cat confdefs.h >>conftest.$ac_ext
11193 cat >>conftest.$ac_ext <<_ACEOF
11194 /* end confdefs.h.  */
11195
11196 /* Override any gcc2 internal prototype to avoid an error.  */
11197 #ifdef __cplusplus
11198 extern "C"
11199 #endif
11200 /* We use char because int might match the return type of a gcc2
11201    builtin and then its argument prototype would still apply.  */
11202 char cexpf ();
11203 int
11204 main ()
11205 {
11206 cexpf ();
11207   ;
11208   return 0;
11209 }
11210 _ACEOF
11211 rm -f conftest.$ac_objext conftest$ac_exeext
11212 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11213   (eval $ac_link) 2>conftest.er1
11214   ac_status=$?
11215   grep -v '^ *+' conftest.er1 >conftest.err
11216   rm -f conftest.er1
11217   cat conftest.err >&5
11218   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11219   (exit $ac_status); } &&
11220          { ac_try='test -z "$ac_c_werror_flag"
11221                          || test ! -s conftest.err'
11222   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11223   (eval $ac_try) 2>&5
11224   ac_status=$?
11225   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11226   (exit $ac_status); }; } &&
11227          { ac_try='test -s conftest$ac_exeext'
11228   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11229   (eval $ac_try) 2>&5
11230   ac_status=$?
11231   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11232   (exit $ac_status); }; }; then
11233   ac_cv_lib_m_cexpf=yes
11234 else
11235   echo "$as_me: failed program was:" >&5
11236 sed 's/^/| /' conftest.$ac_ext >&5
11237
11238 ac_cv_lib_m_cexpf=no
11239 fi
11240 rm -f conftest.err conftest.$ac_objext \
11241       conftest$ac_exeext conftest.$ac_ext
11242 LIBS=$ac_check_lib_save_LIBS
11243 fi
11244 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexpf" >&5
11245 echo "${ECHO_T}$ac_cv_lib_m_cexpf" >&6
11246 if test $ac_cv_lib_m_cexpf = yes; then
11247
11248 cat >>confdefs.h <<\_ACEOF
11249 #define HAVE_CEXPF 1
11250 _ACEOF
11251
11252 fi
11253
11254 echo "$as_me:$LINENO: checking for cexp in -lm" >&5
11255 echo $ECHO_N "checking for cexp in -lm... $ECHO_C" >&6
11256 if test "${ac_cv_lib_m_cexp+set}" = set; then
11257   echo $ECHO_N "(cached) $ECHO_C" >&6
11258 else
11259   ac_check_lib_save_LIBS=$LIBS
11260 LIBS="-lm  $LIBS"
11261 if test x$gcc_no_link = xyes; then
11262   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11263 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11264    { (exit 1); exit 1; }; }
11265 fi
11266 cat >conftest.$ac_ext <<_ACEOF
11267 /* confdefs.h.  */
11268 _ACEOF
11269 cat confdefs.h >>conftest.$ac_ext
11270 cat >>conftest.$ac_ext <<_ACEOF
11271 /* end confdefs.h.  */
11272
11273 /* Override any gcc2 internal prototype to avoid an error.  */
11274 #ifdef __cplusplus
11275 extern "C"
11276 #endif
11277 /* We use char because int might match the return type of a gcc2
11278    builtin and then its argument prototype would still apply.  */
11279 char cexp ();
11280 int
11281 main ()
11282 {
11283 cexp ();
11284   ;
11285   return 0;
11286 }
11287 _ACEOF
11288 rm -f conftest.$ac_objext conftest$ac_exeext
11289 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11290   (eval $ac_link) 2>conftest.er1
11291   ac_status=$?
11292   grep -v '^ *+' conftest.er1 >conftest.err
11293   rm -f conftest.er1
11294   cat conftest.err >&5
11295   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11296   (exit $ac_status); } &&
11297          { ac_try='test -z "$ac_c_werror_flag"
11298                          || test ! -s conftest.err'
11299   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11300   (eval $ac_try) 2>&5
11301   ac_status=$?
11302   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11303   (exit $ac_status); }; } &&
11304          { ac_try='test -s conftest$ac_exeext'
11305   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11306   (eval $ac_try) 2>&5
11307   ac_status=$?
11308   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11309   (exit $ac_status); }; }; then
11310   ac_cv_lib_m_cexp=yes
11311 else
11312   echo "$as_me: failed program was:" >&5
11313 sed 's/^/| /' conftest.$ac_ext >&5
11314
11315 ac_cv_lib_m_cexp=no
11316 fi
11317 rm -f conftest.err conftest.$ac_objext \
11318       conftest$ac_exeext conftest.$ac_ext
11319 LIBS=$ac_check_lib_save_LIBS
11320 fi
11321 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexp" >&5
11322 echo "${ECHO_T}$ac_cv_lib_m_cexp" >&6
11323 if test $ac_cv_lib_m_cexp = yes; then
11324
11325 cat >>confdefs.h <<\_ACEOF
11326 #define HAVE_CEXP 1
11327 _ACEOF
11328
11329 fi
11330
11331 echo "$as_me:$LINENO: checking for cexpl in -lm" >&5
11332 echo $ECHO_N "checking for cexpl in -lm... $ECHO_C" >&6
11333 if test "${ac_cv_lib_m_cexpl+set}" = set; then
11334   echo $ECHO_N "(cached) $ECHO_C" >&6
11335 else
11336   ac_check_lib_save_LIBS=$LIBS
11337 LIBS="-lm  $LIBS"
11338 if test x$gcc_no_link = xyes; then
11339   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11340 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11341    { (exit 1); exit 1; }; }
11342 fi
11343 cat >conftest.$ac_ext <<_ACEOF
11344 /* confdefs.h.  */
11345 _ACEOF
11346 cat confdefs.h >>conftest.$ac_ext
11347 cat >>conftest.$ac_ext <<_ACEOF
11348 /* end confdefs.h.  */
11349
11350 /* Override any gcc2 internal prototype to avoid an error.  */
11351 #ifdef __cplusplus
11352 extern "C"
11353 #endif
11354 /* We use char because int might match the return type of a gcc2
11355    builtin and then its argument prototype would still apply.  */
11356 char cexpl ();
11357 int
11358 main ()
11359 {
11360 cexpl ();
11361   ;
11362   return 0;
11363 }
11364 _ACEOF
11365 rm -f conftest.$ac_objext conftest$ac_exeext
11366 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11367   (eval $ac_link) 2>conftest.er1
11368   ac_status=$?
11369   grep -v '^ *+' conftest.er1 >conftest.err
11370   rm -f conftest.er1
11371   cat conftest.err >&5
11372   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11373   (exit $ac_status); } &&
11374          { ac_try='test -z "$ac_c_werror_flag"
11375                          || test ! -s conftest.err'
11376   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11377   (eval $ac_try) 2>&5
11378   ac_status=$?
11379   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11380   (exit $ac_status); }; } &&
11381          { ac_try='test -s conftest$ac_exeext'
11382   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11383   (eval $ac_try) 2>&5
11384   ac_status=$?
11385   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11386   (exit $ac_status); }; }; then
11387   ac_cv_lib_m_cexpl=yes
11388 else
11389   echo "$as_me: failed program was:" >&5
11390 sed 's/^/| /' conftest.$ac_ext >&5
11391
11392 ac_cv_lib_m_cexpl=no
11393 fi
11394 rm -f conftest.err conftest.$ac_objext \
11395       conftest$ac_exeext conftest.$ac_ext
11396 LIBS=$ac_check_lib_save_LIBS
11397 fi
11398 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cexpl" >&5
11399 echo "${ECHO_T}$ac_cv_lib_m_cexpl" >&6
11400 if test $ac_cv_lib_m_cexpl = yes; then
11401
11402 cat >>confdefs.h <<\_ACEOF
11403 #define HAVE_CEXPL 1
11404 _ACEOF
11405
11406 fi
11407
11408 echo "$as_me:$LINENO: checking for fabsf in -lm" >&5
11409 echo $ECHO_N "checking for fabsf in -lm... $ECHO_C" >&6
11410 if test "${ac_cv_lib_m_fabsf+set}" = set; then
11411   echo $ECHO_N "(cached) $ECHO_C" >&6
11412 else
11413   ac_check_lib_save_LIBS=$LIBS
11414 LIBS="-lm  $LIBS"
11415 if test x$gcc_no_link = xyes; then
11416   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11417 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11418    { (exit 1); exit 1; }; }
11419 fi
11420 cat >conftest.$ac_ext <<_ACEOF
11421 /* confdefs.h.  */
11422 _ACEOF
11423 cat confdefs.h >>conftest.$ac_ext
11424 cat >>conftest.$ac_ext <<_ACEOF
11425 /* end confdefs.h.  */
11426
11427 /* Override any gcc2 internal prototype to avoid an error.  */
11428 #ifdef __cplusplus
11429 extern "C"
11430 #endif
11431 /* We use char because int might match the return type of a gcc2
11432    builtin and then its argument prototype would still apply.  */
11433 char fabsf ();
11434 int
11435 main ()
11436 {
11437 fabsf ();
11438   ;
11439   return 0;
11440 }
11441 _ACEOF
11442 rm -f conftest.$ac_objext conftest$ac_exeext
11443 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11444   (eval $ac_link) 2>conftest.er1
11445   ac_status=$?
11446   grep -v '^ *+' conftest.er1 >conftest.err
11447   rm -f conftest.er1
11448   cat conftest.err >&5
11449   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11450   (exit $ac_status); } &&
11451          { ac_try='test -z "$ac_c_werror_flag"
11452                          || test ! -s conftest.err'
11453   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11454   (eval $ac_try) 2>&5
11455   ac_status=$?
11456   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11457   (exit $ac_status); }; } &&
11458          { ac_try='test -s conftest$ac_exeext'
11459   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11460   (eval $ac_try) 2>&5
11461   ac_status=$?
11462   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11463   (exit $ac_status); }; }; then
11464   ac_cv_lib_m_fabsf=yes
11465 else
11466   echo "$as_me: failed program was:" >&5
11467 sed 's/^/| /' conftest.$ac_ext >&5
11468
11469 ac_cv_lib_m_fabsf=no
11470 fi
11471 rm -f conftest.err conftest.$ac_objext \
11472       conftest$ac_exeext conftest.$ac_ext
11473 LIBS=$ac_check_lib_save_LIBS
11474 fi
11475 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabsf" >&5
11476 echo "${ECHO_T}$ac_cv_lib_m_fabsf" >&6
11477 if test $ac_cv_lib_m_fabsf = yes; then
11478
11479 cat >>confdefs.h <<\_ACEOF
11480 #define HAVE_FABSF 1
11481 _ACEOF
11482
11483 fi
11484
11485 echo "$as_me:$LINENO: checking for fabs in -lm" >&5
11486 echo $ECHO_N "checking for fabs in -lm... $ECHO_C" >&6
11487 if test "${ac_cv_lib_m_fabs+set}" = set; then
11488   echo $ECHO_N "(cached) $ECHO_C" >&6
11489 else
11490   ac_check_lib_save_LIBS=$LIBS
11491 LIBS="-lm  $LIBS"
11492 if test x$gcc_no_link = xyes; then
11493   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11494 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11495    { (exit 1); exit 1; }; }
11496 fi
11497 cat >conftest.$ac_ext <<_ACEOF
11498 /* confdefs.h.  */
11499 _ACEOF
11500 cat confdefs.h >>conftest.$ac_ext
11501 cat >>conftest.$ac_ext <<_ACEOF
11502 /* end confdefs.h.  */
11503
11504 /* Override any gcc2 internal prototype to avoid an error.  */
11505 #ifdef __cplusplus
11506 extern "C"
11507 #endif
11508 /* We use char because int might match the return type of a gcc2
11509    builtin and then its argument prototype would still apply.  */
11510 char fabs ();
11511 int
11512 main ()
11513 {
11514 fabs ();
11515   ;
11516   return 0;
11517 }
11518 _ACEOF
11519 rm -f conftest.$ac_objext conftest$ac_exeext
11520 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11521   (eval $ac_link) 2>conftest.er1
11522   ac_status=$?
11523   grep -v '^ *+' conftest.er1 >conftest.err
11524   rm -f conftest.er1
11525   cat conftest.err >&5
11526   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11527   (exit $ac_status); } &&
11528          { ac_try='test -z "$ac_c_werror_flag"
11529                          || test ! -s conftest.err'
11530   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11531   (eval $ac_try) 2>&5
11532   ac_status=$?
11533   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11534   (exit $ac_status); }; } &&
11535          { ac_try='test -s conftest$ac_exeext'
11536   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11537   (eval $ac_try) 2>&5
11538   ac_status=$?
11539   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11540   (exit $ac_status); }; }; then
11541   ac_cv_lib_m_fabs=yes
11542 else
11543   echo "$as_me: failed program was:" >&5
11544 sed 's/^/| /' conftest.$ac_ext >&5
11545
11546 ac_cv_lib_m_fabs=no
11547 fi
11548 rm -f conftest.err conftest.$ac_objext \
11549       conftest$ac_exeext conftest.$ac_ext
11550 LIBS=$ac_check_lib_save_LIBS
11551 fi
11552 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabs" >&5
11553 echo "${ECHO_T}$ac_cv_lib_m_fabs" >&6
11554 if test $ac_cv_lib_m_fabs = yes; then
11555
11556 cat >>confdefs.h <<\_ACEOF
11557 #define HAVE_FABS 1
11558 _ACEOF
11559
11560 fi
11561
11562 echo "$as_me:$LINENO: checking for fabsl in -lm" >&5
11563 echo $ECHO_N "checking for fabsl in -lm... $ECHO_C" >&6
11564 if test "${ac_cv_lib_m_fabsl+set}" = set; then
11565   echo $ECHO_N "(cached) $ECHO_C" >&6
11566 else
11567   ac_check_lib_save_LIBS=$LIBS
11568 LIBS="-lm  $LIBS"
11569 if test x$gcc_no_link = xyes; then
11570   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11571 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11572    { (exit 1); exit 1; }; }
11573 fi
11574 cat >conftest.$ac_ext <<_ACEOF
11575 /* confdefs.h.  */
11576 _ACEOF
11577 cat confdefs.h >>conftest.$ac_ext
11578 cat >>conftest.$ac_ext <<_ACEOF
11579 /* end confdefs.h.  */
11580
11581 /* Override any gcc2 internal prototype to avoid an error.  */
11582 #ifdef __cplusplus
11583 extern "C"
11584 #endif
11585 /* We use char because int might match the return type of a gcc2
11586    builtin and then its argument prototype would still apply.  */
11587 char fabsl ();
11588 int
11589 main ()
11590 {
11591 fabsl ();
11592   ;
11593   return 0;
11594 }
11595 _ACEOF
11596 rm -f conftest.$ac_objext conftest$ac_exeext
11597 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11598   (eval $ac_link) 2>conftest.er1
11599   ac_status=$?
11600   grep -v '^ *+' conftest.er1 >conftest.err
11601   rm -f conftest.er1
11602   cat conftest.err >&5
11603   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11604   (exit $ac_status); } &&
11605          { ac_try='test -z "$ac_c_werror_flag"
11606                          || test ! -s conftest.err'
11607   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11608   (eval $ac_try) 2>&5
11609   ac_status=$?
11610   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11611   (exit $ac_status); }; } &&
11612          { ac_try='test -s conftest$ac_exeext'
11613   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11614   (eval $ac_try) 2>&5
11615   ac_status=$?
11616   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11617   (exit $ac_status); }; }; then
11618   ac_cv_lib_m_fabsl=yes
11619 else
11620   echo "$as_me: failed program was:" >&5
11621 sed 's/^/| /' conftest.$ac_ext >&5
11622
11623 ac_cv_lib_m_fabsl=no
11624 fi
11625 rm -f conftest.err conftest.$ac_objext \
11626       conftest$ac_exeext conftest.$ac_ext
11627 LIBS=$ac_check_lib_save_LIBS
11628 fi
11629 echo "$as_me:$LINENO: result: $ac_cv_lib_m_fabsl" >&5
11630 echo "${ECHO_T}$ac_cv_lib_m_fabsl" >&6
11631 if test $ac_cv_lib_m_fabsl = yes; then
11632
11633 cat >>confdefs.h <<\_ACEOF
11634 #define HAVE_FABSL 1
11635 _ACEOF
11636
11637 fi
11638
11639 echo "$as_me:$LINENO: checking for cabsf in -lm" >&5
11640 echo $ECHO_N "checking for cabsf in -lm... $ECHO_C" >&6
11641 if test "${ac_cv_lib_m_cabsf+set}" = set; then
11642   echo $ECHO_N "(cached) $ECHO_C" >&6
11643 else
11644   ac_check_lib_save_LIBS=$LIBS
11645 LIBS="-lm  $LIBS"
11646 if test x$gcc_no_link = xyes; then
11647   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11648 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11649    { (exit 1); exit 1; }; }
11650 fi
11651 cat >conftest.$ac_ext <<_ACEOF
11652 /* confdefs.h.  */
11653 _ACEOF
11654 cat confdefs.h >>conftest.$ac_ext
11655 cat >>conftest.$ac_ext <<_ACEOF
11656 /* end confdefs.h.  */
11657
11658 /* Override any gcc2 internal prototype to avoid an error.  */
11659 #ifdef __cplusplus
11660 extern "C"
11661 #endif
11662 /* We use char because int might match the return type of a gcc2
11663    builtin and then its argument prototype would still apply.  */
11664 char cabsf ();
11665 int
11666 main ()
11667 {
11668 cabsf ();
11669   ;
11670   return 0;
11671 }
11672 _ACEOF
11673 rm -f conftest.$ac_objext conftest$ac_exeext
11674 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11675   (eval $ac_link) 2>conftest.er1
11676   ac_status=$?
11677   grep -v '^ *+' conftest.er1 >conftest.err
11678   rm -f conftest.er1
11679   cat conftest.err >&5
11680   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11681   (exit $ac_status); } &&
11682          { ac_try='test -z "$ac_c_werror_flag"
11683                          || test ! -s conftest.err'
11684   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11685   (eval $ac_try) 2>&5
11686   ac_status=$?
11687   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11688   (exit $ac_status); }; } &&
11689          { ac_try='test -s conftest$ac_exeext'
11690   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11691   (eval $ac_try) 2>&5
11692   ac_status=$?
11693   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11694   (exit $ac_status); }; }; then
11695   ac_cv_lib_m_cabsf=yes
11696 else
11697   echo "$as_me: failed program was:" >&5
11698 sed 's/^/| /' conftest.$ac_ext >&5
11699
11700 ac_cv_lib_m_cabsf=no
11701 fi
11702 rm -f conftest.err conftest.$ac_objext \
11703       conftest$ac_exeext conftest.$ac_ext
11704 LIBS=$ac_check_lib_save_LIBS
11705 fi
11706 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabsf" >&5
11707 echo "${ECHO_T}$ac_cv_lib_m_cabsf" >&6
11708 if test $ac_cv_lib_m_cabsf = yes; then
11709
11710 cat >>confdefs.h <<\_ACEOF
11711 #define HAVE_CABSF 1
11712 _ACEOF
11713
11714 fi
11715
11716 echo "$as_me:$LINENO: checking for cabs in -lm" >&5
11717 echo $ECHO_N "checking for cabs in -lm... $ECHO_C" >&6
11718 if test "${ac_cv_lib_m_cabs+set}" = set; then
11719   echo $ECHO_N "(cached) $ECHO_C" >&6
11720 else
11721   ac_check_lib_save_LIBS=$LIBS
11722 LIBS="-lm  $LIBS"
11723 if test x$gcc_no_link = xyes; then
11724   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11725 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11726    { (exit 1); exit 1; }; }
11727 fi
11728 cat >conftest.$ac_ext <<_ACEOF
11729 /* confdefs.h.  */
11730 _ACEOF
11731 cat confdefs.h >>conftest.$ac_ext
11732 cat >>conftest.$ac_ext <<_ACEOF
11733 /* end confdefs.h.  */
11734
11735 /* Override any gcc2 internal prototype to avoid an error.  */
11736 #ifdef __cplusplus
11737 extern "C"
11738 #endif
11739 /* We use char because int might match the return type of a gcc2
11740    builtin and then its argument prototype would still apply.  */
11741 char cabs ();
11742 int
11743 main ()
11744 {
11745 cabs ();
11746   ;
11747   return 0;
11748 }
11749 _ACEOF
11750 rm -f conftest.$ac_objext conftest$ac_exeext
11751 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11752   (eval $ac_link) 2>conftest.er1
11753   ac_status=$?
11754   grep -v '^ *+' conftest.er1 >conftest.err
11755   rm -f conftest.er1
11756   cat conftest.err >&5
11757   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11758   (exit $ac_status); } &&
11759          { ac_try='test -z "$ac_c_werror_flag"
11760                          || test ! -s conftest.err'
11761   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11762   (eval $ac_try) 2>&5
11763   ac_status=$?
11764   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11765   (exit $ac_status); }; } &&
11766          { ac_try='test -s conftest$ac_exeext'
11767   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11768   (eval $ac_try) 2>&5
11769   ac_status=$?
11770   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11771   (exit $ac_status); }; }; then
11772   ac_cv_lib_m_cabs=yes
11773 else
11774   echo "$as_me: failed program was:" >&5
11775 sed 's/^/| /' conftest.$ac_ext >&5
11776
11777 ac_cv_lib_m_cabs=no
11778 fi
11779 rm -f conftest.err conftest.$ac_objext \
11780       conftest$ac_exeext conftest.$ac_ext
11781 LIBS=$ac_check_lib_save_LIBS
11782 fi
11783 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabs" >&5
11784 echo "${ECHO_T}$ac_cv_lib_m_cabs" >&6
11785 if test $ac_cv_lib_m_cabs = yes; then
11786
11787 cat >>confdefs.h <<\_ACEOF
11788 #define HAVE_CABS 1
11789 _ACEOF
11790
11791 fi
11792
11793 echo "$as_me:$LINENO: checking for cabsl in -lm" >&5
11794 echo $ECHO_N "checking for cabsl in -lm... $ECHO_C" >&6
11795 if test "${ac_cv_lib_m_cabsl+set}" = set; then
11796   echo $ECHO_N "(cached) $ECHO_C" >&6
11797 else
11798   ac_check_lib_save_LIBS=$LIBS
11799 LIBS="-lm  $LIBS"
11800 if test x$gcc_no_link = xyes; then
11801   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11802 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11803    { (exit 1); exit 1; }; }
11804 fi
11805 cat >conftest.$ac_ext <<_ACEOF
11806 /* confdefs.h.  */
11807 _ACEOF
11808 cat confdefs.h >>conftest.$ac_ext
11809 cat >>conftest.$ac_ext <<_ACEOF
11810 /* end confdefs.h.  */
11811
11812 /* Override any gcc2 internal prototype to avoid an error.  */
11813 #ifdef __cplusplus
11814 extern "C"
11815 #endif
11816 /* We use char because int might match the return type of a gcc2
11817    builtin and then its argument prototype would still apply.  */
11818 char cabsl ();
11819 int
11820 main ()
11821 {
11822 cabsl ();
11823   ;
11824   return 0;
11825 }
11826 _ACEOF
11827 rm -f conftest.$ac_objext conftest$ac_exeext
11828 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11829   (eval $ac_link) 2>conftest.er1
11830   ac_status=$?
11831   grep -v '^ *+' conftest.er1 >conftest.err
11832   rm -f conftest.er1
11833   cat conftest.err >&5
11834   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11835   (exit $ac_status); } &&
11836          { ac_try='test -z "$ac_c_werror_flag"
11837                          || test ! -s conftest.err'
11838   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11839   (eval $ac_try) 2>&5
11840   ac_status=$?
11841   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11842   (exit $ac_status); }; } &&
11843          { ac_try='test -s conftest$ac_exeext'
11844   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11845   (eval $ac_try) 2>&5
11846   ac_status=$?
11847   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11848   (exit $ac_status); }; }; then
11849   ac_cv_lib_m_cabsl=yes
11850 else
11851   echo "$as_me: failed program was:" >&5
11852 sed 's/^/| /' conftest.$ac_ext >&5
11853
11854 ac_cv_lib_m_cabsl=no
11855 fi
11856 rm -f conftest.err conftest.$ac_objext \
11857       conftest$ac_exeext conftest.$ac_ext
11858 LIBS=$ac_check_lib_save_LIBS
11859 fi
11860 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cabsl" >&5
11861 echo "${ECHO_T}$ac_cv_lib_m_cabsl" >&6
11862 if test $ac_cv_lib_m_cabsl = yes; then
11863
11864 cat >>confdefs.h <<\_ACEOF
11865 #define HAVE_CABSL 1
11866 _ACEOF
11867
11868 fi
11869
11870 echo "$as_me:$LINENO: checking for floorf in -lm" >&5
11871 echo $ECHO_N "checking for floorf in -lm... $ECHO_C" >&6
11872 if test "${ac_cv_lib_m_floorf+set}" = set; then
11873   echo $ECHO_N "(cached) $ECHO_C" >&6
11874 else
11875   ac_check_lib_save_LIBS=$LIBS
11876 LIBS="-lm  $LIBS"
11877 if test x$gcc_no_link = xyes; then
11878   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11879 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11880    { (exit 1); exit 1; }; }
11881 fi
11882 cat >conftest.$ac_ext <<_ACEOF
11883 /* confdefs.h.  */
11884 _ACEOF
11885 cat confdefs.h >>conftest.$ac_ext
11886 cat >>conftest.$ac_ext <<_ACEOF
11887 /* end confdefs.h.  */
11888
11889 /* Override any gcc2 internal prototype to avoid an error.  */
11890 #ifdef __cplusplus
11891 extern "C"
11892 #endif
11893 /* We use char because int might match the return type of a gcc2
11894    builtin and then its argument prototype would still apply.  */
11895 char floorf ();
11896 int
11897 main ()
11898 {
11899 floorf ();
11900   ;
11901   return 0;
11902 }
11903 _ACEOF
11904 rm -f conftest.$ac_objext conftest$ac_exeext
11905 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11906   (eval $ac_link) 2>conftest.er1
11907   ac_status=$?
11908   grep -v '^ *+' conftest.er1 >conftest.err
11909   rm -f conftest.er1
11910   cat conftest.err >&5
11911   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11912   (exit $ac_status); } &&
11913          { ac_try='test -z "$ac_c_werror_flag"
11914                          || test ! -s conftest.err'
11915   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11916   (eval $ac_try) 2>&5
11917   ac_status=$?
11918   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11919   (exit $ac_status); }; } &&
11920          { ac_try='test -s conftest$ac_exeext'
11921   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11922   (eval $ac_try) 2>&5
11923   ac_status=$?
11924   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11925   (exit $ac_status); }; }; then
11926   ac_cv_lib_m_floorf=yes
11927 else
11928   echo "$as_me: failed program was:" >&5
11929 sed 's/^/| /' conftest.$ac_ext >&5
11930
11931 ac_cv_lib_m_floorf=no
11932 fi
11933 rm -f conftest.err conftest.$ac_objext \
11934       conftest$ac_exeext conftest.$ac_ext
11935 LIBS=$ac_check_lib_save_LIBS
11936 fi
11937 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floorf" >&5
11938 echo "${ECHO_T}$ac_cv_lib_m_floorf" >&6
11939 if test $ac_cv_lib_m_floorf = yes; then
11940
11941 cat >>confdefs.h <<\_ACEOF
11942 #define HAVE_FLOORF 1
11943 _ACEOF
11944
11945 fi
11946
11947 echo "$as_me:$LINENO: checking for floor in -lm" >&5
11948 echo $ECHO_N "checking for floor in -lm... $ECHO_C" >&6
11949 if test "${ac_cv_lib_m_floor+set}" = set; then
11950   echo $ECHO_N "(cached) $ECHO_C" >&6
11951 else
11952   ac_check_lib_save_LIBS=$LIBS
11953 LIBS="-lm  $LIBS"
11954 if test x$gcc_no_link = xyes; then
11955   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
11956 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
11957    { (exit 1); exit 1; }; }
11958 fi
11959 cat >conftest.$ac_ext <<_ACEOF
11960 /* confdefs.h.  */
11961 _ACEOF
11962 cat confdefs.h >>conftest.$ac_ext
11963 cat >>conftest.$ac_ext <<_ACEOF
11964 /* end confdefs.h.  */
11965
11966 /* Override any gcc2 internal prototype to avoid an error.  */
11967 #ifdef __cplusplus
11968 extern "C"
11969 #endif
11970 /* We use char because int might match the return type of a gcc2
11971    builtin and then its argument prototype would still apply.  */
11972 char floor ();
11973 int
11974 main ()
11975 {
11976 floor ();
11977   ;
11978   return 0;
11979 }
11980 _ACEOF
11981 rm -f conftest.$ac_objext conftest$ac_exeext
11982 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11983   (eval $ac_link) 2>conftest.er1
11984   ac_status=$?
11985   grep -v '^ *+' conftest.er1 >conftest.err
11986   rm -f conftest.er1
11987   cat conftest.err >&5
11988   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11989   (exit $ac_status); } &&
11990          { ac_try='test -z "$ac_c_werror_flag"
11991                          || test ! -s conftest.err'
11992   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11993   (eval $ac_try) 2>&5
11994   ac_status=$?
11995   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11996   (exit $ac_status); }; } &&
11997          { ac_try='test -s conftest$ac_exeext'
11998   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11999   (eval $ac_try) 2>&5
12000   ac_status=$?
12001   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12002   (exit $ac_status); }; }; then
12003   ac_cv_lib_m_floor=yes
12004 else
12005   echo "$as_me: failed program was:" >&5
12006 sed 's/^/| /' conftest.$ac_ext >&5
12007
12008 ac_cv_lib_m_floor=no
12009 fi
12010 rm -f conftest.err conftest.$ac_objext \
12011       conftest$ac_exeext conftest.$ac_ext
12012 LIBS=$ac_check_lib_save_LIBS
12013 fi
12014 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floor" >&5
12015 echo "${ECHO_T}$ac_cv_lib_m_floor" >&6
12016 if test $ac_cv_lib_m_floor = yes; then
12017
12018 cat >>confdefs.h <<\_ACEOF
12019 #define HAVE_FLOOR 1
12020 _ACEOF
12021
12022 fi
12023
12024 echo "$as_me:$LINENO: checking for floorl in -lm" >&5
12025 echo $ECHO_N "checking for floorl in -lm... $ECHO_C" >&6
12026 if test "${ac_cv_lib_m_floorl+set}" = set; then
12027   echo $ECHO_N "(cached) $ECHO_C" >&6
12028 else
12029   ac_check_lib_save_LIBS=$LIBS
12030 LIBS="-lm  $LIBS"
12031 if test x$gcc_no_link = xyes; then
12032   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12033 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12034    { (exit 1); exit 1; }; }
12035 fi
12036 cat >conftest.$ac_ext <<_ACEOF
12037 /* confdefs.h.  */
12038 _ACEOF
12039 cat confdefs.h >>conftest.$ac_ext
12040 cat >>conftest.$ac_ext <<_ACEOF
12041 /* end confdefs.h.  */
12042
12043 /* Override any gcc2 internal prototype to avoid an error.  */
12044 #ifdef __cplusplus
12045 extern "C"
12046 #endif
12047 /* We use char because int might match the return type of a gcc2
12048    builtin and then its argument prototype would still apply.  */
12049 char floorl ();
12050 int
12051 main ()
12052 {
12053 floorl ();
12054   ;
12055   return 0;
12056 }
12057 _ACEOF
12058 rm -f conftest.$ac_objext conftest$ac_exeext
12059 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12060   (eval $ac_link) 2>conftest.er1
12061   ac_status=$?
12062   grep -v '^ *+' conftest.er1 >conftest.err
12063   rm -f conftest.er1
12064   cat conftest.err >&5
12065   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12066   (exit $ac_status); } &&
12067          { ac_try='test -z "$ac_c_werror_flag"
12068                          || test ! -s conftest.err'
12069   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12070   (eval $ac_try) 2>&5
12071   ac_status=$?
12072   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12073   (exit $ac_status); }; } &&
12074          { ac_try='test -s conftest$ac_exeext'
12075   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12076   (eval $ac_try) 2>&5
12077   ac_status=$?
12078   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12079   (exit $ac_status); }; }; then
12080   ac_cv_lib_m_floorl=yes
12081 else
12082   echo "$as_me: failed program was:" >&5
12083 sed 's/^/| /' conftest.$ac_ext >&5
12084
12085 ac_cv_lib_m_floorl=no
12086 fi
12087 rm -f conftest.err conftest.$ac_objext \
12088       conftest$ac_exeext conftest.$ac_ext
12089 LIBS=$ac_check_lib_save_LIBS
12090 fi
12091 echo "$as_me:$LINENO: result: $ac_cv_lib_m_floorl" >&5
12092 echo "${ECHO_T}$ac_cv_lib_m_floorl" >&6
12093 if test $ac_cv_lib_m_floorl = yes; then
12094
12095 cat >>confdefs.h <<\_ACEOF
12096 #define HAVE_FLOORL 1
12097 _ACEOF
12098
12099 fi
12100
12101 echo "$as_me:$LINENO: checking for frexpf in -lm" >&5
12102 echo $ECHO_N "checking for frexpf in -lm... $ECHO_C" >&6
12103 if test "${ac_cv_lib_m_frexpf+set}" = set; then
12104   echo $ECHO_N "(cached) $ECHO_C" >&6
12105 else
12106   ac_check_lib_save_LIBS=$LIBS
12107 LIBS="-lm  $LIBS"
12108 if test x$gcc_no_link = xyes; then
12109   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12110 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12111    { (exit 1); exit 1; }; }
12112 fi
12113 cat >conftest.$ac_ext <<_ACEOF
12114 /* confdefs.h.  */
12115 _ACEOF
12116 cat confdefs.h >>conftest.$ac_ext
12117 cat >>conftest.$ac_ext <<_ACEOF
12118 /* end confdefs.h.  */
12119
12120 /* Override any gcc2 internal prototype to avoid an error.  */
12121 #ifdef __cplusplus
12122 extern "C"
12123 #endif
12124 /* We use char because int might match the return type of a gcc2
12125    builtin and then its argument prototype would still apply.  */
12126 char frexpf ();
12127 int
12128 main ()
12129 {
12130 frexpf ();
12131   ;
12132   return 0;
12133 }
12134 _ACEOF
12135 rm -f conftest.$ac_objext conftest$ac_exeext
12136 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12137   (eval $ac_link) 2>conftest.er1
12138   ac_status=$?
12139   grep -v '^ *+' conftest.er1 >conftest.err
12140   rm -f conftest.er1
12141   cat conftest.err >&5
12142   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12143   (exit $ac_status); } &&
12144          { ac_try='test -z "$ac_c_werror_flag"
12145                          || test ! -s conftest.err'
12146   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12147   (eval $ac_try) 2>&5
12148   ac_status=$?
12149   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12150   (exit $ac_status); }; } &&
12151          { ac_try='test -s conftest$ac_exeext'
12152   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12153   (eval $ac_try) 2>&5
12154   ac_status=$?
12155   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12156   (exit $ac_status); }; }; then
12157   ac_cv_lib_m_frexpf=yes
12158 else
12159   echo "$as_me: failed program was:" >&5
12160 sed 's/^/| /' conftest.$ac_ext >&5
12161
12162 ac_cv_lib_m_frexpf=no
12163 fi
12164 rm -f conftest.err conftest.$ac_objext \
12165       conftest$ac_exeext conftest.$ac_ext
12166 LIBS=$ac_check_lib_save_LIBS
12167 fi
12168 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexpf" >&5
12169 echo "${ECHO_T}$ac_cv_lib_m_frexpf" >&6
12170 if test $ac_cv_lib_m_frexpf = yes; then
12171
12172 cat >>confdefs.h <<\_ACEOF
12173 #define HAVE_FREXPF 1
12174 _ACEOF
12175
12176 fi
12177
12178 echo "$as_me:$LINENO: checking for frexp in -lm" >&5
12179 echo $ECHO_N "checking for frexp in -lm... $ECHO_C" >&6
12180 if test "${ac_cv_lib_m_frexp+set}" = set; then
12181   echo $ECHO_N "(cached) $ECHO_C" >&6
12182 else
12183   ac_check_lib_save_LIBS=$LIBS
12184 LIBS="-lm  $LIBS"
12185 if test x$gcc_no_link = xyes; then
12186   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12187 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12188    { (exit 1); exit 1; }; }
12189 fi
12190 cat >conftest.$ac_ext <<_ACEOF
12191 /* confdefs.h.  */
12192 _ACEOF
12193 cat confdefs.h >>conftest.$ac_ext
12194 cat >>conftest.$ac_ext <<_ACEOF
12195 /* end confdefs.h.  */
12196
12197 /* Override any gcc2 internal prototype to avoid an error.  */
12198 #ifdef __cplusplus
12199 extern "C"
12200 #endif
12201 /* We use char because int might match the return type of a gcc2
12202    builtin and then its argument prototype would still apply.  */
12203 char frexp ();
12204 int
12205 main ()
12206 {
12207 frexp ();
12208   ;
12209   return 0;
12210 }
12211 _ACEOF
12212 rm -f conftest.$ac_objext conftest$ac_exeext
12213 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12214   (eval $ac_link) 2>conftest.er1
12215   ac_status=$?
12216   grep -v '^ *+' conftest.er1 >conftest.err
12217   rm -f conftest.er1
12218   cat conftest.err >&5
12219   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12220   (exit $ac_status); } &&
12221          { ac_try='test -z "$ac_c_werror_flag"
12222                          || test ! -s conftest.err'
12223   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12224   (eval $ac_try) 2>&5
12225   ac_status=$?
12226   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12227   (exit $ac_status); }; } &&
12228          { ac_try='test -s conftest$ac_exeext'
12229   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12230   (eval $ac_try) 2>&5
12231   ac_status=$?
12232   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12233   (exit $ac_status); }; }; then
12234   ac_cv_lib_m_frexp=yes
12235 else
12236   echo "$as_me: failed program was:" >&5
12237 sed 's/^/| /' conftest.$ac_ext >&5
12238
12239 ac_cv_lib_m_frexp=no
12240 fi
12241 rm -f conftest.err conftest.$ac_objext \
12242       conftest$ac_exeext conftest.$ac_ext
12243 LIBS=$ac_check_lib_save_LIBS
12244 fi
12245 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexp" >&5
12246 echo "${ECHO_T}$ac_cv_lib_m_frexp" >&6
12247 if test $ac_cv_lib_m_frexp = yes; then
12248
12249 cat >>confdefs.h <<\_ACEOF
12250 #define HAVE_FREXP 1
12251 _ACEOF
12252
12253 fi
12254
12255 echo "$as_me:$LINENO: checking for frexpl in -lm" >&5
12256 echo $ECHO_N "checking for frexpl in -lm... $ECHO_C" >&6
12257 if test "${ac_cv_lib_m_frexpl+set}" = set; then
12258   echo $ECHO_N "(cached) $ECHO_C" >&6
12259 else
12260   ac_check_lib_save_LIBS=$LIBS
12261 LIBS="-lm  $LIBS"
12262 if test x$gcc_no_link = xyes; then
12263   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12264 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12265    { (exit 1); exit 1; }; }
12266 fi
12267 cat >conftest.$ac_ext <<_ACEOF
12268 /* confdefs.h.  */
12269 _ACEOF
12270 cat confdefs.h >>conftest.$ac_ext
12271 cat >>conftest.$ac_ext <<_ACEOF
12272 /* end confdefs.h.  */
12273
12274 /* Override any gcc2 internal prototype to avoid an error.  */
12275 #ifdef __cplusplus
12276 extern "C"
12277 #endif
12278 /* We use char because int might match the return type of a gcc2
12279    builtin and then its argument prototype would still apply.  */
12280 char frexpl ();
12281 int
12282 main ()
12283 {
12284 frexpl ();
12285   ;
12286   return 0;
12287 }
12288 _ACEOF
12289 rm -f conftest.$ac_objext conftest$ac_exeext
12290 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12291   (eval $ac_link) 2>conftest.er1
12292   ac_status=$?
12293   grep -v '^ *+' conftest.er1 >conftest.err
12294   rm -f conftest.er1
12295   cat conftest.err >&5
12296   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12297   (exit $ac_status); } &&
12298          { ac_try='test -z "$ac_c_werror_flag"
12299                          || test ! -s conftest.err'
12300   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12301   (eval $ac_try) 2>&5
12302   ac_status=$?
12303   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12304   (exit $ac_status); }; } &&
12305          { ac_try='test -s conftest$ac_exeext'
12306   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12307   (eval $ac_try) 2>&5
12308   ac_status=$?
12309   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12310   (exit $ac_status); }; }; then
12311   ac_cv_lib_m_frexpl=yes
12312 else
12313   echo "$as_me: failed program was:" >&5
12314 sed 's/^/| /' conftest.$ac_ext >&5
12315
12316 ac_cv_lib_m_frexpl=no
12317 fi
12318 rm -f conftest.err conftest.$ac_objext \
12319       conftest$ac_exeext conftest.$ac_ext
12320 LIBS=$ac_check_lib_save_LIBS
12321 fi
12322 echo "$as_me:$LINENO: result: $ac_cv_lib_m_frexpl" >&5
12323 echo "${ECHO_T}$ac_cv_lib_m_frexpl" >&6
12324 if test $ac_cv_lib_m_frexpl = yes; then
12325
12326 cat >>confdefs.h <<\_ACEOF
12327 #define HAVE_FREXPL 1
12328 _ACEOF
12329
12330 fi
12331
12332 echo "$as_me:$LINENO: checking for hypotf in -lm" >&5
12333 echo $ECHO_N "checking for hypotf in -lm... $ECHO_C" >&6
12334 if test "${ac_cv_lib_m_hypotf+set}" = set; then
12335   echo $ECHO_N "(cached) $ECHO_C" >&6
12336 else
12337   ac_check_lib_save_LIBS=$LIBS
12338 LIBS="-lm  $LIBS"
12339 if test x$gcc_no_link = xyes; then
12340   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12341 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12342    { (exit 1); exit 1; }; }
12343 fi
12344 cat >conftest.$ac_ext <<_ACEOF
12345 /* confdefs.h.  */
12346 _ACEOF
12347 cat confdefs.h >>conftest.$ac_ext
12348 cat >>conftest.$ac_ext <<_ACEOF
12349 /* end confdefs.h.  */
12350
12351 /* Override any gcc2 internal prototype to avoid an error.  */
12352 #ifdef __cplusplus
12353 extern "C"
12354 #endif
12355 /* We use char because int might match the return type of a gcc2
12356    builtin and then its argument prototype would still apply.  */
12357 char hypotf ();
12358 int
12359 main ()
12360 {
12361 hypotf ();
12362   ;
12363   return 0;
12364 }
12365 _ACEOF
12366 rm -f conftest.$ac_objext conftest$ac_exeext
12367 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12368   (eval $ac_link) 2>conftest.er1
12369   ac_status=$?
12370   grep -v '^ *+' conftest.er1 >conftest.err
12371   rm -f conftest.er1
12372   cat conftest.err >&5
12373   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12374   (exit $ac_status); } &&
12375          { ac_try='test -z "$ac_c_werror_flag"
12376                          || test ! -s conftest.err'
12377   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12378   (eval $ac_try) 2>&5
12379   ac_status=$?
12380   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12381   (exit $ac_status); }; } &&
12382          { ac_try='test -s conftest$ac_exeext'
12383   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12384   (eval $ac_try) 2>&5
12385   ac_status=$?
12386   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12387   (exit $ac_status); }; }; then
12388   ac_cv_lib_m_hypotf=yes
12389 else
12390   echo "$as_me: failed program was:" >&5
12391 sed 's/^/| /' conftest.$ac_ext >&5
12392
12393 ac_cv_lib_m_hypotf=no
12394 fi
12395 rm -f conftest.err conftest.$ac_objext \
12396       conftest$ac_exeext conftest.$ac_ext
12397 LIBS=$ac_check_lib_save_LIBS
12398 fi
12399 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypotf" >&5
12400 echo "${ECHO_T}$ac_cv_lib_m_hypotf" >&6
12401 if test $ac_cv_lib_m_hypotf = yes; then
12402
12403 cat >>confdefs.h <<\_ACEOF
12404 #define HAVE_HYPOTF 1
12405 _ACEOF
12406
12407 fi
12408
12409 echo "$as_me:$LINENO: checking for hypot in -lm" >&5
12410 echo $ECHO_N "checking for hypot in -lm... $ECHO_C" >&6
12411 if test "${ac_cv_lib_m_hypot+set}" = set; then
12412   echo $ECHO_N "(cached) $ECHO_C" >&6
12413 else
12414   ac_check_lib_save_LIBS=$LIBS
12415 LIBS="-lm  $LIBS"
12416 if test x$gcc_no_link = xyes; then
12417   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12418 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12419    { (exit 1); exit 1; }; }
12420 fi
12421 cat >conftest.$ac_ext <<_ACEOF
12422 /* confdefs.h.  */
12423 _ACEOF
12424 cat confdefs.h >>conftest.$ac_ext
12425 cat >>conftest.$ac_ext <<_ACEOF
12426 /* end confdefs.h.  */
12427
12428 /* Override any gcc2 internal prototype to avoid an error.  */
12429 #ifdef __cplusplus
12430 extern "C"
12431 #endif
12432 /* We use char because int might match the return type of a gcc2
12433    builtin and then its argument prototype would still apply.  */
12434 char hypot ();
12435 int
12436 main ()
12437 {
12438 hypot ();
12439   ;
12440   return 0;
12441 }
12442 _ACEOF
12443 rm -f conftest.$ac_objext conftest$ac_exeext
12444 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12445   (eval $ac_link) 2>conftest.er1
12446   ac_status=$?
12447   grep -v '^ *+' conftest.er1 >conftest.err
12448   rm -f conftest.er1
12449   cat conftest.err >&5
12450   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12451   (exit $ac_status); } &&
12452          { ac_try='test -z "$ac_c_werror_flag"
12453                          || test ! -s conftest.err'
12454   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12455   (eval $ac_try) 2>&5
12456   ac_status=$?
12457   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12458   (exit $ac_status); }; } &&
12459          { ac_try='test -s conftest$ac_exeext'
12460   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12461   (eval $ac_try) 2>&5
12462   ac_status=$?
12463   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12464   (exit $ac_status); }; }; then
12465   ac_cv_lib_m_hypot=yes
12466 else
12467   echo "$as_me: failed program was:" >&5
12468 sed 's/^/| /' conftest.$ac_ext >&5
12469
12470 ac_cv_lib_m_hypot=no
12471 fi
12472 rm -f conftest.err conftest.$ac_objext \
12473       conftest$ac_exeext conftest.$ac_ext
12474 LIBS=$ac_check_lib_save_LIBS
12475 fi
12476 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypot" >&5
12477 echo "${ECHO_T}$ac_cv_lib_m_hypot" >&6
12478 if test $ac_cv_lib_m_hypot = yes; then
12479
12480 cat >>confdefs.h <<\_ACEOF
12481 #define HAVE_HYPOT 1
12482 _ACEOF
12483
12484 fi
12485
12486 echo "$as_me:$LINENO: checking for hypotl in -lm" >&5
12487 echo $ECHO_N "checking for hypotl in -lm... $ECHO_C" >&6
12488 if test "${ac_cv_lib_m_hypotl+set}" = set; then
12489   echo $ECHO_N "(cached) $ECHO_C" >&6
12490 else
12491   ac_check_lib_save_LIBS=$LIBS
12492 LIBS="-lm  $LIBS"
12493 if test x$gcc_no_link = xyes; then
12494   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12495 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12496    { (exit 1); exit 1; }; }
12497 fi
12498 cat >conftest.$ac_ext <<_ACEOF
12499 /* confdefs.h.  */
12500 _ACEOF
12501 cat confdefs.h >>conftest.$ac_ext
12502 cat >>conftest.$ac_ext <<_ACEOF
12503 /* end confdefs.h.  */
12504
12505 /* Override any gcc2 internal prototype to avoid an error.  */
12506 #ifdef __cplusplus
12507 extern "C"
12508 #endif
12509 /* We use char because int might match the return type of a gcc2
12510    builtin and then its argument prototype would still apply.  */
12511 char hypotl ();
12512 int
12513 main ()
12514 {
12515 hypotl ();
12516   ;
12517   return 0;
12518 }
12519 _ACEOF
12520 rm -f conftest.$ac_objext conftest$ac_exeext
12521 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12522   (eval $ac_link) 2>conftest.er1
12523   ac_status=$?
12524   grep -v '^ *+' conftest.er1 >conftest.err
12525   rm -f conftest.er1
12526   cat conftest.err >&5
12527   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12528   (exit $ac_status); } &&
12529          { ac_try='test -z "$ac_c_werror_flag"
12530                          || test ! -s conftest.err'
12531   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12532   (eval $ac_try) 2>&5
12533   ac_status=$?
12534   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12535   (exit $ac_status); }; } &&
12536          { ac_try='test -s conftest$ac_exeext'
12537   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12538   (eval $ac_try) 2>&5
12539   ac_status=$?
12540   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12541   (exit $ac_status); }; }; then
12542   ac_cv_lib_m_hypotl=yes
12543 else
12544   echo "$as_me: failed program was:" >&5
12545 sed 's/^/| /' conftest.$ac_ext >&5
12546
12547 ac_cv_lib_m_hypotl=no
12548 fi
12549 rm -f conftest.err conftest.$ac_objext \
12550       conftest$ac_exeext conftest.$ac_ext
12551 LIBS=$ac_check_lib_save_LIBS
12552 fi
12553 echo "$as_me:$LINENO: result: $ac_cv_lib_m_hypotl" >&5
12554 echo "${ECHO_T}$ac_cv_lib_m_hypotl" >&6
12555 if test $ac_cv_lib_m_hypotl = yes; then
12556
12557 cat >>confdefs.h <<\_ACEOF
12558 #define HAVE_HYPOTL 1
12559 _ACEOF
12560
12561 fi
12562
12563 echo "$as_me:$LINENO: checking for logf in -lm" >&5
12564 echo $ECHO_N "checking for logf in -lm... $ECHO_C" >&6
12565 if test "${ac_cv_lib_m_logf+set}" = set; then
12566   echo $ECHO_N "(cached) $ECHO_C" >&6
12567 else
12568   ac_check_lib_save_LIBS=$LIBS
12569 LIBS="-lm  $LIBS"
12570 if test x$gcc_no_link = xyes; then
12571   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12572 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12573    { (exit 1); exit 1; }; }
12574 fi
12575 cat >conftest.$ac_ext <<_ACEOF
12576 /* confdefs.h.  */
12577 _ACEOF
12578 cat confdefs.h >>conftest.$ac_ext
12579 cat >>conftest.$ac_ext <<_ACEOF
12580 /* end confdefs.h.  */
12581
12582 /* Override any gcc2 internal prototype to avoid an error.  */
12583 #ifdef __cplusplus
12584 extern "C"
12585 #endif
12586 /* We use char because int might match the return type of a gcc2
12587    builtin and then its argument prototype would still apply.  */
12588 char logf ();
12589 int
12590 main ()
12591 {
12592 logf ();
12593   ;
12594   return 0;
12595 }
12596 _ACEOF
12597 rm -f conftest.$ac_objext conftest$ac_exeext
12598 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12599   (eval $ac_link) 2>conftest.er1
12600   ac_status=$?
12601   grep -v '^ *+' conftest.er1 >conftest.err
12602   rm -f conftest.er1
12603   cat conftest.err >&5
12604   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12605   (exit $ac_status); } &&
12606          { ac_try='test -z "$ac_c_werror_flag"
12607                          || test ! -s conftest.err'
12608   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12609   (eval $ac_try) 2>&5
12610   ac_status=$?
12611   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12612   (exit $ac_status); }; } &&
12613          { ac_try='test -s conftest$ac_exeext'
12614   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12615   (eval $ac_try) 2>&5
12616   ac_status=$?
12617   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12618   (exit $ac_status); }; }; then
12619   ac_cv_lib_m_logf=yes
12620 else
12621   echo "$as_me: failed program was:" >&5
12622 sed 's/^/| /' conftest.$ac_ext >&5
12623
12624 ac_cv_lib_m_logf=no
12625 fi
12626 rm -f conftest.err conftest.$ac_objext \
12627       conftest$ac_exeext conftest.$ac_ext
12628 LIBS=$ac_check_lib_save_LIBS
12629 fi
12630 echo "$as_me:$LINENO: result: $ac_cv_lib_m_logf" >&5
12631 echo "${ECHO_T}$ac_cv_lib_m_logf" >&6
12632 if test $ac_cv_lib_m_logf = yes; then
12633
12634 cat >>confdefs.h <<\_ACEOF
12635 #define HAVE_LOGF 1
12636 _ACEOF
12637
12638 fi
12639
12640 echo "$as_me:$LINENO: checking for log in -lm" >&5
12641 echo $ECHO_N "checking for log in -lm... $ECHO_C" >&6
12642 if test "${ac_cv_lib_m_log+set}" = set; then
12643   echo $ECHO_N "(cached) $ECHO_C" >&6
12644 else
12645   ac_check_lib_save_LIBS=$LIBS
12646 LIBS="-lm  $LIBS"
12647 if test x$gcc_no_link = xyes; then
12648   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12649 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12650    { (exit 1); exit 1; }; }
12651 fi
12652 cat >conftest.$ac_ext <<_ACEOF
12653 /* confdefs.h.  */
12654 _ACEOF
12655 cat confdefs.h >>conftest.$ac_ext
12656 cat >>conftest.$ac_ext <<_ACEOF
12657 /* end confdefs.h.  */
12658
12659 /* Override any gcc2 internal prototype to avoid an error.  */
12660 #ifdef __cplusplus
12661 extern "C"
12662 #endif
12663 /* We use char because int might match the return type of a gcc2
12664    builtin and then its argument prototype would still apply.  */
12665 char log ();
12666 int
12667 main ()
12668 {
12669 log ();
12670   ;
12671   return 0;
12672 }
12673 _ACEOF
12674 rm -f conftest.$ac_objext conftest$ac_exeext
12675 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12676   (eval $ac_link) 2>conftest.er1
12677   ac_status=$?
12678   grep -v '^ *+' conftest.er1 >conftest.err
12679   rm -f conftest.er1
12680   cat conftest.err >&5
12681   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12682   (exit $ac_status); } &&
12683          { ac_try='test -z "$ac_c_werror_flag"
12684                          || test ! -s conftest.err'
12685   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12686   (eval $ac_try) 2>&5
12687   ac_status=$?
12688   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12689   (exit $ac_status); }; } &&
12690          { ac_try='test -s conftest$ac_exeext'
12691   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12692   (eval $ac_try) 2>&5
12693   ac_status=$?
12694   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12695   (exit $ac_status); }; }; then
12696   ac_cv_lib_m_log=yes
12697 else
12698   echo "$as_me: failed program was:" >&5
12699 sed 's/^/| /' conftest.$ac_ext >&5
12700
12701 ac_cv_lib_m_log=no
12702 fi
12703 rm -f conftest.err conftest.$ac_objext \
12704       conftest$ac_exeext conftest.$ac_ext
12705 LIBS=$ac_check_lib_save_LIBS
12706 fi
12707 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log" >&5
12708 echo "${ECHO_T}$ac_cv_lib_m_log" >&6
12709 if test $ac_cv_lib_m_log = yes; then
12710
12711 cat >>confdefs.h <<\_ACEOF
12712 #define HAVE_LOG 1
12713 _ACEOF
12714
12715 fi
12716
12717 echo "$as_me:$LINENO: checking for logl in -lm" >&5
12718 echo $ECHO_N "checking for logl in -lm... $ECHO_C" >&6
12719 if test "${ac_cv_lib_m_logl+set}" = set; then
12720   echo $ECHO_N "(cached) $ECHO_C" >&6
12721 else
12722   ac_check_lib_save_LIBS=$LIBS
12723 LIBS="-lm  $LIBS"
12724 if test x$gcc_no_link = xyes; then
12725   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12726 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12727    { (exit 1); exit 1; }; }
12728 fi
12729 cat >conftest.$ac_ext <<_ACEOF
12730 /* confdefs.h.  */
12731 _ACEOF
12732 cat confdefs.h >>conftest.$ac_ext
12733 cat >>conftest.$ac_ext <<_ACEOF
12734 /* end confdefs.h.  */
12735
12736 /* Override any gcc2 internal prototype to avoid an error.  */
12737 #ifdef __cplusplus
12738 extern "C"
12739 #endif
12740 /* We use char because int might match the return type of a gcc2
12741    builtin and then its argument prototype would still apply.  */
12742 char logl ();
12743 int
12744 main ()
12745 {
12746 logl ();
12747   ;
12748   return 0;
12749 }
12750 _ACEOF
12751 rm -f conftest.$ac_objext conftest$ac_exeext
12752 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12753   (eval $ac_link) 2>conftest.er1
12754   ac_status=$?
12755   grep -v '^ *+' conftest.er1 >conftest.err
12756   rm -f conftest.er1
12757   cat conftest.err >&5
12758   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12759   (exit $ac_status); } &&
12760          { ac_try='test -z "$ac_c_werror_flag"
12761                          || test ! -s conftest.err'
12762   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12763   (eval $ac_try) 2>&5
12764   ac_status=$?
12765   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12766   (exit $ac_status); }; } &&
12767          { ac_try='test -s conftest$ac_exeext'
12768   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12769   (eval $ac_try) 2>&5
12770   ac_status=$?
12771   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12772   (exit $ac_status); }; }; then
12773   ac_cv_lib_m_logl=yes
12774 else
12775   echo "$as_me: failed program was:" >&5
12776 sed 's/^/| /' conftest.$ac_ext >&5
12777
12778 ac_cv_lib_m_logl=no
12779 fi
12780 rm -f conftest.err conftest.$ac_objext \
12781       conftest$ac_exeext conftest.$ac_ext
12782 LIBS=$ac_check_lib_save_LIBS
12783 fi
12784 echo "$as_me:$LINENO: result: $ac_cv_lib_m_logl" >&5
12785 echo "${ECHO_T}$ac_cv_lib_m_logl" >&6
12786 if test $ac_cv_lib_m_logl = yes; then
12787
12788 cat >>confdefs.h <<\_ACEOF
12789 #define HAVE_LOGL 1
12790 _ACEOF
12791
12792 fi
12793
12794 echo "$as_me:$LINENO: checking for clogf in -lm" >&5
12795 echo $ECHO_N "checking for clogf in -lm... $ECHO_C" >&6
12796 if test "${ac_cv_lib_m_clogf+set}" = set; then
12797   echo $ECHO_N "(cached) $ECHO_C" >&6
12798 else
12799   ac_check_lib_save_LIBS=$LIBS
12800 LIBS="-lm  $LIBS"
12801 if test x$gcc_no_link = xyes; then
12802   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12803 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12804    { (exit 1); exit 1; }; }
12805 fi
12806 cat >conftest.$ac_ext <<_ACEOF
12807 /* confdefs.h.  */
12808 _ACEOF
12809 cat confdefs.h >>conftest.$ac_ext
12810 cat >>conftest.$ac_ext <<_ACEOF
12811 /* end confdefs.h.  */
12812
12813 /* Override any gcc2 internal prototype to avoid an error.  */
12814 #ifdef __cplusplus
12815 extern "C"
12816 #endif
12817 /* We use char because int might match the return type of a gcc2
12818    builtin and then its argument prototype would still apply.  */
12819 char clogf ();
12820 int
12821 main ()
12822 {
12823 clogf ();
12824   ;
12825   return 0;
12826 }
12827 _ACEOF
12828 rm -f conftest.$ac_objext conftest$ac_exeext
12829 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12830   (eval $ac_link) 2>conftest.er1
12831   ac_status=$?
12832   grep -v '^ *+' conftest.er1 >conftest.err
12833   rm -f conftest.er1
12834   cat conftest.err >&5
12835   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12836   (exit $ac_status); } &&
12837          { ac_try='test -z "$ac_c_werror_flag"
12838                          || test ! -s conftest.err'
12839   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12840   (eval $ac_try) 2>&5
12841   ac_status=$?
12842   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12843   (exit $ac_status); }; } &&
12844          { ac_try='test -s conftest$ac_exeext'
12845   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12846   (eval $ac_try) 2>&5
12847   ac_status=$?
12848   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12849   (exit $ac_status); }; }; then
12850   ac_cv_lib_m_clogf=yes
12851 else
12852   echo "$as_me: failed program was:" >&5
12853 sed 's/^/| /' conftest.$ac_ext >&5
12854
12855 ac_cv_lib_m_clogf=no
12856 fi
12857 rm -f conftest.err conftest.$ac_objext \
12858       conftest$ac_exeext conftest.$ac_ext
12859 LIBS=$ac_check_lib_save_LIBS
12860 fi
12861 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clogf" >&5
12862 echo "${ECHO_T}$ac_cv_lib_m_clogf" >&6
12863 if test $ac_cv_lib_m_clogf = yes; then
12864
12865 cat >>confdefs.h <<\_ACEOF
12866 #define HAVE_CLOGF 1
12867 _ACEOF
12868
12869 fi
12870
12871 echo "$as_me:$LINENO: checking for clog in -lm" >&5
12872 echo $ECHO_N "checking for clog in -lm... $ECHO_C" >&6
12873 if test "${ac_cv_lib_m_clog+set}" = set; then
12874   echo $ECHO_N "(cached) $ECHO_C" >&6
12875 else
12876   ac_check_lib_save_LIBS=$LIBS
12877 LIBS="-lm  $LIBS"
12878 if test x$gcc_no_link = xyes; then
12879   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12880 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12881    { (exit 1); exit 1; }; }
12882 fi
12883 cat >conftest.$ac_ext <<_ACEOF
12884 /* confdefs.h.  */
12885 _ACEOF
12886 cat confdefs.h >>conftest.$ac_ext
12887 cat >>conftest.$ac_ext <<_ACEOF
12888 /* end confdefs.h.  */
12889
12890 /* Override any gcc2 internal prototype to avoid an error.  */
12891 #ifdef __cplusplus
12892 extern "C"
12893 #endif
12894 /* We use char because int might match the return type of a gcc2
12895    builtin and then its argument prototype would still apply.  */
12896 char clog ();
12897 int
12898 main ()
12899 {
12900 clog ();
12901   ;
12902   return 0;
12903 }
12904 _ACEOF
12905 rm -f conftest.$ac_objext conftest$ac_exeext
12906 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12907   (eval $ac_link) 2>conftest.er1
12908   ac_status=$?
12909   grep -v '^ *+' conftest.er1 >conftest.err
12910   rm -f conftest.er1
12911   cat conftest.err >&5
12912   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12913   (exit $ac_status); } &&
12914          { ac_try='test -z "$ac_c_werror_flag"
12915                          || test ! -s conftest.err'
12916   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12917   (eval $ac_try) 2>&5
12918   ac_status=$?
12919   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12920   (exit $ac_status); }; } &&
12921          { ac_try='test -s conftest$ac_exeext'
12922   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12923   (eval $ac_try) 2>&5
12924   ac_status=$?
12925   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12926   (exit $ac_status); }; }; then
12927   ac_cv_lib_m_clog=yes
12928 else
12929   echo "$as_me: failed program was:" >&5
12930 sed 's/^/| /' conftest.$ac_ext >&5
12931
12932 ac_cv_lib_m_clog=no
12933 fi
12934 rm -f conftest.err conftest.$ac_objext \
12935       conftest$ac_exeext conftest.$ac_ext
12936 LIBS=$ac_check_lib_save_LIBS
12937 fi
12938 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog" >&5
12939 echo "${ECHO_T}$ac_cv_lib_m_clog" >&6
12940 if test $ac_cv_lib_m_clog = yes; then
12941
12942 cat >>confdefs.h <<\_ACEOF
12943 #define HAVE_CLOG 1
12944 _ACEOF
12945
12946 fi
12947
12948 echo "$as_me:$LINENO: checking for clogl in -lm" >&5
12949 echo $ECHO_N "checking for clogl in -lm... $ECHO_C" >&6
12950 if test "${ac_cv_lib_m_clogl+set}" = set; then
12951   echo $ECHO_N "(cached) $ECHO_C" >&6
12952 else
12953   ac_check_lib_save_LIBS=$LIBS
12954 LIBS="-lm  $LIBS"
12955 if test x$gcc_no_link = xyes; then
12956   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
12957 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
12958    { (exit 1); exit 1; }; }
12959 fi
12960 cat >conftest.$ac_ext <<_ACEOF
12961 /* confdefs.h.  */
12962 _ACEOF
12963 cat confdefs.h >>conftest.$ac_ext
12964 cat >>conftest.$ac_ext <<_ACEOF
12965 /* end confdefs.h.  */
12966
12967 /* Override any gcc2 internal prototype to avoid an error.  */
12968 #ifdef __cplusplus
12969 extern "C"
12970 #endif
12971 /* We use char because int might match the return type of a gcc2
12972    builtin and then its argument prototype would still apply.  */
12973 char clogl ();
12974 int
12975 main ()
12976 {
12977 clogl ();
12978   ;
12979   return 0;
12980 }
12981 _ACEOF
12982 rm -f conftest.$ac_objext conftest$ac_exeext
12983 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12984   (eval $ac_link) 2>conftest.er1
12985   ac_status=$?
12986   grep -v '^ *+' conftest.er1 >conftest.err
12987   rm -f conftest.er1
12988   cat conftest.err >&5
12989   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12990   (exit $ac_status); } &&
12991          { ac_try='test -z "$ac_c_werror_flag"
12992                          || test ! -s conftest.err'
12993   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12994   (eval $ac_try) 2>&5
12995   ac_status=$?
12996   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12997   (exit $ac_status); }; } &&
12998          { ac_try='test -s conftest$ac_exeext'
12999   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13000   (eval $ac_try) 2>&5
13001   ac_status=$?
13002   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13003   (exit $ac_status); }; }; then
13004   ac_cv_lib_m_clogl=yes
13005 else
13006   echo "$as_me: failed program was:" >&5
13007 sed 's/^/| /' conftest.$ac_ext >&5
13008
13009 ac_cv_lib_m_clogl=no
13010 fi
13011 rm -f conftest.err conftest.$ac_objext \
13012       conftest$ac_exeext conftest.$ac_ext
13013 LIBS=$ac_check_lib_save_LIBS
13014 fi
13015 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clogl" >&5
13016 echo "${ECHO_T}$ac_cv_lib_m_clogl" >&6
13017 if test $ac_cv_lib_m_clogl = yes; then
13018
13019 cat >>confdefs.h <<\_ACEOF
13020 #define HAVE_CLOGL 1
13021 _ACEOF
13022
13023 fi
13024
13025 echo "$as_me:$LINENO: checking for log10f in -lm" >&5
13026 echo $ECHO_N "checking for log10f in -lm... $ECHO_C" >&6
13027 if test "${ac_cv_lib_m_log10f+set}" = set; then
13028   echo $ECHO_N "(cached) $ECHO_C" >&6
13029 else
13030   ac_check_lib_save_LIBS=$LIBS
13031 LIBS="-lm  $LIBS"
13032 if test x$gcc_no_link = xyes; then
13033   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13034 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13035    { (exit 1); exit 1; }; }
13036 fi
13037 cat >conftest.$ac_ext <<_ACEOF
13038 /* confdefs.h.  */
13039 _ACEOF
13040 cat confdefs.h >>conftest.$ac_ext
13041 cat >>conftest.$ac_ext <<_ACEOF
13042 /* end confdefs.h.  */
13043
13044 /* Override any gcc2 internal prototype to avoid an error.  */
13045 #ifdef __cplusplus
13046 extern "C"
13047 #endif
13048 /* We use char because int might match the return type of a gcc2
13049    builtin and then its argument prototype would still apply.  */
13050 char log10f ();
13051 int
13052 main ()
13053 {
13054 log10f ();
13055   ;
13056   return 0;
13057 }
13058 _ACEOF
13059 rm -f conftest.$ac_objext conftest$ac_exeext
13060 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13061   (eval $ac_link) 2>conftest.er1
13062   ac_status=$?
13063   grep -v '^ *+' conftest.er1 >conftest.err
13064   rm -f conftest.er1
13065   cat conftest.err >&5
13066   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13067   (exit $ac_status); } &&
13068          { ac_try='test -z "$ac_c_werror_flag"
13069                          || test ! -s conftest.err'
13070   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13071   (eval $ac_try) 2>&5
13072   ac_status=$?
13073   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13074   (exit $ac_status); }; } &&
13075          { ac_try='test -s conftest$ac_exeext'
13076   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13077   (eval $ac_try) 2>&5
13078   ac_status=$?
13079   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13080   (exit $ac_status); }; }; then
13081   ac_cv_lib_m_log10f=yes
13082 else
13083   echo "$as_me: failed program was:" >&5
13084 sed 's/^/| /' conftest.$ac_ext >&5
13085
13086 ac_cv_lib_m_log10f=no
13087 fi
13088 rm -f conftest.err conftest.$ac_objext \
13089       conftest$ac_exeext conftest.$ac_ext
13090 LIBS=$ac_check_lib_save_LIBS
13091 fi
13092 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10f" >&5
13093 echo "${ECHO_T}$ac_cv_lib_m_log10f" >&6
13094 if test $ac_cv_lib_m_log10f = yes; then
13095
13096 cat >>confdefs.h <<\_ACEOF
13097 #define HAVE_LOG10F 1
13098 _ACEOF
13099
13100 fi
13101
13102 echo "$as_me:$LINENO: checking for log10 in -lm" >&5
13103 echo $ECHO_N "checking for log10 in -lm... $ECHO_C" >&6
13104 if test "${ac_cv_lib_m_log10+set}" = set; then
13105   echo $ECHO_N "(cached) $ECHO_C" >&6
13106 else
13107   ac_check_lib_save_LIBS=$LIBS
13108 LIBS="-lm  $LIBS"
13109 if test x$gcc_no_link = xyes; then
13110   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13111 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13112    { (exit 1); exit 1; }; }
13113 fi
13114 cat >conftest.$ac_ext <<_ACEOF
13115 /* confdefs.h.  */
13116 _ACEOF
13117 cat confdefs.h >>conftest.$ac_ext
13118 cat >>conftest.$ac_ext <<_ACEOF
13119 /* end confdefs.h.  */
13120
13121 /* Override any gcc2 internal prototype to avoid an error.  */
13122 #ifdef __cplusplus
13123 extern "C"
13124 #endif
13125 /* We use char because int might match the return type of a gcc2
13126    builtin and then its argument prototype would still apply.  */
13127 char log10 ();
13128 int
13129 main ()
13130 {
13131 log10 ();
13132   ;
13133   return 0;
13134 }
13135 _ACEOF
13136 rm -f conftest.$ac_objext conftest$ac_exeext
13137 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13138   (eval $ac_link) 2>conftest.er1
13139   ac_status=$?
13140   grep -v '^ *+' conftest.er1 >conftest.err
13141   rm -f conftest.er1
13142   cat conftest.err >&5
13143   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13144   (exit $ac_status); } &&
13145          { ac_try='test -z "$ac_c_werror_flag"
13146                          || test ! -s conftest.err'
13147   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13148   (eval $ac_try) 2>&5
13149   ac_status=$?
13150   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13151   (exit $ac_status); }; } &&
13152          { ac_try='test -s conftest$ac_exeext'
13153   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13154   (eval $ac_try) 2>&5
13155   ac_status=$?
13156   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13157   (exit $ac_status); }; }; then
13158   ac_cv_lib_m_log10=yes
13159 else
13160   echo "$as_me: failed program was:" >&5
13161 sed 's/^/| /' conftest.$ac_ext >&5
13162
13163 ac_cv_lib_m_log10=no
13164 fi
13165 rm -f conftest.err conftest.$ac_objext \
13166       conftest$ac_exeext conftest.$ac_ext
13167 LIBS=$ac_check_lib_save_LIBS
13168 fi
13169 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10" >&5
13170 echo "${ECHO_T}$ac_cv_lib_m_log10" >&6
13171 if test $ac_cv_lib_m_log10 = yes; then
13172
13173 cat >>confdefs.h <<\_ACEOF
13174 #define HAVE_LOG10 1
13175 _ACEOF
13176
13177 fi
13178
13179 echo "$as_me:$LINENO: checking for log10l in -lm" >&5
13180 echo $ECHO_N "checking for log10l in -lm... $ECHO_C" >&6
13181 if test "${ac_cv_lib_m_log10l+set}" = set; then
13182   echo $ECHO_N "(cached) $ECHO_C" >&6
13183 else
13184   ac_check_lib_save_LIBS=$LIBS
13185 LIBS="-lm  $LIBS"
13186 if test x$gcc_no_link = xyes; then
13187   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13188 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13189    { (exit 1); exit 1; }; }
13190 fi
13191 cat >conftest.$ac_ext <<_ACEOF
13192 /* confdefs.h.  */
13193 _ACEOF
13194 cat confdefs.h >>conftest.$ac_ext
13195 cat >>conftest.$ac_ext <<_ACEOF
13196 /* end confdefs.h.  */
13197
13198 /* Override any gcc2 internal prototype to avoid an error.  */
13199 #ifdef __cplusplus
13200 extern "C"
13201 #endif
13202 /* We use char because int might match the return type of a gcc2
13203    builtin and then its argument prototype would still apply.  */
13204 char log10l ();
13205 int
13206 main ()
13207 {
13208 log10l ();
13209   ;
13210   return 0;
13211 }
13212 _ACEOF
13213 rm -f conftest.$ac_objext conftest$ac_exeext
13214 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13215   (eval $ac_link) 2>conftest.er1
13216   ac_status=$?
13217   grep -v '^ *+' conftest.er1 >conftest.err
13218   rm -f conftest.er1
13219   cat conftest.err >&5
13220   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13221   (exit $ac_status); } &&
13222          { ac_try='test -z "$ac_c_werror_flag"
13223                          || test ! -s conftest.err'
13224   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13225   (eval $ac_try) 2>&5
13226   ac_status=$?
13227   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13228   (exit $ac_status); }; } &&
13229          { ac_try='test -s conftest$ac_exeext'
13230   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13231   (eval $ac_try) 2>&5
13232   ac_status=$?
13233   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13234   (exit $ac_status); }; }; then
13235   ac_cv_lib_m_log10l=yes
13236 else
13237   echo "$as_me: failed program was:" >&5
13238 sed 's/^/| /' conftest.$ac_ext >&5
13239
13240 ac_cv_lib_m_log10l=no
13241 fi
13242 rm -f conftest.err conftest.$ac_objext \
13243       conftest$ac_exeext conftest.$ac_ext
13244 LIBS=$ac_check_lib_save_LIBS
13245 fi
13246 echo "$as_me:$LINENO: result: $ac_cv_lib_m_log10l" >&5
13247 echo "${ECHO_T}$ac_cv_lib_m_log10l" >&6
13248 if test $ac_cv_lib_m_log10l = yes; then
13249
13250 cat >>confdefs.h <<\_ACEOF
13251 #define HAVE_LOG10L 1
13252 _ACEOF
13253
13254 fi
13255
13256 echo "$as_me:$LINENO: checking for clog10f in -lm" >&5
13257 echo $ECHO_N "checking for clog10f in -lm... $ECHO_C" >&6
13258 if test "${ac_cv_lib_m_clog10f+set}" = set; then
13259   echo $ECHO_N "(cached) $ECHO_C" >&6
13260 else
13261   ac_check_lib_save_LIBS=$LIBS
13262 LIBS="-lm  $LIBS"
13263 if test x$gcc_no_link = xyes; then
13264   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13265 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13266    { (exit 1); exit 1; }; }
13267 fi
13268 cat >conftest.$ac_ext <<_ACEOF
13269 /* confdefs.h.  */
13270 _ACEOF
13271 cat confdefs.h >>conftest.$ac_ext
13272 cat >>conftest.$ac_ext <<_ACEOF
13273 /* end confdefs.h.  */
13274
13275 /* Override any gcc2 internal prototype to avoid an error.  */
13276 #ifdef __cplusplus
13277 extern "C"
13278 #endif
13279 /* We use char because int might match the return type of a gcc2
13280    builtin and then its argument prototype would still apply.  */
13281 char clog10f ();
13282 int
13283 main ()
13284 {
13285 clog10f ();
13286   ;
13287   return 0;
13288 }
13289 _ACEOF
13290 rm -f conftest.$ac_objext conftest$ac_exeext
13291 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13292   (eval $ac_link) 2>conftest.er1
13293   ac_status=$?
13294   grep -v '^ *+' conftest.er1 >conftest.err
13295   rm -f conftest.er1
13296   cat conftest.err >&5
13297   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13298   (exit $ac_status); } &&
13299          { ac_try='test -z "$ac_c_werror_flag"
13300                          || test ! -s conftest.err'
13301   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13302   (eval $ac_try) 2>&5
13303   ac_status=$?
13304   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13305   (exit $ac_status); }; } &&
13306          { ac_try='test -s conftest$ac_exeext'
13307   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13308   (eval $ac_try) 2>&5
13309   ac_status=$?
13310   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13311   (exit $ac_status); }; }; then
13312   ac_cv_lib_m_clog10f=yes
13313 else
13314   echo "$as_me: failed program was:" >&5
13315 sed 's/^/| /' conftest.$ac_ext >&5
13316
13317 ac_cv_lib_m_clog10f=no
13318 fi
13319 rm -f conftest.err conftest.$ac_objext \
13320       conftest$ac_exeext conftest.$ac_ext
13321 LIBS=$ac_check_lib_save_LIBS
13322 fi
13323 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10f" >&5
13324 echo "${ECHO_T}$ac_cv_lib_m_clog10f" >&6
13325 if test $ac_cv_lib_m_clog10f = yes; then
13326
13327 cat >>confdefs.h <<\_ACEOF
13328 #define HAVE_CLOG10F 1
13329 _ACEOF
13330
13331 fi
13332
13333 echo "$as_me:$LINENO: checking for clog10 in -lm" >&5
13334 echo $ECHO_N "checking for clog10 in -lm... $ECHO_C" >&6
13335 if test "${ac_cv_lib_m_clog10+set}" = set; then
13336   echo $ECHO_N "(cached) $ECHO_C" >&6
13337 else
13338   ac_check_lib_save_LIBS=$LIBS
13339 LIBS="-lm  $LIBS"
13340 if test x$gcc_no_link = xyes; then
13341   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13342 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13343    { (exit 1); exit 1; }; }
13344 fi
13345 cat >conftest.$ac_ext <<_ACEOF
13346 /* confdefs.h.  */
13347 _ACEOF
13348 cat confdefs.h >>conftest.$ac_ext
13349 cat >>conftest.$ac_ext <<_ACEOF
13350 /* end confdefs.h.  */
13351
13352 /* Override any gcc2 internal prototype to avoid an error.  */
13353 #ifdef __cplusplus
13354 extern "C"
13355 #endif
13356 /* We use char because int might match the return type of a gcc2
13357    builtin and then its argument prototype would still apply.  */
13358 char clog10 ();
13359 int
13360 main ()
13361 {
13362 clog10 ();
13363   ;
13364   return 0;
13365 }
13366 _ACEOF
13367 rm -f conftest.$ac_objext conftest$ac_exeext
13368 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13369   (eval $ac_link) 2>conftest.er1
13370   ac_status=$?
13371   grep -v '^ *+' conftest.er1 >conftest.err
13372   rm -f conftest.er1
13373   cat conftest.err >&5
13374   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13375   (exit $ac_status); } &&
13376          { ac_try='test -z "$ac_c_werror_flag"
13377                          || test ! -s conftest.err'
13378   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13379   (eval $ac_try) 2>&5
13380   ac_status=$?
13381   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13382   (exit $ac_status); }; } &&
13383          { ac_try='test -s conftest$ac_exeext'
13384   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13385   (eval $ac_try) 2>&5
13386   ac_status=$?
13387   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13388   (exit $ac_status); }; }; then
13389   ac_cv_lib_m_clog10=yes
13390 else
13391   echo "$as_me: failed program was:" >&5
13392 sed 's/^/| /' conftest.$ac_ext >&5
13393
13394 ac_cv_lib_m_clog10=no
13395 fi
13396 rm -f conftest.err conftest.$ac_objext \
13397       conftest$ac_exeext conftest.$ac_ext
13398 LIBS=$ac_check_lib_save_LIBS
13399 fi
13400 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10" >&5
13401 echo "${ECHO_T}$ac_cv_lib_m_clog10" >&6
13402 if test $ac_cv_lib_m_clog10 = yes; then
13403
13404 cat >>confdefs.h <<\_ACEOF
13405 #define HAVE_CLOG10 1
13406 _ACEOF
13407
13408 fi
13409
13410 echo "$as_me:$LINENO: checking for clog10l in -lm" >&5
13411 echo $ECHO_N "checking for clog10l in -lm... $ECHO_C" >&6
13412 if test "${ac_cv_lib_m_clog10l+set}" = set; then
13413   echo $ECHO_N "(cached) $ECHO_C" >&6
13414 else
13415   ac_check_lib_save_LIBS=$LIBS
13416 LIBS="-lm  $LIBS"
13417 if test x$gcc_no_link = xyes; then
13418   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13419 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13420    { (exit 1); exit 1; }; }
13421 fi
13422 cat >conftest.$ac_ext <<_ACEOF
13423 /* confdefs.h.  */
13424 _ACEOF
13425 cat confdefs.h >>conftest.$ac_ext
13426 cat >>conftest.$ac_ext <<_ACEOF
13427 /* end confdefs.h.  */
13428
13429 /* Override any gcc2 internal prototype to avoid an error.  */
13430 #ifdef __cplusplus
13431 extern "C"
13432 #endif
13433 /* We use char because int might match the return type of a gcc2
13434    builtin and then its argument prototype would still apply.  */
13435 char clog10l ();
13436 int
13437 main ()
13438 {
13439 clog10l ();
13440   ;
13441   return 0;
13442 }
13443 _ACEOF
13444 rm -f conftest.$ac_objext conftest$ac_exeext
13445 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13446   (eval $ac_link) 2>conftest.er1
13447   ac_status=$?
13448   grep -v '^ *+' conftest.er1 >conftest.err
13449   rm -f conftest.er1
13450   cat conftest.err >&5
13451   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13452   (exit $ac_status); } &&
13453          { ac_try='test -z "$ac_c_werror_flag"
13454                          || test ! -s conftest.err'
13455   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13456   (eval $ac_try) 2>&5
13457   ac_status=$?
13458   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13459   (exit $ac_status); }; } &&
13460          { ac_try='test -s conftest$ac_exeext'
13461   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13462   (eval $ac_try) 2>&5
13463   ac_status=$?
13464   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13465   (exit $ac_status); }; }; then
13466   ac_cv_lib_m_clog10l=yes
13467 else
13468   echo "$as_me: failed program was:" >&5
13469 sed 's/^/| /' conftest.$ac_ext >&5
13470
13471 ac_cv_lib_m_clog10l=no
13472 fi
13473 rm -f conftest.err conftest.$ac_objext \
13474       conftest$ac_exeext conftest.$ac_ext
13475 LIBS=$ac_check_lib_save_LIBS
13476 fi
13477 echo "$as_me:$LINENO: result: $ac_cv_lib_m_clog10l" >&5
13478 echo "${ECHO_T}$ac_cv_lib_m_clog10l" >&6
13479 if test $ac_cv_lib_m_clog10l = yes; then
13480
13481 cat >>confdefs.h <<\_ACEOF
13482 #define HAVE_CLOG10L 1
13483 _ACEOF
13484
13485 fi
13486
13487 echo "$as_me:$LINENO: checking for nextafterf in -lm" >&5
13488 echo $ECHO_N "checking for nextafterf in -lm... $ECHO_C" >&6
13489 if test "${ac_cv_lib_m_nextafterf+set}" = set; then
13490   echo $ECHO_N "(cached) $ECHO_C" >&6
13491 else
13492   ac_check_lib_save_LIBS=$LIBS
13493 LIBS="-lm  $LIBS"
13494 if test x$gcc_no_link = xyes; then
13495   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13496 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13497    { (exit 1); exit 1; }; }
13498 fi
13499 cat >conftest.$ac_ext <<_ACEOF
13500 /* confdefs.h.  */
13501 _ACEOF
13502 cat confdefs.h >>conftest.$ac_ext
13503 cat >>conftest.$ac_ext <<_ACEOF
13504 /* end confdefs.h.  */
13505
13506 /* Override any gcc2 internal prototype to avoid an error.  */
13507 #ifdef __cplusplus
13508 extern "C"
13509 #endif
13510 /* We use char because int might match the return type of a gcc2
13511    builtin and then its argument prototype would still apply.  */
13512 char nextafterf ();
13513 int
13514 main ()
13515 {
13516 nextafterf ();
13517   ;
13518   return 0;
13519 }
13520 _ACEOF
13521 rm -f conftest.$ac_objext conftest$ac_exeext
13522 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13523   (eval $ac_link) 2>conftest.er1
13524   ac_status=$?
13525   grep -v '^ *+' conftest.er1 >conftest.err
13526   rm -f conftest.er1
13527   cat conftest.err >&5
13528   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13529   (exit $ac_status); } &&
13530          { ac_try='test -z "$ac_c_werror_flag"
13531                          || test ! -s conftest.err'
13532   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13533   (eval $ac_try) 2>&5
13534   ac_status=$?
13535   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13536   (exit $ac_status); }; } &&
13537          { ac_try='test -s conftest$ac_exeext'
13538   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13539   (eval $ac_try) 2>&5
13540   ac_status=$?
13541   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13542   (exit $ac_status); }; }; then
13543   ac_cv_lib_m_nextafterf=yes
13544 else
13545   echo "$as_me: failed program was:" >&5
13546 sed 's/^/| /' conftest.$ac_ext >&5
13547
13548 ac_cv_lib_m_nextafterf=no
13549 fi
13550 rm -f conftest.err conftest.$ac_objext \
13551       conftest$ac_exeext conftest.$ac_ext
13552 LIBS=$ac_check_lib_save_LIBS
13553 fi
13554 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafterf" >&5
13555 echo "${ECHO_T}$ac_cv_lib_m_nextafterf" >&6
13556 if test $ac_cv_lib_m_nextafterf = yes; then
13557
13558 cat >>confdefs.h <<\_ACEOF
13559 #define HAVE_NEXTAFTERF 1
13560 _ACEOF
13561
13562 fi
13563
13564 echo "$as_me:$LINENO: checking for nextafter in -lm" >&5
13565 echo $ECHO_N "checking for nextafter in -lm... $ECHO_C" >&6
13566 if test "${ac_cv_lib_m_nextafter+set}" = set; then
13567   echo $ECHO_N "(cached) $ECHO_C" >&6
13568 else
13569   ac_check_lib_save_LIBS=$LIBS
13570 LIBS="-lm  $LIBS"
13571 if test x$gcc_no_link = xyes; then
13572   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13573 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13574    { (exit 1); exit 1; }; }
13575 fi
13576 cat >conftest.$ac_ext <<_ACEOF
13577 /* confdefs.h.  */
13578 _ACEOF
13579 cat confdefs.h >>conftest.$ac_ext
13580 cat >>conftest.$ac_ext <<_ACEOF
13581 /* end confdefs.h.  */
13582
13583 /* Override any gcc2 internal prototype to avoid an error.  */
13584 #ifdef __cplusplus
13585 extern "C"
13586 #endif
13587 /* We use char because int might match the return type of a gcc2
13588    builtin and then its argument prototype would still apply.  */
13589 char nextafter ();
13590 int
13591 main ()
13592 {
13593 nextafter ();
13594   ;
13595   return 0;
13596 }
13597 _ACEOF
13598 rm -f conftest.$ac_objext conftest$ac_exeext
13599 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13600   (eval $ac_link) 2>conftest.er1
13601   ac_status=$?
13602   grep -v '^ *+' conftest.er1 >conftest.err
13603   rm -f conftest.er1
13604   cat conftest.err >&5
13605   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13606   (exit $ac_status); } &&
13607          { ac_try='test -z "$ac_c_werror_flag"
13608                          || test ! -s conftest.err'
13609   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13610   (eval $ac_try) 2>&5
13611   ac_status=$?
13612   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13613   (exit $ac_status); }; } &&
13614          { ac_try='test -s conftest$ac_exeext'
13615   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13616   (eval $ac_try) 2>&5
13617   ac_status=$?
13618   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13619   (exit $ac_status); }; }; then
13620   ac_cv_lib_m_nextafter=yes
13621 else
13622   echo "$as_me: failed program was:" >&5
13623 sed 's/^/| /' conftest.$ac_ext >&5
13624
13625 ac_cv_lib_m_nextafter=no
13626 fi
13627 rm -f conftest.err conftest.$ac_objext \
13628       conftest$ac_exeext conftest.$ac_ext
13629 LIBS=$ac_check_lib_save_LIBS
13630 fi
13631 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafter" >&5
13632 echo "${ECHO_T}$ac_cv_lib_m_nextafter" >&6
13633 if test $ac_cv_lib_m_nextafter = yes; then
13634
13635 cat >>confdefs.h <<\_ACEOF
13636 #define HAVE_NEXTAFTER 1
13637 _ACEOF
13638
13639 fi
13640
13641 echo "$as_me:$LINENO: checking for nextafterl in -lm" >&5
13642 echo $ECHO_N "checking for nextafterl in -lm... $ECHO_C" >&6
13643 if test "${ac_cv_lib_m_nextafterl+set}" = set; then
13644   echo $ECHO_N "(cached) $ECHO_C" >&6
13645 else
13646   ac_check_lib_save_LIBS=$LIBS
13647 LIBS="-lm  $LIBS"
13648 if test x$gcc_no_link = xyes; then
13649   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13650 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13651    { (exit 1); exit 1; }; }
13652 fi
13653 cat >conftest.$ac_ext <<_ACEOF
13654 /* confdefs.h.  */
13655 _ACEOF
13656 cat confdefs.h >>conftest.$ac_ext
13657 cat >>conftest.$ac_ext <<_ACEOF
13658 /* end confdefs.h.  */
13659
13660 /* Override any gcc2 internal prototype to avoid an error.  */
13661 #ifdef __cplusplus
13662 extern "C"
13663 #endif
13664 /* We use char because int might match the return type of a gcc2
13665    builtin and then its argument prototype would still apply.  */
13666 char nextafterl ();
13667 int
13668 main ()
13669 {
13670 nextafterl ();
13671   ;
13672   return 0;
13673 }
13674 _ACEOF
13675 rm -f conftest.$ac_objext conftest$ac_exeext
13676 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13677   (eval $ac_link) 2>conftest.er1
13678   ac_status=$?
13679   grep -v '^ *+' conftest.er1 >conftest.err
13680   rm -f conftest.er1
13681   cat conftest.err >&5
13682   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13683   (exit $ac_status); } &&
13684          { ac_try='test -z "$ac_c_werror_flag"
13685                          || test ! -s conftest.err'
13686   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13687   (eval $ac_try) 2>&5
13688   ac_status=$?
13689   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13690   (exit $ac_status); }; } &&
13691          { ac_try='test -s conftest$ac_exeext'
13692   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13693   (eval $ac_try) 2>&5
13694   ac_status=$?
13695   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13696   (exit $ac_status); }; }; then
13697   ac_cv_lib_m_nextafterl=yes
13698 else
13699   echo "$as_me: failed program was:" >&5
13700 sed 's/^/| /' conftest.$ac_ext >&5
13701
13702 ac_cv_lib_m_nextafterl=no
13703 fi
13704 rm -f conftest.err conftest.$ac_objext \
13705       conftest$ac_exeext conftest.$ac_ext
13706 LIBS=$ac_check_lib_save_LIBS
13707 fi
13708 echo "$as_me:$LINENO: result: $ac_cv_lib_m_nextafterl" >&5
13709 echo "${ECHO_T}$ac_cv_lib_m_nextafterl" >&6
13710 if test $ac_cv_lib_m_nextafterl = yes; then
13711
13712 cat >>confdefs.h <<\_ACEOF
13713 #define HAVE_NEXTAFTERL 1
13714 _ACEOF
13715
13716 fi
13717
13718 echo "$as_me:$LINENO: checking for powf in -lm" >&5
13719 echo $ECHO_N "checking for powf in -lm... $ECHO_C" >&6
13720 if test "${ac_cv_lib_m_powf+set}" = set; then
13721   echo $ECHO_N "(cached) $ECHO_C" >&6
13722 else
13723   ac_check_lib_save_LIBS=$LIBS
13724 LIBS="-lm  $LIBS"
13725 if test x$gcc_no_link = xyes; then
13726   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13727 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13728    { (exit 1); exit 1; }; }
13729 fi
13730 cat >conftest.$ac_ext <<_ACEOF
13731 /* confdefs.h.  */
13732 _ACEOF
13733 cat confdefs.h >>conftest.$ac_ext
13734 cat >>conftest.$ac_ext <<_ACEOF
13735 /* end confdefs.h.  */
13736
13737 /* Override any gcc2 internal prototype to avoid an error.  */
13738 #ifdef __cplusplus
13739 extern "C"
13740 #endif
13741 /* We use char because int might match the return type of a gcc2
13742    builtin and then its argument prototype would still apply.  */
13743 char powf ();
13744 int
13745 main ()
13746 {
13747 powf ();
13748   ;
13749   return 0;
13750 }
13751 _ACEOF
13752 rm -f conftest.$ac_objext conftest$ac_exeext
13753 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13754   (eval $ac_link) 2>conftest.er1
13755   ac_status=$?
13756   grep -v '^ *+' conftest.er1 >conftest.err
13757   rm -f conftest.er1
13758   cat conftest.err >&5
13759   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13760   (exit $ac_status); } &&
13761          { ac_try='test -z "$ac_c_werror_flag"
13762                          || test ! -s conftest.err'
13763   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13764   (eval $ac_try) 2>&5
13765   ac_status=$?
13766   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13767   (exit $ac_status); }; } &&
13768          { ac_try='test -s conftest$ac_exeext'
13769   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13770   (eval $ac_try) 2>&5
13771   ac_status=$?
13772   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13773   (exit $ac_status); }; }; then
13774   ac_cv_lib_m_powf=yes
13775 else
13776   echo "$as_me: failed program was:" >&5
13777 sed 's/^/| /' conftest.$ac_ext >&5
13778
13779 ac_cv_lib_m_powf=no
13780 fi
13781 rm -f conftest.err conftest.$ac_objext \
13782       conftest$ac_exeext conftest.$ac_ext
13783 LIBS=$ac_check_lib_save_LIBS
13784 fi
13785 echo "$as_me:$LINENO: result: $ac_cv_lib_m_powf" >&5
13786 echo "${ECHO_T}$ac_cv_lib_m_powf" >&6
13787 if test $ac_cv_lib_m_powf = yes; then
13788
13789 cat >>confdefs.h <<\_ACEOF
13790 #define HAVE_POWF 1
13791 _ACEOF
13792
13793 fi
13794
13795 echo "$as_me:$LINENO: checking for pow in -lm" >&5
13796 echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
13797 if test "${ac_cv_lib_m_pow+set}" = set; then
13798   echo $ECHO_N "(cached) $ECHO_C" >&6
13799 else
13800   ac_check_lib_save_LIBS=$LIBS
13801 LIBS="-lm  $LIBS"
13802 if test x$gcc_no_link = xyes; then
13803   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13804 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13805    { (exit 1); exit 1; }; }
13806 fi
13807 cat >conftest.$ac_ext <<_ACEOF
13808 /* confdefs.h.  */
13809 _ACEOF
13810 cat confdefs.h >>conftest.$ac_ext
13811 cat >>conftest.$ac_ext <<_ACEOF
13812 /* end confdefs.h.  */
13813
13814 /* Override any gcc2 internal prototype to avoid an error.  */
13815 #ifdef __cplusplus
13816 extern "C"
13817 #endif
13818 /* We use char because int might match the return type of a gcc2
13819    builtin and then its argument prototype would still apply.  */
13820 char pow ();
13821 int
13822 main ()
13823 {
13824 pow ();
13825   ;
13826   return 0;
13827 }
13828 _ACEOF
13829 rm -f conftest.$ac_objext conftest$ac_exeext
13830 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13831   (eval $ac_link) 2>conftest.er1
13832   ac_status=$?
13833   grep -v '^ *+' conftest.er1 >conftest.err
13834   rm -f conftest.er1
13835   cat conftest.err >&5
13836   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13837   (exit $ac_status); } &&
13838          { ac_try='test -z "$ac_c_werror_flag"
13839                          || test ! -s conftest.err'
13840   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13841   (eval $ac_try) 2>&5
13842   ac_status=$?
13843   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13844   (exit $ac_status); }; } &&
13845          { ac_try='test -s conftest$ac_exeext'
13846   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13847   (eval $ac_try) 2>&5
13848   ac_status=$?
13849   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13850   (exit $ac_status); }; }; then
13851   ac_cv_lib_m_pow=yes
13852 else
13853   echo "$as_me: failed program was:" >&5
13854 sed 's/^/| /' conftest.$ac_ext >&5
13855
13856 ac_cv_lib_m_pow=no
13857 fi
13858 rm -f conftest.err conftest.$ac_objext \
13859       conftest$ac_exeext conftest.$ac_ext
13860 LIBS=$ac_check_lib_save_LIBS
13861 fi
13862 echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
13863 echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
13864 if test $ac_cv_lib_m_pow = yes; then
13865
13866 cat >>confdefs.h <<\_ACEOF
13867 #define HAVE_POW 1
13868 _ACEOF
13869
13870 fi
13871
13872 echo "$as_me:$LINENO: checking for powl in -lm" >&5
13873 echo $ECHO_N "checking for powl in -lm... $ECHO_C" >&6
13874 if test "${ac_cv_lib_m_powl+set}" = set; then
13875   echo $ECHO_N "(cached) $ECHO_C" >&6
13876 else
13877   ac_check_lib_save_LIBS=$LIBS
13878 LIBS="-lm  $LIBS"
13879 if test x$gcc_no_link = xyes; then
13880   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13881 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13882    { (exit 1); exit 1; }; }
13883 fi
13884 cat >conftest.$ac_ext <<_ACEOF
13885 /* confdefs.h.  */
13886 _ACEOF
13887 cat confdefs.h >>conftest.$ac_ext
13888 cat >>conftest.$ac_ext <<_ACEOF
13889 /* end confdefs.h.  */
13890
13891 /* Override any gcc2 internal prototype to avoid an error.  */
13892 #ifdef __cplusplus
13893 extern "C"
13894 #endif
13895 /* We use char because int might match the return type of a gcc2
13896    builtin and then its argument prototype would still apply.  */
13897 char powl ();
13898 int
13899 main ()
13900 {
13901 powl ();
13902   ;
13903   return 0;
13904 }
13905 _ACEOF
13906 rm -f conftest.$ac_objext conftest$ac_exeext
13907 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13908   (eval $ac_link) 2>conftest.er1
13909   ac_status=$?
13910   grep -v '^ *+' conftest.er1 >conftest.err
13911   rm -f conftest.er1
13912   cat conftest.err >&5
13913   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13914   (exit $ac_status); } &&
13915          { ac_try='test -z "$ac_c_werror_flag"
13916                          || test ! -s conftest.err'
13917   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13918   (eval $ac_try) 2>&5
13919   ac_status=$?
13920   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13921   (exit $ac_status); }; } &&
13922          { ac_try='test -s conftest$ac_exeext'
13923   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13924   (eval $ac_try) 2>&5
13925   ac_status=$?
13926   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13927   (exit $ac_status); }; }; then
13928   ac_cv_lib_m_powl=yes
13929 else
13930   echo "$as_me: failed program was:" >&5
13931 sed 's/^/| /' conftest.$ac_ext >&5
13932
13933 ac_cv_lib_m_powl=no
13934 fi
13935 rm -f conftest.err conftest.$ac_objext \
13936       conftest$ac_exeext conftest.$ac_ext
13937 LIBS=$ac_check_lib_save_LIBS
13938 fi
13939 echo "$as_me:$LINENO: result: $ac_cv_lib_m_powl" >&5
13940 echo "${ECHO_T}$ac_cv_lib_m_powl" >&6
13941 if test $ac_cv_lib_m_powl = yes; then
13942
13943 cat >>confdefs.h <<\_ACEOF
13944 #define HAVE_POWL 1
13945 _ACEOF
13946
13947 fi
13948
13949 echo "$as_me:$LINENO: checking for cpowf in -lm" >&5
13950 echo $ECHO_N "checking for cpowf in -lm... $ECHO_C" >&6
13951 if test "${ac_cv_lib_m_cpowf+set}" = set; then
13952   echo $ECHO_N "(cached) $ECHO_C" >&6
13953 else
13954   ac_check_lib_save_LIBS=$LIBS
13955 LIBS="-lm  $LIBS"
13956 if test x$gcc_no_link = xyes; then
13957   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
13958 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
13959    { (exit 1); exit 1; }; }
13960 fi
13961 cat >conftest.$ac_ext <<_ACEOF
13962 /* confdefs.h.  */
13963 _ACEOF
13964 cat confdefs.h >>conftest.$ac_ext
13965 cat >>conftest.$ac_ext <<_ACEOF
13966 /* end confdefs.h.  */
13967
13968 /* Override any gcc2 internal prototype to avoid an error.  */
13969 #ifdef __cplusplus
13970 extern "C"
13971 #endif
13972 /* We use char because int might match the return type of a gcc2
13973    builtin and then its argument prototype would still apply.  */
13974 char cpowf ();
13975 int
13976 main ()
13977 {
13978 cpowf ();
13979   ;
13980   return 0;
13981 }
13982 _ACEOF
13983 rm -f conftest.$ac_objext conftest$ac_exeext
13984 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13985   (eval $ac_link) 2>conftest.er1
13986   ac_status=$?
13987   grep -v '^ *+' conftest.er1 >conftest.err
13988   rm -f conftest.er1
13989   cat conftest.err >&5
13990   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13991   (exit $ac_status); } &&
13992          { ac_try='test -z "$ac_c_werror_flag"
13993                          || test ! -s conftest.err'
13994   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13995   (eval $ac_try) 2>&5
13996   ac_status=$?
13997   echo "$as_me:$LINENO: \$? = $ac_status" >&5
13998   (exit $ac_status); }; } &&
13999          { ac_try='test -s conftest$ac_exeext'
14000   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14001   (eval $ac_try) 2>&5
14002   ac_status=$?
14003   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14004   (exit $ac_status); }; }; then
14005   ac_cv_lib_m_cpowf=yes
14006 else
14007   echo "$as_me: failed program was:" >&5
14008 sed 's/^/| /' conftest.$ac_ext >&5
14009
14010 ac_cv_lib_m_cpowf=no
14011 fi
14012 rm -f conftest.err conftest.$ac_objext \
14013       conftest$ac_exeext conftest.$ac_ext
14014 LIBS=$ac_check_lib_save_LIBS
14015 fi
14016 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpowf" >&5
14017 echo "${ECHO_T}$ac_cv_lib_m_cpowf" >&6
14018 if test $ac_cv_lib_m_cpowf = yes; then
14019
14020 cat >>confdefs.h <<\_ACEOF
14021 #define HAVE_CPOWF 1
14022 _ACEOF
14023
14024 fi
14025
14026 echo "$as_me:$LINENO: checking for cpow in -lm" >&5
14027 echo $ECHO_N "checking for cpow in -lm... $ECHO_C" >&6
14028 if test "${ac_cv_lib_m_cpow+set}" = set; then
14029   echo $ECHO_N "(cached) $ECHO_C" >&6
14030 else
14031   ac_check_lib_save_LIBS=$LIBS
14032 LIBS="-lm  $LIBS"
14033 if test x$gcc_no_link = xyes; then
14034   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14035 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14036    { (exit 1); exit 1; }; }
14037 fi
14038 cat >conftest.$ac_ext <<_ACEOF
14039 /* confdefs.h.  */
14040 _ACEOF
14041 cat confdefs.h >>conftest.$ac_ext
14042 cat >>conftest.$ac_ext <<_ACEOF
14043 /* end confdefs.h.  */
14044
14045 /* Override any gcc2 internal prototype to avoid an error.  */
14046 #ifdef __cplusplus
14047 extern "C"
14048 #endif
14049 /* We use char because int might match the return type of a gcc2
14050    builtin and then its argument prototype would still apply.  */
14051 char cpow ();
14052 int
14053 main ()
14054 {
14055 cpow ();
14056   ;
14057   return 0;
14058 }
14059 _ACEOF
14060 rm -f conftest.$ac_objext conftest$ac_exeext
14061 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14062   (eval $ac_link) 2>conftest.er1
14063   ac_status=$?
14064   grep -v '^ *+' conftest.er1 >conftest.err
14065   rm -f conftest.er1
14066   cat conftest.err >&5
14067   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14068   (exit $ac_status); } &&
14069          { ac_try='test -z "$ac_c_werror_flag"
14070                          || test ! -s conftest.err'
14071   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14072   (eval $ac_try) 2>&5
14073   ac_status=$?
14074   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14075   (exit $ac_status); }; } &&
14076          { ac_try='test -s conftest$ac_exeext'
14077   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14078   (eval $ac_try) 2>&5
14079   ac_status=$?
14080   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14081   (exit $ac_status); }; }; then
14082   ac_cv_lib_m_cpow=yes
14083 else
14084   echo "$as_me: failed program was:" >&5
14085 sed 's/^/| /' conftest.$ac_ext >&5
14086
14087 ac_cv_lib_m_cpow=no
14088 fi
14089 rm -f conftest.err conftest.$ac_objext \
14090       conftest$ac_exeext conftest.$ac_ext
14091 LIBS=$ac_check_lib_save_LIBS
14092 fi
14093 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpow" >&5
14094 echo "${ECHO_T}$ac_cv_lib_m_cpow" >&6
14095 if test $ac_cv_lib_m_cpow = yes; then
14096
14097 cat >>confdefs.h <<\_ACEOF
14098 #define HAVE_CPOW 1
14099 _ACEOF
14100
14101 fi
14102
14103 echo "$as_me:$LINENO: checking for cpowl in -lm" >&5
14104 echo $ECHO_N "checking for cpowl in -lm... $ECHO_C" >&6
14105 if test "${ac_cv_lib_m_cpowl+set}" = set; then
14106   echo $ECHO_N "(cached) $ECHO_C" >&6
14107 else
14108   ac_check_lib_save_LIBS=$LIBS
14109 LIBS="-lm  $LIBS"
14110 if test x$gcc_no_link = xyes; then
14111   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14112 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14113    { (exit 1); exit 1; }; }
14114 fi
14115 cat >conftest.$ac_ext <<_ACEOF
14116 /* confdefs.h.  */
14117 _ACEOF
14118 cat confdefs.h >>conftest.$ac_ext
14119 cat >>conftest.$ac_ext <<_ACEOF
14120 /* end confdefs.h.  */
14121
14122 /* Override any gcc2 internal prototype to avoid an error.  */
14123 #ifdef __cplusplus
14124 extern "C"
14125 #endif
14126 /* We use char because int might match the return type of a gcc2
14127    builtin and then its argument prototype would still apply.  */
14128 char cpowl ();
14129 int
14130 main ()
14131 {
14132 cpowl ();
14133   ;
14134   return 0;
14135 }
14136 _ACEOF
14137 rm -f conftest.$ac_objext conftest$ac_exeext
14138 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14139   (eval $ac_link) 2>conftest.er1
14140   ac_status=$?
14141   grep -v '^ *+' conftest.er1 >conftest.err
14142   rm -f conftest.er1
14143   cat conftest.err >&5
14144   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14145   (exit $ac_status); } &&
14146          { ac_try='test -z "$ac_c_werror_flag"
14147                          || test ! -s conftest.err'
14148   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14149   (eval $ac_try) 2>&5
14150   ac_status=$?
14151   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14152   (exit $ac_status); }; } &&
14153          { ac_try='test -s conftest$ac_exeext'
14154   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14155   (eval $ac_try) 2>&5
14156   ac_status=$?
14157   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14158   (exit $ac_status); }; }; then
14159   ac_cv_lib_m_cpowl=yes
14160 else
14161   echo "$as_me: failed program was:" >&5
14162 sed 's/^/| /' conftest.$ac_ext >&5
14163
14164 ac_cv_lib_m_cpowl=no
14165 fi
14166 rm -f conftest.err conftest.$ac_objext \
14167       conftest$ac_exeext conftest.$ac_ext
14168 LIBS=$ac_check_lib_save_LIBS
14169 fi
14170 echo "$as_me:$LINENO: result: $ac_cv_lib_m_cpowl" >&5
14171 echo "${ECHO_T}$ac_cv_lib_m_cpowl" >&6
14172 if test $ac_cv_lib_m_cpowl = yes; then
14173
14174 cat >>confdefs.h <<\_ACEOF
14175 #define HAVE_CPOWL 1
14176 _ACEOF
14177
14178 fi
14179
14180 echo "$as_me:$LINENO: checking for roundf in -lm" >&5
14181 echo $ECHO_N "checking for roundf in -lm... $ECHO_C" >&6
14182 if test "${ac_cv_lib_m_roundf+set}" = set; then
14183   echo $ECHO_N "(cached) $ECHO_C" >&6
14184 else
14185   ac_check_lib_save_LIBS=$LIBS
14186 LIBS="-lm  $LIBS"
14187 if test x$gcc_no_link = xyes; then
14188   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14189 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14190    { (exit 1); exit 1; }; }
14191 fi
14192 cat >conftest.$ac_ext <<_ACEOF
14193 /* confdefs.h.  */
14194 _ACEOF
14195 cat confdefs.h >>conftest.$ac_ext
14196 cat >>conftest.$ac_ext <<_ACEOF
14197 /* end confdefs.h.  */
14198
14199 /* Override any gcc2 internal prototype to avoid an error.  */
14200 #ifdef __cplusplus
14201 extern "C"
14202 #endif
14203 /* We use char because int might match the return type of a gcc2
14204    builtin and then its argument prototype would still apply.  */
14205 char roundf ();
14206 int
14207 main ()
14208 {
14209 roundf ();
14210   ;
14211   return 0;
14212 }
14213 _ACEOF
14214 rm -f conftest.$ac_objext conftest$ac_exeext
14215 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14216   (eval $ac_link) 2>conftest.er1
14217   ac_status=$?
14218   grep -v '^ *+' conftest.er1 >conftest.err
14219   rm -f conftest.er1
14220   cat conftest.err >&5
14221   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14222   (exit $ac_status); } &&
14223          { ac_try='test -z "$ac_c_werror_flag"
14224                          || test ! -s conftest.err'
14225   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14226   (eval $ac_try) 2>&5
14227   ac_status=$?
14228   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14229   (exit $ac_status); }; } &&
14230          { ac_try='test -s conftest$ac_exeext'
14231   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14232   (eval $ac_try) 2>&5
14233   ac_status=$?
14234   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14235   (exit $ac_status); }; }; then
14236   ac_cv_lib_m_roundf=yes
14237 else
14238   echo "$as_me: failed program was:" >&5
14239 sed 's/^/| /' conftest.$ac_ext >&5
14240
14241 ac_cv_lib_m_roundf=no
14242 fi
14243 rm -f conftest.err conftest.$ac_objext \
14244       conftest$ac_exeext conftest.$ac_ext
14245 LIBS=$ac_check_lib_save_LIBS
14246 fi
14247 echo "$as_me:$LINENO: result: $ac_cv_lib_m_roundf" >&5
14248 echo "${ECHO_T}$ac_cv_lib_m_roundf" >&6
14249 if test $ac_cv_lib_m_roundf = yes; then
14250
14251 cat >>confdefs.h <<\_ACEOF
14252 #define HAVE_ROUNDF 1
14253 _ACEOF
14254
14255 fi
14256
14257 echo "$as_me:$LINENO: checking for round in -lm" >&5
14258 echo $ECHO_N "checking for round in -lm... $ECHO_C" >&6
14259 if test "${ac_cv_lib_m_round+set}" = set; then
14260   echo $ECHO_N "(cached) $ECHO_C" >&6
14261 else
14262   ac_check_lib_save_LIBS=$LIBS
14263 LIBS="-lm  $LIBS"
14264 if test x$gcc_no_link = xyes; then
14265   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14266 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14267    { (exit 1); exit 1; }; }
14268 fi
14269 cat >conftest.$ac_ext <<_ACEOF
14270 /* confdefs.h.  */
14271 _ACEOF
14272 cat confdefs.h >>conftest.$ac_ext
14273 cat >>conftest.$ac_ext <<_ACEOF
14274 /* end confdefs.h.  */
14275
14276 /* Override any gcc2 internal prototype to avoid an error.  */
14277 #ifdef __cplusplus
14278 extern "C"
14279 #endif
14280 /* We use char because int might match the return type of a gcc2
14281    builtin and then its argument prototype would still apply.  */
14282 char round ();
14283 int
14284 main ()
14285 {
14286 round ();
14287   ;
14288   return 0;
14289 }
14290 _ACEOF
14291 rm -f conftest.$ac_objext conftest$ac_exeext
14292 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14293   (eval $ac_link) 2>conftest.er1
14294   ac_status=$?
14295   grep -v '^ *+' conftest.er1 >conftest.err
14296   rm -f conftest.er1
14297   cat conftest.err >&5
14298   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14299   (exit $ac_status); } &&
14300          { ac_try='test -z "$ac_c_werror_flag"
14301                          || test ! -s conftest.err'
14302   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14303   (eval $ac_try) 2>&5
14304   ac_status=$?
14305   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14306   (exit $ac_status); }; } &&
14307          { ac_try='test -s conftest$ac_exeext'
14308   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14309   (eval $ac_try) 2>&5
14310   ac_status=$?
14311   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14312   (exit $ac_status); }; }; then
14313   ac_cv_lib_m_round=yes
14314 else
14315   echo "$as_me: failed program was:" >&5
14316 sed 's/^/| /' conftest.$ac_ext >&5
14317
14318 ac_cv_lib_m_round=no
14319 fi
14320 rm -f conftest.err conftest.$ac_objext \
14321       conftest$ac_exeext conftest.$ac_ext
14322 LIBS=$ac_check_lib_save_LIBS
14323 fi
14324 echo "$as_me:$LINENO: result: $ac_cv_lib_m_round" >&5
14325 echo "${ECHO_T}$ac_cv_lib_m_round" >&6
14326 if test $ac_cv_lib_m_round = yes; then
14327
14328 cat >>confdefs.h <<\_ACEOF
14329 #define HAVE_ROUND 1
14330 _ACEOF
14331
14332 fi
14333
14334 echo "$as_me:$LINENO: checking for roundl in -lm" >&5
14335 echo $ECHO_N "checking for roundl in -lm... $ECHO_C" >&6
14336 if test "${ac_cv_lib_m_roundl+set}" = set; then
14337   echo $ECHO_N "(cached) $ECHO_C" >&6
14338 else
14339   ac_check_lib_save_LIBS=$LIBS
14340 LIBS="-lm  $LIBS"
14341 if test x$gcc_no_link = xyes; then
14342   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14343 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14344    { (exit 1); exit 1; }; }
14345 fi
14346 cat >conftest.$ac_ext <<_ACEOF
14347 /* confdefs.h.  */
14348 _ACEOF
14349 cat confdefs.h >>conftest.$ac_ext
14350 cat >>conftest.$ac_ext <<_ACEOF
14351 /* end confdefs.h.  */
14352
14353 /* Override any gcc2 internal prototype to avoid an error.  */
14354 #ifdef __cplusplus
14355 extern "C"
14356 #endif
14357 /* We use char because int might match the return type of a gcc2
14358    builtin and then its argument prototype would still apply.  */
14359 char roundl ();
14360 int
14361 main ()
14362 {
14363 roundl ();
14364   ;
14365   return 0;
14366 }
14367 _ACEOF
14368 rm -f conftest.$ac_objext conftest$ac_exeext
14369 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14370   (eval $ac_link) 2>conftest.er1
14371   ac_status=$?
14372   grep -v '^ *+' conftest.er1 >conftest.err
14373   rm -f conftest.er1
14374   cat conftest.err >&5
14375   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14376   (exit $ac_status); } &&
14377          { ac_try='test -z "$ac_c_werror_flag"
14378                          || test ! -s conftest.err'
14379   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14380   (eval $ac_try) 2>&5
14381   ac_status=$?
14382   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14383   (exit $ac_status); }; } &&
14384          { ac_try='test -s conftest$ac_exeext'
14385   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14386   (eval $ac_try) 2>&5
14387   ac_status=$?
14388   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14389   (exit $ac_status); }; }; then
14390   ac_cv_lib_m_roundl=yes
14391 else
14392   echo "$as_me: failed program was:" >&5
14393 sed 's/^/| /' conftest.$ac_ext >&5
14394
14395 ac_cv_lib_m_roundl=no
14396 fi
14397 rm -f conftest.err conftest.$ac_objext \
14398       conftest$ac_exeext conftest.$ac_ext
14399 LIBS=$ac_check_lib_save_LIBS
14400 fi
14401 echo "$as_me:$LINENO: result: $ac_cv_lib_m_roundl" >&5
14402 echo "${ECHO_T}$ac_cv_lib_m_roundl" >&6
14403 if test $ac_cv_lib_m_roundl = yes; then
14404
14405 cat >>confdefs.h <<\_ACEOF
14406 #define HAVE_ROUNDL 1
14407 _ACEOF
14408
14409 fi
14410
14411 echo "$as_me:$LINENO: checking for scalbnf in -lm" >&5
14412 echo $ECHO_N "checking for scalbnf in -lm... $ECHO_C" >&6
14413 if test "${ac_cv_lib_m_scalbnf+set}" = set; then
14414   echo $ECHO_N "(cached) $ECHO_C" >&6
14415 else
14416   ac_check_lib_save_LIBS=$LIBS
14417 LIBS="-lm  $LIBS"
14418 if test x$gcc_no_link = xyes; then
14419   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14420 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14421    { (exit 1); exit 1; }; }
14422 fi
14423 cat >conftest.$ac_ext <<_ACEOF
14424 /* confdefs.h.  */
14425 _ACEOF
14426 cat confdefs.h >>conftest.$ac_ext
14427 cat >>conftest.$ac_ext <<_ACEOF
14428 /* end confdefs.h.  */
14429
14430 /* Override any gcc2 internal prototype to avoid an error.  */
14431 #ifdef __cplusplus
14432 extern "C"
14433 #endif
14434 /* We use char because int might match the return type of a gcc2
14435    builtin and then its argument prototype would still apply.  */
14436 char scalbnf ();
14437 int
14438 main ()
14439 {
14440 scalbnf ();
14441   ;
14442   return 0;
14443 }
14444 _ACEOF
14445 rm -f conftest.$ac_objext conftest$ac_exeext
14446 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14447   (eval $ac_link) 2>conftest.er1
14448   ac_status=$?
14449   grep -v '^ *+' conftest.er1 >conftest.err
14450   rm -f conftest.er1
14451   cat conftest.err >&5
14452   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14453   (exit $ac_status); } &&
14454          { ac_try='test -z "$ac_c_werror_flag"
14455                          || test ! -s conftest.err'
14456   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14457   (eval $ac_try) 2>&5
14458   ac_status=$?
14459   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14460   (exit $ac_status); }; } &&
14461          { ac_try='test -s conftest$ac_exeext'
14462   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14463   (eval $ac_try) 2>&5
14464   ac_status=$?
14465   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14466   (exit $ac_status); }; }; then
14467   ac_cv_lib_m_scalbnf=yes
14468 else
14469   echo "$as_me: failed program was:" >&5
14470 sed 's/^/| /' conftest.$ac_ext >&5
14471
14472 ac_cv_lib_m_scalbnf=no
14473 fi
14474 rm -f conftest.err conftest.$ac_objext \
14475       conftest$ac_exeext conftest.$ac_ext
14476 LIBS=$ac_check_lib_save_LIBS
14477 fi
14478 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbnf" >&5
14479 echo "${ECHO_T}$ac_cv_lib_m_scalbnf" >&6
14480 if test $ac_cv_lib_m_scalbnf = yes; then
14481
14482 cat >>confdefs.h <<\_ACEOF
14483 #define HAVE_SCALBNF 1
14484 _ACEOF
14485
14486 fi
14487
14488 echo "$as_me:$LINENO: checking for scalbn in -lm" >&5
14489 echo $ECHO_N "checking for scalbn in -lm... $ECHO_C" >&6
14490 if test "${ac_cv_lib_m_scalbn+set}" = set; then
14491   echo $ECHO_N "(cached) $ECHO_C" >&6
14492 else
14493   ac_check_lib_save_LIBS=$LIBS
14494 LIBS="-lm  $LIBS"
14495 if test x$gcc_no_link = xyes; then
14496   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14497 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14498    { (exit 1); exit 1; }; }
14499 fi
14500 cat >conftest.$ac_ext <<_ACEOF
14501 /* confdefs.h.  */
14502 _ACEOF
14503 cat confdefs.h >>conftest.$ac_ext
14504 cat >>conftest.$ac_ext <<_ACEOF
14505 /* end confdefs.h.  */
14506
14507 /* Override any gcc2 internal prototype to avoid an error.  */
14508 #ifdef __cplusplus
14509 extern "C"
14510 #endif
14511 /* We use char because int might match the return type of a gcc2
14512    builtin and then its argument prototype would still apply.  */
14513 char scalbn ();
14514 int
14515 main ()
14516 {
14517 scalbn ();
14518   ;
14519   return 0;
14520 }
14521 _ACEOF
14522 rm -f conftest.$ac_objext conftest$ac_exeext
14523 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14524   (eval $ac_link) 2>conftest.er1
14525   ac_status=$?
14526   grep -v '^ *+' conftest.er1 >conftest.err
14527   rm -f conftest.er1
14528   cat conftest.err >&5
14529   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14530   (exit $ac_status); } &&
14531          { ac_try='test -z "$ac_c_werror_flag"
14532                          || test ! -s conftest.err'
14533   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14534   (eval $ac_try) 2>&5
14535   ac_status=$?
14536   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14537   (exit $ac_status); }; } &&
14538          { ac_try='test -s conftest$ac_exeext'
14539   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14540   (eval $ac_try) 2>&5
14541   ac_status=$?
14542   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14543   (exit $ac_status); }; }; then
14544   ac_cv_lib_m_scalbn=yes
14545 else
14546   echo "$as_me: failed program was:" >&5
14547 sed 's/^/| /' conftest.$ac_ext >&5
14548
14549 ac_cv_lib_m_scalbn=no
14550 fi
14551 rm -f conftest.err conftest.$ac_objext \
14552       conftest$ac_exeext conftest.$ac_ext
14553 LIBS=$ac_check_lib_save_LIBS
14554 fi
14555 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbn" >&5
14556 echo "${ECHO_T}$ac_cv_lib_m_scalbn" >&6
14557 if test $ac_cv_lib_m_scalbn = yes; then
14558
14559 cat >>confdefs.h <<\_ACEOF
14560 #define HAVE_SCALBN 1
14561 _ACEOF
14562
14563 fi
14564
14565 echo "$as_me:$LINENO: checking for scalbnl in -lm" >&5
14566 echo $ECHO_N "checking for scalbnl in -lm... $ECHO_C" >&6
14567 if test "${ac_cv_lib_m_scalbnl+set}" = set; then
14568   echo $ECHO_N "(cached) $ECHO_C" >&6
14569 else
14570   ac_check_lib_save_LIBS=$LIBS
14571 LIBS="-lm  $LIBS"
14572 if test x$gcc_no_link = xyes; then
14573   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14574 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14575    { (exit 1); exit 1; }; }
14576 fi
14577 cat >conftest.$ac_ext <<_ACEOF
14578 /* confdefs.h.  */
14579 _ACEOF
14580 cat confdefs.h >>conftest.$ac_ext
14581 cat >>conftest.$ac_ext <<_ACEOF
14582 /* end confdefs.h.  */
14583
14584 /* Override any gcc2 internal prototype to avoid an error.  */
14585 #ifdef __cplusplus
14586 extern "C"
14587 #endif
14588 /* We use char because int might match the return type of a gcc2
14589    builtin and then its argument prototype would still apply.  */
14590 char scalbnl ();
14591 int
14592 main ()
14593 {
14594 scalbnl ();
14595   ;
14596   return 0;
14597 }
14598 _ACEOF
14599 rm -f conftest.$ac_objext conftest$ac_exeext
14600 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14601   (eval $ac_link) 2>conftest.er1
14602   ac_status=$?
14603   grep -v '^ *+' conftest.er1 >conftest.err
14604   rm -f conftest.er1
14605   cat conftest.err >&5
14606   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14607   (exit $ac_status); } &&
14608          { ac_try='test -z "$ac_c_werror_flag"
14609                          || test ! -s conftest.err'
14610   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14611   (eval $ac_try) 2>&5
14612   ac_status=$?
14613   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14614   (exit $ac_status); }; } &&
14615          { ac_try='test -s conftest$ac_exeext'
14616   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14617   (eval $ac_try) 2>&5
14618   ac_status=$?
14619   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14620   (exit $ac_status); }; }; then
14621   ac_cv_lib_m_scalbnl=yes
14622 else
14623   echo "$as_me: failed program was:" >&5
14624 sed 's/^/| /' conftest.$ac_ext >&5
14625
14626 ac_cv_lib_m_scalbnl=no
14627 fi
14628 rm -f conftest.err conftest.$ac_objext \
14629       conftest$ac_exeext conftest.$ac_ext
14630 LIBS=$ac_check_lib_save_LIBS
14631 fi
14632 echo "$as_me:$LINENO: result: $ac_cv_lib_m_scalbnl" >&5
14633 echo "${ECHO_T}$ac_cv_lib_m_scalbnl" >&6
14634 if test $ac_cv_lib_m_scalbnl = yes; then
14635
14636 cat >>confdefs.h <<\_ACEOF
14637 #define HAVE_SCALBNL 1
14638 _ACEOF
14639
14640 fi
14641
14642 echo "$as_me:$LINENO: checking for sinf in -lm" >&5
14643 echo $ECHO_N "checking for sinf in -lm... $ECHO_C" >&6
14644 if test "${ac_cv_lib_m_sinf+set}" = set; then
14645   echo $ECHO_N "(cached) $ECHO_C" >&6
14646 else
14647   ac_check_lib_save_LIBS=$LIBS
14648 LIBS="-lm  $LIBS"
14649 if test x$gcc_no_link = xyes; then
14650   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14651 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14652    { (exit 1); exit 1; }; }
14653 fi
14654 cat >conftest.$ac_ext <<_ACEOF
14655 /* confdefs.h.  */
14656 _ACEOF
14657 cat confdefs.h >>conftest.$ac_ext
14658 cat >>conftest.$ac_ext <<_ACEOF
14659 /* end confdefs.h.  */
14660
14661 /* Override any gcc2 internal prototype to avoid an error.  */
14662 #ifdef __cplusplus
14663 extern "C"
14664 #endif
14665 /* We use char because int might match the return type of a gcc2
14666    builtin and then its argument prototype would still apply.  */
14667 char sinf ();
14668 int
14669 main ()
14670 {
14671 sinf ();
14672   ;
14673   return 0;
14674 }
14675 _ACEOF
14676 rm -f conftest.$ac_objext conftest$ac_exeext
14677 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14678   (eval $ac_link) 2>conftest.er1
14679   ac_status=$?
14680   grep -v '^ *+' conftest.er1 >conftest.err
14681   rm -f conftest.er1
14682   cat conftest.err >&5
14683   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14684   (exit $ac_status); } &&
14685          { ac_try='test -z "$ac_c_werror_flag"
14686                          || test ! -s conftest.err'
14687   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14688   (eval $ac_try) 2>&5
14689   ac_status=$?
14690   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14691   (exit $ac_status); }; } &&
14692          { ac_try='test -s conftest$ac_exeext'
14693   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14694   (eval $ac_try) 2>&5
14695   ac_status=$?
14696   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14697   (exit $ac_status); }; }; then
14698   ac_cv_lib_m_sinf=yes
14699 else
14700   echo "$as_me: failed program was:" >&5
14701 sed 's/^/| /' conftest.$ac_ext >&5
14702
14703 ac_cv_lib_m_sinf=no
14704 fi
14705 rm -f conftest.err conftest.$ac_objext \
14706       conftest$ac_exeext conftest.$ac_ext
14707 LIBS=$ac_check_lib_save_LIBS
14708 fi
14709 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinf" >&5
14710 echo "${ECHO_T}$ac_cv_lib_m_sinf" >&6
14711 if test $ac_cv_lib_m_sinf = yes; then
14712
14713 cat >>confdefs.h <<\_ACEOF
14714 #define HAVE_SINF 1
14715 _ACEOF
14716
14717 fi
14718
14719 echo "$as_me:$LINENO: checking for sin in -lm" >&5
14720 echo $ECHO_N "checking for sin in -lm... $ECHO_C" >&6
14721 if test "${ac_cv_lib_m_sin+set}" = set; then
14722   echo $ECHO_N "(cached) $ECHO_C" >&6
14723 else
14724   ac_check_lib_save_LIBS=$LIBS
14725 LIBS="-lm  $LIBS"
14726 if test x$gcc_no_link = xyes; then
14727   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14728 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14729    { (exit 1); exit 1; }; }
14730 fi
14731 cat >conftest.$ac_ext <<_ACEOF
14732 /* confdefs.h.  */
14733 _ACEOF
14734 cat confdefs.h >>conftest.$ac_ext
14735 cat >>conftest.$ac_ext <<_ACEOF
14736 /* end confdefs.h.  */
14737
14738 /* Override any gcc2 internal prototype to avoid an error.  */
14739 #ifdef __cplusplus
14740 extern "C"
14741 #endif
14742 /* We use char because int might match the return type of a gcc2
14743    builtin and then its argument prototype would still apply.  */
14744 char sin ();
14745 int
14746 main ()
14747 {
14748 sin ();
14749   ;
14750   return 0;
14751 }
14752 _ACEOF
14753 rm -f conftest.$ac_objext conftest$ac_exeext
14754 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14755   (eval $ac_link) 2>conftest.er1
14756   ac_status=$?
14757   grep -v '^ *+' conftest.er1 >conftest.err
14758   rm -f conftest.er1
14759   cat conftest.err >&5
14760   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14761   (exit $ac_status); } &&
14762          { ac_try='test -z "$ac_c_werror_flag"
14763                          || test ! -s conftest.err'
14764   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14765   (eval $ac_try) 2>&5
14766   ac_status=$?
14767   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14768   (exit $ac_status); }; } &&
14769          { ac_try='test -s conftest$ac_exeext'
14770   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14771   (eval $ac_try) 2>&5
14772   ac_status=$?
14773   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14774   (exit $ac_status); }; }; then
14775   ac_cv_lib_m_sin=yes
14776 else
14777   echo "$as_me: failed program was:" >&5
14778 sed 's/^/| /' conftest.$ac_ext >&5
14779
14780 ac_cv_lib_m_sin=no
14781 fi
14782 rm -f conftest.err conftest.$ac_objext \
14783       conftest$ac_exeext conftest.$ac_ext
14784 LIBS=$ac_check_lib_save_LIBS
14785 fi
14786 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sin" >&5
14787 echo "${ECHO_T}$ac_cv_lib_m_sin" >&6
14788 if test $ac_cv_lib_m_sin = yes; then
14789
14790 cat >>confdefs.h <<\_ACEOF
14791 #define HAVE_SIN 1
14792 _ACEOF
14793
14794 fi
14795
14796 echo "$as_me:$LINENO: checking for sinl in -lm" >&5
14797 echo $ECHO_N "checking for sinl in -lm... $ECHO_C" >&6
14798 if test "${ac_cv_lib_m_sinl+set}" = set; then
14799   echo $ECHO_N "(cached) $ECHO_C" >&6
14800 else
14801   ac_check_lib_save_LIBS=$LIBS
14802 LIBS="-lm  $LIBS"
14803 if test x$gcc_no_link = xyes; then
14804   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14805 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14806    { (exit 1); exit 1; }; }
14807 fi
14808 cat >conftest.$ac_ext <<_ACEOF
14809 /* confdefs.h.  */
14810 _ACEOF
14811 cat confdefs.h >>conftest.$ac_ext
14812 cat >>conftest.$ac_ext <<_ACEOF
14813 /* end confdefs.h.  */
14814
14815 /* Override any gcc2 internal prototype to avoid an error.  */
14816 #ifdef __cplusplus
14817 extern "C"
14818 #endif
14819 /* We use char because int might match the return type of a gcc2
14820    builtin and then its argument prototype would still apply.  */
14821 char sinl ();
14822 int
14823 main ()
14824 {
14825 sinl ();
14826   ;
14827   return 0;
14828 }
14829 _ACEOF
14830 rm -f conftest.$ac_objext conftest$ac_exeext
14831 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14832   (eval $ac_link) 2>conftest.er1
14833   ac_status=$?
14834   grep -v '^ *+' conftest.er1 >conftest.err
14835   rm -f conftest.er1
14836   cat conftest.err >&5
14837   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14838   (exit $ac_status); } &&
14839          { ac_try='test -z "$ac_c_werror_flag"
14840                          || test ! -s conftest.err'
14841   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14842   (eval $ac_try) 2>&5
14843   ac_status=$?
14844   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14845   (exit $ac_status); }; } &&
14846          { ac_try='test -s conftest$ac_exeext'
14847   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14848   (eval $ac_try) 2>&5
14849   ac_status=$?
14850   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14851   (exit $ac_status); }; }; then
14852   ac_cv_lib_m_sinl=yes
14853 else
14854   echo "$as_me: failed program was:" >&5
14855 sed 's/^/| /' conftest.$ac_ext >&5
14856
14857 ac_cv_lib_m_sinl=no
14858 fi
14859 rm -f conftest.err conftest.$ac_objext \
14860       conftest$ac_exeext conftest.$ac_ext
14861 LIBS=$ac_check_lib_save_LIBS
14862 fi
14863 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinl" >&5
14864 echo "${ECHO_T}$ac_cv_lib_m_sinl" >&6
14865 if test $ac_cv_lib_m_sinl = yes; then
14866
14867 cat >>confdefs.h <<\_ACEOF
14868 #define HAVE_SINL 1
14869 _ACEOF
14870
14871 fi
14872
14873 echo "$as_me:$LINENO: checking for csinf in -lm" >&5
14874 echo $ECHO_N "checking for csinf in -lm... $ECHO_C" >&6
14875 if test "${ac_cv_lib_m_csinf+set}" = set; then
14876   echo $ECHO_N "(cached) $ECHO_C" >&6
14877 else
14878   ac_check_lib_save_LIBS=$LIBS
14879 LIBS="-lm  $LIBS"
14880 if test x$gcc_no_link = xyes; then
14881   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14882 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14883    { (exit 1); exit 1; }; }
14884 fi
14885 cat >conftest.$ac_ext <<_ACEOF
14886 /* confdefs.h.  */
14887 _ACEOF
14888 cat confdefs.h >>conftest.$ac_ext
14889 cat >>conftest.$ac_ext <<_ACEOF
14890 /* end confdefs.h.  */
14891
14892 /* Override any gcc2 internal prototype to avoid an error.  */
14893 #ifdef __cplusplus
14894 extern "C"
14895 #endif
14896 /* We use char because int might match the return type of a gcc2
14897    builtin and then its argument prototype would still apply.  */
14898 char csinf ();
14899 int
14900 main ()
14901 {
14902 csinf ();
14903   ;
14904   return 0;
14905 }
14906 _ACEOF
14907 rm -f conftest.$ac_objext conftest$ac_exeext
14908 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14909   (eval $ac_link) 2>conftest.er1
14910   ac_status=$?
14911   grep -v '^ *+' conftest.er1 >conftest.err
14912   rm -f conftest.er1
14913   cat conftest.err >&5
14914   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14915   (exit $ac_status); } &&
14916          { ac_try='test -z "$ac_c_werror_flag"
14917                          || test ! -s conftest.err'
14918   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14919   (eval $ac_try) 2>&5
14920   ac_status=$?
14921   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14922   (exit $ac_status); }; } &&
14923          { ac_try='test -s conftest$ac_exeext'
14924   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14925   (eval $ac_try) 2>&5
14926   ac_status=$?
14927   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14928   (exit $ac_status); }; }; then
14929   ac_cv_lib_m_csinf=yes
14930 else
14931   echo "$as_me: failed program was:" >&5
14932 sed 's/^/| /' conftest.$ac_ext >&5
14933
14934 ac_cv_lib_m_csinf=no
14935 fi
14936 rm -f conftest.err conftest.$ac_objext \
14937       conftest$ac_exeext conftest.$ac_ext
14938 LIBS=$ac_check_lib_save_LIBS
14939 fi
14940 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinf" >&5
14941 echo "${ECHO_T}$ac_cv_lib_m_csinf" >&6
14942 if test $ac_cv_lib_m_csinf = yes; then
14943
14944 cat >>confdefs.h <<\_ACEOF
14945 #define HAVE_CSINF 1
14946 _ACEOF
14947
14948 fi
14949
14950 echo "$as_me:$LINENO: checking for csin in -lm" >&5
14951 echo $ECHO_N "checking for csin in -lm... $ECHO_C" >&6
14952 if test "${ac_cv_lib_m_csin+set}" = set; then
14953   echo $ECHO_N "(cached) $ECHO_C" >&6
14954 else
14955   ac_check_lib_save_LIBS=$LIBS
14956 LIBS="-lm  $LIBS"
14957 if test x$gcc_no_link = xyes; then
14958   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
14959 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
14960    { (exit 1); exit 1; }; }
14961 fi
14962 cat >conftest.$ac_ext <<_ACEOF
14963 /* confdefs.h.  */
14964 _ACEOF
14965 cat confdefs.h >>conftest.$ac_ext
14966 cat >>conftest.$ac_ext <<_ACEOF
14967 /* end confdefs.h.  */
14968
14969 /* Override any gcc2 internal prototype to avoid an error.  */
14970 #ifdef __cplusplus
14971 extern "C"
14972 #endif
14973 /* We use char because int might match the return type of a gcc2
14974    builtin and then its argument prototype would still apply.  */
14975 char csin ();
14976 int
14977 main ()
14978 {
14979 csin ();
14980   ;
14981   return 0;
14982 }
14983 _ACEOF
14984 rm -f conftest.$ac_objext conftest$ac_exeext
14985 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14986   (eval $ac_link) 2>conftest.er1
14987   ac_status=$?
14988   grep -v '^ *+' conftest.er1 >conftest.err
14989   rm -f conftest.er1
14990   cat conftest.err >&5
14991   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14992   (exit $ac_status); } &&
14993          { ac_try='test -z "$ac_c_werror_flag"
14994                          || test ! -s conftest.err'
14995   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14996   (eval $ac_try) 2>&5
14997   ac_status=$?
14998   echo "$as_me:$LINENO: \$? = $ac_status" >&5
14999   (exit $ac_status); }; } &&
15000          { ac_try='test -s conftest$ac_exeext'
15001   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15002   (eval $ac_try) 2>&5
15003   ac_status=$?
15004   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15005   (exit $ac_status); }; }; then
15006   ac_cv_lib_m_csin=yes
15007 else
15008   echo "$as_me: failed program was:" >&5
15009 sed 's/^/| /' conftest.$ac_ext >&5
15010
15011 ac_cv_lib_m_csin=no
15012 fi
15013 rm -f conftest.err conftest.$ac_objext \
15014       conftest$ac_exeext conftest.$ac_ext
15015 LIBS=$ac_check_lib_save_LIBS
15016 fi
15017 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csin" >&5
15018 echo "${ECHO_T}$ac_cv_lib_m_csin" >&6
15019 if test $ac_cv_lib_m_csin = yes; then
15020
15021 cat >>confdefs.h <<\_ACEOF
15022 #define HAVE_CSIN 1
15023 _ACEOF
15024
15025 fi
15026
15027 echo "$as_me:$LINENO: checking for csinl in -lm" >&5
15028 echo $ECHO_N "checking for csinl in -lm... $ECHO_C" >&6
15029 if test "${ac_cv_lib_m_csinl+set}" = set; then
15030   echo $ECHO_N "(cached) $ECHO_C" >&6
15031 else
15032   ac_check_lib_save_LIBS=$LIBS
15033 LIBS="-lm  $LIBS"
15034 if test x$gcc_no_link = xyes; then
15035   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15036 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15037    { (exit 1); exit 1; }; }
15038 fi
15039 cat >conftest.$ac_ext <<_ACEOF
15040 /* confdefs.h.  */
15041 _ACEOF
15042 cat confdefs.h >>conftest.$ac_ext
15043 cat >>conftest.$ac_ext <<_ACEOF
15044 /* end confdefs.h.  */
15045
15046 /* Override any gcc2 internal prototype to avoid an error.  */
15047 #ifdef __cplusplus
15048 extern "C"
15049 #endif
15050 /* We use char because int might match the return type of a gcc2
15051    builtin and then its argument prototype would still apply.  */
15052 char csinl ();
15053 int
15054 main ()
15055 {
15056 csinl ();
15057   ;
15058   return 0;
15059 }
15060 _ACEOF
15061 rm -f conftest.$ac_objext conftest$ac_exeext
15062 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15063   (eval $ac_link) 2>conftest.er1
15064   ac_status=$?
15065   grep -v '^ *+' conftest.er1 >conftest.err
15066   rm -f conftest.er1
15067   cat conftest.err >&5
15068   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15069   (exit $ac_status); } &&
15070          { ac_try='test -z "$ac_c_werror_flag"
15071                          || test ! -s conftest.err'
15072   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15073   (eval $ac_try) 2>&5
15074   ac_status=$?
15075   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15076   (exit $ac_status); }; } &&
15077          { ac_try='test -s conftest$ac_exeext'
15078   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15079   (eval $ac_try) 2>&5
15080   ac_status=$?
15081   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15082   (exit $ac_status); }; }; then
15083   ac_cv_lib_m_csinl=yes
15084 else
15085   echo "$as_me: failed program was:" >&5
15086 sed 's/^/| /' conftest.$ac_ext >&5
15087
15088 ac_cv_lib_m_csinl=no
15089 fi
15090 rm -f conftest.err conftest.$ac_objext \
15091       conftest$ac_exeext conftest.$ac_ext
15092 LIBS=$ac_check_lib_save_LIBS
15093 fi
15094 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinl" >&5
15095 echo "${ECHO_T}$ac_cv_lib_m_csinl" >&6
15096 if test $ac_cv_lib_m_csinl = yes; then
15097
15098 cat >>confdefs.h <<\_ACEOF
15099 #define HAVE_CSINL 1
15100 _ACEOF
15101
15102 fi
15103
15104 echo "$as_me:$LINENO: checking for sinhf in -lm" >&5
15105 echo $ECHO_N "checking for sinhf in -lm... $ECHO_C" >&6
15106 if test "${ac_cv_lib_m_sinhf+set}" = set; then
15107   echo $ECHO_N "(cached) $ECHO_C" >&6
15108 else
15109   ac_check_lib_save_LIBS=$LIBS
15110 LIBS="-lm  $LIBS"
15111 if test x$gcc_no_link = xyes; then
15112   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15113 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15114    { (exit 1); exit 1; }; }
15115 fi
15116 cat >conftest.$ac_ext <<_ACEOF
15117 /* confdefs.h.  */
15118 _ACEOF
15119 cat confdefs.h >>conftest.$ac_ext
15120 cat >>conftest.$ac_ext <<_ACEOF
15121 /* end confdefs.h.  */
15122
15123 /* Override any gcc2 internal prototype to avoid an error.  */
15124 #ifdef __cplusplus
15125 extern "C"
15126 #endif
15127 /* We use char because int might match the return type of a gcc2
15128    builtin and then its argument prototype would still apply.  */
15129 char sinhf ();
15130 int
15131 main ()
15132 {
15133 sinhf ();
15134   ;
15135   return 0;
15136 }
15137 _ACEOF
15138 rm -f conftest.$ac_objext conftest$ac_exeext
15139 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15140   (eval $ac_link) 2>conftest.er1
15141   ac_status=$?
15142   grep -v '^ *+' conftest.er1 >conftest.err
15143   rm -f conftest.er1
15144   cat conftest.err >&5
15145   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15146   (exit $ac_status); } &&
15147          { ac_try='test -z "$ac_c_werror_flag"
15148                          || test ! -s conftest.err'
15149   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15150   (eval $ac_try) 2>&5
15151   ac_status=$?
15152   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15153   (exit $ac_status); }; } &&
15154          { ac_try='test -s conftest$ac_exeext'
15155   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15156   (eval $ac_try) 2>&5
15157   ac_status=$?
15158   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15159   (exit $ac_status); }; }; then
15160   ac_cv_lib_m_sinhf=yes
15161 else
15162   echo "$as_me: failed program was:" >&5
15163 sed 's/^/| /' conftest.$ac_ext >&5
15164
15165 ac_cv_lib_m_sinhf=no
15166 fi
15167 rm -f conftest.err conftest.$ac_objext \
15168       conftest$ac_exeext conftest.$ac_ext
15169 LIBS=$ac_check_lib_save_LIBS
15170 fi
15171 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinhf" >&5
15172 echo "${ECHO_T}$ac_cv_lib_m_sinhf" >&6
15173 if test $ac_cv_lib_m_sinhf = yes; then
15174
15175 cat >>confdefs.h <<\_ACEOF
15176 #define HAVE_SINHF 1
15177 _ACEOF
15178
15179 fi
15180
15181 echo "$as_me:$LINENO: checking for sinh in -lm" >&5
15182 echo $ECHO_N "checking for sinh in -lm... $ECHO_C" >&6
15183 if test "${ac_cv_lib_m_sinh+set}" = set; then
15184   echo $ECHO_N "(cached) $ECHO_C" >&6
15185 else
15186   ac_check_lib_save_LIBS=$LIBS
15187 LIBS="-lm  $LIBS"
15188 if test x$gcc_no_link = xyes; then
15189   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15190 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15191    { (exit 1); exit 1; }; }
15192 fi
15193 cat >conftest.$ac_ext <<_ACEOF
15194 /* confdefs.h.  */
15195 _ACEOF
15196 cat confdefs.h >>conftest.$ac_ext
15197 cat >>conftest.$ac_ext <<_ACEOF
15198 /* end confdefs.h.  */
15199
15200 /* Override any gcc2 internal prototype to avoid an error.  */
15201 #ifdef __cplusplus
15202 extern "C"
15203 #endif
15204 /* We use char because int might match the return type of a gcc2
15205    builtin and then its argument prototype would still apply.  */
15206 char sinh ();
15207 int
15208 main ()
15209 {
15210 sinh ();
15211   ;
15212   return 0;
15213 }
15214 _ACEOF
15215 rm -f conftest.$ac_objext conftest$ac_exeext
15216 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15217   (eval $ac_link) 2>conftest.er1
15218   ac_status=$?
15219   grep -v '^ *+' conftest.er1 >conftest.err
15220   rm -f conftest.er1
15221   cat conftest.err >&5
15222   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15223   (exit $ac_status); } &&
15224          { ac_try='test -z "$ac_c_werror_flag"
15225                          || test ! -s conftest.err'
15226   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15227   (eval $ac_try) 2>&5
15228   ac_status=$?
15229   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15230   (exit $ac_status); }; } &&
15231          { ac_try='test -s conftest$ac_exeext'
15232   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15233   (eval $ac_try) 2>&5
15234   ac_status=$?
15235   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15236   (exit $ac_status); }; }; then
15237   ac_cv_lib_m_sinh=yes
15238 else
15239   echo "$as_me: failed program was:" >&5
15240 sed 's/^/| /' conftest.$ac_ext >&5
15241
15242 ac_cv_lib_m_sinh=no
15243 fi
15244 rm -f conftest.err conftest.$ac_objext \
15245       conftest$ac_exeext conftest.$ac_ext
15246 LIBS=$ac_check_lib_save_LIBS
15247 fi
15248 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinh" >&5
15249 echo "${ECHO_T}$ac_cv_lib_m_sinh" >&6
15250 if test $ac_cv_lib_m_sinh = yes; then
15251
15252 cat >>confdefs.h <<\_ACEOF
15253 #define HAVE_SINH 1
15254 _ACEOF
15255
15256 fi
15257
15258 echo "$as_me:$LINENO: checking for sinhl in -lm" >&5
15259 echo $ECHO_N "checking for sinhl in -lm... $ECHO_C" >&6
15260 if test "${ac_cv_lib_m_sinhl+set}" = set; then
15261   echo $ECHO_N "(cached) $ECHO_C" >&6
15262 else
15263   ac_check_lib_save_LIBS=$LIBS
15264 LIBS="-lm  $LIBS"
15265 if test x$gcc_no_link = xyes; then
15266   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15267 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15268    { (exit 1); exit 1; }; }
15269 fi
15270 cat >conftest.$ac_ext <<_ACEOF
15271 /* confdefs.h.  */
15272 _ACEOF
15273 cat confdefs.h >>conftest.$ac_ext
15274 cat >>conftest.$ac_ext <<_ACEOF
15275 /* end confdefs.h.  */
15276
15277 /* Override any gcc2 internal prototype to avoid an error.  */
15278 #ifdef __cplusplus
15279 extern "C"
15280 #endif
15281 /* We use char because int might match the return type of a gcc2
15282    builtin and then its argument prototype would still apply.  */
15283 char sinhl ();
15284 int
15285 main ()
15286 {
15287 sinhl ();
15288   ;
15289   return 0;
15290 }
15291 _ACEOF
15292 rm -f conftest.$ac_objext conftest$ac_exeext
15293 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15294   (eval $ac_link) 2>conftest.er1
15295   ac_status=$?
15296   grep -v '^ *+' conftest.er1 >conftest.err
15297   rm -f conftest.er1
15298   cat conftest.err >&5
15299   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15300   (exit $ac_status); } &&
15301          { ac_try='test -z "$ac_c_werror_flag"
15302                          || test ! -s conftest.err'
15303   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15304   (eval $ac_try) 2>&5
15305   ac_status=$?
15306   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15307   (exit $ac_status); }; } &&
15308          { ac_try='test -s conftest$ac_exeext'
15309   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15310   (eval $ac_try) 2>&5
15311   ac_status=$?
15312   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15313   (exit $ac_status); }; }; then
15314   ac_cv_lib_m_sinhl=yes
15315 else
15316   echo "$as_me: failed program was:" >&5
15317 sed 's/^/| /' conftest.$ac_ext >&5
15318
15319 ac_cv_lib_m_sinhl=no
15320 fi
15321 rm -f conftest.err conftest.$ac_objext \
15322       conftest$ac_exeext conftest.$ac_ext
15323 LIBS=$ac_check_lib_save_LIBS
15324 fi
15325 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sinhl" >&5
15326 echo "${ECHO_T}$ac_cv_lib_m_sinhl" >&6
15327 if test $ac_cv_lib_m_sinhl = yes; then
15328
15329 cat >>confdefs.h <<\_ACEOF
15330 #define HAVE_SINHL 1
15331 _ACEOF
15332
15333 fi
15334
15335 echo "$as_me:$LINENO: checking for csinhf in -lm" >&5
15336 echo $ECHO_N "checking for csinhf in -lm... $ECHO_C" >&6
15337 if test "${ac_cv_lib_m_csinhf+set}" = set; then
15338   echo $ECHO_N "(cached) $ECHO_C" >&6
15339 else
15340   ac_check_lib_save_LIBS=$LIBS
15341 LIBS="-lm  $LIBS"
15342 if test x$gcc_no_link = xyes; then
15343   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15344 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15345    { (exit 1); exit 1; }; }
15346 fi
15347 cat >conftest.$ac_ext <<_ACEOF
15348 /* confdefs.h.  */
15349 _ACEOF
15350 cat confdefs.h >>conftest.$ac_ext
15351 cat >>conftest.$ac_ext <<_ACEOF
15352 /* end confdefs.h.  */
15353
15354 /* Override any gcc2 internal prototype to avoid an error.  */
15355 #ifdef __cplusplus
15356 extern "C"
15357 #endif
15358 /* We use char because int might match the return type of a gcc2
15359    builtin and then its argument prototype would still apply.  */
15360 char csinhf ();
15361 int
15362 main ()
15363 {
15364 csinhf ();
15365   ;
15366   return 0;
15367 }
15368 _ACEOF
15369 rm -f conftest.$ac_objext conftest$ac_exeext
15370 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15371   (eval $ac_link) 2>conftest.er1
15372   ac_status=$?
15373   grep -v '^ *+' conftest.er1 >conftest.err
15374   rm -f conftest.er1
15375   cat conftest.err >&5
15376   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15377   (exit $ac_status); } &&
15378          { ac_try='test -z "$ac_c_werror_flag"
15379                          || test ! -s conftest.err'
15380   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15381   (eval $ac_try) 2>&5
15382   ac_status=$?
15383   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15384   (exit $ac_status); }; } &&
15385          { ac_try='test -s conftest$ac_exeext'
15386   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15387   (eval $ac_try) 2>&5
15388   ac_status=$?
15389   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15390   (exit $ac_status); }; }; then
15391   ac_cv_lib_m_csinhf=yes
15392 else
15393   echo "$as_me: failed program was:" >&5
15394 sed 's/^/| /' conftest.$ac_ext >&5
15395
15396 ac_cv_lib_m_csinhf=no
15397 fi
15398 rm -f conftest.err conftest.$ac_objext \
15399       conftest$ac_exeext conftest.$ac_ext
15400 LIBS=$ac_check_lib_save_LIBS
15401 fi
15402 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinhf" >&5
15403 echo "${ECHO_T}$ac_cv_lib_m_csinhf" >&6
15404 if test $ac_cv_lib_m_csinhf = yes; then
15405
15406 cat >>confdefs.h <<\_ACEOF
15407 #define HAVE_CSINHF 1
15408 _ACEOF
15409
15410 fi
15411
15412 echo "$as_me:$LINENO: checking for csinh in -lm" >&5
15413 echo $ECHO_N "checking for csinh in -lm... $ECHO_C" >&6
15414 if test "${ac_cv_lib_m_csinh+set}" = set; then
15415   echo $ECHO_N "(cached) $ECHO_C" >&6
15416 else
15417   ac_check_lib_save_LIBS=$LIBS
15418 LIBS="-lm  $LIBS"
15419 if test x$gcc_no_link = xyes; then
15420   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15421 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15422    { (exit 1); exit 1; }; }
15423 fi
15424 cat >conftest.$ac_ext <<_ACEOF
15425 /* confdefs.h.  */
15426 _ACEOF
15427 cat confdefs.h >>conftest.$ac_ext
15428 cat >>conftest.$ac_ext <<_ACEOF
15429 /* end confdefs.h.  */
15430
15431 /* Override any gcc2 internal prototype to avoid an error.  */
15432 #ifdef __cplusplus
15433 extern "C"
15434 #endif
15435 /* We use char because int might match the return type of a gcc2
15436    builtin and then its argument prototype would still apply.  */
15437 char csinh ();
15438 int
15439 main ()
15440 {
15441 csinh ();
15442   ;
15443   return 0;
15444 }
15445 _ACEOF
15446 rm -f conftest.$ac_objext conftest$ac_exeext
15447 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15448   (eval $ac_link) 2>conftest.er1
15449   ac_status=$?
15450   grep -v '^ *+' conftest.er1 >conftest.err
15451   rm -f conftest.er1
15452   cat conftest.err >&5
15453   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15454   (exit $ac_status); } &&
15455          { ac_try='test -z "$ac_c_werror_flag"
15456                          || test ! -s conftest.err'
15457   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15458   (eval $ac_try) 2>&5
15459   ac_status=$?
15460   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15461   (exit $ac_status); }; } &&
15462          { ac_try='test -s conftest$ac_exeext'
15463   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15464   (eval $ac_try) 2>&5
15465   ac_status=$?
15466   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15467   (exit $ac_status); }; }; then
15468   ac_cv_lib_m_csinh=yes
15469 else
15470   echo "$as_me: failed program was:" >&5
15471 sed 's/^/| /' conftest.$ac_ext >&5
15472
15473 ac_cv_lib_m_csinh=no
15474 fi
15475 rm -f conftest.err conftest.$ac_objext \
15476       conftest$ac_exeext conftest.$ac_ext
15477 LIBS=$ac_check_lib_save_LIBS
15478 fi
15479 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinh" >&5
15480 echo "${ECHO_T}$ac_cv_lib_m_csinh" >&6
15481 if test $ac_cv_lib_m_csinh = yes; then
15482
15483 cat >>confdefs.h <<\_ACEOF
15484 #define HAVE_CSINH 1
15485 _ACEOF
15486
15487 fi
15488
15489 echo "$as_me:$LINENO: checking for csinhl in -lm" >&5
15490 echo $ECHO_N "checking for csinhl in -lm... $ECHO_C" >&6
15491 if test "${ac_cv_lib_m_csinhl+set}" = set; then
15492   echo $ECHO_N "(cached) $ECHO_C" >&6
15493 else
15494   ac_check_lib_save_LIBS=$LIBS
15495 LIBS="-lm  $LIBS"
15496 if test x$gcc_no_link = xyes; then
15497   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15498 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15499    { (exit 1); exit 1; }; }
15500 fi
15501 cat >conftest.$ac_ext <<_ACEOF
15502 /* confdefs.h.  */
15503 _ACEOF
15504 cat confdefs.h >>conftest.$ac_ext
15505 cat >>conftest.$ac_ext <<_ACEOF
15506 /* end confdefs.h.  */
15507
15508 /* Override any gcc2 internal prototype to avoid an error.  */
15509 #ifdef __cplusplus
15510 extern "C"
15511 #endif
15512 /* We use char because int might match the return type of a gcc2
15513    builtin and then its argument prototype would still apply.  */
15514 char csinhl ();
15515 int
15516 main ()
15517 {
15518 csinhl ();
15519   ;
15520   return 0;
15521 }
15522 _ACEOF
15523 rm -f conftest.$ac_objext conftest$ac_exeext
15524 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15525   (eval $ac_link) 2>conftest.er1
15526   ac_status=$?
15527   grep -v '^ *+' conftest.er1 >conftest.err
15528   rm -f conftest.er1
15529   cat conftest.err >&5
15530   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15531   (exit $ac_status); } &&
15532          { ac_try='test -z "$ac_c_werror_flag"
15533                          || test ! -s conftest.err'
15534   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15535   (eval $ac_try) 2>&5
15536   ac_status=$?
15537   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15538   (exit $ac_status); }; } &&
15539          { ac_try='test -s conftest$ac_exeext'
15540   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15541   (eval $ac_try) 2>&5
15542   ac_status=$?
15543   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15544   (exit $ac_status); }; }; then
15545   ac_cv_lib_m_csinhl=yes
15546 else
15547   echo "$as_me: failed program was:" >&5
15548 sed 's/^/| /' conftest.$ac_ext >&5
15549
15550 ac_cv_lib_m_csinhl=no
15551 fi
15552 rm -f conftest.err conftest.$ac_objext \
15553       conftest$ac_exeext conftest.$ac_ext
15554 LIBS=$ac_check_lib_save_LIBS
15555 fi
15556 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csinhl" >&5
15557 echo "${ECHO_T}$ac_cv_lib_m_csinhl" >&6
15558 if test $ac_cv_lib_m_csinhl = yes; then
15559
15560 cat >>confdefs.h <<\_ACEOF
15561 #define HAVE_CSINHL 1
15562 _ACEOF
15563
15564 fi
15565
15566 echo "$as_me:$LINENO: checking for sqrtf in -lm" >&5
15567 echo $ECHO_N "checking for sqrtf in -lm... $ECHO_C" >&6
15568 if test "${ac_cv_lib_m_sqrtf+set}" = set; then
15569   echo $ECHO_N "(cached) $ECHO_C" >&6
15570 else
15571   ac_check_lib_save_LIBS=$LIBS
15572 LIBS="-lm  $LIBS"
15573 if test x$gcc_no_link = xyes; then
15574   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15575 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15576    { (exit 1); exit 1; }; }
15577 fi
15578 cat >conftest.$ac_ext <<_ACEOF
15579 /* confdefs.h.  */
15580 _ACEOF
15581 cat confdefs.h >>conftest.$ac_ext
15582 cat >>conftest.$ac_ext <<_ACEOF
15583 /* end confdefs.h.  */
15584
15585 /* Override any gcc2 internal prototype to avoid an error.  */
15586 #ifdef __cplusplus
15587 extern "C"
15588 #endif
15589 /* We use char because int might match the return type of a gcc2
15590    builtin and then its argument prototype would still apply.  */
15591 char sqrtf ();
15592 int
15593 main ()
15594 {
15595 sqrtf ();
15596   ;
15597   return 0;
15598 }
15599 _ACEOF
15600 rm -f conftest.$ac_objext conftest$ac_exeext
15601 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15602   (eval $ac_link) 2>conftest.er1
15603   ac_status=$?
15604   grep -v '^ *+' conftest.er1 >conftest.err
15605   rm -f conftest.er1
15606   cat conftest.err >&5
15607   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15608   (exit $ac_status); } &&
15609          { ac_try='test -z "$ac_c_werror_flag"
15610                          || test ! -s conftest.err'
15611   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15612   (eval $ac_try) 2>&5
15613   ac_status=$?
15614   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15615   (exit $ac_status); }; } &&
15616          { ac_try='test -s conftest$ac_exeext'
15617   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15618   (eval $ac_try) 2>&5
15619   ac_status=$?
15620   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15621   (exit $ac_status); }; }; then
15622   ac_cv_lib_m_sqrtf=yes
15623 else
15624   echo "$as_me: failed program was:" >&5
15625 sed 's/^/| /' conftest.$ac_ext >&5
15626
15627 ac_cv_lib_m_sqrtf=no
15628 fi
15629 rm -f conftest.err conftest.$ac_objext \
15630       conftest$ac_exeext conftest.$ac_ext
15631 LIBS=$ac_check_lib_save_LIBS
15632 fi
15633 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrtf" >&5
15634 echo "${ECHO_T}$ac_cv_lib_m_sqrtf" >&6
15635 if test $ac_cv_lib_m_sqrtf = yes; then
15636
15637 cat >>confdefs.h <<\_ACEOF
15638 #define HAVE_SQRTF 1
15639 _ACEOF
15640
15641 fi
15642
15643 echo "$as_me:$LINENO: checking for sqrt in -lm" >&5
15644 echo $ECHO_N "checking for sqrt in -lm... $ECHO_C" >&6
15645 if test "${ac_cv_lib_m_sqrt+set}" = set; then
15646   echo $ECHO_N "(cached) $ECHO_C" >&6
15647 else
15648   ac_check_lib_save_LIBS=$LIBS
15649 LIBS="-lm  $LIBS"
15650 if test x$gcc_no_link = xyes; then
15651   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15652 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15653    { (exit 1); exit 1; }; }
15654 fi
15655 cat >conftest.$ac_ext <<_ACEOF
15656 /* confdefs.h.  */
15657 _ACEOF
15658 cat confdefs.h >>conftest.$ac_ext
15659 cat >>conftest.$ac_ext <<_ACEOF
15660 /* end confdefs.h.  */
15661
15662 /* Override any gcc2 internal prototype to avoid an error.  */
15663 #ifdef __cplusplus
15664 extern "C"
15665 #endif
15666 /* We use char because int might match the return type of a gcc2
15667    builtin and then its argument prototype would still apply.  */
15668 char sqrt ();
15669 int
15670 main ()
15671 {
15672 sqrt ();
15673   ;
15674   return 0;
15675 }
15676 _ACEOF
15677 rm -f conftest.$ac_objext conftest$ac_exeext
15678 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15679   (eval $ac_link) 2>conftest.er1
15680   ac_status=$?
15681   grep -v '^ *+' conftest.er1 >conftest.err
15682   rm -f conftest.er1
15683   cat conftest.err >&5
15684   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15685   (exit $ac_status); } &&
15686          { ac_try='test -z "$ac_c_werror_flag"
15687                          || test ! -s conftest.err'
15688   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15689   (eval $ac_try) 2>&5
15690   ac_status=$?
15691   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15692   (exit $ac_status); }; } &&
15693          { ac_try='test -s conftest$ac_exeext'
15694   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15695   (eval $ac_try) 2>&5
15696   ac_status=$?
15697   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15698   (exit $ac_status); }; }; then
15699   ac_cv_lib_m_sqrt=yes
15700 else
15701   echo "$as_me: failed program was:" >&5
15702 sed 's/^/| /' conftest.$ac_ext >&5
15703
15704 ac_cv_lib_m_sqrt=no
15705 fi
15706 rm -f conftest.err conftest.$ac_objext \
15707       conftest$ac_exeext conftest.$ac_ext
15708 LIBS=$ac_check_lib_save_LIBS
15709 fi
15710 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrt" >&5
15711 echo "${ECHO_T}$ac_cv_lib_m_sqrt" >&6
15712 if test $ac_cv_lib_m_sqrt = yes; then
15713
15714 cat >>confdefs.h <<\_ACEOF
15715 #define HAVE_SQRT 1
15716 _ACEOF
15717
15718 fi
15719
15720 echo "$as_me:$LINENO: checking for sqrtl in -lm" >&5
15721 echo $ECHO_N "checking for sqrtl in -lm... $ECHO_C" >&6
15722 if test "${ac_cv_lib_m_sqrtl+set}" = set; then
15723   echo $ECHO_N "(cached) $ECHO_C" >&6
15724 else
15725   ac_check_lib_save_LIBS=$LIBS
15726 LIBS="-lm  $LIBS"
15727 if test x$gcc_no_link = xyes; then
15728   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15729 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15730    { (exit 1); exit 1; }; }
15731 fi
15732 cat >conftest.$ac_ext <<_ACEOF
15733 /* confdefs.h.  */
15734 _ACEOF
15735 cat confdefs.h >>conftest.$ac_ext
15736 cat >>conftest.$ac_ext <<_ACEOF
15737 /* end confdefs.h.  */
15738
15739 /* Override any gcc2 internal prototype to avoid an error.  */
15740 #ifdef __cplusplus
15741 extern "C"
15742 #endif
15743 /* We use char because int might match the return type of a gcc2
15744    builtin and then its argument prototype would still apply.  */
15745 char sqrtl ();
15746 int
15747 main ()
15748 {
15749 sqrtl ();
15750   ;
15751   return 0;
15752 }
15753 _ACEOF
15754 rm -f conftest.$ac_objext conftest$ac_exeext
15755 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15756   (eval $ac_link) 2>conftest.er1
15757   ac_status=$?
15758   grep -v '^ *+' conftest.er1 >conftest.err
15759   rm -f conftest.er1
15760   cat conftest.err >&5
15761   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15762   (exit $ac_status); } &&
15763          { ac_try='test -z "$ac_c_werror_flag"
15764                          || test ! -s conftest.err'
15765   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15766   (eval $ac_try) 2>&5
15767   ac_status=$?
15768   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15769   (exit $ac_status); }; } &&
15770          { ac_try='test -s conftest$ac_exeext'
15771   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15772   (eval $ac_try) 2>&5
15773   ac_status=$?
15774   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15775   (exit $ac_status); }; }; then
15776   ac_cv_lib_m_sqrtl=yes
15777 else
15778   echo "$as_me: failed program was:" >&5
15779 sed 's/^/| /' conftest.$ac_ext >&5
15780
15781 ac_cv_lib_m_sqrtl=no
15782 fi
15783 rm -f conftest.err conftest.$ac_objext \
15784       conftest$ac_exeext conftest.$ac_ext
15785 LIBS=$ac_check_lib_save_LIBS
15786 fi
15787 echo "$as_me:$LINENO: result: $ac_cv_lib_m_sqrtl" >&5
15788 echo "${ECHO_T}$ac_cv_lib_m_sqrtl" >&6
15789 if test $ac_cv_lib_m_sqrtl = yes; then
15790
15791 cat >>confdefs.h <<\_ACEOF
15792 #define HAVE_SQRTL 1
15793 _ACEOF
15794
15795 fi
15796
15797 echo "$as_me:$LINENO: checking for csqrtf in -lm" >&5
15798 echo $ECHO_N "checking for csqrtf in -lm... $ECHO_C" >&6
15799 if test "${ac_cv_lib_m_csqrtf+set}" = set; then
15800   echo $ECHO_N "(cached) $ECHO_C" >&6
15801 else
15802   ac_check_lib_save_LIBS=$LIBS
15803 LIBS="-lm  $LIBS"
15804 if test x$gcc_no_link = xyes; then
15805   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15806 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15807    { (exit 1); exit 1; }; }
15808 fi
15809 cat >conftest.$ac_ext <<_ACEOF
15810 /* confdefs.h.  */
15811 _ACEOF
15812 cat confdefs.h >>conftest.$ac_ext
15813 cat >>conftest.$ac_ext <<_ACEOF
15814 /* end confdefs.h.  */
15815
15816 /* Override any gcc2 internal prototype to avoid an error.  */
15817 #ifdef __cplusplus
15818 extern "C"
15819 #endif
15820 /* We use char because int might match the return type of a gcc2
15821    builtin and then its argument prototype would still apply.  */
15822 char csqrtf ();
15823 int
15824 main ()
15825 {
15826 csqrtf ();
15827   ;
15828   return 0;
15829 }
15830 _ACEOF
15831 rm -f conftest.$ac_objext conftest$ac_exeext
15832 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15833   (eval $ac_link) 2>conftest.er1
15834   ac_status=$?
15835   grep -v '^ *+' conftest.er1 >conftest.err
15836   rm -f conftest.er1
15837   cat conftest.err >&5
15838   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15839   (exit $ac_status); } &&
15840          { ac_try='test -z "$ac_c_werror_flag"
15841                          || test ! -s conftest.err'
15842   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15843   (eval $ac_try) 2>&5
15844   ac_status=$?
15845   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15846   (exit $ac_status); }; } &&
15847          { ac_try='test -s conftest$ac_exeext'
15848   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15849   (eval $ac_try) 2>&5
15850   ac_status=$?
15851   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15852   (exit $ac_status); }; }; then
15853   ac_cv_lib_m_csqrtf=yes
15854 else
15855   echo "$as_me: failed program was:" >&5
15856 sed 's/^/| /' conftest.$ac_ext >&5
15857
15858 ac_cv_lib_m_csqrtf=no
15859 fi
15860 rm -f conftest.err conftest.$ac_objext \
15861       conftest$ac_exeext conftest.$ac_ext
15862 LIBS=$ac_check_lib_save_LIBS
15863 fi
15864 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrtf" >&5
15865 echo "${ECHO_T}$ac_cv_lib_m_csqrtf" >&6
15866 if test $ac_cv_lib_m_csqrtf = yes; then
15867
15868 cat >>confdefs.h <<\_ACEOF
15869 #define HAVE_CSQRTF 1
15870 _ACEOF
15871
15872 fi
15873
15874 echo "$as_me:$LINENO: checking for csqrt in -lm" >&5
15875 echo $ECHO_N "checking for csqrt in -lm... $ECHO_C" >&6
15876 if test "${ac_cv_lib_m_csqrt+set}" = set; then
15877   echo $ECHO_N "(cached) $ECHO_C" >&6
15878 else
15879   ac_check_lib_save_LIBS=$LIBS
15880 LIBS="-lm  $LIBS"
15881 if test x$gcc_no_link = xyes; then
15882   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15883 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15884    { (exit 1); exit 1; }; }
15885 fi
15886 cat >conftest.$ac_ext <<_ACEOF
15887 /* confdefs.h.  */
15888 _ACEOF
15889 cat confdefs.h >>conftest.$ac_ext
15890 cat >>conftest.$ac_ext <<_ACEOF
15891 /* end confdefs.h.  */
15892
15893 /* Override any gcc2 internal prototype to avoid an error.  */
15894 #ifdef __cplusplus
15895 extern "C"
15896 #endif
15897 /* We use char because int might match the return type of a gcc2
15898    builtin and then its argument prototype would still apply.  */
15899 char csqrt ();
15900 int
15901 main ()
15902 {
15903 csqrt ();
15904   ;
15905   return 0;
15906 }
15907 _ACEOF
15908 rm -f conftest.$ac_objext conftest$ac_exeext
15909 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15910   (eval $ac_link) 2>conftest.er1
15911   ac_status=$?
15912   grep -v '^ *+' conftest.er1 >conftest.err
15913   rm -f conftest.er1
15914   cat conftest.err >&5
15915   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15916   (exit $ac_status); } &&
15917          { ac_try='test -z "$ac_c_werror_flag"
15918                          || test ! -s conftest.err'
15919   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15920   (eval $ac_try) 2>&5
15921   ac_status=$?
15922   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15923   (exit $ac_status); }; } &&
15924          { ac_try='test -s conftest$ac_exeext'
15925   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15926   (eval $ac_try) 2>&5
15927   ac_status=$?
15928   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15929   (exit $ac_status); }; }; then
15930   ac_cv_lib_m_csqrt=yes
15931 else
15932   echo "$as_me: failed program was:" >&5
15933 sed 's/^/| /' conftest.$ac_ext >&5
15934
15935 ac_cv_lib_m_csqrt=no
15936 fi
15937 rm -f conftest.err conftest.$ac_objext \
15938       conftest$ac_exeext conftest.$ac_ext
15939 LIBS=$ac_check_lib_save_LIBS
15940 fi
15941 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrt" >&5
15942 echo "${ECHO_T}$ac_cv_lib_m_csqrt" >&6
15943 if test $ac_cv_lib_m_csqrt = yes; then
15944
15945 cat >>confdefs.h <<\_ACEOF
15946 #define HAVE_CSQRT 1
15947 _ACEOF
15948
15949 fi
15950
15951 echo "$as_me:$LINENO: checking for csqrtl in -lm" >&5
15952 echo $ECHO_N "checking for csqrtl in -lm... $ECHO_C" >&6
15953 if test "${ac_cv_lib_m_csqrtl+set}" = set; then
15954   echo $ECHO_N "(cached) $ECHO_C" >&6
15955 else
15956   ac_check_lib_save_LIBS=$LIBS
15957 LIBS="-lm  $LIBS"
15958 if test x$gcc_no_link = xyes; then
15959   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
15960 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
15961    { (exit 1); exit 1; }; }
15962 fi
15963 cat >conftest.$ac_ext <<_ACEOF
15964 /* confdefs.h.  */
15965 _ACEOF
15966 cat confdefs.h >>conftest.$ac_ext
15967 cat >>conftest.$ac_ext <<_ACEOF
15968 /* end confdefs.h.  */
15969
15970 /* Override any gcc2 internal prototype to avoid an error.  */
15971 #ifdef __cplusplus
15972 extern "C"
15973 #endif
15974 /* We use char because int might match the return type of a gcc2
15975    builtin and then its argument prototype would still apply.  */
15976 char csqrtl ();
15977 int
15978 main ()
15979 {
15980 csqrtl ();
15981   ;
15982   return 0;
15983 }
15984 _ACEOF
15985 rm -f conftest.$ac_objext conftest$ac_exeext
15986 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
15987   (eval $ac_link) 2>conftest.er1
15988   ac_status=$?
15989   grep -v '^ *+' conftest.er1 >conftest.err
15990   rm -f conftest.er1
15991   cat conftest.err >&5
15992   echo "$as_me:$LINENO: \$? = $ac_status" >&5
15993   (exit $ac_status); } &&
15994          { ac_try='test -z "$ac_c_werror_flag"
15995                          || test ! -s conftest.err'
15996   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
15997   (eval $ac_try) 2>&5
15998   ac_status=$?
15999   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16000   (exit $ac_status); }; } &&
16001          { ac_try='test -s conftest$ac_exeext'
16002   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16003   (eval $ac_try) 2>&5
16004   ac_status=$?
16005   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16006   (exit $ac_status); }; }; then
16007   ac_cv_lib_m_csqrtl=yes
16008 else
16009   echo "$as_me: failed program was:" >&5
16010 sed 's/^/| /' conftest.$ac_ext >&5
16011
16012 ac_cv_lib_m_csqrtl=no
16013 fi
16014 rm -f conftest.err conftest.$ac_objext \
16015       conftest$ac_exeext conftest.$ac_ext
16016 LIBS=$ac_check_lib_save_LIBS
16017 fi
16018 echo "$as_me:$LINENO: result: $ac_cv_lib_m_csqrtl" >&5
16019 echo "${ECHO_T}$ac_cv_lib_m_csqrtl" >&6
16020 if test $ac_cv_lib_m_csqrtl = yes; then
16021
16022 cat >>confdefs.h <<\_ACEOF
16023 #define HAVE_CSQRTL 1
16024 _ACEOF
16025
16026 fi
16027
16028 echo "$as_me:$LINENO: checking for tanf in -lm" >&5
16029 echo $ECHO_N "checking for tanf in -lm... $ECHO_C" >&6
16030 if test "${ac_cv_lib_m_tanf+set}" = set; then
16031   echo $ECHO_N "(cached) $ECHO_C" >&6
16032 else
16033   ac_check_lib_save_LIBS=$LIBS
16034 LIBS="-lm  $LIBS"
16035 if test x$gcc_no_link = xyes; then
16036   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16037 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16038    { (exit 1); exit 1; }; }
16039 fi
16040 cat >conftest.$ac_ext <<_ACEOF
16041 /* confdefs.h.  */
16042 _ACEOF
16043 cat confdefs.h >>conftest.$ac_ext
16044 cat >>conftest.$ac_ext <<_ACEOF
16045 /* end confdefs.h.  */
16046
16047 /* Override any gcc2 internal prototype to avoid an error.  */
16048 #ifdef __cplusplus
16049 extern "C"
16050 #endif
16051 /* We use char because int might match the return type of a gcc2
16052    builtin and then its argument prototype would still apply.  */
16053 char tanf ();
16054 int
16055 main ()
16056 {
16057 tanf ();
16058   ;
16059   return 0;
16060 }
16061 _ACEOF
16062 rm -f conftest.$ac_objext conftest$ac_exeext
16063 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16064   (eval $ac_link) 2>conftest.er1
16065   ac_status=$?
16066   grep -v '^ *+' conftest.er1 >conftest.err
16067   rm -f conftest.er1
16068   cat conftest.err >&5
16069   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16070   (exit $ac_status); } &&
16071          { ac_try='test -z "$ac_c_werror_flag"
16072                          || test ! -s conftest.err'
16073   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16074   (eval $ac_try) 2>&5
16075   ac_status=$?
16076   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16077   (exit $ac_status); }; } &&
16078          { ac_try='test -s conftest$ac_exeext'
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); }; }; then
16084   ac_cv_lib_m_tanf=yes
16085 else
16086   echo "$as_me: failed program was:" >&5
16087 sed 's/^/| /' conftest.$ac_ext >&5
16088
16089 ac_cv_lib_m_tanf=no
16090 fi
16091 rm -f conftest.err conftest.$ac_objext \
16092       conftest$ac_exeext conftest.$ac_ext
16093 LIBS=$ac_check_lib_save_LIBS
16094 fi
16095 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanf" >&5
16096 echo "${ECHO_T}$ac_cv_lib_m_tanf" >&6
16097 if test $ac_cv_lib_m_tanf = yes; then
16098
16099 cat >>confdefs.h <<\_ACEOF
16100 #define HAVE_TANF 1
16101 _ACEOF
16102
16103 fi
16104
16105 echo "$as_me:$LINENO: checking for tan in -lm" >&5
16106 echo $ECHO_N "checking for tan in -lm... $ECHO_C" >&6
16107 if test "${ac_cv_lib_m_tan+set}" = set; then
16108   echo $ECHO_N "(cached) $ECHO_C" >&6
16109 else
16110   ac_check_lib_save_LIBS=$LIBS
16111 LIBS="-lm  $LIBS"
16112 if test x$gcc_no_link = xyes; then
16113   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16114 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16115    { (exit 1); exit 1; }; }
16116 fi
16117 cat >conftest.$ac_ext <<_ACEOF
16118 /* confdefs.h.  */
16119 _ACEOF
16120 cat confdefs.h >>conftest.$ac_ext
16121 cat >>conftest.$ac_ext <<_ACEOF
16122 /* end confdefs.h.  */
16123
16124 /* Override any gcc2 internal prototype to avoid an error.  */
16125 #ifdef __cplusplus
16126 extern "C"
16127 #endif
16128 /* We use char because int might match the return type of a gcc2
16129    builtin and then its argument prototype would still apply.  */
16130 char tan ();
16131 int
16132 main ()
16133 {
16134 tan ();
16135   ;
16136   return 0;
16137 }
16138 _ACEOF
16139 rm -f conftest.$ac_objext conftest$ac_exeext
16140 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16141   (eval $ac_link) 2>conftest.er1
16142   ac_status=$?
16143   grep -v '^ *+' conftest.er1 >conftest.err
16144   rm -f conftest.er1
16145   cat conftest.err >&5
16146   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16147   (exit $ac_status); } &&
16148          { ac_try='test -z "$ac_c_werror_flag"
16149                          || test ! -s conftest.err'
16150   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16151   (eval $ac_try) 2>&5
16152   ac_status=$?
16153   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16154   (exit $ac_status); }; } &&
16155          { ac_try='test -s conftest$ac_exeext'
16156   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16157   (eval $ac_try) 2>&5
16158   ac_status=$?
16159   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16160   (exit $ac_status); }; }; then
16161   ac_cv_lib_m_tan=yes
16162 else
16163   echo "$as_me: failed program was:" >&5
16164 sed 's/^/| /' conftest.$ac_ext >&5
16165
16166 ac_cv_lib_m_tan=no
16167 fi
16168 rm -f conftest.err conftest.$ac_objext \
16169       conftest$ac_exeext conftest.$ac_ext
16170 LIBS=$ac_check_lib_save_LIBS
16171 fi
16172 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tan" >&5
16173 echo "${ECHO_T}$ac_cv_lib_m_tan" >&6
16174 if test $ac_cv_lib_m_tan = yes; then
16175
16176 cat >>confdefs.h <<\_ACEOF
16177 #define HAVE_TAN 1
16178 _ACEOF
16179
16180 fi
16181
16182 echo "$as_me:$LINENO: checking for tanl in -lm" >&5
16183 echo $ECHO_N "checking for tanl in -lm... $ECHO_C" >&6
16184 if test "${ac_cv_lib_m_tanl+set}" = set; then
16185   echo $ECHO_N "(cached) $ECHO_C" >&6
16186 else
16187   ac_check_lib_save_LIBS=$LIBS
16188 LIBS="-lm  $LIBS"
16189 if test x$gcc_no_link = xyes; then
16190   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16191 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16192    { (exit 1); exit 1; }; }
16193 fi
16194 cat >conftest.$ac_ext <<_ACEOF
16195 /* confdefs.h.  */
16196 _ACEOF
16197 cat confdefs.h >>conftest.$ac_ext
16198 cat >>conftest.$ac_ext <<_ACEOF
16199 /* end confdefs.h.  */
16200
16201 /* Override any gcc2 internal prototype to avoid an error.  */
16202 #ifdef __cplusplus
16203 extern "C"
16204 #endif
16205 /* We use char because int might match the return type of a gcc2
16206    builtin and then its argument prototype would still apply.  */
16207 char tanl ();
16208 int
16209 main ()
16210 {
16211 tanl ();
16212   ;
16213   return 0;
16214 }
16215 _ACEOF
16216 rm -f conftest.$ac_objext conftest$ac_exeext
16217 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16218   (eval $ac_link) 2>conftest.er1
16219   ac_status=$?
16220   grep -v '^ *+' conftest.er1 >conftest.err
16221   rm -f conftest.er1
16222   cat conftest.err >&5
16223   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16224   (exit $ac_status); } &&
16225          { ac_try='test -z "$ac_c_werror_flag"
16226                          || test ! -s conftest.err'
16227   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16228   (eval $ac_try) 2>&5
16229   ac_status=$?
16230   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16231   (exit $ac_status); }; } &&
16232          { ac_try='test -s conftest$ac_exeext'
16233   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16234   (eval $ac_try) 2>&5
16235   ac_status=$?
16236   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16237   (exit $ac_status); }; }; then
16238   ac_cv_lib_m_tanl=yes
16239 else
16240   echo "$as_me: failed program was:" >&5
16241 sed 's/^/| /' conftest.$ac_ext >&5
16242
16243 ac_cv_lib_m_tanl=no
16244 fi
16245 rm -f conftest.err conftest.$ac_objext \
16246       conftest$ac_exeext conftest.$ac_ext
16247 LIBS=$ac_check_lib_save_LIBS
16248 fi
16249 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanl" >&5
16250 echo "${ECHO_T}$ac_cv_lib_m_tanl" >&6
16251 if test $ac_cv_lib_m_tanl = yes; then
16252
16253 cat >>confdefs.h <<\_ACEOF
16254 #define HAVE_TANL 1
16255 _ACEOF
16256
16257 fi
16258
16259 echo "$as_me:$LINENO: checking for ctanf in -lm" >&5
16260 echo $ECHO_N "checking for ctanf in -lm... $ECHO_C" >&6
16261 if test "${ac_cv_lib_m_ctanf+set}" = set; then
16262   echo $ECHO_N "(cached) $ECHO_C" >&6
16263 else
16264   ac_check_lib_save_LIBS=$LIBS
16265 LIBS="-lm  $LIBS"
16266 if test x$gcc_no_link = xyes; then
16267   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16268 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16269    { (exit 1); exit 1; }; }
16270 fi
16271 cat >conftest.$ac_ext <<_ACEOF
16272 /* confdefs.h.  */
16273 _ACEOF
16274 cat confdefs.h >>conftest.$ac_ext
16275 cat >>conftest.$ac_ext <<_ACEOF
16276 /* end confdefs.h.  */
16277
16278 /* Override any gcc2 internal prototype to avoid an error.  */
16279 #ifdef __cplusplus
16280 extern "C"
16281 #endif
16282 /* We use char because int might match the return type of a gcc2
16283    builtin and then its argument prototype would still apply.  */
16284 char ctanf ();
16285 int
16286 main ()
16287 {
16288 ctanf ();
16289   ;
16290   return 0;
16291 }
16292 _ACEOF
16293 rm -f conftest.$ac_objext conftest$ac_exeext
16294 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16295   (eval $ac_link) 2>conftest.er1
16296   ac_status=$?
16297   grep -v '^ *+' conftest.er1 >conftest.err
16298   rm -f conftest.er1
16299   cat conftest.err >&5
16300   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16301   (exit $ac_status); } &&
16302          { ac_try='test -z "$ac_c_werror_flag"
16303                          || test ! -s conftest.err'
16304   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16305   (eval $ac_try) 2>&5
16306   ac_status=$?
16307   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16308   (exit $ac_status); }; } &&
16309          { ac_try='test -s conftest$ac_exeext'
16310   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16311   (eval $ac_try) 2>&5
16312   ac_status=$?
16313   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16314   (exit $ac_status); }; }; then
16315   ac_cv_lib_m_ctanf=yes
16316 else
16317   echo "$as_me: failed program was:" >&5
16318 sed 's/^/| /' conftest.$ac_ext >&5
16319
16320 ac_cv_lib_m_ctanf=no
16321 fi
16322 rm -f conftest.err conftest.$ac_objext \
16323       conftest$ac_exeext conftest.$ac_ext
16324 LIBS=$ac_check_lib_save_LIBS
16325 fi
16326 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanf" >&5
16327 echo "${ECHO_T}$ac_cv_lib_m_ctanf" >&6
16328 if test $ac_cv_lib_m_ctanf = yes; then
16329
16330 cat >>confdefs.h <<\_ACEOF
16331 #define HAVE_CTANF 1
16332 _ACEOF
16333
16334 fi
16335
16336 echo "$as_me:$LINENO: checking for ctan in -lm" >&5
16337 echo $ECHO_N "checking for ctan in -lm... $ECHO_C" >&6
16338 if test "${ac_cv_lib_m_ctan+set}" = set; then
16339   echo $ECHO_N "(cached) $ECHO_C" >&6
16340 else
16341   ac_check_lib_save_LIBS=$LIBS
16342 LIBS="-lm  $LIBS"
16343 if test x$gcc_no_link = xyes; then
16344   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16345 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16346    { (exit 1); exit 1; }; }
16347 fi
16348 cat >conftest.$ac_ext <<_ACEOF
16349 /* confdefs.h.  */
16350 _ACEOF
16351 cat confdefs.h >>conftest.$ac_ext
16352 cat >>conftest.$ac_ext <<_ACEOF
16353 /* end confdefs.h.  */
16354
16355 /* Override any gcc2 internal prototype to avoid an error.  */
16356 #ifdef __cplusplus
16357 extern "C"
16358 #endif
16359 /* We use char because int might match the return type of a gcc2
16360    builtin and then its argument prototype would still apply.  */
16361 char ctan ();
16362 int
16363 main ()
16364 {
16365 ctan ();
16366   ;
16367   return 0;
16368 }
16369 _ACEOF
16370 rm -f conftest.$ac_objext conftest$ac_exeext
16371 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16372   (eval $ac_link) 2>conftest.er1
16373   ac_status=$?
16374   grep -v '^ *+' conftest.er1 >conftest.err
16375   rm -f conftest.er1
16376   cat conftest.err >&5
16377   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16378   (exit $ac_status); } &&
16379          { ac_try='test -z "$ac_c_werror_flag"
16380                          || test ! -s conftest.err'
16381   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16382   (eval $ac_try) 2>&5
16383   ac_status=$?
16384   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16385   (exit $ac_status); }; } &&
16386          { ac_try='test -s conftest$ac_exeext'
16387   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16388   (eval $ac_try) 2>&5
16389   ac_status=$?
16390   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16391   (exit $ac_status); }; }; then
16392   ac_cv_lib_m_ctan=yes
16393 else
16394   echo "$as_me: failed program was:" >&5
16395 sed 's/^/| /' conftest.$ac_ext >&5
16396
16397 ac_cv_lib_m_ctan=no
16398 fi
16399 rm -f conftest.err conftest.$ac_objext \
16400       conftest$ac_exeext conftest.$ac_ext
16401 LIBS=$ac_check_lib_save_LIBS
16402 fi
16403 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctan" >&5
16404 echo "${ECHO_T}$ac_cv_lib_m_ctan" >&6
16405 if test $ac_cv_lib_m_ctan = yes; then
16406
16407 cat >>confdefs.h <<\_ACEOF
16408 #define HAVE_CTAN 1
16409 _ACEOF
16410
16411 fi
16412
16413 echo "$as_me:$LINENO: checking for ctanl in -lm" >&5
16414 echo $ECHO_N "checking for ctanl in -lm... $ECHO_C" >&6
16415 if test "${ac_cv_lib_m_ctanl+set}" = set; then
16416   echo $ECHO_N "(cached) $ECHO_C" >&6
16417 else
16418   ac_check_lib_save_LIBS=$LIBS
16419 LIBS="-lm  $LIBS"
16420 if test x$gcc_no_link = xyes; then
16421   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16422 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16423    { (exit 1); exit 1; }; }
16424 fi
16425 cat >conftest.$ac_ext <<_ACEOF
16426 /* confdefs.h.  */
16427 _ACEOF
16428 cat confdefs.h >>conftest.$ac_ext
16429 cat >>conftest.$ac_ext <<_ACEOF
16430 /* end confdefs.h.  */
16431
16432 /* Override any gcc2 internal prototype to avoid an error.  */
16433 #ifdef __cplusplus
16434 extern "C"
16435 #endif
16436 /* We use char because int might match the return type of a gcc2
16437    builtin and then its argument prototype would still apply.  */
16438 char ctanl ();
16439 int
16440 main ()
16441 {
16442 ctanl ();
16443   ;
16444   return 0;
16445 }
16446 _ACEOF
16447 rm -f conftest.$ac_objext conftest$ac_exeext
16448 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16449   (eval $ac_link) 2>conftest.er1
16450   ac_status=$?
16451   grep -v '^ *+' conftest.er1 >conftest.err
16452   rm -f conftest.er1
16453   cat conftest.err >&5
16454   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16455   (exit $ac_status); } &&
16456          { ac_try='test -z "$ac_c_werror_flag"
16457                          || test ! -s conftest.err'
16458   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16459   (eval $ac_try) 2>&5
16460   ac_status=$?
16461   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16462   (exit $ac_status); }; } &&
16463          { ac_try='test -s conftest$ac_exeext'
16464   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16465   (eval $ac_try) 2>&5
16466   ac_status=$?
16467   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16468   (exit $ac_status); }; }; then
16469   ac_cv_lib_m_ctanl=yes
16470 else
16471   echo "$as_me: failed program was:" >&5
16472 sed 's/^/| /' conftest.$ac_ext >&5
16473
16474 ac_cv_lib_m_ctanl=no
16475 fi
16476 rm -f conftest.err conftest.$ac_objext \
16477       conftest$ac_exeext conftest.$ac_ext
16478 LIBS=$ac_check_lib_save_LIBS
16479 fi
16480 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanl" >&5
16481 echo "${ECHO_T}$ac_cv_lib_m_ctanl" >&6
16482 if test $ac_cv_lib_m_ctanl = yes; then
16483
16484 cat >>confdefs.h <<\_ACEOF
16485 #define HAVE_CTANL 1
16486 _ACEOF
16487
16488 fi
16489
16490 echo "$as_me:$LINENO: checking for tanhf in -lm" >&5
16491 echo $ECHO_N "checking for tanhf in -lm... $ECHO_C" >&6
16492 if test "${ac_cv_lib_m_tanhf+set}" = set; then
16493   echo $ECHO_N "(cached) $ECHO_C" >&6
16494 else
16495   ac_check_lib_save_LIBS=$LIBS
16496 LIBS="-lm  $LIBS"
16497 if test x$gcc_no_link = xyes; then
16498   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16499 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16500    { (exit 1); exit 1; }; }
16501 fi
16502 cat >conftest.$ac_ext <<_ACEOF
16503 /* confdefs.h.  */
16504 _ACEOF
16505 cat confdefs.h >>conftest.$ac_ext
16506 cat >>conftest.$ac_ext <<_ACEOF
16507 /* end confdefs.h.  */
16508
16509 /* Override any gcc2 internal prototype to avoid an error.  */
16510 #ifdef __cplusplus
16511 extern "C"
16512 #endif
16513 /* We use char because int might match the return type of a gcc2
16514    builtin and then its argument prototype would still apply.  */
16515 char tanhf ();
16516 int
16517 main ()
16518 {
16519 tanhf ();
16520   ;
16521   return 0;
16522 }
16523 _ACEOF
16524 rm -f conftest.$ac_objext conftest$ac_exeext
16525 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16526   (eval $ac_link) 2>conftest.er1
16527   ac_status=$?
16528   grep -v '^ *+' conftest.er1 >conftest.err
16529   rm -f conftest.er1
16530   cat conftest.err >&5
16531   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16532   (exit $ac_status); } &&
16533          { ac_try='test -z "$ac_c_werror_flag"
16534                          || 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"
16611                          || test ! -s conftest.err'
16612   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16613   (eval $ac_try) 2>&5
16614   ac_status=$?
16615   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16616   (exit $ac_status); }; } &&
16617          { ac_try='test -s conftest$ac_exeext'
16618   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16619   (eval $ac_try) 2>&5
16620   ac_status=$?
16621   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16622   (exit $ac_status); }; }; then
16623   ac_cv_lib_m_tanh=yes
16624 else
16625   echo "$as_me: failed program was:" >&5
16626 sed 's/^/| /' conftest.$ac_ext >&5
16627
16628 ac_cv_lib_m_tanh=no
16629 fi
16630 rm -f conftest.err conftest.$ac_objext \
16631       conftest$ac_exeext conftest.$ac_ext
16632 LIBS=$ac_check_lib_save_LIBS
16633 fi
16634 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanh" >&5
16635 echo "${ECHO_T}$ac_cv_lib_m_tanh" >&6
16636 if test $ac_cv_lib_m_tanh = yes; then
16637
16638 cat >>confdefs.h <<\_ACEOF
16639 #define HAVE_TANH 1
16640 _ACEOF
16641
16642 fi
16643
16644 echo "$as_me:$LINENO: checking for tanhl in -lm" >&5
16645 echo $ECHO_N "checking for tanhl in -lm... $ECHO_C" >&6
16646 if test "${ac_cv_lib_m_tanhl+set}" = set; then
16647   echo $ECHO_N "(cached) $ECHO_C" >&6
16648 else
16649   ac_check_lib_save_LIBS=$LIBS
16650 LIBS="-lm  $LIBS"
16651 if test x$gcc_no_link = xyes; then
16652   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16653 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16654    { (exit 1); exit 1; }; }
16655 fi
16656 cat >conftest.$ac_ext <<_ACEOF
16657 /* confdefs.h.  */
16658 _ACEOF
16659 cat confdefs.h >>conftest.$ac_ext
16660 cat >>conftest.$ac_ext <<_ACEOF
16661 /* end confdefs.h.  */
16662
16663 /* Override any gcc2 internal prototype to avoid an error.  */
16664 #ifdef __cplusplus
16665 extern "C"
16666 #endif
16667 /* We use char because int might match the return type of a gcc2
16668    builtin and then its argument prototype would still apply.  */
16669 char tanhl ();
16670 int
16671 main ()
16672 {
16673 tanhl ();
16674   ;
16675   return 0;
16676 }
16677 _ACEOF
16678 rm -f conftest.$ac_objext conftest$ac_exeext
16679 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16680   (eval $ac_link) 2>conftest.er1
16681   ac_status=$?
16682   grep -v '^ *+' conftest.er1 >conftest.err
16683   rm -f conftest.er1
16684   cat conftest.err >&5
16685   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16686   (exit $ac_status); } &&
16687          { ac_try='test -z "$ac_c_werror_flag"
16688                          || test ! -s conftest.err'
16689   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16690   (eval $ac_try) 2>&5
16691   ac_status=$?
16692   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16693   (exit $ac_status); }; } &&
16694          { ac_try='test -s conftest$ac_exeext'
16695   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16696   (eval $ac_try) 2>&5
16697   ac_status=$?
16698   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16699   (exit $ac_status); }; }; then
16700   ac_cv_lib_m_tanhl=yes
16701 else
16702   echo "$as_me: failed program was:" >&5
16703 sed 's/^/| /' conftest.$ac_ext >&5
16704
16705 ac_cv_lib_m_tanhl=no
16706 fi
16707 rm -f conftest.err conftest.$ac_objext \
16708       conftest$ac_exeext conftest.$ac_ext
16709 LIBS=$ac_check_lib_save_LIBS
16710 fi
16711 echo "$as_me:$LINENO: result: $ac_cv_lib_m_tanhl" >&5
16712 echo "${ECHO_T}$ac_cv_lib_m_tanhl" >&6
16713 if test $ac_cv_lib_m_tanhl = yes; then
16714
16715 cat >>confdefs.h <<\_ACEOF
16716 #define HAVE_TANHL 1
16717 _ACEOF
16718
16719 fi
16720
16721 echo "$as_me:$LINENO: checking for ctanhf in -lm" >&5
16722 echo $ECHO_N "checking for ctanhf in -lm... $ECHO_C" >&6
16723 if test "${ac_cv_lib_m_ctanhf+set}" = set; then
16724   echo $ECHO_N "(cached) $ECHO_C" >&6
16725 else
16726   ac_check_lib_save_LIBS=$LIBS
16727 LIBS="-lm  $LIBS"
16728 if test x$gcc_no_link = xyes; then
16729   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16730 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16731    { (exit 1); exit 1; }; }
16732 fi
16733 cat >conftest.$ac_ext <<_ACEOF
16734 /* confdefs.h.  */
16735 _ACEOF
16736 cat confdefs.h >>conftest.$ac_ext
16737 cat >>conftest.$ac_ext <<_ACEOF
16738 /* end confdefs.h.  */
16739
16740 /* Override any gcc2 internal prototype to avoid an error.  */
16741 #ifdef __cplusplus
16742 extern "C"
16743 #endif
16744 /* We use char because int might match the return type of a gcc2
16745    builtin and then its argument prototype would still apply.  */
16746 char ctanhf ();
16747 int
16748 main ()
16749 {
16750 ctanhf ();
16751   ;
16752   return 0;
16753 }
16754 _ACEOF
16755 rm -f conftest.$ac_objext conftest$ac_exeext
16756 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16757   (eval $ac_link) 2>conftest.er1
16758   ac_status=$?
16759   grep -v '^ *+' conftest.er1 >conftest.err
16760   rm -f conftest.er1
16761   cat conftest.err >&5
16762   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16763   (exit $ac_status); } &&
16764          { ac_try='test -z "$ac_c_werror_flag"
16765                          || test ! -s conftest.err'
16766   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16767   (eval $ac_try) 2>&5
16768   ac_status=$?
16769   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16770   (exit $ac_status); }; } &&
16771          { ac_try='test -s conftest$ac_exeext'
16772   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16773   (eval $ac_try) 2>&5
16774   ac_status=$?
16775   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16776   (exit $ac_status); }; }; then
16777   ac_cv_lib_m_ctanhf=yes
16778 else
16779   echo "$as_me: failed program was:" >&5
16780 sed 's/^/| /' conftest.$ac_ext >&5
16781
16782 ac_cv_lib_m_ctanhf=no
16783 fi
16784 rm -f conftest.err conftest.$ac_objext \
16785       conftest$ac_exeext conftest.$ac_ext
16786 LIBS=$ac_check_lib_save_LIBS
16787 fi
16788 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanhf" >&5
16789 echo "${ECHO_T}$ac_cv_lib_m_ctanhf" >&6
16790 if test $ac_cv_lib_m_ctanhf = yes; then
16791
16792 cat >>confdefs.h <<\_ACEOF
16793 #define HAVE_CTANHF 1
16794 _ACEOF
16795
16796 fi
16797
16798 echo "$as_me:$LINENO: checking for ctanh in -lm" >&5
16799 echo $ECHO_N "checking for ctanh in -lm... $ECHO_C" >&6
16800 if test "${ac_cv_lib_m_ctanh+set}" = set; then
16801   echo $ECHO_N "(cached) $ECHO_C" >&6
16802 else
16803   ac_check_lib_save_LIBS=$LIBS
16804 LIBS="-lm  $LIBS"
16805 if test x$gcc_no_link = xyes; then
16806   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16807 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16808    { (exit 1); exit 1; }; }
16809 fi
16810 cat >conftest.$ac_ext <<_ACEOF
16811 /* confdefs.h.  */
16812 _ACEOF
16813 cat confdefs.h >>conftest.$ac_ext
16814 cat >>conftest.$ac_ext <<_ACEOF
16815 /* end confdefs.h.  */
16816
16817 /* Override any gcc2 internal prototype to avoid an error.  */
16818 #ifdef __cplusplus
16819 extern "C"
16820 #endif
16821 /* We use char because int might match the return type of a gcc2
16822    builtin and then its argument prototype would still apply.  */
16823 char ctanh ();
16824 int
16825 main ()
16826 {
16827 ctanh ();
16828   ;
16829   return 0;
16830 }
16831 _ACEOF
16832 rm -f conftest.$ac_objext conftest$ac_exeext
16833 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16834   (eval $ac_link) 2>conftest.er1
16835   ac_status=$?
16836   grep -v '^ *+' conftest.er1 >conftest.err
16837   rm -f conftest.er1
16838   cat conftest.err >&5
16839   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16840   (exit $ac_status); } &&
16841          { ac_try='test -z "$ac_c_werror_flag"
16842                          || test ! -s conftest.err'
16843   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16844   (eval $ac_try) 2>&5
16845   ac_status=$?
16846   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16847   (exit $ac_status); }; } &&
16848          { ac_try='test -s conftest$ac_exeext'
16849   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16850   (eval $ac_try) 2>&5
16851   ac_status=$?
16852   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16853   (exit $ac_status); }; }; then
16854   ac_cv_lib_m_ctanh=yes
16855 else
16856   echo "$as_me: failed program was:" >&5
16857 sed 's/^/| /' conftest.$ac_ext >&5
16858
16859 ac_cv_lib_m_ctanh=no
16860 fi
16861 rm -f conftest.err conftest.$ac_objext \
16862       conftest$ac_exeext conftest.$ac_ext
16863 LIBS=$ac_check_lib_save_LIBS
16864 fi
16865 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanh" >&5
16866 echo "${ECHO_T}$ac_cv_lib_m_ctanh" >&6
16867 if test $ac_cv_lib_m_ctanh = yes; then
16868
16869 cat >>confdefs.h <<\_ACEOF
16870 #define HAVE_CTANH 1
16871 _ACEOF
16872
16873 fi
16874
16875 echo "$as_me:$LINENO: checking for ctanhl in -lm" >&5
16876 echo $ECHO_N "checking for ctanhl in -lm... $ECHO_C" >&6
16877 if test "${ac_cv_lib_m_ctanhl+set}" = set; then
16878   echo $ECHO_N "(cached) $ECHO_C" >&6
16879 else
16880   ac_check_lib_save_LIBS=$LIBS
16881 LIBS="-lm  $LIBS"
16882 if test x$gcc_no_link = xyes; then
16883   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16884 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16885    { (exit 1); exit 1; }; }
16886 fi
16887 cat >conftest.$ac_ext <<_ACEOF
16888 /* confdefs.h.  */
16889 _ACEOF
16890 cat confdefs.h >>conftest.$ac_ext
16891 cat >>conftest.$ac_ext <<_ACEOF
16892 /* end confdefs.h.  */
16893
16894 /* Override any gcc2 internal prototype to avoid an error.  */
16895 #ifdef __cplusplus
16896 extern "C"
16897 #endif
16898 /* We use char because int might match the return type of a gcc2
16899    builtin and then its argument prototype would still apply.  */
16900 char ctanhl ();
16901 int
16902 main ()
16903 {
16904 ctanhl ();
16905   ;
16906   return 0;
16907 }
16908 _ACEOF
16909 rm -f conftest.$ac_objext conftest$ac_exeext
16910 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16911   (eval $ac_link) 2>conftest.er1
16912   ac_status=$?
16913   grep -v '^ *+' conftest.er1 >conftest.err
16914   rm -f conftest.er1
16915   cat conftest.err >&5
16916   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16917   (exit $ac_status); } &&
16918          { ac_try='test -z "$ac_c_werror_flag"
16919                          || test ! -s conftest.err'
16920   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16921   (eval $ac_try) 2>&5
16922   ac_status=$?
16923   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16924   (exit $ac_status); }; } &&
16925          { ac_try='test -s conftest$ac_exeext'
16926   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
16927   (eval $ac_try) 2>&5
16928   ac_status=$?
16929   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16930   (exit $ac_status); }; }; then
16931   ac_cv_lib_m_ctanhl=yes
16932 else
16933   echo "$as_me: failed program was:" >&5
16934 sed 's/^/| /' conftest.$ac_ext >&5
16935
16936 ac_cv_lib_m_ctanhl=no
16937 fi
16938 rm -f conftest.err conftest.$ac_objext \
16939       conftest$ac_exeext conftest.$ac_ext
16940 LIBS=$ac_check_lib_save_LIBS
16941 fi
16942 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ctanhl" >&5
16943 echo "${ECHO_T}$ac_cv_lib_m_ctanhl" >&6
16944 if test $ac_cv_lib_m_ctanhl = yes; then
16945
16946 cat >>confdefs.h <<\_ACEOF
16947 #define HAVE_CTANHL 1
16948 _ACEOF
16949
16950 fi
16951
16952 echo "$as_me:$LINENO: checking for truncf in -lm" >&5
16953 echo $ECHO_N "checking for truncf in -lm... $ECHO_C" >&6
16954 if test "${ac_cv_lib_m_truncf+set}" = set; then
16955   echo $ECHO_N "(cached) $ECHO_C" >&6
16956 else
16957   ac_check_lib_save_LIBS=$LIBS
16958 LIBS="-lm  $LIBS"
16959 if test x$gcc_no_link = xyes; then
16960   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
16961 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
16962    { (exit 1); exit 1; }; }
16963 fi
16964 cat >conftest.$ac_ext <<_ACEOF
16965 /* confdefs.h.  */
16966 _ACEOF
16967 cat confdefs.h >>conftest.$ac_ext
16968 cat >>conftest.$ac_ext <<_ACEOF
16969 /* end confdefs.h.  */
16970
16971 /* Override any gcc2 internal prototype to avoid an error.  */
16972 #ifdef __cplusplus
16973 extern "C"
16974 #endif
16975 /* We use char because int might match the return type of a gcc2
16976    builtin and then its argument prototype would still apply.  */
16977 char truncf ();
16978 int
16979 main ()
16980 {
16981 truncf ();
16982   ;
16983   return 0;
16984 }
16985 _ACEOF
16986 rm -f conftest.$ac_objext conftest$ac_exeext
16987 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
16988   (eval $ac_link) 2>conftest.er1
16989   ac_status=$?
16990   grep -v '^ *+' conftest.er1 >conftest.err
16991   rm -f conftest.er1
16992   cat conftest.err >&5
16993   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16994   (exit $ac_status); } &&
16995          { ac_try='test -z "$ac_c_werror_flag"
16996                          || test ! -s conftest.err'
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); }; } &&
17002          { ac_try='test -s conftest$ac_exeext'
17003   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17004   (eval $ac_try) 2>&5
17005   ac_status=$?
17006   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17007   (exit $ac_status); }; }; then
17008   ac_cv_lib_m_truncf=yes
17009 else
17010   echo "$as_me: failed program was:" >&5
17011 sed 's/^/| /' conftest.$ac_ext >&5
17012
17013 ac_cv_lib_m_truncf=no
17014 fi
17015 rm -f conftest.err conftest.$ac_objext \
17016       conftest$ac_exeext conftest.$ac_ext
17017 LIBS=$ac_check_lib_save_LIBS
17018 fi
17019 echo "$as_me:$LINENO: result: $ac_cv_lib_m_truncf" >&5
17020 echo "${ECHO_T}$ac_cv_lib_m_truncf" >&6
17021 if test $ac_cv_lib_m_truncf = yes; then
17022
17023 cat >>confdefs.h <<\_ACEOF
17024 #define HAVE_TRUNCF 1
17025 _ACEOF
17026
17027 fi
17028
17029 echo "$as_me:$LINENO: checking for trunc in -lm" >&5
17030 echo $ECHO_N "checking for trunc in -lm... $ECHO_C" >&6
17031 if test "${ac_cv_lib_m_trunc+set}" = set; then
17032   echo $ECHO_N "(cached) $ECHO_C" >&6
17033 else
17034   ac_check_lib_save_LIBS=$LIBS
17035 LIBS="-lm  $LIBS"
17036 if test x$gcc_no_link = xyes; then
17037   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17038 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17039    { (exit 1); exit 1; }; }
17040 fi
17041 cat >conftest.$ac_ext <<_ACEOF
17042 /* confdefs.h.  */
17043 _ACEOF
17044 cat confdefs.h >>conftest.$ac_ext
17045 cat >>conftest.$ac_ext <<_ACEOF
17046 /* end confdefs.h.  */
17047
17048 /* Override any gcc2 internal prototype to avoid an error.  */
17049 #ifdef __cplusplus
17050 extern "C"
17051 #endif
17052 /* We use char because int might match the return type of a gcc2
17053    builtin and then its argument prototype would still apply.  */
17054 char trunc ();
17055 int
17056 main ()
17057 {
17058 trunc ();
17059   ;
17060   return 0;
17061 }
17062 _ACEOF
17063 rm -f conftest.$ac_objext conftest$ac_exeext
17064 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17065   (eval $ac_link) 2>conftest.er1
17066   ac_status=$?
17067   grep -v '^ *+' conftest.er1 >conftest.err
17068   rm -f conftest.er1
17069   cat conftest.err >&5
17070   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17071   (exit $ac_status); } &&
17072          { ac_try='test -z "$ac_c_werror_flag"
17073                          || test ! -s conftest.err'
17074   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17075   (eval $ac_try) 2>&5
17076   ac_status=$?
17077   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17078   (exit $ac_status); }; } &&
17079          { ac_try='test -s conftest$ac_exeext'
17080   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17081   (eval $ac_try) 2>&5
17082   ac_status=$?
17083   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17084   (exit $ac_status); }; }; then
17085   ac_cv_lib_m_trunc=yes
17086 else
17087   echo "$as_me: failed program was:" >&5
17088 sed 's/^/| /' conftest.$ac_ext >&5
17089
17090 ac_cv_lib_m_trunc=no
17091 fi
17092 rm -f conftest.err conftest.$ac_objext \
17093       conftest$ac_exeext conftest.$ac_ext
17094 LIBS=$ac_check_lib_save_LIBS
17095 fi
17096 echo "$as_me:$LINENO: result: $ac_cv_lib_m_trunc" >&5
17097 echo "${ECHO_T}$ac_cv_lib_m_trunc" >&6
17098 if test $ac_cv_lib_m_trunc = yes; then
17099
17100 cat >>confdefs.h <<\_ACEOF
17101 #define HAVE_TRUNC 1
17102 _ACEOF
17103
17104 fi
17105
17106 echo "$as_me:$LINENO: checking for truncl in -lm" >&5
17107 echo $ECHO_N "checking for truncl in -lm... $ECHO_C" >&6
17108 if test "${ac_cv_lib_m_truncl+set}" = set; then
17109   echo $ECHO_N "(cached) $ECHO_C" >&6
17110 else
17111   ac_check_lib_save_LIBS=$LIBS
17112 LIBS="-lm  $LIBS"
17113 if test x$gcc_no_link = xyes; then
17114   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17115 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17116    { (exit 1); exit 1; }; }
17117 fi
17118 cat >conftest.$ac_ext <<_ACEOF
17119 /* confdefs.h.  */
17120 _ACEOF
17121 cat confdefs.h >>conftest.$ac_ext
17122 cat >>conftest.$ac_ext <<_ACEOF
17123 /* end confdefs.h.  */
17124
17125 /* Override any gcc2 internal prototype to avoid an error.  */
17126 #ifdef __cplusplus
17127 extern "C"
17128 #endif
17129 /* We use char because int might match the return type of a gcc2
17130    builtin and then its argument prototype would still apply.  */
17131 char truncl ();
17132 int
17133 main ()
17134 {
17135 truncl ();
17136   ;
17137   return 0;
17138 }
17139 _ACEOF
17140 rm -f conftest.$ac_objext conftest$ac_exeext
17141 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17142   (eval $ac_link) 2>conftest.er1
17143   ac_status=$?
17144   grep -v '^ *+' conftest.er1 >conftest.err
17145   rm -f conftest.er1
17146   cat conftest.err >&5
17147   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17148   (exit $ac_status); } &&
17149          { ac_try='test -z "$ac_c_werror_flag"
17150                          || test ! -s conftest.err'
17151   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17152   (eval $ac_try) 2>&5
17153   ac_status=$?
17154   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17155   (exit $ac_status); }; } &&
17156          { ac_try='test -s conftest$ac_exeext'
17157   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17158   (eval $ac_try) 2>&5
17159   ac_status=$?
17160   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17161   (exit $ac_status); }; }; then
17162   ac_cv_lib_m_truncl=yes
17163 else
17164   echo "$as_me: failed program was:" >&5
17165 sed 's/^/| /' conftest.$ac_ext >&5
17166
17167 ac_cv_lib_m_truncl=no
17168 fi
17169 rm -f conftest.err conftest.$ac_objext \
17170       conftest$ac_exeext conftest.$ac_ext
17171 LIBS=$ac_check_lib_save_LIBS
17172 fi
17173 echo "$as_me:$LINENO: result: $ac_cv_lib_m_truncl" >&5
17174 echo "${ECHO_T}$ac_cv_lib_m_truncl" >&6
17175 if test $ac_cv_lib_m_truncl = yes; then
17176
17177 cat >>confdefs.h <<\_ACEOF
17178 #define HAVE_TRUNCL 1
17179 _ACEOF
17180
17181 fi
17182
17183 echo "$as_me:$LINENO: checking for erff in -lm" >&5
17184 echo $ECHO_N "checking for erff in -lm... $ECHO_C" >&6
17185 if test "${ac_cv_lib_m_erff+set}" = set; then
17186   echo $ECHO_N "(cached) $ECHO_C" >&6
17187 else
17188   ac_check_lib_save_LIBS=$LIBS
17189 LIBS="-lm  $LIBS"
17190 if test x$gcc_no_link = xyes; then
17191   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17192 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17193    { (exit 1); exit 1; }; }
17194 fi
17195 cat >conftest.$ac_ext <<_ACEOF
17196 /* confdefs.h.  */
17197 _ACEOF
17198 cat confdefs.h >>conftest.$ac_ext
17199 cat >>conftest.$ac_ext <<_ACEOF
17200 /* end confdefs.h.  */
17201
17202 /* Override any gcc2 internal prototype to avoid an error.  */
17203 #ifdef __cplusplus
17204 extern "C"
17205 #endif
17206 /* We use char because int might match the return type of a gcc2
17207    builtin and then its argument prototype would still apply.  */
17208 char erff ();
17209 int
17210 main ()
17211 {
17212 erff ();
17213   ;
17214   return 0;
17215 }
17216 _ACEOF
17217 rm -f conftest.$ac_objext conftest$ac_exeext
17218 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17219   (eval $ac_link) 2>conftest.er1
17220   ac_status=$?
17221   grep -v '^ *+' conftest.er1 >conftest.err
17222   rm -f conftest.er1
17223   cat conftest.err >&5
17224   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17225   (exit $ac_status); } &&
17226          { ac_try='test -z "$ac_c_werror_flag"
17227                          || test ! -s conftest.err'
17228   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17229   (eval $ac_try) 2>&5
17230   ac_status=$?
17231   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17232   (exit $ac_status); }; } &&
17233          { ac_try='test -s conftest$ac_exeext'
17234   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17235   (eval $ac_try) 2>&5
17236   ac_status=$?
17237   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17238   (exit $ac_status); }; }; then
17239   ac_cv_lib_m_erff=yes
17240 else
17241   echo "$as_me: failed program was:" >&5
17242 sed 's/^/| /' conftest.$ac_ext >&5
17243
17244 ac_cv_lib_m_erff=no
17245 fi
17246 rm -f conftest.err conftest.$ac_objext \
17247       conftest$ac_exeext conftest.$ac_ext
17248 LIBS=$ac_check_lib_save_LIBS
17249 fi
17250 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erff" >&5
17251 echo "${ECHO_T}$ac_cv_lib_m_erff" >&6
17252 if test $ac_cv_lib_m_erff = yes; then
17253
17254 cat >>confdefs.h <<\_ACEOF
17255 #define HAVE_ERFF 1
17256 _ACEOF
17257
17258 fi
17259
17260 echo "$as_me:$LINENO: checking for erf in -lm" >&5
17261 echo $ECHO_N "checking for erf in -lm... $ECHO_C" >&6
17262 if test "${ac_cv_lib_m_erf+set}" = set; then
17263   echo $ECHO_N "(cached) $ECHO_C" >&6
17264 else
17265   ac_check_lib_save_LIBS=$LIBS
17266 LIBS="-lm  $LIBS"
17267 if test x$gcc_no_link = xyes; then
17268   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17269 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17270    { (exit 1); exit 1; }; }
17271 fi
17272 cat >conftest.$ac_ext <<_ACEOF
17273 /* confdefs.h.  */
17274 _ACEOF
17275 cat confdefs.h >>conftest.$ac_ext
17276 cat >>conftest.$ac_ext <<_ACEOF
17277 /* end confdefs.h.  */
17278
17279 /* Override any gcc2 internal prototype to avoid an error.  */
17280 #ifdef __cplusplus
17281 extern "C"
17282 #endif
17283 /* We use char because int might match the return type of a gcc2
17284    builtin and then its argument prototype would still apply.  */
17285 char erf ();
17286 int
17287 main ()
17288 {
17289 erf ();
17290   ;
17291   return 0;
17292 }
17293 _ACEOF
17294 rm -f conftest.$ac_objext conftest$ac_exeext
17295 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17296   (eval $ac_link) 2>conftest.er1
17297   ac_status=$?
17298   grep -v '^ *+' conftest.er1 >conftest.err
17299   rm -f conftest.er1
17300   cat conftest.err >&5
17301   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17302   (exit $ac_status); } &&
17303          { ac_try='test -z "$ac_c_werror_flag"
17304                          || test ! -s conftest.err'
17305   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17306   (eval $ac_try) 2>&5
17307   ac_status=$?
17308   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17309   (exit $ac_status); }; } &&
17310          { ac_try='test -s conftest$ac_exeext'
17311   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17312   (eval $ac_try) 2>&5
17313   ac_status=$?
17314   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17315   (exit $ac_status); }; }; then
17316   ac_cv_lib_m_erf=yes
17317 else
17318   echo "$as_me: failed program was:" >&5
17319 sed 's/^/| /' conftest.$ac_ext >&5
17320
17321 ac_cv_lib_m_erf=no
17322 fi
17323 rm -f conftest.err conftest.$ac_objext \
17324       conftest$ac_exeext conftest.$ac_ext
17325 LIBS=$ac_check_lib_save_LIBS
17326 fi
17327 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erf" >&5
17328 echo "${ECHO_T}$ac_cv_lib_m_erf" >&6
17329 if test $ac_cv_lib_m_erf = yes; then
17330
17331 cat >>confdefs.h <<\_ACEOF
17332 #define HAVE_ERF 1
17333 _ACEOF
17334
17335 fi
17336
17337 echo "$as_me:$LINENO: checking for erfl in -lm" >&5
17338 echo $ECHO_N "checking for erfl in -lm... $ECHO_C" >&6
17339 if test "${ac_cv_lib_m_erfl+set}" = set; then
17340   echo $ECHO_N "(cached) $ECHO_C" >&6
17341 else
17342   ac_check_lib_save_LIBS=$LIBS
17343 LIBS="-lm  $LIBS"
17344 if test x$gcc_no_link = xyes; then
17345   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17346 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17347    { (exit 1); exit 1; }; }
17348 fi
17349 cat >conftest.$ac_ext <<_ACEOF
17350 /* confdefs.h.  */
17351 _ACEOF
17352 cat confdefs.h >>conftest.$ac_ext
17353 cat >>conftest.$ac_ext <<_ACEOF
17354 /* end confdefs.h.  */
17355
17356 /* Override any gcc2 internal prototype to avoid an error.  */
17357 #ifdef __cplusplus
17358 extern "C"
17359 #endif
17360 /* We use char because int might match the return type of a gcc2
17361    builtin and then its argument prototype would still apply.  */
17362 char erfl ();
17363 int
17364 main ()
17365 {
17366 erfl ();
17367   ;
17368   return 0;
17369 }
17370 _ACEOF
17371 rm -f conftest.$ac_objext conftest$ac_exeext
17372 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17373   (eval $ac_link) 2>conftest.er1
17374   ac_status=$?
17375   grep -v '^ *+' conftest.er1 >conftest.err
17376   rm -f conftest.er1
17377   cat conftest.err >&5
17378   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17379   (exit $ac_status); } &&
17380          { ac_try='test -z "$ac_c_werror_flag"
17381                          || test ! -s conftest.err'
17382   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17383   (eval $ac_try) 2>&5
17384   ac_status=$?
17385   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17386   (exit $ac_status); }; } &&
17387          { ac_try='test -s conftest$ac_exeext'
17388   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17389   (eval $ac_try) 2>&5
17390   ac_status=$?
17391   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17392   (exit $ac_status); }; }; then
17393   ac_cv_lib_m_erfl=yes
17394 else
17395   echo "$as_me: failed program was:" >&5
17396 sed 's/^/| /' conftest.$ac_ext >&5
17397
17398 ac_cv_lib_m_erfl=no
17399 fi
17400 rm -f conftest.err conftest.$ac_objext \
17401       conftest$ac_exeext conftest.$ac_ext
17402 LIBS=$ac_check_lib_save_LIBS
17403 fi
17404 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfl" >&5
17405 echo "${ECHO_T}$ac_cv_lib_m_erfl" >&6
17406 if test $ac_cv_lib_m_erfl = yes; then
17407
17408 cat >>confdefs.h <<\_ACEOF
17409 #define HAVE_ERFL 1
17410 _ACEOF
17411
17412 fi
17413
17414 echo "$as_me:$LINENO: checking for erfcf in -lm" >&5
17415 echo $ECHO_N "checking for erfcf in -lm... $ECHO_C" >&6
17416 if test "${ac_cv_lib_m_erfcf+set}" = set; then
17417   echo $ECHO_N "(cached) $ECHO_C" >&6
17418 else
17419   ac_check_lib_save_LIBS=$LIBS
17420 LIBS="-lm  $LIBS"
17421 if test x$gcc_no_link = xyes; then
17422   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17423 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17424    { (exit 1); exit 1; }; }
17425 fi
17426 cat >conftest.$ac_ext <<_ACEOF
17427 /* confdefs.h.  */
17428 _ACEOF
17429 cat confdefs.h >>conftest.$ac_ext
17430 cat >>conftest.$ac_ext <<_ACEOF
17431 /* end confdefs.h.  */
17432
17433 /* Override any gcc2 internal prototype to avoid an error.  */
17434 #ifdef __cplusplus
17435 extern "C"
17436 #endif
17437 /* We use char because int might match the return type of a gcc2
17438    builtin and then its argument prototype would still apply.  */
17439 char erfcf ();
17440 int
17441 main ()
17442 {
17443 erfcf ();
17444   ;
17445   return 0;
17446 }
17447 _ACEOF
17448 rm -f conftest.$ac_objext conftest$ac_exeext
17449 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17450   (eval $ac_link) 2>conftest.er1
17451   ac_status=$?
17452   grep -v '^ *+' conftest.er1 >conftest.err
17453   rm -f conftest.er1
17454   cat conftest.err >&5
17455   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17456   (exit $ac_status); } &&
17457          { ac_try='test -z "$ac_c_werror_flag"
17458                          || test ! -s conftest.err'
17459   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17460   (eval $ac_try) 2>&5
17461   ac_status=$?
17462   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17463   (exit $ac_status); }; } &&
17464          { ac_try='test -s conftest$ac_exeext'
17465   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17466   (eval $ac_try) 2>&5
17467   ac_status=$?
17468   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17469   (exit $ac_status); }; }; then
17470   ac_cv_lib_m_erfcf=yes
17471 else
17472   echo "$as_me: failed program was:" >&5
17473 sed 's/^/| /' conftest.$ac_ext >&5
17474
17475 ac_cv_lib_m_erfcf=no
17476 fi
17477 rm -f conftest.err conftest.$ac_objext \
17478       conftest$ac_exeext conftest.$ac_ext
17479 LIBS=$ac_check_lib_save_LIBS
17480 fi
17481 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfcf" >&5
17482 echo "${ECHO_T}$ac_cv_lib_m_erfcf" >&6
17483 if test $ac_cv_lib_m_erfcf = yes; then
17484
17485 cat >>confdefs.h <<\_ACEOF
17486 #define HAVE_ERFCF 1
17487 _ACEOF
17488
17489 fi
17490
17491 echo "$as_me:$LINENO: checking for erfc in -lm" >&5
17492 echo $ECHO_N "checking for erfc in -lm... $ECHO_C" >&6
17493 if test "${ac_cv_lib_m_erfc+set}" = set; then
17494   echo $ECHO_N "(cached) $ECHO_C" >&6
17495 else
17496   ac_check_lib_save_LIBS=$LIBS
17497 LIBS="-lm  $LIBS"
17498 if test x$gcc_no_link = xyes; then
17499   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17500 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17501    { (exit 1); exit 1; }; }
17502 fi
17503 cat >conftest.$ac_ext <<_ACEOF
17504 /* confdefs.h.  */
17505 _ACEOF
17506 cat confdefs.h >>conftest.$ac_ext
17507 cat >>conftest.$ac_ext <<_ACEOF
17508 /* end confdefs.h.  */
17509
17510 /* Override any gcc2 internal prototype to avoid an error.  */
17511 #ifdef __cplusplus
17512 extern "C"
17513 #endif
17514 /* We use char because int might match the return type of a gcc2
17515    builtin and then its argument prototype would still apply.  */
17516 char erfc ();
17517 int
17518 main ()
17519 {
17520 erfc ();
17521   ;
17522   return 0;
17523 }
17524 _ACEOF
17525 rm -f conftest.$ac_objext conftest$ac_exeext
17526 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17527   (eval $ac_link) 2>conftest.er1
17528   ac_status=$?
17529   grep -v '^ *+' conftest.er1 >conftest.err
17530   rm -f conftest.er1
17531   cat conftest.err >&5
17532   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17533   (exit $ac_status); } &&
17534          { ac_try='test -z "$ac_c_werror_flag"
17535                          || test ! -s conftest.err'
17536   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17537   (eval $ac_try) 2>&5
17538   ac_status=$?
17539   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17540   (exit $ac_status); }; } &&
17541          { ac_try='test -s conftest$ac_exeext'
17542   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17543   (eval $ac_try) 2>&5
17544   ac_status=$?
17545   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17546   (exit $ac_status); }; }; then
17547   ac_cv_lib_m_erfc=yes
17548 else
17549   echo "$as_me: failed program was:" >&5
17550 sed 's/^/| /' conftest.$ac_ext >&5
17551
17552 ac_cv_lib_m_erfc=no
17553 fi
17554 rm -f conftest.err conftest.$ac_objext \
17555       conftest$ac_exeext conftest.$ac_ext
17556 LIBS=$ac_check_lib_save_LIBS
17557 fi
17558 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfc" >&5
17559 echo "${ECHO_T}$ac_cv_lib_m_erfc" >&6
17560 if test $ac_cv_lib_m_erfc = yes; then
17561
17562 cat >>confdefs.h <<\_ACEOF
17563 #define HAVE_ERFC 1
17564 _ACEOF
17565
17566 fi
17567
17568 echo "$as_me:$LINENO: checking for erfcl in -lm" >&5
17569 echo $ECHO_N "checking for erfcl in -lm... $ECHO_C" >&6
17570 if test "${ac_cv_lib_m_erfcl+set}" = set; then
17571   echo $ECHO_N "(cached) $ECHO_C" >&6
17572 else
17573   ac_check_lib_save_LIBS=$LIBS
17574 LIBS="-lm  $LIBS"
17575 if test x$gcc_no_link = xyes; then
17576   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17577 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17578    { (exit 1); exit 1; }; }
17579 fi
17580 cat >conftest.$ac_ext <<_ACEOF
17581 /* confdefs.h.  */
17582 _ACEOF
17583 cat confdefs.h >>conftest.$ac_ext
17584 cat >>conftest.$ac_ext <<_ACEOF
17585 /* end confdefs.h.  */
17586
17587 /* Override any gcc2 internal prototype to avoid an error.  */
17588 #ifdef __cplusplus
17589 extern "C"
17590 #endif
17591 /* We use char because int might match the return type of a gcc2
17592    builtin and then its argument prototype would still apply.  */
17593 char erfcl ();
17594 int
17595 main ()
17596 {
17597 erfcl ();
17598   ;
17599   return 0;
17600 }
17601 _ACEOF
17602 rm -f conftest.$ac_objext conftest$ac_exeext
17603 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17604   (eval $ac_link) 2>conftest.er1
17605   ac_status=$?
17606   grep -v '^ *+' conftest.er1 >conftest.err
17607   rm -f conftest.er1
17608   cat conftest.err >&5
17609   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17610   (exit $ac_status); } &&
17611          { ac_try='test -z "$ac_c_werror_flag"
17612                          || test ! -s conftest.err'
17613   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17614   (eval $ac_try) 2>&5
17615   ac_status=$?
17616   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17617   (exit $ac_status); }; } &&
17618          { ac_try='test -s conftest$ac_exeext'
17619   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17620   (eval $ac_try) 2>&5
17621   ac_status=$?
17622   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17623   (exit $ac_status); }; }; then
17624   ac_cv_lib_m_erfcl=yes
17625 else
17626   echo "$as_me: failed program was:" >&5
17627 sed 's/^/| /' conftest.$ac_ext >&5
17628
17629 ac_cv_lib_m_erfcl=no
17630 fi
17631 rm -f conftest.err conftest.$ac_objext \
17632       conftest$ac_exeext conftest.$ac_ext
17633 LIBS=$ac_check_lib_save_LIBS
17634 fi
17635 echo "$as_me:$LINENO: result: $ac_cv_lib_m_erfcl" >&5
17636 echo "${ECHO_T}$ac_cv_lib_m_erfcl" >&6
17637 if test $ac_cv_lib_m_erfcl = yes; then
17638
17639 cat >>confdefs.h <<\_ACEOF
17640 #define HAVE_ERFCL 1
17641 _ACEOF
17642
17643 fi
17644
17645 echo "$as_me:$LINENO: checking for j0f in -lm" >&5
17646 echo $ECHO_N "checking for j0f in -lm... $ECHO_C" >&6
17647 if test "${ac_cv_lib_m_j0f+set}" = set; then
17648   echo $ECHO_N "(cached) $ECHO_C" >&6
17649 else
17650   ac_check_lib_save_LIBS=$LIBS
17651 LIBS="-lm  $LIBS"
17652 if test x$gcc_no_link = xyes; then
17653   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17654 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17655    { (exit 1); exit 1; }; }
17656 fi
17657 cat >conftest.$ac_ext <<_ACEOF
17658 /* confdefs.h.  */
17659 _ACEOF
17660 cat confdefs.h >>conftest.$ac_ext
17661 cat >>conftest.$ac_ext <<_ACEOF
17662 /* end confdefs.h.  */
17663
17664 /* Override any gcc2 internal prototype to avoid an error.  */
17665 #ifdef __cplusplus
17666 extern "C"
17667 #endif
17668 /* We use char because int might match the return type of a gcc2
17669    builtin and then its argument prototype would still apply.  */
17670 char j0f ();
17671 int
17672 main ()
17673 {
17674 j0f ();
17675   ;
17676   return 0;
17677 }
17678 _ACEOF
17679 rm -f conftest.$ac_objext conftest$ac_exeext
17680 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17681   (eval $ac_link) 2>conftest.er1
17682   ac_status=$?
17683   grep -v '^ *+' conftest.er1 >conftest.err
17684   rm -f conftest.er1
17685   cat conftest.err >&5
17686   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17687   (exit $ac_status); } &&
17688          { ac_try='test -z "$ac_c_werror_flag"
17689                          || test ! -s conftest.err'
17690   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17691   (eval $ac_try) 2>&5
17692   ac_status=$?
17693   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17694   (exit $ac_status); }; } &&
17695          { ac_try='test -s conftest$ac_exeext'
17696   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17697   (eval $ac_try) 2>&5
17698   ac_status=$?
17699   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17700   (exit $ac_status); }; }; then
17701   ac_cv_lib_m_j0f=yes
17702 else
17703   echo "$as_me: failed program was:" >&5
17704 sed 's/^/| /' conftest.$ac_ext >&5
17705
17706 ac_cv_lib_m_j0f=no
17707 fi
17708 rm -f conftest.err conftest.$ac_objext \
17709       conftest$ac_exeext conftest.$ac_ext
17710 LIBS=$ac_check_lib_save_LIBS
17711 fi
17712 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0f" >&5
17713 echo "${ECHO_T}$ac_cv_lib_m_j0f" >&6
17714 if test $ac_cv_lib_m_j0f = yes; then
17715
17716 cat >>confdefs.h <<\_ACEOF
17717 #define HAVE_J0F 1
17718 _ACEOF
17719
17720 fi
17721
17722 echo "$as_me:$LINENO: checking for j0 in -lm" >&5
17723 echo $ECHO_N "checking for j0 in -lm... $ECHO_C" >&6
17724 if test "${ac_cv_lib_m_j0+set}" = set; then
17725   echo $ECHO_N "(cached) $ECHO_C" >&6
17726 else
17727   ac_check_lib_save_LIBS=$LIBS
17728 LIBS="-lm  $LIBS"
17729 if test x$gcc_no_link = xyes; then
17730   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17731 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17732    { (exit 1); exit 1; }; }
17733 fi
17734 cat >conftest.$ac_ext <<_ACEOF
17735 /* confdefs.h.  */
17736 _ACEOF
17737 cat confdefs.h >>conftest.$ac_ext
17738 cat >>conftest.$ac_ext <<_ACEOF
17739 /* end confdefs.h.  */
17740
17741 /* Override any gcc2 internal prototype to avoid an error.  */
17742 #ifdef __cplusplus
17743 extern "C"
17744 #endif
17745 /* We use char because int might match the return type of a gcc2
17746    builtin and then its argument prototype would still apply.  */
17747 char j0 ();
17748 int
17749 main ()
17750 {
17751 j0 ();
17752   ;
17753   return 0;
17754 }
17755 _ACEOF
17756 rm -f conftest.$ac_objext conftest$ac_exeext
17757 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17758   (eval $ac_link) 2>conftest.er1
17759   ac_status=$?
17760   grep -v '^ *+' conftest.er1 >conftest.err
17761   rm -f conftest.er1
17762   cat conftest.err >&5
17763   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17764   (exit $ac_status); } &&
17765          { ac_try='test -z "$ac_c_werror_flag"
17766                          || test ! -s conftest.err'
17767   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17768   (eval $ac_try) 2>&5
17769   ac_status=$?
17770   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17771   (exit $ac_status); }; } &&
17772          { ac_try='test -s conftest$ac_exeext'
17773   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17774   (eval $ac_try) 2>&5
17775   ac_status=$?
17776   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17777   (exit $ac_status); }; }; then
17778   ac_cv_lib_m_j0=yes
17779 else
17780   echo "$as_me: failed program was:" >&5
17781 sed 's/^/| /' conftest.$ac_ext >&5
17782
17783 ac_cv_lib_m_j0=no
17784 fi
17785 rm -f conftest.err conftest.$ac_objext \
17786       conftest$ac_exeext conftest.$ac_ext
17787 LIBS=$ac_check_lib_save_LIBS
17788 fi
17789 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0" >&5
17790 echo "${ECHO_T}$ac_cv_lib_m_j0" >&6
17791 if test $ac_cv_lib_m_j0 = yes; then
17792
17793 cat >>confdefs.h <<\_ACEOF
17794 #define HAVE_J0 1
17795 _ACEOF
17796
17797 fi
17798
17799 echo "$as_me:$LINENO: checking for j0l in -lm" >&5
17800 echo $ECHO_N "checking for j0l in -lm... $ECHO_C" >&6
17801 if test "${ac_cv_lib_m_j0l+set}" = set; then
17802   echo $ECHO_N "(cached) $ECHO_C" >&6
17803 else
17804   ac_check_lib_save_LIBS=$LIBS
17805 LIBS="-lm  $LIBS"
17806 if test x$gcc_no_link = xyes; then
17807   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17808 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17809    { (exit 1); exit 1; }; }
17810 fi
17811 cat >conftest.$ac_ext <<_ACEOF
17812 /* confdefs.h.  */
17813 _ACEOF
17814 cat confdefs.h >>conftest.$ac_ext
17815 cat >>conftest.$ac_ext <<_ACEOF
17816 /* end confdefs.h.  */
17817
17818 /* Override any gcc2 internal prototype to avoid an error.  */
17819 #ifdef __cplusplus
17820 extern "C"
17821 #endif
17822 /* We use char because int might match the return type of a gcc2
17823    builtin and then its argument prototype would still apply.  */
17824 char j0l ();
17825 int
17826 main ()
17827 {
17828 j0l ();
17829   ;
17830   return 0;
17831 }
17832 _ACEOF
17833 rm -f conftest.$ac_objext conftest$ac_exeext
17834 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17835   (eval $ac_link) 2>conftest.er1
17836   ac_status=$?
17837   grep -v '^ *+' conftest.er1 >conftest.err
17838   rm -f conftest.er1
17839   cat conftest.err >&5
17840   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17841   (exit $ac_status); } &&
17842          { ac_try='test -z "$ac_c_werror_flag"
17843                          || test ! -s conftest.err'
17844   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17845   (eval $ac_try) 2>&5
17846   ac_status=$?
17847   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17848   (exit $ac_status); }; } &&
17849          { ac_try='test -s conftest$ac_exeext'
17850   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17851   (eval $ac_try) 2>&5
17852   ac_status=$?
17853   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17854   (exit $ac_status); }; }; then
17855   ac_cv_lib_m_j0l=yes
17856 else
17857   echo "$as_me: failed program was:" >&5
17858 sed 's/^/| /' conftest.$ac_ext >&5
17859
17860 ac_cv_lib_m_j0l=no
17861 fi
17862 rm -f conftest.err conftest.$ac_objext \
17863       conftest$ac_exeext conftest.$ac_ext
17864 LIBS=$ac_check_lib_save_LIBS
17865 fi
17866 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j0l" >&5
17867 echo "${ECHO_T}$ac_cv_lib_m_j0l" >&6
17868 if test $ac_cv_lib_m_j0l = yes; then
17869
17870 cat >>confdefs.h <<\_ACEOF
17871 #define HAVE_J0L 1
17872 _ACEOF
17873
17874 fi
17875
17876 echo "$as_me:$LINENO: checking for j1f in -lm" >&5
17877 echo $ECHO_N "checking for j1f in -lm... $ECHO_C" >&6
17878 if test "${ac_cv_lib_m_j1f+set}" = set; then
17879   echo $ECHO_N "(cached) $ECHO_C" >&6
17880 else
17881   ac_check_lib_save_LIBS=$LIBS
17882 LIBS="-lm  $LIBS"
17883 if test x$gcc_no_link = xyes; then
17884   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17885 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17886    { (exit 1); exit 1; }; }
17887 fi
17888 cat >conftest.$ac_ext <<_ACEOF
17889 /* confdefs.h.  */
17890 _ACEOF
17891 cat confdefs.h >>conftest.$ac_ext
17892 cat >>conftest.$ac_ext <<_ACEOF
17893 /* end confdefs.h.  */
17894
17895 /* Override any gcc2 internal prototype to avoid an error.  */
17896 #ifdef __cplusplus
17897 extern "C"
17898 #endif
17899 /* We use char because int might match the return type of a gcc2
17900    builtin and then its argument prototype would still apply.  */
17901 char j1f ();
17902 int
17903 main ()
17904 {
17905 j1f ();
17906   ;
17907   return 0;
17908 }
17909 _ACEOF
17910 rm -f conftest.$ac_objext conftest$ac_exeext
17911 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17912   (eval $ac_link) 2>conftest.er1
17913   ac_status=$?
17914   grep -v '^ *+' conftest.er1 >conftest.err
17915   rm -f conftest.er1
17916   cat conftest.err >&5
17917   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17918   (exit $ac_status); } &&
17919          { ac_try='test -z "$ac_c_werror_flag"
17920                          || test ! -s conftest.err'
17921   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17922   (eval $ac_try) 2>&5
17923   ac_status=$?
17924   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17925   (exit $ac_status); }; } &&
17926          { ac_try='test -s conftest$ac_exeext'
17927   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17928   (eval $ac_try) 2>&5
17929   ac_status=$?
17930   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17931   (exit $ac_status); }; }; then
17932   ac_cv_lib_m_j1f=yes
17933 else
17934   echo "$as_me: failed program was:" >&5
17935 sed 's/^/| /' conftest.$ac_ext >&5
17936
17937 ac_cv_lib_m_j1f=no
17938 fi
17939 rm -f conftest.err conftest.$ac_objext \
17940       conftest$ac_exeext conftest.$ac_ext
17941 LIBS=$ac_check_lib_save_LIBS
17942 fi
17943 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1f" >&5
17944 echo "${ECHO_T}$ac_cv_lib_m_j1f" >&6
17945 if test $ac_cv_lib_m_j1f = yes; then
17946
17947 cat >>confdefs.h <<\_ACEOF
17948 #define HAVE_J1F 1
17949 _ACEOF
17950
17951 fi
17952
17953 echo "$as_me:$LINENO: checking for j1 in -lm" >&5
17954 echo $ECHO_N "checking for j1 in -lm... $ECHO_C" >&6
17955 if test "${ac_cv_lib_m_j1+set}" = set; then
17956   echo $ECHO_N "(cached) $ECHO_C" >&6
17957 else
17958   ac_check_lib_save_LIBS=$LIBS
17959 LIBS="-lm  $LIBS"
17960 if test x$gcc_no_link = xyes; then
17961   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
17962 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
17963    { (exit 1); exit 1; }; }
17964 fi
17965 cat >conftest.$ac_ext <<_ACEOF
17966 /* confdefs.h.  */
17967 _ACEOF
17968 cat confdefs.h >>conftest.$ac_ext
17969 cat >>conftest.$ac_ext <<_ACEOF
17970 /* end confdefs.h.  */
17971
17972 /* Override any gcc2 internal prototype to avoid an error.  */
17973 #ifdef __cplusplus
17974 extern "C"
17975 #endif
17976 /* We use char because int might match the return type of a gcc2
17977    builtin and then its argument prototype would still apply.  */
17978 char j1 ();
17979 int
17980 main ()
17981 {
17982 j1 ();
17983   ;
17984   return 0;
17985 }
17986 _ACEOF
17987 rm -f conftest.$ac_objext conftest$ac_exeext
17988 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
17989   (eval $ac_link) 2>conftest.er1
17990   ac_status=$?
17991   grep -v '^ *+' conftest.er1 >conftest.err
17992   rm -f conftest.er1
17993   cat conftest.err >&5
17994   echo "$as_me:$LINENO: \$? = $ac_status" >&5
17995   (exit $ac_status); } &&
17996          { ac_try='test -z "$ac_c_werror_flag"
17997                          || test ! -s conftest.err'
17998   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
17999   (eval $ac_try) 2>&5
18000   ac_status=$?
18001   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18002   (exit $ac_status); }; } &&
18003          { ac_try='test -s conftest$ac_exeext'
18004   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18005   (eval $ac_try) 2>&5
18006   ac_status=$?
18007   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18008   (exit $ac_status); }; }; then
18009   ac_cv_lib_m_j1=yes
18010 else
18011   echo "$as_me: failed program was:" >&5
18012 sed 's/^/| /' conftest.$ac_ext >&5
18013
18014 ac_cv_lib_m_j1=no
18015 fi
18016 rm -f conftest.err conftest.$ac_objext \
18017       conftest$ac_exeext conftest.$ac_ext
18018 LIBS=$ac_check_lib_save_LIBS
18019 fi
18020 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1" >&5
18021 echo "${ECHO_T}$ac_cv_lib_m_j1" >&6
18022 if test $ac_cv_lib_m_j1 = yes; then
18023
18024 cat >>confdefs.h <<\_ACEOF
18025 #define HAVE_J1 1
18026 _ACEOF
18027
18028 fi
18029
18030 echo "$as_me:$LINENO: checking for j1l in -lm" >&5
18031 echo $ECHO_N "checking for j1l in -lm... $ECHO_C" >&6
18032 if test "${ac_cv_lib_m_j1l+set}" = set; then
18033   echo $ECHO_N "(cached) $ECHO_C" >&6
18034 else
18035   ac_check_lib_save_LIBS=$LIBS
18036 LIBS="-lm  $LIBS"
18037 if test x$gcc_no_link = xyes; then
18038   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18039 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18040    { (exit 1); exit 1; }; }
18041 fi
18042 cat >conftest.$ac_ext <<_ACEOF
18043 /* confdefs.h.  */
18044 _ACEOF
18045 cat confdefs.h >>conftest.$ac_ext
18046 cat >>conftest.$ac_ext <<_ACEOF
18047 /* end confdefs.h.  */
18048
18049 /* Override any gcc2 internal prototype to avoid an error.  */
18050 #ifdef __cplusplus
18051 extern "C"
18052 #endif
18053 /* We use char because int might match the return type of a gcc2
18054    builtin and then its argument prototype would still apply.  */
18055 char j1l ();
18056 int
18057 main ()
18058 {
18059 j1l ();
18060   ;
18061   return 0;
18062 }
18063 _ACEOF
18064 rm -f conftest.$ac_objext conftest$ac_exeext
18065 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18066   (eval $ac_link) 2>conftest.er1
18067   ac_status=$?
18068   grep -v '^ *+' conftest.er1 >conftest.err
18069   rm -f conftest.er1
18070   cat conftest.err >&5
18071   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18072   (exit $ac_status); } &&
18073          { ac_try='test -z "$ac_c_werror_flag"
18074                          || test ! -s conftest.err'
18075   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18076   (eval $ac_try) 2>&5
18077   ac_status=$?
18078   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18079   (exit $ac_status); }; } &&
18080          { ac_try='test -s conftest$ac_exeext'
18081   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18082   (eval $ac_try) 2>&5
18083   ac_status=$?
18084   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18085   (exit $ac_status); }; }; then
18086   ac_cv_lib_m_j1l=yes
18087 else
18088   echo "$as_me: failed program was:" >&5
18089 sed 's/^/| /' conftest.$ac_ext >&5
18090
18091 ac_cv_lib_m_j1l=no
18092 fi
18093 rm -f conftest.err conftest.$ac_objext \
18094       conftest$ac_exeext conftest.$ac_ext
18095 LIBS=$ac_check_lib_save_LIBS
18096 fi
18097 echo "$as_me:$LINENO: result: $ac_cv_lib_m_j1l" >&5
18098 echo "${ECHO_T}$ac_cv_lib_m_j1l" >&6
18099 if test $ac_cv_lib_m_j1l = yes; then
18100
18101 cat >>confdefs.h <<\_ACEOF
18102 #define HAVE_J1L 1
18103 _ACEOF
18104
18105 fi
18106
18107 echo "$as_me:$LINENO: checking for jnf in -lm" >&5
18108 echo $ECHO_N "checking for jnf in -lm... $ECHO_C" >&6
18109 if test "${ac_cv_lib_m_jnf+set}" = set; then
18110   echo $ECHO_N "(cached) $ECHO_C" >&6
18111 else
18112   ac_check_lib_save_LIBS=$LIBS
18113 LIBS="-lm  $LIBS"
18114 if test x$gcc_no_link = xyes; then
18115   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18116 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18117    { (exit 1); exit 1; }; }
18118 fi
18119 cat >conftest.$ac_ext <<_ACEOF
18120 /* confdefs.h.  */
18121 _ACEOF
18122 cat confdefs.h >>conftest.$ac_ext
18123 cat >>conftest.$ac_ext <<_ACEOF
18124 /* end confdefs.h.  */
18125
18126 /* Override any gcc2 internal prototype to avoid an error.  */
18127 #ifdef __cplusplus
18128 extern "C"
18129 #endif
18130 /* We use char because int might match the return type of a gcc2
18131    builtin and then its argument prototype would still apply.  */
18132 char jnf ();
18133 int
18134 main ()
18135 {
18136 jnf ();
18137   ;
18138   return 0;
18139 }
18140 _ACEOF
18141 rm -f conftest.$ac_objext conftest$ac_exeext
18142 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18143   (eval $ac_link) 2>conftest.er1
18144   ac_status=$?
18145   grep -v '^ *+' conftest.er1 >conftest.err
18146   rm -f conftest.er1
18147   cat conftest.err >&5
18148   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18149   (exit $ac_status); } &&
18150          { ac_try='test -z "$ac_c_werror_flag"
18151                          || test ! -s conftest.err'
18152   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18153   (eval $ac_try) 2>&5
18154   ac_status=$?
18155   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18156   (exit $ac_status); }; } &&
18157          { ac_try='test -s conftest$ac_exeext'
18158   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18159   (eval $ac_try) 2>&5
18160   ac_status=$?
18161   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18162   (exit $ac_status); }; }; then
18163   ac_cv_lib_m_jnf=yes
18164 else
18165   echo "$as_me: failed program was:" >&5
18166 sed 's/^/| /' conftest.$ac_ext >&5
18167
18168 ac_cv_lib_m_jnf=no
18169 fi
18170 rm -f conftest.err conftest.$ac_objext \
18171       conftest$ac_exeext conftest.$ac_ext
18172 LIBS=$ac_check_lib_save_LIBS
18173 fi
18174 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jnf" >&5
18175 echo "${ECHO_T}$ac_cv_lib_m_jnf" >&6
18176 if test $ac_cv_lib_m_jnf = yes; then
18177
18178 cat >>confdefs.h <<\_ACEOF
18179 #define HAVE_JNF 1
18180 _ACEOF
18181
18182 fi
18183
18184 echo "$as_me:$LINENO: checking for jn in -lm" >&5
18185 echo $ECHO_N "checking for jn in -lm... $ECHO_C" >&6
18186 if test "${ac_cv_lib_m_jn+set}" = set; then
18187   echo $ECHO_N "(cached) $ECHO_C" >&6
18188 else
18189   ac_check_lib_save_LIBS=$LIBS
18190 LIBS="-lm  $LIBS"
18191 if test x$gcc_no_link = xyes; then
18192   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18193 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18194    { (exit 1); exit 1; }; }
18195 fi
18196 cat >conftest.$ac_ext <<_ACEOF
18197 /* confdefs.h.  */
18198 _ACEOF
18199 cat confdefs.h >>conftest.$ac_ext
18200 cat >>conftest.$ac_ext <<_ACEOF
18201 /* end confdefs.h.  */
18202
18203 /* Override any gcc2 internal prototype to avoid an error.  */
18204 #ifdef __cplusplus
18205 extern "C"
18206 #endif
18207 /* We use char because int might match the return type of a gcc2
18208    builtin and then its argument prototype would still apply.  */
18209 char jn ();
18210 int
18211 main ()
18212 {
18213 jn ();
18214   ;
18215   return 0;
18216 }
18217 _ACEOF
18218 rm -f conftest.$ac_objext conftest$ac_exeext
18219 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18220   (eval $ac_link) 2>conftest.er1
18221   ac_status=$?
18222   grep -v '^ *+' conftest.er1 >conftest.err
18223   rm -f conftest.er1
18224   cat conftest.err >&5
18225   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18226   (exit $ac_status); } &&
18227          { ac_try='test -z "$ac_c_werror_flag"
18228                          || test ! -s conftest.err'
18229   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18230   (eval $ac_try) 2>&5
18231   ac_status=$?
18232   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18233   (exit $ac_status); }; } &&
18234          { ac_try='test -s conftest$ac_exeext'
18235   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18236   (eval $ac_try) 2>&5
18237   ac_status=$?
18238   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18239   (exit $ac_status); }; }; then
18240   ac_cv_lib_m_jn=yes
18241 else
18242   echo "$as_me: failed program was:" >&5
18243 sed 's/^/| /' conftest.$ac_ext >&5
18244
18245 ac_cv_lib_m_jn=no
18246 fi
18247 rm -f conftest.err conftest.$ac_objext \
18248       conftest$ac_exeext conftest.$ac_ext
18249 LIBS=$ac_check_lib_save_LIBS
18250 fi
18251 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jn" >&5
18252 echo "${ECHO_T}$ac_cv_lib_m_jn" >&6
18253 if test $ac_cv_lib_m_jn = yes; then
18254
18255 cat >>confdefs.h <<\_ACEOF
18256 #define HAVE_JN 1
18257 _ACEOF
18258
18259 fi
18260
18261 echo "$as_me:$LINENO: checking for jnl in -lm" >&5
18262 echo $ECHO_N "checking for jnl in -lm... $ECHO_C" >&6
18263 if test "${ac_cv_lib_m_jnl+set}" = set; then
18264   echo $ECHO_N "(cached) $ECHO_C" >&6
18265 else
18266   ac_check_lib_save_LIBS=$LIBS
18267 LIBS="-lm  $LIBS"
18268 if test x$gcc_no_link = xyes; then
18269   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18270 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18271    { (exit 1); exit 1; }; }
18272 fi
18273 cat >conftest.$ac_ext <<_ACEOF
18274 /* confdefs.h.  */
18275 _ACEOF
18276 cat confdefs.h >>conftest.$ac_ext
18277 cat >>conftest.$ac_ext <<_ACEOF
18278 /* end confdefs.h.  */
18279
18280 /* Override any gcc2 internal prototype to avoid an error.  */
18281 #ifdef __cplusplus
18282 extern "C"
18283 #endif
18284 /* We use char because int might match the return type of a gcc2
18285    builtin and then its argument prototype would still apply.  */
18286 char jnl ();
18287 int
18288 main ()
18289 {
18290 jnl ();
18291   ;
18292   return 0;
18293 }
18294 _ACEOF
18295 rm -f conftest.$ac_objext conftest$ac_exeext
18296 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18297   (eval $ac_link) 2>conftest.er1
18298   ac_status=$?
18299   grep -v '^ *+' conftest.er1 >conftest.err
18300   rm -f conftest.er1
18301   cat conftest.err >&5
18302   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18303   (exit $ac_status); } &&
18304          { ac_try='test -z "$ac_c_werror_flag"
18305                          || test ! -s conftest.err'
18306   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18307   (eval $ac_try) 2>&5
18308   ac_status=$?
18309   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18310   (exit $ac_status); }; } &&
18311          { ac_try='test -s conftest$ac_exeext'
18312   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18313   (eval $ac_try) 2>&5
18314   ac_status=$?
18315   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18316   (exit $ac_status); }; }; then
18317   ac_cv_lib_m_jnl=yes
18318 else
18319   echo "$as_me: failed program was:" >&5
18320 sed 's/^/| /' conftest.$ac_ext >&5
18321
18322 ac_cv_lib_m_jnl=no
18323 fi
18324 rm -f conftest.err conftest.$ac_objext \
18325       conftest$ac_exeext conftest.$ac_ext
18326 LIBS=$ac_check_lib_save_LIBS
18327 fi
18328 echo "$as_me:$LINENO: result: $ac_cv_lib_m_jnl" >&5
18329 echo "${ECHO_T}$ac_cv_lib_m_jnl" >&6
18330 if test $ac_cv_lib_m_jnl = yes; then
18331
18332 cat >>confdefs.h <<\_ACEOF
18333 #define HAVE_JNL 1
18334 _ACEOF
18335
18336 fi
18337
18338 echo "$as_me:$LINENO: checking for y0f in -lm" >&5
18339 echo $ECHO_N "checking for y0f in -lm... $ECHO_C" >&6
18340 if test "${ac_cv_lib_m_y0f+set}" = set; then
18341   echo $ECHO_N "(cached) $ECHO_C" >&6
18342 else
18343   ac_check_lib_save_LIBS=$LIBS
18344 LIBS="-lm  $LIBS"
18345 if test x$gcc_no_link = xyes; then
18346   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18347 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18348    { (exit 1); exit 1; }; }
18349 fi
18350 cat >conftest.$ac_ext <<_ACEOF
18351 /* confdefs.h.  */
18352 _ACEOF
18353 cat confdefs.h >>conftest.$ac_ext
18354 cat >>conftest.$ac_ext <<_ACEOF
18355 /* end confdefs.h.  */
18356
18357 /* Override any gcc2 internal prototype to avoid an error.  */
18358 #ifdef __cplusplus
18359 extern "C"
18360 #endif
18361 /* We use char because int might match the return type of a gcc2
18362    builtin and then its argument prototype would still apply.  */
18363 char y0f ();
18364 int
18365 main ()
18366 {
18367 y0f ();
18368   ;
18369   return 0;
18370 }
18371 _ACEOF
18372 rm -f conftest.$ac_objext conftest$ac_exeext
18373 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18374   (eval $ac_link) 2>conftest.er1
18375   ac_status=$?
18376   grep -v '^ *+' conftest.er1 >conftest.err
18377   rm -f conftest.er1
18378   cat conftest.err >&5
18379   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18380   (exit $ac_status); } &&
18381          { ac_try='test -z "$ac_c_werror_flag"
18382                          || test ! -s conftest.err'
18383   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18384   (eval $ac_try) 2>&5
18385   ac_status=$?
18386   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18387   (exit $ac_status); }; } &&
18388          { ac_try='test -s conftest$ac_exeext'
18389   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18390   (eval $ac_try) 2>&5
18391   ac_status=$?
18392   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18393   (exit $ac_status); }; }; then
18394   ac_cv_lib_m_y0f=yes
18395 else
18396   echo "$as_me: failed program was:" >&5
18397 sed 's/^/| /' conftest.$ac_ext >&5
18398
18399 ac_cv_lib_m_y0f=no
18400 fi
18401 rm -f conftest.err conftest.$ac_objext \
18402       conftest$ac_exeext conftest.$ac_ext
18403 LIBS=$ac_check_lib_save_LIBS
18404 fi
18405 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0f" >&5
18406 echo "${ECHO_T}$ac_cv_lib_m_y0f" >&6
18407 if test $ac_cv_lib_m_y0f = yes; then
18408
18409 cat >>confdefs.h <<\_ACEOF
18410 #define HAVE_Y0F 1
18411 _ACEOF
18412
18413 fi
18414
18415 echo "$as_me:$LINENO: checking for y0 in -lm" >&5
18416 echo $ECHO_N "checking for y0 in -lm... $ECHO_C" >&6
18417 if test "${ac_cv_lib_m_y0+set}" = set; then
18418   echo $ECHO_N "(cached) $ECHO_C" >&6
18419 else
18420   ac_check_lib_save_LIBS=$LIBS
18421 LIBS="-lm  $LIBS"
18422 if test x$gcc_no_link = xyes; then
18423   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18424 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18425    { (exit 1); exit 1; }; }
18426 fi
18427 cat >conftest.$ac_ext <<_ACEOF
18428 /* confdefs.h.  */
18429 _ACEOF
18430 cat confdefs.h >>conftest.$ac_ext
18431 cat >>conftest.$ac_ext <<_ACEOF
18432 /* end confdefs.h.  */
18433
18434 /* Override any gcc2 internal prototype to avoid an error.  */
18435 #ifdef __cplusplus
18436 extern "C"
18437 #endif
18438 /* We use char because int might match the return type of a gcc2
18439    builtin and then its argument prototype would still apply.  */
18440 char y0 ();
18441 int
18442 main ()
18443 {
18444 y0 ();
18445   ;
18446   return 0;
18447 }
18448 _ACEOF
18449 rm -f conftest.$ac_objext conftest$ac_exeext
18450 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18451   (eval $ac_link) 2>conftest.er1
18452   ac_status=$?
18453   grep -v '^ *+' conftest.er1 >conftest.err
18454   rm -f conftest.er1
18455   cat conftest.err >&5
18456   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18457   (exit $ac_status); } &&
18458          { ac_try='test -z "$ac_c_werror_flag"
18459                          || test ! -s conftest.err'
18460   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18461   (eval $ac_try) 2>&5
18462   ac_status=$?
18463   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18464   (exit $ac_status); }; } &&
18465          { ac_try='test -s conftest$ac_exeext'
18466   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18467   (eval $ac_try) 2>&5
18468   ac_status=$?
18469   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18470   (exit $ac_status); }; }; then
18471   ac_cv_lib_m_y0=yes
18472 else
18473   echo "$as_me: failed program was:" >&5
18474 sed 's/^/| /' conftest.$ac_ext >&5
18475
18476 ac_cv_lib_m_y0=no
18477 fi
18478 rm -f conftest.err conftest.$ac_objext \
18479       conftest$ac_exeext conftest.$ac_ext
18480 LIBS=$ac_check_lib_save_LIBS
18481 fi
18482 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0" >&5
18483 echo "${ECHO_T}$ac_cv_lib_m_y0" >&6
18484 if test $ac_cv_lib_m_y0 = yes; then
18485
18486 cat >>confdefs.h <<\_ACEOF
18487 #define HAVE_Y0 1
18488 _ACEOF
18489
18490 fi
18491
18492 echo "$as_me:$LINENO: checking for y0l in -lm" >&5
18493 echo $ECHO_N "checking for y0l in -lm... $ECHO_C" >&6
18494 if test "${ac_cv_lib_m_y0l+set}" = set; then
18495   echo $ECHO_N "(cached) $ECHO_C" >&6
18496 else
18497   ac_check_lib_save_LIBS=$LIBS
18498 LIBS="-lm  $LIBS"
18499 if test x$gcc_no_link = xyes; then
18500   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18501 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18502    { (exit 1); exit 1; }; }
18503 fi
18504 cat >conftest.$ac_ext <<_ACEOF
18505 /* confdefs.h.  */
18506 _ACEOF
18507 cat confdefs.h >>conftest.$ac_ext
18508 cat >>conftest.$ac_ext <<_ACEOF
18509 /* end confdefs.h.  */
18510
18511 /* Override any gcc2 internal prototype to avoid an error.  */
18512 #ifdef __cplusplus
18513 extern "C"
18514 #endif
18515 /* We use char because int might match the return type of a gcc2
18516    builtin and then its argument prototype would still apply.  */
18517 char y0l ();
18518 int
18519 main ()
18520 {
18521 y0l ();
18522   ;
18523   return 0;
18524 }
18525 _ACEOF
18526 rm -f conftest.$ac_objext conftest$ac_exeext
18527 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18528   (eval $ac_link) 2>conftest.er1
18529   ac_status=$?
18530   grep -v '^ *+' conftest.er1 >conftest.err
18531   rm -f conftest.er1
18532   cat conftest.err >&5
18533   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18534   (exit $ac_status); } &&
18535          { ac_try='test -z "$ac_c_werror_flag"
18536                          || test ! -s conftest.err'
18537   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18538   (eval $ac_try) 2>&5
18539   ac_status=$?
18540   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18541   (exit $ac_status); }; } &&
18542          { ac_try='test -s conftest$ac_exeext'
18543   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18544   (eval $ac_try) 2>&5
18545   ac_status=$?
18546   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18547   (exit $ac_status); }; }; then
18548   ac_cv_lib_m_y0l=yes
18549 else
18550   echo "$as_me: failed program was:" >&5
18551 sed 's/^/| /' conftest.$ac_ext >&5
18552
18553 ac_cv_lib_m_y0l=no
18554 fi
18555 rm -f conftest.err conftest.$ac_objext \
18556       conftest$ac_exeext conftest.$ac_ext
18557 LIBS=$ac_check_lib_save_LIBS
18558 fi
18559 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y0l" >&5
18560 echo "${ECHO_T}$ac_cv_lib_m_y0l" >&6
18561 if test $ac_cv_lib_m_y0l = yes; then
18562
18563 cat >>confdefs.h <<\_ACEOF
18564 #define HAVE_Y0L 1
18565 _ACEOF
18566
18567 fi
18568
18569 echo "$as_me:$LINENO: checking for y1f in -lm" >&5
18570 echo $ECHO_N "checking for y1f in -lm... $ECHO_C" >&6
18571 if test "${ac_cv_lib_m_y1f+set}" = set; then
18572   echo $ECHO_N "(cached) $ECHO_C" >&6
18573 else
18574   ac_check_lib_save_LIBS=$LIBS
18575 LIBS="-lm  $LIBS"
18576 if test x$gcc_no_link = xyes; then
18577   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18578 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18579    { (exit 1); exit 1; }; }
18580 fi
18581 cat >conftest.$ac_ext <<_ACEOF
18582 /* confdefs.h.  */
18583 _ACEOF
18584 cat confdefs.h >>conftest.$ac_ext
18585 cat >>conftest.$ac_ext <<_ACEOF
18586 /* end confdefs.h.  */
18587
18588 /* Override any gcc2 internal prototype to avoid an error.  */
18589 #ifdef __cplusplus
18590 extern "C"
18591 #endif
18592 /* We use char because int might match the return type of a gcc2
18593    builtin and then its argument prototype would still apply.  */
18594 char y1f ();
18595 int
18596 main ()
18597 {
18598 y1f ();
18599   ;
18600   return 0;
18601 }
18602 _ACEOF
18603 rm -f conftest.$ac_objext conftest$ac_exeext
18604 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18605   (eval $ac_link) 2>conftest.er1
18606   ac_status=$?
18607   grep -v '^ *+' conftest.er1 >conftest.err
18608   rm -f conftest.er1
18609   cat conftest.err >&5
18610   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18611   (exit $ac_status); } &&
18612          { ac_try='test -z "$ac_c_werror_flag"
18613                          || test ! -s conftest.err'
18614   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18615   (eval $ac_try) 2>&5
18616   ac_status=$?
18617   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18618   (exit $ac_status); }; } &&
18619          { ac_try='test -s conftest$ac_exeext'
18620   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18621   (eval $ac_try) 2>&5
18622   ac_status=$?
18623   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18624   (exit $ac_status); }; }; then
18625   ac_cv_lib_m_y1f=yes
18626 else
18627   echo "$as_me: failed program was:" >&5
18628 sed 's/^/| /' conftest.$ac_ext >&5
18629
18630 ac_cv_lib_m_y1f=no
18631 fi
18632 rm -f conftest.err conftest.$ac_objext \
18633       conftest$ac_exeext conftest.$ac_ext
18634 LIBS=$ac_check_lib_save_LIBS
18635 fi
18636 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1f" >&5
18637 echo "${ECHO_T}$ac_cv_lib_m_y1f" >&6
18638 if test $ac_cv_lib_m_y1f = yes; then
18639
18640 cat >>confdefs.h <<\_ACEOF
18641 #define HAVE_Y1F 1
18642 _ACEOF
18643
18644 fi
18645
18646 echo "$as_me:$LINENO: checking for y1 in -lm" >&5
18647 echo $ECHO_N "checking for y1 in -lm... $ECHO_C" >&6
18648 if test "${ac_cv_lib_m_y1+set}" = set; then
18649   echo $ECHO_N "(cached) $ECHO_C" >&6
18650 else
18651   ac_check_lib_save_LIBS=$LIBS
18652 LIBS="-lm  $LIBS"
18653 if test x$gcc_no_link = xyes; then
18654   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18655 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18656    { (exit 1); exit 1; }; }
18657 fi
18658 cat >conftest.$ac_ext <<_ACEOF
18659 /* confdefs.h.  */
18660 _ACEOF
18661 cat confdefs.h >>conftest.$ac_ext
18662 cat >>conftest.$ac_ext <<_ACEOF
18663 /* end confdefs.h.  */
18664
18665 /* Override any gcc2 internal prototype to avoid an error.  */
18666 #ifdef __cplusplus
18667 extern "C"
18668 #endif
18669 /* We use char because int might match the return type of a gcc2
18670    builtin and then its argument prototype would still apply.  */
18671 char y1 ();
18672 int
18673 main ()
18674 {
18675 y1 ();
18676   ;
18677   return 0;
18678 }
18679 _ACEOF
18680 rm -f conftest.$ac_objext conftest$ac_exeext
18681 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18682   (eval $ac_link) 2>conftest.er1
18683   ac_status=$?
18684   grep -v '^ *+' conftest.er1 >conftest.err
18685   rm -f conftest.er1
18686   cat conftest.err >&5
18687   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18688   (exit $ac_status); } &&
18689          { ac_try='test -z "$ac_c_werror_flag"
18690                          || test ! -s conftest.err'
18691   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18692   (eval $ac_try) 2>&5
18693   ac_status=$?
18694   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18695   (exit $ac_status); }; } &&
18696          { ac_try='test -s conftest$ac_exeext'
18697   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18698   (eval $ac_try) 2>&5
18699   ac_status=$?
18700   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18701   (exit $ac_status); }; }; then
18702   ac_cv_lib_m_y1=yes
18703 else
18704   echo "$as_me: failed program was:" >&5
18705 sed 's/^/| /' conftest.$ac_ext >&5
18706
18707 ac_cv_lib_m_y1=no
18708 fi
18709 rm -f conftest.err conftest.$ac_objext \
18710       conftest$ac_exeext conftest.$ac_ext
18711 LIBS=$ac_check_lib_save_LIBS
18712 fi
18713 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1" >&5
18714 echo "${ECHO_T}$ac_cv_lib_m_y1" >&6
18715 if test $ac_cv_lib_m_y1 = yes; then
18716
18717 cat >>confdefs.h <<\_ACEOF
18718 #define HAVE_Y1 1
18719 _ACEOF
18720
18721 fi
18722
18723 echo "$as_me:$LINENO: checking for y1l in -lm" >&5
18724 echo $ECHO_N "checking for y1l in -lm... $ECHO_C" >&6
18725 if test "${ac_cv_lib_m_y1l+set}" = set; then
18726   echo $ECHO_N "(cached) $ECHO_C" >&6
18727 else
18728   ac_check_lib_save_LIBS=$LIBS
18729 LIBS="-lm  $LIBS"
18730 if test x$gcc_no_link = xyes; then
18731   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18732 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18733    { (exit 1); exit 1; }; }
18734 fi
18735 cat >conftest.$ac_ext <<_ACEOF
18736 /* confdefs.h.  */
18737 _ACEOF
18738 cat confdefs.h >>conftest.$ac_ext
18739 cat >>conftest.$ac_ext <<_ACEOF
18740 /* end confdefs.h.  */
18741
18742 /* Override any gcc2 internal prototype to avoid an error.  */
18743 #ifdef __cplusplus
18744 extern "C"
18745 #endif
18746 /* We use char because int might match the return type of a gcc2
18747    builtin and then its argument prototype would still apply.  */
18748 char y1l ();
18749 int
18750 main ()
18751 {
18752 y1l ();
18753   ;
18754   return 0;
18755 }
18756 _ACEOF
18757 rm -f conftest.$ac_objext conftest$ac_exeext
18758 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18759   (eval $ac_link) 2>conftest.er1
18760   ac_status=$?
18761   grep -v '^ *+' conftest.er1 >conftest.err
18762   rm -f conftest.er1
18763   cat conftest.err >&5
18764   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18765   (exit $ac_status); } &&
18766          { ac_try='test -z "$ac_c_werror_flag"
18767                          || test ! -s conftest.err'
18768   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18769   (eval $ac_try) 2>&5
18770   ac_status=$?
18771   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18772   (exit $ac_status); }; } &&
18773          { ac_try='test -s conftest$ac_exeext'
18774   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18775   (eval $ac_try) 2>&5
18776   ac_status=$?
18777   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18778   (exit $ac_status); }; }; then
18779   ac_cv_lib_m_y1l=yes
18780 else
18781   echo "$as_me: failed program was:" >&5
18782 sed 's/^/| /' conftest.$ac_ext >&5
18783
18784 ac_cv_lib_m_y1l=no
18785 fi
18786 rm -f conftest.err conftest.$ac_objext \
18787       conftest$ac_exeext conftest.$ac_ext
18788 LIBS=$ac_check_lib_save_LIBS
18789 fi
18790 echo "$as_me:$LINENO: result: $ac_cv_lib_m_y1l" >&5
18791 echo "${ECHO_T}$ac_cv_lib_m_y1l" >&6
18792 if test $ac_cv_lib_m_y1l = yes; then
18793
18794 cat >>confdefs.h <<\_ACEOF
18795 #define HAVE_Y1L 1
18796 _ACEOF
18797
18798 fi
18799
18800 echo "$as_me:$LINENO: checking for ynf in -lm" >&5
18801 echo $ECHO_N "checking for ynf in -lm... $ECHO_C" >&6
18802 if test "${ac_cv_lib_m_ynf+set}" = set; then
18803   echo $ECHO_N "(cached) $ECHO_C" >&6
18804 else
18805   ac_check_lib_save_LIBS=$LIBS
18806 LIBS="-lm  $LIBS"
18807 if test x$gcc_no_link = xyes; then
18808   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18809 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18810    { (exit 1); exit 1; }; }
18811 fi
18812 cat >conftest.$ac_ext <<_ACEOF
18813 /* confdefs.h.  */
18814 _ACEOF
18815 cat confdefs.h >>conftest.$ac_ext
18816 cat >>conftest.$ac_ext <<_ACEOF
18817 /* end confdefs.h.  */
18818
18819 /* Override any gcc2 internal prototype to avoid an error.  */
18820 #ifdef __cplusplus
18821 extern "C"
18822 #endif
18823 /* We use char because int might match the return type of a gcc2
18824    builtin and then its argument prototype would still apply.  */
18825 char ynf ();
18826 int
18827 main ()
18828 {
18829 ynf ();
18830   ;
18831   return 0;
18832 }
18833 _ACEOF
18834 rm -f conftest.$ac_objext conftest$ac_exeext
18835 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18836   (eval $ac_link) 2>conftest.er1
18837   ac_status=$?
18838   grep -v '^ *+' conftest.er1 >conftest.err
18839   rm -f conftest.er1
18840   cat conftest.err >&5
18841   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18842   (exit $ac_status); } &&
18843          { ac_try='test -z "$ac_c_werror_flag"
18844                          || test ! -s conftest.err'
18845   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18846   (eval $ac_try) 2>&5
18847   ac_status=$?
18848   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18849   (exit $ac_status); }; } &&
18850          { ac_try='test -s conftest$ac_exeext'
18851   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18852   (eval $ac_try) 2>&5
18853   ac_status=$?
18854   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18855   (exit $ac_status); }; }; then
18856   ac_cv_lib_m_ynf=yes
18857 else
18858   echo "$as_me: failed program was:" >&5
18859 sed 's/^/| /' conftest.$ac_ext >&5
18860
18861 ac_cv_lib_m_ynf=no
18862 fi
18863 rm -f conftest.err conftest.$ac_objext \
18864       conftest$ac_exeext conftest.$ac_ext
18865 LIBS=$ac_check_lib_save_LIBS
18866 fi
18867 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ynf" >&5
18868 echo "${ECHO_T}$ac_cv_lib_m_ynf" >&6
18869 if test $ac_cv_lib_m_ynf = yes; then
18870
18871 cat >>confdefs.h <<\_ACEOF
18872 #define HAVE_YNF 1
18873 _ACEOF
18874
18875 fi
18876
18877 echo "$as_me:$LINENO: checking for yn in -lm" >&5
18878 echo $ECHO_N "checking for yn in -lm... $ECHO_C" >&6
18879 if test "${ac_cv_lib_m_yn+set}" = set; then
18880   echo $ECHO_N "(cached) $ECHO_C" >&6
18881 else
18882   ac_check_lib_save_LIBS=$LIBS
18883 LIBS="-lm  $LIBS"
18884 if test x$gcc_no_link = xyes; then
18885   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18886 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18887    { (exit 1); exit 1; }; }
18888 fi
18889 cat >conftest.$ac_ext <<_ACEOF
18890 /* confdefs.h.  */
18891 _ACEOF
18892 cat confdefs.h >>conftest.$ac_ext
18893 cat >>conftest.$ac_ext <<_ACEOF
18894 /* end confdefs.h.  */
18895
18896 /* Override any gcc2 internal prototype to avoid an error.  */
18897 #ifdef __cplusplus
18898 extern "C"
18899 #endif
18900 /* We use char because int might match the return type of a gcc2
18901    builtin and then its argument prototype would still apply.  */
18902 char yn ();
18903 int
18904 main ()
18905 {
18906 yn ();
18907   ;
18908   return 0;
18909 }
18910 _ACEOF
18911 rm -f conftest.$ac_objext conftest$ac_exeext
18912 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18913   (eval $ac_link) 2>conftest.er1
18914   ac_status=$?
18915   grep -v '^ *+' conftest.er1 >conftest.err
18916   rm -f conftest.er1
18917   cat conftest.err >&5
18918   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18919   (exit $ac_status); } &&
18920          { ac_try='test -z "$ac_c_werror_flag"
18921                          || test ! -s conftest.err'
18922   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18923   (eval $ac_try) 2>&5
18924   ac_status=$?
18925   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18926   (exit $ac_status); }; } &&
18927          { ac_try='test -s conftest$ac_exeext'
18928   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
18929   (eval $ac_try) 2>&5
18930   ac_status=$?
18931   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18932   (exit $ac_status); }; }; then
18933   ac_cv_lib_m_yn=yes
18934 else
18935   echo "$as_me: failed program was:" >&5
18936 sed 's/^/| /' conftest.$ac_ext >&5
18937
18938 ac_cv_lib_m_yn=no
18939 fi
18940 rm -f conftest.err conftest.$ac_objext \
18941       conftest$ac_exeext conftest.$ac_ext
18942 LIBS=$ac_check_lib_save_LIBS
18943 fi
18944 echo "$as_me:$LINENO: result: $ac_cv_lib_m_yn" >&5
18945 echo "${ECHO_T}$ac_cv_lib_m_yn" >&6
18946 if test $ac_cv_lib_m_yn = yes; then
18947
18948 cat >>confdefs.h <<\_ACEOF
18949 #define HAVE_YN 1
18950 _ACEOF
18951
18952 fi
18953
18954 echo "$as_me:$LINENO: checking for ynl in -lm" >&5
18955 echo $ECHO_N "checking for ynl in -lm... $ECHO_C" >&6
18956 if test "${ac_cv_lib_m_ynl+set}" = set; then
18957   echo $ECHO_N "(cached) $ECHO_C" >&6
18958 else
18959   ac_check_lib_save_LIBS=$LIBS
18960 LIBS="-lm  $LIBS"
18961 if test x$gcc_no_link = xyes; then
18962   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
18963 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
18964    { (exit 1); exit 1; }; }
18965 fi
18966 cat >conftest.$ac_ext <<_ACEOF
18967 /* confdefs.h.  */
18968 _ACEOF
18969 cat confdefs.h >>conftest.$ac_ext
18970 cat >>conftest.$ac_ext <<_ACEOF
18971 /* end confdefs.h.  */
18972
18973 /* Override any gcc2 internal prototype to avoid an error.  */
18974 #ifdef __cplusplus
18975 extern "C"
18976 #endif
18977 /* We use char because int might match the return type of a gcc2
18978    builtin and then its argument prototype would still apply.  */
18979 char ynl ();
18980 int
18981 main ()
18982 {
18983 ynl ();
18984   ;
18985   return 0;
18986 }
18987 _ACEOF
18988 rm -f conftest.$ac_objext conftest$ac_exeext
18989 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
18990   (eval $ac_link) 2>conftest.er1
18991   ac_status=$?
18992   grep -v '^ *+' conftest.er1 >conftest.err
18993   rm -f conftest.er1
18994   cat conftest.err >&5
18995   echo "$as_me:$LINENO: \$? = $ac_status" >&5
18996   (exit $ac_status); } &&
18997          { ac_try='test -z "$ac_c_werror_flag"
18998                          || test ! -s conftest.err'
18999   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19000   (eval $ac_try) 2>&5
19001   ac_status=$?
19002   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19003   (exit $ac_status); }; } &&
19004          { ac_try='test -s conftest$ac_exeext'
19005   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19006   (eval $ac_try) 2>&5
19007   ac_status=$?
19008   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19009   (exit $ac_status); }; }; then
19010   ac_cv_lib_m_ynl=yes
19011 else
19012   echo "$as_me: failed program was:" >&5
19013 sed 's/^/| /' conftest.$ac_ext >&5
19014
19015 ac_cv_lib_m_ynl=no
19016 fi
19017 rm -f conftest.err conftest.$ac_objext \
19018       conftest$ac_exeext conftest.$ac_ext
19019 LIBS=$ac_check_lib_save_LIBS
19020 fi
19021 echo "$as_me:$LINENO: result: $ac_cv_lib_m_ynl" >&5
19022 echo "${ECHO_T}$ac_cv_lib_m_ynl" >&6
19023 if test $ac_cv_lib_m_ynl = yes; then
19024
19025 cat >>confdefs.h <<\_ACEOF
19026 #define HAVE_YNL 1
19027 _ACEOF
19028
19029 fi
19030
19031
19032 # On AIX, clog is present in libm as __clog
19033 echo "$as_me:$LINENO: checking for __clog in -lm" >&5
19034 echo $ECHO_N "checking for __clog in -lm... $ECHO_C" >&6
19035 if test "${ac_cv_lib_m___clog+set}" = set; then
19036   echo $ECHO_N "(cached) $ECHO_C" >&6
19037 else
19038   ac_check_lib_save_LIBS=$LIBS
19039 LIBS="-lm  $LIBS"
19040 if test x$gcc_no_link = xyes; then
19041   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19042 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19043    { (exit 1); exit 1; }; }
19044 fi
19045 cat >conftest.$ac_ext <<_ACEOF
19046 /* confdefs.h.  */
19047 _ACEOF
19048 cat confdefs.h >>conftest.$ac_ext
19049 cat >>conftest.$ac_ext <<_ACEOF
19050 /* end confdefs.h.  */
19051
19052 /* Override any gcc2 internal prototype to avoid an error.  */
19053 #ifdef __cplusplus
19054 extern "C"
19055 #endif
19056 /* We use char because int might match the return type of a gcc2
19057    builtin and then its argument prototype would still apply.  */
19058 char __clog ();
19059 int
19060 main ()
19061 {
19062 __clog ();
19063   ;
19064   return 0;
19065 }
19066 _ACEOF
19067 rm -f conftest.$ac_objext conftest$ac_exeext
19068 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19069   (eval $ac_link) 2>conftest.er1
19070   ac_status=$?
19071   grep -v '^ *+' conftest.er1 >conftest.err
19072   rm -f conftest.er1
19073   cat conftest.err >&5
19074   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19075   (exit $ac_status); } &&
19076          { ac_try='test -z "$ac_c_werror_flag"
19077                          || test ! -s conftest.err'
19078   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19079   (eval $ac_try) 2>&5
19080   ac_status=$?
19081   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19082   (exit $ac_status); }; } &&
19083          { ac_try='test -s conftest$ac_exeext'
19084   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19085   (eval $ac_try) 2>&5
19086   ac_status=$?
19087   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19088   (exit $ac_status); }; }; then
19089   ac_cv_lib_m___clog=yes
19090 else
19091   echo "$as_me: failed program was:" >&5
19092 sed 's/^/| /' conftest.$ac_ext >&5
19093
19094 ac_cv_lib_m___clog=no
19095 fi
19096 rm -f conftest.err conftest.$ac_objext \
19097       conftest$ac_exeext conftest.$ac_ext
19098 LIBS=$ac_check_lib_save_LIBS
19099 fi
19100 echo "$as_me:$LINENO: result: $ac_cv_lib_m___clog" >&5
19101 echo "${ECHO_T}$ac_cv_lib_m___clog" >&6
19102 if test $ac_cv_lib_m___clog = yes; then
19103
19104 cat >>confdefs.h <<\_ACEOF
19105 #define HAVE_CLOG 1
19106 _ACEOF
19107
19108 fi
19109
19110
19111 # Check for a isfinite macro that works on long doubles.
19112
19113   echo "$as_me:$LINENO: checking whether isfinite is broken" >&5
19114 echo $ECHO_N "checking whether isfinite is broken... $ECHO_C" >&6
19115 if test "${have_broken_isfinite+set}" = set; then
19116   echo $ECHO_N "(cached) $ECHO_C" >&6
19117 else
19118
19119   libgfor_check_for_broken_isfinite_save_LIBS=$LIBS
19120   LIBS="$LIBS -lm"
19121   if test "$cross_compiling" = yes; then
19122
19123 case "${target}" in
19124   hppa*-*-hpux*) have_broken_isfinite=yes ;;
19125   *) have_broken_isfinite=no ;;
19126 esac
19127 else
19128   cat >conftest.$ac_ext <<_ACEOF
19129 /* confdefs.h.  */
19130 _ACEOF
19131 cat confdefs.h >>conftest.$ac_ext
19132 cat >>conftest.$ac_ext <<_ACEOF
19133 /* end confdefs.h.  */
19134
19135 #ifdef HAVE_MATH_H
19136 #include <math.h>
19137 #endif
19138 #include <float.h>
19139 int main ()
19140 {
19141 #ifdef isfinite
19142 #ifdef LDBL_MAX
19143   if (!isfinite(LDBL_MAX)) return 1;
19144 #endif
19145 #ifdef DBL_MAX
19146   if (!isfinite(DBL_MAX)) return 1;
19147 #endif
19148 #endif
19149 return 0;
19150 }
19151 _ACEOF
19152 rm -f conftest$ac_exeext
19153 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19154   (eval $ac_link) 2>&5
19155   ac_status=$?
19156   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19157   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
19158   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19159   (eval $ac_try) 2>&5
19160   ac_status=$?
19161   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19162   (exit $ac_status); }; }; then
19163   have_broken_isfinite=no
19164 else
19165   echo "$as_me: program exited with status $ac_status" >&5
19166 echo "$as_me: failed program was:" >&5
19167 sed 's/^/| /' conftest.$ac_ext >&5
19168
19169 ( exit $ac_status )
19170 have_broken_isfinite=yes
19171 fi
19172 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
19173 fi
19174   LIBS=$libgfor_check_for_broken_isfinite_save_LIBS
19175 fi
19176 echo "$as_me:$LINENO: result: $have_broken_isfinite" >&5
19177 echo "${ECHO_T}$have_broken_isfinite" >&6
19178 if test x"$have_broken_isfinite" = xyes; then
19179
19180 cat >>confdefs.h <<\_ACEOF
19181 #define HAVE_BROKEN_ISFINITE 1
19182 _ACEOF
19183
19184 fi
19185
19186 # Check for a isnan macro that works on long doubles.
19187
19188   echo "$as_me:$LINENO: checking whether isnan is broken" >&5
19189 echo $ECHO_N "checking whether isnan is broken... $ECHO_C" >&6
19190 if test "${have_broken_isnan+set}" = set; then
19191   echo $ECHO_N "(cached) $ECHO_C" >&6
19192 else
19193
19194   libgfor_check_for_broken_isnan_save_LIBS=$LIBS
19195   LIBS="$LIBS -lm"
19196   if test "$cross_compiling" = yes; then
19197
19198 case "${target}" in
19199   hppa*-*-hpux*) have_broken_isnan=yes ;;
19200   *) have_broken_isnan=no ;;
19201 esac
19202 else
19203   cat >conftest.$ac_ext <<_ACEOF
19204 /* confdefs.h.  */
19205 _ACEOF
19206 cat confdefs.h >>conftest.$ac_ext
19207 cat >>conftest.$ac_ext <<_ACEOF
19208 /* end confdefs.h.  */
19209
19210 #ifdef HAVE_MATH_H
19211 #include <math.h>
19212 #endif
19213 #include <float.h>
19214 int main ()
19215 {
19216 #ifdef isnan
19217 #ifdef LDBL_MAX
19218   {
19219     long double x;
19220     x = __builtin_nanl ("");
19221     if (!isnan(x)) return 1;
19222     if (isnan(LDBL_MAX)) return 1;
19223 #ifdef NAN
19224     x = (long double) NAN;
19225     if (!isnan(x)) return 1;
19226 #endif
19227   }
19228 #endif
19229 #ifdef DBL_MAX
19230   {
19231     double y;
19232     y = __builtin_nan ("");
19233     if (!isnan(y)) return 1;
19234     if (isnan(DBL_MAX)) return 1;
19235 #ifdef NAN
19236     y = (double) NAN;
19237     if (!isnan(y)) return 1;
19238 #endif
19239   }
19240 #endif
19241 #endif
19242 return 0;
19243 }
19244 _ACEOF
19245 rm -f conftest$ac_exeext
19246 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19247   (eval $ac_link) 2>&5
19248   ac_status=$?
19249   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19250   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
19251   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19252   (eval $ac_try) 2>&5
19253   ac_status=$?
19254   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19255   (exit $ac_status); }; }; then
19256   have_broken_isnan=no
19257 else
19258   echo "$as_me: program exited with status $ac_status" >&5
19259 echo "$as_me: failed program was:" >&5
19260 sed 's/^/| /' conftest.$ac_ext >&5
19261
19262 ( exit $ac_status )
19263 have_broken_isnan=yes
19264 fi
19265 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
19266 fi
19267   LIBS=$libgfor_check_for_broken_isnan_save_LIBS
19268 fi
19269 echo "$as_me:$LINENO: result: $have_broken_isnan" >&5
19270 echo "${ECHO_T}$have_broken_isnan" >&6
19271 if test x"$have_broken_isnan" = xyes; then
19272
19273 cat >>confdefs.h <<\_ACEOF
19274 #define HAVE_BROKEN_ISNAN 1
19275 _ACEOF
19276
19277 fi
19278
19279 # Check for a fpclassify macro that works on long doubles.
19280
19281   echo "$as_me:$LINENO: checking whether fpclassify is broken" >&5
19282 echo $ECHO_N "checking whether fpclassify is broken... $ECHO_C" >&6
19283 if test "${have_broken_fpclassify+set}" = set; then
19284   echo $ECHO_N "(cached) $ECHO_C" >&6
19285 else
19286
19287   libgfor_check_for_broken_fpclassify_save_LIBS=$LIBS
19288   LIBS="$LIBS -lm"
19289   if test "$cross_compiling" = yes; then
19290
19291 case "${target}" in
19292   hppa*-*-hpux*) have_broken_fpclassify=yes ;;
19293   *) have_broken_fpclassify=no ;;
19294 esac
19295 else
19296   cat >conftest.$ac_ext <<_ACEOF
19297 /* confdefs.h.  */
19298 _ACEOF
19299 cat confdefs.h >>conftest.$ac_ext
19300 cat >>conftest.$ac_ext <<_ACEOF
19301 /* end confdefs.h.  */
19302
19303 #ifdef HAVE_MATH_H
19304 #include <math.h>
19305 #endif
19306 #include <float.h>
19307 int main ()
19308 {
19309 #ifdef fpclassify
19310 #ifdef LDBL_MAX
19311         if (fpclassify(LDBL_MAX) == FP_NAN
19312             || fpclassify(LDBL_MAX) == FP_INFINITE) return 1;
19313 #endif
19314 #ifdef DBL_MAX
19315         if (fpclassify(DBL_MAX) == FP_NAN
19316             || fpclassify(DBL_MAX) == FP_INFINITE) return 1;
19317 #endif
19318 #endif
19319 return 0;
19320 }
19321 _ACEOF
19322 rm -f conftest$ac_exeext
19323 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19324   (eval $ac_link) 2>&5
19325   ac_status=$?
19326   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19327   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
19328   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19329   (eval $ac_try) 2>&5
19330   ac_status=$?
19331   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19332   (exit $ac_status); }; }; then
19333   have_broken_fpclassify=no
19334 else
19335   echo "$as_me: program exited with status $ac_status" >&5
19336 echo "$as_me: failed program was:" >&5
19337 sed 's/^/| /' conftest.$ac_ext >&5
19338
19339 ( exit $ac_status )
19340 have_broken_fpclassify=yes
19341 fi
19342 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
19343 fi
19344   LIBS=$libgfor_check_for_broken_fpclassify_save_LIBS
19345 fi
19346 echo "$as_me:$LINENO: result: $have_broken_fpclassify" >&5
19347 echo "${ECHO_T}$have_broken_fpclassify" >&6
19348 if test x"$have_broken_fpclassify" = xyes; then
19349
19350 cat >>confdefs.h <<\_ACEOF
19351 #define HAVE_BROKEN_FPCLASSIFY 1
19352 _ACEOF
19353
19354 fi
19355
19356 # Fallback in case isfinite is not available.
19357 echo "$as_me:$LINENO: checking for finite in -lm" >&5
19358 echo $ECHO_N "checking for finite in -lm... $ECHO_C" >&6
19359 if test "${ac_cv_lib_m_finite+set}" = set; then
19360   echo $ECHO_N "(cached) $ECHO_C" >&6
19361 else
19362   ac_check_lib_save_LIBS=$LIBS
19363 LIBS="-lm  $LIBS"
19364 if test x$gcc_no_link = xyes; then
19365   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19366 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19367    { (exit 1); exit 1; }; }
19368 fi
19369 cat >conftest.$ac_ext <<_ACEOF
19370 /* confdefs.h.  */
19371 _ACEOF
19372 cat confdefs.h >>conftest.$ac_ext
19373 cat >>conftest.$ac_ext <<_ACEOF
19374 /* end confdefs.h.  */
19375
19376 /* Override any gcc2 internal prototype to avoid an error.  */
19377 #ifdef __cplusplus
19378 extern "C"
19379 #endif
19380 /* We use char because int might match the return type of a gcc2
19381    builtin and then its argument prototype would still apply.  */
19382 char finite ();
19383 int
19384 main ()
19385 {
19386 finite ();
19387   ;
19388   return 0;
19389 }
19390 _ACEOF
19391 rm -f conftest.$ac_objext conftest$ac_exeext
19392 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19393   (eval $ac_link) 2>conftest.er1
19394   ac_status=$?
19395   grep -v '^ *+' conftest.er1 >conftest.err
19396   rm -f conftest.er1
19397   cat conftest.err >&5
19398   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19399   (exit $ac_status); } &&
19400          { ac_try='test -z "$ac_c_werror_flag"
19401                          || test ! -s conftest.err'
19402   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19403   (eval $ac_try) 2>&5
19404   ac_status=$?
19405   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19406   (exit $ac_status); }; } &&
19407          { ac_try='test -s conftest$ac_exeext'
19408   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19409   (eval $ac_try) 2>&5
19410   ac_status=$?
19411   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19412   (exit $ac_status); }; }; then
19413   ac_cv_lib_m_finite=yes
19414 else
19415   echo "$as_me: failed program was:" >&5
19416 sed 's/^/| /' conftest.$ac_ext >&5
19417
19418 ac_cv_lib_m_finite=no
19419 fi
19420 rm -f conftest.err conftest.$ac_objext \
19421       conftest$ac_exeext conftest.$ac_ext
19422 LIBS=$ac_check_lib_save_LIBS
19423 fi
19424 echo "$as_me:$LINENO: result: $ac_cv_lib_m_finite" >&5
19425 echo "${ECHO_T}$ac_cv_lib_m_finite" >&6
19426 if test $ac_cv_lib_m_finite = yes; then
19427
19428 cat >>confdefs.h <<\_ACEOF
19429 #define HAVE_FINITE 1
19430 _ACEOF
19431
19432 fi
19433
19434
19435 # Check for GNU libc feenableexcept
19436 echo "$as_me:$LINENO: checking for feenableexcept in -lm" >&5
19437 echo $ECHO_N "checking for feenableexcept in -lm... $ECHO_C" >&6
19438 if test "${ac_cv_lib_m_feenableexcept+set}" = set; then
19439   echo $ECHO_N "(cached) $ECHO_C" >&6
19440 else
19441   ac_check_lib_save_LIBS=$LIBS
19442 LIBS="-lm  $LIBS"
19443 if test x$gcc_no_link = xyes; then
19444   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19445 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19446    { (exit 1); exit 1; }; }
19447 fi
19448 cat >conftest.$ac_ext <<_ACEOF
19449 /* confdefs.h.  */
19450 _ACEOF
19451 cat confdefs.h >>conftest.$ac_ext
19452 cat >>conftest.$ac_ext <<_ACEOF
19453 /* end confdefs.h.  */
19454
19455 /* Override any gcc2 internal prototype to avoid an error.  */
19456 #ifdef __cplusplus
19457 extern "C"
19458 #endif
19459 /* We use char because int might match the return type of a gcc2
19460    builtin and then its argument prototype would still apply.  */
19461 char feenableexcept ();
19462 int
19463 main ()
19464 {
19465 feenableexcept ();
19466   ;
19467   return 0;
19468 }
19469 _ACEOF
19470 rm -f conftest.$ac_objext conftest$ac_exeext
19471 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19472   (eval $ac_link) 2>conftest.er1
19473   ac_status=$?
19474   grep -v '^ *+' conftest.er1 >conftest.err
19475   rm -f conftest.er1
19476   cat conftest.err >&5
19477   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19478   (exit $ac_status); } &&
19479          { ac_try='test -z "$ac_c_werror_flag"
19480                          || test ! -s conftest.err'
19481   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19482   (eval $ac_try) 2>&5
19483   ac_status=$?
19484   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19485   (exit $ac_status); }; } &&
19486          { ac_try='test -s conftest$ac_exeext'
19487   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19488   (eval $ac_try) 2>&5
19489   ac_status=$?
19490   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19491   (exit $ac_status); }; }; then
19492   ac_cv_lib_m_feenableexcept=yes
19493 else
19494   echo "$as_me: failed program was:" >&5
19495 sed 's/^/| /' conftest.$ac_ext >&5
19496
19497 ac_cv_lib_m_feenableexcept=no
19498 fi
19499 rm -f conftest.err conftest.$ac_objext \
19500       conftest$ac_exeext conftest.$ac_ext
19501 LIBS=$ac_check_lib_save_LIBS
19502 fi
19503 echo "$as_me:$LINENO: result: $ac_cv_lib_m_feenableexcept" >&5
19504 echo "${ECHO_T}$ac_cv_lib_m_feenableexcept" >&6
19505 if test $ac_cv_lib_m_feenableexcept = yes; then
19506   have_feenableexcept=yes
19507 cat >>confdefs.h <<\_ACEOF
19508 #define HAVE_FEENABLEEXCEPT 1
19509 _ACEOF
19510
19511 fi
19512
19513
19514 # Runs configure.host to set up necessary host-dependent shell variables.
19515 # We then display a message about it, and propagate them through the
19516 # build chain.
19517 . ${srcdir}/configure.host
19518 { echo "$as_me:$LINENO: FPU dependent file will be ${fpu_host}.h" >&5
19519 echo "$as_me: FPU dependent file will be ${fpu_host}.h" >&6;}
19520 FPU_HOST_HEADER=config/${fpu_host}.h
19521
19522
19523 # The standard autoconf HAVE_STRUCT_TIMEZONE doesn't actually check
19524 # for struct timezone, as you might think.  We also need to check how
19525 # to call gettimeofday if we have it.
19526 echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
19527 echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
19528 if test "${ac_cv_header_time+set}" = set; then
19529   echo $ECHO_N "(cached) $ECHO_C" >&6
19530 else
19531   cat >conftest.$ac_ext <<_ACEOF
19532 /* confdefs.h.  */
19533 _ACEOF
19534 cat confdefs.h >>conftest.$ac_ext
19535 cat >>conftest.$ac_ext <<_ACEOF
19536 /* end confdefs.h.  */
19537 #include <sys/types.h>
19538 #include <sys/time.h>
19539 #include <time.h>
19540
19541 int
19542 main ()
19543 {
19544 if ((struct tm *) 0)
19545 return 0;
19546   ;
19547   return 0;
19548 }
19549 _ACEOF
19550 rm -f conftest.$ac_objext
19551 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
19552   (eval $ac_compile) 2>conftest.er1
19553   ac_status=$?
19554   grep -v '^ *+' conftest.er1 >conftest.err
19555   rm -f conftest.er1
19556   cat conftest.err >&5
19557   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19558   (exit $ac_status); } &&
19559          { ac_try='test -z "$ac_c_werror_flag"
19560                          || test ! -s conftest.err'
19561   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19562   (eval $ac_try) 2>&5
19563   ac_status=$?
19564   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19565   (exit $ac_status); }; } &&
19566          { ac_try='test -s conftest.$ac_objext'
19567   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19568   (eval $ac_try) 2>&5
19569   ac_status=$?
19570   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19571   (exit $ac_status); }; }; then
19572   ac_cv_header_time=yes
19573 else
19574   echo "$as_me: failed program was:" >&5
19575 sed 's/^/| /' conftest.$ac_ext >&5
19576
19577 ac_cv_header_time=no
19578 fi
19579 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
19580 fi
19581 echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
19582 echo "${ECHO_T}$ac_cv_header_time" >&6
19583 if test $ac_cv_header_time = yes; then
19584
19585 cat >>confdefs.h <<\_ACEOF
19586 #define TIME_WITH_SYS_TIME 1
19587 _ACEOF
19588
19589 fi
19590
19591
19592
19593 for ac_func in gettimeofday
19594 do
19595 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
19596 echo "$as_me:$LINENO: checking for $ac_func" >&5
19597 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
19598 if eval "test \"\${$as_ac_var+set}\" = set"; then
19599   echo $ECHO_N "(cached) $ECHO_C" >&6
19600 else
19601   if test x$gcc_no_link = xyes; then
19602   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19603 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19604    { (exit 1); exit 1; }; }
19605 fi
19606 cat >conftest.$ac_ext <<_ACEOF
19607 /* confdefs.h.  */
19608 _ACEOF
19609 cat confdefs.h >>conftest.$ac_ext
19610 cat >>conftest.$ac_ext <<_ACEOF
19611 /* end confdefs.h.  */
19612 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
19613    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
19614 #define $ac_func innocuous_$ac_func
19615
19616 /* System header to define __stub macros and hopefully few prototypes,
19617     which can conflict with char $ac_func (); below.
19618     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
19619     <limits.h> exists even on freestanding compilers.  */
19620
19621 #ifdef __STDC__
19622 # include <limits.h>
19623 #else
19624 # include <assert.h>
19625 #endif
19626
19627 #undef $ac_func
19628
19629 /* Override any gcc2 internal prototype to avoid an error.  */
19630 #ifdef __cplusplus
19631 extern "C"
19632 {
19633 #endif
19634 /* We use char because int might match the return type of a gcc2
19635    builtin and then its argument prototype would still apply.  */
19636 char $ac_func ();
19637 /* The GNU C library defines this for functions which it implements
19638     to always fail with ENOSYS.  Some functions are actually named
19639     something starting with __ and the normal name is an alias.  */
19640 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
19641 choke me
19642 #else
19643 char (*f) () = $ac_func;
19644 #endif
19645 #ifdef __cplusplus
19646 }
19647 #endif
19648
19649 int
19650 main ()
19651 {
19652 return f != $ac_func;
19653   ;
19654   return 0;
19655 }
19656 _ACEOF
19657 rm -f conftest.$ac_objext conftest$ac_exeext
19658 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19659   (eval $ac_link) 2>conftest.er1
19660   ac_status=$?
19661   grep -v '^ *+' conftest.er1 >conftest.err
19662   rm -f conftest.er1
19663   cat conftest.err >&5
19664   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19665   (exit $ac_status); } &&
19666          { ac_try='test -z "$ac_c_werror_flag"
19667                          || test ! -s conftest.err'
19668   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19669   (eval $ac_try) 2>&5
19670   ac_status=$?
19671   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19672   (exit $ac_status); }; } &&
19673          { ac_try='test -s conftest$ac_exeext'
19674   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19675   (eval $ac_try) 2>&5
19676   ac_status=$?
19677   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19678   (exit $ac_status); }; }; then
19679   eval "$as_ac_var=yes"
19680 else
19681   echo "$as_me: failed program was:" >&5
19682 sed 's/^/| /' conftest.$ac_ext >&5
19683
19684 eval "$as_ac_var=no"
19685 fi
19686 rm -f conftest.err conftest.$ac_objext \
19687       conftest$ac_exeext conftest.$ac_ext
19688 fi
19689 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
19690 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
19691 if test `eval echo '${'$as_ac_var'}'` = yes; then
19692   cat >>confdefs.h <<_ACEOF
19693 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
19694 _ACEOF
19695
19696 fi
19697 done
19698
19699   if test "$ac_cv_func_gettimeofday" = yes; then
19700     echo "$as_me:$LINENO: checking for struct timezone" >&5
19701 echo $ECHO_N "checking for struct timezone... $ECHO_C" >&6
19702 if test "${gfor_cv_struct_timezone+set}" = set; then
19703   echo $ECHO_N "(cached) $ECHO_C" >&6
19704 else
19705   cat >conftest.$ac_ext <<_ACEOF
19706 /* confdefs.h.  */
19707 _ACEOF
19708 cat confdefs.h >>conftest.$ac_ext
19709 cat >>conftest.$ac_ext <<_ACEOF
19710 /* end confdefs.h.  */
19711 #include <sys/time.h>
19712 int
19713 main ()
19714 {
19715 struct timezone tz;
19716   ;
19717   return 0;
19718 }
19719 _ACEOF
19720 rm -f conftest.$ac_objext
19721 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
19722   (eval $ac_compile) 2>conftest.er1
19723   ac_status=$?
19724   grep -v '^ *+' conftest.er1 >conftest.err
19725   rm -f conftest.er1
19726   cat conftest.err >&5
19727   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19728   (exit $ac_status); } &&
19729          { ac_try='test -z "$ac_c_werror_flag"
19730                          || test ! -s conftest.err'
19731   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19732   (eval $ac_try) 2>&5
19733   ac_status=$?
19734   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19735   (exit $ac_status); }; } &&
19736          { ac_try='test -s conftest.$ac_objext'
19737   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19738   (eval $ac_try) 2>&5
19739   ac_status=$?
19740   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19741   (exit $ac_status); }; }; then
19742   gfor_cv_struct_timezone=yes
19743 else
19744   echo "$as_me: failed program was:" >&5
19745 sed 's/^/| /' conftest.$ac_ext >&5
19746
19747 gfor_cv_struct_timezone=no
19748 fi
19749 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
19750 fi
19751 echo "$as_me:$LINENO: result: $gfor_cv_struct_timezone" >&5
19752 echo "${ECHO_T}$gfor_cv_struct_timezone" >&6
19753     if test $gfor_cv_struct_timezone = yes; then
19754                   if test "$cross_compiling" = yes; then
19755   gfor_have_struct_timezone=yes
19756 else
19757   cat >conftest.$ac_ext <<_ACEOF
19758 /* confdefs.h.  */
19759 _ACEOF
19760 cat confdefs.h >>conftest.$ac_ext
19761 cat >>conftest.$ac_ext <<_ACEOF
19762 /* end confdefs.h.  */
19763
19764 #ifdef TIME_WITH_SYS_TIME
19765 #include <sys/time.h>
19766 #include <time.h>
19767 #else
19768 #ifdef HAVE_SYS_TIME_H
19769 #include <sys/time.h>
19770 #else
19771 #include <time.h>
19772 #endif
19773 #endif
19774 main ()
19775 {
19776   struct timeval time;
19777   struct timezone dummy;
19778   if (gettimeofday (&time, &dummy))
19779     exit (1);
19780   else
19781     exit (0);
19782 }
19783 _ACEOF
19784 rm -f conftest$ac_exeext
19785 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19786   (eval $ac_link) 2>&5
19787   ac_status=$?
19788   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19789   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
19790   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19791   (eval $ac_try) 2>&5
19792   ac_status=$?
19793   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19794   (exit $ac_status); }; }; then
19795   gfor_have_struct_timezone=yes
19796 else
19797   echo "$as_me: program exited with status $ac_status" >&5
19798 echo "$as_me: failed program was:" >&5
19799 sed 's/^/| /' conftest.$ac_ext >&5
19800
19801 ( exit $ac_status )
19802 gfor_have_struct_timezone=no
19803 fi
19804 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
19805 fi
19806       if test $gfor_have_struct_timezone = yes; then
19807
19808 cat >>confdefs.h <<\_ACEOF
19809 #define HAVE_TIMEZONE 1
19810 _ACEOF
19811
19812       fi
19813     fi
19814
19815     echo "$as_me:$LINENO: checking whether gettimeofday can accept two arguments" >&5
19816 echo $ECHO_N "checking whether gettimeofday can accept two arguments... $ECHO_C" >&6
19817 if test "${emacs_cv_gettimeofday_two_arguments+set}" = set; then
19818   echo $ECHO_N "(cached) $ECHO_C" >&6
19819 else
19820   if test x$gcc_no_link = xyes; then
19821   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19822 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19823    { (exit 1); exit 1; }; }
19824 fi
19825 cat >conftest.$ac_ext <<_ACEOF
19826 /* confdefs.h.  */
19827 _ACEOF
19828 cat confdefs.h >>conftest.$ac_ext
19829 cat >>conftest.$ac_ext <<_ACEOF
19830 /* end confdefs.h.  */
19831
19832 #ifdef TIME_WITH_SYS_TIME
19833 #include <sys/time.h>
19834 #include <time.h>
19835 #else
19836 #ifdef HAVE_SYS_TIME_H
19837 #include <sys/time.h>
19838 #else
19839 #include <time.h>
19840 #endif
19841 #endif
19842
19843 int
19844 main ()
19845 {
19846
19847       struct timeval time;
19848 #ifdef HAVE_TIMEZONE
19849       struct timezone dummy;
19850 #define DUMMY &dummy
19851 #else
19852 #define DUMMY NULL
19853 #endif
19854       gettimeofday (&time, DUMMY);
19855   ;
19856   return 0;
19857 }
19858 _ACEOF
19859 rm -f conftest.$ac_objext conftest$ac_exeext
19860 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19861   (eval $ac_link) 2>conftest.er1
19862   ac_status=$?
19863   grep -v '^ *+' conftest.er1 >conftest.err
19864   rm -f conftest.er1
19865   cat conftest.err >&5
19866   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19867   (exit $ac_status); } &&
19868          { ac_try='test -z "$ac_c_werror_flag"
19869                          || test ! -s conftest.err'
19870   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19871   (eval $ac_try) 2>&5
19872   ac_status=$?
19873   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19874   (exit $ac_status); }; } &&
19875          { ac_try='test -s conftest$ac_exeext'
19876   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19877   (eval $ac_try) 2>&5
19878   ac_status=$?
19879   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19880   (exit $ac_status); }; }; then
19881   emacs_cv_gettimeofday_two_arguments=yes
19882 else
19883   echo "$as_me: failed program was:" >&5
19884 sed 's/^/| /' conftest.$ac_ext >&5
19885
19886 emacs_cv_gettimeofday_two_arguments=no
19887 fi
19888 rm -f conftest.err conftest.$ac_objext \
19889       conftest$ac_exeext conftest.$ac_ext
19890 fi
19891 echo "$as_me:$LINENO: result: $emacs_cv_gettimeofday_two_arguments" >&5
19892 echo "${ECHO_T}$emacs_cv_gettimeofday_two_arguments" >&6
19893     if test $emacs_cv_gettimeofday_two_arguments = no; then
19894
19895 cat >>confdefs.h <<\_ACEOF
19896 #define GETTIMEOFDAY_ONE_ARGUMENT 1
19897 _ACEOF
19898
19899     fi
19900   fi
19901
19902 # Attempt to assert that the target is of common type in case we don't
19903 # have C99 integer types at all.
19904
19905   echo "$as_me:$LINENO: checking whether the target is ILP32" >&5
19906 echo $ECHO_N "checking whether the target is ILP32... $ECHO_C" >&6
19907 if test "${target_ilp32+set}" = set; then
19908   echo $ECHO_N "(cached) $ECHO_C" >&6
19909 else
19910
19911   save_CFLAGS="$CFLAGS"
19912   CFLAGS="-O2"
19913   if test x$gcc_no_link = xyes; then
19914   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
19915 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
19916    { (exit 1); exit 1; }; }
19917 fi
19918 cat >conftest.$ac_ext <<_ACEOF
19919 /* confdefs.h.  */
19920 _ACEOF
19921 cat confdefs.h >>conftest.$ac_ext
19922 cat >>conftest.$ac_ext <<_ACEOF
19923 /* end confdefs.h.  */
19924
19925 int
19926 main ()
19927 {
19928
19929 if (sizeof(int) == 4 && sizeof(long) == 4 && sizeof(void *) == 4)
19930   ;
19931 else
19932   undefined_function ();
19933
19934   ;
19935   return 0;
19936 }
19937 _ACEOF
19938 rm -f conftest.$ac_objext conftest$ac_exeext
19939 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
19940   (eval $ac_link) 2>conftest.er1
19941   ac_status=$?
19942   grep -v '^ *+' conftest.er1 >conftest.err
19943   rm -f conftest.er1
19944   cat conftest.err >&5
19945   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19946   (exit $ac_status); } &&
19947          { ac_try='test -z "$ac_c_werror_flag"
19948                          || test ! -s conftest.err'
19949   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19950   (eval $ac_try) 2>&5
19951   ac_status=$?
19952   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19953   (exit $ac_status); }; } &&
19954          { ac_try='test -s conftest$ac_exeext'
19955   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
19956   (eval $ac_try) 2>&5
19957   ac_status=$?
19958   echo "$as_me:$LINENO: \$? = $ac_status" >&5
19959   (exit $ac_status); }; }; then
19960   target_ilp32=yes
19961 else
19962   echo "$as_me: failed program was:" >&5
19963 sed 's/^/| /' conftest.$ac_ext >&5
19964
19965 target_ilp32=no
19966 fi
19967 rm -f conftest.err conftest.$ac_objext \
19968       conftest$ac_exeext conftest.$ac_ext
19969   CFLAGS="$save_CFLAGS"
19970 fi
19971 echo "$as_me:$LINENO: result: $target_ilp32" >&5
19972 echo "${ECHO_T}$target_ilp32" >&6
19973   if test $target_ilp32 = yes; then
19974
19975 cat >>confdefs.h <<\_ACEOF
19976 #define TARGET_ILP32 1
19977 _ACEOF
19978
19979   fi
19980
19981
19982 # Check out attribute support.
19983
19984   echo "$as_me:$LINENO: checking whether the target supports hidden visibility" >&5
19985 echo $ECHO_N "checking whether the target supports hidden visibility... $ECHO_C" >&6
19986 if test "${have_attribute_visibility+set}" = set; then
19987   echo $ECHO_N "(cached) $ECHO_C" >&6
19988 else
19989
19990   save_CFLAGS="$CFLAGS"
19991   CFLAGS="$CFLAGS -Werror"
19992   cat >conftest.$ac_ext <<_ACEOF
19993 /* confdefs.h.  */
19994 _ACEOF
19995 cat confdefs.h >>conftest.$ac_ext
19996 cat >>conftest.$ac_ext <<_ACEOF
19997 /* end confdefs.h.  */
19998 void __attribute__((visibility("hidden"))) foo(void) { }
19999 int
20000 main ()
20001 {
20002
20003   ;
20004   return 0;
20005 }
20006 _ACEOF
20007 rm -f conftest.$ac_objext
20008 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
20009   (eval $ac_compile) 2>conftest.er1
20010   ac_status=$?
20011   grep -v '^ *+' conftest.er1 >conftest.err
20012   rm -f conftest.er1
20013   cat conftest.err >&5
20014   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20015   (exit $ac_status); } &&
20016          { ac_try='test -z "$ac_c_werror_flag"
20017                          || test ! -s conftest.err'
20018   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20019   (eval $ac_try) 2>&5
20020   ac_status=$?
20021   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20022   (exit $ac_status); }; } &&
20023          { ac_try='test -s conftest.$ac_objext'
20024   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20025   (eval $ac_try) 2>&5
20026   ac_status=$?
20027   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20028   (exit $ac_status); }; }; then
20029   have_attribute_visibility=yes
20030 else
20031   echo "$as_me: failed program was:" >&5
20032 sed 's/^/| /' conftest.$ac_ext >&5
20033
20034 have_attribute_visibility=no
20035 fi
20036 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
20037   CFLAGS="$save_CFLAGS"
20038 fi
20039 echo "$as_me:$LINENO: result: $have_attribute_visibility" >&5
20040 echo "${ECHO_T}$have_attribute_visibility" >&6
20041   if test $have_attribute_visibility = yes; then
20042
20043 cat >>confdefs.h <<\_ACEOF
20044 #define HAVE_ATTRIBUTE_VISIBILITY 1
20045 _ACEOF
20046
20047   fi
20048
20049   echo "$as_me:$LINENO: checking whether the target supports dllexport" >&5
20050 echo $ECHO_N "checking whether the target supports dllexport... $ECHO_C" >&6
20051 if test "${have_attribute_dllexport+set}" = set; then
20052   echo $ECHO_N "(cached) $ECHO_C" >&6
20053 else
20054
20055   save_CFLAGS="$CFLAGS"
20056   CFLAGS="$CFLAGS -Werror"
20057   cat >conftest.$ac_ext <<_ACEOF
20058 /* confdefs.h.  */
20059 _ACEOF
20060 cat confdefs.h >>conftest.$ac_ext
20061 cat >>conftest.$ac_ext <<_ACEOF
20062 /* end confdefs.h.  */
20063 void __attribute__((dllexport)) foo(void) { }
20064 int
20065 main ()
20066 {
20067
20068   ;
20069   return 0;
20070 }
20071 _ACEOF
20072 rm -f conftest.$ac_objext
20073 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
20074   (eval $ac_compile) 2>conftest.er1
20075   ac_status=$?
20076   grep -v '^ *+' conftest.er1 >conftest.err
20077   rm -f conftest.er1
20078   cat conftest.err >&5
20079   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20080   (exit $ac_status); } &&
20081          { ac_try='test -z "$ac_c_werror_flag"
20082                          || test ! -s conftest.err'
20083   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20084   (eval $ac_try) 2>&5
20085   ac_status=$?
20086   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20087   (exit $ac_status); }; } &&
20088          { ac_try='test -s conftest.$ac_objext'
20089   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20090   (eval $ac_try) 2>&5
20091   ac_status=$?
20092   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20093   (exit $ac_status); }; }; then
20094   have_attribute_dllexport=yes
20095 else
20096   echo "$as_me: failed program was:" >&5
20097 sed 's/^/| /' conftest.$ac_ext >&5
20098
20099 have_attribute_dllexport=no
20100 fi
20101 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
20102   CFLAGS="$save_CFLAGS"
20103 fi
20104 echo "$as_me:$LINENO: result: $have_attribute_dllexport" >&5
20105 echo "${ECHO_T}$have_attribute_dllexport" >&6
20106   if test $have_attribute_dllexport = yes; then
20107
20108 cat >>confdefs.h <<\_ACEOF
20109 #define HAVE_ATTRIBUTE_DLLEXPORT 1
20110 _ACEOF
20111
20112   fi
20113
20114   echo "$as_me:$LINENO: checking whether the target supports symbol aliases" >&5
20115 echo $ECHO_N "checking whether the target supports symbol aliases... $ECHO_C" >&6
20116 if test "${have_attribute_alias+set}" = set; then
20117   echo $ECHO_N "(cached) $ECHO_C" >&6
20118 else
20119
20120   if test x$gcc_no_link = xyes; then
20121   { { echo "$as_me:$LINENO: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&5
20122 echo "$as_me: error: Link tests are not allowed after GCC_NO_EXECUTABLES." >&2;}
20123    { (exit 1); exit 1; }; }
20124 fi
20125 cat >conftest.$ac_ext <<_ACEOF
20126 /* confdefs.h.  */
20127 _ACEOF
20128 cat confdefs.h >>conftest.$ac_ext
20129 cat >>conftest.$ac_ext <<_ACEOF
20130 /* end confdefs.h.  */
20131
20132 #define ULP     STR1(__USER_LABEL_PREFIX__)
20133 #define STR1(x) STR2(x)
20134 #define STR2(x) #x
20135 void foo(void) { }
20136 extern void bar(void) __attribute__((alias(ULP "foo")));
20137 int
20138 main ()
20139 {
20140 bar();
20141   ;
20142   return 0;
20143 }
20144 _ACEOF
20145 rm -f conftest.$ac_objext conftest$ac_exeext
20146 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20147   (eval $ac_link) 2>conftest.er1
20148   ac_status=$?
20149   grep -v '^ *+' conftest.er1 >conftest.err
20150   rm -f conftest.er1
20151   cat conftest.err >&5
20152   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20153   (exit $ac_status); } &&
20154          { ac_try='test -z "$ac_c_werror_flag"
20155                          || test ! -s conftest.err'
20156   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20157   (eval $ac_try) 2>&5
20158   ac_status=$?
20159   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20160   (exit $ac_status); }; } &&
20161          { ac_try='test -s conftest$ac_exeext'
20162   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20163   (eval $ac_try) 2>&5
20164   ac_status=$?
20165   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20166   (exit $ac_status); }; }; then
20167   have_attribute_alias=yes
20168 else
20169   echo "$as_me: failed program was:" >&5
20170 sed 's/^/| /' conftest.$ac_ext >&5
20171
20172 have_attribute_alias=no
20173 fi
20174 rm -f conftest.err conftest.$ac_objext \
20175       conftest$ac_exeext conftest.$ac_ext
20176 fi
20177 echo "$as_me:$LINENO: result: $have_attribute_alias" >&5
20178 echo "${ECHO_T}$have_attribute_alias" >&6
20179   if test $have_attribute_alias = yes; then
20180
20181 cat >>confdefs.h <<\_ACEOF
20182 #define HAVE_ATTRIBUTE_ALIAS 1
20183 _ACEOF
20184
20185   fi
20186
20187 # Various other checks on target
20188
20189   echo "$as_me:$LINENO: checking whether the target can unlink an open file" >&5
20190 echo $ECHO_N "checking whether the target can unlink an open file... $ECHO_C" >&6
20191 if test "${have_unlink_open_file+set}" = set; then
20192   echo $ECHO_N "(cached) $ECHO_C" >&6
20193 else
20194
20195   if test "$cross_compiling" = yes; then
20196
20197 case "${target}" in
20198   *mingw*) have_unlink_open_file=no ;;
20199   *) have_unlink_open_file=yes;;
20200 esac
20201 else
20202   cat >conftest.$ac_ext <<_ACEOF
20203 /* confdefs.h.  */
20204 _ACEOF
20205 cat confdefs.h >>conftest.$ac_ext
20206 cat >>conftest.$ac_ext <<_ACEOF
20207 /* end confdefs.h.  */
20208
20209 #include <errno.h>
20210 #include <fcntl.h>
20211 #include <unistd.h>
20212 #include <sys/stat.h>
20213
20214 int main ()
20215 {
20216   int fd;
20217
20218   fd = open ("testfile", O_RDWR | O_CREAT, S_IWRITE | S_IREAD);
20219   if (fd <= 0)
20220     return 0;
20221   if (unlink ("testfile") == -1)
20222     return 1;
20223   write (fd, "This is a test\n", 15);
20224   close (fd);
20225
20226   if (open ("testfile", O_RDONLY, S_IWRITE | S_IREAD) == -1 && errno == ENOENT)
20227     return 0;
20228   else
20229     return 1;
20230 }
20231 _ACEOF
20232 rm -f conftest$ac_exeext
20233 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20234   (eval $ac_link) 2>&5
20235   ac_status=$?
20236   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20237   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
20238   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20239   (eval $ac_try) 2>&5
20240   ac_status=$?
20241   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20242   (exit $ac_status); }; }; then
20243   have_unlink_open_file=yes
20244 else
20245   echo "$as_me: program exited with status $ac_status" >&5
20246 echo "$as_me: failed program was:" >&5
20247 sed 's/^/| /' conftest.$ac_ext >&5
20248
20249 ( exit $ac_status )
20250 have_unlink_open_file=no
20251 fi
20252 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
20253 fi
20254 fi
20255 echo "$as_me:$LINENO: result: $have_unlink_open_file" >&5
20256 echo "${ECHO_T}$have_unlink_open_file" >&6
20257 if test x"$have_unlink_open_file" = xyes; then
20258
20259 cat >>confdefs.h <<\_ACEOF
20260 #define HAVE_UNLINK_OPEN_FILE 1
20261 _ACEOF
20262
20263 fi
20264
20265 # Check whether line terminator is LF or CRLF
20266
20267   echo "$as_me:$LINENO: checking whether the target has CRLF as line terminator" >&5
20268 echo $ECHO_N "checking whether the target has CRLF as line terminator... $ECHO_C" >&6
20269 if test "${have_crlf+set}" = set; then
20270   echo $ECHO_N "(cached) $ECHO_C" >&6
20271 else
20272
20273   if test "$cross_compiling" = yes; then
20274
20275 case "${target}" in
20276   *mingw*) have_crlf=yes ;;
20277   *) have_crlf=no;;
20278 esac
20279 else
20280   cat >conftest.$ac_ext <<_ACEOF
20281 /* confdefs.h.  */
20282 _ACEOF
20283 cat confdefs.h >>conftest.$ac_ext
20284 cat >>conftest.$ac_ext <<_ACEOF
20285 /* end confdefs.h.  */
20286
20287 /* This test program should exit with status 0 if system uses a CRLF as
20288    line terminator, and status 1 otherwise.
20289    Since it is used to check for mingw systems, and should return 0 in any
20290    other case, in case of a failure we will not use CRLF.  */
20291 #include <sys/stat.h>
20292 #include <stdlib.h>
20293 #include <fcntl.h>
20294 #include <stdio.h>
20295
20296 int main ()
20297 {
20298 #ifndef O_BINARY
20299   exit(1);
20300 #else
20301   int fd, bytes;
20302   char buff[5];
20303
20304   fd = open ("foo", O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
20305   if (fd < 0)
20306     exit(1);
20307   if (write (fd, "\n", 1) < 0)
20308     perror ("write");
20309
20310   close (fd);
20311
20312   if ((fd = open ("foo", O_RDONLY | O_BINARY, S_IRWXU)) < 0)
20313     exit(1);
20314   bytes = read (fd, buff, 5);
20315   if (bytes == 2 && buff[0] == '\r' && buff[1] == '\n')
20316     exit(0);
20317   else
20318     exit(1);
20319 #endif
20320 }
20321 _ACEOF
20322 rm -f conftest$ac_exeext
20323 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
20324   (eval $ac_link) 2>&5
20325   ac_status=$?
20326   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20327   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
20328   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
20329   (eval $ac_try) 2>&5
20330   ac_status=$?
20331   echo "$as_me:$LINENO: \$? = $ac_status" >&5
20332   (exit $ac_status); }; }; then
20333   have_crlf=yes
20334 else
20335   echo "$as_me: program exited with status $ac_status" >&5
20336 echo "$as_me: failed program was:" >&5
20337 sed 's/^/| /' conftest.$ac_ext >&5
20338
20339 ( exit $ac_status )
20340 have_crlf=no
20341 fi
20342 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
20343 fi
20344 fi
20345 echo "$as_me:$LINENO: result: $have_crlf" >&5
20346 echo "${ECHO_T}$have_crlf" >&6
20347 if test x"$have_crlf" = xyes; then
20348
20349 cat >>confdefs.h <<\_ACEOF
20350 #define HAVE_CRLF 1
20351 _ACEOF
20352
20353 fi
20354
20355 cat >confcache <<\_ACEOF
20356 # This file is a shell script that caches the results of configure
20357 # tests run on this system so they can be shared between configure
20358 # scripts and configure runs, see configure's option --config-cache.
20359 # It is not useful on other systems.  If it contains results you don't
20360 # want to keep, you may remove or edit it.
20361 #
20362 # config.status only pays attention to the cache file if you give it
20363 # the --recheck option to rerun configure.
20364 #
20365 # `ac_cv_env_foo' variables (set or unset) will be overridden when
20366 # loading this file, other *unset* `ac_cv_foo' will be assigned the
20367 # following values.
20368
20369 _ACEOF
20370
20371 # The following way of writing the cache mishandles newlines in values,
20372 # but we know of no workaround that is simple, portable, and efficient.
20373 # So, don't put newlines in cache variables' values.
20374 # Ultrix sh set writes to stderr and can't be redirected directly,
20375 # and sets the high bit in the cache file unless we assign to the vars.
20376 {
20377   (set) 2>&1 |
20378     case `(ac_space=' '; set | grep ac_space) 2>&1` in
20379     *ac_space=\ *)
20380       # `set' does not quote correctly, so add quotes (double-quote
20381       # substitution turns \\\\ into \\, and sed turns \\ into \).
20382       sed -n \
20383         "s/'/'\\\\''/g;
20384           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
20385       ;;
20386     *)
20387       # `set' quotes correctly as required by POSIX, so do not add quotes.
20388       sed -n \
20389         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
20390       ;;
20391     esac;
20392 } |
20393   sed '
20394      t clear
20395      : clear
20396      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
20397      t end
20398      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
20399      : end' >>confcache
20400 if diff $cache_file confcache >/dev/null 2>&1; then :; else
20401   if test -w $cache_file; then
20402     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
20403     cat confcache >$cache_file
20404   else
20405     echo "not updating unwritable cache $cache_file"
20406   fi
20407 fi
20408 rm -f confcache
20409
20410 if test ${multilib} = yes; then
20411   multilib_arg="--enable-multilib"
20412 else
20413   multilib_arg=
20414 fi
20415
20416 # Write our Makefile.
20417           ac_config_files="$ac_config_files Makefile"
20418
20419 cat >confcache <<\_ACEOF
20420 # This file is a shell script that caches the results of configure
20421 # tests run on this system so they can be shared between configure
20422 # scripts and configure runs, see configure's option --config-cache.
20423 # It is not useful on other systems.  If it contains results you don't
20424 # want to keep, you may remove or edit it.
20425 #
20426 # config.status only pays attention to the cache file if you give it
20427 # the --recheck option to rerun configure.
20428 #
20429 # `ac_cv_env_foo' variables (set or unset) will be overridden when
20430 # loading this file, other *unset* `ac_cv_foo' will be assigned the
20431 # following values.
20432
20433 _ACEOF
20434
20435 # The following way of writing the cache mishandles newlines in values,
20436 # but we know of no workaround that is simple, portable, and efficient.
20437 # So, don't put newlines in cache variables' values.
20438 # Ultrix sh set writes to stderr and can't be redirected directly,
20439 # and sets the high bit in the cache file unless we assign to the vars.
20440 {
20441   (set) 2>&1 |
20442     case `(ac_space=' '; set | grep ac_space) 2>&1` in
20443     *ac_space=\ *)
20444       # `set' does not quote correctly, so add quotes (double-quote
20445       # substitution turns \\\\ into \\, and sed turns \\ into \).
20446       sed -n \
20447         "s/'/'\\\\''/g;
20448           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
20449       ;;
20450     *)
20451       # `set' quotes correctly as required by POSIX, so do not add quotes.
20452       sed -n \
20453         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
20454       ;;
20455     esac;
20456 } |
20457   sed '
20458      t clear
20459      : clear
20460      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
20461      t end
20462      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
20463      : end' >>confcache
20464 if diff $cache_file confcache >/dev/null 2>&1; then :; else
20465   if test -w $cache_file; then
20466     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
20467     cat confcache >$cache_file
20468   else
20469     echo "not updating unwritable cache $cache_file"
20470   fi
20471 fi
20472 rm -f confcache
20473
20474 test "x$prefix" = xNONE && prefix=$ac_default_prefix
20475 # Let make expand exec_prefix.
20476 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
20477
20478 # VPATH may cause trouble with some makes, so we remove $(srcdir),
20479 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
20480 # trailing colons and then remove the whole line if VPATH becomes empty
20481 # (actually we leave an empty line to preserve line numbers).
20482 if test "x$srcdir" = x.; then
20483   ac_vpsub='/^[  ]*VPATH[        ]*=/{
20484 s/:*\$(srcdir):*/:/;
20485 s/:*\${srcdir}:*/:/;
20486 s/:*@srcdir@:*/:/;
20487 s/^\([^=]*=[     ]*\):*/\1/;
20488 s/:*$//;
20489 s/^[^=]*=[       ]*$//;
20490 }'
20491 fi
20492
20493 DEFS=-DHAVE_CONFIG_H
20494
20495 ac_libobjs=
20496 ac_ltlibobjs=
20497 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
20498   # 1. Remove the extension, and $U if already installed.
20499   ac_i=`echo "$ac_i" |
20500          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
20501   # 2. Add them.
20502   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
20503   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
20504 done
20505 LIBOBJS=$ac_libobjs
20506
20507 LTLIBOBJS=$ac_ltlibobjs
20508
20509
20510 if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then
20511   { { echo "$as_me:$LINENO: error: conditional \"MAINTAINER_MODE\" was never defined.
20512 Usually this means the macro was only invoked conditionally." >&5
20513 echo "$as_me: error: conditional \"MAINTAINER_MODE\" was never defined.
20514 Usually this means the macro was only invoked conditionally." >&2;}
20515    { (exit 1); exit 1; }; }
20516 fi
20517
20518 : ${CONFIG_STATUS=./config.status}
20519 ac_clean_files_save=$ac_clean_files
20520 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
20521 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
20522 echo "$as_me: creating $CONFIG_STATUS" >&6;}
20523 cat >$CONFIG_STATUS <<_ACEOF
20524 #! $SHELL
20525 # Generated by $as_me.
20526 # Run this file to recreate the current configuration.
20527 # Compiler output produced by configure, useful for debugging
20528 # configure, is in config.log if it exists.
20529
20530 debug=false
20531 ac_cs_recheck=false
20532 ac_cs_silent=false
20533 SHELL=\${CONFIG_SHELL-$SHELL}
20534 _ACEOF
20535
20536 cat >>$CONFIG_STATUS <<\_ACEOF
20537 ## --------------------- ##
20538 ## M4sh Initialization.  ##
20539 ## --------------------- ##
20540
20541 # Be Bourne compatible
20542 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
20543   emulate sh
20544   NULLCMD=:
20545   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
20546   # is contrary to our usage.  Disable this feature.
20547   alias -g '${1+"$@"}'='"$@"'
20548 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
20549   set -o posix
20550 fi
20551 DUALCASE=1; export DUALCASE # for MKS sh
20552
20553 # Support unset when possible.
20554 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
20555   as_unset=unset
20556 else
20557   as_unset=false
20558 fi
20559
20560
20561 # Work around bugs in pre-3.0 UWIN ksh.
20562 $as_unset ENV MAIL MAILPATH
20563 PS1='$ '
20564 PS2='> '
20565 PS4='+ '
20566
20567 # NLS nuisances.
20568 for as_var in \
20569   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
20570   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
20571   LC_TELEPHONE LC_TIME
20572 do
20573   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
20574     eval $as_var=C; export $as_var
20575   else
20576     $as_unset $as_var
20577   fi
20578 done
20579
20580 # Required to use basename.
20581 if expr a : '\(a\)' >/dev/null 2>&1; then
20582   as_expr=expr
20583 else
20584   as_expr=false
20585 fi
20586
20587 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
20588   as_basename=basename
20589 else
20590   as_basename=false
20591 fi
20592
20593
20594 # Name of the executable.
20595 as_me=`$as_basename "$0" ||
20596 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
20597          X"$0" : 'X\(//\)$' \| \
20598          X"$0" : 'X\(/\)$' \| \
20599          .     : '\(.\)' 2>/dev/null ||
20600 echo X/"$0" |
20601     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
20602           /^X\/\(\/\/\)$/{ s//\1/; q; }
20603           /^X\/\(\/\).*/{ s//\1/; q; }
20604           s/.*/./; q'`
20605
20606
20607 # PATH needs CR, and LINENO needs CR and PATH.
20608 # Avoid depending upon Character Ranges.
20609 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
20610 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
20611 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
20612 as_cr_digits='0123456789'
20613 as_cr_alnum=$as_cr_Letters$as_cr_digits
20614
20615 # The user is always right.
20616 if test "${PATH_SEPARATOR+set}" != set; then
20617   echo "#! /bin/sh" >conf$$.sh
20618   echo  "exit 0"   >>conf$$.sh
20619   chmod +x conf$$.sh
20620   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
20621     PATH_SEPARATOR=';'
20622   else
20623     PATH_SEPARATOR=:
20624   fi
20625   rm -f conf$$.sh
20626 fi
20627
20628
20629   as_lineno_1=$LINENO
20630   as_lineno_2=$LINENO
20631   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
20632   test "x$as_lineno_1" != "x$as_lineno_2" &&
20633   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
20634   # Find who we are.  Look in the path if we contain no path at all
20635   # relative or not.
20636   case $0 in
20637     *[\\/]* ) as_myself=$0 ;;
20638     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20639 for as_dir in $PATH
20640 do
20641   IFS=$as_save_IFS
20642   test -z "$as_dir" && as_dir=.
20643   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
20644 done
20645
20646        ;;
20647   esac
20648   # We did not find ourselves, most probably we were run as `sh COMMAND'
20649   # in which case we are not to be found in the path.
20650   if test "x$as_myself" = x; then
20651     as_myself=$0
20652   fi
20653   if test ! -f "$as_myself"; then
20654     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
20655 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
20656    { (exit 1); exit 1; }; }
20657   fi
20658   case $CONFIG_SHELL in
20659   '')
20660     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
20661 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
20662 do
20663   IFS=$as_save_IFS
20664   test -z "$as_dir" && as_dir=.
20665   for as_base in sh bash ksh sh5; do
20666          case $as_dir in
20667          /*)
20668            if ("$as_dir/$as_base" -c '
20669   as_lineno_1=$LINENO
20670   as_lineno_2=$LINENO
20671   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
20672   test "x$as_lineno_1" != "x$as_lineno_2" &&
20673   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
20674              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
20675              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
20676              CONFIG_SHELL=$as_dir/$as_base
20677              export CONFIG_SHELL
20678              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
20679            fi;;
20680          esac
20681        done
20682 done
20683 ;;
20684   esac
20685
20686   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
20687   # uniformly replaced by the line number.  The first 'sed' inserts a
20688   # line-number line before each line; the second 'sed' does the real
20689   # work.  The second script uses 'N' to pair each line-number line
20690   # with the numbered line, and appends trailing '-' during
20691   # substitution so that $LINENO is not a special case at line end.
20692   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
20693   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
20694   sed '=' <$as_myself |
20695     sed '
20696       N
20697       s,$,-,
20698       : loop
20699       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
20700       t loop
20701       s,-$,,
20702       s,^['$as_cr_digits']*\n,,
20703     ' >$as_me.lineno &&
20704   chmod +x $as_me.lineno ||
20705     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
20706 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
20707    { (exit 1); exit 1; }; }
20708
20709   # Don't try to exec as it changes $[0], causing all sort of problems
20710   # (the dirname of $[0] is not the place where we might find the
20711   # original and so on.  Autoconf is especially sensible to this).
20712   . ./$as_me.lineno
20713   # Exit status is that of the last command.
20714   exit
20715 }
20716
20717
20718 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
20719   *c*,-n*) ECHO_N= ECHO_C='
20720 ' ECHO_T='      ' ;;
20721   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
20722   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
20723 esac
20724
20725 if expr a : '\(a\)' >/dev/null 2>&1; then
20726   as_expr=expr
20727 else
20728   as_expr=false
20729 fi
20730
20731 rm -f conf$$ conf$$.exe conf$$.file
20732 echo >conf$$.file
20733 if ln -s conf$$.file conf$$ 2>/dev/null; then
20734   # We could just check for DJGPP; but this test a) works b) is more generic
20735   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
20736   if test -f conf$$.exe; then
20737     # Don't use ln at all; we don't have any links
20738     as_ln_s='cp -p'
20739   else
20740     as_ln_s='ln -s'
20741   fi
20742 elif ln conf$$.file conf$$ 2>/dev/null; then
20743   as_ln_s=ln
20744 else
20745   as_ln_s='cp -p'
20746 fi
20747 rm -f conf$$ conf$$.exe conf$$.file
20748
20749 if mkdir -p . 2>/dev/null; then
20750   as_mkdir_p=:
20751 else
20752   test -d ./-p && rmdir ./-p
20753   as_mkdir_p=false
20754 fi
20755
20756 as_executable_p="test -f"
20757
20758 # Sed expression to map a string onto a valid CPP name.
20759 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
20760
20761 # Sed expression to map a string onto a valid variable name.
20762 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
20763
20764
20765 # IFS
20766 # We need space, tab and new line, in precisely that order.
20767 as_nl='
20768 '
20769 IFS="   $as_nl"
20770
20771 # CDPATH.
20772 $as_unset CDPATH
20773
20774 exec 6>&1
20775
20776 # Open the log real soon, to keep \$[0] and so on meaningful, and to
20777 # report actual input values of CONFIG_FILES etc. instead of their
20778 # values after options handling.  Logging --version etc. is OK.
20779 exec 5>>config.log
20780 {
20781   echo
20782   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
20783 ## Running $as_me. ##
20784 _ASBOX
20785 } >&5
20786 cat >&5 <<_CSEOF
20787
20788 This file was extended by GNU Fortran Runtime Library $as_me 0.2, which was
20789 generated by GNU Autoconf 2.59.  Invocation command line was
20790
20791   CONFIG_FILES    = $CONFIG_FILES
20792   CONFIG_HEADERS  = $CONFIG_HEADERS
20793   CONFIG_LINKS    = $CONFIG_LINKS
20794   CONFIG_COMMANDS = $CONFIG_COMMANDS
20795   $ $0 $@
20796
20797 _CSEOF
20798 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
20799 echo >&5
20800 _ACEOF
20801
20802 # Files that config.status was made for.
20803 if test -n "$ac_config_files"; then
20804   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
20805 fi
20806
20807 if test -n "$ac_config_headers"; then
20808   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
20809 fi
20810
20811 if test -n "$ac_config_links"; then
20812   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
20813 fi
20814
20815 if test -n "$ac_config_commands"; then
20816   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
20817 fi
20818
20819 cat >>$CONFIG_STATUS <<\_ACEOF
20820
20821 ac_cs_usage="\
20822 \`$as_me' instantiates files from templates according to the
20823 current configuration.
20824
20825 Usage: $0 [OPTIONS] [FILE]...
20826
20827   -h, --help       print this help, then exit
20828   -V, --version    print version number, then exit
20829   -q, --quiet      do not print progress messages
20830   -d, --debug      don't remove temporary files
20831       --recheck    update $as_me by reconfiguring in the same conditions
20832   --file=FILE[:TEMPLATE]
20833                    instantiate the configuration file FILE
20834   --header=FILE[:TEMPLATE]
20835                    instantiate the configuration header FILE
20836
20837 Configuration files:
20838 $config_files
20839
20840 Configuration headers:
20841 $config_headers
20842
20843 Configuration commands:
20844 $config_commands
20845
20846 Report bugs to <bug-autoconf@gnu.org>."
20847 _ACEOF
20848
20849 cat >>$CONFIG_STATUS <<_ACEOF
20850 ac_cs_version="\\
20851 GNU Fortran Runtime Library config.status 0.2
20852 configured by $0, generated by GNU Autoconf 2.59,
20853   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
20854
20855 Copyright (C) 2003 Free Software Foundation, Inc.
20856 This config.status script is free software; the Free Software Foundation
20857 gives unlimited permission to copy, distribute and modify it."
20858 srcdir=$srcdir
20859 INSTALL="$INSTALL"
20860 _ACEOF
20861
20862 cat >>$CONFIG_STATUS <<\_ACEOF
20863 # If no file are specified by the user, then we need to provide default
20864 # value.  By we need to know if files were specified by the user.
20865 ac_need_defaults=:
20866 while test $# != 0
20867 do
20868   case $1 in
20869   --*=*)
20870     ac_option=`expr "x$1" : 'x\([^=]*\)='`
20871     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
20872     ac_shift=:
20873     ;;
20874   -*)
20875     ac_option=$1
20876     ac_optarg=$2
20877     ac_shift=shift
20878     ;;
20879   *) # This is not an option, so the user has probably given explicit
20880      # arguments.
20881      ac_option=$1
20882      ac_need_defaults=false;;
20883   esac
20884
20885   case $ac_option in
20886   # Handling of the options.
20887 _ACEOF
20888 cat >>$CONFIG_STATUS <<\_ACEOF
20889   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
20890     ac_cs_recheck=: ;;
20891   --version | --vers* | -V )
20892     echo "$ac_cs_version"; exit 0 ;;
20893   --he | --h)
20894     # Conflict between --help and --header
20895     { { echo "$as_me:$LINENO: error: ambiguous option: $1
20896 Try \`$0 --help' for more information." >&5
20897 echo "$as_me: error: ambiguous option: $1
20898 Try \`$0 --help' for more information." >&2;}
20899    { (exit 1); exit 1; }; };;
20900   --help | --hel | -h )
20901     echo "$ac_cs_usage"; exit 0 ;;
20902   --debug | --d* | -d )
20903     debug=: ;;
20904   --file | --fil | --fi | --f )
20905     $ac_shift
20906     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
20907     ac_need_defaults=false;;
20908   --header | --heade | --head | --hea )
20909     $ac_shift
20910     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
20911     ac_need_defaults=false;;
20912   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
20913   | -silent | --silent | --silen | --sile | --sil | --si | --s)
20914     ac_cs_silent=: ;;
20915
20916   # This is an error.
20917   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
20918 Try \`$0 --help' for more information." >&5
20919 echo "$as_me: error: unrecognized option: $1
20920 Try \`$0 --help' for more information." >&2;}
20921    { (exit 1); exit 1; }; } ;;
20922
20923   *) ac_config_targets="$ac_config_targets $1" ;;
20924
20925   esac
20926   shift
20927 done
20928
20929 ac_configure_extra_args=
20930
20931 if $ac_cs_silent; then
20932   exec 6>/dev/null
20933   ac_configure_extra_args="$ac_configure_extra_args --silent"
20934 fi
20935
20936 _ACEOF
20937 cat >>$CONFIG_STATUS <<_ACEOF
20938 if \$ac_cs_recheck; then
20939   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
20940   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
20941 fi
20942
20943 _ACEOF
20944
20945 cat >>$CONFIG_STATUS <<_ACEOF
20946 #
20947 # INIT-COMMANDS section.
20948 #
20949
20950
20951 srcdir="$srcdir"
20952 host="$host"
20953 target="$target"
20954 with_multisubdir="$with_multisubdir"
20955 with_multisrctop="$with_multisrctop"
20956 with_target_subdir="$with_target_subdir"
20957 ac_configure_args="${multilib_arg} ${ac_configure_args}"
20958 multi_basedir="$multi_basedir"
20959 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
20960 CC="$CC"
20961
20962 _ACEOF
20963
20964
20965
20966 cat >>$CONFIG_STATUS <<\_ACEOF
20967 for ac_config_target in $ac_config_targets
20968 do
20969   case "$ac_config_target" in
20970   # Handling of arguments.
20971   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
20972   "default-1" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default-1" ;;
20973   "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
20974   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
20975 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
20976    { (exit 1); exit 1; }; };;
20977   esac
20978 done
20979
20980 # If the user did not use the arguments to specify the items to instantiate,
20981 # then the envvar interface is used.  Set only those that are not.
20982 # We use the long form for the default assignment because of an extremely
20983 # bizarre bug on SunOS 4.1.3.
20984 if $ac_need_defaults; then
20985   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
20986   test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
20987   test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
20988 fi
20989
20990 # Have a temporary directory for convenience.  Make it in the build tree
20991 # simply because there is no reason to put it here, and in addition,
20992 # creating and moving files from /tmp can sometimes cause problems.
20993 # Create a temporary directory, and hook for its removal unless debugging.
20994 $debug ||
20995 {
20996   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
20997   trap '{ (exit 1); exit 1; }' 1 2 13 15
20998 }
20999
21000 # Create a (secure) tmp directory for tmp files.
21001
21002 {
21003   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
21004   test -n "$tmp" && test -d "$tmp"
21005 }  ||
21006 {
21007   tmp=./confstat$$-$RANDOM
21008   (umask 077 && mkdir $tmp)
21009 } ||
21010 {
21011    echo "$me: cannot create a temporary directory in ." >&2
21012    { (exit 1); exit 1; }
21013 }
21014
21015 _ACEOF
21016
21017 cat >>$CONFIG_STATUS <<_ACEOF
21018
21019 #
21020 # CONFIG_FILES section.
21021 #
21022
21023 # No need to generate the scripts if there are no CONFIG_FILES.
21024 # This happens for instance when ./config.status config.h
21025 if test -n "\$CONFIG_FILES"; then
21026   # Protect against being on the right side of a sed subst in config.status.
21027   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
21028    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
21029 s,@SHELL@,$SHELL,;t t
21030 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
21031 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
21032 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
21033 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
21034 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
21035 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
21036 s,@exec_prefix@,$exec_prefix,;t t
21037 s,@prefix@,$prefix,;t t
21038 s,@program_transform_name@,$program_transform_name,;t t
21039 s,@bindir@,$bindir,;t t
21040 s,@sbindir@,$sbindir,;t t
21041 s,@libexecdir@,$libexecdir,;t t
21042 s,@datadir@,$datadir,;t t
21043 s,@sysconfdir@,$sysconfdir,;t t
21044 s,@sharedstatedir@,$sharedstatedir,;t t
21045 s,@localstatedir@,$localstatedir,;t t
21046 s,@libdir@,$libdir,;t t
21047 s,@includedir@,$includedir,;t t
21048 s,@oldincludedir@,$oldincludedir,;t t
21049 s,@infodir@,$infodir,;t t
21050 s,@mandir@,$mandir,;t t
21051 s,@build_alias@,$build_alias,;t t
21052 s,@host_alias@,$host_alias,;t t
21053 s,@target_alias@,$target_alias,;t t
21054 s,@DEFS@,$DEFS,;t t
21055 s,@ECHO_C@,$ECHO_C,;t t
21056 s,@ECHO_N@,$ECHO_N,;t t
21057 s,@ECHO_T@,$ECHO_T,;t t
21058 s,@LIBS@,$LIBS,;t t
21059 s,@build@,$build,;t t
21060 s,@build_cpu@,$build_cpu,;t t
21061 s,@build_vendor@,$build_vendor,;t t
21062 s,@build_os@,$build_os,;t t
21063 s,@host@,$host,;t t
21064 s,@host_cpu@,$host_cpu,;t t
21065 s,@host_vendor@,$host_vendor,;t t
21066 s,@host_os@,$host_os,;t t
21067 s,@target@,$target,;t t
21068 s,@target_cpu@,$target_cpu,;t t
21069 s,@target_vendor@,$target_vendor,;t t
21070 s,@target_os@,$target_os,;t t
21071 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
21072 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
21073 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
21074 s,@CYGPATH_W@,$CYGPATH_W,;t t
21075 s,@PACKAGE@,$PACKAGE,;t t
21076 s,@VERSION@,$VERSION,;t t
21077 s,@ACLOCAL@,$ACLOCAL,;t t
21078 s,@AUTOCONF@,$AUTOCONF,;t t
21079 s,@AUTOMAKE@,$AUTOMAKE,;t t
21080 s,@AUTOHEADER@,$AUTOHEADER,;t t
21081 s,@MAKEINFO@,$MAKEINFO,;t t
21082 s,@install_sh@,$install_sh,;t t
21083 s,@STRIP@,$STRIP,;t t
21084 s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t
21085 s,@INSTALL_STRIP_PROGRAM@,$INSTALL_STRIP_PROGRAM,;t t
21086 s,@mkdir_p@,$mkdir_p,;t t
21087 s,@AWK@,$AWK,;t t
21088 s,@SET_MAKE@,$SET_MAKE,;t t
21089 s,@am__leading_dot@,$am__leading_dot,;t t
21090 s,@AMTAR@,$AMTAR,;t t
21091 s,@am__tar@,$am__tar,;t t
21092 s,@am__untar@,$am__untar,;t t
21093 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
21094 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
21095 s,@MAINT@,$MAINT,;t t
21096 s,@multi_basedir@,$multi_basedir,;t t
21097 s,@toolexecdir@,$toolexecdir,;t t
21098 s,@toolexeclibdir@,$toolexeclibdir,;t t
21099 s,@CC@,$CC,;t t
21100 s,@ac_ct_CC@,$ac_ct_CC,;t t
21101 s,@EXEEXT@,$EXEEXT,;t t
21102 s,@OBJEXT@,$OBJEXT,;t t
21103 s,@AM_FCFLAGS@,$AM_FCFLAGS,;t t
21104 s,@AM_CFLAGS@,$AM_CFLAGS,;t t
21105 s,@AS@,$AS,;t t
21106 s,@ac_ct_AS@,$ac_ct_AS,;t t
21107 s,@AR@,$AR,;t t
21108 s,@ac_ct_AR@,$ac_ct_AR,;t t
21109 s,@RANLIB@,$RANLIB,;t t
21110 s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
21111 s,@LN_S@,$LN_S,;t t
21112 s,@LIBTOOL@,$LIBTOOL,;t t
21113 s,@enable_shared@,$enable_shared,;t t
21114 s,@enable_static@,$enable_static,;t t
21115 s,@FC@,$FC,;t t
21116 s,@FCFLAGS@,$FCFLAGS,;t t
21117 s,@LDFLAGS@,$LDFLAGS,;t t
21118 s,@ac_ct_FC@,$ac_ct_FC,;t t
21119 s,@extra_ldflags_libgfortran@,$extra_ldflags_libgfortran,;t t
21120 s,@CPP@,$CPP,;t t
21121 s,@CPPFLAGS@,$CPPFLAGS,;t t
21122 s,@EGREP@,$EGREP,;t t
21123 s,@FPU_HOST_HEADER@,$FPU_HOST_HEADER,;t t
21124 s,@LIBOBJS@,$LIBOBJS,;t t
21125 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
21126 CEOF
21127
21128 _ACEOF
21129
21130   cat >>$CONFIG_STATUS <<\_ACEOF
21131   # Split the substitutions into bite-sized pieces for seds with
21132   # small command number limits, like on Digital OSF/1 and HP-UX.
21133   ac_max_sed_lines=48
21134   ac_sed_frag=1 # Number of current file.
21135   ac_beg=1 # First line for current file.
21136   ac_end=$ac_max_sed_lines # Line after last line for current file.
21137   ac_more_lines=:
21138   ac_sed_cmds=
21139   while $ac_more_lines; do
21140     if test $ac_beg -gt 1; then
21141       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
21142     else
21143       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
21144     fi
21145     if test ! -s $tmp/subs.frag; then
21146       ac_more_lines=false
21147     else
21148       # The purpose of the label and of the branching condition is to
21149       # speed up the sed processing (if there are no `@' at all, there
21150       # is no need to browse any of the substitutions).
21151       # These are the two extra sed commands mentioned above.
21152       (echo ':t
21153   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
21154       if test -z "$ac_sed_cmds"; then
21155         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
21156       else
21157         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
21158       fi
21159       ac_sed_frag=`expr $ac_sed_frag + 1`
21160       ac_beg=$ac_end
21161       ac_end=`expr $ac_end + $ac_max_sed_lines`
21162     fi
21163   done
21164   if test -z "$ac_sed_cmds"; then
21165     ac_sed_cmds=cat
21166   fi
21167 fi # test -n "$CONFIG_FILES"
21168
21169 _ACEOF
21170 cat >>$CONFIG_STATUS <<\_ACEOF
21171 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
21172   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
21173   case $ac_file in
21174   - | *:- | *:-:* ) # input from stdin
21175         cat >$tmp/stdin
21176         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
21177         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
21178   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
21179         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
21180   * )   ac_file_in=$ac_file.in ;;
21181   esac
21182
21183   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
21184   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
21185 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
21186          X"$ac_file" : 'X\(//\)[^/]' \| \
21187          X"$ac_file" : 'X\(//\)$' \| \
21188          X"$ac_file" : 'X\(/\)' \| \
21189          .     : '\(.\)' 2>/dev/null ||
21190 echo X"$ac_file" |
21191     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
21192           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
21193           /^X\(\/\/\)$/{ s//\1/; q; }
21194           /^X\(\/\).*/{ s//\1/; q; }
21195           s/.*/./; q'`
21196   { if $as_mkdir_p; then
21197     mkdir -p "$ac_dir"
21198   else
21199     as_dir="$ac_dir"
21200     as_dirs=
21201     while test ! -d "$as_dir"; do
21202       as_dirs="$as_dir $as_dirs"
21203       as_dir=`(dirname "$as_dir") 2>/dev/null ||
21204 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
21205          X"$as_dir" : 'X\(//\)[^/]' \| \
21206          X"$as_dir" : 'X\(//\)$' \| \
21207          X"$as_dir" : 'X\(/\)' \| \
21208          .     : '\(.\)' 2>/dev/null ||
21209 echo X"$as_dir" |
21210     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
21211           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
21212           /^X\(\/\/\)$/{ s//\1/; q; }
21213           /^X\(\/\).*/{ s//\1/; q; }
21214           s/.*/./; q'`
21215     done
21216     test ! -n "$as_dirs" || mkdir $as_dirs
21217   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
21218 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
21219    { (exit 1); exit 1; }; }; }
21220
21221   ac_builddir=.
21222
21223 if test "$ac_dir" != .; then
21224   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
21225   # A "../" for each directory in $ac_dir_suffix.
21226   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
21227 else
21228   ac_dir_suffix= ac_top_builddir=
21229 fi
21230
21231 case $srcdir in
21232   .)  # No --srcdir option.  We are building in place.
21233     ac_srcdir=.
21234     if test -z "$ac_top_builddir"; then
21235        ac_top_srcdir=.
21236     else
21237        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
21238     fi ;;
21239   [\\/]* | ?:[\\/]* )  # Absolute path.
21240     ac_srcdir=$srcdir$ac_dir_suffix;
21241     ac_top_srcdir=$srcdir ;;
21242   *) # Relative path.
21243     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
21244     ac_top_srcdir=$ac_top_builddir$srcdir ;;
21245 esac
21246
21247 # Do not use `cd foo && pwd` to compute absolute paths, because
21248 # the directories may not exist.
21249 case `pwd` in
21250 .) ac_abs_builddir="$ac_dir";;
21251 *)
21252   case "$ac_dir" in
21253   .) ac_abs_builddir=`pwd`;;
21254   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
21255   *) ac_abs_builddir=`pwd`/"$ac_dir";;
21256   esac;;
21257 esac
21258 case $ac_abs_builddir in
21259 .) ac_abs_top_builddir=${ac_top_builddir}.;;
21260 *)
21261   case ${ac_top_builddir}. in
21262   .) ac_abs_top_builddir=$ac_abs_builddir;;
21263   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
21264   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
21265   esac;;
21266 esac
21267 case $ac_abs_builddir in
21268 .) ac_abs_srcdir=$ac_srcdir;;
21269 *)
21270   case $ac_srcdir in
21271   .) ac_abs_srcdir=$ac_abs_builddir;;
21272   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
21273   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
21274   esac;;
21275 esac
21276 case $ac_abs_builddir in
21277 .) ac_abs_top_srcdir=$ac_top_srcdir;;
21278 *)
21279   case $ac_top_srcdir in
21280   .) ac_abs_top_srcdir=$ac_abs_builddir;;
21281   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
21282   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
21283   esac;;
21284 esac
21285
21286
21287   case $INSTALL in
21288   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
21289   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
21290   esac
21291
21292   if test x"$ac_file" != x-; then
21293     { echo "$as_me:$LINENO: creating $ac_file" >&5
21294 echo "$as_me: creating $ac_file" >&6;}
21295     rm -f "$ac_file"
21296   fi
21297   # Let's still pretend it is `configure' which instantiates (i.e., don't
21298   # use $as_me), people would be surprised to read:
21299   #    /* config.h.  Generated by config.status.  */
21300   if test x"$ac_file" = x-; then
21301     configure_input=
21302   else
21303     configure_input="$ac_file.  "
21304   fi
21305   configure_input=$configure_input"Generated from `echo $ac_file_in |
21306                                      sed 's,.*/,,'` by configure."
21307
21308   # First look for the input files in the build tree, otherwise in the
21309   # src tree.
21310   ac_file_inputs=`IFS=:
21311     for f in $ac_file_in; do
21312       case $f in
21313       -) echo $tmp/stdin ;;
21314       [\\/$]*)
21315          # Absolute (can't be DOS-style, as IFS=:)
21316          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
21317 echo "$as_me: error: cannot find input file: $f" >&2;}
21318    { (exit 1); exit 1; }; }
21319          echo "$f";;
21320       *) # Relative
21321          if test -f "$f"; then
21322            # Build tree
21323            echo "$f"
21324          elif test -f "$srcdir/$f"; then
21325            # Source tree
21326            echo "$srcdir/$f"
21327          else
21328            # /dev/null tree
21329            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
21330 echo "$as_me: error: cannot find input file: $f" >&2;}
21331    { (exit 1); exit 1; }; }
21332          fi;;
21333       esac
21334     done` || { (exit 1); exit 1; }
21335 _ACEOF
21336 cat >>$CONFIG_STATUS <<_ACEOF
21337   sed "$ac_vpsub
21338 $extrasub
21339 _ACEOF
21340 cat >>$CONFIG_STATUS <<\_ACEOF
21341 :t
21342 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
21343 s,@configure_input@,$configure_input,;t t
21344 s,@srcdir@,$ac_srcdir,;t t
21345 s,@abs_srcdir@,$ac_abs_srcdir,;t t
21346 s,@top_srcdir@,$ac_top_srcdir,;t t
21347 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
21348 s,@builddir@,$ac_builddir,;t t
21349 s,@abs_builddir@,$ac_abs_builddir,;t t
21350 s,@top_builddir@,$ac_top_builddir,;t t
21351 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
21352 s,@INSTALL@,$ac_INSTALL,;t t
21353 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
21354   rm -f $tmp/stdin
21355   if test x"$ac_file" != x-; then
21356     mv $tmp/out $ac_file
21357   else
21358     cat $tmp/out
21359     rm -f $tmp/out
21360   fi
21361
21362 done
21363 _ACEOF
21364 cat >>$CONFIG_STATUS <<\_ACEOF
21365
21366 #
21367 # CONFIG_HEADER section.
21368 #
21369
21370 # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
21371 # NAME is the cpp macro being defined and VALUE is the value it is being given.
21372 #
21373 # ac_d sets the value in "#define NAME VALUE" lines.
21374 ac_dA='s,^\([    ]*\)#\([        ]*define[       ][      ]*\)'
21375 ac_dB='[         ].*$,\1#\2'
21376 ac_dC=' '
21377 ac_dD=',;t'
21378 # ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
21379 ac_uA='s,^\([    ]*\)#\([        ]*\)undef\([    ][      ]*\)'
21380 ac_uB='$,\1#\2define\3'
21381 ac_uC=' '
21382 ac_uD=',;t'
21383
21384 for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue
21385   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
21386   case $ac_file in
21387   - | *:- | *:-:* ) # input from stdin
21388         cat >$tmp/stdin
21389         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
21390         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
21391   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
21392         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
21393   * )   ac_file_in=$ac_file.in ;;
21394   esac
21395
21396   test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5
21397 echo "$as_me: creating $ac_file" >&6;}
21398
21399   # First look for the input files in the build tree, otherwise in the
21400   # src tree.
21401   ac_file_inputs=`IFS=:
21402     for f in $ac_file_in; do
21403       case $f in
21404       -) echo $tmp/stdin ;;
21405       [\\/$]*)
21406          # Absolute (can't be DOS-style, as IFS=:)
21407          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
21408 echo "$as_me: error: cannot find input file: $f" >&2;}
21409    { (exit 1); exit 1; }; }
21410          # Do quote $f, to prevent DOS paths from being IFS'd.
21411          echo "$f";;
21412       *) # Relative
21413          if test -f "$f"; then
21414            # Build tree
21415            echo "$f"
21416          elif test -f "$srcdir/$f"; then
21417            # Source tree
21418            echo "$srcdir/$f"
21419          else
21420            # /dev/null tree
21421            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
21422 echo "$as_me: error: cannot find input file: $f" >&2;}
21423    { (exit 1); exit 1; }; }
21424          fi;;
21425       esac
21426     done` || { (exit 1); exit 1; }
21427   # Remove the trailing spaces.
21428   sed 's/[       ]*$//' $ac_file_inputs >$tmp/in
21429
21430 _ACEOF
21431
21432 # Transform confdefs.h into two sed scripts, `conftest.defines' and
21433 # `conftest.undefs', that substitutes the proper values into
21434 # config.h.in to produce config.h.  The first handles `#define'
21435 # templates, and the second `#undef' templates.
21436 # And first: Protect against being on the right side of a sed subst in
21437 # config.status.  Protect against being in an unquoted here document
21438 # in config.status.
21439 rm -f conftest.defines conftest.undefs
21440 # Using a here document instead of a string reduces the quoting nightmare.
21441 # Putting comments in sed scripts is not portable.
21442 #
21443 # `end' is used to avoid that the second main sed command (meant for
21444 # 0-ary CPP macros) applies to n-ary macro definitions.
21445 # See the Autoconf documentation for `clear'.
21446 cat >confdef2sed.sed <<\_ACEOF
21447 s/[\\&,]/\\&/g
21448 s,[\\$`],\\&,g
21449 t clear
21450 : clear
21451 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
21452 t end
21453 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
21454 : end
21455 _ACEOF
21456 # If some macros were called several times there might be several times
21457 # the same #defines, which is useless.  Nevertheless, we may not want to
21458 # sort them, since we want the *last* AC-DEFINE to be honored.
21459 uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines
21460 sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs
21461 rm -f confdef2sed.sed
21462
21463 # This sed command replaces #undef with comments.  This is necessary, for
21464 # example, in the case of _POSIX_SOURCE, which is predefined and required
21465 # on some systems where configure will not decide to define it.
21466 cat >>conftest.undefs <<\_ACEOF
21467 s,^[     ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
21468 _ACEOF
21469
21470 # Break up conftest.defines because some shells have a limit on the size
21471 # of here documents, and old seds have small limits too (100 cmds).
21472 echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
21473 echo '  if grep "^[      ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
21474 echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
21475 echo '  :' >>$CONFIG_STATUS
21476 rm -f conftest.tail
21477 while grep . conftest.defines >/dev/null
21478 do
21479   # Write a limited-size here document to $tmp/defines.sed.
21480   echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
21481   # Speed up: don't consider the non `#define' lines.
21482   echo '/^[      ]*#[    ]*define/!b' >>$CONFIG_STATUS
21483   # Work around the forget-to-reset-the-flag bug.
21484   echo 't clr' >>$CONFIG_STATUS
21485   echo ': clr' >>$CONFIG_STATUS
21486   sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS
21487   echo 'CEOF
21488   sed -f $tmp/defines.sed $tmp/in >$tmp/out
21489   rm -f $tmp/in
21490   mv $tmp/out $tmp/in
21491 ' >>$CONFIG_STATUS
21492   sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail
21493   rm -f conftest.defines
21494   mv conftest.tail conftest.defines
21495 done
21496 rm -f conftest.defines
21497 echo '  fi # grep' >>$CONFIG_STATUS
21498 echo >>$CONFIG_STATUS
21499
21500 # Break up conftest.undefs because some shells have a limit on the size
21501 # of here documents, and old seds have small limits too (100 cmds).
21502 echo '  # Handle all the #undef templates' >>$CONFIG_STATUS
21503 rm -f conftest.tail
21504 while grep . conftest.undefs >/dev/null
21505 do
21506   # Write a limited-size here document to $tmp/undefs.sed.
21507   echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
21508   # Speed up: don't consider the non `#undef'
21509   echo '/^[      ]*#[    ]*undef/!b' >>$CONFIG_STATUS
21510   # Work around the forget-to-reset-the-flag bug.
21511   echo 't clr' >>$CONFIG_STATUS
21512   echo ': clr' >>$CONFIG_STATUS
21513   sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS
21514   echo 'CEOF
21515   sed -f $tmp/undefs.sed $tmp/in >$tmp/out
21516   rm -f $tmp/in
21517   mv $tmp/out $tmp/in
21518 ' >>$CONFIG_STATUS
21519   sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail
21520   rm -f conftest.undefs
21521   mv conftest.tail conftest.undefs
21522 done
21523 rm -f conftest.undefs
21524
21525 cat >>$CONFIG_STATUS <<\_ACEOF
21526   # Let's still pretend it is `configure' which instantiates (i.e., don't
21527   # use $as_me), people would be surprised to read:
21528   #    /* config.h.  Generated by config.status.  */
21529   if test x"$ac_file" = x-; then
21530     echo "/* Generated by configure.  */" >$tmp/config.h
21531   else
21532     echo "/* $ac_file.  Generated by configure.  */" >$tmp/config.h
21533   fi
21534   cat $tmp/in >>$tmp/config.h
21535   rm -f $tmp/in
21536   if test x"$ac_file" != x-; then
21537     if diff $ac_file $tmp/config.h >/dev/null 2>&1; then
21538       { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
21539 echo "$as_me: $ac_file is unchanged" >&6;}
21540     else
21541       ac_dir=`(dirname "$ac_file") 2>/dev/null ||
21542 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
21543          X"$ac_file" : 'X\(//\)[^/]' \| \
21544          X"$ac_file" : 'X\(//\)$' \| \
21545          X"$ac_file" : 'X\(/\)' \| \
21546          .     : '\(.\)' 2>/dev/null ||
21547 echo X"$ac_file" |
21548     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
21549           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
21550           /^X\(\/\/\)$/{ s//\1/; q; }
21551           /^X\(\/\).*/{ s//\1/; q; }
21552           s/.*/./; q'`
21553       { if $as_mkdir_p; then
21554     mkdir -p "$ac_dir"
21555   else
21556     as_dir="$ac_dir"
21557     as_dirs=
21558     while test ! -d "$as_dir"; do
21559       as_dirs="$as_dir $as_dirs"
21560       as_dir=`(dirname "$as_dir") 2>/dev/null ||
21561 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
21562          X"$as_dir" : 'X\(//\)[^/]' \| \
21563          X"$as_dir" : 'X\(//\)$' \| \
21564          X"$as_dir" : 'X\(/\)' \| \
21565          .     : '\(.\)' 2>/dev/null ||
21566 echo X"$as_dir" |
21567     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
21568           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
21569           /^X\(\/\/\)$/{ s//\1/; q; }
21570           /^X\(\/\).*/{ s//\1/; q; }
21571           s/.*/./; q'`
21572     done
21573     test ! -n "$as_dirs" || mkdir $as_dirs
21574   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
21575 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
21576    { (exit 1); exit 1; }; }; }
21577
21578       rm -f $ac_file
21579       mv $tmp/config.h $ac_file
21580     fi
21581   else
21582     cat $tmp/config.h
21583     rm -f $tmp/config.h
21584   fi
21585 # Compute $ac_file's index in $config_headers.
21586 _am_stamp_count=1
21587 for _am_header in $config_headers :; do
21588   case $_am_header in
21589     $ac_file | $ac_file:* )
21590       break ;;
21591     * )
21592       _am_stamp_count=`expr $_am_stamp_count + 1` ;;
21593   esac
21594 done
21595 echo "timestamp for $ac_file" >`(dirname $ac_file) 2>/dev/null ||
21596 $as_expr X$ac_file : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
21597          X$ac_file : 'X\(//\)[^/]' \| \
21598          X$ac_file : 'X\(//\)$' \| \
21599          X$ac_file : 'X\(/\)' \| \
21600          .     : '\(.\)' 2>/dev/null ||
21601 echo X$ac_file |
21602     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
21603           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
21604           /^X\(\/\/\)$/{ s//\1/; q; }
21605           /^X\(\/\).*/{ s//\1/; q; }
21606           s/.*/./; q'`/stamp-h$_am_stamp_count
21607 done
21608 _ACEOF
21609 cat >>$CONFIG_STATUS <<\_ACEOF
21610
21611 #
21612 # CONFIG_COMMANDS section.
21613 #
21614 for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue
21615   ac_dest=`echo "$ac_file" | sed 's,:.*,,'`
21616   ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`
21617   ac_dir=`(dirname "$ac_dest") 2>/dev/null ||
21618 $as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
21619          X"$ac_dest" : 'X\(//\)[^/]' \| \
21620          X"$ac_dest" : 'X\(//\)$' \| \
21621          X"$ac_dest" : 'X\(/\)' \| \
21622          .     : '\(.\)' 2>/dev/null ||
21623 echo X"$ac_dest" |
21624     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
21625           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
21626           /^X\(\/\/\)$/{ s//\1/; q; }
21627           /^X\(\/\).*/{ s//\1/; q; }
21628           s/.*/./; q'`
21629   { if $as_mkdir_p; then
21630     mkdir -p "$ac_dir"
21631   else
21632     as_dir="$ac_dir"
21633     as_dirs=
21634     while test ! -d "$as_dir"; do
21635       as_dirs="$as_dir $as_dirs"
21636       as_dir=`(dirname "$as_dir") 2>/dev/null ||
21637 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
21638          X"$as_dir" : 'X\(//\)[^/]' \| \
21639          X"$as_dir" : 'X\(//\)$' \| \
21640          X"$as_dir" : 'X\(/\)' \| \
21641          .     : '\(.\)' 2>/dev/null ||
21642 echo X"$as_dir" |
21643     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
21644           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
21645           /^X\(\/\/\)$/{ s//\1/; q; }
21646           /^X\(\/\).*/{ s//\1/; q; }
21647           s/.*/./; q'`
21648     done
21649     test ! -n "$as_dirs" || mkdir $as_dirs
21650   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
21651 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
21652    { (exit 1); exit 1; }; }; }
21653
21654   ac_builddir=.
21655
21656 if test "$ac_dir" != .; then
21657   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
21658   # A "../" for each directory in $ac_dir_suffix.
21659   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
21660 else
21661   ac_dir_suffix= ac_top_builddir=
21662 fi
21663
21664 case $srcdir in
21665   .)  # No --srcdir option.  We are building in place.
21666     ac_srcdir=.
21667     if test -z "$ac_top_builddir"; then
21668        ac_top_srcdir=.
21669     else
21670        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
21671     fi ;;
21672   [\\/]* | ?:[\\/]* )  # Absolute path.
21673     ac_srcdir=$srcdir$ac_dir_suffix;
21674     ac_top_srcdir=$srcdir ;;
21675   *) # Relative path.
21676     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
21677     ac_top_srcdir=$ac_top_builddir$srcdir ;;
21678 esac
21679
21680 # Do not use `cd foo && pwd` to compute absolute paths, because
21681 # the directories may not exist.
21682 case `pwd` in
21683 .) ac_abs_builddir="$ac_dir";;
21684 *)
21685   case "$ac_dir" in
21686   .) ac_abs_builddir=`pwd`;;
21687   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
21688   *) ac_abs_builddir=`pwd`/"$ac_dir";;
21689   esac;;
21690 esac
21691 case $ac_abs_builddir in
21692 .) ac_abs_top_builddir=${ac_top_builddir}.;;
21693 *)
21694   case ${ac_top_builddir}. in
21695   .) ac_abs_top_builddir=$ac_abs_builddir;;
21696   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
21697   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
21698   esac;;
21699 esac
21700 case $ac_abs_builddir in
21701 .) ac_abs_srcdir=$ac_srcdir;;
21702 *)
21703   case $ac_srcdir in
21704   .) ac_abs_srcdir=$ac_abs_builddir;;
21705   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
21706   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
21707   esac;;
21708 esac
21709 case $ac_abs_builddir in
21710 .) ac_abs_top_srcdir=$ac_top_srcdir;;
21711 *)
21712   case $ac_top_srcdir in
21713   .) ac_abs_top_srcdir=$ac_abs_builddir;;
21714   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
21715   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
21716   esac;;
21717 esac
21718
21719
21720   { echo "$as_me:$LINENO: executing $ac_dest commands" >&5
21721 echo "$as_me: executing $ac_dest commands" >&6;}
21722   case $ac_dest in
21723     default-1 )
21724 # Only add multilib support code if we just rebuilt the top-level
21725 # Makefile.
21726 case " $CONFIG_FILES " in
21727  *" Makefile "*)
21728    ac_file=Makefile . ${multi_basedir}/config-ml.in
21729    ;;
21730 esac ;;
21731   esac
21732 done
21733 _ACEOF
21734
21735 cat >>$CONFIG_STATUS <<\_ACEOF
21736
21737 { (exit 0); exit 0; }
21738 _ACEOF
21739 chmod +x $CONFIG_STATUS
21740 ac_clean_files=$ac_clean_files_save
21741
21742
21743 # configure is writing to config.log, and then calls config.status.
21744 # config.status does its own redirection, appending to config.log.
21745 # Unfortunately, on DOS this fails, as config.log is still kept open
21746 # by configure, so config.status won't be able to write to it; its
21747 # output is simply discarded.  So we exec the FD to /dev/null,
21748 # effectively closing config.log, so it can be properly (re)opened and
21749 # appended to by config.status.  When coming back to configure, we
21750 # need to make the FD available again.
21751 if test "$no_create" != yes; then
21752   ac_cs_success=:
21753   ac_config_status_args=
21754   test "$silent" = yes &&
21755     ac_config_status_args="$ac_config_status_args --quiet"
21756   exec 5>/dev/null
21757   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
21758   exec 5>>config.log
21759   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
21760   # would make configure fail if this is the last instruction.
21761   $ac_cs_success || { (exit 1); exit 1; }
21762 fi
21763